ASP.NET MVC 开源项目Kigg解读（2）——Kigg.Core第一部分

Kigg是一个很好的ASP.NET MVC范例项目，本着研究的目的，对Kigg进行解读。

上一篇中，我们介绍了Kigg的启动、后台任务和事件聚合器。这一篇，我们来看看Kigg的核心类库Kigg.Core

一、类库一览

Kigg.Core是Kigg的灵魂所在，主要包含：

• ConfigurationSettings：站点设置
• DomainObjects：领域模型
• Extension：对.NET对象的扩展
• Helper:一些帮助方法
• Infrastructure：基础架构
• Repository：数据访问
• Service：数据服务

 

二、杂项

    在想到底用什么来描述ConfigurationSettings，Extension，Helper，第一印象是杂项，那么就叫杂项吧！ORZ~

1、配置信息

    ConfigurationSettings其实是Kigg的站点配置信息：

  Kigg是通过在Unity的配置文件中来设置这些配置信息的

                       <type type="IConfigurationSettings" mapTo="ConfigurationSettings">
                        <lifetime type="Singleton"/>
                        <typeConfig extensionType="Microsoft.Practices.Unity.Configuration.TypeInjectionElement, Microsoft.Practices.Unity.Configuration">
                            <property name="RootUrl" propertyType="System.String">
                                <value type="System.String" value="http://localhost:4252"/>
                            </property>
                            <property name="WebmasterEmail" propertyType="System.String">
                                <value type="System.String" value=""/>
                            </property>
                            // 省略……
                        </typeConfig>
                    </type>

 

2、Extension

再来看Extension：

Extension包含了对集合、枚举对象、Guid、DateTime以及String的扩展，有兴趣的同学可以去看看。

第一篇中的ForEach就来自于EnumerableExtension

    public static class EnumerableExtension
    {
        [DebuggerStepThrough]
        public static void ForEach<T>(this IEnumerable<T> enumerable, Action<T> action)
        {
            foreach (T item in enumerable)
            {
                action(item);
            }
        }
    }

 

3、Helper

 

最后看看Helper

这里包含了一些帮助类库：

CheckArgument是参数检验，比如：

            [DebuggerStepThrough]
            public static void IsNotEmpty(Guid argument, string argumentName)
            {
                if (argument == Guid.Empty)
                {
                    throw new ArgumentException("\"{0}\" cannot be empty guid.".FormatWith(argumentName), argumentName);
                }
            }

CheckArgument广泛的运用在Kigg.Core的方法中，比如第一部分中的

public StartBackgroundTasks(IBackgroundTask[] tasks)
{
    Check.Argument.IsNotEmpty(tasks, "tasks");
    _tasks = tasks;  10:
}

 

    PagedResult是个有意思的玩意，如果你使用过Subsonic，你会发现这个和PagedList有点像。PagedResult在Kigg中作为获取列表方法的返回类型，包含了结果集和总记录数，因此分页就比较方便了。

public class PagedResult<T>
   {
       private readonly ReadOnlyCollection<T> _result;
       private readonly int _total;

       public PagedResult(IEnumerable<T> result, int total)
       {
           Check.Argument.IsNotNull(result, "result");
           Check.Argument.IsNotNegative(total, "total");

           _result = new ReadOnlyCollection<T>(new List<T>(result));
           _total = total;
       }

       public PagedResult() : this(new List<T>(), 0)
       {
       }

       public ICollection<T> Result
       {
           [DebuggerStepThrough]
           get
           {
               return _result;
           }
       }

       public int Total
       {
           [DebuggerStepThrough]
           get
           {
               return _total;
           }
       }

       public bool IsEmpty
       {
           [DebuggerStepThrough]
           get
           {
               return _result.Count == 0;
           }
       }
   }

 

三、基础架构

话说，这一块是Kigg比较核心的部分。

这里包含了前面提到的Boot、BackgroundTask和EventAggrator,在这里就不再多说了。

1、IOC

 

    IOC是Kigg的基石，大部分的类的实例化和状态维持都由它来实现。Kigg使用Unity来作为IOC工具，想要简单的话，直接使用Unity就可以了，但是为了解除与Unity的依赖，Kigg特地抽象出一个接口IDependencyResolver：

 

public interface IDependencyResolver : IDisposable
   {
       void Register<T>(T instance);

       void Inject<T>(T existing);

       T Resolve<T>(Type type);

       T Resolve<T>(Type type, string name);

       T Resolve<T>();

       T Resolve<T>(string name);

       IEnumerable<T> ResolveAll<T>();
   }

 

这样，不管使用什么IOC工具，只需要实现这个接口就可以了。

在没用IOC的时候，要创建一个借口的实例怎么做？用工厂模式呗！这样在AppSetting中配置下dependencyResolverTypeName就可以了

    public interface IDependencyResolverFactory
    {
        IDependencyResolver CreateInstance();
    }
public class DependencyResolverFactory : IDependencyResolverFactory
    {
        private readonly Type _resolverType;

        public DependencyResolverFactory(string resolverTypeName)
        {
            Check.Argument.IsNotEmpty(resolverTypeName, "resolverTypeName");

            _resolverType = Type.GetType(resolverTypeName, true, true);
        }

        public DependencyResolverFactory() : this(new ConfigurationManagerWrapper().AppSettings["dependencyResolverTypeName"])
        {
        }

        public IDependencyResolver CreateInstance()
        {
            return Activator.CreateInstance(_resolverType) as IDependencyResolver;
        }
    }

