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

r囧r小猫 2021-11-02 12:38 240阅读 0赞

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

[![1][]][1 1]

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

→关于通知内容，可以封装成一个类  
→关于通知对象，可以抽象出基类和实现类  
→关于通知对象的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][]

转载于:https://www.cnblogs.com/darrenji/p/3762119.html

[1]: /images/20211101/7f123f5663cc4c3b85793b9bb2fd7049.png
[1 1]: https://images0.cnblogs.com/blog/417212/201405/310954082138977.png
[Dependency Injection of an Abstract Factory]: http://www.codeproject.com/Articles/778264/Dependency-Injection-of-an-Abstract-Factory