C#, Skopiuj jeden bool na inny (przez ref, not val)

Question

Jestem tutaj na ceglanym murze. Czy możliwe jest skopiowanie jednego boola do refowania drugiego. Rozważ ten kod. . .

bool a = false; 
bool b = a; 

b jest teraz całkowicie oddzielnym boolem o wartości false. Jeśli później zmienię a, nie będzie to miało wpływu na b. Czy możliwe jest wykonanie a = b przez ref? Jak to zrobić?

Wielkie dzięki

Answer 1

Bool jest typem wartości i nie można go skopiować przez odniesienie.

Answer 2

Nie. Ponieważ bool jest typem wartości, zawsze będzie kopiowany według wartości.

Najlepszym rozwiązaniem jest, aby owinąć bool w klasie - to nada jej typ referencyjny semantyki:

public class BoolWrapper 
{ 
    public bool Value { get; set; } 
    public BoolWrapper (bool value) { this.Value = value; } 
} 

BoolWrapper a = new BoolWrapper(false); 
BoolWrapper b = a; 
b.Value = true; 
// a.Value == true 

Answer 3

może nie być to, co chcesz, ale jeśli scenariusz były takie, że chciałeś funkcję który wywołałeś, aby zmodyfikować swój lokalny boolean, możesz użyć ref lub out keyworkd.

bool a = false; 

F(ref a); 
// a now equals true 

... 

void F(ref bool x) 
{ 
x = true; 
} 

Answer 4

Dzięki @Reed za odpowiedź (+1)! Zachęcił mnie do bardziej ogólnego rozwiązania "generic"! :)

public class ValueWrapper<T> where T : struct 
{ 
    public T Value { get; set; } 
    public ValueWrapper(T value) { this.Value = value; } 
} 

Answer 5

Wystarczy użyć flagi jako Nullable<bool> lub bool? i ustawić te w struktury, która jest przekazywana do metody rodzajowej. Powyższa klasa ValueWrapper<T> jest dokładnie tym, co robi Nullable<T>.

Answer 6

Zgaduję, że musisz podać referencję, bool nie można owinąć klasą "BoolWrapper", ponieważ bool ma miejsce, którego nie możesz lub nie chcesz modyfikować.

Można to zrobić!

Najpierw zadeklarować co każde odniesienie bool będzie wyglądać

/// <summary> A reference to a bool.</summary> 
/// <param name="value">new value</param> 
/// <returns>Value of boolean</returns> 
public delegate bool BoolRef(bool? value = null); 

Teraz można zrobić odniesienie do myBool jak ten

bool myBool; // A given bool that you cannot wrap or change 
    private bool myBoolRef(bool? value) { 
     if (value != null) { 
      myBool = (bool)value; 
     } 
     return myBool; 
    } 

i używać go tak:

void myTestCaller() { 
     foo(myBoolRef); 
    } 
    void foo(BoolRef b) { 
     bool c = b(); // get myBool 
     b(true); // set myBool to true 
    } 

Ta sama sztuczka działa dla innych typów wartości, takich jak int

Answer 7

Miałem przypadek, w którym chciałem, aby jedna klasa zmieniła inną klasę bool - proszę zauważyć, że istnieją lepsze sposoby radzenia sobie z tą sytuacją, ale jest to dowód na to, że za pomocą akcji.

public class Class1 
{ 
    bool myBool { get; set; } 
    void changeBoolFunc(bool val) { myBool = val; } 
    public Class1() 
    { 
     Action<bool> changeBoolAction = changeBoolFunc; 
     myBool = true; 
     Console.WriteLine(myBool); // outputs "True" 
     Class2 c2 = new Class2(changeBoolAction); 
     Console.WriteLine(myBool); // outputs "False" 
    } 
} 
public class Class2 
{ 
    public Class2(Action<bool> boolChanger) { boolChanger(false); } 
} 
void Main() 
{ 
    Class1 c1 = new Class1(); 
} 

Answer 8

Małe rozszerzenie Andrey's odpowiedź ... to pozwala na przypisanie go do dowolnego typu chcesz w końcu bezpośrednio.Więc:

 ValueWrapper<bool> wrappedBool = new ValueWrapper<bool>(true); 

     bool unwrapped = wrappedBool; // you can assign it direclty: 

     if (wrappedBool) { // or use it how you'd use a bool directly 
      // ... 
     } 

public class ValueWrapper<T> 
{ 

    public T Value { get; set; } 

    public ValueWrapper() { } 

    public ValueWrapper(T value) { 
     this.Value = value; 
    } 

    public static implicit operator T(ValueWrapper<T> wrapper) 
    { 
     if (wrapper == null) { 
      return default(T); 
     } 
     return wrapper.Value; 
    } 

}