Как создать интерфейс.NET со статическими участниками?

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

public abstract class Singleton<T> where T : Singleton<T>
{
  private static T _instance;

  public static T Instance
  {
    get { return _instance; }
    protected set { _instance = value; }
  }
}

Любой класс, который происходит из Singleton, будет иметь статическое свойство Instance корректного типа:

public class MySingleton : Singleton<MySingleton>
{
    static MySingleton()
    {
        Instance = new MySingleton();
    }

    private MySingleton() { } 
}

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

Хорошо я сделал этот ответ Wiki, потому что я просто собираюсь предложить мнение, которое является в касательной к Вашему вопросу.

Я лично думаю, что Одиночные элементы являются злоупотребившим waaay, это - вариант использования, что IMO на самом деле довольно редок, в большинстве случаев статический класс удовлетворил бы варианту использования намного лучше, и в других случаях просто созданный приписываемый объект фабрики является лучшим выбором, фактический одиночный элемент намного более редок, чем люди думают.

У меня не было бы интерфейса для описания общего шаблона для этого, поскольку я на самом деле захочу, чтобы каждое использование одиночного элемента думалось об очень тщательно и выравнивалось по ширине.

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

Запишите модульный тест вместо этого.

Я знаю, что это не Ваш вопрос, но сколько одиночных элементов Вы имеете таким образом, что Вы требуете интерфейса? Это пахнет как плохой дизайн мне - можно ли объяснить ясно, почему эти классы должны быть одиночными элементами, а не экземплярами? Если бы Ваш ответ является памятью, я предложил бы Ваше сверхразмышление Вашего приложения, и если Вы действительно заинтересованы, изучаете шаблон в наилегчайшем весе (или возможно простой шаблон "фабрика"). Извините за не ответ на вопрос непосредственно, но это не походит на прекрасную идею.

Помимо этого это не работает, как Вы заявляете, как Вы использовали бы этот интерфейс и класс с реализацией?

Вы могли бы попробовать интерфейсом стиля Фабрики

interface ISingletonFactory<T>
{
    public T Instance {get;}
}

public class SingletonFactory: ISingletonFactory<Singleton>
{
    public Singleton Instance {get { return Singleton.Instance;}}
}

public class Singleton
{
    private Singleton foo;
    public static Singleton Instance { get { return foo; } }
}

Учитывая классическое понятие ООП Интерфейса, который определяет его как Контракт между классами с реализацией, Вы не можете добавить такую вещь как статический метод для него. Если бы Вы могли бы сделать, Вы закончили бы в чем-то более подобном абстрактному классу, в котором у Вас есть частичная реализация Вашего класса и других частей, потребованных на расширяющиеся классы.

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

Метод, который я реализовал в прошлом, создает интерфейс и абстрактный базовый класс, который реализует интерфейс. Это выглядит примерно так:

public interface IMyCompanySetting
{
    XmlNode Serialize();
    IMyCompanySetting Deserialize(XmlNode pattern);
    string SettingName { get; }

строковый ключ {добирается;} возражают, что SettingValue {добираются; набор;} Объем SettingScope {добираются; набор; }}

public abstract class MyCompanySettingBase : IMyCompanySetting
{
    public MyCompanySettingBase() {}
    public MyCompanySettingBase(XmlNode pattern)
    {
        Deserialize(pattern);
    }
    #region IMyCompanySetting Members

    public abstract XmlNode Serialize();
    public abstract IMyCompanySetting Deserialize(XmlNode pattern);
    public abstract string SettingName{ get; }
public abstract string Key { get; }
    public abstract SettingScope Scope{ get; set; }
    public abstract object SettingValue{ get; set; }

    #endregion

public static XmlNode WrapInSettingEnvelope(XmlNode innerNode, IMyCompanySetting theSetting)
{
    // Write the top of the envelope.
    XmlTextWriter xtw = null;
    MemoryStream theStream = OpenSettingEnvelope(theSetting, ref xtw);

    // Insert the message.
    xtw.WriteNode(new XmlTextReader(innerNode.OuterXml, XmlNodeType.Element, null), true);

    // Close the envelope.
    XmlNode retNode = CloseSettingEnvelope(xtw, theStream);
    return retNode;

}

public static MemoryStream OpenSettingEnvelope(IMyCompanySetting theSetting, ref XmlTextWriter theWriter)
{
    MemoryStream theStream = new MemoryStream();
    theWriter = new XmlTextWriter(theStream, Encoding.ASCII);
    System.Type messageType = theSetting.GetType();

    string[] fullAssembly = messageType.Assembly.ToString().Split(',');
    string assemblyName = fullAssembly[0].Trim();

    theWriter.WriteStartElement(theSetting.SettingName);
    theWriter.WriteAttributeString("type", messageType.ToString());
    theWriter.WriteAttributeString("assembly", assemblyName);
    theWriter.WriteAttributeString("scope", ConfigurationManager.ScopeName(theSetting.Scope));

    return theStream;
}

public static XmlNode CloseSettingEnvelope(XmlTextWriter xtw, MemoryStream theStream)
{
    XmlDocument retDoc = new XmlDocument();
    try
    {
        // Close the envelope.
        xtw.WriteEndElement();
        xtw.Flush();

        // Return the node.
        string xmlString = Encoding.ASCII.GetString(theStream.ToArray());
        retDoc.LoadXml(xmlString);
    }
    catch (XmlException)
    {
        string xmlString = Encoding.ASCII.GetString(theStream.ToArray());
        Trace.WriteLine(xmlString);
        retDoc.LoadXml(@"<error/>");
    }
    catch (Exception)
    {
        retDoc.LoadXml(@"<error/>");
    }
    return retDoc.DocumentElement;
}

}