当前位置：首页 > 开发教程 > IT博文 > .NET技术 > C# >

C＃不好的做法：了解如何通过坏榜样的好代码 - 第2部分

时间：2016-06-01 09:35 来源：互联网作者：源码搜藏收藏

介绍大家好！这篇文章是我以前的文章的延续： C＃不好的做法：了解如何通过坏榜样的好代码我强烈建议阅读它之前，你会开始阅读这一个（我将把它很多次）。正如我注意到，很多人发现我的第一篇文章有帮助我决定写它的第二部分。所以..只是简要地回顾一下

介绍

大家好！这篇文章是我以前的文章的延续：

C＃不好的做法：了解如何通过坏榜样的好代码

我强烈建议阅读它之前，你会开始阅读这一个（我将把它很多次）。

正如我注意到，很多人发现我的第一篇文章有帮助我决定写它的第二部分。

所以..只是简要地回顾一下我的第一篇文章是关于。我发现有可应用的代码，使之成为一些技巧：

更可读
更好的维护
可扩展

我已经表明，它在一个极其简单的方法 - 避免在文章吨行代码放置（许多人 - 请参阅意见 - 没有得到文章的想法，他们认为我试图重构极度简化方法用几行代码），因为我相信这会令文章完全不可读。

所以，总结一下我展示了如何使用一些技巧和设计模式，可以从该公司的生活让你和你的同事更容易，当你有实现复杂的应用程序，这有可能扩大，并保持很长一段时间。

我发现它其中介绍实现真实世界特性的一个简单的例子 - 折扣计算器。

本文的目标

C＃不好的做法：了解如何通过坏榜样的好代码 - 第2部分

在前面的文章中，我已经结束了一个清洁，维护的解决方案。

然而，由于许多聪明人注意到，开关情况声明在下面的工厂：

隐藏复制代码

public class DefaultAccountDiscountCalculatorFactory : IAccountDiscountCalculatorFactory
{
  public IAccountDiscountCalculator GetAccountDiscountCalculator(AccountStatus accountStatus)
  {
    IAccountDiscountCalculator calculator;
    switch (accountStatus)
    {
      case AccountStatus.NotRegistered:
        calculator = new NotRegisteredDiscountCalculator();
        break;
      case AccountStatus.SimpleCustomer:
        calculator = new SimpleCustomerDiscountCalculator();
        break;
      case AccountStatus.ValuableCustomer:
        calculator = new ValuableCustomerDiscountCalculator();
        break;
      case AccountStatus.MostValuableCustomer:
        calculator = new MostValuableCustomerDiscountCalculator();
        break;
      default:
        throw new NotImplementedException();
    }
 
    return calculator;
  }
}

仍然违反打开/关闭原则。他们提出了一些非常好的解决方案。我完全同意这一点，并在写入前一篇文章中，我打算写下一个将展示如何解决这个问题。

上一篇文章很长，我决定把它单独的一个作为这个话题是非常复杂的，有实施的几种方法。

所以总结起来，我将在本文中专注于我们的抽象工厂摆脱的switch-case语句。

正如在我看来，没有一个灵丹妙药来解决这个问题，每一个情况下，我决定实施展示了几个版本，并描述每个优点和缺点。

工厂代码将在这篇文章中我们的基本代码。

感谢给我们HID（在以前的文章）实施背后的抽象（接口）工厂的事实：

隐藏复制代码

public interface IAccountDiscountCalculatorFactory
{
  IAccountDiscountCalculator GetAccountDiscountCalculator(AccountStatus accountStatus);
}

我们将能够切换到一个新的实现的工厂不触及任何其他类。

我们将只需要注入不同实施的IAccountDiscountCalculatorFactory 接口进入DiscountManager 如果需要类或另一呼叫者。

是不是“编程接口”的方式极大的 !! 当然如此！

C＃不好的做法：了解如何通过坏榜样的好代码 - 第2部分

开关情况VS字典模式

为什么的switch-case或多个的if-else如果语句是一个坏主意。

嗯..让我们来看看下面的工厂：

隐藏复制代码

