ラムダ式をプレーンなデリゲートパラメーターとして提供するときにキャストする必要がある理由

メソッドSystem.Windows.Forms.Control.Invoke（Delegate method）を取る

なぜこれがコンパイル時エラーになるのですか？

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));

メソッドがプレーンなデリゲートを期待するとき？

ラムダ式はデリゲート型または式ツリーに変換できますが、どのデリゲート型を知っている必要があります。署名を知っているだけでは十分ではありません。たとえば、私が持っているとしましょう：

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);
}

ラムダを何度もキャストするのはうんざりですか？

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スレッドにマーシャリングしようとしているため、これが9分の1の時間で発生します。ここに怠惰な方法があります：

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

これで型付けされたので、問題はなくなり（qvスキートの答え）、次のような非常に簡潔な構文になります。

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);

ピーター・ウォン。あなたはダマンです。あなたのコンセプトをもう少し詳しく見て、私はこれら2つの機能を思いつきました。

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

これら2つの関数をフォームアプリに配置し、バックグラウンドワーカーから次のように呼び出すことができます

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;
    }
}

ここで、型パラメーター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. 型指定が1つ少なくなります（仮パラメーターのみを指定する必要があります）。

2. これにより、例に示すように、と言うFunc<int, T>ときだけでなく、任意のに対して自由に使用できます。Tstring

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());

私のアプローチでは、型を1回だけ宣言する必要があります（Funcsの場合は1つ少なくなります）。

Andreyの答えを実装するもう1つの方法は、完全に一般的ではないようなものです

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);

これはタイピングがさらに少なくなりますが、特定のタイプセーフを失うので、これは価値がありません。

パーティーに少し遅れますが、このようにキャストすることもできます

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.");
}