微软企业库源码解析——DAAB（三）DatabaseFactory（其余的Strategy）

下面我们继续分析剩下的三个Strategy：

stagedStrategyChain.AddNew<LocatorLookupStrategy>(BuilderStage.PreCreation);
stagedStrategyChain.AddNew<ConfiguredObjectStrategy>(BuilderStage.PreCreation);
stagedStrategyChain.AddNew<InstrumentationStrategy>(BuilderStage.PostInitialization);

先看LocatorLookupStrategy

public override void PreBuildUp(IBuilderContext context)
{
    if (context.Locator != null)
    {
        Monitor.Enter(context.Locator);
        context.RecoveryStack.Add(new LockReleaser(context.Locator));
        object result = context.Locator.Get(context.BuildKey);
        if (result != null)
        {
            context.Existing = result;
            context.BuildComplete = true;
            Monitor.Exit(context.Locator);
        }
    }
}

还记得我们在BuildUp中Locator是null，所以这个Strategy在这里没起任何作用

下面我们来看ConfiguredObjectStrategy，这个策略是整个装配过程的重点

/// <summary>
/// Implementation of <see cref="IBuilderStrategy"/> which creates objects.
/// </summary>
/// <remarks>
/// <para>The strategy looks for the <see cref="CustomFactoryAttribute">CustomFactory</see> attribute to
/// retrieve the <see cref="ICustomFactory"/> implementation needed to build the requested types based on
/// configuration.</para>
/// <para>The provided context must have a <see cref="ConfigurationObjectPolicy"/> holding a <see cref="IConfigurationSource"/>
/// where to request the configuration information.</para>
/// </remarks>
/// <seealso cref="ICustomFactory"/>
/// <seealso cref="CustomFactoryAttribute"/>
/// <seealso cref="ConfigurationObjectPolicy"/>
public class ConfiguredObjectStrategy : EnterpriseLibraryBuilderStrategy
{
    /// <summary>
    /// Override of <see cref="IBuilderStrategy.PreBuildUp"/>.
    /// Creates the requested object using the custom factory associated to the type specified by the context's key,
    /// and updates the context's existing object.
    /// </summary>
    /// <param name="context">The <see cref="IBuilderContext"/> that represents the current building process.</param>
    /// <exception cref="InvalidOperationException"> when the requested type does not have the
    /// required <see cref="CustomFactoryAttribute">CustomFactory</see> attribute.</exception>
    /// <exception cref="System.Configuration.ConfigurationErrorsException"> when the configuration for the requested ID is not present or is
    /// invalid in the configuration source.</exception>
    public override void PreBuildUp(IBuilderContext context)
    {
        base.PreBuildUp(context);

        IConfigurationSource configurationSource = GetConfigurationSource(context);
        ConfigurationReflectionCache reflectionCache = GetReflectionCache(context);

        NamedTypeBuildKey key = (NamedTypeBuildKey) context.BuildKey;
        string id = key.Name;
        Type t = key.Type;

        ICustomFactory factory = GetCustomFactory(t, reflectionCache);
        if (factory != null)
        {
            context.Existing = factory.CreateObject(context, id, configurationSource, reflectionCache);
        }
        else
        {
            throw new InvalidOperationException(
                string.Format(
                    Resources.Culture,
                    Resources.ExceptionCustomFactoryAttributeNotFound,
                    t.FullName,
                    id));
        }
    }

    private static ICustomFactory GetCustomFactory(Type t, ConfigurationReflectionCache reflectionCache)
    {
        ICustomFactory customFactory = reflectionCache.GetCustomFactory(t);

        return customFactory;
    }
}

GetCustomFactory这句得到的是Database类中的Attribute标记的

[CustomFactory(typeof(DatabaseCustomFactory))]

string id是前一篇文章得到的DefaultDatabase或者是指定的数据连接字符串的Name

具体的追踪过程请参见该系列文章的第二篇

