System.Data.Dll 剖析

System.Data.Dll 剖析

先看下一张类结构

接下来通过Reflector工具反编译System.Date.Dll中相关类如下

IDbConnection

public interface IDbConnection : IDisposable

{

    // Methods

    IDbTransaction BeginTransaction();

    IDbTransaction BeginTransaction(IsolationLevel il);

    void ChangeDatabase(string databaseName);

    void Close();

    IDbCommand CreateCommand();

    void Open();

 

    // Properties

    string ConnectionString { get; set; }

    int ConnectionTimeout { get; }

    string Database { get; }

    ConnectionState State { get; }

}

 DbConnection

public abstract class DbConnection : Component, IDbConnection, IDisposable

{

    // Fields

    private StateChangeEventHandler _stateChangeEventHandler;

 

    // Events

    [ResDescription("DbConnection_StateChange"), ResCategory("DataCategory_StateChange")]

    public event StateChangeEventHandler StateChange;

 

    // Methods

    protected DbConnection();

    protected abstract DbTransaction BeginDbTransaction(IsolationLevel isolationLevel);

    public DbTransaction BeginTransaction();

    public DbTransaction BeginTransaction(IsolationLevel isolationLevel);

    public abstract void ChangeDatabase(string databaseName);

    public abstract void Close();

    public DbCommand CreateCommand();

    protected abstract DbCommand CreateDbCommand();

    public virtual void EnlistTransaction(Transaction transaction);

    public virtual DataTable GetSchema();

    public virtual DataTable GetSchema(string collectionName);

    public virtual DataTable GetSchema(string collectionName, string[] restrictionValues);

    protected virtual void OnStateChange(StateChangeEventArgs stateChange);

    public abstract void Open();

    IDbTransaction IDbConnection.BeginTransaction();

    IDbTransaction IDbConnection.BeginTransaction(IsolationLevel isolationLevel);

    IDbCommand IDbConnection.CreateCommand();

 

    // Properties

    [ResCategory("DataCategory_Data"), DefaultValue(""), RecommendedAsConfigurable(true), RefreshProperties(RefreshProperties.All)]

    public abstract string ConnectionString { get; set; }

    [ResCategory("DataCategory_Data")]

    public virtual int ConnectionTimeout { get; }

    [ResCategory("DataCategory_Data")]

    public abstract string Database { get; }

    [ResCategory("DataCategory_Data")]

    public abstract string DataSource { get; }

    protected virtual DbProviderFactory DbProviderFactory { get; }

    internal DbProviderFactory ProviderFactory { get; }

    [Browsable(false)]

    public abstract string ServerVersion { get; }

    [Browsable(false), ResDescription("DbConnection_State")]

    public abstract ConnectionState State { get; }

}

SqlConnection

[DefaultEvent("InfoMessage")]

public sealed class SqlConnection : DbConnection, ICloneable

{

    // Fields

    private bool _AsycCommandInProgress;

    private int _closeCount;

    private bool _collectstats;

    private static readonly DbConnectionFactory _connectionFactory;

    private bool _fireInfoMessageEventOnUserErrors;

    private DbConnectionInternal _innerConnection;

    private static int _objectTypeCount;

    private DbConnectionPoolGroup _poolGroup;

    private SqlDebugContext _sdc;

    internal SqlStatistics _statistics;

    private DbConnectionOptions _userConnectionOptions;

    private static readonly object EventInfoMessage;

    internal static readonly CodeAccessPermission ExecutePermission;

    internal readonly int ObjectID;

 

    // Events

    [ResCategory("DataCategory_InfoMessage"), ResDescription("DbConnection_InfoMessage")]

    public event SqlInfoMessageEventHandler InfoMessage;

 

    // Methods

    static SqlConnection();

    public SqlConnection();

    private SqlConnection(SqlConnection connection);

    public SqlConnection(string connectionString);

    [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]

    internal void Abort(Exception e);

    internal void AddPreparedCommand(SqlCommand cmd);

    internal void AddWeakReference(object value, int tag);

    protected override DbTransaction BeginDbTransaction(IsolationLevel isolationLevel);

    public SqlTransaction BeginTransaction();

    public SqlTransaction BeginTransaction(IsolationLevel iso);

    public SqlTransaction BeginTransaction(string transactionName);

