微软企业库源码解析——DAAB（二）DatabaseFactory（ConfigurationNameMappingStrategy篇）

其实跟踪到这里我就已经崩溃了，不过为了让问题水落石出，我们祭出Reflactor继续追踪下去。

public TTypeToBuild BuildUp<TTypeToBuild>(IReadWriteLocator locator, ILifetimeContainer lifetime, IPolicyList policies, IStrategyChain strategies, object buildKey, object existing)
{
    return (TTypeToBuild) this.BuildUp(locator, lifetime, policies, strategies, buildKey, existing);
}

public object BuildUp(IReadWriteLocator locator, ILifetimeContainer lifetime, IPolicyList policies, IStrategyChain strategies, object buildKey, object existing)
{
    Guard.ArgumentNotNull(strategies, "strategies");
    BuilderContext context = new BuilderContext(strategies, locator, lifetime, policies, buildKey, existing);
    return strategies.ExecuteBuildUp(context);
}

这里面的Guard是用来检测各种参数的，其中提供了类似于ArgumentNotNull之类的一系列方法，也是比较常用的，将参数检测集中起来的方法，值得大家学习。

可以看到，Builder用了StrategyChain进行的装配。所以，我们又得返回去看看StrategyChain里面都有什么东西。

找到EnterpriseLibraryFactory的构造函数，发现StrategyChain是这么出来的

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();

据我猜测，BuilderStage应该是说明在何时这个策略参与对象的装配的。

我们从第一个Strategy开始看，即ConfigurationNameMappingStrategy。

/// <summary>
/// Implementation of <see cref="IBuilderStrategy"/> which maps null instance names into a different name.
/// </summary>
/// <remarks>
/// The strategy is used to deal with default names.
/// </remarks>
/// <seealso cref="ConfigurationNameMapperAttribute"/>
/// <seealso cref="IConfigurationNameMapper"/>
public class ConfigurationNameMappingStrategy : EnterpriseLibraryBuilderStrategy
{
    /// <summary>
    /// Override of <see cref="IBuilderStrategy.PreBuildUp"/>. Updates the instance name using a name mapper associated to type
    /// to build so later strategies in the build chain will use the updated instance name.
    /// </summary>
    /// <remarks>
    /// Will only update the instance name if it is <see langword="null"/>.
    /// </remarks>
    /// <param name="context">The <see cref="IBuilderContext"/> that represents the current building process.</param>
    /// <exception cref="System.Configuration.ConfigurationErrorsException"> when the configuration required to do the mapping is not present or is
    /// invalid in the configuration source.</exception>
    public override void PreBuildUp(IBuilderContext context)
    {
        base.PreBuildUp(context);

        NamedTypeBuildKey key = (NamedTypeBuildKey) context.BuildKey;

        if (key.Name == null)
        {
            ConfigurationReflectionCache reflectionCache = GetReflectionCache(context);

            IConfigurationNameMapper mapper = reflectionCache.GetConfigurationNameMapper(key.Type);
            if (mapper != null)
            {
                context.BuildKey = new NamedTypeBuildKey(key.Type, mapper.MapName(null, GetConfigurationSource(context)));
            }
        }
    }
}

从注释我们可以看出，这个策略是为了将默认名称取出来并替换null名称的。刚刚我们CreateDatabase的时候如果不加上实例名的话，传递的就是null。这个策略就是将这个null的实例名替换成被标记为Default的实例名，以便下面的装配工作顺利进行。

我们看到PreBuildUp方法是override的，同时还调用了base.PreBuildUp。在ConfigurationNameMappingStrategy的父类EnterpriseLibraryBuilderStrategy中没有覆盖PreBuildUp方法。我用Reflactor查看了EnterpriseLibraryBuilderStrategy的父类BuilderStrategy，看到了BuilderStrategy的四个方法

public virtual void PostBuildUp(IBuilderContext context);
public virtual void PostTearDown(IBuilderContext context);
public virtual void PreBuildUp(IBuilderContext context);
public virtual void PreTearDown(IBuilderContext context);

都是空方法

NamedTypeBuildKey key实际上就是在EnterpriseLibraryFactory中调用BuildUp时传递的参数NamedTypeBuildKey.Make<T>()，而这个方法得到的是NamedTypeBuildKey(typeof(T))。

GetReflectionCache方法是在其父类EnterpriseLibraryBuilderStrategy中定义的

protected static ConfigurationReflectionCache GetReflectionCache(IBuilderContext context)
{
    IReflectionCachePolicy policy
        = context.Policies.Get<IReflectionCachePolicy>(typeof(IReflectionCachePolicy));

    if (policy == null)
        return new ConfigurationReflectionCache();
    else
        return policy.ReflectionCache;
}

reflectionCache.GetConfigurationNameMapper(key.Type)这里经过了一系列复杂的变化后得到了Database标记中包含的Attribute中指定的ConfigurationNameMapper：DatabaseMapper。这里，我们不用太担心反射的性能，因为微软企业库对反射后的结果等都进行了缓存，大大提高了效率，所以，我们完全可以在需要时随时创建Database实例。

再来看mapper.MapName

