基础/后代类分辨率的策略和工厂模式

问题描述 投票：0回答：1

我正在重构一个代码库，偶然发现了一个工厂类，它根据传递给方法的子类型创建了对象。

该类基本上有一个公共方法，其中一个参数是基类的后代。在此方法中有一个switch语句，它确定传递哪个子类型并有条件地调用不同的方法来生成结果。

我试图整理一下，并认为策略模式可能符合要求，因为代码违反了开放封闭原则。

自从Autofac被使用以来，我认为过渡是直截了当的，但是我已经遇到了一个障碍。

问题与Autofac无关，而是与设计的选择有关。

以下代码说明了类的组成，但缺乏。

public abstract class Parent { }
public class ChildA : Parent { }
public class ChildB : Parent { }

public interface IChildStrategy<T> where T:Parent
{
    IEnumerable<object> CreateObjects(Parent child);
}

public class ChildAStrategy : IChildStrategy<ChildA>
{
    private IEnumerable<object> CreateObjects(ChildA child)
    {
        yield return "child A";
    }

    public IEnumerable<object> CreateObjects(Parent child) => 
        CreateObjects(child as ChildA);
}

public class ChildBStrategy : IChildStrategy<ChildB>
{
    private IEnumerable<object> CreateObjects(ChildB child)
    {
        yield return "child b";
        yield return "child b's pet";
    }

    public IEnumerable<object> CreateObjects(Parent child) =>
        CreateObjects(child as ChildB);         
}

[TestMethod]
public void TestStrategyPattern()
{
    var container = builder.Build();

    Parent child = new ChildA();
    var type = child.GetType();
    var strategy = container.Resolve(typeof(IChildStrategy<>)
        .MakeGenericType(type));

    // strategy.CreateObjects(child);
    // Assert.AreEqual("child A", fromDict);

    var dict = new Dictionary<Type, Func<Parent, IEnumerable<object>>>();

    dict.Add(typeof(ChildA), x => new ChildAStrategy().CreateObjects(x));
    dict.Add(typeof(ChildB), x => new ChildBStrategy().CreateObjects(x));

    var fromDict = dict[type](child);

    Assert.AreEqual("child A", fromDict);
}

我已经尝试过使用泛型类型注册接口，如下所示：

public interface IChildStrategy<T> where T:Parent
{
    IEnumerable<object> CreateObjects(T child);
}

但它并没有真正改变困难。

对于子类的设计模式有什么好的替代方案吗？

Updated

这就是我最终的结果。这些更改基本上是从CreateObjects方法中删除参数，而是将其作为依赖项注入构造函数，并将策略注册为Keyed<T>注册。

public abstract class Parent { }
public class ChildA : Parent { }
public class ChildB : Parent { }

public interface IChildStrategy
{
    IEnumerable<object> CreateObjects();
}

public class ChildAStrategy : IChildStrategy
{
    private readonly ChildA childA;

    public ChildAStrategy(ChildA childA)
    {
        this.childA = childA;
    }

    public IEnumerable<object> CreateObjects()
    {
        yield return childA;
    }
}

public class ChildBStrategy : IChildStrategy
{
    private readonly ChildB childB;

    public ChildBStrategy(ChildB childB)
    {
        this.childB = childB;
    }

    public IEnumerable<object> CreateObjects()
    {
        yield return childB;
        yield return "child b's pet";
    }
}

[TestMethod]
public void TestStrategyPattern()
{
    var builder = new ContainerBuilder();
    builder.RegisterType<ChildAStrategy>().Keyed<IChildStrategy>(typeof(ChildA));
    builder.RegisterType<ChildBStrategy>().Keyed<IChildStrategy>(typeof(ChildB));

    var container = builder.Build();

    IChildStrategy resolve(Parent x) => container.ResolveKeyed<IChildStrategy>(x.GetType(), new TypedParameter(x.GetType(), x));

    Parent root;
    IChildStrategy strategy;
    root = new ChildA();
    strategy = resolve(root);
    Assert.IsInstanceOfType(strategy, typeof(ChildAStrategy));
    Assert.AreSame(root, strategy.CreateObjects().Single());
    root = new ChildB();
    strategy = resolve(root);
    Assert.IsInstanceOfType(strategy, typeof(ChildBStrategy));
    Assert.AreSame(root, strategy.CreateObjects().First());
    Assert.AreEqual("child b's pet", strategy.CreateObjects().Last());
}
c# autofac strategy-pattern factory-method
1个回答
0
投票

Updated Answer

原始答案包含在下面

我认为你正在寻找的模式是Mediator。

