如何传递数组'；方法签名C#

现在我有一本词典。 我想调用IDataExchangeServiceCallBack的方法

IDataExchangeServiceCallBack的代码如下：

[ServiceContract]
public interface IDataExchangeServiceCallBack
{
    [OperationContract(IsOneWay = true)]
    void SendResult(string msg);

    [OperationContract(IsOneWay = true)]
    void Receive(List<RealDataModel> models);
}

[服务合同]
公共接口IDataExchangeServiceCallBack
{
[运营合同（IsOneWay=true）]
void SendResult（字符串msg）；
[运营合同（IsOneWay=true）]
无效接收（列出型号）；
}

在另一个类中，我希望调用dict的foreach方法

比如

    public void Receive(List<RealDataModel> models)
    {
        Broast(o => nameof(o.Receive), models);
    }

    public void SendResult(string msg)
    {
        Broast(o => nameof(o.SendResult), msg);
    }

public void Receive（列出型号）
{
Broast（o=>nameof（o.Receive），型号）；
}
公共void SendResult（字符串msg）
{
Broast（o=>nameof（o.SendResult），msg）；
}

和Broast方法如下：

    private void Broast(Func<IDataExchangeServiceCallBack, string> funcMethodName, params object[] args)
    {
        if (_callbackChannelList.Count > 0)
        {
            var callbackChannels = _callbackChannelList.ToArray();

            foreach (var channel in callbackChannels)
            {
                try
                {
                    var type = channel.Value.GetType();

                    // fetch the method's name.
                    var methodName = funcMethodName.Invoke(channel.Value);

                    // reflect & get the method
                    var methodInfo = type.GetMethod(methodName);

                    //invoke
                    methodInfo?.Invoke(channel.Value, args);
                }
                catch (Exception ex)
                {
                    _callbackChannelList.TryRemove(channel.Key, out _);
                }
            }
        }
    }

private void Broast（Func funcMethodName，params object[]args）
{
如果（_callbackChannelList.Count>0）
{
var callbackChannels=_callbackChannelList.ToArray（）；
foreach（回调通道中的var通道）
{
尝试
{
var type=channel.Value.GetType（）；
//获取方法的名称。
var methodName=funcMethodName.Invoke（channel.Value）；
//反思并获得方法
var methodInfo=type.GetMethod（methodName）；
//援引
methodInfo？.Invoke（channel.Value，args）；
}
捕获（例外情况除外）
{
_callbackChannelList.TryRemove（channel.Key，out)；
}
}
}
}

现在我的问题是如何在没有反射的情况下实现上述代码，是否有更好的解决方案

表达式可以实现它吗

我对表情不熟悉

---

谢谢。

我不明白你是如何得到你的解决方案的。无论

o

的类型如何，表达式（例如，

nameof（o.Receive）

将始终产生字符串

“Receive”

。在我看来，您可以将

nameof（IDataExchangeServiceCallBack.Receive）

传递给该方法，而不是传递委托

也就是说，我也不明白为什么要使用反射或

表达式。在我看来，在调用站点，您知道要处理的对象类型、要调用的方法以及要传递的参数。因此，您可以传递一个完成所有这些任务的委托。例如：

private void Broast(Action<IDataExchangeServiceCallBack> callback)
{
    foreach (var channel in _callbackChannelList.ToArray())
    {
        try
        {
            //invoke
            callback(channel.Value);
        }
        catch (Exception ex)
        {
            _callbackChannelList.TryRemove(channel.Key, out _);
        }
    }

}

private void Broast（操作回调）
{
foreach（callbackChannelList.ToArray（）中的var通道）
{
尝试
{
//援引
回调（channel.Value）；
}
捕获（例外情况除外）
{
_callbackChannelList.TryRemove（channel.Key，out)；
}
}
}

用法如下：

public void Receive(List<RealDataModel> models)
{
    Broast(o => o.Receive(models));
}

public void SendResult(string msg)
{
    Broast(o => o.SendResult(msg));
}

public void Receive（列出型号）
{
Broast（o=>o.Receive（models））；
}
公共void SendResult（字符串msg）
{
Broast（o=>o.SendResult（msg））；
}

注意，我已经稍微清理了
Broast（）
方法。在空集合上调用
ToArray（）
几乎没有开销，而且它大大简化了代码，删除了
Count>0
检查。如果您可以删除不必要的条件检查，那么以后编写和阅读代码总是更容易。
我不明白您是如何获得现有解决方案的。无论
o
的类型如何，表达式（例如，
nameof（o.Receive）
将始终产生字符串
“Receive”
。在我看来，您可以将
nameof（IDataExchangeServiceCallBack.Receive）
传递给该方法，而不是传递委托

也就是说，我也不明白为什么要使用反射或
表达式。在我看来，在调用站点，您知道要处理的对象类型、要调用的方法以及要传递的参数。因此，您可以传递一个完成所有这些任务的委托。例如：

private void Broast(Action<IDataExchangeServiceCallBack> callback)
{
    foreach (var channel in _callbackChannelList.ToArray())
    {
        try
        {
            //invoke
            callback(channel.Value);
        }
        catch (Exception ex)
        {
            _callbackChannelList.TryRemove(channel.Key, out _);
        }
    }

}

private void Broast（操作回调）
{
foreach（callbackChannelList.ToArray（）中的var通道）
{
尝试
{
//援引
回调（channel.Value）；
}
捕获（例外情况除外）
{
_callbackChannelList.TryRemove（channel.Key，out)；
}
}
}

用法如下：

public void Receive(List<RealDataModel> models)
{
    Broast(o => o.Receive(models));
}

public void SendResult(string msg)
{
    Broast(o => o.SendResult(msg));
}

public void Receive（列出型号）
{
Broast（o=>o.Receive（models））；
}
公共void SendResult（字符串msg）
{
Broast（o=>o.SendResult（msg））；
}

注意，我已经稍微清理了
Broast（）
方法。在空集合上调用
ToArray（）
几乎没有开销，而且它大大简化了代码，删除了
Count>0
检查。如果可以删除不必要的条件检查，那么以后编写和读取代码总是更容易