Sql Serverデータベース接続プールの使用について
79532 ワード
最近Javaのデータベース接続プールを使っていますが、C#はSql Serverに対してデータベース接続プールがありますか?
まず、データベース接続文字列が必要です.たとえば、「Data Source=server;Initial Catalog=test;User ID=sa;Password=123456;
実はこの接続文字列の配置は1つのクラスに対応しています:System.Data.SqlClient.SqlConnectionStringBuilderは、このクラスでオンラインの具体的なパラメータを詳細に規定しています.
このクラスの具体的なコードを見てみましょう.
このクラスが継承クラスであることを発見しました:DbConnectionStringBuilder
では、このクラスのソースコードを見てみましょう.
データベース・パラメータの構成については、次のような列挙があります.
クラスの初期値(MaxPoolSize,MinPoolSizeなど)を表示することで、デフォルト値を使用するとほとんどの状況を満たすことができます.特殊な処理が必要な場合は、接続文字列を変更するだけです.
---------------------------------------------------------------------------------------------------------------------------------------------------------------
では、OleDB、ODBC方式、Oracleの接続など、その接続パラメータはどうでしょうか.
……………………………………
まず、データベース接続文字列が必要です.たとえば、「Data Source=server;Initial Catalog=test;User ID=sa;Password=123456;
実はこの接続文字列の配置は1つのクラスに対応しています:System.Data.SqlClient.SqlConnectionStringBuilderは、このクラスでオンラインの具体的なパラメータを詳細に規定しています.
このクラスの具体的なコードを見てみましょう.
[TypeConverter(typeof(SqlConnectionStringBuilderConverter)), DefaultProperty("DataSource")]
public sealed class SqlConnectionStringBuilder : DbConnectionStringBuilder
{
// Fields
private ApplicationIntent _applicationIntent;
private string _applicationName;
private bool _asynchronousProcessing;
private string _attachDBFilename;
private bool _connectionReset;
private int _connectTimeout;
private bool _contextConnection;
private string _currentLanguage;
private string _dataSource;
private bool _encrypt;
private bool _enlist;
private string _failoverPartner;
private string _initialCatalog;
private bool _integratedSecurity;
private static readonly Dictionary<string, Keywords> _keywords;
private int _loadBalanceTimeout;
private int _maxPoolSize;
private int _minPoolSize;
private bool _multipleActiveResultSets;
private bool _multiSubnetFailover;
private string _networkLibrary;
private int _packetSize;
private string _password;
private bool _persistSecurityInfo;
private bool _pooling;
private bool _replication;
private string _transactionBinding;
private bool _trustServerCertificate;
private string _typeSystemVersion;
private string _userID;
private bool _userInstance;
private static readonly string[] _validKeywords;
private string _workstationID;
internal const int KeywordsCount = 0x1f;
// Methods
static SqlConnectionStringBuilder()
{
string[] strArray = new string[0x1f];
strArray[0x1d] = "ApplicationIntent";
strArray[0x17] = "Application Name";
strArray[12] = "Asynchronous Processing";
strArray[2] = "AttachDbFilename";
strArray[13] = "Connection Reset";
strArray[0x1b] = "Context Connection";
strArray[0x10] = "Connect Timeout";
strArray[0x18] = "Current Language";
strArray[0] = "Data Source";
strArray[0x11] = "Encrypt";
strArray[8] = "Enlist";
strArray[1] = "Failover Partner";
strArray[3] = "Initial Catalog";
strArray[4] = "Integrated Security";
strArray[0x13] = "Load Balance Timeout";
strArray[11] = "Max Pool Size";
strArray[10] = "Min Pool Size";
strArray[14] = "MultipleActiveResultSets";
strArray[30] = "MultiSubnetFailover";
strArray[20] = "Network Library";
strArray[0x15] = "Packet Size";
strArray[7] = "Password";
strArray[5] = "Persist Security Info";
strArray[9] = "Pooling";
strArray[15] = "Replication";
strArray[0x1c] = "Transaction Binding";
strArray[0x12] = "TrustServerCertificate";
strArray[0x16] = "Type System Version";
strArray[6] = "User ID";
strArray[0x1a] = "User Instance";
strArray[0x19] = "Workstation ID";
_validKeywords = strArray;
Dictionary<string, Keywords> dictionary = new Dictionary<string, Keywords>(0x34, StringComparer.OrdinalIgnoreCase);
dictionary.Add("ApplicationIntent", Keywords.ApplicationIntent);
dictionary.Add("Application Name", Keywords.ApplicationName);
dictionary.Add("Asynchronous Processing", Keywords.AsynchronousProcessing);
dictionary.Add("AttachDbFilename", Keywords.AttachDBFilename);
dictionary.Add("Connect Timeout", Keywords.ConnectTimeout);
dictionary.Add("Connection Reset", Keywords.ConnectionReset);
dictionary.Add("Context Connection", Keywords.ContextConnection);
dictionary.Add("Current Language", Keywords.CurrentLanguage);
dictionary.Add("Data Source", Keywords.DataSource);
dictionary.Add("Encrypt", Keywords.Encrypt);
dictionary.Add("Enlist", Keywords.Enlist);
dictionary.Add("Failover Partner", Keywords.FailoverPartner);
dictionary.Add("Initial Catalog", Keywords.InitialCatalog);
dictionary.Add("Integrated Security", Keywords.IntegratedSecurity);
dictionary.Add("Load Balance Timeout", Keywords.LoadBalanceTimeout);
dictionary.Add("MultipleActiveResultSets", Keywords.MultipleActiveResultSets);
dictionary.Add("Max Pool Size", Keywords.MaxPoolSize);
dictionary.Add("Min Pool Size", Keywords.MinPoolSize);
dictionary.Add("MultiSubnetFailover", Keywords.MultiSubnetFailover);
dictionary.Add("Network Library", Keywords.NetworkLibrary);
dictionary.Add("Packet Size", Keywords.PacketSize);
dictionary.Add("Password", Keywords.Password);
dictionary.Add("Persist Security Info", Keywords.PersistSecurityInfo);
dictionary.Add("Pooling", Keywords.Pooling);
dictionary.Add("Replication", Keywords.Replication);
dictionary.Add("Transaction Binding", Keywords.TransactionBinding);
dictionary.Add("TrustServerCertificate", Keywords.TrustServerCertificate);
dictionary.Add("Type System Version", Keywords.TypeSystemVersion);
dictionary.Add("User ID", Keywords.UserID);
dictionary.Add("User Instance", Keywords.UserInstance);
dictionary.Add("Workstation ID", Keywords.WorkstationID);
dictionary.Add("app", Keywords.ApplicationName);
dictionary.Add("async", Keywords.AsynchronousProcessing);
dictionary.Add("extended properties", Keywords.AttachDBFilename);
dictionary.Add("initial file name", Keywords.AttachDBFilename);
dictionary.Add("connection timeout", Keywords.ConnectTimeout);
dictionary.Add("timeout", Keywords.ConnectTimeout);
dictionary.Add("language", Keywords.CurrentLanguage);
dictionary.Add("addr", Keywords.DataSource);
dictionary.Add("address", Keywords.DataSource);
dictionary.Add("network address", Keywords.DataSource);
dictionary.Add("server", Keywords.DataSource);
dictionary.Add("database", Keywords.InitialCatalog);
dictionary.Add("trusted_connection", Keywords.IntegratedSecurity);
dictionary.Add("connection lifetime", Keywords.LoadBalanceTimeout);
dictionary.Add("net", Keywords.NetworkLibrary);
dictionary.Add("network", Keywords.NetworkLibrary);
dictionary.Add("pwd", Keywords.Password);
dictionary.Add("persistsecurityinfo", Keywords.PersistSecurityInfo);
dictionary.Add("uid", Keywords.UserID);
dictionary.Add("user", Keywords.UserID);
dictionary.Add("wsid", Keywords.WorkstationID);
_keywords = dictionary;
}
public SqlConnectionStringBuilder()
: this(null)
{
}
public SqlConnectionStringBuilder(string connectionString)
{
this._applicationName = ".Net SqlClient Data Provider";
this._attachDBFilename = "";
this._currentLanguage = "";
this._dataSource = "";
this._failoverPartner = "";
this._initialCatalog = "";
this._networkLibrary = "";
this._password = "";
this._transactionBinding = "Implicit Unbind";
this._typeSystemVersion = "Latest";
this._userID = "";
this._workstationID = "";
this._connectTimeout = 15;
this._maxPoolSize = 100;
this._packetSize = 0x1f40;
this._connectionReset = true;
this._enlist = true;
this._pooling = true;
if (!ADP.IsEmpty(connectionString))
{
base.ConnectionString = connectionString;
}
}
public override void Clear()
{
base.Clear();
for (int i = 0; i < _validKeywords.Length; i++)
{
this.Reset((Keywords)i);
}
}
public override bool ContainsKey(string keyword)
{
ADP.CheckArgumentNull(keyword, "keyword");
return _keywords.ContainsKey(keyword);
}
private static ApplicationIntent ConvertToApplicationIntent(string keyword, object value)
{
return DbConnectionStringBuilderUtil.ConvertToApplicationIntent(keyword, value);
}
private static bool ConvertToBoolean(object value)
{
return DbConnectionStringBuilderUtil.ConvertToBoolean(value);
}
private static int ConvertToInt32(object value)
{
return DbConnectionStringBuilderUtil.ConvertToInt32(value);
}
private static bool ConvertToIntegratedSecurity(object value)
{
return DbConnectionStringBuilderUtil.ConvertToIntegratedSecurity(value);
}
private static string ConvertToString(object value)
{
return DbConnectionStringBuilderUtil.ConvertToString(value);
}
private object GetAt(Keywords index)
{
switch (index)
{
case Keywords.DataSource:
return this.DataSource;
case Keywords.FailoverPartner:
return this.FailoverPartner;
case Keywords.AttachDBFilename:
return this.AttachDBFilename;
case Keywords.InitialCatalog:
return this.InitialCatalog;
case Keywords.IntegratedSecurity:
return this.IntegratedSecurity;
case Keywords.PersistSecurityInfo:
return this.PersistSecurityInfo;
case Keywords.UserID:
return this.UserID;
case Keywords.Password:
return this.Password;
case Keywords.Enlist:
return this.Enlist;
case Keywords.Pooling:
return this.Pooling;
case Keywords.MinPoolSize:
return this.MinPoolSize;
case Keywords.MaxPoolSize:
return this.MaxPoolSize;
case Keywords.AsynchronousProcessing:
return this.AsynchronousProcessing;
case Keywords.ConnectionReset:
return this.ConnectionReset;
case Keywords.MultipleActiveResultSets:
return this.MultipleActiveResultSets;
case Keywords.Replication:
return this.Replication;
case Keywords.ConnectTimeout:
return this.ConnectTimeout;
case Keywords.Encrypt:
return this.Encrypt;
case Keywords.TrustServerCertificate:
return this.TrustServerCertificate;
case Keywords.LoadBalanceTimeout:
return this.LoadBalanceTimeout;
case Keywords.NetworkLibrary:
return this.NetworkLibrary;
case Keywords.PacketSize:
return this.PacketSize;
case Keywords.TypeSystemVersion:
return this.TypeSystemVersion;
case Keywords.ApplicationName:
return this.ApplicationName;
case Keywords.CurrentLanguage:
return this.CurrentLanguage;
case Keywords.WorkstationID:
return this.WorkstationID;
case Keywords.UserInstance:
return this.UserInstance;
case Keywords.ContextConnection:
return this.ContextConnection;
case Keywords.TransactionBinding:
return this.TransactionBinding;
case Keywords.ApplicationIntent:
return this.ApplicationIntent;
case Keywords.MultiSubnetFailover:
return this.MultiSubnetFailover;
}
throw ADP.KeywordNotSupported(_validKeywords[(int)index]);
}
private Keywords GetIndex(string keyword)
{
Keywords keywords;
ADP.CheckArgumentNull(keyword, "keyword");
if (!_keywords.TryGetValue(keyword, out keywords))
{
throw ADP.KeywordNotSupported(keyword);
}
return keywords;
}
protected override void GetProperties(Hashtable propertyDescriptors)
{
foreach (PropertyDescriptor descriptor in TypeDescriptor.GetProperties(this, true))
{
bool flag2 = false;
bool isReadOnly = false;
string displayName = descriptor.DisplayName;
if ("Integrated Security" == displayName)
{
flag2 = true;
isReadOnly = descriptor.IsReadOnly;
}
else
{
if (!("Password" == displayName) && !("User ID" == displayName))
{
continue;
}
isReadOnly = this.IntegratedSecurity;
}
Attribute[] attributesFromCollection = base.GetAttributesFromCollection(descriptor.Attributes);
DbConnectionStringBuilderDescriptor descriptor2 = new DbConnectionStringBuilderDescriptor(descriptor.Name, descriptor.ComponentType, descriptor.PropertyType, isReadOnly, attributesFromCollection);
descriptor2.RefreshOnChange = flag2;
propertyDescriptors[displayName] = descriptor2;
}
base.GetProperties(propertyDescriptors);
}
public override bool Remove(string keyword)
{
Keywords keywords;
ADP.CheckArgumentNull(keyword, "keyword");
if (_keywords.TryGetValue(keyword, out keywords) && base.Remove(_validKeywords[(int)keywords]))
{
this.Reset(keywords);
return true;
}
return false;
}
private void Reset(Keywords index)
{
switch (index)
{
case Keywords.DataSource:
this._dataSource = "";
return;
case Keywords.FailoverPartner:
this._failoverPartner = "";
return;
case Keywords.AttachDBFilename:
this._attachDBFilename = "";
return;
case Keywords.InitialCatalog:
this._initialCatalog = "";
return;
case Keywords.IntegratedSecurity:
this._integratedSecurity = false;
return;
case Keywords.PersistSecurityInfo:
this._persistSecurityInfo = false;
return;
case Keywords.UserID:
this._userID = "";
return;
case Keywords.Password:
this._password = "";
return;
case Keywords.Enlist:
this._enlist = true;
return;
case Keywords.Pooling:
this._pooling = true;
return;
case Keywords.MinPoolSize:
this._minPoolSize = 0;
return;
case Keywords.MaxPoolSize:
this._maxPoolSize = 100;
return;
case Keywords.AsynchronousProcessing:
this._asynchronousProcessing = false;
return;
case Keywords.ConnectionReset:
this._connectionReset = true;
return;
case Keywords.MultipleActiveResultSets:
this._multipleActiveResultSets = false;
return;
case Keywords.Replication:
this._replication = false;
return;
case Keywords.ConnectTimeout:
this._connectTimeout = 15;
return;
case Keywords.Encrypt:
this._encrypt = false;
return;
case Keywords.TrustServerCertificate:
this._trustServerCertificate = false;
return;
case Keywords.LoadBalanceTimeout:
this._loadBalanceTimeout = 0;
return;
case Keywords.NetworkLibrary:
this._networkLibrary = "";
return;
case Keywords.PacketSize:
this._packetSize = 0x1f40;
return;
case Keywords.TypeSystemVersion:
this._typeSystemVersion = "Latest";
return;
case Keywords.ApplicationName:
this._applicationName = ".Net SqlClient Data Provider";
return;
case Keywords.CurrentLanguage:
this._currentLanguage = "";
return;
case Keywords.WorkstationID:
this._workstationID = "";
return;
case Keywords.UserInstance:
this._userInstance = false;
return;
case Keywords.ContextConnection:
this._contextConnection = false;
return;
case Keywords.TransactionBinding:
this._transactionBinding = "Implicit Unbind";
return;
case Keywords.ApplicationIntent:
this._applicationIntent = ApplicationIntent.ReadWrite;
return;
case Keywords.MultiSubnetFailover:
this._multiSubnetFailover = false;
return;
}
throw ADP.KeywordNotSupported(_validKeywords[(int)index]);
}
private void SetApplicationIntentValue(ApplicationIntent value)
{
base["ApplicationIntent"] = DbConnectionStringBuilderUtil.ApplicationIntentToString(value);
}
private void SetValue(string keyword, bool value)
{
base[keyword] = value.ToString(null);
}
private void SetValue(string keyword, int value)
{
base[keyword] = value.ToString((IFormatProvider)null);
}
private void SetValue(string keyword, string value)
{
ADP.CheckArgumentNull(value, keyword);
base[keyword] = value;
}
public override bool ShouldSerialize(string keyword)
{
Keywords keywords;
ADP.CheckArgumentNull(keyword, "keyword");
return (_keywords.TryGetValue(keyword, out keywords) && base.ShouldSerialize(_validKeywords[(int)keywords]));
}
public override bool TryGetValue(string keyword, out object value)
{
Keywords keywords;
if (_keywords.TryGetValue(keyword, out keywords))
{
value = this.GetAt(keywords);
return true;
}
value = null;
return false;
}
// Properties
[ResCategory("DataCategory_Initialization"), DisplayName("ApplicationIntent"), ResDescription("DbConnectionString_ApplicationIntent"), RefreshProperties(RefreshProperties.All)]
public ApplicationIntent ApplicationIntent
{
get
{
return this._applicationIntent;
}
set
{
if (!DbConnectionStringBuilderUtil.IsValidApplicationIntentValue(value))
{
throw ADP.InvalidEnumerationValue(typeof(ApplicationIntent), (int)value);
}
this.SetApplicationIntentValue(value);
this._applicationIntent = value;
}
}
[RefreshProperties(RefreshProperties.All), DisplayName("Application Name"), ResCategory("DataCategory_Context"), ResDescription("DbConnectionString_ApplicationName")]
public string ApplicationName
{
get
{
return this._applicationName;
}
set
{
this.SetValue("Application Name", value);
this._applicationName = value;
}
}
[DisplayName("Asynchronous Processing"), ResCategory("DataCategory_Initialization"), ResDescription("DbConnectionString_AsynchronousProcessing"), RefreshProperties(RefreshProperties.All)]
public bool AsynchronousProcessing
{
get
{
return this._asynchronousProcessing;
}
set
{
this.SetValue("Asynchronous Processing", value);
this._asynchronousProcessing = value;
}
}
[Editor("System.Windows.Forms.Design.FileNameEditor, System.Design, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", "System.Drawing.Design.UITypeEditor, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"), DisplayName("AttachDbFilename"), ResCategory("DataCategory_Source"), ResDescription("DbConnectionString_AttachDBFilename"), RefreshProperties(RefreshProperties.All)]
public string AttachDBFilename
{
get
{
return this._attachDBFilename;
}
set
{
this.SetValue("AttachDbFilename", value);
this._attachDBFilename = value;
}
}
[ResCategory("DataCategory_Pooling"), Browsable(false), DisplayName("Connection Reset"), Obsolete("ConnectionReset has been deprecated. SqlConnection will ignore the 'connection reset' keyword and always reset the connection"), ResDescription("DbConnectionString_ConnectionReset"), RefreshProperties(RefreshProperties.All)]
public bool ConnectionReset
{
get
{
return this._connectionReset;
}
set
{
this.SetValue("Connection Reset", value);
this._connectionReset = value;
}
}
[ResCategory("DataCategory_Initialization"), DisplayName("Connect Timeout"), RefreshProperties(RefreshProperties.All), ResDescription("DbConnectionString_ConnectTimeout")]
public int ConnectTimeout
{
get
{
return this._connectTimeout;
}
set
{
if (value < 0)
{
throw ADP.InvalidConnectionOptionValue("Connect Timeout");
}
this.SetValue("Connect Timeout", value);
this._connectTimeout = value;
}
}
[ResDescription("DbConnectionString_ContextConnection"), RefreshProperties(RefreshProperties.All), ResCategory("DataCategory_Source"), DisplayName("Context Connection")]
public bool ContextConnection
{
get
{
return this._contextConnection;
}
set
{
this.SetValue("Context Connection", value);
this._contextConnection = value;
}
}
[RefreshProperties(RefreshProperties.All), DisplayName("Current Language"), ResCategory("DataCategory_Initialization"), ResDescription("DbConnectionString_CurrentLanguage")]
public string CurrentLanguage
{
get
{
return this._currentLanguage;
}
set
{
this.SetValue("Current Language", value);
this._currentLanguage = value;
}
}
[ResDescription("DbConnectionString_DataSource"), DisplayName("Data Source"), RefreshProperties(RefreshProperties.All), TypeConverter(typeof(SqlDataSourceConverter)), ResCategory("DataCategory_Source")]
public string DataSource
{
get
{
return this._dataSource;
}
set
{
this.SetValue("Data Source", value);
this._dataSource = value;
}
}
[ResCategory("DataCategory_Security"), ResDescription("DbConnectionString_Encrypt"), RefreshProperties(RefreshProperties.All), DisplayName("Encrypt")]
public bool Encrypt
{
get
{
return this._encrypt;
}
set
{
this.SetValue("Encrypt", value);
this._encrypt = value;
}
}
[ResCategory("DataCategory_Pooling"), ResDescription("DbConnectionString_Enlist"), RefreshProperties(RefreshProperties.All), DisplayName("Enlist")]
public bool Enlist
{
get
{
return this._enlist;
}
set
{
this.SetValue("Enlist", value);
this._enlist = value;
}
}
[ResDescription("DbConnectionString_FailoverPartner"), ResCategory("DataCategory_Source"), RefreshProperties(RefreshProperties.All), TypeConverter(typeof(SqlDataSourceConverter)), DisplayName("Failover Partner")]
public string FailoverPartner
{
get
{
return this._failoverPartner;
}
set
{
this.SetValue("Failover Partner", value);
this._failoverPartner = value;
}
}
[ResCategory("DataCategory_Source"), ResDescription("DbConnectionString_InitialCatalog"), RefreshProperties(RefreshProperties.All), TypeConverter(typeof(SqlInitialCatalogConverter)), DisplayName("Initial Catalog")]
public string InitialCatalog
{
get
{
return this._initialCatalog;
}
set
{
this.SetValue("Initial Catalog", value);
this._initialCatalog = value;
}
}
[DisplayName("Integrated Security"), ResCategory("DataCategory_Security"), ResDescription("DbConnectionString_IntegratedSecurity"), RefreshProperties(RefreshProperties.All)]
public bool IntegratedSecurity
{
get
{
return this._integratedSecurity;
}
set
{
this.SetValue("Integrated Security", value);
this._integratedSecurity = value;
}
}
public override bool IsFixedSize
{
get
{
return true;
}
}
public override object this[string keyword]
{
get
{
Keywords index = this.GetIndex(keyword);
return this.GetAt(index);
}
set
{
if (value != null)
{
switch (this.GetIndex(keyword))
{
case Keywords.DataSource:
this.DataSource = ConvertToString(value);
return;
case Keywords.FailoverPartner:
this.FailoverPartner = ConvertToString(value);
return;
case Keywords.AttachDBFilename:
this.AttachDBFilename = ConvertToString(value);
return;
case Keywords.InitialCatalog:
this.InitialCatalog = ConvertToString(value);
return;
case Keywords.IntegratedSecurity:
this.IntegratedSecurity = ConvertToIntegratedSecurity(value);
return;
case Keywords.PersistSecurityInfo:
this.PersistSecurityInfo = ConvertToBoolean(value);
return;
case Keywords.UserID:
this.UserID = ConvertToString(value);
return;
case Keywords.Password:
this.Password = ConvertToString(value);
return;
case Keywords.Enlist:
this.Enlist = ConvertToBoolean(value);
return;
case Keywords.Pooling:
this.Pooling = ConvertToBoolean(value);
return;
case Keywords.MinPoolSize:
this.MinPoolSize = ConvertToInt32(value);
return;
case Keywords.MaxPoolSize:
this.MaxPoolSize = ConvertToInt32(value);
return;
case Keywords.AsynchronousProcessing:
this.AsynchronousProcessing = ConvertToBoolean(value);
return;
case Keywords.ConnectionReset:
this.ConnectionReset = ConvertToBoolean(value);
return;
case Keywords.MultipleActiveResultSets:
this.MultipleActiveResultSets = ConvertToBoolean(value);
return;
case Keywords.Replication:
this.Replication = ConvertToBoolean(value);
return;
case Keywords.ConnectTimeout:
this.ConnectTimeout = ConvertToInt32(value);
return;
case Keywords.Encrypt:
this.Encrypt = ConvertToBoolean(value);
return;
case Keywords.TrustServerCertificate:
this.TrustServerCertificate = ConvertToBoolean(value);
return;
case Keywords.LoadBalanceTimeout:
this.LoadBalanceTimeout = ConvertToInt32(value);
return;
case Keywords.NetworkLibrary:
this.NetworkLibrary = ConvertToString(value);
return;
case Keywords.PacketSize:
this.PacketSize = ConvertToInt32(value);
return;
case Keywords.TypeSystemVersion:
this.TypeSystemVersion = ConvertToString(value);
return;
case Keywords.ApplicationName:
this.ApplicationName = ConvertToString(value);
return;
case Keywords.CurrentLanguage:
this.CurrentLanguage = ConvertToString(value);
return;
case Keywords.WorkstationID:
this.WorkstationID = ConvertToString(value);
return;
case Keywords.UserInstance:
this.UserInstance = ConvertToBoolean(value);
return;
case Keywords.ContextConnection:
this.ContextConnection = ConvertToBoolean(value);
return;
case Keywords.TransactionBinding:
this.TransactionBinding = ConvertToString(value);
return;
case Keywords.ApplicationIntent:
this.ApplicationIntent = ConvertToApplicationIntent(keyword, value);
return;
case Keywords.MultiSubnetFailover:
this.MultiSubnetFailover = ConvertToBoolean(value);
return;
}
throw ADP.KeywordNotSupported(keyword);
}
this.Remove(keyword);
}
}
public override ICollection Keys
{
get
{
return new ReadOnlyCollection<string>(_validKeywords);
}
}
[DisplayName("Load Balance Timeout"), ResDescription("DbConnectionString_LoadBalanceTimeout"), RefreshProperties(RefreshProperties.All), ResCategory("DataCategory_Pooling")]
public int LoadBalanceTimeout
{
get
{
return this._loadBalanceTimeout;
}
set
{
if (value < 0)
{
throw ADP.InvalidConnectionOptionValue("Load Balance Timeout");
}
this.SetValue("Load Balance Timeout", value);
this._loadBalanceTimeout = value;
}
}
[DisplayName("Max Pool Size"), ResCategory("DataCategory_Pooling"), ResDescription("DbConnectionString_MaxPoolSize"), RefreshProperties(RefreshProperties.All)]
public int MaxPoolSize
{
get
{
return this._maxPoolSize;
}
set
{
if (value < 1)
{
throw ADP.InvalidConnectionOptionValue("Max Pool Size");
}
this.SetValue("Max Pool Size", value);
this._maxPoolSize = value;
}
}
[ResDescription("DbConnectionString_MinPoolSize"), RefreshProperties(RefreshProperties.All), ResCategory("DataCategory_Pooling"), DisplayName("Min Pool Size")]
public int MinPoolSize
{
get
{
return this._minPoolSize;
}
set
{
if (value < 0)
{
throw ADP.InvalidConnectionOptionValue("Min Pool Size");
}
this.SetValue("Min Pool Size", value);
this._minPoolSize = value;
}
}
[DisplayName("MultipleActiveResultSets"), RefreshProperties(RefreshProperties.All), ResCategory("DataCategory_Advanced"), ResDescription("DbConnectionString_MultipleActiveResultSets")]
public bool MultipleActiveResultSets
{
get
{
return this._multipleActiveResultSets;
}
set
{
this.SetValue("MultipleActiveResultSets", value);
this._multipleActiveResultSets = value;
}
}
[ResDescription("DbConnectionString_MultiSubnetFailover"), DisplayName("MultiSubnetFailover"), ResCategory("DataCategory_Source"), RefreshProperties(RefreshProperties.All)]
public bool MultiSubnetFailover
{
get
{
return this._multiSubnetFailover;
}
set
{
this.SetValue("MultiSubnetFailover", value);
this._multiSubnetFailover = value;
}
}
[ResCategory("DataCategory_Advanced"), DisplayName("Network Library"), TypeConverter(typeof(NetworkLibraryConverter)), ResDescription("DbConnectionString_NetworkLibrary"), RefreshProperties(RefreshProperties.All)]
public string NetworkLibrary
{
get
{
return this._networkLibrary;
}
set
{
if (value != null)
{
switch (value.Trim().ToLower(CultureInfo.InvariantCulture))
{
case "dbmsadsn":
value = "dbmsadsn";
goto Label_011F;
case "dbmsvinn":
value = "dbmsvinn";
goto Label_011F;
case "dbmsspxn":
value = "dbmsspxn";
goto Label_011F;
case "dbmsrpcn":
value = "dbmsrpcn";
goto Label_011F;
case "dbnmpntw":
value = "dbnmpntw";
goto Label_011F;
case "dbmslpcn":
value = "dbmslpcn";
goto Label_011F;
case "dbmssocn":
value = "dbmssocn";
goto Label_011F;
case "dbmsgnet":
value = "dbmsgnet";
goto Label_011F;
}
throw ADP.InvalidConnectionOptionValue("Network Library");
}
Label_011F:
this.SetValue("Network Library", value);
this._networkLibrary = value;
}
}
[ResCategory("DataCategory_Advanced"), RefreshProperties(RefreshProperties.All), ResDescription("DbConnectionString_PacketSize"), DisplayName("Packet Size")]
public int PacketSize
{
get
{
return this._packetSize;
}
set
{
if ((value < 0x200) || (0x8000 < value))
{
throw SQL.InvalidPacketSizeValue();
}
this.SetValue("Packet Size", value);
this._packetSize = value;
}
}
[PasswordPropertyText(true), DisplayName("Password"), ResDescription("DbConnectionString_Password"), RefreshProperties(RefreshProperties.All), ResCategory("DataCategory_Security")]
public string Password
{
get
{
return this._password;
}
set
{
this.SetValue("Password", value);
this._password = value;
}
}
[ResDescription("DbConnectionString_PersistSecurityInfo"), RefreshProperties(RefreshProperties.All), ResCategory("DataCategory_Security"), DisplayName("Persist Security Info")]
public bool PersistSecurityInfo
{
get
{
return this._persistSecurityInfo;
}
set
{
this.SetValue("Persist Security Info", value);
this._persistSecurityInfo = value;
}
}
[ResDescription("DbConnectionString_Pooling"), RefreshProperties(RefreshProperties.All), DisplayName("Pooling"), ResCategory("DataCategory_Pooling")]
public bool Pooling
{
get
{
return this._pooling;
}
set
{
this.SetValue("Pooling", value);
this._pooling = value;
}
}
[DisplayName("Replication"), ResDescription("DbConnectionString_Replication"), ResCategory("DataCategory_Replication"), RefreshProperties(RefreshProperties.All)]
public bool Replication
{
get
{
return this._replication;
}
set
{
this.SetValue("Replication", value);
this._replication = value;
}
}
[ResCategory("DataCategory_Advanced"), ResDescription("DbConnectionString_TransactionBinding"), DisplayName("Transaction Binding"), RefreshProperties(RefreshProperties.All)]
public string TransactionBinding
{
get
{
return this._transactionBinding;
}
set
{
this.SetValue("Transaction Binding", value);
this._transactionBinding = value;
}
}
[ResDescription("DbConnectionString_TrustServerCertificate"), ResCategory("DataCategory_Security"), RefreshProperties(RefreshProperties.All), DisplayName("TrustServerCertificate")]
public bool TrustServerCertificate
{
get
{
return this._trustServerCertificate;
}
set
{
this.SetValue("TrustServerCertificate", value);
this._trustServerCertificate = value;
}
}
[ResDescription("DbConnectionString_TypeSystemVersion"), ResCategory("DataCategory_Advanced"), RefreshProperties(RefreshProperties.All), DisplayName("Type System Version")]
public string TypeSystemVersion
{
get
{
return this._typeSystemVersion;
}
set
{
this.SetValue("Type System Version", value);
this._typeSystemVersion = value;
}
}
[ResCategory("DataCategory_Security"), RefreshProperties(RefreshProperties.All), ResDescription("DbConnectionString_UserID"), DisplayName("User ID")]
public string UserID
{
get
{
return this._userID;
}
set
{
this.SetValue("User ID", value);
this._userID = value;
}
}
[RefreshProperties(RefreshProperties.All), ResDescription("DbConnectionString_UserInstance"), DisplayName("User Instance"), ResCategory("DataCategory_Source")]
public bool UserInstance
{
get
{
return this._userInstance;
}
set
{
this.SetValue("User Instance", value);
this._userInstance = value;
}
}
public override ICollection Values
{
get
{
object[] items = new object[_validKeywords.Length];
for (int i = 0; i < items.Length; i++)
{
items[i] = this.GetAt((Keywords)i);
}
return new ReadOnlyCollection<object>(items);
}
}
[ResDescription("DbConnectionString_WorkstationID"), DisplayName("Workstation ID"), RefreshProperties(RefreshProperties.All), ResCategory("DataCategory_Context")]
public string WorkstationID
{
get
{
return this._workstationID;
}
set
{
this.SetValue("Workstation ID", value);
this._workstationID = value;
}
}
// Nested Types
private enum Keywords
{
DataSource,
FailoverPartner,
AttachDBFilename,
InitialCatalog,
IntegratedSecurity,
PersistSecurityInfo,
UserID,
Password,
Enlist,
Pooling,
MinPoolSize,
MaxPoolSize,
AsynchronousProcessing,
ConnectionReset,
MultipleActiveResultSets,
Replication,
ConnectTimeout,
Encrypt,
TrustServerCertificate,
LoadBalanceTimeout,
NetworkLibrary,
PacketSize,
TypeSystemVersion,
ApplicationName,
CurrentLanguage,
WorkstationID,
UserInstance,
ContextConnection,
TransactionBinding,
ApplicationIntent,
MultiSubnetFailover,
KeywordsCount
}
private sealed class NetworkLibraryConverter : TypeConverter
{
// Fields
private TypeConverter.StandardValuesCollection _standardValues;
private const string NamedPipes = "Named Pipes (DBNMPNTW)";
private const string SharedMemory = "Shared Memory (DBMSLPCN)";
private const string TCPIP = "TCP/IP (DBMSSOCN)";
private const string VIA = "VIA (DBMSGNET)";
// Methods
public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
{
if (!(typeof(string) == sourceType))
{
return base.CanConvertFrom(context, sourceType);
}
return true;
}
public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
{
if (!(typeof(string) == destinationType))
{
return base.CanConvertTo(context, destinationType);
}
return true;
}
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
string x = value as string;
if (x == null)
{
return base.ConvertFrom(context, culture, value);
}
x = x.Trim();
if (StringComparer.OrdinalIgnoreCase.Equals(x, "Named Pipes (DBNMPNTW)"))
{
return "dbnmpntw";
}
if (StringComparer.OrdinalIgnoreCase.Equals(x, "Shared Memory (DBMSLPCN)"))
{
return "dbmslpcn";
}
if (StringComparer.OrdinalIgnoreCase.Equals(x, "TCP/IP (DBMSSOCN)"))
{
return "dbmssocn";
}
if (StringComparer.OrdinalIgnoreCase.Equals(x, "VIA (DBMSGNET)"))
{
return "dbmsgnet";
}
return x;
}
public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
{
string str2 = value as string;
if ((str2 == null) || !(destinationType == typeof(string)))
{
return base.ConvertTo(context, culture, value, destinationType);
}
string str = str2.Trim().ToLower(CultureInfo.InvariantCulture);
if (str == null)
{
return str2;
}
if (!(str == "dbnmpntw"))
{
if (str == "dbmslpcn")
{
return "Shared Memory (DBMSLPCN)";
}
if (str == "dbmssocn")
{
return "TCP/IP (DBMSSOCN)";
}
if (str == "dbmsgnet")
{
return "VIA (DBMSGNET)";
}
return str2;
}
return "Named Pipes (DBNMPNTW)";
}
public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext context)
{
if (context != null)
{
object instance = context.Instance;
}
TypeConverter.StandardValuesCollection valuess = this._standardValues;
if (valuess == null)
{
string[] values = new string[] { "Named Pipes (DBNMPNTW)", "Shared Memory (DBMSLPCN)", "TCP/IP (DBMSSOCN)", "VIA (DBMSGNET)" };
valuess = new TypeConverter.StandardValuesCollection(values);
this._standardValues = valuess;
}
return valuess;
}
public override bool GetStandardValuesExclusive(ITypeDescriptorContext context)
{
return false;
}
public override bool GetStandardValuesSupported(ITypeDescriptorContext context)
{
return true;
}
}
internal sealed class SqlConnectionStringBuilderConverter : ExpandableObjectConverter
{
// Methods
public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
{
return ((typeof(InstanceDescriptor) == destinationType) || base.CanConvertTo(context, destinationType));
}
public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
{
if (destinationType == null)
{
throw ADP.ArgumentNull("destinationType");
}
if (typeof(InstanceDescriptor) == destinationType)
{
SqlConnectionStringBuilder options = value as SqlConnectionStringBuilder;
if (options != null)
{
return this.ConvertToInstanceDescriptor(options);
}
}
return base.ConvertTo(context, culture, value, destinationType);
}
private InstanceDescriptor ConvertToInstanceDescriptor(SqlConnectionStringBuilder options)
{
Type[] types = new Type[] { typeof(string) };
return new InstanceDescriptor(typeof(SqlConnectionStringBuilder).GetConstructor(types), new object[] { options.ConnectionString });
}
}
private sealed class SqlDataSourceConverter : StringConverter
{
// Fields
private TypeConverter.StandardValuesCollection _standardValues;
// Methods
public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext context)
{
TypeConverter.StandardValuesCollection valuess = this._standardValues;
if (this._standardValues == null)
{
DataTable dataSources = SqlClientFactory.Instance.CreateDataSourceEnumerator().GetDataSources();
DataColumn column2 = dataSources.Columns["ServerName"];
DataColumn column = dataSources.Columns["InstanceName"];
DataRowCollection rows = dataSources.Rows;
string[] array = new string[rows.Count];
for (int i = 0; i < array.Length; i++)
{
string str2 = rows[i][column2] as string;
string str = rows[i][column] as string;
if (((str == null) || (str.Length == 0)) || ("MSSQLSERVER" == str))
{
array[i] = str2;
}
else
{
array[i] = str2 + @"\" + str;
}
}
Array.Sort<string>(array);
valuess = new TypeConverter.StandardValuesCollection(array);
this._standardValues = valuess;
}
return valuess;
}
public override bool GetStandardValuesExclusive(ITypeDescriptorContext context)
{
return false;
}
public override bool GetStandardValuesSupported(ITypeDescriptorContext context)
{
return true;
}
}
private sealed class SqlInitialCatalogConverter : StringConverter
{
// Methods
public override TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext context)
{
if (!this.GetStandardValuesSupportedInternal(context))
{
return null;
}
List<string> values = new List<string>();
try
{
SqlConnectionStringBuilder instance = (SqlConnectionStringBuilder)context.Instance;
using (SqlConnection connection = new SqlConnection())
{
connection.ConnectionString = instance.ConnectionString;
connection.Open();
foreach (DataRow row in connection.GetSchema("DATABASES").Rows)
{
string item = (string)row["database_name"];
values.Add(item);
}
}
}
catch (SqlException exception)
{
ADP.TraceExceptionWithoutRethrow(exception);
}
return new TypeConverter.StandardValuesCollection(values);
}
public override bool GetStandardValuesExclusive(ITypeDescriptorContext context)
{
return false;
}
public override bool GetStandardValuesSupported(ITypeDescriptorContext context)
{
return this.GetStandardValuesSupportedInternal(context);
}
private bool GetStandardValuesSupportedInternal(ITypeDescriptorContext context)
{
bool flag = false;
if (context == null)
{
return flag;
}
SqlConnectionStringBuilder instance = context.Instance as SqlConnectionStringBuilder;
if (((instance == null) || (0 >= instance.DataSource.Length)) || (!instance.IntegratedSecurity && (0 >= instance.UserID.Length)))
{
return flag;
}
return true;
}
}
}
このクラスが継承クラスであることを発見しました:DbConnectionStringBuilder
では、このクラスのソースコードを見てみましょう.
public class DbConnectionStringBuilder : IDictionary, ICollection, IEnumerable, ICustomTypeDescriptor
{
// Fields
private bool _browsableConnectionString;
private string _connectionString;
private Dictionary<string, object> _currentValues;
internal readonly int _objectID;
private static int _objectTypeCount;
private PropertyDescriptorCollection _propertyDescriptors;
private readonly bool UseOdbcRules;
// Methods
public DbConnectionStringBuilder()
{
this._connectionString = "";
this._browsableConnectionString = true;
this._objectID = Interlocked.Increment(ref _objectTypeCount);
}
public DbConnectionStringBuilder(bool useOdbcRules)
{
this._connectionString = "";
this._browsableConnectionString = true;
this._objectID = Interlocked.Increment(ref _objectTypeCount);
this.UseOdbcRules = useOdbcRules;
}
public void Add(string keyword, object value)
{
this[keyword] = value;
}
public static void AppendKeyValuePair(StringBuilder builder, string keyword, string value)
{
DbConnectionOptions.AppendKeyValuePairBuilder(builder, keyword, value, false);
}
public static void AppendKeyValuePair(StringBuilder builder, string keyword, string value, bool useOdbcRules)
{
DbConnectionOptions.AppendKeyValuePairBuilder(builder, keyword, value, useOdbcRules);
}
public virtual void Clear()
{
Bid.Trace("<comm.DbConnectionStringBuilder.Clear|API>
");
this._connectionString = "";
this._propertyDescriptors = null;
this.CurrentValues.Clear();
}
protected internal void ClearPropertyDescriptors()
{
this._propertyDescriptors = null;
}
public virtual bool ContainsKey(string keyword)
{
ADP.CheckArgumentNull(keyword, "keyword");
return this.CurrentValues.ContainsKey(keyword);
}
public virtual bool EquivalentTo(DbConnectionStringBuilder connectionStringBuilder)
{
ADP.CheckArgumentNull(connectionStringBuilder, "connectionStringBuilder");
Bid.Trace("<comm.DbConnectionStringBuilder.EquivalentTo|API> %d#, connectionStringBuilder=%d#
", this.ObjectID, connectionStringBuilder.ObjectID);
if ((base.GetType() != connectionStringBuilder.GetType()) || (this.CurrentValues.Count != connectionStringBuilder.CurrentValues.Count))
{
return false;
}
foreach (KeyValuePair<string, object> pair in this.CurrentValues)
{
object obj2;
if (!connectionStringBuilder.CurrentValues.TryGetValue(pair.Key, out obj2) || !pair.Value.Equals(obj2))
{
return false;
}
}
return true;
}
internal Attribute[] GetAttributesFromCollection(AttributeCollection collection)
{
Attribute[] array = new Attribute[collection.Count];
collection.CopyTo(array, 0);
return array;
}
private PropertyDescriptorCollection GetProperties()
{
PropertyDescriptorCollection descriptors = this._propertyDescriptors;
if (descriptors == null)
{
IntPtr ptr;
Bid.ScopeEnter(out ptr, "<comm.DbConnectionStringBuilder.GetProperties|INFO> %d#", this.ObjectID);
try
{
Hashtable propertyDescriptors = new Hashtable(StringComparer.OrdinalIgnoreCase);
this.GetProperties(propertyDescriptors);
PropertyDescriptor[] array = new PropertyDescriptor[propertyDescriptors.Count];
propertyDescriptors.Values.CopyTo(array, 0);
descriptors = new PropertyDescriptorCollection(array);
this._propertyDescriptors = descriptors;
}
finally
{
Bid.ScopeLeave(ref ptr);
}
}
return descriptors;
}
protected virtual void GetProperties(Hashtable propertyDescriptors)
{
IntPtr ptr;
Bid.ScopeEnter(out ptr, "<comm.DbConnectionStringBuilder.GetProperties|API> %d#", this.ObjectID);
try
{
Attribute[] attributesFromCollection;
foreach (PropertyDescriptor descriptor in TypeDescriptor.GetProperties(this, true))
{
if ("ConnectionString" != descriptor.Name)
{
string displayName = descriptor.DisplayName;
if (!propertyDescriptors.ContainsKey(displayName))
{
attributesFromCollection = this.GetAttributesFromCollection(descriptor.Attributes);
PropertyDescriptor descriptor3 = new DbConnectionStringBuilderDescriptor(descriptor.Name, descriptor.ComponentType, descriptor.PropertyType, descriptor.IsReadOnly, attributesFromCollection);
propertyDescriptors[displayName] = descriptor3;
}
}
else
{
if (this.BrowsableConnectionString)
{
propertyDescriptors["ConnectionString"] = descriptor;
continue;
}
propertyDescriptors.Remove("ConnectionString");
}
}
if (!this.IsFixedSize)
{
attributesFromCollection = null;
foreach (string str in this.Keys)
{
Type type;
if (propertyDescriptors.ContainsKey(str))
{
continue;
}
object obj2 = this[str];
if (obj2 != null)
{
type = obj2.GetType();
if (typeof(string) == type)
{
int num;
if (int.TryParse((string) obj2, out num))
{
type = typeof(int);
}
else
{
bool flag;
if (bool.TryParse((string) obj2, out flag))
{
type = typeof(bool);
}
}
}
}
else
{
type = typeof(string);
}
Attribute[] attributes = attributesFromCollection;
if (StringComparer.OrdinalIgnoreCase.Equals("Password", str) || StringComparer.OrdinalIgnoreCase.Equals("pwd", str))
{
attributes = new Attribute[] { BrowsableAttribute.Yes, PasswordPropertyTextAttribute.Yes, new ResCategoryAttribute("DataCategory_Security"), RefreshPropertiesAttribute.All };
}
else if (attributesFromCollection == null)
{
attributesFromCollection = new Attribute[] { BrowsableAttribute.Yes, RefreshPropertiesAttribute.All };
attributes = attributesFromCollection;
}
PropertyDescriptor descriptor2 = new DbConnectionStringBuilderDescriptor(str, base.GetType(), type, false, attributes);
propertyDescriptors[str] = descriptor2;
}
}
}
finally
{
Bid.ScopeLeave(ref ptr);
}
}
private PropertyDescriptorCollection GetProperties(Attribute[] attributes)
{
PropertyDescriptorCollection properties = this.GetProperties();
if ((attributes == null) || (attributes.Length == 0))
{
return properties;
}
PropertyDescriptor[] sourceArray = new PropertyDescriptor[properties.Count];
int index = 0;
foreach (PropertyDescriptor descriptor in properties)
{
bool flag = true;
foreach (Attribute attribute in attributes)
{
Attribute attribute2 = descriptor.Attributes[attribute.GetType()];
if (((attribute2 == null) && !attribute.IsDefaultAttribute()) || !attribute2.Match(attribute))
{
flag = false;
break;
}
}
if (flag)
{
sourceArray[index] = descriptor;
index++;
}
}
PropertyDescriptor[] destinationArray = new PropertyDescriptor[index];
Array.Copy(sourceArray, destinationArray, index);
return new PropertyDescriptorCollection(destinationArray);
}
private string ObjectToString(object keyword)
{
string str;
try
{
str = (string) keyword;
}
catch (InvalidCastException)
{
throw new ArgumentException("keyword", "not a string");
}
return str;
}
public virtual bool Remove(string keyword)
{
Bid.Trace("<comm.DbConnectionStringBuilder.Remove|API> %d#, keyword='%ls'
", this.ObjectID, keyword);
ADP.CheckArgumentNull(keyword, "keyword");
if (this.CurrentValues.Remove(keyword))
{
this._connectionString = null;
this._propertyDescriptors = null;
return true;
}
return false;
}
public virtual bool ShouldSerialize(string keyword)
{
ADP.CheckArgumentNull(keyword, "keyword");
return this.CurrentValues.ContainsKey(keyword);
}
void ICollection.CopyTo(Array array, int index)
{
Bid.Trace("<comm.DbConnectionStringBuilder.ICollection.CopyTo|API> %d#
", this.ObjectID);
this.Collection.CopyTo(array, index);
}
void IDictionary.Add(object keyword, object value)
{
this.Add(this.ObjectToString(keyword), value);
}
bool IDictionary.Contains(object keyword)
{
return this.ContainsKey(this.ObjectToString(keyword));
}
IDictionaryEnumerator IDictionary.GetEnumerator()
{
Bid.Trace("<comm.DbConnectionStringBuilder.IDictionary.GetEnumerator|API> %d#
", this.ObjectID);
return this.Dictionary.GetEnumerator();
}
void IDictionary.Remove(object keyword)
{
this.Remove(this.ObjectToString(keyword));
}
IEnumerator IEnumerable.GetEnumerator()
{
Bid.Trace("<comm.DbConnectionStringBuilder.IEnumerable.GetEnumerator|API> %d#
", this.ObjectID);
return this.Collection.GetEnumerator();
}
AttributeCollection ICustomTypeDescriptor.GetAttributes()
{
return TypeDescriptor.GetAttributes(this, true);
}
string ICustomTypeDescriptor.GetClassName()
{
return TypeDescriptor.GetClassName(this, true);
}
string ICustomTypeDescriptor.GetComponentName()
{
return TypeDescriptor.GetComponentName(this, true);
}
TypeConverter ICustomTypeDescriptor.GetConverter()
{
return TypeDescriptor.GetConverter(this, true);
}
EventDescriptor ICustomTypeDescriptor.GetDefaultEvent()
{
return TypeDescriptor.GetDefaultEvent(this, true);
}
PropertyDescriptor ICustomTypeDescriptor.GetDefaultProperty()
{
return TypeDescriptor.GetDefaultProperty(this, true);
}
object ICustomTypeDescriptor.GetEditor(Type editorBaseType)
{
return TypeDescriptor.GetEditor(this, editorBaseType, true);
}
EventDescriptorCollection ICustomTypeDescriptor.GetEvents()
{
return TypeDescriptor.GetEvents(this, true);
}
EventDescriptorCollection ICustomTypeDescriptor.GetEvents(Attribute[] attributes)
{
return TypeDescriptor.GetEvents(this, attributes, true);
}
PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties()
{
return this.GetProperties();
}
PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties(Attribute[] attributes)
{
return this.GetProperties(attributes);
}
object ICustomTypeDescriptor.GetPropertyOwner(PropertyDescriptor pd)
{
return this;
}
public override string ToString()
{
return this.ConnectionString;
}
public virtual bool TryGetValue(string keyword, out object value)
{
ADP.CheckArgumentNull(keyword, "keyword");
return this.CurrentValues.TryGetValue(keyword, out value);
}
// Properties
[DesignOnly(true), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
public bool BrowsableConnectionString
{
get
{
return this._browsableConnectionString;
}
set
{
this._browsableConnectionString = value;
this._propertyDescriptors = null;
}
}
private ICollection Collection
{
get
{
return this.CurrentValues;
}
}
[RefreshProperties(RefreshProperties.All), ResDescription("DbConnectionString_ConnectionString"), ResCategory("DataCategory_Data")]
public string ConnectionString
{
get
{
Bid.Trace("<comm.DbConnectionStringBuilder.get_ConnectionString|API> %d#
", this.ObjectID);
string str = this._connectionString;
if (str == null)
{
StringBuilder builder = new StringBuilder();
foreach (string str2 in this.Keys)
{
object obj2;
if (this.ShouldSerialize(str2) && this.TryGetValue(str2, out obj2))
{
string str3 = (obj2 != null) ? Convert.ToString(obj2, CultureInfo.InvariantCulture) : null;
AppendKeyValuePair(builder, str2, str3, this.UseOdbcRules);
}
}
str = builder.ToString();
this._connectionString = str;
}
return str;
}
set
{
Bid.Trace("<comm.DbConnectionStringBuilder.set_ConnectionString|API> %d#
", this.ObjectID);
DbConnectionOptions options = new DbConnectionOptions(value, null, this.UseOdbcRules);
string connectionString = this.ConnectionString;
this.Clear();
try
{
for (NameValuePair pair = options.KeyChain; pair != null; pair = pair.Next)
{
if (pair.Value != null)
{
this[pair.Name] = pair.Value;
}
else
{
this.Remove(pair.Name);
}
}
this._connectionString = null;
}
catch (ArgumentException)
{
this.ConnectionString = connectionString;
this._connectionString = connectionString;
throw;
}
}
}
[Browsable(false)]
public virtual int Count
{
get
{
return this.CurrentValues.Count;
}
}
private Dictionary<string, object> CurrentValues
{
get
{
Dictionary<string, object> dictionary = this._currentValues;
if (dictionary == null)
{
dictionary = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
this._currentValues = dictionary;
}
return dictionary;
}
}
private IDictionary Dictionary
{
get
{
return this.CurrentValues;
}
}
[Browsable(false)]
public virtual bool IsFixedSize
{
get
{
return false;
}
}
[Browsable(false)]
public bool IsReadOnly
{
get
{
return false;
}
}
[Browsable(false)]
public virtual object this[string keyword]
{
get
{
object obj2;
Bid.Trace("<comm.DbConnectionStringBuilder.get_Item|API> %d#, keyword='%ls'
", this.ObjectID, keyword);
ADP.CheckArgumentNull(keyword, "keyword");
if (!this.CurrentValues.TryGetValue(keyword, out obj2))
{
throw ADP.KeywordNotSupported(keyword);
}
return obj2;
}
set
{
ADP.CheckArgumentNull(keyword, "keyword");
bool flag = false;
if (value != null)
{
string str = DbConnectionStringBuilderUtil.ConvertToString(value);
DbConnectionOptions.ValidateKeyValuePair(keyword, str);
flag = this.CurrentValues.ContainsKey(keyword);
this.CurrentValues[keyword] = str;
}
else
{
flag = this.Remove(keyword);
}
this._connectionString = null;
if (flag)
{
this._propertyDescriptors = null;
}
}
}
[Browsable(false)]
public virtual ICollection Keys
{
get
{
Bid.Trace("<comm.DbConnectionStringBuilder.Keys|API> %d#
", this.ObjectID);
return this.Dictionary.Keys;
}
}
internal int ObjectID
{
get
{
return this._objectID;
}
}
bool ICollection.IsSynchronized
{
get
{
return this.Collection.IsSynchronized;
}
}
object ICollection.SyncRoot
{
get
{
return this.Collection.SyncRoot;
}
}
object IDictionary.this[object keyword]
{
get
{
return this[this.ObjectToString(keyword)];
}
set
{
this[this.ObjectToString(keyword)] = value;
}
}
[Browsable(false)]
public virtual ICollection Values
{
get
{
Bid.Trace("<comm.DbConnectionStringBuilder.Values|API> %d#
", this.ObjectID);
ICollection<string> keys = (ICollection<string>) this.Keys;
IEnumerator<string> enumerator = keys.GetEnumerator();
object[] items = new object[keys.Count];
for (int i = 0; i < items.Length; i++)
{
enumerator.MoveNext();
items[i] = this[enumerator.Current];
}
return new ReadOnlyCollection<object>(items);
}
}
}
Collapse Methods
データベース・パラメータの構成については、次のような列挙があります.
private enum Keywords
{
DataSource,// SQL Server
FailoverPartner,//
AttachDBFilename,// 。
InitialCatalog,//
IntegratedSecurity,// ， ID （ false ）， Windows （ true ）
PersistSecurityInfo,// ， ， （ ）
UserID,// SQL Server ID
Password,//SQL Server
Enlist,// ， SQL Server
Pooling,// ，
MinPoolSize,//
MaxPoolSize,//
AsynchronousProcessing,// ，
ConnectionReset,// ， ( )
MultipleActiveResultSets,// ，
Replication,// ，
ConnectTimeout,// ， （ ）
Encrypt,// ， ，SQL Server SSL
TrustServerCertificate,//
LoadBalanceTimeout,// （ ）
NetworkLibrary,// ， SQL Server
PacketSize,// SQL Server （ ）
TypeSystemVersion,// ，
ApplicationName,// , ， “.NET SqlClient Data Provider”
CurrentLanguage,// SQL Server
WorkstationID,// SQL Server
UserInstance,// SQL Server Express
ContextConnection,// SQL Server /
TransactionBinding,// ， System.Transactions
ApplicationIntent,
MultiSubnetFailover,
KeywordsCount
}クラスの初期値(MaxPoolSize,MinPoolSizeなど)を表示することで、デフォルト値を使用するとほとんどの状況を満たすことができます.特殊な処理が必要な場合は、接続文字列を変更するだけです.
---------------------------------------------------------------------------------------------------------------------------------------------------------------
では、OleDB、ODBC方式、Oracleの接続など、その接続パラメータはどうでしょうか.
……………………………………