标签: anonymous-delegates

我试图传递参数,这是匿名委托(没有输入参数,没有返回值),以实现功能.

像这样的东西:

private function DoSomething(delegate cmd)
{
     cmd();
}

然后,我想用这个函数以这种方式调用函数:

DoSomething(delegate
{
     Console.WriteLine("Hooah!");
});

我想要这种特定的方式,因为它很容易使用写作风格.

可能？

在Silverlight 4中,我有一个自定义服务类,它有一个异步的Completed事件.在Completed事件中,我获取返回的数据并通过以下方式调用populate方法:

private void service_Completed(object sender, CompletedEventArgs args)
{
    Dispatcher.BeginInvoke(() => populateInbox(args.Jobs));
}

private void populateInbox(List<JobViewModel> jobs)
{
    inbox.DataContext = jobs;
}

BeginInvokeSL4中的工作,但是当我将它移植到WPF时,我收到以下错误:

无法将lambda表达式转换为类型'System.Delegate',因为它不是委托类型

我尝试将其更改为一个内联的,匿名的,参数化的代表:

Dispatcher.BeginInvoke(delegate(List<JobViewModel> jobs)
{
    inbox.DataContext = jobs;
});

但是,这会产生相同的编译时错误.

知道如何在WPF中使用它吗？重构使用BackgroundWorker它不是我的选择.

我有以下高阶函数:

public static Func<T, bool> Not<T>(Func<T, bool> otherFunc)
{
    return arg => !otherFunc(arg);
}

并尝试这样称呼它:

var isValidStr = LinqUtils.Not(string.IsNullOrWhiteSpace);

编译器给我"类型参数不能从使用中推断"错误.但以下工作:

var isValidStr = LinqUtils.Not((string s) => string.IsNullOrWhiteSpace(s));

我想知道有什么区别？ string.IsNullOrWhiteSpace已经是一个具有完全相同签名的非重载函数.

如评论中所述,以下内容也有效,但仍无法解释为什么在这种情况下类型推断失败:

var isValidStr = LinqUtils.Not<string>(string.IsNullOrWhiteSpace);

在我的程序中,我们分割了大量需要在四个线程中查看的数据.

Thread one = new Thread(delegate() { NewMethod(recordsSplitIntoQuarters[0], param2, param3, param4, param5); });
Thread two = new Thread(delegate() { NewMethod(recordsSplitIntoQuarters[1], param2, param3, param4, param5); });
Thread three = new Thread(delegate() { NewMethod(recordsSplitIntoQuarters[2], param2, param3, param4, param5); });
Thread four= new Thread(delegate() { NewMethod(recordsSplitIntoQuarters[3], param2, param3, param4, param5); });

我们的编码标准要求我们符合StyleCop标准,StyleCop要求如下:

SA1410:从匿名方法中删除括号,因为委托的参数列表为空.

这样做会给我这个编译错误:

以下方法或属性之间的调用不明确:'System.Threading.Thread.Thread(System.Threading.ParameterizedThreadStart)'和'System.Threading.Thread.Thread(System.Threading.ThreadStart)'

我查看了ThreadStart和ParameterizedThreadStart对象,我无法弄清楚如何获得我需要完成的任何这些对象.

我的问题:匿名代表如何工作？他们编译到什么？最后,我将不得不在没有匿名代表的情况下工作,但我不知道从哪里开始.

谢谢您的帮助,

导引头

我正在用C#构建一个消息调度图,主要是用一些不同的方法来玩.我很好奇我正在测量的性能差异,但是从IL看起来并不明显.

消息地图:

delegate void MessageHandler(Message message);
AddHandler(Type t, MessageHandler handler) 
{ 
    /* add 'handler' to messageMap invocation list */ 
}

delegate void GenericMessageHandler<T>(T message);
AddHandler<T>(GenericMessageHandler<T> handler) where T: Message
{
    AddHandler(typeof(T), e => { handler((T)e); });
}

Dictionary<Type, MessageHandler> messageMap;

然后我有一个Messages类的层次结构,类似于WPF中的EventArgs,例如:

public class Message {}
public class VelocityUpdateMessage : Message

和具有处理函数的observer类:

void HandleVelocityUpdate(VelocityUpdateMessage message) { ... }

