微软企业库源码解析——DAAB（一）DatabaseFactory

首先从最常用的数据获取块开始下手。

我们每次使用数据获取块首先做的就是得到一个Database

Database db = DatabaseFactory.CreateDatabase()

我们首先从DatabaseFactory着手

从名字上即可以猜测，DatabaseFactory是工厂模式的应用，用来创建一个恰当的Database。我们知道DAAB是兼容多种数据库的（MSSQL，Oracle等），因此所创建的Database应该是特异化的Database，比如SqlDatabase，从源代码的结构上看也是这样的。

再来看DatabaseFactory的代码

public static class DatabaseFactory

DatabaseFactory是一个静态类，其中只含有静态方法

public static Database CreateDatabase();
public static Database CreateDatabase(string name);
private static void TryLogConfigurationError(ConfigurationErrorsException configurationException, string instanceName)

我们关注的是CreateDatabase方法，这两个方法差不多，不过一个是得到默认Database一个是得到指定的Database

public static Database CreateDatabase()
{
    try
    {
        DatabaseProviderFactory factory = new DatabaseProviderFactory(ConfigurationSourceFactory.Create());
        return factory.CreateDefault();
    }
    catch (ConfigurationErrorsException configurationException)
    {
        TryLogConfigurationError(configurationException, "default");

        throw;
    }
}

从上面的代码我们可以发现DatabaseFactory是从DatabaseProviderFactory获得了Database并返回的，同时尝试把发生的错误记录下来，然后异常又被再次抛出了。

对于异常的处理并不是我们关心的，我们继续去看DatabaseProviderFactory。

public class DatabaseProviderFactory : NameTypeFactoryBase<Database>
{
    /// <summary>
    /// <para>Initializes a new instance of the <see cref="DatabaseProviderFactory"/> class
    /// with the default configuration source.</para>
    /// </summary>
    protected DatabaseProviderFactory()
        : base()
    {
    }

    /// <summary>
    /// <para>Initializes a new instance of the <see cref="DatabaseProviderFactory"/> class
    /// with the given configuration source.</para>
    /// </summary>
    /// <param name="configurationSource">The source for configuration information.</param>
    public DatabaseProviderFactory(IConfigurationSource configurationSource)
        : base(configurationSource)
    {}

}

可以知道，DatabaseFactory用ConfigurationSourceFactory创建的一个配置源装配了DatabaseProviderFactory。看来重点在NameTypeFactoryBase上。

我们来看NameTypeFactoryBase。

/// <summary>
/// Base class for instance factories.
/// </summary>
/// <remarks>
/// This class is used to create instances of types compatible with <typeparamref name="T"/> described
/// by a configuration source.
/// </remarks>
public class NameTypeFactoryBase<T>
{
    private IConfigurationSource configurationSource;

    /// <summary>
    /// Initializes a new instance of the <see cref="NameTypeFactoryBase{T}"/> class with the default configuration source.
    /// </summary>
    protected NameTypeFactoryBase()
        : this(ConfigurationSourceFactory.Create())
    {
    }

    /// <summary>
    /// Initializes a new instance of the <see cref="NameTypeFactoryBase{T}"/> class with a configuration source.
    /// </summary>
    /// <param name="configurationSource">The configuration source to use.</param>
    protected NameTypeFactoryBase(IConfigurationSource configurationSource)
    {
        this.configurationSource = configurationSource;
    }

    /// <summary>
    /// Returns a new instance of <typeparamref name="T"/> based on the default instance configuration.
    /// </summary>
    /// <returns>
    /// A new instance of <typeparamref name="T"/>.
    /// </returns>
    public T CreateDefault()
    {
        return EnterpriseLibraryFactory.BuildUp<T>(configurationSource);
    }

    /// <summary>
    /// Returns an new instance of <typeparamref name="T"/> based on the configuration for <paramref name="name"/>.
    /// </summary>
    /// <param name="name">The name of the required instance.</param>
    /// <returns>
    /// A new instance of <typeparamref name="T"/>.
    /// </returns>
    public T Create(string name)
    {
        return EnterpriseLibraryFactory.BuildUp<T>(name, configurationSource);
    }
}

回忆DatabaseFactory类，在创建了一个DatabaseProviderFactory后即调用了其Create或CreateDefault方法，这两个方法都是由NameTypeFactoryBase<Database>继承的。从这里可以看出，NameTypeFactoryBase用EnterpriseLibraryFactory从配置源读取配置并装配了Database类。

我们继续挖掘到EnterpriseLibraryFactory类。

public static class EnterpriseLibraryFactory

这也是一个静态类。这个类代码比较多，我就拣几段重要的贴上来。

static EnterpriseLibraryFactory()
{
    builder = new Builder();
    StagedStrategyChain<BuilderStage> stagedStrategyChain = new StagedStrategyChain<BuilderStage>();
    stagedStrategyChain.AddNew<ConfigurationNameMappingStrategy>(BuilderStage.PreCreation);
    stagedStrategyChain.AddNew<LocatorLookupStrategy>(BuilderStage.PreCreation);
    stagedStrategyChain.AddNew<ConfiguredObjectStrategy>(BuilderStage.PreCreation);
    stagedStrategyChain.AddNew<InstrumentationStrategy>(BuilderStage.PostInitialization);
    strategyChain = stagedStrategyChain.MakeStrategyChain();
}

public static T BuildUp<T>(IConfigurationSource configurationSource)
{
    return BuildUp<T>(null, null, configurationSource);
}

public static T BuildUp<T>(IReadWriteLocator locator,
                           ILifetimeContainer lifetimeContainer,
                           IConfigurationSource configurationSource)
{
    if (configurationSource == null)
        throw new ArgumentNullException("configurationSource");

    try
    {
        return GetObjectBuilder()
            .BuildUp<T>(locator,
                        lifetimeContainer,
                        GetPolicies(configurationSource),
                        strategyChain,
                        NamedTypeBuildKey.Make<T>(),
                        null);

    }
    catch (BuildFailedException e)
    {
        // look for the wrapped ConfigurationErrorsException, if any, and throw it
        ConfigurationErrorsException cee = GetConfigurationErrorsException(e);
        if (cee != null)
        {
            throw cee;
        }

        // unknown exception, bubble it up
        throw;
    }
}

private static PolicyList GetPolicies(IConfigurationSource configurationSource)
{
    PolicyList policyList = new PolicyList();
    policyList.Set<IConfigurationObjectPolicy>(new ConfigurationObjectPolicy(configurationSource),
                                               typeof(IConfigurationSource));
    policyList.Set<IReflectionCachePolicy>(new ReflectionCachePolicy(reflectionCache),
                                           typeof(IReflectionCachePolicy));

    return policyList;
}

private static IBuilder GetObjectBuilder()
{
    return builder;
}

private static IConfigurationSource ConfigurationSource
{
    get { return ConfigurationSourceFactory.Create(); }
}

熟悉Unity的朋友应该能猜到，大概是按照StrategyChain对Database进行了装配。

现在关键就在builder上了，可是Builder是ObjectBuilder2中的类，没有源码。

今天的工作先到这里了。