    public SqlTransaction BeginTransaction(IsolationLevel iso, string transactionName);

    public override void ChangeDatabase(string database);

    public static void ChangePassword(string connectionString, string newPassword);

    internal static void CheckGetExtendedUDTInfo(SqlMetaDataPriv metaData, bool fThrow);

    internal void CheckSQLDebug();

    [SecurityPermission(SecurityAction.Demand, Flags=SecurityPermissionFlag.UnmanagedCode)]

    private void CheckSQLDebug(SqlDebugContext sdc);

    private void CheckSQLDebugOnConnect();

    public static void ClearAllPools();

    public static void ClearPool(SqlConnection connection);

    public override void Close();

    private void CompleteOpen();

    private string ConnectionString_Get();

    private void ConnectionString_Set(string value);

    private void CopyFrom(SqlConnection connection);

    public SqlCommand CreateCommand();

    protected override DbCommand CreateDbCommand();

    private static CodeAccessPermission CreateExecutePermission();

    protected override void Dispose(bool disposing);

    private void DisposeMe(bool disposing);

    public void EnlistDistributedTransaction(ITransaction transaction);

    private void EnlistDistributedTransactionHelper(ITransaction transaction);

    public override void EnlistTransaction(Transaction transaction);

    internal static string FixupDatabaseTransactionName(string name);

    internal byte[] GetBytes(object o);

    internal byte[] GetBytes(object o, out Format format, out int maxSize);

    private DbMetaDataFactory GetMetaDataFactory(DbConnectionInternal internalConnection);

    internal DbMetaDataFactory GetMetaDataFactoryInternal(DbConnectionInternal internalConnection);

    internal SqlInternalConnection GetOpenConnection();

    internal SqlInternalConnection GetOpenConnection(string method);

    internal SqlInternalConnectionTds GetOpenTdsConnection();

    internal SqlInternalConnectionTds GetOpenTdsConnection(string method);

    public override DataTable GetSchema();

    public override DataTable GetSchema(string collectionName);

    public override DataTable GetSchema(string collectionName, string[] restrictionValues);

    internal object GetUdtValue(object value, SqlMetaDataPriv metaData, bool returnDBNull);

    private void IssueSQLDebug(uint option, string machineName, uint pid, uint id, string sdiDllName, byte[] data);

    internal void NotifyWeakReference(int message);

    internal void OnError(SqlException exception, bool breakConnection);

    internal void OnInfoMessage(SqlInfoMessageEventArgs imevent);

    public override void Open();

    internal void PermissionDemand();

    private static void RefreshMemoryMappedData(SqlDebugContext sdc);

    internal void RemovePreparedCommand(SqlCommand cmd);

    internal void RemoveWeakReference(object value);

    public void ResetStatistics();

    public IDictionary RetrieveStatistics();

    internal void SetInnerConnectionEvent(DbConnectionInternal to);

    internal bool SetInnerConnectionFrom(DbConnectionInternal to, DbConnectionInternal from);

    internal void SetInnerConnectionTo(DbConnectionInternal to);

    object ICloneable.Clone();

    private void UpdateStatistics();

    internal void ValidateConnectionForExecute(string method, SqlCommand command);

    [Conditional("DEBUG")]

    internal static void VerifyExecutePermission();

 

    // Properties

