Отложенное выполнение в C#

Question

Как я могу реализовать свой собственный механизм отложенного выполнения на C#?

Так, например, у меня есть:

string x = DoFoo();

Можно ли сотворить какую-нибудь магию, чтобы DoFoo не выполнялся, пока я не «использую» x?

Answer 1

Вы можете использовать лямбды / делегаты:

Func<string> doit = () => DoFoo();
//  - or -
Func<string> doit = DoFoo;

Позже вы можете вызывать doit так же, как метод:

string x = doit();

<Ч>

Я думаю, что ближе всего вы можете получить что-то вроде этого:

Lazy<string> x = DoFoo;

string y = x; // "use" x

С определением Lazy < T > , похожим на это (не проверено):

public class Lazy<T>
{
    private readonly Func<T> func;
    private bool hasValue;
    private T value;

    public Lazy(Func<T> func)
    {
        this.func = func;
        this.hasValue = false;
    }

    public static implicit operator Lazy<T>(Func<T> func)
    {
        return new Lazy<T>(func);
    }

    public static implicit operator T(Lazy<T> lazy)
    {
        if (!lazy.hasValue)
        {
            lazy.value = lazy.func();
            lazy.hasValue = true;
        }
        return lazy.value;
    }
}

К сожалению, похоже, что алгоритмы вывода типов компилятора не могут автоматически определить тип Func < T > и поэтому не могут сопоставить его с оператором неявного преобразования. Нам нужно явно объявить тип делегата, что делает операторы присваивания более подробными:

// none of these will compile...
Lazy<string> x = DoFoo;
Lazy<string> y = () => DoFoo();
Lazy<string> z = delegate() { return DoFoo(); };

// these all work...
Lazy<string> a = (Func<string>)DoFoo;
Lazy<string> b = (Func<string>)(() => DoFoo());
Lazy<string> c = new Func<string>(DoFoo);
Lazy<string> d = new Func<string>(() => DoFoo());
Lazy<string> e = new Lazy<string>(DoFoo);
Lazy<string> f = new Lazy<string>(() => DoFoo);

Answer 2

Один из вариантов — использовать Lazy<T> класс, ранее входивший в библиотеку параллельных расширений, теперь являющийся частью .Net Framework 4.0.

• Ссылка: http://msdn.microsoft.com/en-us/library/dd642331(VS.100).aspx

Это позволяет задерживать данные процесса с учетом потоков.

Answer 3

Хотя он несколько грязный, вы всегда можете использовать ключевое слово yield:

public IEnumerable<int> DoFoo() {
   Console.WriteLine("doing foo");
   yield return 10;
}

[Test]
public void TestMethod()
{
    var x = DoFoo();
    Console.WriteLine("foo aquired?");
    Console.WriteLine(x.First());
}

Answer 4

Вместо передачи строки x передайте делегат, который доставит вам строку

Func<String> fooFunc=()=>DoFoo();

Answer 5

Почему бы просто не вызывать DoFoo (), пока вы этого не захотите?

- Изменить

Я имею в виду, что ты имеешь в виду " использовать "

Например, если вы хотите, чтобы он вызывался при вызове '.ToString ()', вы всегда можете унаследовать класс и реализовать там свою функцию (но это было бы совершенно не интуитивно понятно ИМХО).

Answer 6

Вы в значительной степени описываете LINQ в действии. Запрос linq описывает, как получить данные, но данные извлекаются (вызывается DoFunc) только тогда, когда запрос повторяется. Подумайте, можете ли вы изменить свой дизайн, чтобы он принимал IQueryable < строка > , где вам нужна строка .