Gewusst wie: Verzögerte Initialisierung von Objekten

Die System.Lazy<T>-Klasse vereinfacht die verzögerte Initialisierung und Instanziierung von Objekten. Wenn Sie Objekte verzögert initialisieren, müssen Sie die Objekte ggf. gar nicht erstellen, falls sie nie benötigt werden, oder Sie können ihre Initialisierung bis zum ersten Zugriff verschieben. Weitere Informationen finden Sie unter Verzögerte Initialisierung.

Beispiel

Im folgenden Beispiel wird das Initialisieren eines Werts mit Lazy<T> gezeigt. In diesem Beispiel wird angenommen, dass die verzögerte Variable abhängig von anderem Code, durch den die someCondition-Variable auf true oder false festgelegt wird, möglicherweise nicht benötigt wird.

    Dim someCondition As Boolean = False

    Sub Main()
        'Initializing a value with a big computation, computed in parallel
        Dim _data As Lazy(Of Integer) = New Lazy(Of Integer)(Function()
                                                                 Dim result =
                                                                     ParallelEnumerable.Range(0, 1000).
                                                                     Aggregate(Function(x, y)
                                                                                   Return x + y
                                                                               End Function)
                                                                 Return result
                                                             End Function)

        '  do work that may or may not set someCondition to True
        ' ...
        '  Initialize the data only if needed
        If someCondition = True Then

            If (_data.Value > 100) Then

                Console.WriteLine("Good data")
            End If
        End If
    End Sub

  static bool someCondition = false;  
  //Initializing a value with a big computation, computed in parallel
  Lazy<int> _data = new Lazy<int>(delegate
  {
      return ParallelEnumerable.Range(0, 1000).
          Select(i => Compute(i)).Aggregate((x,y) => x + y);
  }, LazyExecutionMode.EnsureSingleThreadSafeExecution);

  // Do some work that may or may not set someCondition to true.
  //  ...
  // Initialize the data only if necessary
  if (someCondition)
{
    if (_data.Value > 100)
      {
          Console.WriteLine("Good data");
      }
}

Im folgenden Beispiel wird die Verwendung der System.Threading.ThreadLocal<T>-Klasse zum Initialisieren eines Typs gezeigt, der nur für die aktuelle Objektinstanz im aktuellen Thread sichtbar ist.

    'Initializing a value per thread, per instance
    Dim _scratchArrays =
        New ThreadLocal(Of Integer()())(Function() InitializeArrays())

    ' use the thread-local data
    Dim tempArr As Integer() = _scratchArrays.Value(i)
    ' ...
End Sub

Function InitializeArrays() As Integer()()
    Dim result(10)() As Integer
    ' Initialize the arrays on the current thread.
    ' ... 

    Return result
End Function

//Initializing a value per thread, per instance
 ThreadLocal<int[][]> _scratchArrays = 
     new ThreadLocal<int[][]>(InitializeArrays);
// . . .
 static int[][] InitializeArrays () {return new int[][]}
//   . . .
// use the thread-local data
int i = 8;
int [] tempArr = _scratchArrays.Value[i];

Siehe auch

Referenz

System.Threading.LazyInitializer

Konzepte

Verzögerte Initialisierung