public class DefaultAccountDiscountCalculatorFactory : IAccountDiscountCalculatorFactory
{
  public IAccountDiscountCalculator GetAccountDiscountCalculator(AccountStatus accountStatus)
  {
    IAccountDiscountCalculator calculator;
    switch (accountStatus)
    {
      case AccountStatus.NotRegistered:
        calculator = new NotRegisteredDiscountCalculator();
        break;
      case AccountStatus.SimpleCustomer:
        calculator = new SimpleCustomerDiscountCalculator();
        break;
      case AccountStatus.ValuableCustomer:
        calculator = new ValuableCustomerDiscountCalculator();
        break;
      case AccountStatus.MostValuableCustomer:
        calculator = new MostValuableCustomerDiscountCalculator();
        break;
      default:
        throw new NotImplementedException();
    }
 
    return calculator;
  }
}

我们现在有4个帐户状态。现在想象一下，我们公司正在计划增加更多。

第一个问题

这意味着，每一次我们将增加一个支持新的状态，我们必须修改我们的工厂，通过添加新的案例块。这意味着，每一个变化都可能引入的错误在我们的阶级或能打破现有的单元测试。

第二个问题

我厂还紧密结合的具体实现-它违反了控制反转原则。我们将不能够取代的例如一个实现SimpleCustomerDiscountCalculator与ExtendedSimpleCustomerDiscountCalculator没有工厂改装。

更有力的例子

我们可以想象的情况下，这些问题将得到更好的可见。如果我们将有一个巨大的switch-case语句和每一个案例块将返回一个包含一个特定的业务逻辑，对于给定的国家，我们可以想像，我们的类的实例的switch-case语句，我们将要处理的每个时间延长（存在于全球大约200个国家的）一个新的。一段时间后，我们的switch-case语句将是巨大且无法读取。会有添加同一国家两次等的危险。

了解对象的生命周期

C＃不好的做法：了解如何通过坏榜样的好代码 - 第2部分

之前，我将开始展示我们的问题的解决方案我想说这是我们将要创建的对象的生命周期中的几句话。

在实施真实世界的解决方案，我们总是要考虑每一个对象的生命周期应该怎么看起来像相对于整个应用程序。

由于我们不需要厂家的多个实例（一个实例可以返回对象为每个线程的每个调用），我们应该创建每个应用程序仅其中的一个实例。

我们可以通过IOC容器实现它和的方式，来我厂每次调用会返回相同的对象进行配置。对于一个实例，如果我们使用的是AutoFac库，它的配置看起来如下：

隐藏复制代码

var builder = new ContainerBuilder();
builder.RegisterType<DefaultAccountDiscountCalculatorFactory>().As<IAccountDiscountCalculatorFactory>().SingleInstance();

如果我们注入依赖手工，我们必须在应用程序根目录一旦创建一个实例，并注入相同的实例将会使用它的每一个组成部分。通过应用程序根我的意思是，例如主要的的情况下，方法控制台应用程序。

在我们的计算器实现如案例：

NotRegisteredDiscountCalculator
SimpleCustomerDiscountCalculator
等等

答案并不明显。

C＃不好的做法：了解如何通过坏榜样的好代码 - 第2部分

有可能是管理它的方法有两种：

我们希望我们的工厂返回 THE SAME实例IAccountDiscountCalculator实施每一个电话
我们希望我们的工厂返回 一个新的实例IAccountDiscountCalculator实现每个呼叫

隐藏复制代码

public class SimpleCustomerDiscountCalculator : IAccountDiscountCalculator
{
  private readonly IUser _user;
 
  public SetUser(IUser user)
  {
    _user = user;
  }
 
  public decimal ApplyDiscount(decimal price)
  {
  //business logic which is using _user field
  }
}

在上面的类我们国家是一个字段：_user

如果我们要实现多线程应用程序像ASP MVC项目，我们不能用上面类的一个实例每次呼叫。每个线程将要使用SimpleCustomerDiscountCalculator类在不同的用户进行操作。因此，我们需要返回的新实例SimpleCustomerDiscountCalculator类每次调用工厂。

我归纳我的解决方案分为两类：

工厂返回 THE SAME类的实例每次调用
工厂返回 一个新的类的实例每次调用

有用的字典

在所有建议的解决方案，下面我将使用C＃字典类。不过，我会在不同的变体使用它。

C＃不好的做法：了解如何通过坏榜样的好代码 - 第2部分

现在，让我们去具体实现..

C＃不好的做法：了解如何通过坏榜样的好代码 - 第2部分

每次调用同一个实例

在本组的解决方案，每次调用工厂的具体实施IAccountDiscountCalculator了一个实例：

