Я могу Переопределить с производными типами?

Можно повторно объявить (новый), но Вы не можете повторно объявить и переопределить одновременно (с тем же именем). Одна опция состоит в том, чтобы использовать защищенный метод скрыть деталь - это позволяет и полиморфизм и скрывающийся одновременно:

public class Father
{
    public Father SomePropertyName
    {
        get {
            return SomePropertyImpl();
        }
    }
    protected virtual Father SomePropertyImpl()
    {
        // base-class version
    }
}

public class Child : Father
{
    public new Child SomePropertyName
    {
        get
        { // since we know our local SomePropertyImpl actually returns a Child
            return (Child)SomePropertyImpl();
        }
    }
    protected override Father SomePropertyImpl()
    {
        // do something different, might return a Child
        // but typed as Father for the return
    }
}

Нет, но можно использовать дженерики в 2 и выше:

public class MyClass<T> where T: Person
{
    public virtual T SomePropertyName
    {
        get
        {
            return  ...;
        }
    }
}

Тогда Родительский элемент и Ребенок являются универсальными версиями того же класса

От Википедия :

На языке программирования C#, поддержке и ковариантности типа возврата и контравариантности параметра для делегатов был добавлен в версии 2.0 языка. Ни ковариантность, ни контравариантность не поддерживаются для переопределения метода.

Это ничего явно не говорит о ковариантности свойств все же.

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

Нет. C# не поддерживает эту идею (это называют "ковариантностью типа возврата"). Можно однако сделать это:

public class FatherProp
{
}

public class ChildProp: FatherProp
{
}


public class Father
{
    public virtual FatherProp SomePropertyName
    {
        get
        {
            return new FatherProp();
        }
    }
}


public class Child : Father
{
    public override FatherProp SomePropertyName
    {
        get
        {
            // override to return a derived type instead
            return new ChildProp();
        }
    }
}

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

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

базовый класс виртуальный метод (в этом случае, виртуальное свойство) не только имеют реализацию, но также и определяют контракт: то, что дочерний класс может предоставить различную реализацию SomePropertyName, если это выполняет этот контракт (т.е. SomePropertyName возвращает объект типа "FatherProp"). Возврат объекта типа "ChildProp", полученный из "FatherProp", выполняет этот контракт. Но Вы не можете изменить контракт в "Ребенке" - этот контракт относится ко всем классам, убывавшим от "Родительского элемента".

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

номер C# не поддерживает эту идею (это называют "ковариантностью типа возврата").

Из Википедии:

На языке программирования C#, поддержке и ковариантности типа возврата и контравариантности параметра для делегатов был добавлен в версии 2.0 языка. Ни ковариантность, ни контравариантность не поддерживаются для переопределения метода.

можно повторно объявить (новый), но Вы не можете повторно объявить и переопределить одновременно (с тем же именем). Одна опция состоит в том, чтобы использовать защищенный метод скрыть деталь - это позволяет и полиморфизм и скрывающийся одновременно:

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

public class MyClass<T> where T: Person
{
   public virtual T SomePropertyNameA
   {        
      get { return  ...; }    
   }
}//Then the Father and Child are generic versions of the same class

Это является самым близким, я мог приехать (до сих пор):

    public sealed class JustFather : Father<JustFather> {}

    public class Father<T> where T : Father<T>
    { public virtual T SomePropertyName
        { get { return (T) this; }
        }
    }

    public class Child : Father<Child>
    { public override Child SomePropertyName
        { get { return  this; }
        }
    }

Без JustFather класс, Вы не могли инстанцировать Father<T>, если это не был некоторый другой производный тип.