    internal bool AsycCommandInProgress { get; [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)] set; }

    internal bool Asynchronous { get; }

    internal int CloseCount { get; }

    internal DbConnectionFactory ConnectionFactory { get; }

    internal DbConnectionOptions ConnectionOptions { get; }

    [Editor("Microsoft.VSDesigner.Data.SQL.Design.SqlConnectionStringEditor, Microsoft.VSDesigner, Version=8.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", "System.Drawing.Design.UITypeEditor, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"), ResDescription("SqlConnection_ConnectionString"), DefaultValue(""), RecommendedAsConfigurable(true), RefreshProperties(RefreshProperties.All), ResCategory("DataCategory_Data")]

    public override string ConnectionString { get; set; }

    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), ResDescription("SqlConnection_ConnectionTimeout")]

    public override int ConnectionTimeout { get; }

    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), ResDescription("SqlConnection_Database")]

    public override string Database { get; }

    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), Browsable(true), ResDescription("SqlConnection_DataSource")]

    public override string DataSource { get; }

    protected override DbProviderFactory DbProviderFactory { get; }

    public bool FireInfoMessageEventOnUserErrors { get; set; }

    internal bool HasLocalTransaction { get; }

    internal bool HasLocalTransactionFromAPI { get; }

    internal DbConnectionInternal InnerConnection { get; }

    internal bool IsContextConnection { get; }

    internal bool IsKatmaiOrNewer { get; }

    internal bool IsShiloh { get; }

    internal bool IsYukonOrNewer { get; }

    [ResDescription("SqlConnection_PacketSize"), ResCategory("DataCategory_Data"), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

    public int PacketSize { get; }

    internal TdsParser Parser { get; }

    internal DbConnectionPoolGroup PoolGroup { get; set; }

    [ResDescription("SqlConnection_ServerVersion"), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), Browsable(false)]

    public override string ServerVersion { get; }

    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), Browsable(false), ResDescription("DbConnection_State")]

    public override ConnectionState State { get; }

    internal SqlStatistics Statistics { get; }

    [DefaultValue(false), ResDescription("SqlConnection_StatisticsEnabled"), ResCategory("DataCategory_Data")]

    public bool StatisticsEnabled { get; set; }

    internal SqlConnectionString.TransactionBindingEnum TransactionBinding { get; }

    internal SqlConnectionString.TypeSystem TypeSystem { get; }

    internal DbConnectionOptions UserConnectionOptions { get; }

    [ResDescription("SqlConnection_WorkstationId"), ResCategory("DataCategory_Data"), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]

    public string WorkstationId { get; }

}

 

 

 IDbCommand

public interface IDbCommand : IDisposable

{

    // Methods

    void Cancel();

    IDbDataParameter CreateParameter();

    int ExecuteNonQuery();

    IDataReader ExecuteReader();

    IDataReader ExecuteReader(CommandBehavior behavior);

    object ExecuteScalar();

    void Prepare();

 

    // Properties

    string CommandText { get; set; }

    int CommandTimeout { get; set; }

    CommandType CommandType { get; set; }

    IDbConnection Connection { get; set; }

    IDataParameterCollection Parameters { get; }

    IDbTransaction Transaction { get; set; }

    UpdateRowSource UpdatedRowSource { get; set; }

}

 DbCommand

public abstract class DbCommand : Component, IDbCommand, IDisposable

{

    // Methods

    protected DbCommand();

    public abstract void Cancel();

    protected abstract DbParameter CreateDbParameter();

    public DbParameter CreateParameter();

    protected abstract DbDataReader ExecuteDbDataReader(CommandBehavior behavior);

    public abstract int ExecuteNonQuery();

    public DbDataReader ExecuteReader();

    public DbDataReader ExecuteReader(CommandBehavior behavior);

    public abstract object ExecuteScalar();

    public abstract void Prepare();

    IDbDataParameter IDbCommand.CreateParameter();

    IDataReader IDbCommand.ExecuteReader();

    IDataReader IDbCommand.ExecuteReader(CommandBehavior behavior);

 

    // Properties

    [ResDescription("DbCommand_CommandText"), DefaultValue(""), RefreshProperties(RefreshProperties.All), ResCategory("DataCategory_Data")]

    public abstract string CommandText { get; set; }

    [ResCategory("DataCategory_Data"), ResDescription("DbCommand_CommandTimeout")]

    public abstract int CommandTimeout { get; set; }

    [ResCategory("DataCategory_Data"), ResDescription("DbCommand_CommandType"), DefaultValue(1), RefreshProperties(RefreshProperties.All)]

    public abstract CommandType CommandType { get; set; }

    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), ResCategory("DataCategory_Data"), DefaultValue((string) null), ResDescription("DbCommand_Connection"), Browsable(false)]

    public DbConnection Connection { get; set; }

    protected abstract DbConnection DbConnection { get; set; }

    protected abstract DbParameterCollection DbParameterCollection { get; }

    protected abstract DbTransaction DbTransaction { get; set; }

    [EditorBrowsable(EditorBrowsableState.Never), DefaultValue(true), DesignOnly(true), Browsable(false)]

    public abstract bool DesignTimeVisible { get; set; }

    [ResDescription("DbCommand_Parameters"), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), Browsable(false), ResCategory("DataCategory_Data")]

    public DbParameterCollection Parameters { get; }

    IDbConnection IDbCommand.Connection { get; set; }

    IDataParameterCollection IDbCommand.Parameters { get; }

    IDbTransaction IDbCommand.Transaction { get; set; }

    [DefaultValue((string) null), Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), ResDescription("DbCommand_Transaction")]

    public DbTransaction Transaction { get; set; }

    [ResCategory("DataCategory_Update"), ResDescription("DbCommand_UpdatedRowSource"), DefaultValue(3)]

    public abstract UpdateRowSource UpdatedRowSource { get; set; }

}

 

 

 SqlCommand