隐藏复制代码

_factory.GetAccountDiscountCalculator(AccountStatus.SimpleCustomer);

将返回相同的对象。

基本版本

我的解决方案的第一个版本提供了一个简单的工厂：

隐藏复制代码

public class DictionarableAccountDiscountCalculatorFactory : IAccountDiscountCalculatorFactory
{
    private readonly Dictionary<AccountStatus, IAccountDiscountCalculator> _discountsDictionary;
    public DictionarableAccountDiscountCalculatorFactory(Dictionary<AccountStatus, IAccountDiscountCalculator> discountsDictionary)
    {
        _discountsDictionary = discountsDictionary;
    }

    public IAccountDiscountCalculator GetAccountDiscountCalculator(AccountStatus accountStatus)
    {
        IAccountDiscountCalculator calculator;

        if (!_discountsDictionary.TryGetValue(accountStatus, out calculator))
        {
            throw new NotImplementedException("There is no implementation of IAccountDiscountCalculatorFactory interface for given Account Status");
        }

        return calculator;
    }
}

上述工厂中包含的对象字典（计算器-的的实现IAccountDiscountCalculator接口）。这是出厂的配置。

当我们将要获得从工厂对象将返回我们分配到一个实现AccountStatus枚举值。

为了使它的工作，我们要配置这个工厂创建的同时。正如我之前提到的，我们只需要一个单一的实例，我们将创建应用程序根这种情况下（如果我们想手动注入），或者在创建IoC容器。

因此，虽然创造我们的工厂，我们需要创建一个配置（分配给每个执行一个选定的AccountStatus）：

隐藏复制代码

var discountsDictionary = new Dictionary<AccountStatus, IAccountDiscountCalculator>
      {
        {AccountStatus.NotRegistered, new NotRegisteredDiscountCalculator()},
        {AccountStatus.SimpleCustomer, new SimpleCustomerDiscountCalculator()},
        {AccountStatus.ValuableCustomer, new ValuableCustomerDiscountCalculator()},
        {AccountStatus.MostValuableCustomer, new MostValuableCustomerDiscountCalculator()}
      };

并把它注射进厂：

手动：

隐藏复制代码

var factory = new DictionarableAccountDiscountCalculatorFactory(discountsDictionary);

或使用IOC容器（在这个例子中，我使用- AutoFac库），这里是负责我们出厂配置的一部分：

隐藏复制代码

var builder = new ContainerBuilder();
builder.RegisterType<DictionarableAccountDiscountCalculatorFactory>().As<IAccountDiscountCalculatorFactory>()
.WithParameter("discountsDictionary", discountsDictionary)
.SingleInstance();

现在，我们可以像以前一样使用我们的工厂，注入到呼叫者，以相同的方式（参见前文）：

隐藏复制代码

priceAfterDiscount = _factory.GetAccountDiscountCalculator(accountStatus).ApplyDiscount(price);

优点：

这很简单
强类型的配置-配置（错误的错误类型定义）将导致错误在编译时
从工厂返回一个对象是非常快的 - 他们已经创建

缺点：

会不会在多线程环境中工作时，返回的对象有一个状态

在我看来，这是我们正在考虑的要素最合适的版本- 简单的打折计算器例子。

不过，我想展示我们如何能够处理不同的情况下...

懒人版

C＃不好的做法：了解如何通过坏榜样的好代码 - 第2部分

现在想象一下，我们的计算器的创作是非常昂贵的。你完全可以装载沉重的文件，然后保存在内存中。但是...我们需要只用一个计算器应用程序实例...

这怎么可能呢？例如，每个用户运行的单独的实例Windows窗体应用程序，并与一个特定的帐户状态的客户进行折扣计算。比方说，玛丽在执行计算简单的客户和Ted是在执行计算最有价值的客户。然后将不会有必要在每个应用实例来创建所有计算器。

要解决这个问题，我们可以通过提高我们的工厂懒惰型C＃它实现延迟加载模式。

C＃不好的做法：了解如何通过坏榜样的好代码 - 第2部分

懒惰的类型是引入.NET Framework 4的版本。如果您正在使用旧版本的.NET Framework，你必须手动实现延迟加载。

本厂实施现在看起来如下：

隐藏复制代码

