如何使用反射来调用DomainService.Load方法

本文关键字：DomainService Load 方法 调用 何使用 反射 | 更新日期: 2023-09-27 17:57:47

我正在尝试构建一个实用程序方法，该方法将使用反射一般加载entitycollections。其想法是，使用该实用程序的程序员可以指定任何类型的实体，并且该方法将发现正确的EntityQuery，并用它们请求的内容加载上下文。因此，我已经从用户那里收集了Entity类型和Where子句，现在我正试图弄清楚如何调用该方法。这是我所拥有的：

public void Handle(LoadEntityQuery loadQuery, Action<LoadEntityQueryResult> reply)
{
    foreach (var entry in loadQuery.Entities)
    {
        Type entityType = entry.Key;
        Type _contextType = EmployeeJobsContext.Instance.GetType();
        MethodInfo _methodInfo = (from x in _contextType.GetMethods()
                                 where x.ReturnType.BaseType == typeof(EntityQuery)
                                 from y in x.ReturnType.GetGenericArguments()
                                 where y == entityType
                                 select x).FirstOrDefault();
        if (_methodInfo != null)
        {
            var query = _methodInfo.Invoke(EmployeeJobsContext.Instance, null);
           var _loadMethods = from x in _contextType.GetMethods()
                              where x.Name == "Load" &&
                                    x.GetParameters().Length == 3
                              select x;
           MethodInfo _loadMethod = null;
           if (_loadMethods != null)
           {
               foreach (MethodInfo item in _loadMethods)
               {
                   ParameterInfo[] _paramInfo = item.GetParameters();
                   if (_paramInfo[0].ParameterType.BaseType == typeof(EntityQuery) &&
                       _paramInfo[1].ParameterType.IsGenericType &&
                       _paramInfo[1].ParameterType.GetGenericArguments().Length == 1 &&
                       _paramInfo[1].ParameterType.GetGenericArguments()[0].BaseType == typeof(LoadOperation) &&
                       _paramInfo[2].ParameterType == typeof(object))
                   {
                       _loadMethod = item;
                       break;
                   }
               }
           }
           MethodInfo _loadOpMethod = this.GetType().GetMethod("LoadOperationResult");
           Delegate d = Delegate.CreateDelegate(typeof(LoadOpDel), _loadOpMethod);
           if (_loadMethod != null)
           {
               object [] _params = new object[3];
               _params[0] = query;
               _params[1] = d;
               _params[2] = null;
               _loadMethod = _loadMethod.MakeGenericMethod(entityType);
               _loadMethod.Invoke(_context, _params);
           }
        }           
    }
}
public delegate void LoadOpDel(LoadOperation loadOp);
public void LoadOperationResult (LoadOperation loadOp)
{
    if (loadOp.HasError == true)
    {
        //reply(new LoadEntityQueryResult { Error = loadOp.Error.Message });
        loadOp.MarkErrorAsHandled();
    }
}

foreach循环迭代Dictionary>>，其中Key是Entity类型，值是where子句。代码的第一部分是找到正确的EntityQuery方法并调用它来获得实际的查询。然后它会发现正确的Load重载（我知道，可能有更好的方法来找到方法：））这部分代码工作正常，我能够发现正确的EntityQuery和Load方法。

对于LoadOperation，我想使用LoadOperationResult作为我的委托方法。但是，当我尝试运行此代码时，我收到一个异常，指出委托类型和方法类型签名不匹配。我非常确信我的签名是正确的，因为如果我直接调用Load并正常地将函数名作为回调传递，则此代码将正确执行。我对反射式编程相当熟悉，但将Generics和Action回调添加到组合中有点超出了我目前的水平。我不知道自己做错了什么，有人能给我什么建议吗？我离这儿很远吗？谢谢你的帮助！！Jason

如何使用反射来调用DomainService.Load方法

在不了解您正在使用的类的任何其他信息的情况下，我无法真正测试我的解决方案，但当我将委托创建从for循环中移除时，我可以让它发挥作用。我把你的目标方法改为静态：

public static void LoadOperationResult(LoadOperation loadOp)

并且创建委托时没有出现问题。

比方说，我在这方面不是特别称职，但我认为你想创建一次委托，并在需要时重复使用它。为什么要一遍又一遍地创建它？

即使Action<LoadOperation>和LoadOpDel具有相同的签名，也不能在它们之间隐式转换。在C#中，强制有时会让这看起来不真实，但如果你使用的是反射型强制，显然不会奏效。

我发现我不需要使用反射来调用Load方法（不需要委托），而是通过创建一个基于Entity类型的泛型方法来直接调用Load。以下是我为感兴趣的人想出的：

    /// <summary>
    /// The Action callback for the LoadEntityQuery handler. This callback is used to respond to the 
    /// LoadEntityQuery when all Load calls are complete. See the Handle method 
    /// </summary>
    private Action<LoadEntityQueryResult> _reply = null;
    /// <summary>
    /// Accumulator used to determine when the last entity has been loaded
    /// </summary>
    private int EntityCount { get; set; }
    /// <summary>
    /// Collective error container for Errors from the LoadOperation. This is value is returned via
    /// the _reply callback to the calling code.
    /// </summary>
    private List<Exception> Errors = null;
    public void Handle(LoadEntityQuery loadQuery, Action<LoadEntityQueryResult> reply)
    {
        _reply = reply;
        Errors = new List<Exception>();
        EntityCount = loadQuery.Entities.Count();
        MethodInfo _loadOpMethod = this.GetType().GetMethod("Load", BindingFlags.NonPublic | BindingFlags.Instance);
        int _entityCount = loadQuery.Entities.Count();
        foreach (var entry in loadQuery.Entities)
        {
            Type entityType = entry.Key;
            Type _contextType = EmployeeJobsContext.Instance.GetType();
            MethodInfo _methodInfo = (from x in _contextType.GetMethods()
                                      where x.ReturnType.BaseType == typeof(EntityQuery)
                                      from y in x.ReturnType.GetGenericArguments()
                                      where y == entityType
                                      select x).FirstOrDefault();
            if (_methodInfo != null)
            {
                var query = _methodInfo.Invoke(EmployeeJobsContext.Instance, null);
                MethodInfo _typedLoadOpMethod = _loadOpMethod.MakeGenericMethod(new Type[] { entityType });
                _typedLoadOpMethod.Invoke(this, new[] { query, entry.Value});
            }
        }
    }
    private void Load<T>(EntityQuery<T> query, Expression<Func<T, bool>> where) where T: Entity
    {
        if (where != null)
            query = query.Where(where);
        EmployeeJobsContext.Instance.Load(query, (loadOp) =>
            {
                EntityCount--;
                if (loadOp.HasError)
                {
                    Errors.Add(loadOp.Error);
                    loadOp.MarkErrorAsHandled();
                }
                if (EntityCount == 0)
                    _reply(new LoadEntityQueryResult { ErrorList = Errors });
            }, null);
    }

Load操作的处理程序监视最后一个实体完成加载，然后向客户端响应加载已完成（如果出现任何错误，则会返回）。

相关文章：