1:
2:
3:
4:
5:
6:
7:
8:

    sealed class SOFTconfig
    {
        private SOFTconfig() 
        {  /* ...hier optional Initialisierungscode... */ }
        public List<string> testlist = new List<string>();
        public static readonly SOFTconfig Instance = new SOFTconfig() ;

    }					

1:

SOFTConfig config = SOFTconfig.Instance ;					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:

public static class Singleton<T> where T : new()
{
    static Mutex mutex = new Mutex();
    static T instance;
    public static T Instance    {
        get        {
            mutex.WaitOne();
            if(instance == null)
                instance = new T();
            mutex.ReleaseMutex();
            return instance;
        }
    }
}					

1:
2:
3:
4:
5:
6:

type
  Singleton<T> = public static class
    where T has constructor;
  public
    property Instance : T := new T(); readonly;
  end;					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:

  LazySingleton<T> = public static class
    where T has constructor;
  public
    property Instance : T read GetInstanceCall();
  private
    GetInstanceCall : GetInstanceHandler;
    
    method InitialGetInstance: T; locked; // nur die Methode ist gesperrt
    constructor;
  end;
  
  GetInstanceHandler nested in LazySingleton<T>
    = private delegate : T;
    
implementation

constructor LazySingleton<T>; 
begin
  GetInstanceCall := @InitialGetInstance;
end;

method LazySingleton<T>.InitialGetInstance: T; 
begin
  if not assigned(GetInstanceCall.Target) then // InitialGetInstance ist statisch
  begin
    var newInstance := new T();
    
    GetInstanceCall := method : T;
    begin
      exit newInstance;
    end;
  end;

  exit GetInstanceCall()
end;					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:

type
  LazySingleton2<T> = public static class
    where T has constructor;
  public
    property Instance : T read
      LazySingleton2<T>.NestedHelper.Instance;
  end;
  
  NestedHelper nested in LazySingleton2<T>
    = private static class
  private
    class constructor; empty;
  public
    Instance : T := new T(); readonly;
  end;