Можно ли написать синтаксис как -()()?

Я где-то читаю в электронной книге (которую я отчаянно хочу найти), что, используя делегаты, можно написать код с синтаксисом следующим образом:

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

Может ли кто-нибудь представить какие-либо подробности, как это было бы возможно/в какой ситуации это могло произойти?

Ответы

Ответ 1

Вы можете сделать немного лучше, чем приведенные до сих пор примеры, на самом деле... вы можете его произвольно расширить:

class Test
{
    delegate Hofstadter Hofstadter();

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

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

И вот еще одна ужасная альтернатива, для дополнительного искусства ASCII:

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

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

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

Никогда, никогда не делай этого.

РЕДАКТИРОВАТЬ: Один последний - хотя он как бы просто заменяет вещи подчеркиваниями как что-то еще и повторное использование имен, где это возможно:

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

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

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

Ответ 2

Вот пример программы, которая демонстрирует это:

using System;

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

Говоря, я бы никогда не делал этого в производственном коде. Это очень неожиданно.

Изменить: на всякий случай вы хотите увидеть что-то еще более уродливое... [особенно "()()[()=>{}]()" ]:

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()()[()=>{}]();
    }
}

Ответ 3

Вам просто нужно немного саморейтинга, и вы можете называть его столько раз, сколько хотите:

delegate Foo Foo();

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

Ответ 4

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

печатает

Hello World!
Hello World!

Это работает, потому что func() и Bar() возвращает делегат Action, который может быть вызван с использованием синтаксиса вызова функции.

Ответ 5

Что-то вроде:

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

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

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

Ответ 6

Если у вас есть функция, которая возвращает делегат, который вы обычно присоединяете к сигналу, но вы хотите просто сразу вызвать эту функцию, вы можете использовать этот синтаксис.