根据我的理解，这是一个符合您需求的示例实现。这种实现加强了处理程序的类型，但在调解器本身中更加使用dynamic。如果性能是一个问题，你可能想要运行一些测试 - 这个实现可能比你现有的代码慢（参见：How does having a dynamic variable affect performance?）

using System.Collections.Generic;
using System.Linq;
using Autofac;
using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace _54542354.MediatorExample
{
    /**
     * Example Input/Output types
     **/
    abstract class ActionBase { }
    class ExampleAction : ActionBase { public string Name { get; set; } }
    class ReturnType { public string Id { get; set; } }

    /**
     * Interfaces
     **/
    interface IActionHandler<TAction> where TAction : ActionBase
    {
        IEnumerable<ReturnType> Handle(TAction action);
    }

    interface IActionHandlerMediator
    {
        IEnumerable<ReturnType> Handle(ActionBase action);
    }

    /**
     * Example implementations
     **/
    class ExampleHandler : IActionHandler<ExampleAction>
    {
        public IEnumerable<ReturnType> Handle(ExampleAction action)
        {
            yield return new ReturnType{ Id = $"{action.Name}_First" };
            yield return new ReturnType{ Id = $"{action.Name}_Second" };
        }
    }

    class ActionHandlerMediator : IActionHandlerMediator
    {
        readonly ILifetimeScope container;

        public ActionHandlerMediator(ILifetimeScope container)
            => this.container = container;

        public IEnumerable<ReturnType> Handle(ActionBase action)
        {
            // TODO: Error handling. What if no strategy is registered for the provided type?
            dynamic handler = container.Resolve(typeof(IActionHandler<>)
                .MakeGenericType(action.GetType()));

            return (IEnumerable<ReturnType>)handler.Handle((dynamic)action);
        }
    }

    /**
     * Usage example
     **/
    [TestClass]
    public class Tests
    {
        [TestMethod]
        public void TestMediator()
        {
            var builder = new ContainerBuilder();
            builder.RegisterType<ExampleHandler>().As<IActionHandler<ExampleAction>>();
            builder.RegisterType<ActionHandlerMediator>().As<IActionHandlerMediator>();
            var container = builder.Build();

            var handler = container.Resolve<IActionHandlerMediator>();

            var result = handler.Handle(new ExampleAction() { Name = "MyName" });

            Assert.AreEqual("MyName_First", result.First().Id);
            Assert.AreEqual("MyName_Second", result.Last().Id);
        }
    }
}

Original Answer

我试着运行你的示例代码。我不得不调整一些开箱即用的东西，但我认为它实际上是按照你想要的方式（在我的调整之后）。

这是我最终得到的：

[TestMethod]
public void TestStrategyPattern_Dict()
{
    // Define the available strategies
    var dict = new Dictionary<Type, Func<Parent, IEnumerable<object>>>();
    dict.Add(typeof(ChildA), x => new ChildAStrategy().CreateObjects(x));
    dict.Add(typeof(ChildB), x => new ChildBStrategy().CreateObjects(x));

    // Create the input object
    Parent child = new ChildA();

    // Invoke the strategy
    IEnumerable<object> enumerable = dict[child.GetType()](child);

    // Verify the results
    Assert.AreEqual("child A", enumerable.Single());
}

[TestMethod]
public void TestStrategyPattern_AutoFac()
{
    // Define the available strategies
    var builder = new ContainerBuilder();
    builder.RegisterType<ChildAStrategy>().As<IChildStrategy<ChildA>>();
    builder.RegisterType<ChildBStrategy>().As<IChildStrategy<ChildB>>();
    var container = builder.Build();

    // Create the input object
    Parent child = new ChildA();

    // Resolve the strategy
    // Because we don't know exactly what type the container will return,
    // we need to use `dynamic`
    dynamic strategy = container.Resolve(typeof(IChildStrategy<>)
        .MakeGenericType(child.GetType()));

    // Invoke the strategy
    IEnumerable<object> enumerable = strategy.CreateObjects(child);

    // Verify the results
    Assert.AreEqual("child A", enumerable.Single());
}

这些测试都通过了。我没有更改测试之外的任何代码。

我介绍的两个主要变化是：

  • 在断言之前使用.Single()。这是必要的，因为策略返回IEnumerable，但断言期望可枚举的第一个对象。
  • 从AutoFac解析策略时使用dynamic类型。这是必要的，因为编译器无法判断AutoFac将返回什么类型。在原始代码中，返回的类型是object，它没有CreateObjects(Parent)方法。 dynamic让我们调用我们想要的任何方法 - 编译器只会认为它存在。如果方法不存在，我们将得到运行时异常，但因为我们知道我们刚刚创建了IChildStrategy<>，所以我们可以确信该方法将存在。
最新问题
© www.soinside.com 2019 - 2024. All rights reserved.