当作为纯Delegate参数提供时，为什么必须强制转换lambda表达式

采取方法System.Windows.Forms.Control.Invoke（Delegate方法）

为什么会给出编译时错误：

string str = "woop";
Invoke(() => this.Text = str);
// Error: Cannot convert lambda expression to type 'System.Delegate'
// because it is not a delegate type

但这工作正常：

string str = "woop";
Invoke((Action)(() => this.Text = str));

该方法何时需要普通代表？

Lambda表达式可以转换为委托类型或表达式树-但它必须知道哪种委托类型。仅知道签名是不够的。例如，假设我有：

public delegate void Action1();
public delegate void Action2();

...

Delegate x = () => Console.WriteLine("hi");

您期望所指对象的具体类型x是什么？是的，编译器可以生成带有适当签名的新委托类型，但这很少有用，并且您进行错误检查的机会也会减少。

如果你想很容易地调用Control.Invoke与Action最容易做的事情是添加扩展的方法来控制：

public static void Invoke(this Control control, Action action)
{
    control.Invoke((Delegate) action);
}

厌倦了一次又一次地铸造lambda？

public sealed class Lambda<T>
{
    public static Func<T, T> Cast = x => x;
}

public class Example
{
    public void Run()
    {
        // Declare
        var c = Lambda<Func<int, string>>.Cast;
        // Use
        var f1 = c(x => x.ToString());
        var f2 = c(x => "Hello!");
        var f3 = c(x => (x + x).ToString());
    }
}

人们十分之一的时间收到此消息，是因为他们试图封送至UI线程。这是懒惰的方式：

static void UI(Action action) 
{ 
  System.Windows.Threading.Dispatcher.CurrentDispatcher.BeginInvoke(action); 
}

现在已经输入了，问题就解决了（qv Skeet的答案），我们的语法非常简洁：

int foo = 5;
public void SomeMethod()
{
  var bar = "a string";
  UI(() =>
  {
    //lifting is marvellous, anything in scope where the lambda
    //expression is defined is available to the asynch code
    someTextBlock.Text = string.Format("{0} = {1}", foo, bar);        
  });
}

对于奖励积分，这是另一个提示。您不会对UI内容执行此操作，但是在需要SomeMethod阻止它完成之前（例如，请求/响应I / O，等待响应）的情况下，请使用 WaitHandle（qv msdn WaitAll，WaitAny，WaitOne）。

请注意，AutoResetEvent是WaitHandle的派生类。

public void BlockingMethod()
{
  AutoResetEvent are = new AutoResetEvent(false);
  ThreadPool.QueueUserWorkItem ((state) =>
  {
    //do asynch stuff        
    are.Set();
  });      
  are.WaitOne(); //don't exit till asynch stuff finishes
}

最后一条提示是，因为事情可能会纠结在一起：WaitHandles使线程停顿。这就是他们应该做的。如果在停滞期间尝试封送UI线程，则应用程序将挂起。在这种情况下（a）进行了一些认真的重构，并且（b）作为临时破解，您可以像这样等待：

  bool wait = true;
  ThreadPool.QueueUserWorkItem ((state) =>
  {
    //do asynch stuff        
    wait = false;
  });
  while (wait) Thread.Sleep(100);

彼得·沃恩。你是个男人 使您的概念更进一步，我提出了这两个功能。

private void UIA(Action action) {this.Invoke(action);}
private T UIF<T>(Func<T> func) {return (T)this.Invoke(func);}

我将这两个函数放到Form应用程序中，可以像这样的后台工作人员打电话

int row = 5;
string ip = UIF<string>(() => this.GetIp(row));
bool r = GoPingIt(ip);
UIA(() => this.SetPing(i, r));

也许有点懒，但是我不必设置工作人员完成的功能，在这种情况下非常方便

private void Ping_DoWork(object sender, System.ComponentModel.DoWorkEventArgs e)
{
  int count = this.dg.Rows.Count;
  System.Threading.Tasks.Parallel.For(0, count, i => 
  {
    string ip = UIF<string>(() => this.GetIp(i));
    bool r = GoPingIt(ip);
    UIA(() => this.SetPing(i, r));
  });
  UIA(() => SetAllControlsEnabled(true));
}

