在抽象工厂中使用依赖倒置

本篇实现的效果为：当学校有通知的时候，把通知内容发送到每一个人，如下：





□ 思路
可以把通知内容、通知对象、通知方式、通知行为抽象成类、接口、接口实现，再为一些接口创建对应的抽象工厂及其实现。所有的这些依赖可以通过"依赖倒置容器"来管理。

→关于通知内容，可以封装成一个类
→关于通知对象，可以抽象出基类和实现类
→关于通知对象的Repository，有对应的接口、接口实现，抽象工厂、抽象工厂实现
→关于Email通知方式的Repository,有对应的接口，接口实现，抽象工厂、抽象工厂实现
→关于通知的行为，可以有对应的接口和接口实现
→关于客户端调用，这么些接口和接口实现，以及抽象工厂和抽象工厂实现，我们需要使用"依赖倒置"，把所有的依赖注册到依赖倒置容器中，使用的时候，再分别拿出来。

另外，可以为所有的抽象工厂提供一个统一的访问入口，让一个接口实现所有的抽象工厂接口，外部访问的时候，可以通过这个接口拿到所有的抽象工厂。

□ 关于通知内容

可以把通知的对象抽象出一个基类来，学生、老师等继承于这个基类。

using System;

namespace AbstractFactoryDI.Core.Model
{
public abstract class Person
{
public virtual Guid Id { get; set; }
public virtual string PIN { get; set; }
public virtual string Name { get; set; }
public virtual string Surname { get; set; }
public virtual string Email { get; set; }
}

public partial class Student : Person
{
}

public partial class Trainer : Person
{
}
}

□ 关于通知对象的Repository

关于通知对象Person的Repository接口，从中可以获取到通知对象Person的集合。

using System.Collections.Generic;
using AbstractFactoryDI.Core.Model;

namespace AbstractFactoryDI.Core.Repository
{
public interface IPersonRepository
{
IEnumerable<Person> GetAllActivePeople();
}
}

为通知对象Person的Repository接口创建抽象工厂。

using AbstractFactoryDI.Core.Repository;

namespace AbstractFactoryDI.Core.Factories
{
public interface IRepositoryFactory
{
IPersonRepository CreatePersonRepository();
}
}

针对IPersonRepository的实现是：

using System;
using System.Collections.Generic;
using System.Linq;
using AbstractFactoryDI.Core.Model;
using AbstractFactoryDI.Core.Repository;

namespace AbstractFactoryDI.Infrastructure.Repository
{
public class PersonRepository : IPersonRepository
{
private static ICollection<Person>  _people = new List<Person>()
{
new Student(){Id = Guid.NewGuid(),Name = "jack", Surname = "cute jack",Email = "jack@sina.com", PIN = "001"},
new Student(){Id = Guid.NewGuid(),Name = "sunny", Surname = "cute sunny",Email = "sunny@sina.com", PIN = "002"},
};
public System.Collections.Generic.IEnumerable<Core.Model.Person> GetAllActivePeople()
{
return _people.AsEnumerable();
}
}
}

□ 关于通知方式中的Email通知

把通过Email通知的方式也抽象成一个接口。

using System;

namespace AbstractFactoryDI.Core.Notificators
{
public interface IEmailNotificator : IDisposable
{
void SendNotification(string toAddress, string message);
}
}

与IEmailNotificator对应的抽象工厂为：

using AbstractFactoryDI.Core.Notificators;

namespace AbstractFactoryDI.Core.Factories
{
public interface IEmailNotificatorFactory
{
IEmailNotificator CreateEmailNotificator();
}
}

IEmailNotificator接口实现是：

using System;
using AbstractFactoryDI.Core.Notificators;

namespace AbstractFactoryDI.Infrastructure.Notificators
{
public class EmailNotificator : IEmailNotificator
{

public void SendNotification(string toAddress, string message)
{
//System.Net.Mail.SmtpClient发邮件
Console.WriteLine(message);
Console.WriteLine();
Console.WriteLine();
}

public void Dispose()
{
//dispose System.Net.Mail.SmtpClient
}
}
}

□ 关于抽象工厂的统一入口

现在已经有了有关通知对象的抽象工厂IRepositoryFactory和有关邮件通知方式的抽象工厂IEmailNotificatorFactory，我们还希望为所有的这些抽象工厂创建一个统一的访问入口，于是创建实现所有抽象工厂接口的接口：

namespace AbstractFactoryDI.Core.Factories
{
public interface IServiceFactory : IRepositoryFactory, IEmailNotificatorFactory
{

}
}

IServiceFactory对应的实现是：

