将基类向下转换为派生的泛型 C#

Question

我正在努力解决与泛型之间转换相关的问题，这可能是一个简单的问题。 基本上我想创建一个基类列表并添加多个类。

public interface IQueryEngineDependency
{
    public IEnumerable<QueryDependencyDetail> GetDependencies<>();
}

public abstract class QueryDependencyDetail
{
    public int Order { get; set; }
}

public class QueryDependencyDetail<TEntity, TKey> : QueryDependencyDetail
        where TEntity : BaseEntity<TKey>
{
    public virtual Func<TEntity, object> Key { get; set; }

    public IQueryable<TEntity> Data { get; set; }

    public Func<TEntity, object> JoinKey { get; set; }

    public Expression<Func<TEntity, bool>> WhereClause { get; set; }   
}

问题

例如，我有一个类实现了上面显示的接口，但我正在找出实现它的正确方法。

public class TestQueryDependency : IQueryEngineDependency
{
        public IEnumerable<QueryDependencyDetail> GetDependencies()
        {
            var dependencies = new List<QueryDependencyDetail>
            {
                new QueryDependencyDetail<Tasks, long>
                {
                    Order = 1,
                    Data = null // just to simplify
                }
            };

            return dependencies;
        }
}

如果我在代码中的某处调用GetDependencies 方法，我该如何进行向下转换以访问泛型类型字段？我的意思是我会得到QueryDependencyDetail 类型的实例。那么是否可以将其转换为QueryDependencyDetail<TEntity, TKey>？ 还是有其他方法可以做到这一点？

编辑

var testDep = new TestQueryDependency();
var dependencies = testDep.GetDependencies();

请记住，在我的特定实现中，依赖项可能有多达 20 个不同的实例。 例如，我如何访问数据字段？ （只是一个简单的场景）

var first = dependencies.FirstOrDefault()?.Data; ?????

我将需要它来使用 LINQ 执行动态查询。

提前致谢。

Answer 1

我不确定你想要完成什么。

如果将泛型参数放在引擎接口上会怎样？

public interface IQueryEngineDependency<TEntity,TKey> where TEntity : BaseEntity<TKey> {
    public IEnumerable<QueryDependencyDetail<TEntity,TKey>> GetDependencies();
}

然后你可以创建一个测试引擎：

public class TestQueryDependency : IQueryEngineDependency<Tasks,long> {
    public IEnumerable<QueryDependencyDetail<Tasks,long >> GetDependencies() {
        var dependencies = new[] {
                new QueryDependencyDetail<Tasks, long> {
                    Order = 1,
                    Data = null // just to simplify
                }
            };

        return dependencies;
    }
}

Answer 2

你应该可以直接投射它，即(QueryDependencyDetail<TEntity, TKey>) myObject

但是，您必须确保类型实际上与真实对象匹配。让我们举一个简化的例子：

    public class A { }
    public class B<T> : A { }
    public static B<T> Test<T>(A a) => (B<T>)a;

和

    var a = new B<int>();
    var b1 = Test<int>(a); // works since a is of type of B<int>
    var b2 = Test<string>(a); // Will throw invalid cast exception since a is not of type B<string>

你也可以测试类型：

if(a is B<int> b)

这里的问题是你必须知道对象的实际类型。你不能只是将a 转换为B<T> 而不在某个地方声明T 实际上是什么。

我用来解决这类问题的解决方案是避免任何需要知道泛型类型的事情。确保接口或基类包含与对象交互时所需的所有方法。当涉及多个类时，这可能会有点复杂，但通常是可以的。

编辑： 第三种选择可能是使用反射。这可以让您检查泛型类型参数的实际类型。它可能允许使用相同的泛型类型参数创建另一个对象。缺点是使用反射可能非常麻烦，并且可能容易出错且速度慢。