本质上，从gui DataGridView获取一些ip地址，对其进行ping操作，将结果图标设置为绿色或红色，然后重新启用表单上的按钮。是的，它是后台工作人员中的“ parallel.for”。是的，这会消耗很多开销，但是对于短列表和更紧凑的代码而言，它可以忽略不计。

我试图以@Andrey Naumov的答案为基础。可能这是一个轻微的改进。

public sealed class Lambda<S>
{
    public static Func<S, T> CreateFunc<T>(Func<S, T> func)
    {
        return func;
    }

    public static Expression<Func<S, T>> CreateExpression<T>(Expression<Func<S, T>> expression)
    {
        return expression;
    }

    public Func<S, T> Func<T>(Func<S, T> func)
    {
        return func;
    }

    public Expression<Func<S, T>> Expression<T>(Expression<Func<S, T>> expression)
    {
        return expression;
    }
}

其中type参数S是形式参数（输入参数，这是推断其余类型的最低要求）。现在您可以这样称呼它：

var l = new Lambda<int>();
var d1 = l.Func(x => x.ToString());
var e1 = l.Expression(x => "Hello!");
var d2 = l.Func(x => x + x);

//or if you have only one lambda, consider a static overload
var e2 = Lambda<int>.CreateExpression(x => "Hello!");

你可以有额外的过载Action<S>和Expression<Action<S>>同样在同一个班。对于其他内置的委托和表达式类型，你就必须编写单独的类一样Lambda，Lambda<S, T>，Lambda<S, T, U>等。

与原始方法相比，我看到了这一优势：

1. 一种较少的类型规范（仅需要指定形式参数）。

2. 如示例所示，这使您可以自由地对任何对象使用它Func<int, T>，而不仅仅是T说时string。

3. 立即支持表达式。在较早的方法中，您将不得不再次指定类型，例如：

   var e = Lambda<Expression<Func<int, string>>>.Cast(x => "Hello!");
   
   //or in case 'Cast' is an instance member on non-generic 'Lambda' class:
   var e = lambda.Cast<Expression<Func<int, string>>>(x => "Hello!");

   用于表达。

4. 像上面一样，将类扩展为其他委托（和表达式）类型也很麻烦。

   var e = Lambda<Action<int>>.Cast(x => x.ToString());
   
   //or for Expression<Action<T>> if 'Cast' is an instance member on non-generic 'Lambda' class:
   var e = lambda.Cast<Expression<Action<int>>>(x => x.ToString());

在我的方法中，您只需要声明一次类型（对于Funcs，则少声明一次）。

实现安德烈答案的另一种方法就像不完全通用

public sealed class Lambda<T>
{
    public static Func<Func<T, object>, Func<T, object>> Func = x => x;
    public static Func<Expression<Func<T, object>>, Expression<Func<T, object>>> Expression = x => x;
}

所以事情减少为：

var l = Lambda<int>.Expression;
var e1 = l(x => x.ToString());
var e2 = l(x => "Hello!");
var e3 = l(x => x + x);

打字的次数更少了，但是您失去了某些类型的安全性，imo，这是不值得的。

参加聚会有点晚，但是你也可以这样

this.BeginInvoke((Action)delegate {
    // do awesome stuff
});

 this.Dispatcher.Invoke((Action)(() => { textBox1.Text = "Test 123"; }));

玩XUnit和Fluent断言，可以以我觉得很酷的方式使用此内联功能。

之前

[Fact]
public void Pass_Open_Connection_Without_Provider()
{
    Action action = () => {
        using (var c = DbProviderFactories.GetFactory("MySql.Data.MySqlClient").CreateConnection())
        {
            c.ConnectionString = "<xxx>";
            c.Open();
        }
    };

    action.Should().Throw<Exception>().WithMessage("xxx");
}

后

[Fact]
public void Pass_Open_Connection_Without_Provider()
{
    ((Action)(() => {
        using (var c = DbProviderFactories.GetFactory("<provider>").CreateConnection())
        {
            c.ConnectionString = "<connection>";
            c.Open();
        }
    })).Should().Throw<Exception>().WithMessage("Unable to find the requested .Net Framework Data Provider.  It may not be installed.");
}