наследование абстрактного класса со статическим свойством в C #

Один из способов - это отражение, но оно требует времени выполнения и подвержено ошибкам во время выполнения. Как уже упоминалось, вы не можете заставить наследовать классы повторно объявить какое-то статическое поле и иметь возможность использовать это поле в классе-предке. Поэтому я считаю, что необходима минимальная избыточность кода: каждый наследующий класс должен предоставлять собственный генератор ключей. Этот генератор, конечно, можно держать в статическом поле класса.

(Обратите внимание, что это не обязательно является потокобезопасным.)

class KeyGenerator
{
    private int _value = 0;

    public int NextId()
    {
        return --this._value;
    }
}

abstract class ModelBase
{
    private KeyGenerator _generator;

    public ModelBase(KeyGenerator _generator)
    {
        this._generator = _generator;
    }

    public void SaveObject()
    {
        int id = this._generator.NextId();
        Console.WriteLine("Saving " + id.ToString());
    }
}

class Car : ModelBase
{
    private static KeyGenerator carKeyGenerator = new KeyGenerator();

    public Car()
        : base(carKeyGenerator)
    {
    }
}

class Food : ModelBase
{
    private static KeyGenerator foodKeyGenerator = new KeyGenerator();

    public Food()
        : base(foodKeyGenerator)
    {
    }
}

class Program
{
    static void Main(string[] args)
    {
        Food food1 = new Food();
        Food food2 = new Food();
        Car car1 = new Car();
        food1.SaveObject();
        food2.SaveObject();
        car1.SaveObject();
    }
}

Это производит:

Saving -1
Saving -2
Saving -1

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

https://msdn.microsoft.com/en-us/library/system.guid(v=vs.110).aspx

Что ж, статические классы не наследуются, так что это out, m, и вы не можете заставить подклассы реализовывать статический метод, так что это тоже исключено.

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

public interface IDataModelFactory<T> where T:ModelBase
{
    int GetLastTempId();
}

public Model1Factory : IDataModelFactory<Model1>
{
    public int GetLastTempId()
    {
        // logic for Model1 
    }
}

public Model2Factory : IDataModelFactory<Model2>
{
    public int GetLastTempId()
    {
        // logic for Model2
    }
}

Или, если логика общая для всех классов, создайте абстрактный базовый класс с (или без) интерфейсом:

public DataModelFactory<T> : IDataModelFactory<T>
{
    public virtual int GetLastTempId()
    {
        // common logic
    }

    // other common logic
}

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

В качестве примечания: если вы не уверены, какими будут отношения наследование / интерфейс, я часто нахожу, что быстрее начать с повторного использования копирования / вставки и рефакторинга вашего кода, чтобы ввести базовые классы и интерфейсы. Таким образом вы узнаете, что такое общий код, и сможете преобразовать его в общие методы. В противном случае у вас возникнет соблазн попробовать поместить все в базовый класс и использовать переключатели или другие конструкции для изменения логики на основе производного типа.