C#瞬态依赖模式

我有以下情况。 SomeClass依赖于IDiagram，而图实现了该接口。SomeClass的生命周期就是应用程序的生命周期，但是图的生命周期更短。如果按下某个按钮，它可能会改变。 因为我在这个问题上找不到任何令人满意的东西，所以我提出了下图所示的模式

• 图表的观察者会意识到图表可以更改，并在更改时设置正确的实例
• 观察者将通过委托当前图表实例的方法来实现IDiagram接口
• 一些工厂会创建新的图表，并提出更改
• 有些人不会意识到这一点

实施这种模式是个好主意吗？有哪些缺点？这个问题有更好的解决办法吗

下面是使用IDependency而不是IDiagram的示例代码：

    private static void Main(string[] args)
    {
        var transientDependency = new TransientDependency();
        var dependencyObserver = new DependecyObserver(transientDependency);
        var dependencyFactory = new Factory(transientDependency);
        var someClass = new SomeClass(dependencyObserver);
        var someOtherClass = new SomeClass(dependencyObserver);

         // Note that someClass can only be used after the dependency has been created, because the Changed event has to be invoked
        dependencyFactory.CreateDependency();
    }

    public class DependecyObserver : IDependency
    {
        public DependecyObserver(TransientDependency transient)
        {
            transient.Changed += (s, dependency) => Dependency = dependency;
        }

        private Dependency Dependency { get; set; }

        public void SomeMethod()
        {
            Dependency.SomeMethod();
        }
    }

    public class Factory
    {
        private TransientDependency TransientDependency { get; }

        public Factory(TransientDependency transientDependency)
        {
            TransientDependency = transientDependency;
        }

        public void CreateDependency()
        {
            TransientDependency.RaiseChanged(new Dependency());
        }
    }

    public class SomeClass
    {
        public SomeClass(IDependency dependency)
        {
            dependency.SomeMethod();
        }
    }

    public class TransientDependency : TransientInstance<Dependency> { }

    public abstract class TransientInstance<T>
    {
        public EventHandler<T> Changed;

        public void RaiseChanged(T instance)
        {
            Changed?.Invoke(this, instance);
        }
    }

    public class Dependency : IDependency
    {
        public void SomeMethod()
        {
            throw new NotImplementedException();
        }
    }

    public interface IDependency
    {
        void SomeMethod();
    }

private static void Main（字符串[]args）
{
var transientDependency=新的transientDependency（）；
var dependencyObserver=新的dependencyObserver（瞬时依赖）；
var dependencyFactory=新工厂（暂时依赖）；
var someClass=新的someClass（dependencyObserver）；
var someOtherClass=新的SomeClass（dependencyObserver）；
//请注意，someClass只能在创建依赖项之后使用，因为必须调用已更改的事件
dependencyFactory.CreateDependency（）；
}
公共类依赖观察者：IDependency
{
公共依赖性观察者（暂时依赖性暂时）
{
暂时性改变+=（s，依赖性）=>依赖性=依赖性；
}
私有依赖项{get；set；}
公共方法（）
{
Dependency.SomeMethod（）；
}
}
公营工厂
{
私有TransientDependency TransientDependency{get；}
公共工厂（暂时依赖暂时依赖）
{
暂时依赖=暂时依赖；
}
公共void CreateDependency（）
{
TransientDependency.RaiseChanged（新依赖项（））；
}
}
公共类
{
公共类（IDependency依赖）
{
dependency.SomeMethod（）；
}
}
公共类TransientDependency:TransientInstance{}
公共抽象类瞬态
{
公共事件处理程序已更改；
公共无效提升更改（T实例）
{
已更改？.Invoke（此实例）；
}
}
公共类依赖：IDependency
{
公共方法（）
{
抛出新的NotImplementedException（）；
}
}
公共接口独立性
{
无效方法（）；
}

我不能100%确定您的每个类的生命周期和使用情况，也许我完全搞错了。。。如果

TransientDiagram

实际上是瞬态的，您的

SomeFactory

将在与

DiagramObserver

订阅的实例不同的实例上引发事件？或者，如果

DiagramObserver

和

SomeFactory

之间共享了

transientDiagramObserver

，为什么不将

DiagramObserver

传递到工厂，直接在那里设置实例，而不包含所有事件？没错，命名很混乱，因为TransientDiagram不是瞬态的，DiagramObserver和SomeFactory之间共享一个实例。虽然我不喜欢为依赖项创建setter（这会导致大量误用类），但这就是为什么我选择通过事件来实现这一点，因为我将所有依赖项都保留在构造函数中。然而，我看到了如何通过将DiagramObserver传递给某个工厂并在那里设置依赖项来更容易理解。我现在添加了一个全面的预期用途示例。