Сериализирующие анонимные делегаты в C#

Некоторые объекты должны выполнить произвольные "события", достигающие некоторого условия.

, насколько произвольный эти события? Они могут считаться, присвоенный идентификатор и отображаться на соотносимо?

public class Command<T> where T : ISerializable
{
  T _target;
  int _actionId;
  int _conditionId;

  public Command<T>(T Target, int ActionId, int ConditionId)
  {
    _target = Target;
    _actionId = ActionId;
    _conditionId = ConditionId;
  }

  public bool FireRule()
  {
    Func<T, bool> theCondition = conditionMap.LookupCondition<T>(_conditionId)
    Action<T> theAction = actionMap.LookupAction<T>(_actionId);

    if (theCondition(_target))
    {
      theAction(_target);
      return true;
    }
    return false;
  }  
}

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

, Что точно это, Вы хотите к , делают с сериализированным делегатом? Я действительно не думаю, что это - хорошая идея...

, Так как это состояние локально, хотя это приводит к проблемам при попытке установить отображение.

разве локальное состояние не представило бы те же самые проблемы для сериализации?

предположим компилятор и платформа позволили этому работать:

Other o = FromSomeWhere();
Thing t = OtherPlace();
target.OnWhatever = () => t.DoFoo() + o.DoBar();
target.Save();

я предполагаю t, и o должен был быть сериализирован также. Методы не имеют состояния, экземпляры делают.

Позже, Вы десериализовываете цель. Разве Вы не получаете новые копии t и o? Разве эти копии не будут вне синхронизации ни с какими изменениями в оригинале t и o?

Также: разве Ваш ручной пример нельзя было назвать этим путем?

Other o = FromSomeWhere();
Thing t = OtherPlace();
target.OnWhatever = new DoFooBar() {Other = o, Thing = t} .Run;
target.Save();

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

Это - то, что компилятор C# делает автоматически для меня с анонимными функциями. Моей проблемой является сериализация этих классов компилятора.

        Other o = FromSomeWhere();
        Thing t = OtherPlace();
        target.OnWhatever = () => t.DoFoo() + o.DoBar();
        target.Save();c

Попытка сериализировать, который перестал бы работать. Так как это состояние локально, хотя это приводит к проблемам при попытке установить отображение. Вместо этого я должен был бы объявить что-то вроде этого:

[Serializable]
abstract class Command<T>
{
    public abstract T Run();
}

class DoFooBar : Command<int>
{
    public Other Other { get; set; }
    public Thing Thing { get; set; }

    public override int Run()
    {
        return Thing.DoFoo() + Other.DoBar(); 
    }
}

и затем используют его как это:

        DoFooBar cmd = new DoFooBar();
        cmd.Other = FromSomewhere();
        cmd.Thing = OtherPlace();

        target.OnWhatever = cmd.Run;

        target.Save();

По существу то, что это означает, делает вручную, что компилятор C# делает для меня автоматически.

Я не уверен на 100% в этом, но я считаю, что если вы хотите «сохранить» делегата или некоторый код в базе данных, который может быть довольно динамичным, вам нужно создать Expression, то вы можете скомпилировать выражение в Func <...>.

Основы дерева выражений

Вызовы с поздним связыванием с деревьями выражений