访问从通用抽象库派生的类中的重写的抽象属性所需的接口？

Question

So my dilemma is that in order to access IntThing 's or StringThing 's MyProperty from UtilityThing<T> , I'm defining an interface with MyProperty and using it as the generic constraint on T in UtilityThing<T> . This is working, but seems redundant given that the same property is already defined in the abstract base. Am I missing a facet of design here, or is this actually the way it needs to be done in this instance?

public interface IThing {
    string MyProperty { get; set; } 
}

public abstract class Thing<T> {
    protected string _MyProperty;
    public abstract string MyProperty { get; set; }
    public T OtherProperty { get; set; }

    public string CommonMethod() {
        return MyProperty + "foobar";   
    }
}

public class IntThing : Thing<int?>, IThing {
    public override string MyProperty {
        get { return _MyProperty; }
        set { _MyProperty = value + OtherProperty.ToString(); }
    }
}

public class StringThing: Thing<string>, IThing {
    public override string MyProperty {
        get { return _MyProperty; }
        set { _MyProperty = OtherProperty + value; }
    }
}

public class UtilityThing<T> where T: IThing, new() {
    public T DoIt(SomeContext someContext, string name) {
        string contextVal = someContext.GetValue(name);

        var thing = new T { MyProperty = contextVal }
        return thing;
    }
}

Answer 1

You'll need to introduce a new generic type. Once the new type is introduced you can eliminate the need of the interface.

public class UtilityThing<T, I> where T : Thing<I>, new()
{
    public T DoIt(SomeContext someContext, string name)
    {
        string contextVal = someContext.GetValue(name);

        var thing = new T { MyProperty = contextVal };
        return thing;
    }
}

And you can use it like this:

var utility = new UtilityThing<IntThing, int?>();