public class DictionarableLazyAccountDiscountCalculatorFactory : IAccountDiscountCalculatorFactory
{
    private readonly Dictionary<AccountStatus, Lazy<IAccountDiscountCalculator>> _discountsDictionary;
    public DictionarableLazyAccountDiscountCalculatorFactory(Dictionary<AccountStatus, Lazy<IAccountDiscountCalculator>> discountsDictionary)
    {
        _discountsDictionary = discountsDictionary;
    }

    public IAccountDiscountCalculator GetAccountDiscountCalculator(AccountStatus accountStatus)
    {
        Lazy<IAccountDiscountCalculator> calculator;

        if (!_discountsDictionary.TryGetValue(accountStatus, out calculator))
        {
            throw new NotImplementedException("There is no implementation of IAccountDiscountCalculatorFactory interface for given Account Status");
        }

        return calculator.Value;
    }
}

出厂配置将改变一点点，以及：

隐藏复制代码

var lazyDiscountsDictionary = new Dictionary<AccountStatus, Lazy<IAccountDiscountCalculator>>
  {
    {AccountStatus.NotRegistered, new Lazy<IAccountDiscountCalculator>(() => new NotRegisteredDiscountCalculator()) },
    {AccountStatus.SimpleCustomer, new Lazy<IAccountDiscountCalculator>(() => new SimpleCustomerDiscountCalculator())},
    {AccountStatus.ValuableCustomer, new Lazy<IAccountDiscountCalculator>(() => new ValuableCustomerDiscountCalculator())},
    {AccountStatus.MostValuableCustomer, new Lazy<IAccountDiscountCalculator>(() => new MostValuableCustomerDiscountCalculator())}
  };
var factory = new DictionarableLazyAccountDiscountCalculatorFactory(lazyDiscountsDictionary);

几句什么，我们在这里做..
我懒惰的工厂现在的构造函数作为参数字典<AccountStatus，懒惰<IAccountDiscountCalculator >>键入并将其存储在私有字段。
词典现在将使用懒IAccountDiscountCalculator实现所以在创建lazyDiscountsDictionary（出厂配置）来设置我使用下面的语法每个项目的价值： C＃不好的做法：了解如何通过坏榜样的好代码 - 第2部分

隐藏复制代码

new Lazy<IAccountDiscountCalculator>(() => new NotRegisteredDiscountCalculator())

我们正在使用的构造 懒惰的类，它接受一个 Func键委托作为参数。当我们将试图访问值存储在我们的字典值N（财产懒惰首次类型），这代表将被执行，具体执行计算器将创建。

其余的将相同看作为第一个例子。

现在它的第一个请求会被执行后的具体执行计算器将创建。接下来的每一个要求相同的实现将返回相同的（而在第一次调用创建）对象。

需要注意的是，我们还没有更改接口IAccountDiscountCalculator。因此，我们可以以同样的方式作为用于基本版本中使用它的调用者类。

隐藏复制代码

priceAfterDiscount = _factory.GetAccountDiscountCalculator(accountStatus).ApplyDiscount(price);

C＃不好的做法：了解如何通过坏榜样的好代码 - 第2部分重要的是，你应该决定，如果你真的需要使用延迟加载。有时，基本版本可能会更好 - 例如，当您可以接受的情况时，应用程序启动将需要更多的时间和你不想耽误从工厂返回一个对象。

优点：

更快的应用程序启动
不保留对象在内存中，直到你真的需要它
强类型的配置-配置（错误的错误类型定义）将导致错误在编译时

缺点：

从工厂第一个对象的回报速度会变慢
会不会在多线程环境中工作时，返回的对象有一个状态

代码外配置

如果您需要或希望保持出厂（实施枚举值的分配）的代码库之外的配置 - 这个版本会适合你。

我们可以存储在数据库表或任何适合我们更好的配置文件中的配置。

我来举一个例子，当配置存储在数据库中的表，我将使用实体框架代码首先从数据库中获取此配置，并将其注入到工厂。

本厂实施现在看起来如下：

隐藏缩小

复制代码

public class ConfigurableAccountDiscountCalculatorFactory : IAccountDiscountCalculatorFactory
{
    private readonly Dictionary<AccountStatus, IAccountDiscountCalculator> _discountsDictionary;
    public ConfigurableAccountDiscountCalculatorFactory(Dictionary<AccountStatus, string> discountsDictionary)
    {
        _discountsDictionary = ConvertStringsDictToObjectsDict(discountsDictionary);
    }

