Как я могу гарантировать, что класс имеет статическое свойство, используя интерфейс или абстракцию?

Вы не можете этого сделать. Интерфейсы, абстрактные и т. Д. Не могут применяться к статическим членам. Если вы хотите сделать это, вам нужно будет вручную не забыть сделать это для всех производных классов.

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

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

Я бы просто поместил свойство в интерфейс и перенаправил его статическому члену.

public interface IMyInterface
{
    void Foo();
    IList<string> Properties { get; }
}

public class ConcreteClass : IMyInterface
{
    public void Foo(){}
    public IList<string> Properties
    {
        get { return s_properties; }
    }
}

Но это подводит меня ко второму вопросу - чего вы пытаетесь достичь? Зачем вам нужен статический член в классе? Что вам действительно нужно, так это дать объекту возможность определить, какими свойствами он обладает, верно? Так зачем вашему коду заботиться о том, хранятся ли они статически или для каждого экземпляра?

Похоже, вы путаете контракт (то, что вы хотите делать) с реализацией (как поставщик службы достигает цели).

Ok. Может быть, я был недостаточно ясен. Но я добился в основном того, что мне нужно, сделав что-то вроде этого:

public abstract myBaseClass
{
 public List<string> MyParameterNames
   {
     get 
         {
             throw 
               new ApplicationException("MyParameterNames in base class 
                                 is not hidden by its child.");
         }
   }
}

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

Не лучший способ, но он помогает мне в некотором роде преодолеть мою проблему.

Это невозможно. Наследование нельзя применить к членам типа (статическим членам).

Здесь собраны все части решения, разбросанные по нескольким ответам.

1. Создайте интерфейс, как обычно.
2. Создайте абстрактный базовый класс, который реализует интерфейс и определяет любые статические члены, которые потребуются.
3. При создании фактических реализаций наследуйте от абстрактного базового класса, а не от интерфейса.

Хотя он по-прежнему не позволит вам получить доступ к Subclass.MyParameterNames из AbstractClass.MyParameterNames, вы сможете гарантировать, что это свойство доступно для всех реализаций AbastractClass.

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

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

Вы можете в конструкторе для MyBase вызвать GetType() и использовать отражение, чтобы убедиться, что производный класс имеет правильное свойство. Очевидно, это будет происходить только во время выполнения, но я не совсем уверен, в чем будет смысл этого ограничения: в чем вред, если статического свойства нет?

Почему бы не сделать MyParameterNames виртуальным и переопределить их в производных классах, чтобы генерировать исключение

public abstract class BaseClass
{
    public virtual List<string> MyParameterNames
    {
        get;
    }
}

public class DerivedClass : BaseClass
{
    public override List<string> MyParameterNames
    {
        get
        {
            throw new Exception();
        }
    }
}

Хотя в интерфейсе невозможно иметь значение static, можно иметь статическое значение в абстрактном классе. Однако этот экземпляр хранится на уровне абстрактного класса; поэтому будет общим для всех производных классов. В зависимости от ваших потребностей вы можете использовать это в своих интересах; то есть иметь словарь в вашем базовом классе, ключом для которого является тип (тип является типом производного класса), а затем хранить свои списки под этим.

//example of the base class
public abstract class MyAbstractBaseClass
{
    private static readonly IDictionary<Type,IList<MyAbstractBaseClass>> values = new Dictionary<Type,IList<MyAbstractBaseClass>>();
    public List<string> MyParameterNames 
    {
        get
        {
            return values[this.GetType()].Select(x => x.Name).ToList();
        }
    }
    public string Name {get; private set;}
    protected MyAbstractBaseClass(string name)
    {
        //assign the new item's name to the variable
        Name = name;
        //keep a list of all derivations of this class
        var key = this.GetType();
        if (!values.ContainsKey(key))
        {
            values.Add(key, new List<MyAbstractBaseClass>());
        }
        values[key].Add(this);
    }
}

//examples of dervived class implementations
public class MyDerivedClassOne: MyAbstractBaseClass
{
    private MyDerivedClassOne(string name): base(name){}
    public static readonly MyDerivedClassOne Example1 = new MyDerivedClassOne("First Example");
    public static readonly MyDerivedClassOne Example2 = new MyDerivedClassOne("Second Example");
}
public class MyDerivedClassTwo: MyAbstractBaseClass
{
    private MyDerivedClassTwo(string name): base(name){}
    public static readonly MyDerivedClassTwo Example1 = new MyDerivedClassTwo("1st Example");
    public static readonly MyDerivedClassTwo Example2 = new MyDerivedClassTwo("2nd Example");
}

//working example
void Main()
{
    foreach (var s in MyDerivedClassOne.Example1.MyParameterNames)
    {
        Console.WriteLine($"MyDerivedClassOne.Example1.MyParameterNames: {s}.");
    }
    foreach (var s in MyDerivedClassTwo.Example1.MyParameterNames)
    {
        Console.WriteLine($"MyDerivedClassTwo.Example1.MyParameterNames: {s}.");
    }
}

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