[Designer("Microsoft.VSDesigner.Data.VS.SqlCommandDesigner, Microsoft.VSDesigner, Version=8.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"), ToolboxItem(true), DefaultEvent("RecordsAffected")]

public sealed class SqlCommand : DbCommand, ICloneable

{

    // Fields

    private SqlConnection _activeConnection;

    private bool _batchRPCMode;

    private CachedAsyncState _cachedAsyncState;

    private _SqlMetaDataSet _cachedMetaData;

    private string _commandText;

    private int _commandTimeout;

   private CommandType _commandType;

    private int _currentlyExecutingBatch;

    private bool _designTimeInvisible;

    private bool _dirty;

    private EXECTYPE _execType;

    private bool _hiddenPrepare;

    private bool _inPrepare;

    private SqlNotificationRequest _notification;

    private bool _notificationAutoEnlist;

    private static int _objectTypeCount;

    private SmiEventSink_DeferedProcessing _outParamEventSink;

    private List<SqlParameterCollection> _parameterCollectionList;

    private SqlParameterCollection _parameters;

    private volatile bool _pendingCancel;

    private int _prepareHandle;

    internal int _rowsAffected;

    private _SqlRPC[] _rpcArrayOf1;

    private List<_SqlRPC> _RPCList;

    private CommandEventSink _smiEventSink;

    private SmiRequestExecutor _smiRequest;

    private SmiContext _smiRequestContext;

    internal SqlDependency _sqlDep;

    private _SqlRPC[] _SqlRPCBatchArray;

    private StatementCompletedEventHandler _statementCompletedEventHandler;

    private TdsParserStateObject _stateObj;

    private SqlTransaction _transaction;

    private UpdateRowSource _updatedRowSource;

    internal static readonly string[] KatmaiProcParamsNames;

    internal readonly int ObjectID;

    internal static readonly string[] PreKatmaiProcParamsNames;

 

    // Events

    [ResCategory("DataCategory_StatementCompleted"), ResDescription("DbCommand_StatementCompleted")]

    public event StatementCompletedEventHandler StatementCompleted;

 

    // Methods

    static SqlCommand();

    public SqlCommand();

    private SqlCommand(SqlCommand from);

    public SqlCommand(string cmdText);

    public SqlCommand(string cmdText, SqlConnection connection);

    public SqlCommand(string cmdText, SqlConnection connection, SqlTransaction transaction);

    internal void AddBatchCommand(string commandText, SqlParameterCollection parameters, CommandType cmdType);

    [HostProtection(SecurityAction.LinkDemand, ExternalThreading=true)]

    public IAsyncResult BeginExecuteNonQuery();

    [HostProtection(SecurityAction.LinkDemand, ExternalThreading=true)]

    public IAsyncResult BeginExecuteNonQuery(AsyncCallback callback, object stateObject);

    [HostProtection(SecurityAction.LinkDemand, ExternalThreading=true)]

    public IAsyncResult BeginExecuteReader();

    [HostProtection(SecurityAction.LinkDemand, ExternalThreading=true)]

    public IAsyncResult BeginExecuteReader(CommandBehavior behavior);

    [HostProtection(SecurityAction.LinkDemand, ExternalThreading=true)]

    public IAsyncResult BeginExecuteReader(AsyncCallback callback, object stateObject);

    [HostProtection(SecurityAction.LinkDemand, ExternalThreading=true)]

    public IAsyncResult BeginExecuteReader(AsyncCallback callback, object stateObject, CommandBehavior behavior);

    [HostProtection(SecurityAction.LinkDemand, ExternalThreading=true)]

    public IAsyncResult BeginExecuteXmlReader();

    [HostProtection(SecurityAction.LinkDemand, ExternalThreading=true)]

