是否存在一种通用模式可以通过自动状态离开操作在 C# 中为对象提供表达式或状态生命周期？

Question

命令式应用程序中有四种基本的对象生命周期：

1. 表达式（临时）生命周期
2. 范围生命周期
3. 状态生命周期（事件之间）
4. 应用程序生命周期

c# 的设计没有 RAII 支持，后来添加了 using 语句作为提供自动化必要机制的一种手段作用域的生命周期。应用程序生命周期是托管应用程序范围，因为应用程序关闭与调用垃圾收集一样具有确定性。这使得表达式和状态生命周期无法通过任何自动确定性破坏的语言机制来处理。

C# 中是否有解决这些基本需求的通用模式？我确信这些针对常见需求的解决方案现在已经被解决了很多次，但是在网上查找，我找不到任何关于此的文章。

在 C++ 中，临时生命周期对象中的 dtor 用于为表达式提供代理或包装器，并且可以在各种用于修改表达式、临时更改流状态以及表达式模板等高级优化的习惯用法中找到。对于状态，常见的面向对象解决方案是使用状态模式，并将具有给定状态生命周期的对象作为成员放入状态对象中。通过这种方式，例如，如果屏幕上有一个给定状态的显示框，ctor 将显示该对象，而 dtor 将从显示系统中删除它。

当我在线搜索“表达式模板”或“状态模式”之类的内容时，我得到的结果不包括自动终结器调用。相反，我看到对清理状态的调用作为单独的函数调用留下（因此，如果您有一个显示对象的多个状态，如示例所示，您必须在每个状态中调用清理，而不是只编写一次清理代码在对象中，并且类似地记住每个状态的所有对象）。我看到将单个表达式分解为多个语句以合并临时变量的显式终结。

对于临时工，我通常倾向于

(/*expression that builds proxy at some point*/).Dispose();

支持多线解决方案。

对于最近的状态生命周期项目，我创建了以下类

namespace libAutoDisposable
{
    public class AutoDisposable
    {
        public void AutoDispose()
        {
            // use reflection to get the fields of this
            FieldInfo[] infos = GetType().GetFields();

            // loop through members
            foreach (FieldInfo info in infos)
            {
                // now try to call AutoDispose or Dispose on each member
                if (typeof(AutoDisposable).IsAssignableFrom(info.FieldType))
                {
                    // get the value object
                    AutoDisposable value = (AutoDisposable)info.GetValue(this);

                    // and invoke
                    value.AutoDispose();
                }
                else if (typeof(IDisposable).IsAssignableFrom(info.FieldType))
                {
                    // get the value object
                    IDisposable value = (IDisposable)info.GetValue(this);

                    // so invoke
                    value.Dispose();
                }
            }
        }
    }
}

，它将迭代状态对象的成员，并且当调用状态对象的 AutoDispose 时，所有需要终结的对象（即从 IDisposable 派生）将调用 Dispose。此外，我将其递归化以支持对象重用。这样就不需要在每个状态中编写清理代码，而是允许我的状态机在转换代码中调用一次 AutoDispose。

然而，这有很多缺点，包括：

• 使对象在遇到异常时未被回收
• 确定每次状态转换时在运行时调用的方法，而不是每个类（希望如此）运行时或（世界上最好的）翻译时调用一次。
• 基类反射方法是一种尽可能黑客/侵入性的代码。

我确信优秀的架构师已经在 C# 项目中工作过并且必须解决这些问题。哪些模式已经发展到可以自动破坏表达和状态生命周期？

---

编辑：我写了我的状态解决方案的缺点，但我忘记提及为什么我发现我倾向于使用的表达式或临时生命周期解决方案不令人满意。从域语言的角度来看，对代理上的 Dispose 的调用将表达式标识为具有代理。不过，通常情况下，代理的意义在于，有些表达式带有它们，有些则没有它们，并且表达式在某个时刻是否返回代理是一个实现细节。例如，您可能

mySerialisationStream.Serialise(obj1).Serialise(obj2);

会

mySerialisationStream.Serialise(specialFormatter).Serialise(obj1).Serialise(obj2);

插入一个特殊的格式化程序，该格式化程序持续 Serialise 调用行的长度，然后返回默认格式。必须添加 Dispose 调用意味着我知道一行何时具有特殊的格式化程序对象，尽管我可能会尝试一般性地执行操作。然后，当只有代理需要采取任何操作时，我要么必须重新设计以向 MySerializationStream 类添加一个不执行任何操作的 Dispose。随着我在表达式中使用的类型数量的增加，这会增加组合的复杂性。

Answer 1

您可以将 using 语句与代码块一起“包装”为函数调用中的 lambda 表达式，以实现 RAII 语义：

        var stringBuilder = new StringBuilder();
        var stream = new Stream(stringBuilder);

        stream
            .Serialize(1)
            .IsolateMemento(s=>new StreamMemento(s),s=>s
                .Serialize(new Formatter("formatted {0}"))
                .Serialize(2))
            .Serialize(3);

        Assert.AreEqual("1;formatted 2;3;", stringBuilder.ToString());

主要部分是以下扩展方法：

    public static class MementoExtensions
    {
        public static T IsolateMemento<T>(
            this T originator,
            Func<T, IDisposable> generateMemento,
            Func<T, T> map)
        {
            using (generateMemento(originator))
                return map(originator);
        }
    }

实现细节：

    public class Stream
    {
        public StringBuilder StringBuilder { get; set; }
        public Stream(StringBuilder stringBuilder) { StringBuilder = stringBuilder; }
        public Formatter Formatter = new Formatter("{0}");
        public Stream Serialize(object o)
        {
            var formatter = o as Formatter;
            if (formatter != null) Formatter = formatter;
            else StringBuilder.Append(Formatter.Format((o ?? "").ToString())).Append(";");
            return this;
        }
    }

    public class Formatter
    {
        public string FormatString { get; set; }
        public Formatter(string s) { FormatString = s; }
        public string Format(string s) { return string.Format(FormatString, s); }
    }

    public class StreamMemento : IDisposable
    {
        private Stream Originator { get; set; }
        private Formatter FormatterBefore { get; set; }
        public StreamMemento(Stream s) { Originator = s; FormatterBefore= s.Formatter; }
        public void Dispose() { Originator.Formatter = FormatterBefore; }
    }

更新：

如果您想使用装饰器，例如从 Serialize 返回装饰器方法，可以使用另一个扩展：

public static T DecoratedAction<T>(
                this T originator,
                Func<T,T> createDecorator,
                Action<T> act)
            {
                var decorated = createDecorator(originator);
                act(decorated);
                return originator;
            }

用法是：

stream.Serialize(obj1).DecoratedAction(s=>s.Serialize(formatter), s=>s.Serialize(obj2)).Serialize(obj3)

当 Serialize(formatter) 返回装饰代理 Stream 时，功能等同于：

stream.Serialize(obj1).DecoratedAction(s=>new FormattedStream(formatter,s), s=>s.Serialize(obj2)).Serialize(obj3)

请注意，装饰器和备忘录都是在 lambda 表达式中创建的，因为我不想要另一个该表达式中stream的入口 - 它必须能够对调用链中先前表达式的结果进行操作，这对于构建流畅的接口至关重要。

我在这里没有使用 using/IDisposable ，因为我假设装饰器并不意味着被确定性地处置。此外，如果返回代理或原始对象，这种方式并不重要。