¿Es posible escribir sintaxis como -()()?

Question

leí en un libro electrónico en algún lugar (que estoy desesperado por encontrar de nuevo), que, mediante el uso de los delegados, es posible escribir código que tiene la sintaxis de la siguiente manera:

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

¿Alguien puede dar detalles de cómo esto sería posible/¿en qué situación ocurriría esto?

Answer 1

Usted puede hacer un poco mejor que los ejemplos dados hasta ahora, de hecho ... se puede extender de manera arbitraria:

class Test 
{ 
    delegate Hofstadter Hofstadter(); 

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

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

Y aquí hay otra alternativa horrible, por el arte ASCII adicional:

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

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

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

Nunca haga esto.

EDIT: Un último - aunque es tanto sobre sólo la sustitución de las cosas con guiones como cualquier otra cosa, y la reutilización de los nombres siempre que sea posible:

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

impresiones

 
Hello World! 
Hello World! 

Esto funciona, porque func() y Bar() devolver un delegado Action cual puede ser invocado utilizando la sintaxis normal de invocación de método.

Answer 3

He aquí un programa de ejemplo que muestra esto:

using System; 

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

Dicho esto, yo no volvería a hacer esto en el código de producción. Es muy inesperado.

---

Editar: Sólo en caso de que quiera ver algo aún más feo ... [especialmente el "()()[()=>{}]()"]:

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

Algo así como:

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

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

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

Answer 5

Si tiene una función que devuelve un delegado que normalmente adjuntaría a una señal, pero desea llamar a esa función de inmediato, puede usar esta sintaxis.

Answer 6

Sólo se necesita un poco de auto referencia, y se le puede llamar tantas veces como se quiera:

delegate Foo Foo(); 

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

Answer 7

Además, echa un vistazo a esta entrada del blog por Bertrand Leroy algo similar: http://weblogs.asp.net/bleroy/archive/2010/03/30/a-c-implementation-of-the-callstream-pattern.aspx

Pero eso realmente hace algo semi-útil :)