    public IAsyncResult BeginExecuteXmlReader(AsyncCallback callback, object stateObject);

    private _SqlRPC BuildExecute(bool inSchema);

    private void BuildExecuteSql(CommandBehavior behavior, string commandText, SqlParameterCollection parameters, ref _SqlRPC rpc);

    internal string BuildParamList(TdsParser parser, SqlParameterCollection parameters);

    private _SqlRPC BuildPrepare(CommandBehavior behavior);

    private _SqlRPC BuildPrepExec(CommandBehavior behavior);

    private void BuildRPC(bool inSchema, SqlParameterCollection parameters, ref _SqlRPC rpc);

    private _SqlRPC BuildUnprepare();

    public override void Cancel();

    private void CheckNotificationStateAndAutoEnlist();

    private void CheckThrowSNIException();

    internal void ClearBatchCommand();

    public SqlCommand Clone();

    private SqlDataReader CompleteAsyncExecuteReader();

    private object CompleteExecuteScalar(SqlDataReader ds, bool returnSqlValue);

    private XmlReader CompleteXmlReader(SqlDataReader ds);

    private int CountSendableParameters(SqlParameterCollection parameters);

    protected override DbParameter CreateDbParameter();

    public SqlParameter CreateParameter();

    internal void DeriveParameters();

    protected override void Dispose(bool disposing);

    private void DisposeSmiRequest();

    public int EndExecuteNonQuery(IAsyncResult asyncResult);

    public SqlDataReader EndExecuteReader(IAsyncResult asyncResult);

    public XmlReader EndExecuteXmlReader(IAsyncResult asyncResult);

    internal int ExecuteBatchRPCCommand();

    protected override DbDataReader ExecuteDbDataReader(CommandBehavior behavior);

    public override int ExecuteNonQuery();

    public SqlDataReader ExecuteReader();

    public SqlDataReader ExecuteReader(CommandBehavior behavior);

    internal SqlDataReader ExecuteReader(CommandBehavior behavior, string method);

    public override object ExecuteScalar();

    internal void ExecuteToPipe(SmiContext pipeContext);

    public XmlReader ExecuteXmlReader();

    private void FinishExecuteReader(SqlDataReader ds, RunBehavior runBehavior, string resetOptionsString);

    private string GetCommandText(CommandBehavior behavior);

    private SqlParameterCollection GetCurrentParameterCollection();

    internal SqlException GetErrors(int commandIndex);

    private int GetParameterCount(SqlParameterCollection parameters);

    private SqlParameter GetParameterForOutputValueExtraction(SqlParameterCollection parameters, string paramName, int paramCount);

    internal int? GetRecordsAffected(int commandIndex);

    private string GetResetOptionsString(CommandBehavior behavior);

    private void GetRPCObject(int paramCount, ref _SqlRPC rpc);

    private string GetSetOptionsString(CommandBehavior behavior);

    private void GetStateObject();

    private IAsyncResult InternalBeginExecuteReader(AsyncCallback callback, object stateObject, CommandBehavior behavior);

    private SqlDataReader InternalEndExecuteReader(IAsyncResult asyncResult, string endMethod);

    private int InternalExecuteNonQuery(DbAsyncResult result, string methodName, bool sendToPipe);

    private SqlDataReader InternalPrepare(CommandBehavior behavior);

    private void InternalUnprepare(bool isClosing);

    private void NotifyDependency();

    internal void OnDoneProc();

    internal void OnParameterAvailableSmi(SmiParameterMetaData metaData, ITypedGettersV3 parameterValues, int ordinal);

    internal void OnParametersAvailableSmi(SmiParameterMetaData[] paramMetaData, ITypedGettersV3 parameterValues);

    internal void OnReturnStatus(int status);

    internal void OnReturnValue(SqlReturnValue rec);

    internal void OnStatementCompleted(int recordCount);

    private ParameterDirection ParameterDirectionFromOleDbDirection(short oledbDirection);

    public override void Prepare();

    private void PropertyChanging();

    private void PutStateObject();

    public void ResetCommandTimeout();

    private void RunExecuteNonQuerySmi(bool sendToPipe);

    private void RunExecuteNonQueryTds(string methodName, bool async);

    internal SqlDataReader RunExecuteReader(CommandBehavior cmdBehavior, RunBehavior runBehavior, bool returnStream, string method);

