Array der Singleton-Klasse

Question

Wie die Titel sagt, muss ich ein Array von Singleton-Klasse implementieren. Meine Projektidee baut eine einfache PLC-Ladder-IDE, die in Microsoft Visual C# geschrieben wurde.
Da ich kein Experte Code-Writer bin, schrieb ich einen großen Teil meines Codes in einer einzigen Datei. Es funktionierte einwandfrei, aber es war nicht einfach zu lesen und zu aktualisieren. Also habe ich es in fünf verschiedene Klassen aufgeteilt.

MainClass.cs - Main program 
CustomMethods.cs - All my methods 
CustomEventHandlers.cs - All my event handlers 
Components.cs - This class holds information (name, type, input, output, etc) and I need a 2-D array of this, because I'm using it as a "screen buffer" for the project. 
SharedVariables.cs - All my variables are declared here. My components class is initialized as a 2-D array in here too. 

Das Problem ist, dass ich nicht schaffen kann und eine Instanz von „Komponenten“ Array zwischen meinen Klassen teilen. Ich habe das "Singleton-Muster" gefunden, kann es aber immer noch nicht richtig implementieren. Ich kann mein Array der Singleton-Klasse nicht initialisieren. Hier ist der Code (irrelevante Teile werden ausgeschnitten).

//Custom method.cs 
namespace AVR_PLC 
{ 
    class CustomMethods 
    { 
     CustomEventHandlers extHandlers; 
     SharedVariables Variables; 

     public void setup() 
     { 
      extHandlers = new CustomEventHandlers(); 
      Variables = new SharedVariables(); 

       for (int i = 0; i < Variables.maxX; i++) 
        for (int j = 0; j < Variables.maxY; j++) 
         Variables.pBuffer[i, j] = new Components; 
     } 
--------------------------------------------- 
//SharedVariables.cs 
namespace AVR_PLC 
{ 
    class SharedVariables 
    { 
     public int maxX = 10; 
     public int maxY = 100; 
     public Components[,] pBuffer = Components[10, 100]; //Panel buffer 

    } 
} 
--------------------------------------------- 
//Components.cs 
namespace AVR_PLC 
{ 
    public class Components 
    { 
     //***** Singleton pattern implementation *********** 
     //Private static object. 
     private static volatile Components instance; 
     private static readonly object mutex = new Object(); 

     //Private constructor to prevent object creation. 
     private Components() 
     { 

     } 

     //Public property to access outside of the class to create an object. 
     public static Components Instance 
     { 
      get 
      { 
       if (instance == null) 
        lock (mutex) 
         if (instance == null) 
          instance = new Components(); 
       return instance; 
      } 
     } 
     //************************************************ 
     private string _name = "Default name"; 

     public string Name 
     { 
      get { return this._name; } 
      set { this._name = value; } 
     } 
     public void reset() 
     { 
      _name = "Default name"; 
     } 
    } 
} 

Answer 1

Ein Singleton ist eine Klasse, die es nur eine Instanz ist (Persönlich, wenn C# ziehe ich statische Klassen statt Singletons).

Um auf die Singleton-Klasse zuzugreifen, verwenden Sie die Eigenschaft Components.Instance. Aber in deinem Fall willst du eigentlich kein Singleton.
Wenn Sie ein Array von Component-Objekten haben möchten, möchten Sie lieber ein neues für jedes neue Objekt im Array erstellen, sonst ist das Array irgendwie nutzlos (wenn es genau dasselbe Objekt enthält).

Um eine Variable zwischen mehreren Instanzen der gleichen Klasse zu teilen, verwenden Sie das Schlüsselwort static, was es im Grunde über alle Klassen zum selben Objekt macht (wenn Sie es in einem ändern, ändert es sich).
So könnten Sie einfach Ihre freigegebenen Variablen Klasse eine statische Klasse machen:

public static class SharedVariables 
{ 
    public static int maxX = 10; 
    public static int maxY = 100; 
    public static Components[,] pBuffer = Components[10, 100]; 
} 

Und werden sie erreichbar sein, wohin Sie die SharedVariables Klasse zugreifen.

Die große Frage ist aber: Brauchen Sie wirklich eine statische SharedVariables Klasse? Ich vermute, du hast ein Designproblem, über das du nachdenken solltest.