Propriedade abstrata na classe base para forçar o programador a defini-lo

Estou codificando com um padrão de estado para um dispositivo incorporado. Eu tenho uma classe base / abstrata chamada State e, em seguida, cada classe de estado discreta (concreta) implementa a classe abstrata de estado.

Na classe estadual, tenho vários métodos abstratos. Se eu não implementar os métodos abstratos na classe discreta (concreta), o Visual Studio emitirá um erro semelhante a este:

... Erro 1 'myConcreteState' não implementa o membro abstrato herdado 'myAbstractState'

Agora: estou tentando criar uma propriedade String para cada estado chamado StateName. Sempre que crio uma nova classe concreta, preciso definir StateName. Quero que o VS gere um erro se não o usar. Existe uma maneira simples de fazer isso?

Eu tentei isso na classe abstract / base:

public abstract string StateName { get; set; }

Mas não preciso implementar os métodos Get e Set em cada estado.

Pergunta revisada: Em uma situação ideal, cada classe de estado teria que definir StateName e ser herdada da classe base abstrata.

StateName = "MyState1"; //or whatever the state's name is

Se essa instrução estiver faltando, o Visual Studio gerará um erro conforme descrito acima. Isso é possível e, se sim, como?

Eu acho que a maneira "correta" de fazer isso é ter um construtor protegido na classe base que requer o nome do estado como parâmetro.

public abstract class State
{
    private readonly string _name;

    protected State(string name)
    {
        if(String.IsNullOrEmpty(name))
            throw new ArgumentException("Must not be empty", "name");

        _name = name;
    }

    public string Name { get { return _name; } }
}

Os estados concretos fornecem um construtor público que chama implicitamente o construtor da classe base com o nome apropriado.

public abstract class SomeState : State
{
    public SomeState() : base("The name of this state")
    {
        // ...
    }
}

Como a classe base não expõe outros construtores (nem protegidos nem públicos), cada classe herdada precisa passar por esse único construtor e, portanto, precisa definir um nome.

Observe que você não precisa fornecer o nome ao instanciar um estado concreto, porque o construtor cuida disso:

var someState = new SomeState(); // No need to define the name here
var name = someState.Name; // returns "The name of this state"

A partir do C # 6 (acredito - C #: o C # 6.0 novo e aprimorado ), você é capaz de criar apenas propriedades getter. Então você pode declarar sua classe base assim -

public abstract class State
{
    public abstract string name { get; }

    // Your other functions....
}

E então, na sua subclasse, você pode implementar Stateassim -

public class SomeState : State
{
    public override string name { get { return "State_1"; } }
}

Ou até mais limpo usando o operador lambda -

public class SomeState : State
{
    public override string name => "State_1";
}

Ambos sempre retornariam "State_1" e seriam imutáveis.

Seus requisitos são uma contradição:

Estou tentando criar uma propriedade String para cada estado chamado StateName.

vs.

Mas não preciso implementar tudo isso em cada Estado.

Não há nenhum recurso de idioma que permita forçar a existência de um membro em apenas algumas subclasses. Afinal, o objetivo de usar uma superclasse é confiar no fato de que todas as subclasses terão todos os membros da superclasse (e possivelmente mais). Se você deseja criar classes que agem como Statemas não têm nome, então, por definição, elas (/ podem) não devem ser subclasses de State.

Você precisa alterar seus requisitos ou usar algo diferente da herança simples.

Uma possível solução com o código atual é tornar o método Statenão abstrato e retornar uma string vazia.