Объявление Класса как член себя

это не обязательно рекурсивно по своей природе. подумайте о связном списке. или дерево.

class Directory
{
   string name;
   Directory parentDirectory;
}

Это просто позволяет объектам этого класса иметь внутреннюю ссылку на другой объект этого класса.

Это программный шаблон, известный как « Синглтон ».

Некоторые люди не одобряют использование шаблона по большему количеству причин, чем только что указано в вопросе, но, к лучшему или к худшему, это общий шаблон в .NET Framework. Вы найдете свойства Singleton (или поля) в классах, которые предназначены для однократного создания. Думайте о статическом свойстве Instance как о глобальном крючке, на который можно повесить объект.

Поскольку это класс, а не структура, когда вы объявляете поле, которое является классом, вы определяете только ссылку на класс. Это позволяет вам сохранять ссылки при условии, что вы их назначаете.

В вашем случае ваша ссылка выделяет новый класс, но он статичен, поэтому он будет делать это только один раз, независимо от того, сколько классов вы Создайте. Конструктор экземпляра запускается при первом использовании Factory и вызывает единственный нестатический конструктор. Выполнение instance.instance.instance запрещено, поскольку экземпляр является статическим. Вы не можете получить доступ к статической переменной из члена - вам нужно сделать Factory.instance.

Однако вы ~ можете ~ сделать экземпляр нестатическим и сделать так, чтобы он был ссылкой на какой-нибудь другой класс "Factory" или даже ссылкой на него. В этом случае вы можете связать instance.instance. instance - но он будет просто следовать за ссылками, пока вы их установили. Все работает, никаких проблем.

There will only ever be one instance of 'instance' because it is static. The only way you should be able to access it is by calling Factory.instance.

string text = Factory.instance.ToString(); // legal
string text2 = Factory.instance.instance.ToString(); // compiler error

Я думаю, вам стоит спросить наоборот: почему этого не может быть? Factory - это просто тип, подобный любому типу, который разрешается компилятором.

Поскольку в большинстве ответов здесь указано, что это работает только потому, что Factory является статическим полем, я добавил следующий пример. Обратите внимание, что это очень примитивный образец связанного списка (вы, вероятно, не стали бы реализовывать его таким образом по разным причинам, но я пока не придумал лучшего примера). В этом примере ChainedListItem - это контейнер для элемента односвязного списка, который содержит поле того же типа, указывающее на следующий элемент в списке. В списке есть (пустой) элемент заголовка, а последний элемент отмечен пустым полем _nextItem :

public class ChainedListItem<T>
{
    private ChainedListItem<T> _nextItem;
    T _content;

    public ChainedListItem<T> NextItem
    {
        get { return _nextItem; }
        set { _nextItem = value; }
    }

    public T Content
    {
        get { return _content; }
        set { _content = value; }
    }

    public ChainedListItem<T> Add(T content)
    {
        _nextItem = new ChainedListItem<T>();
        _nextItem.Content = content;
        return _nextItem;
    }

    public void Dump()
    {
        ChainedListItem<T> current = this;
        while ((current = current.NextItem) != null)
        {
            Console.WriteLine(current._content);
        }
    }
}

class Program
{
    static void Main(string[] args)
    {
        ChainedListItem<int> chainedList = new ChainedListItem<int>();
        chainedList.Add(1).Add(2).Add(3);
        chainedList.Dump();        
    }
}

«Кроличья нора» уходит настолько глубоко, насколько пространство стека позволяет вам сделать еще один вызов конструктора типа. Если вы попытаетесь пойти глубже, вы получите исключение stackoverflow, как и при любой другой рекурсии.

Кстати, код, который вы написали в своем ответе, показывает очень простую реализацию Singleton ], который фактически основан на наличии (частного) статического члена того же типа, что и окружающий тип.

И, наконец, что не менее важно, такие конструкции также прекрасно работают в C ++.

код, который вы написали в своем ответе, показывает очень простую реализацию синглтона , которая фактически основана на наличии (частного) статического члена того же типа, что и окружающий тип.

И, наконец, что не менее важно, такие конструкции также прекрасно работают в C ++.

код, который вы написали в своем ответе, показывает очень простую реализацию синглтона , которая фактически основана на наличии (частного) статического члена того же типа, что и окружающий тип.

И, наконец, что не менее важно, такие конструкции также прекрасно работают в C ++.

This is done all the time is most OO languages. instance is a static member of Factory. There is nothing unusual about this code. It is standard Factory pattern. Do you also have a problem with code like this?

x = x + 1;

Я не уверен, как вы вообще можете получить доступ к экземпляру, поскольку он является частным. Единственное, для чего это было бы полезно, - это реализация синглтона, но в этом случае вы должны использовать общедоступное свойство, открывающее экземпляр.

Это синглтон . Это означает, что на самом деле существует только один экземпляр класса.

Это весь класс? Обычно в C # вы увидите синглтон, например

public class SomeClass
{

  static readonly SomeClass instance = new SomeClass();


        public static SomeClass Instance
        {
            get { return instance; }
        } 


        static SomeClass() 
        {
        }

        SomeClass()
        {
        }
}