    public IAccountDiscountCalculator GetAccountDiscountCalculator(AccountStatus accountStatus)
    {
        IAccountDiscountCalculator calculator;

        if (!_discountsDictionary.TryGetValue(accountStatus, out calculator))
        {
            throw new NotImplementedException("There is no implementation of IAccountDiscountCalculatorFactory interface for given Account Status");
        }

        return calculator;
    }

    private Dictionary<AccountStatus, IAccountDiscountCalculator> ConvertStringsDictToObjectsDict(
        Dictionary<AccountStatus, string> dict)
    {
        return dict.ToDictionary(x => x.Key,
            x => (IAccountDiscountCalculator)Activator.CreateInstance(Type.GetType(x.Value)));                
    }
}

你可以看到工厂的构造函数现在只需字符串值的字典作为参数：

隐藏复制代码

Dictionary<AccountStatus,string>

并将其转换为一个字典IAccountDiscountCalculator实现：

隐藏复制代码

Dictionary<AccountStatus,IAccountDiscountCalculator>

使用私有方法：

隐藏复制代码

private Dictionary<AccountStatus, IAccountDiscountCalculator> ConvertStringsDictToObjectsDict(
    Dictionary<AccountStatus, string> dict)
{
    return dict.ToDictionary(x => x.Key,
        x => (IAccountDiscountCalculator)Activator.CreateInstance(Type.GetType(x.Value)));                
}

我们存储在数据库表中的配置将是这样的：

C＃不好的做法：了解如何通过坏榜样的好代码 - 第2部分

字符串值公约是继下面的模式：

[命名空间]。[类名]，[的AssemblyName]

请注意，我把帐户状态的整数值显然是数据库不支持枚举值。

您还可以将您的配置在配置文件（使用相同的符号）。

现在，我们需要使用数据库配置来创建我们的工厂：

隐藏复制代码

var discountsDictionary = _repository.GetDiscountCalculatorConfiguration();
 
var factory = new ConfigurableAccountDiscountCalculatorFactory(discountsDictionary);

其中GetDiscountCalculatorConfiguration在我的仓库类方法看起来如下：

隐藏复制代码

public Dictionary<AccountStatus, string> GetDiscountCalculatorConfiguration()
{
    return _context.DiscountCalculatorConfigurationItems.ToDictionary(x => x.AccountStatus, x => x.Implementation);
}

该DiscountCalculatorConfigurationItem POCO类看起来如下：

隐藏复制代码

public class DiscountCalculatorConfigurationItem
{
    [Key]
    public AccountStatus AccountStatus { get; set; }
    public string Implementation { get; set; }
}

重要的是，我没有直接映射整数从数据库中值的枚举类型！实体框架会为我做！是不是很大？它是！

C＃不好的做法：了解如何通过坏榜样的好代码 - 第2部分

注意的EntityFramework支持枚举从版本5！

如果你不使用下5版（老EF 英孚，ADO.NET，从读取配置文件），你必须映射整数到枚举值的每个项目。然而这是一个非常简单的转换：

隐藏复制代码

(YourEnum)yourIntVariable

我会做在工厂的私有方法：

ConvertStringsDictToObjectsDict

而输入字典转换为私有的。

请注意，我们仍然以相同的方式如之前使用我们的工厂中的呼叫者。

C＃不好的做法：了解如何通过坏榜样的好代码 - 第2部分重要信息：即使有也不会配置计算器的实现应用程序将打破时，你会尝试创建工厂的构造函数试图实例所有的计算器。
所以，你不能，如果运行应用程序有您的配置的错误。

当这种方法可能是有用的？看看我们的例子。

试想一下，我们已经排队系统。我们将消息发送到队列。消息包含足够的信息来计算折扣（别人之间帐户状态）。我们也有这订阅队列中，得到一个消息，并计算折扣部分。

我们已经在我们系统中的下列帐户状态：

隐藏复制代码

public enum AccountStatus
{
  NotRegistered = 1,
  SimpleCustomer = 2,
  ValuableCustomer = 3,
  MostValuableCustomer = 4,
  SimpleCustomerExtended = 5,
  ValuableCustomerExtended = 6,
  MostValuableCustomerExtended = 7
}

我们也有4个实现IAccountDiscountCalculator接口：

