Eine Sicherung mit einem Boolean

Question

Ich habe eine Menge von Code-Stücken, die einmal während der Initialisierung ausgeführt werden müssen.

ich auf diese Weise einen boolean-Flag zu verwenden, weil es in einem Fall ist

bool _fuse; 

void PerformLayout() 
{ 
    Size size; 

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

    // ... 
} 

Weil es oft geschieht, habe ich etwas dieses Boolesche Variable zu machen, um wie eine Sicherung:

Also tat ich dies:

bool _fuse; 

void PerformLayout() 
{ 
    Size size; 

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

    // ... 
} 

Wenn es auf false initialisiert wird, sobald das Ergebnis der Abfrage false zurückgibt, machen den switc h zu wahr, und aufeinander folgende Aufrufe kehren wahr zurück.

Natürlich funktioniert es, aber ich bin nur mäßig zufrieden und ich bin mir sicher, dass es elegantere Lösungen gibt. Was wäre dein?

Answer 1

Ich denke, die allgemeine Stoßrichtung Wiederholung ist hier richtig (auch wenn die Wiederholung sehr klein zu vermeiden ist ... aber immer noch). kapseln Sie es einfach und nennen Sie es richtig:

struct InitializerGuard { 
    private bool hasRun; 

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

Verbrauch:

InitializerGuard sizeInitializer; 

void PerformLayout() 
{ 
    Size size; 

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

    // ... 
} 

Aber wenn Sie sich mit diesem Muster sehr oft feststellen, könnte dies anzeigen, dass ein Refactoring in Ordnung ist. Vielleicht einigen Variablen nur Standardwerte zuweisen? Warum werden sie überhaupt nicht initialisiert?

Answer 2

können Sie Nullable-Typen verwenden und die Null-Koaleszenz-Operator eine Size Eigenschaft zu deklarieren:

Size? _containerSize; 

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

Sie können es dann wie folgt verwenden:

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

Wenn der Typ Sie zu faul initialisieren Ist ein Referenztyp, wird es noch einfacher.

Eine weitere Option ist die Verwendung des Typs Lazy<T>. Dies kann in Multi-Threading-Szenarien verwendet werden, in denen der obige Code brechen kann:

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

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

Answer 3

Es gibt viele Möglichkeiten, dies zu erreichen. Sie können eine komplexe Zustandsmaschine erstellen, die Ihre Logik ausführt (am schnellsten), aber in vielen Fällen wird das Overkill sein. Alternativ können Sie einen Booleschen Überblick behalten, der den Zustand Ihrer Instanz genau so enthält, wie Sie ihn jetzt haben. Sie können auch beiden Lösungen in eine einfache Zustandsmaschine mit Methoden wie (moderatly schnell) zu kombinieren entscheiden:

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