接下来我们来看DatabaseCustomFactory

/// <summary>
/// This type supports the Enterprise Library infrastructure and is not intended to be used directly from your code.
/// Represents the process to build a <see cref="Database"/> described by configuration information.
/// </summary>
public class DatabaseCustomFactory : ICustomFactory
{
    private IDictionary<Type, IDatabaseAssembler> assemblersMapping = new Dictionary<Type, IDatabaseAssembler>(5);
    private object assemblersMappingLock = new object();

    /// <summary>
    /// This method supports the Enterprise Library infrastructure and is not intended to be used directly from your code.
    /// Returns an <see cref="IDatabaseAssembler"/> that represents the building process for a a concrete <see cref="Database"/>.
    /// </summary>
    /// <param name="type">The concrete <see cref="Database"/> type.</param>
    /// <param name="name">The name of the instance to build, or <see langword="null"/> (<b>Nothing</b> in Visual Basic).</param>
    /// <param name="reflectionCache">The cache to use retrieving reflection information.</param>
    /// <returns>The <see cref="IDatabaseAssembler"/> instance.</returns>
    /// <exception cref="InvalidOperationException">when concrete <see cref="Database"/> type does have the required <see cref="DatabaseAssemblerAttribute"/>.</exception>
    public IDatabaseAssembler GetAssembler(Type type, string name, ConfigurationReflectionCache reflectionCache)
    {
        bool exists = false;
        IDatabaseAssembler assembler;
        lock (assemblersMappingLock)
        {
            exists = assemblersMapping.TryGetValue(type, out assembler);
        }
        if (!exists)
        {
            DatabaseAssemblerAttribute assemblerAttribute
                = reflectionCache.GetCustomAttribute<DatabaseAssemblerAttribute>(type);
            if (assemblerAttribute == null)
                throw new InvalidOperationException(
                    string.Format(
                        Resources.Culture,
                        Resources.ExceptionDatabaseTypeDoesNotHaveAssemblerAttribute,
                        type.FullName,
                        name));

            assembler
                = (IDatabaseAssembler)Activator.CreateInstance(assemblerAttribute.AssemblerType);

            lock (assemblersMappingLock)
            {
                assemblersMapping[type] = assembler;
            }
        }

        return assembler;
    }

    /// <summary>
    /// This method supports the Enterprise Library infrastructure and is not intended to be used directly from your code.
    /// Returns a new instance of a concrete <see cref="Database"/>, described by the <see cref="ConnectionStringSettings"/>
    /// found in the <paramref name="configurationSource"/> under the name <paramref name="name"/>, plus any additional
    /// configuration information that might describe the the concrete <b>Database</b>.
    /// </summary>
    /// <param name="context">The <see cref="IBuilderContext"/> that represents the current building process.</param>
    /// <param name="name">The name of the instance to build, or <see langword="null"/> (<b>Nothing</b> in Visual Basic).</param>
    /// <param name="configurationSource">The source for configuration objects.</param>
    /// <param name="reflectionCache">The cache to use retrieving reflection information.</param>
    /// <returns>A new instance of the appropriate subtype of <typeparamref name="Tobject"/>.</returns>
    /// <exception cref="ConfigurationErrorsException">when the configuration is invalid or <paramref name="name"/> cannot be found.</exception>
    public object CreateObject(IBuilderContext context, string name, IConfigurationSource configurationSource, ConfigurationReflectionCache reflectionCache)
    {
        DatabaseConfigurationView configurationView = new DatabaseConfigurationView(configurationSource);
        ConnectionStringSettings connectionStringSettings = configurationView.GetConnectionStringSettings(name);
        DbProviderMapping mapping = configurationView.GetProviderMapping(name, connectionStringSettings.ProviderName);

        IDatabaseAssembler assembler = GetAssembler(mapping.DatabaseType, name, reflectionCache);
        Database database = assembler.Assemble(name, connectionStringSettings, configurationSource);

