C＃：访问静态类实例的初始化成员将返回NULL

Question

I am developing an Item system for Unity and I am trying to reason about XML file manipulation. I have an ItemDatabase class as shown below:

[XmlRoot("ItemDatabase")]
public class ItemDatabase
{
    // List that contains all Game Items.
    // Members must be Serializable. Use Editor workflow
    // to create an item Adder/Remover for the Database.
    [XmlArray("Items"), XmlArrayItem("BaseGameItem")]
    public List<BaseGameItem> Items = new List<BaseGameItem>();

    // Singleton Pattern. Only one instance will be initialized.
    public static ItemDatabase itemDb;

    public ItemDatabase()
    {
        if(itemDb == null)
        itemDb = this;
    }

    // Saves the Item List to an XML file.
    public void Save(string filepath)
    {
        XmlSerializer serializer = new XmlSerializer(typeof(ItemDatabase));

        // Disposable Pattern
        using (FileStream stream = new FileStream(filepath, FileMode.Create))
        {
            // Check if path was valid.
            if (stream != null)
            {
                serializer.Serialize(stream, this);
                stream.Close();
            }
        }
    }

    // Loads an existing Item List from an XML file.
    public static ItemDatabase Load(string filepath)
    {
        XmlSerializer serializer = new XmlSerializer(typeof(ItemDatabase));

        using (FileStream stream = new FileStream(filepath, FileMode.Open))
        {
            if (stream != null)
            {
                ItemDatabase db = serializer.Deserialize(stream) as ItemDatabase;
                stream.Close();
                return db;
            }

            // Return null if the file cannot be read/found.
            else
            {
                return null;
            }
        }

    }

}

Recently, I got exposed to a very basic implementation of the Singleton pattern, which makes sense for me to use for something like a database. The instance of the class is static, whereas the List is initialized above.

However, I then try to access this class using a GUI I called the DatabaseManager class. The relevant implementation is shown below:

public class ItemDatabaseManager : EditorWindow
{
    // List of items from database.
    List<BaseGameItem> items;

    // Item template to add/remove from database.
    // To be filled by user.
    BaseGameItem itemToAdd;

    private void OnEnable()
    {
        items = ItemDatabase.itemDb.Items;
    }

My thought process led me to believe that:

1. There shall be one instance of ItemDatabase, which in turn implies there will only be one list to manage.
2. Since the List is initialized, I would be able to directly access it from external classes such as the manager.

However, whenever the editor window shows up, I get a Null Reference Exception, indicating that the List of items is null. I have confirmed it is not the ItemDatabase instance. How is it even possible for the List to be empty when it was immediately initialized as part of the class definition? What am I fundamentally overlooking in this scenario? Maybe there is an underlying order of constructors that I am misinterpreting?

Assuming I understand things properly, setting the list to public static fixes that - but it defeats the purpose of keeping the list directly inaccessible?

Answer 1

Actually you are not implementing the singleton pattern correctly because you create the instance in the constructor. Have a look at this MSDN article .

Example:

public class ItemDatabase
{
   private static ItemDatabase _instance;

   private ItemDatabase() {}

   public static ItemDatabase Instance
   {
      get 
      {
         if (instance == null)
         {
            instance = new ItemDatabase();
         }
         return instance;
      }
   }

   // ... add the rest of your code
}

You can now simply access the singleton with:

ItemDatabase.Instance

and the instance will be dynamically created on demand at the first access.

EDIT: as per @maccettura comment the code above is not thread safe. If you need thread-safety you can use a lock object ( see this article for more info ):

public class ItemDatabase
{
   private static ItemDatabase _instance;
   private static readonly object _lock = new object();

   private ItemDatabase() {}

   public static ItemDatabase Instance
   {
      get 
      {
         lock (_object)
         {
             if (instance == null)
             {
                instance = new ItemDatabase();
             }
             return instance;
         }
      }
   }

   // ... add the rest of your code
}