using AbstractFactoryDI.Core.Factories;
using AbstractFactoryDI.Infrastructure.Notificators;
using AbstractFactoryDI.Infrastructure.Repository;

namespace AbstractFactoryDI.Factories.Concrete
{
public class ServiceFactory : IServiceFactory
{

public virtual Core.Repository.IPersonRepository CreatePersonRepository()
{
return new PersonRepository();
}

public virtual Core.Notificators.IEmailNotificator CreateEmailNotificator()
{
return new EmailNotificator();
}
}
}

□ 关于通知内容

通知内容包含放假开始时间、结束时间、内容等，把之封装成一个类。

using System;

namespace AbstractFactoryDI.Core.Services
{
public class ClosureInfo
{
public DateTime StartDate { get; set; }
public DateTime EndDate { get; set; }
public string Reason { get; set; }
}
}

□ 关于通知行为

发送通知需要以上的ClosureInfo类型参数，考虑到发送通知的方式可能有多种，比如短信、邮件等，可以为发送通知抽象出一个接口。

namespace AbstractFactoryDI.Core.Services
{
public interface INotificationService
{
void NotifySchoolClosure(ClosureInfo info);
}
}

关于INotificationService的实现。我们可以从抽象工厂统一入口拿到IPersonRepository，从而获取到所有的通知对象。还可以从抽象工厂统一入口拿到IEmailNotificator，来发送通知信息。

using System.Collections.Generic;
using System.Text;
using AbstractFactoryDI.Core.Factories;
using AbstractFactoryDI.Core.Model;

namespace AbstractFactoryDI.Core.Services
{
public class NotificationService : INotificationService
{
private readonly IServiceFactory _factory;

public NotificationService(IServiceFactory factory)
{
_factory = factory;
}
public void NotifySchoolClosure(ClosureInfo info)
{
var personRepository = _factory.CreatePersonRepository();
var people = personRepository.GetAllActivePeople();
NotifySchoolClosure(info, people);
}

private void NotifySchoolClosure(ClosureInfo info, IEnumerable<Person> people)
{
using (var notificator = _factory.CreateEmailNotificator())
{
foreach (var person in people)
{
notificator.SendNotification(person.Email, FormatMessage(person, info));
}
}
}

private string FormatMessage(Person person, ClosureInfo info)
{
var str = new StringBuilder();
str.Append(string.Format("您好 {0}\n", person.Name));
str.Append(info.Reason);
str.Append(string.Format(" 学校将在{0}和{1}期间放假\n", info.StartDate, info.EndDate));
str.Append("请注意安全~~");
return str.ToString();
}
}
}

□ 客户端

前面已经有了抽象工厂以及抽象工厂的实现，抽象工厂入口以及抽象工厂入口的实现，接口和接口实现......所有的这些，都可以让依赖倒置来解决，这里使用Microsoft.Practices.Unity。

using AbstractFactoryDI.Core.Factories;
using AbstractFactoryDI.Core.Services;
using AbstractFactoryDI.Factories.Concrete;
using Microsoft.Practices.Unity;

namespace AbstractFactoryDI.Client
{
public class RootContainer
{
private static readonly UnityContainer _container;

static RootContainer()
{
_container = new UnityContainer();
RegisterAll();
}

internal static void RegisterAll()
{
_container.RegisterType<IEmailNotificatorFactory, ServiceFactory>();
_container.RegisterType<IRepositoryFactory, ServiceFactory>();
_container.RegisterType<IServiceFactory, ServiceFactory>();
_container.RegisterType<INotificationService, NotificationService>();
}

internal static Iofs Resolve<Iofs>()
{
return _container.Resolve<Iofs>();
}
}
}

客户端调用的时候，首先在构造函数中注册所有的依赖，然后在使用的时候，在从依赖倒置容器中解析出具体的接口实现。

using System;
using AbstractFactoryDI.Core.Services;

namespace AbstractFactoryDI.Client
{
class Program
{
public Program()
{
RootContainer.RegisterAll();
}

static void Main(string[] args)
{
NotifyChristmasVacation();
Console.ReadKey();
}

static void NotifyChristmasVacation()
{
INotificationService notificaitonService = RootContainer.Resolve<INotificationService>();
var closureInfo = new ClosureInfo()
{
StartDate = new DateTime(DateTime.Now.Year, 12, 24),
EndDate = new DateTime(DateTime.Now.Year, 12, 26),
Reason = "圣诞节放假~~"
};
notificaitonService.NotifySchoolClosure(closureInfo);
}
}
}

参考资料：

Dependency Injection of an Abstract Factory