        return database;
    }
}

DatabaseConfigurationView就是把xxx.config当做只跟数据获取块有关的配置文件看待，这一点跟DataView有异曲同工之妙。

下面来看ConnectionStringSettings是怎么得到的。

/// <summary>
/// Returns the <see cref="ConnectionStringSettings"/> object with the given name from the connection strings
/// configuration section in the receiver's configuration source.
/// </summary>
/// <remarks>
/// The connection string will be retrieved from the configuration source if it contains the connection strings section,
/// otherwise it will be retrieved from the default configuration file.
/// </remarks>
/// <param name="name">The name for the desired connection string configuration.</param>
/// <returns>The connection string configuration.</returns>
/// <exception cref="ArgumentException">if <paramref name="name"/> is <see langword="null"/> (<b>Nothing</b> in Visual Basic) or empty.</exception>
/// <exception cref="ConfigurationErrorsException">if the connection string object is not found, or if it does not specify a provider name.</exception>
public ConnectionStringSettings GetConnectionStringSettings(string name)
{
    ValidateInstanceName(name);

    ConnectionStringSettings connectionStringSettings;
    ConfigurationSection configSection = configurationSource.GetSection("connectionStrings");
    if ((configSection != null) && (configSection is ConnectionStringsSection))
    {
        ConnectionStringsSection connectionStringsSection = configSection as ConnectionStringsSection;
        connectionStringSettings = connectionStringsSection.ConnectionStrings[name];
    }
    else
        connectionStringSettings = ConfigurationManager.ConnectionStrings[name];

    ValidateConnectionStringSettings(name, connectionStringSettings);
    return connectionStringSettings;
}

这里首先检索的是ConfigurationSource中是否含有connectionStrings配置节，如果不含有的话，再从默认的配置源（web.config或者app.config）中获取包含指定name的连接字符串

接下来我们看DbProviderMapping是怎么得到的

/// <summary>
/// Returns the <see cref="DbProviderMapping"/> that specifies the mapping between an ADO.NET provider factory and a
/// <see cref="Database"/> instance.
/// </summary>
/// <remarks>
/// The mapping based in logical names will be probed first. If there is no success, the default type based mappings
/// will be considered. If no default mapping is defined for the provider factory type, the generic database will be used.
/// </remarks>
/// <param name="name">The name of the <see cref="Database"/> instance.</param>
/// <param name="dbProviderName">The logical provider name.</param>
/// <returns>The <see cref="DbProviderMapping"/> that matches the <paramref name="dbProviderName"/>.</returns>
public DbProviderMapping GetProviderMapping(string name, string dbProviderName)
{
    DatabaseSettings settings = this.DatabaseSettings;
    if (settings != null)
    {
        DbProviderMapping existingMapping = settings.ProviderMappings.Get(dbProviderName);
        if (existingMapping != null)
        {
            return existingMapping;
        }
    }

    DbProviderMapping defaultMapping = this.GetDefaultMapping(name, dbProviderName);
    if (defaultMapping != null)
    {
        return defaultMapping;
    }

    return this.GetGenericMapping();
}

说实在的，这段代码我很不理解，不理解的地方在于这句

DbProviderMapping existingMapping = settings.ProviderMappings.Get(dbProviderName);

Settings的获得是从配置文件中的dataConfiguration配置节中读取的

然而ProviderMappings具有Attribute标记

[ConfigurationProperty(dbProviderMappingsProperty, IsRequired = false)]

其中dbProviderMappingsProperty=”providerMappings”

然而，无论我怎么在配置文件中找，也没有找到providerMappings这个配置节或者是属性

这样的话

[ConfigurationProperty(dbProviderMappingsProperty, IsRequired = false)]
public NamedElementCollection<DbProviderMapping> ProviderMappings
{
    get
    {
        return (NamedElementCollection<DbProviderMapping>)base[dbProviderMappingsProperty];
    }
}