NotRegisteredDiscountCalculator
SimpleCustomerDiscountCalculator
ValuableCustomerDiscountCalculator
MostValuableCustomerDiscountCalculator

要求是，我们的信息（帐户状态），首先应该由计算器如下处理：

NotRegistered - NotRegisteredDiscountCalculator
SimpleCustomer - SimpleCustomerDiscountCalculator
ValuableCustomer - ValuableCustomerDiscountCalculator
MostValuableCustomer - MostValuableCustomerDiscountCalculator

但一段时间后，我们将需要逐步添加下一状态支持：迭代1： SimpleCustomerExtended - SimpleCustomerDiscountCalculator 迭代2： ValuableCustomerExtended - ValuableCustomerDiscountCalculator迭代3： MostValuableCustomerExtended - MostValuableCustomerDiscountCalculator

部署过程非常耗时的，因为生产服务器在几个节点上运行。我们不希望在每个迭代修改应用程序的代码库。

如果我们将有代码之外的出厂配置，我们只需要更改数据库表或配置文件，然后重新启动该服务。现在由一个增加对那些3帐户状态的一个支持将是更容易和更快。

优点：

配置变化并不意味着一个代码库的变化
开关分配AccountStatus - IAccountDiscountCalculatorFactory实现可以通过配置来完成

缺点：

弱类型配置-错误的配置（错误类型定义）将导致错误在运行时
会不会在多线程环境中工作时，返回的对象有一个状态
你可能允许部署团队更改代码的行为

配置在不同的源 - 懒人版

如果你既需要：代码基地+延迟加载外配置 - 这个版本是给你的！

隐藏缩小

复制代码

public class ConfigurableLazyAccountDiscountCalculatorFactory : IAccountDiscountCalculatorFactory
{
    private readonly Dictionary<AccountStatus, Lazy<IAccountDiscountCalculator>> _discountsDictionary;
    public ConfigurableLazyAccountDiscountCalculatorFactory(Dictionary<AccountStatus, Type> discountsDictionary)
    {
        _discountsDictionary = ConvertStringsDictToObjectsDict(discountsDictionary);
    }

    public IAccountDiscountCalculator GetAccountDiscountCalculator(AccountStatus accountStatus)
    {
        Lazy<IAccountDiscountCalculator> calculator;

        if (!_discountsDictionary.TryGetValue(accountStatus, out calculator))
        {
            throw new NotImplementedException("There is no implementation of IAccountDiscountCalculatorFactory interface for given Account Status");
        }

        return calculator.Value;
    }

    private Dictionary<AccountStatus, Lazy<IAccountDiscountCalculator>> ConvertStringsDictToObjectsDict(
        Dictionary<AccountStatus, Type> dict)
    {
      return dict.ToDictionary(x => x.Key,
          x => new Lazy<IAccountDiscountCalculator>(() => (IAccountDiscountCalculator)Activator.CreateInstance(x.Value)));                
    }
}

正如你可以在上面的代码中看到的，我已经从以前的版本一点点改变配置的工厂。

该型民营词典从：

隐藏复制代码

Dictionary<AccountStatus, IAccountDiscountCalculator>

至：

隐藏复制代码

Dictionary<AccountStatus, Lazy<IAccountDiscountCalculator>>

另一个区别是，构造我们的工厂现在使用一个类型的参数：

隐藏复制代码

Dictionary<AccountStatus, Type>

所以出厂的配置现在看起来是这样的：

隐藏复制代码

var discountsDictionary = _repository.GetDiscountCalculatorConfiguration().ToDictionary(x=> x.Key, x => Type.GetType(x.Value));

感谢这个转换：

隐藏复制代码

Type.GetType(x.Value)

如果我们将在实现类型定义了一个错误，将创建出厂前将发生错误。公平竞争！

而最重要的事情- ConvertStringsDictToObjectsDict方法现在创建计算器一个懒惰的实例：

隐藏复制代码

new Lazy<IAccountDiscountCalculator>(() => (IAccountDiscountCalculator)Activator.CreateInstance(x.Value))

该GetAccountDiscountCalculator方法现在返回值字典中的值（财产懒惰型）：

隐藏复制代码

return calculator.Value;

优点：

配置变化并不意味着一个代码库的变化
更快的应用程序启动
不保留对象在内存中，直到你真的需要它
开关分配AccountStatus - IAccountDiscountCalculatorFactory实现可以通过配置来完成

缺点：

