C# 如何创建函数<；T、 布尔>；当T未知时

我有一个对象，他的实例是在运行时创建的，如下所示：

var type = GetTypeFromAssembly(typeName, fullNameSpaceType);
        var instanceOfMyType = Activator.CreateInstance(type);
        ReadObject(instanceOfMyType.GetType().GetProperties(), instanceOfMyType, fullNameSpaceType);
        return instanceOfMyType;

var parameter = Expression.Parameter(typeof(MyObjectReflectionRuntimeType>));

        var condition =
            Expression.Lambda<Func<MyObjectReflectionRuntimeType, bool>>(
                Expression.Equal(
                    Expression.Property(parameter, theEntity.GetType().GetProperty("Id").Name),
                    Expression.Constant(id, typeof(TKey))
                    ), parameter
                ).Compile();

我需要通过Id查找对象，为此我构建了以下方法：

var parameter = Expression.Parameter(typeof(object));

        var condition =
            Expression.Lambda<Func<object, bool>>(
                Expression.Equal(
                    Expression.Property(parameter, theEntity.GetType().GetProperty("Id").Name),
                    Expression.Constant(id, typeof(TKey))
                    ), parameter
                ).Compile();

var parameter=Expression.parameter（typeof（object））；
var条件=
Lambda(
表达式。相等(
Expression.Property（参数，theEntity.GetType（）.GetProperty（“Id”）.Name），
表达式.常量（id，typeof（TKey））
)，参数
).Compile（）；

但引发一个未处理的异常，该异常表示：

未为类型“System.Object”定义实例属性“Id”

那么，我如何用T构建一个Func，其中T是在运行时设置的？？大概是这样的：

var type = GetTypeFromAssembly(typeName, fullNameSpaceType);
        var instanceOfMyType = Activator.CreateInstance(type);
        ReadObject(instanceOfMyType.GetType().GetProperties(), instanceOfMyType, fullNameSpaceType);
        return instanceOfMyType;

var parameter = Expression.Parameter(typeof(MyObjectReflectionRuntimeType>));

        var condition =
            Expression.Lambda<Func<MyObjectReflectionRuntimeType, bool>>(
                Expression.Equal(
                    Expression.Property(parameter, theEntity.GetType().GetProperty("Id").Name),
                    Expression.Constant(id, typeof(TKey))
                    ), parameter
                ).Compile();

var parameter=Expression.parameter（typeof（MyObjectReflectionRuntimeType>）；
var条件=
Lambda(
表达式。相等(
Expression.Property（参数，theEntity.GetType（）.GetProperty（“Id”）.Name），
表达式.常量（id，typeof（TKey））
)，参数
).Compile（）；

更新[不带实体框架的解决方案]

我已作出以下声明：

    public interface IBaseObject<T>
{
    T Id { get; set; }
}

    public class AnyClass : IBaseObject<Guid>
{
    public Guid Id { get; set; }
}

 var parameter = Expression.Parameter(typeof(IBaseObject<Guid>));
        var id = Guid.NewGuid();
        var theEntity = new AnyClass();

        var theList = new List<AnyClass>
        {
            new AnyClass
            {
                Id = Guid.NewGuid()
            },

            new AnyClass
            {
                Id = Guid.NewGuid()
            },

            new AnyClass
            {
                Id = id
            },

            new AnyClass
            {
                Id = Guid.NewGuid()
            }
        };

        var condition =
            Expression.Lambda<Func<IBaseObject<Guid>, bool>>(
                Expression.Equal(
                    Expression.Property(parameter, theEntity.GetType().GetProperty("Id").Name),
                    Expression.Constant(id, typeof(Guid))
                    ), parameter
                ).Compile();

        var theMetaData = theList.Where(condition).FirstOrDefault();

公共接口IBaseObject
{
T Id{get；set；}
}
公共类AnyClass:IBaseObject
{
公共Guid Id{get；set；}
}
var参数=Expression.parameter（typeof（IBaseObject））；
var id=Guid.NewGuid（）；
var theEntity=newanyclass（）；
var theList=新列表
{
新AnyClass
{
Id=Guid.NewGuid（）
},
新AnyClass
{
Id=Guid.NewGuid（）
},
新AnyClass
{
Id=Id
},
新AnyClass
{
Id=Guid.NewGuid（）
}
};
var条件=
Lambda(
表达式。相等(
Expression.Property（参数，theEntity.GetType（）.GetProperty（“Id”）.Name），
表达式.常量（id，typeof（Guid））
)，参数
).Compile（）；
var theMetaData=list.Where（condition）.FirstOrDefault（）；

但它在实体框架上崩溃，因为

IBaseObject

不是上下文的一部分：（

[更新二]

我已经找到了这样的解决方案，但它不是最优的（感谢@Serge Semenov）：

var parameter=Expression.parameter（typeof（object））；
var entity=Expression.Convert（参数，theEntity.GetType（））；
var条件=
Lambda(
表达式。相等(
Expression.Property（实体，theEntity.GetType（）.GetProperty（“Id”）.Name），
表达式.常量（id，typeof（TKey））
)，参数
).Compile（）；
var theObject=wait_unitOfWork.Set（theEntity.GetType（））.toListSync（）；
返回object.FirstOrDefault（条件）；

我认为这不是最好的方法，因为我不想使用

await\u unitOfWork.Set（theEntity.GetType（））.toListSync（）；

而是想使用

await\u unitOfWork.Set（theEntity.GetType（））.FirstOrDefaultAsync（）；

，但它不起作用

---

有什么想法吗？

将

对象

传递给

函数

，但访问在其他类型上定义的

Id

属性

最简单的修复方法是将

对象

强制转换为类型

T

，然后访问其属性，就像在C#

（（T）obj）中所做的那样。Id

：

var parameter = Expression.Parameter(typeof(object));
var entity = Expression.Convert(parameter, theEntity.GetType());
...
Expression.Property(entity, theEntity.GetType().GetProperty("Id").Name),
...

---

可能是的副本。我不认为这是那篇文章的副本。不是副本…为什么不将条件作为参数发送？你希望实现什么？你能用外行的术语解释一下吗？你能检查一下我对你的建议所做的更新是否如你所认为的那样吗？它不起作用，因为

object

type没有t属于上下文：（…此行

var theMetaData=\u unitOfWork.Set（）.Where（condition）.FirstOrDefault（）；

使应用程序崩溃