为了方便使用IOC，Kigg特定创建了一个静态类库IOC：

public static class IoC
    {
        private static IDependencyResolver _resolver;

        [DebuggerStepThrough]
        public static void InitializeWith(IDependencyResolverFactory factory)
        {
            Check.Argument.IsNotNull(factory, "factory");

            _resolver = factory.CreateInstance();
        }

        [DebuggerStepThrough]
        public static void Register<T>(T instance)
        {
            Check.Argument.IsNotNull(instance, "instance");

            _resolver.Register(instance);
        }

        [DebuggerStepThrough]
        public static void Inject<T>(T existing)
        {
            Check.Argument.IsNotNull(existing, "existing");

            _resolver.Inject(existing);
        }

        [DebuggerStepThrough]
        public static T Resolve<T>(Type type)
        {
            Check.Argument.IsNotNull(type, "type");

            return _resolver.Resolve<T>(type);
        }

        [DebuggerStepThrough]
        public static T Resolve<T>(Type type, string name)
        {
            Check.Argument.IsNotNull(type, "type");
            Check.Argument.IsNotEmpty(name, "name");

            return _resolver.Resolve<T>(type, name);
        }

        [DebuggerStepThrough]
        public static T Resolve<T>()
        {
            return _resolver.Resolve<T>();
        }

        [DebuggerStepThrough]
        public static T Resolve<T>(string name)
        {
            Check.Argument.IsNotEmpty(name, "name");

            return _resolver.Resolve<T>(name);
        }

        [DebuggerStepThrough]
        public static IEnumerable<T> ResolveAll<T>()
        {
            return _resolver.ResolveAll<T>();
        }

        [DebuggerStepThrough]
        public static void Reset()
        {
            if (_resolver != null)
            {
                _resolver.Dispose();
            }
        }
    }

 

    在使用的使用，需要先调用IoC.InitializeWith()，初始化IoC内部的静态字段_resolver，然后就可以直接方便的使用IOC了，回顾第一篇的代码：

   1:    public static class Bootstrapper

   2:      {

   3:          static Bootstrapper()

   4:          {

   5:              try

   6:              {

   7:                  IoC.InitializeWith(new DependencyResolverFactory());

   8:              }

   9:              catch (ArgumentException)

  10:              {

  11:                  // Config file is Missing

  12:              }

  13:          }

  14:  

  15:          public static void Run()

  16:          {

  17:              IoC.ResolveAll<IBootstrapperTask>().ForEach(t => t.Execute());

  18:          }

  19:      }

 

2、缓存

   缓存组件很多，Kigg选用的是Enterprise Library。同样的为了消除与缓存组件的依赖，Kigg定义了自己的缓存接口：

public interface ICache
    {
        int Count
        {
            get;
        }

        void Clear();

        bool Contains(string key);

        T Get<T>(string key);

        bool TryGet<T>(string key, out T value);

        void Set<T>(string key, T value);

        void Set<T>(string key, T value, DateTime absoluteExpiration);

        void Set<T>(string key, T value, TimeSpan slidingExpiration);

        void Remove(string key);
    }

    同样的，为了方便调用，Kigg创建了Cache静态类，这次，采用的是一个静态属性，注意下InternalCache是通过IOC初始化的。这样，只需要在IOC的配置文件中指定下哪个具体的类实现了ICache接口就可以了。

public static class Cache
    {
        public static int Count
        {
            [DebuggerStepThrough]
            get
            {
                return InternalCache.Count;
            }
        }

        private static ICache InternalCache
        {
            [DebuggerStepThrough]
            get
            {
                return IoC.Resolve<ICache>();
            }
        }

        [DebuggerStepThrough]
        public static void Clear()
        {
            InternalCache.Clear();
        }

        [DebuggerStepThrough]
        public static bool Contains(string key)
        {
            Check.Argument.IsNotEmpty(key, "key");

            return InternalCache.Contains(key);
        }

        [DebuggerStepThrough]
        public static T Get<T>(string key)
        {
            Check.Argument.IsNotEmpty(key, "key");

            return InternalCache.Get<T>(key);
        }

        [DebuggerStepThrough]
        public static bool TryGet<T>(string key, out T value)
        {
            Check.Argument.IsNotEmpty(key, "key");

            return InternalCache.TryGet(key, out value);
        }

        [DebuggerStepThrough]
        public static void Set<T>(string key, T value)
        {
            Check.Argument.IsNotEmpty(key, "key");

            InternalCache.Set(key, value);
  57:          }               // 以下省略
    }

 

3、日志

     日志和缓存同样一个道理，有一个Log接口

public interface ILog
    {
        void Info(string message);

        void Warning(string message);

        void Error(string message);

        void Exception(Exception exception);
    }

      然后一个静态类Log，这里没有用一个静态的字段或属性来缓存ILog接口，而是一个GetLog()方法，效率上不如前面的Cache，算是一个小瑕疵吧。

public static class Log
    {
        [MethodImpl(MethodImplOptions.NoInlining)]
        [DebuggerStepThrough]
        public static void Info(string message)
        {
            Check.Argument.IsNotEmpty(message, "message");

            GetLog().Info(message);
        }

       // 省略部分代码

        [MethodImpl(MethodImplOptions.NoInlining)]
        private static ILog GetLog()
        {
            return IoC.Resolve<ILog>();
        }

        [MethodImpl(MethodImplOptions.NoInlining)]
        private static string Format(string format, params object[] args)
        {
            Check.Argument.IsNotEmpty(format, "format");

            return format.FormatWith(args);
        }
    }

未完、待续……