    internal SqlDataReader RunExecuteReader(CommandBehavior cmdBehavior, RunBehavior runBehavior, bool returnStream, string method, DbAsyncResult result);

    private SqlDataReader RunExecuteReaderSmi(CommandBehavior cmdBehavior, RunBehavior runBehavior, bool returnStream);

    private SqlDataReader RunExecuteReaderTds(CommandBehavior cmdBehavior, RunBehavior runBehavior, bool returnStream, bool async);

    private void SetUpRPCParameters(_SqlRPC rpc, int startCount, bool inSchema, SqlParameterCollection parameters);

    private void SetUpSmiRequest(SqlInternalConnectionSmi innerConnection);

    private static bool ShouldSendParameter(SqlParameter p);

    private bool ShouldSerializeCommandTimeout();

    [SecurityPermission(SecurityAction.Assert, Infrastructure=true)]

    internal static string SqlNotificationContext();

    object ICloneable.Clone();

    internal void Unprepare(bool isClosing);

    private static string UnquoteProcedureName(string name, out object groupNumber);

    private static string UnquoteProcedurePart(string part);

    private void ValidateAsyncCommand();

    private void ValidateCommand(string method, bool async);

    private void VerifyEndExecuteState(DbAsyncResult dbAsyncResult, string endMethod);

    private void WaitForAsyncResults(IAsyncResult asyncResult);

 

    // Properties

    internal bool BatchRPCMode { get; set; }

    private CachedAsyncState cachedAsyncState { get; }

    [Editor("Microsoft.VSDesigner.Data.SQL.Design.SqlCommandTextEditor, Microsoft.VSDesigner, Version=8.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", "System.Drawing.Design.UITypeEditor, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"), RefreshProperties(RefreshProperties.All), ResCategory("DataCategory_Data"), ResDescription("DbCommand_CommandText"), DefaultValue("")]

    public override string CommandText { get; set; }

    [ResDescription("DbCommand_CommandTimeout"), ResCategory("DataCategory_Data")]

    public override int CommandTimeout { get; set; }

    [ResCategory("DataCategory_Data"), DefaultValue(1), ResDescription("DbCommand_CommandType"), RefreshProperties(RefreshProperties.All)]

    public override CommandType CommandType { get; set; }

    [DefaultValue((string) null), Editor("Microsoft.VSDesigner.Data.Design.DbConnectionEditor, Microsoft.VSDesigner, Version=8.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", "System.Drawing.Design.UITypeEditor, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"), ResCategory("DataCategory_Data"), ResDescription("DbCommand_Connection")]

    public SqlConnection Connection { get; set; }

    protected override DbConnection DbConnection { get; set; }

    protected override DbParameterCollection DbParameterCollection { get; }

    protected override DbTransaction DbTransaction { get; set; }

    [DefaultValue(true), Browsable(false), EditorBrowsable(EditorBrowsableState.Never), DesignOnly(true)]

    public override bool DesignTimeVisible { get; set; }

    private CommandEventSink EventSink { get; }

    internal int InternalRecordsAffected { get; set; }

    private SqlInternalConnectionSmi InternalSmiConnection { get; }

    private SqlInternalConnectionTds InternalTdsConnection { get; }

    internal bool IsDirty { get; set; }

    private bool IsPrepared { get; }

    private bool IsShiloh { get; }

    private bool IsUserPrepared { get; }

    internal _SqlMetaDataSet MetaData { get; }