弱类型配置 - 错误的配置（错误类型定义）将导致错误在运行时
会不会在多线程环境中工作时，返回的对象有一个状态
你可能允许部署团队更改代码的行为
从工厂第一个对象的回报速度会变慢

每次调用一个新实例

在本组的解决方案，每个打电话到工厂的具体实施IAccountDiscountCalculator -一个实例：

隐藏复制代码

_factory.GetAccountDiscountCalculator(AccountStatus.SimpleCustomer);

将返回一个新的对象。

基本版本

本厂本组第一个版本看起来如下：

隐藏缩小

复制代码

public class DictionarableAccountDiscountCalculatorFactory : IAccountDiscountCalculatorFactory
{
  private readonly Dictionary<AccountStatus, Type> _discountsDictionary;
  public DictionarableAccountDiscountCalculatorFactory(Dictionary<AccountStatus, Type> discountsDictionary)
  {       
    _discountsDictionary = discountsDictionary;
    CheckIfAllValuesFromDictImplementsProperInterface();
  }

  public IAccountDiscountCalculator GetAccountDiscountCalculator(AccountStatus accountStatus)
  {
    Type calculator;

    if (!_discountsDictionary.TryGetValue(accountStatus, out calculator))
    {
      throw new NotImplementedException("There is no implementation of IAccountDiscountCalculatorFactory interface for given Account Status");
    }

    return (IAccountDiscountCalculator)Activator.CreateInstance(calculator);
  }

  private void CheckIfAllValuesFromDictImplementsProperInterface()
  {
    foreach (var item in _discountsDictionary)
    {
      if (!typeof(IAccountDiscountCalculator).IsAssignableFrom(item.Value))
      {
        throw new ArgumentException("The type: " + item.Value.FullName + "does not implement IAccountDiscountCalculatorFactory interface!");
      }
    }
  }
}

你可以看到，我们的私人字典，现在养了类型类型的值：

隐藏复制代码

private readonly Dictionary<AccountStatus, Type> _discountsDictionary;

为什么？

C＃不好的做法：了解如何通过坏榜样的好代码 - 第2部分

因为我们要实例化的类型，分配给该特定的一个目的AccountStatus在GetAccountDiscountCalculator方法：

隐藏复制代码

return (IAccountDiscountCalculator)Activator.CreateInstance(calculator);

类型类型允许我们保持它存在于应用程序，在我们的情况下，任何类型-实现Ø F中的IAccountDiscountCalculator。

我在这里使用C＃激活类来创建从可变一个新的对象类型的类型。

你可以看到一件事，在我们的工厂实现：

隐藏复制代码

private void CheckIfAllValuesFromDictImplementsProperInterface()
{
  foreach (var item in _discountsDictionary)
  {
    if (!typeof(IAccountDiscountCalculator).IsAssignableFrom(item.Value))
    {
      throw new ArgumentException("The type: " + item.Value.FullName + "does not implement IAccountDiscountCalculatorFactory interface!");
    }
  }
}

同时，创建工厂的方法，如果从构造函数中执行。

C＃不好的做法：了解如何通过坏榜样的好代码 - 第2部分我因为我们的工厂正试图使每个计算器实现的实例添加此检查的代码，并将其转换为一个IAccountDiscountCalculator接口。如果我们将配置没有实现一个计算器执行IAccountDiscountCalculator，我们会得到一个错误，当工厂将尝试施放此计算器的一个实例的接口（同时返回对象）。我们不希望它！现在，如果这种情况会发生，我们将看到它同时工厂将创建。

的最后一件事是注射词典的配置：

隐藏复制代码

var discountsDictionary = new Dictionary<AccountStatus, Type>
            {
              {AccountStatus.NotRegistered, typeof(NotRegisteredDiscountCalculator)},
              {AccountStatus.SimpleCustomer, typeof(SimpleCustomerDiscountCalculator)},
              {AccountStatus.ValuableCustomer, typeof(ValuableCustomerDiscountCalculator)},
              {AccountStatus.MostValuableCustomer, typeof(MostValuableCustomerDiscountCalculator)}
            };

所以总结起来，每次我们将调用时间GetAccountDiscountCalculator方法，工厂将返回分配一个新的对象（在注射的字典）到AccountStatus。

优点：

这很简单
强类型的配置 - 配置（错误类型定义）不慎就会导致错误的编译时
工程就像在多线程环境魅力时，返回的对象有一个状态