应该返回的是null？不知道ConfigurationManager.GetSection是怎么处理的，反正在MSDN上我是没有找到什么有用的资料，不知道有没有哪位不吝赐教。

如果那里返回的是null的话，这句话就该有空引用的异常

DbProviderMapping existingMapping = settings.ProviderMappings.Get(dbProviderName);

如果不是null的话，又是如何实例化的NamedElementCollection<DbProviderMapping>呢

在此留下一个疑问，留待后人解决。

这里，我们可以猜测到，DbProviderMapping是用来根据配置文件中的ProviderName来确定的，从而根据这个mapping来获得相应的SqlDatabase或者是其他的Database。

IDatabaseAssembler assembler = GetAssembler(mapping.DatabaseType, name, reflectionCache);

mapping.DatabaseType就是SqlDatabase或者OracleDatabase或者GenericDatabase，具体是哪个由配置文件决定。

/// <summary>
/// This method supports the Enterprise Library infrastructure and is not intended to be used directly from your code.
/// Returns an <see cref="IDatabaseAssembler"/> that represents the building process for a a concrete <see cref="Database"/>.
/// </summary>
/// <param name="type">The concrete <see cref="Database"/> type.</param>
/// <param name="name">The name of the instance to build, or <see langword="null"/> (<b>Nothing</b> in Visual Basic).</param>
/// <param name="reflectionCache">The cache to use retrieving reflection information.</param>
/// <returns>The <see cref="IDatabaseAssembler"/> instance.</returns>
/// <exception cref="InvalidOperationException">when concrete <see cref="Database"/> type does have the required <see cref="DatabaseAssemblerAttribute"/>.</exception>
public IDatabaseAssembler GetAssembler(Type type, string name, ConfigurationReflectionCache reflectionCache)
{
    bool exists = false;
    IDatabaseAssembler assembler;
    lock (assemblersMappingLock)
    {
        exists = assemblersMapping.TryGetValue(type, out assembler);
    }
    if (!exists)
    {
        DatabaseAssemblerAttribute assemblerAttribute
            = reflectionCache.GetCustomAttribute<DatabaseAssemblerAttribute>(type);
        if (assemblerAttribute == null)
            throw new InvalidOperationException(
                string.Format(
                    Resources.Culture,
                    Resources.ExceptionDatabaseTypeDoesNotHaveAssemblerAttribute,
                    type.FullName,
                    name));

        assembler
            = (IDatabaseAssembler)Activator.CreateInstance(assemblerAttribute.AssemblerType);

        lock (assemblersMappingLock)
        {
            assemblersMapping[type] = assembler;
        }
    }
    
    return assembler;
}

这里通过反射得到了相应Database的程序集，比如说SqlDatabaseAssembler

然后通过该Assembler的Assemble方法得到了相应的Database

到这里，就已经完成了相应Database的创建。

下面是InstrumentationStrategy

public override void PreBuildUp(IBuilderContext context)
{
    base.PreBuildUp(context);

    if (context.Existing != null && context.Existing is IInstrumentationEventProvider)
    {
        IConfigurationSource configurationSource = GetConfigurationSource(context);
        ConfigurationReflectionCache reflectionCache = GetReflectionCache(context);

        NamedTypeBuildKey key = (NamedTypeBuildKey)context.BuildKey;
        string id = key.Name;

        InstrumentationAttachmentStrategy instrumentation = new InstrumentationAttachmentStrategy();

        if (ConfigurationNameProvider.IsMadeUpName(id))
        {
            instrumentation.AttachInstrumentation(context.Existing, configurationSource, reflectionCache);
        }
        else
        {
            instrumentation.AttachInstrumentation(id, context.Existing, configurationSource, reflectionCache);
        }
    }
}

检查了所有的Database，发现其父类Database实现了IInstrumentationEventProvider接口。

我们来看ConfigurationNameProvider的IsMadeUpName方法