    [Browsable(false), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), ResCategory("DataCategory_Notification"), ResDescription("SqlCommand_Notification")]

    public SqlNotificationRequest Notification { get; set; }

    [DefaultValue(true), ResDescription("SqlCommand_NotificationAutoEnlist"), ResCategory("DataCategory_Notification")]

    public bool NotificationAutoEnlist { get; set; }

    private SmiEventSink_DeferedProcessing OutParamEventSink { get; }

    [DesignerSerializationVisibility(DesignerSerializationVisibility.Content), ResCategory("DataCategory_Data"), ResDescription("DbCommand_Parameters")]

    public SqlParameterCollection Parameters { get; }

    internal SqlStatistics Statistics { get; }

    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), ResDescription("DbCommand_Transaction"), Browsable(false)]

    public SqlTransaction Transaction { get; set; }

    [ResCategory("DataCategory_Update"), DefaultValue(3), ResDescription("DbCommand_UpdatedRowSource")]

    public override UpdateRowSource UpdatedRowSource { get; set; }

 

    // Nested Types

    private class CachedAsyncState

    {

        // Fields

        private int _cachedAsyncCloseCount;

        private SqlConnection _cachedAsyncConnection;

        private SqlDataReader _cachedAsyncReader;

        private DbAsyncResult _cachedAsyncResult;

        private RunBehavior _cachedRunBehavior;

        private string _cachedSetOptions;

 

        // Methods

        internal CachedAsyncState();

        internal bool IsActiveConnectionValid(SqlConnection activeConnection);

        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]

        internal void ResetAsyncState();

        internal void SetActiveConnectionAndResult(DbAsyncResult result, SqlConnection activeConnection);

        internal void SetAsyncReaderState(SqlDataReader ds, RunBehavior runBehavior, string optionSettings);

 

        // Properties

        internal SqlDataReader CachedAsyncReader { get; }

        internal RunBehavior CachedRunBehavior { get; }

        internal string CachedSetOptions { get; }

        internal bool PendingAsyncOperation { get; }

    }

 

    private sealed class CommandEventSink : SmiEventSink_Default

    {

        // Fields

        private SqlCommand _command;

 

        // Methods

        internal CommandEventSink(SqlCommand command);

        internal override void BatchCompleted();

        internal override void ParameterAvailable(SmiParameterMetaData metaData, SmiTypedGetterSetter parameterValues, int ordinal);

        internal override void ParametersAvailable(SmiParameterMetaData[] metaData, ITypedGettersV3 parameterValues);

        internal override void StatementCompleted(int rowsAffected);

    }

 

    private enum EXECTYPE

    {

        UNPREPARED,

        PREPAREPENDING,

        PREPARED

    }

}

 

 DbProviderFactories

public static class DbProviderFactories

{

    // Fields

    private static DataSet _configTable;

    private static ConnectionState _initState;

    private static object _lockobj;

    private const string AssemblyQualifiedName = "AssemblyQualifiedName";

    private const string Instance = "Instance";

    private const string InvariantName = "InvariantName";

 

    // Methods

    static DbProviderFactories();

    private static DataSet GetConfigTable();

    public static DbProviderFactory GetFactory(DataRow providerRow);

    public static DbProviderFactory GetFactory(string providerInvariantName);

    public static DataTable GetFactoryClasses();

    private static void Initialize();

}

 

接下再看一下常见的数据访问代码

 

// Create a new database provider factory

DbProviderFactory factory =

DbProviderFactories.GetFactory("System.Data.SqlClient");

// Create the connection object

DbConnection conn = factory.CreateConnection();

// Initialize the connection string

conn.ConnectionString = "... connection string ...";

// Create the command object and set its properties

DbCommand comm = conn.CreateCommand();

comm.CommandText = "GetDepartments";

comm.CommandType = CommandType.StoredProcedure;

// Open the connection

conn.Open();

// Execute the command and save the results in a DataTable

DbDataReader reader = comm.ExecuteReader();

DataTable table = new DataTable();

table.Load(reader);

// Close the reader and the connection

reader.Close();

conn.Close();

DbProviderFactories其实是一个工厂类，他会根据数据连接类型实例化相应的connetion,command,把DbProviderFactories. GetFactory()反编译出来的原代码可以看出结果，代码码如下

public static DbProviderFactory GetFactory(string providerInvariantName)

{

    ADP.CheckArgumentLength(providerInvariantName, "providerInvariantName");

    DataSet configTable = GetConfigTable();

    DataTable table = (configTable != null) ? configTable.Tables["DbProviderFactories"] : null;

    if (table != null)

    {

        DataRow providerRow = table.Rows.Find(providerInvariantName);

        if (providerRow != null)

        {

            return GetFactory(providerRow);

        }

    }

    throw ADP.ConfigProviderNotFound();

}

其中return GetFactory(providerRow);这句话就不必要继续反编译下去了，只要理解他会跟据我们的需要返回相的类型即可，如上面的示例数据访问代码DbProviderFactories.GetFactory("System.Data.SqlClient")会返回SqlConnection对像。

通过下面这的概要类图可以帮助理解