/// <summary>
/// This method supports the Enterprise Library infrastructure and is not intended to be used directly from your code.
/// Returns the default database name from the configuration in the <paramref name="configSource"/>, if the
/// value for <paramref name="name"/> is <see langword="null"/> (<b>Nothing</b> in Visual Basic).
/// </summary>
/// <param name="name">The current name.</param>
/// <param name="configSource">The source for configuration information.</param>
/// <returns>The default database name if <paramref name="name"/> is <see langword="null"/> (<b>Nothing</b> in Visual Basic),
/// otherwise the original value for <b>name</b>.</returns>
public string MapName(string name, IConfigurationSource configSource)
{
    if (name != null)
        return name;

    return new DatabaseConfigurationView(configSource).DefaultName;
}

继续跟踪到DatabaseConfigurationView

/// <summary>
/// <para>Gets the <see cref="DatabaseSettings"/> configuration data.</para>
/// </summary>
/// <returns>
/// <para>The <see cref="DatabaseSettings"/> configuration data.</para>
/// </returns>
public DatabaseSettings DatabaseSettings
{
    get { return (DatabaseSettings)configurationSource.GetSection(DatabaseSettings.SectionName); }
}

/// <summary>
/// <para>Gets the name of the default configured <see cref="Database"/>.</para>
/// </summary>
/// <returns>
/// <para>The name of the default configured <see cref="Database"/>.</para>
/// </returns>
public string DefaultName
{
    get
    {
        DatabaseSettings settings = this.DatabaseSettings;
        string databaseName = settings != null ? settings.DefaultDatabase : null;
        return databaseName;
    }
}

这里的configurationSource就是一开始在DatabaseFactory中ConfigurationSourceFactory.Create()得到的，后来经过各种传递用在这里了。

接下来我们只好跑到ConfigurationSourceFactory中看看是怎么回事了。

/// <summary>
/// Creates a new configuration sources based on the default configuration information from the
/// application's default configuration file.
/// </summary>
/// <returns>The new configuration source instance described as the default in the configuration file,
/// or a new instance of <see cref="SystemConfigurationSource"/> if the is no configuration sources configuration.</returns>
/// <exception cref="ConfigurationSourceSection">when there is a configuration section but it does not define
/// a default configurtion source, or when the configuration for the defined default configuration source is not found.</exception>
public static IConfigurationSource Create()
{
    ConfigurationSourceSection configurationSourceSection
        = ConfigurationSourceSection.GetConfigurationSourceSection();

    if (configurationSourceSection != null)
    {
        string systemSourceName = configurationSourceSection.SelectedSource;
        if (!string.IsNullOrEmpty(systemSourceName))
        {
            return Create(systemSourceName);
        }
        else
        {
            throw new ConfigurationErrorsException(Resources.ExceptionSystemSourceNotDefined);
        }
    }

    return new SystemConfigurationSource();
}

接下来先得看看这句

ConfigurationSourceSection configurationSourceSection = ConfigurationSourceSection.GetConfigurationSourceSection();

这句得到的configurationSourceSection如果是null的话，就直接返回了SystemConfigurationSource

/// <summary>
/// Configuration section for the configuration sources.
/// </summary>
/// <remarks>
/// This configuration must reside in the application's default configuration file.
/// </remarks>
public class ConfigurationSourceSection : SerializableConfigurationSection
{
    private const string selectedSourceProperty = "selectedSource";
    private const string sourcesProperty = "sources";

    /// <summary>
    /// This field supports the Enterprise Library infrastructure and is not intended to be used directly from your code.
    /// </summary>
    public const string SectionName = "enterpriseLibrary.ConfigurationSource";        

    /// <summary>
    /// Returns the <see cref="ConfigurationSourceSection"/> from the application's default configuration file.
    /// </summary>
    /// <returns>The section from the configuration file, or <see langword="null"/> (<b>Nothing</b> in Visual Basic) if the section is not present in the configuration file.</returns>
    public static ConfigurationSourceSection GetConfigurationSourceSection()
    {
        return (ConfigurationSourceSection)ConfigurationManager.GetSection(SectionName);
    }

    /// <summary>
    /// Gets or sets the name for the default configuration source.
    /// </summary>
    [ConfigurationProperty(selectedSourceProperty, IsRequired=true)]
    public string SelectedSource
    {
        get
        {
            return (string)this[selectedSourceProperty];
        }
        set
        {
            this[selectedSourceProperty] = value;
        }
    }

    /// <summary>
    /// Gets the collection of defined configuration sources.
    /// </summary>
    [ConfigurationProperty(sourcesProperty, IsRequired = true)]
    public NameTypeConfigurationElementCollection<ConfigurationSourceElement, ConfigurationSourceElement> Sources
    {
        get
        {
            return (NameTypeConfigurationElementCollection<ConfigurationSourceElement, ConfigurationSourceElement>)this[sourcesProperty];
        }           

    }
}

可以看出，这里实际上是从App.config或者Web.config中读取节enterpriseLibrary.ConfigurationSource

这是Entlib4里面新加入的功能，可以把配置节独立出来存储到别的文件中，没有尝试过的朋友可以打开微软企业库4.1试一试

这样的话，也就是说，如果选择了ConfigurationSource的话就从该位置读取配置，否则就从SystemConfigurationSource读取配置

之后自然是顺理成章的从dataConfiguration配置节中读取DefaultDatabase，并且替换context中的BuildKey中的null值。

EntLib的庞大实在是令我崩溃，只好把这个策略再划分出来了。

不过不得不佩服ObjectBuilder的设计者，太强大了。