缺点：

对象返回出厂慢 - 工厂每次调用的对象将创建一个新的实例
如果配置类型给出不执行IAccountDiscountCalculator，将发生在运行时错误
来电者是负责工厂将返回后管理对象的生命周期

代码外配置

该版本提供了一个工厂，将返回一个新的对象，每次每个呼叫和配置存储代码之外-在这一次配置文件。

让我们开始从这个时候配置文件：

隐藏复制代码

<xml version="1.0" encoding="utf-8" >
<configuration>
  <configSections>
    <section name="DiscountCalculatorsConfiguration" type="System.Configuration.NameValueSectionHandler" />
  </configSections>
  <DiscountCalculatorsConfiguration>
    <add key="NotRegistered" value="Calculators.NotRegisteredDiscountCalculator, Calculators" />
    <add key="SimpleCustomer" value="Calculators.SimpleCustomerDiscountCalculator, Calculators" />
    <add key="ValuableCustomer" value="Calculators.ValuableCustomerDiscountCalculator, Calculators" />
    <add key="MostValuableCustomer" value="Calculators.MostValuableCustomerDiscountCalculator, Calculators" />
  </DiscountCalculatorsConfiguration>
</configuration>

我创建了一个自定义的部分，并把它命名为DiscountCalculatorsConfiguration。
里面的部分，我们拥有的集合键-值对的-我们的工厂（如存储在数据库中配置的情况下，同样的约定）的定义。
现在，我们只需要运行此代码之前，我们将创建工厂：

隐藏复制代码

var collection = ConfigurationManager.GetSection("DiscountCalculatorsConfiguration") as NameValueCollection;
var discountsDictionary = collection.AllKeys.ToDictionary(k => k, k => collection[k]);

并注入创造词典到我们的新工厂：

隐藏缩小

复制代码

public class ConfigurableAccountDiscountCalculatorFactory : IAccountDiscountCalculatorFactory
{
  private readonly Dictionary<AccountStatus, Type> _discountsDictionary;
  public ConfigurableAccountDiscountCalculatorFactory(Dictionary<string, string> discountsDictionary)
  {
    _discountsDictionary = ConvertStringsDictToDictOfTypes(discountsDictionary);
    CheckIfAllValuesFromDictImplementsProperInterface();
  }

  public IAccountDiscountCalculator GetAccountDiscountCalculator(AccountStatus accountStatus)
  {
    Type calculator;

    if (!_discountsDictionary.TryGetValue(accountStatus, out calculator))
    {
        throw new NotImplementedException("There is no implementation of IAccountDiscountCalculatorFactory interface for given Account Status");
    }

    return (IAccountDiscountCalculator)Activator.CreateInstance(calculator);
  }

  private void CheckIfAllValuesFromDictImplementsProperInterface()
  {
    foreach (var item in _discountsDictionary)
    {
      if (!typeof(IAccountDiscountCalculator).IsAssignableFrom(item.Value))
      {
        throw new ArgumentException("The type: " + item.Value.FullName + " does not implement IAccountDiscountCalculatorFactory interface!");
      }
    }
  }

  private Dictionary<AccountStatus, Type> ConvertStringsDictToDictOfTypes(
      Dictionary<string, string> dict)
  {
    return dict.ToDictionary(x => (AccountStatus)Enum.Parse(typeof(AccountStatus), x.Key, true),
        x => Type.GetType(x.Value));
  }
}

请注意，以处理从配置文件创建的字典，我们必须准备我们的工厂采取

隐藏复制代码

Dictionary<string, string>

作为参数，并把它转换为：

隐藏复制代码

Dictionary<AccountStatus, Type>

在：

隐藏复制代码

private Dictionary<AccountStatus, Type> ConvertStringsDictToDictOfTypes(
    Dictionary<string, string> dict)
{
  return dict.ToDictionary(x => (AccountStatus)Enum.Parse(typeof(AccountStatus), x.Key, true),
      x => Type.GetType(x.Value));
}

方法。

该GetAccountDiscountCalculator方法看起来如同在以前的版本。

C＃不好的做法：了解如何通过坏榜样的好代码 - 第2部分请注意，即使我们将在配置中的错误（在定义实现类型），将同时工厂将被创建（中出现的错误ConvertStringsDictToDictOfTypes法）：

隐藏复制代码