在抽象基类中使用具体实现类型

Question

有什么方法可以在这里做我想做的事吗？

基类定义如下：

public abstract class BaseClass<TExists>
    where TExists : BaseExists
{
    // needs to be overridden by child
    protected abstract bool Exists(TExists existsData, out /*typeof(this)*/ existingElement); // <- how to have the concrete type here?

    // static method to be invoked without any need of an instance
    public static bool Exists(TExists existsData, out /*typeof(this)*/ existingElement)
    {
        var temp; // <-- how to set the type here?

        // create a concrete instance
        var instance = Activator.CreateInstance(???);

        // call the concrete implementation
        if(instance.Exists(existsData, out temp))
        {
            return true;
        }

        return false;
    }
}

这里我们有一些具体的实现：

public class ChildClass : BaseClass<ChildClassExists>
{
    protected override bool Exists(ChildClassExists exists, out ChildClass existingElement)
    {
        // do child-related things here
    }
}

最后我想像这样使用它

ChildClass existing;    
if(ChildClass.Exists(new ChildClassExists(), out existing)){
    // do things here with the existing element of type 'ChildClass'
}

因为我这里不需要实例（这隐藏在 Exists 的基类实现中）。

更新 #1

正如在 InBetweens 第一个答案中一样，我现在有了：

public static bool Exists<T>(TExists existsModel, out T existingEntityModel)
    where T : BaseClass<TExists>
{
    var instance = Activator.CreateInstance<T>();
    return instance.ExistsInternal(existsModel, out existingEntityModel);
}

protected abstract bool ExistsInternal<T>(TExists createModel, out T existingEntityModel)
    where T : BaseClass<TExists>;

但这会在 ExistsInternal 方法的具体实现中引发错误

无法将源类型“ChildClass”转换为目标类型“T”

在覆盖中

protected override bool ExistsInternal<T>(ChildClassExists existsData, out T existingElement)
{
    existingElement = new ChildClass(); // <-- here the error is thrown
    return true;
}

Answer 1

只需在Exists 方法中添加一个新的泛型参数即可。这种类型将由编译器推断，因此对可用性没有实际影响：

public abstract class BaseClass<TExists> where TExists : BaseExists
{
    // needs to be overridden by child
    protected abstract bool InternalExistsCheck<T>(TExists existsData, out T existingElement) where T : BaseClass<TExists>, new();

    // static method to be invoked without any need of an instance
    public static bool Exists<T>(TExists existsData, out T existingElement) where T : BaseClass<TExists>, new()
    {
        T temp; // <-- how to set the type here?
        existingElement = null;

        // create a concrete instance
        var instance = new T();

        // call the concrete implementation
        if (instance.InternalExistsCheck(existsData, out temp))
        {
            existingElement = temp;
            return true;
        }

        return false;
    }
}

请注意，如果您不更改受保护的 Exists 方法，您将收到一个模棱两可的调用编译时错误（VS 2013）。

现在，一切都很好：

public class ChildClass : BaseClass<ChildClassExists>
{
    protected override bool InternalExistsCheck<T>(ChildClassExists exists, out T existingElement)
    {
        ....
    }
}

和

ChildClass existing;

if (ChildClass.Exists(new ChildClassExists(), out existing))
{
     // do things here with the existing element of type 'ChildClass'
}

更新

解决您对无法在覆盖的ChildClass.InternalExistsCheck(,) 中将ChildInstance 分配给existing 的担忧，是的，您只需执行以下操作即可：

existing = new T();

如果T 是ChildClass（由编译器推断），那么您将创建一个ChildClass 实例。请记住，虽然您得到的是 BaseClass<ChildExists> 类型的引用，而不是 ChildClass 。

如果您绝对需要 ChildClass 类型的引用，那么有一个解决方法（如果您需要这样做，可能是因为泛型不是适合您的工具）：

var childClassTypedReference = (object)existing as ChildClass.

请意识到整个解决方案并不像您希望的那样类型安全；您必须考虑existing 不是ChildClass 类型引用的可能性（因此childClassTypedReference 是null）。没有什么可以阻止 existing 成为 any 类型扩展 BaseClass<ChildExists>。

我没有你的代码的全貌，但我真的认为你在这里滥用泛型。我认为具有IExists 接口依赖项的非通用方法将是一种更简洁的方法。

Answer 2

受 cmets/answers 的启发，我想出了以下完全符合我需求的解决方案。

1 添加了一个新的（非泛型）基类BaseClass

2 让泛型基类继承自非泛型

public abstract class BaseClass<TExists> : BaseClass
{
}

3 在BaseClass<TExists> 中设置abstract 和static 方法

// abstract to be overriden by child-classes
protected abstract BaseClass ExistsInternal(TExists existsModel);

public static bool Exists<T>(TExists existsModel, out T existing) where T : BaseClass<TExists>
{
    // create a new instance of the concrete child
    var instance = (T) Activator.CreateInstance<T>;

    // set the out parameter (can be null)
    existing = instance.ExistsInternal(existsModel) as T;

    // return if already existing
    return existing!= null;
}

4 在子类中实现覆盖

protected override BaseClass ExistsInternal(ChildClassExists existsModel)
{
    // check for existing
    var existing = ...; // do child-class dependend stuff

    // return concrete instance or null
    return existing != null ? new ChildClass(existing) : null;
}

5 调用它（通过ChildClass 使用推断的类型）

ChildClass childClass;
if (ChildClass.Exists(childClassExists, out childClass))
{
    // do things with existing childClass
}

6 对 InBetween 和 haim7770 表示感谢

@InBetween, @haim7770 -> 谢谢！ ;)