/// <summary>
/// Manages the creation of names for anonymous instances.
/// </summary>
public static class ConfigurationNameProvider
{
    private const string nameSuffix = "___";

    /// <summary>
    /// Creates a new name.
    /// </summary>
    /// <returns>The created name.</returns>
    public static string MakeUpName()
    {
        return Guid.NewGuid().ToString() + nameSuffix;
    }

    /// <summary>
    /// Tests a name to determine if it has been created.
    /// </summary>
    /// <param name="name">The name to test.</param>
    /// <returns><b>true</b> if the name was made up.</returns>
    public static bool IsMadeUpName(string name)
    {
        if (name == null) return false;

        return name.EndsWith(nameSuffix);
    }
}

根据注释，ConfigurationNameProvider就是专门用来管理BuildKey.Name的类。这个类的MakeUpName方法在前面的分析中没有被调用过，而且BuildKey.Name也不是以"___"结尾，所以应该进入方法：

instrumentation.AttachInstrumentation(id, context.Existing, configurationSource, reflectionCache);

/// <summary>
/// Drives binding of instrumentation events to handler methods based on the attributes on the 
/// source object.
/// </summary>
public class InstrumentationAttachmentStrategy
{
    InstrumentationAttacherFactory attacherFactory = new InstrumentationAttacherFactory();

    /// <overloads>
    /// Attaches the instrumentation events in the <paramref name="createdObject"></paramref> to the 
    /// creating instance of the listener object, as defined by the <see cref="InstrumentationListenerAttribute"></see>
    /// on the source class.
    /// </overloads>
    /// <summary>
    /// Attaches the instrumentation events in the <paramref name="createdObject"></paramref> to the 
    /// creating instance of the listener object, as defined by the <see cref="InstrumentationListenerAttribute"></see>
    /// on the source class.
    /// </summary>
    /// <param name="createdObject">Source object used for instrumentation events.</param>
    /// <param name="configurationSource"><see cref="IConfigurationSource"></see> instance used to define whether
    /// instrumentation is enabled or disabled for application.</param>
    /// <param name="reflectionCache">Cache for instrumentation attributes discovered through reflection.</param>
    public void AttachInstrumentation(object createdObject, IConfigurationSource configurationSource, ConfigurationReflectionCache reflectionCache)
    {
        ArgumentGenerator arguments = new ArgumentGenerator();
        AttachInstrumentation(arguments, createdObject, configurationSource, reflectionCache);
    }

    /// <summary>
    /// Attaches the instrumentation events in the <paramref name="createdObject"></paramref> to the 
    /// creating instance of the listener object, as defined by the <see cref="InstrumentationListenerAttribute"></see>
    /// on the source class.
    /// </summary>
    /// <param name="instanceName">User-provided instance name given to the instrumenation listener during its instantiation.</param>
    /// <param name="createdObject">Source object used for instrumentation events.</param>
    /// <param name="configurationSource"><see cref="IConfigurationSource"></see> instance used to define whether
    /// instrumentation is enabled or disabled for application.</param>
    /// <param name="reflectionCache">Cache for instrumentation attributes discovered through reflection.</param>
    public void AttachInstrumentation(string instanceName, object createdObject, IConfigurationSource configurationSource, ConfigurationReflectionCache reflectionCache)
    {
        ArgumentGenerator arguments = new ArgumentGenerator(instanceName);
        AttachInstrumentation(arguments, createdObject, configurationSource, reflectionCache);
    }

    private void AttachInstrumentation(ArgumentGenerator arguments, object createdObject,
                                       IConfigurationSource configurationSource,
                                       ConfigurationReflectionCache reflectionCache)
    {
        InstrumentationConfigurationSection section = GetConfigurationSection(configurationSource);
        if (section.InstrumentationIsEntirelyDisabled) return;

        if (createdObject is IInstrumentationEventProvider)
        {
            createdObject = ((IInstrumentationEventProvider)createdObject).GetInstrumentationEventProvider();
        }

        object[] constructorArgs = arguments.ToArguments(section);

        BindInstrumentationTo(createdObject, constructorArgs, reflectionCache);
    }