我正在测量2种添加和调用处理程序的方法.我正在包装委托调用,所以我可以获得一些概念类型的安全性,其中存在性能差异.

方法1:听众呼叫

AddHandler(typeof(VelocityUpdateMessage), 
           e => { HandleVelocityUpdate((VelocityUpdateMessage)e); });

方法2:听众呼叫

AddHandler<VelocityUpdateMessage>(HandleVelocityUpdate);

这两种方法都构建了一个MessageHandler委托,它可以进行强制转换和相同的方法调用,但是调用使用方法#2构建的委托,即使生成的IL看起来相同,也会慢一点.是否会在转换为泛型类型时产生额外的运行时开销？是类型约束吗？一旦解决了泛型类型,我希望JITted代理是相同的.

谢谢你的任何信息.

你能解释一下下面的代码:

private static List<Post> _Posts;
public static Post GetPost(Guid id)
{
    return _Posts.Find(delegate(Post p)
    {
        return p.Id == id;
    });
}

1. 通过这种方式在通用列表中找到对象有什么意义？他可以简单地迭代列表.

2. 这个委托方法如何为列表的每个元素调用？

注意:如果这有一个共同的名称,你可以更新我的问题标题吗？

谢谢 !

我想知道是否有可能使变量的"动态"类型适用于匿名委托.

我尝试过以下方法:

dynamic v = delegate() {
};

但后来我收到以下错误消息:

Cannot convert anonymous method to type 'dynamic' because it is not a delegate type

不幸的是,以下代码也不起作用:

Delegate v = delegate() {
};
object v2 = delegate() {
};

如果我想创建一个接受任何类型的委托的方法,即使是内联声明的委托,我该怎么办？

例如:

class X{
    public void Y(dynamic d){
    }
    static void Main(){
        Y(delegate(){});
        Y(delegate(string x){});
    }
}

当delegate在C#中使用匿名s时,CLR将在堆上为已使用的变量生成本地的副本(例如,当前作用域中的变量).对于当前作用域的每个声明变量,这样的local将被放到堆上.

您可以在此示例中看到此行为:

class Program
{
    static void Main(string[] args)
    {
        for (int i = 0; i < 5; i++)
            ThreadPool.QueueUserWorkItem(delegate { execute(i); });

        Thread.Sleep(1000);

        Console.WriteLine();

        for (int i = 0; i < 5; i++)
        {
            int j = i;

            ThreadPool.QueueUserWorkItem(delegate { execute(j); });
        }

        Thread.Sleep(1000);
    }

    static void execute(int number)
    {
        Console.WriteLine(" * NUM=" + number.ToString());
    }
}

该程序的输出是(顺序可能在最后5个条目上有所不同,而在第一个条目上也可能得到低于5的数字):

 * NUM=5
 * NUM=5
 * NUM=5
 * NUM=5
 * NUM=5

 * NUM=0
 * NUM=1
 * NUM=2
 * NUM=3
 * …

我正在学习/试验C#中的一些功能模式,我遇到了一个无法解释的问题.我确信这是一个简单的答案(我希望),但我很难看到它.可能与闭包等有关,而我无法开箱即用,隐藏了我的答案!

这是我的实验:我试图从函数委托中返回一个特定类的全新实例.

public class Foo{
    string A { get; set ; }
}

static void Main( string[] args ){
    // the delegate...
    Func<Foo,bool> someFunc = o => {
        o = new Foo { A = "A new instance of o?" };
        return true;
    };

    Foo foo = null;   // was hoping to replace this via delegate
    var myFunc = someFunc;
    var result = myFunc( foo );

    if ( foo == null )
        Console.WriteLine( "foo unchanged :-(" );
    else
        Console.WriteLine( foo.A …

我有进度表格,代表:

    // in ProgressForm thread
    public delegate void executeMethod(object parameters);      
    private executeMethod method;
    public object parameters;
    // ...
    private void ProgressForm_Shown(object sender, EventArgs e)
    {
         method.Invoke(parameters);
    }

哪种方式更好(高效或安全)应用 - 匿名代表调用如下:

// in other thread
ProgressForm progress = new ProgressForm();
progress.ExecuteMethod = delegate
{
   // to do
}

或使用这样的单独方法:

// in other thread
private void myMethod(object par)
{
     // to do
}

progress.ExecuteMethod = this.myMethod;