Est-il possible d'écrire une syntaxe comme -()()?

Question

J'ai lu dans un livre électronique quelque part (que je suis désespéré de retrouver), qui, à l'aide des délégués, il est possible d'écrire du code qui a la syntaxe comme suit:

()(); // where delegate precedes this. 

Quelqu'un peut-il fournir des détails comment cela serait possible/dans quelle situation cela se produirait?

Answer 1

Vous pouvez faire un peu mieux que les exemples donnés à ce jour, en fait ... vous pouvez l'étendre de façon arbitraire:

class Test 
{ 
    delegate Hofstadter Hofstadter(); 

    static void Main() 
    { 
     // Unfortunately I'm clearly not as smart as the real thing 
     Hofstadter douglas =() => null; 

     douglas()()()()()()(); 
    } 
} 

Et voici une autre alternative horrible, pour l'art supplémentaire ASCII:

class Test 
{ 
    delegate __ ___(); 
    delegate ___ __(___ _); 

    static void Main() 
    { 
     ___ _ =() => null; 

     _()((_))(); 
    } 
} 

S'il vous plaît ne jamais, jamais le faire.

EDIT: Un dernier - bien qu'il soit autant de simplement remplacer les choses par des underscores comme toute autre chose, et la réutilisation des noms chaque fois que possible:

class Test 
{ 
    delegate void _(); 
    delegate __<_> ___<_>(); 
    delegate ___<_> __<_>(___<_> ____); 

    static ___<_> ____<_>(___<_> ____) { return ____; } 
    static __<_> ____<_>() { return ____<_>; } 

    static void Main() 
    { 
     ((__<_>)____)(____<_>)(); 
    } 
} 

Answer 2

static void Foo() 
{ 
    Console.WriteLine("Hello World!"); 
} 

static Action Bar() 
{ 
    return new Action(Foo); 
} 

static void Main() 
{ 
    Func<Action> func = new Func<Action>(Bar); 
    func()(); 

    Bar()(); 
} 

impressions

 
Hello World! 
Hello World! 

Cela fonctionne, parce que func() et Bar() retourner un délégué Action qui peut être invoqué en utilisant la syntaxe normale d'appel de méthode.

Answer 3

Voici un exemple de programme qui démontre ceci:

using System; 

class Program 
{ 
    static Action GetMethod() 
    { 
     return() => Console.WriteLine("Executing"); 
    } 
    static void Main() 
    { 
     GetMethod()(); 
     Console.ReadKey(); 
    } 
} 

Cela étant dit, je ne jamais faire dans le code de production. C'est très inattendu.

---

Edit: Juste au cas où vous voulez voir quelque chose encore plus laid ... [en particulier le "()()[()=>{}]()"]:

using System; 

class Program 
{ 
    static void Main() 
    { 
     (new Program()).Confusion(); 
     Console.ReadKey(); 
    } 

    public Action this[Action index] 
    { 
     get { 
      return() => Console.WriteLine("Executing"); 
     } 
    } 

    Func<Program> GetInstance() 
    { 
     return() => this; 
    } 

    void Confusion() 
    { 
     // This is particularly ugly... 
     GetInstance()()[()=>{}](); 
    } 
} 

Answer 4

Quelque chose comme:

delegate void FunctionA(); 
delegate FunctionA FunctionB(); 

void TestA() { } 
FunctionA TestB() { return TestA; } 

void Main() 
{ 
    TestB()(); 
} 

Answer 5

Si vous avez une fonction qui renvoie un délégué que vous associeriez généralement à un signal, mais que vous souhaitez appeler cette fonction immédiatement, vous pouvez utiliser cette syntaxe.

Answer 6

Vous avez juste besoin d'un référencement peu de soi-même, et vous pouvez l'appeler autant de fois que vous le souhaitez:

delegate Foo Foo(); 

class Program { 
    static void Main(string[] args) { 
     Foo f = null; 
     f =() => f; 
     // Add more "()" as you feel like... 
     f()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()(); 
    } 
} 

Answer 7

aussi, consultez ce blog par Bertrand Leroy pour quelque chose de similaire: http://weblogs.asp.net/bleroy/archive/2010/03/30/a-c-implementation-of-the-callstream-pattern.aspx

Mais cela fait en fait quelque chose de semi-utile :)