    private void BindInstrumentationTo(object createdObject, object[] constructorArgs, ConfigurationReflectionCache reflectionCache)
    {
        IInstrumentationAttacher attacher = attacherFactory.CreateBinder(createdObject, constructorArgs, reflectionCache);
        attacher.BindInstrumentation();
    }

    private InstrumentationConfigurationSection GetConfigurationSection(IConfigurationSource configurationSource)
    {
        InstrumentationConfigurationSection section =
            (InstrumentationConfigurationSection)configurationSource.GetSection(InstrumentationConfigurationSection.SectionName);
        if (section == null) section = new InstrumentationConfigurationSection(false, false, false);
        
        return section;
    }

    private class ArgumentGenerator
    {
        private string instanceName;

        public ArgumentGenerator(string instanceName)
        {
            this.instanceName = instanceName;
        }

        public ArgumentGenerator() { }

        public object[] ToArguments(InstrumentationConfigurationSection configSection)
        {
            return instanceName == null
                    ?
                   new object[] { configSection.PerformanceCountersEnabled, configSection.EventLoggingEnabled, configSection.WmiEnabled, configSection.ApplicationInstanceName }
                    :
                   new object[]
                       {
                           instanceName, configSection.PerformanceCountersEnabled, configSection.EventLoggingEnabled,
                           configSection.WmiEnabled, configSection.ApplicationInstanceName
                       };
        }
    }
}

首先，AttachInstrumentation方法构造了一个用来传递参数的类ArgumentGenerator。然后通过configurationSource获得了InstrumentationConfigurationSection配置节，如果该配置节不存在，就创建一个PerformanceCountersEnabled，EventLoggingEnabled，WmiEnabled都为False的InstrumentationConfigurationSection实例。

紧接着，在这句，如果没有配置过InstrumentationConfigurationSection的话

if (section.InstrumentationIsEntirelyDisabled) return;

就返回了，因为

internal bool InstrumentationIsEntirelyDisabled
{
    get { return (PerformanceCountersEnabled || EventLoggingEnabled || WmiEnabled) == false; }
}

而刚刚直接新建了一个这三个值都是False的InstrumentationConfigurationSection实例。

如果配置过InstrumentationConfigurationSection的话，createObject是某个Database的实例，他们都继承自Database类，Database类实现了接口IInstrumentationEventProvider，该方法返回了类DataInstrumentationProvider。现在createObject指向了Database返回的类DataInstrumentationProvider。接下来，刚刚构造的用来生成参数的类ArgumentGenerator生成了一系列参数。

接下来我们来看那个attacher。

IInstrumentationAttacher attacher = attacherFactory.CreateBinder(createdObject, constructorArgs, reflectionCache);

首先得看attacherFactory。attacherFactory是在类InstrumentationAttachmentStrategy一开始就声明并赋值的一个变量。

InstrumentationAttacherFactory attacherFactory = new InstrumentationAttacherFactory();

我们来看InstrumentationAttacherFactory的CreateBinder方法

/// <summary>
/// Represents a factor to attach instrumentation objects.
/// </summary>
public class InstrumentationAttacherFactory
{
    /// <summary>
    /// Create the binder for instrumentation.
    /// </summary>
    /// <param name="createdObject">The created object for the attacher.</param>
    /// <param name="constructorArgs">The construcor objects.</param>
    /// <param name="reflectionCache">The relection cache.</param>
    /// <returns>An <see cref="IInstrumentationAttacher"/> object.</returns>
    public IInstrumentationAttacher CreateBinder(object createdObject,
                                                 object[] constructorArgs,
                                                 ConfigurationReflectionCache reflectionCache)
    {
        InstrumentationListenerAttribute listenerAttribute = GetInstrumentationListenerAttribute(createdObject, reflectionCache);

        if (listenerAttribute == null) return new NoBindingInstrumentationAttacher();

        Type listenerType = listenerAttribute.ListenerType;
        Type listenerBinderType = listenerAttribute.ListenerBinderType;

        if (listenerBinderType == null) return new ReflectionInstrumentationAttacher(createdObject, listenerType, constructorArgs);
        return new ExplicitInstrumentationAttacher(createdObject, listenerType, constructorArgs, listenerBinderType);
    }

