Hacer un fusible con un booleano

Question

Tengo un montón de códigos que deben ejecutarse una vez durante la inicialización.

tengo que usar una bandera booleana de esta manera porque está en un evento

bool _fuse; 

void PerformLayout() 
{ 
    Size size; 

    if (!_fuse) 
    { 
     size = _InitialContainerSize; 
     _fuse = true; 
    } 
    else 
     size = parent.Size; 

    // ... 
} 

porque sucede a menudo, me hizo algo para que esta variable booleana para que parezca un fusible:

Así que hice esto:

bool _fuse; 

void PerformLayout() 
{ 
    Size size; 

    if (!Burnt(ref _fuse)) 
     size = _InitialContainerSize; 
    else 
     size = parent.Size; 

    // ... 
} 

Si se inicializa en false, el resultado de la consulta devuelve falsa una vez, hacer que el switc h verdadero, y las llamadas sucesivas devuelven verdadero.

public static bool Burnt(ref bool value) 
{ 
    if (!value) 
    { 
     value = true; 
     return false; 
    } 
    else 
     return true; 
} 

Por supuesto, funciona, pero solo estoy moderadamente satisfecho y estoy seguro de que hay soluciones más elegantes. ¿Cuál sería el tuyo?

Answer 1

Creo que la tendencia general a evitar la repetición aquí es correcto (incluso si la repetición es muy pequeña ... pero todavía) Sólo encapsular y nombrar correctamente:

struct InitializerGuard { 
    private bool hasRun; 

    public bool HasRun() { 
     if (hasRun) 
      return true; 
     hasRun = true; 
     return false; 
    } 
} 

Uso:

InitializerGuard sizeInitializer; 

void PerformLayout() 
{ 
    Size size; 

    if (!sizeInitializer.HasRun()) 
     size = _InitialContainerSize; 
    else 
     size = parent.Size; 

    // ... 
} 

Pero si usted se encuentra el uso de este patrón muy a menudo esto podría indicar que una refactorización está en orden. Tal vez simplemente asignar valores predeterminados a algunas variables? ¿Por qué no se inicializan, de todos modos?

Answer 2

Puede utilizar los tipos anulables y el operador coalescente nula para declarar una Size propiedad:

Size? _containerSize; 

Size ContainerSize { 
    get { 
    return (_containerSize ?? (_containerSize = _InitialContainerSize)).Value; 
    } 
} 

entonces usted puede utilizar de esta manera:

void PerformLayout() { 
    var size = ContainerSize; 
    // ... 
} 

Si el tipo que desea inicializar perezoso es un tipo de referencia, se vuelve aún más simple.

Otra opción es utilizar el tipo Lazy<T>. Esto se puede usar en escenarios de varios subprocesos donde el código anterior se puede romper:

Lazy<Size> _containerSize = new Lazy<Size>(() => _InitialContainerSize); 

void PerformLayout() { 
    var size = _containerSize.Value; 
    // ... 
} 

Answer 3

Hay muchas maneras de lograr esto. Puede crear una máquina de estado compleja que realice su lógica (la más rápida) pero, en muchos casos, eso será excesivo. Alternativamente, puede hacer un seguimiento de un booleano que contiene el estado de su instancia tal como lo hace ahora. También puede optar por combinar ambas soluciones a una máquina de estado simple, con métodos como (moderatly rápida):

public class TestClass 
{ 
    private Action performLayoutAction; 

    public TestClass() 
    { 
     // initial state 
     performLayoutAction = InitializePeformLayout; 
    } 

    public void PerformLayout() 
    { 
     performLayoutAction(); 
    } 

    private void InitializePeformLayout() 
    { 
     // whatever 

     performLayoutAction = ContiniousPerformLayout; 
    } 

    private void ContiniousPerformLayout() 
    { 
     // whatever 
    } 
}