通用接口/基类-无类型约束的访问成员

Question

Suppose I have a class structure looking like this:

public abstract class MyOtherBaseClass
{
  public string HelloWorld;
}
public interface MyInterface<T> where T : MyOtherBaseClass
{
  T MyObject { get; set; }
}
public abstract class MyBaseClass<T> : MyInterface<T>
  where T : MyOtherBaseClass
{
  public T MyObject { get; set; }
}
public class MyImplementation : MyBaseClass<MyOtherBaseClass>
{

}

Is there any way I can access MyObject in any implementation of MyBaseClass ? I can't use a variable of MyBaseClass or MyInterface because I have to specify type constraints, but in my case I'm not interested in specifying them since all I want to do is access the value within.

Ideally I'd like to be able to do something like this:

MyBaseClass baseObject = null;
if(someCondition)
{
   baseObject = new MyImplementation();
}
else if(otherCondition)
{
   baseObject = new OtherImplementation(); //this also inherits from MyBaseClass
}
var objectValue = baseObject.MyObject;
var helloWorldValue = objectValue.HelloWorld;

Answer 1

What you want is not entirely possible, not with generics. The type MyBaseClass simply does not exists. A generic type must have a generic type argument.

If you do not want to use generics, why use generics?

This could also be a valid option:

public interface MyInterface
{
  object MyObject { get; set; }
}
public abstract class MyBaseClass : MyInterface
{
  public object  MyObject { get; set; }
}

Of course, in this example you have to cast the object to a specific type.

You could also combine both techniques:

public interface MyInterface // This is the non-generic interface.
{
    object MyObject { get; set; }
}
public interface MyInterface<T> // This is the generic interface.

    where T : MyOtherBaseClass
{
    T MyObject { get; set; }
}
public abstract class MyBaseClass<T> : MyInterface, MyInterface<T> // This class implements both the non-generic and the generic interface.
  where T : MyOtherBaseClass
{
    public T MyObject { get; set; } // Implementation of the generic property.
    object MyInterface.MyObject // Implementation of the non-generic property.
    {
        get { return MyObject; }
        set { MyObject = (T)value; }
    }
}
...
MyInterface baseObject; // The non-generic interface is used as base object.
baseObject = new MyImplementation(); // It is assigned an instance of MyImplementation which uses a generic base class.
object value = baseObject.MyObject;