    static InstrumentationListenerAttribute GetInstrumentationListenerAttribute(object createdObject,
                                                                         ConfigurationReflectionCache reflectionCache)
    {
        Type createdObjectType = createdObject.GetType();
        InstrumentationListenerAttribute listenerAttribute
            = reflectionCache.GetCustomAttribute<InstrumentationListenerAttribute>(createdObjectType, true);
        return listenerAttribute;
    }
}

首先，用ConfigurationReflectionCache反射得到了createObject的InstrumentationListenerAttribute，也就是DataInstrumentationProvider的InstrumentationListenerAttribute：

[InstrumentationListener(typeof(DataInstrumentationListener), typeof(DataInstrumentationListenerBinder))]
public class DataInstrumentationProvider

然后返回了一个ExplicitInstrumentationAttacher，我们来看ExplicitInstrumentationAttacher的BindInstrumentation方法

public void BindInstrumentation()
{
    IExplicitInstrumentationBinder binder = (IExplicitInstrumentationBinder) Activator.CreateInstance(explicitBinderType);
    object listener = Activator.CreateInstance(listenerType, listenerConstructorArguments);

    binder.Bind(source, listener);
}

先创建了刚刚得到的InstrumentationListenerAttribute中的DataInstrumentationListenerBinder。然后用刚刚的参数生成类ArgumentGenerator生成的参数创建了DataInstrumentationListener。然后调用Binder的Bind方法将DataInstrumentationListener和DataInstrumentationProvider绑定到一起。

这样一来，每当出现指定的操作的时候，就可以根据配置文件中的配置来决定是否进行性能计数，事件日志等操作。具体来说，就是将DataInstrumentationProvider中的事件

/// <summary>
/// Occurs when a new database connection is opened by a <see cref="Database"/> instance.
/// </summary>
[InstrumentationProvider("ConnectionOpened")]
public event EventHandler<EventArgs> connectionOpened;

/// <summary>
/// Occurs when the attempt to open a new database connection by a <see cref="Database"/> instance fails.
/// </summary>
[InstrumentationProvider("ConnectionFailed")]
public event EventHandler<ConnectionFailedEventArgs> connectionFailed;

/// <summary>
/// Occurs when a database command is executed by a <see cref="Database"/> instance.
/// </summary>
[InstrumentationProvider("CommandExecuted")]
public event EventHandler<CommandExecutedEventArgs> commandExecuted;

/// <summary>
/// Occurs when the attempt to execute a database command by a <see cref="Database"/> instance fails.
/// </summary>
[InstrumentationProvider("CommandFailed")]
public event EventHandler<CommandFailedEventArgs> commandFailed;

绑定到具体处理这些事件的类DataInstrumentationListener上

public void Bind(object source, object listener)
{
    DataInstrumentationListener castedListener = (DataInstrumentationListener)listener;
    DataInstrumentationProvider castedProvider = (DataInstrumentationProvider)source;

    castedProvider.commandExecuted += castedListener.CommandExecuted;
    castedProvider.commandFailed += castedListener.CommandFailed;
    castedProvider.connectionFailed += castedListener.ConnectionFailed;
    castedProvider.connectionOpened += castedListener.ConnectionOpened;
}

至此，所有的Strategy都分析完毕。

DatabaseFactory的工作原理也就明晰了。