C#, copia un bool a otro (por ref, no val)

Question

Estoy en una pared de ladrillos aquí. ¿Es posible copiar un bool al ref de otro? Considera este código. . .

bool a = false; 
bool b = a; 

b ahora es un bool totalmente separado con un valor de falso. Si posteriormente cambio a, no tendrá efecto en b. ¿Es posible hacer a = b por ref? ¿Como podría hacerlo?

Muchas gracias

Answer 1

Un bool es un tipo de valor y no pueden ser copiados por referencia.

Answer 2

No. Dado que bool es un tipo de valor, siempre se copiará por valor.

La mejor opción es envolver su bool dentro de una clase - esto le dará tipo de referencia semántica:

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

esto puede no ser lo que quiera, pero si su situación fuera tal que querías una función que llamó para modificar su booleano local, puede usar el ref o out keyworkd.

bool a = false; 

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

... 

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

Answer 4

Gracias a @Reed por su respuesta (+1)! ¡Me animó a una solución más "genérica" ​​! :)

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

Answer 5

sólo tiene que utilizar las banderas como Nullable<bool> o bool? y establecer las de la estructura que se pasa al método genérico. La clase anterior ValueWrapper<T> es esencialmente exactamente lo que Nullable<T> hace.

Answer 6

Supongo que necesita pasar una referencia a bool, que no puede envolver con una clase 'BoolWrapper', porque el bool vive en un lugar que no puede o no desea modificar.

¡Se puede hacer!

Primera declarar lo que cualquier referencia bool se verá como

/// <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); 

Ahora usted puede hacer una referencia a myBool como esto

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

Y utilizar de esta manera:

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

El mismo truco funciona para otros tipos de valores, como int

Answer 7

Tuve un caso en el que quería que una clase cambiara el bool de otra clase: tenga en cuenta que hay mejores formas de manejar esta situación, pero esta es una prueba de concepto con Actions.

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

pequeña extensión a Andrey's respuesta ... esto le permite asignar a cualquier tipo que desea en el extremo directamente.Por lo tanto:

 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; 
    } 

}