Files
mono/mcs/class/System.Data/System.Data.SqlClient/SqlConnectionStringBuilder.cs
T
Daniel Morgan 2066f021be 2008-08-27 Daniel Morgan <[email protected]>
* System.Data.SqlClient/SqlConnectionStringBuilder.cs: modified -
	add missing connection options, correct case of some connection options,
	added dictionary for mapping
	defaults, for Item this indexer needs to return a default
	for a valid keyword if it does not exist in the dictionary,
	must override the Keys and Values collection to return all keys
	and values whether or not they exist in the dictionary and if
	they do not then return a default value for Values

svn path=/trunk/mcs/; revision=111781
2008-08-28 02:27:59 +00:00

882 lines
29 KiB
C#

//
// System.Data.SqlClient.SqlConnectionStringBuilder.cs
//
// Author:
// Sureshkumar T ([email protected])
//
// Copyright (C) 2004 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
#if NET_2_0
using System;
using System.Text;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Data;
using System.Data.Common;
using System.ComponentModel;
namespace System.Data.SqlClient
{
[DefaultPropertyAttribute ("DataSource")]
#if NET_2_0
[TypeConverterAttribute ("System.Data.SqlClient.SqlConnectionStringBuilder+SqlConnectionStringBuilderConverter, " + Consts.AssemblySystem_Data)]
#endif
public sealed class SqlConnectionStringBuilder : DbConnectionStringBuilder
{
private const string DEF_APPLICATIONNAME = ".NET SqlClient Data Provider";
private const bool DEF_ASYNCHRONOUSPROCESSING = false;
private const string DEF_ATTACHDBFILENAME = "";
private const bool DEF_CONNECTIONRESET = true;
private const int DEF_CONNECTTIMEOUT = 15;
private const string DEF_CURRENTLANGUAGE = "";
private const string DEF_DATASOURCE = "";
private const bool DEF_ENCRYPT = false;
private const bool DEF_ENLIST = false;
private const string DEF_FAILOVERPARTNER = "";
private const string DEF_INITIALCATALOG = "";
private const bool DEF_INTEGRATEDSECURITY = false;
private const int DEF_LOADBALANCETIMEOUT = 0;
private const int DEF_MAXPOOLSIZE = 100;
private const int DEF_MINPOOLSIZE = 0;
private const bool DEF_MULTIPLEACTIVERESULTSETS = false;
private const string DEF_NETWORKLIBRARY = "";
private const int DEF_PACKETSIZE = 8000;
private const string DEF_PASSWORD = "";
private const bool DEF_PERSISTSECURITYINFO = false;
private const bool DEF_POOLING = true;
private const bool DEF_REPLICATION = false;
private const string DEF_USERID = "";
private const string DEF_WORKSTATIONID = "";
private const string DEF_TYPESYSTEMVERSION = "Latest";
private const bool DEF_TRUSTSERVERCERTIFICATE = false;
private const bool DEF_USERINSTANCE = false;
private const bool DEF_CONTEXTCONNECTION = false;
private const string DEF_TRANSACTIONBINDING = "Implicit Unbind";
#region // Fields
private string _applicationName;
private bool _asynchronousProcessing;
private string _attachDBFilename;
private bool _connectionReset;
private int _connectTimeout;
private string _currentLanguage;
private string _dataSource;
private bool _encrypt;
private bool _enlist;
private string _failoverPartner;
private string _initialCatalog;
private bool _integratedSecurity;
private int _loadBalanceTimeout;
private int _maxPoolSize;
private int _minPoolSize;
private bool _multipleActiveResultSets;
private string _networkLibrary;
private int _packetSize;
private string _password;
private bool _persistSecurityInfo;
private bool _pooling;
private bool _replication;
private string _userID;
private string _workstationID;
private bool _trustServerCertificate;
private string _typeSystemVersion;
private bool _userInstance;
private bool _contextConnection;
private string _transactionBinding;
private static Dictionary <string, string> _keywords; // for mapping duplicate keywords
private static Dictionary <string, object> _defaults;
#endregion // Fields
#region Constructors
public SqlConnectionStringBuilder () : this (String.Empty)
{
}
public SqlConnectionStringBuilder (string connectionString)
{
Init ();
base.ConnectionString = connectionString;
}
static SqlConnectionStringBuilder ()
{
_keywords = new Dictionary <string, string> ();
_keywords ["APP"] = "Application Name";
_keywords ["APPLICATION NAME"] = "Application Name";
_keywords ["ATTACHDBFILENAME"] = "AttachDbFilename";
_keywords ["EXTENDED PROPERTIES"] = "Extended Properties";
_keywords ["INITIAL FILE NAME"] = "Initial File Name";
_keywords ["TIMEOUT"] = "Connect Timeout";
_keywords ["CONNECT TIMEOUT"] = "Connect Timeout";
_keywords ["CONNECTION TIMEOUT"] = "Connect Timeout";
_keywords ["CONNECTION RESET"] = "Connection Reset";
_keywords ["LANGUAGE"] = "Current Language";
_keywords ["CURRENT LANGUAGE"] = "Current Language";
_keywords ["DATA SOURCE"] = "Data Source";
_keywords ["SERVER"] = "Data Source";
_keywords ["ADDRESS"] = "Data Source";
_keywords ["ADDR"] = "Data Source";
_keywords ["NETWORK ADDRESS"] = "Data Source";
_keywords ["ENCRYPT"] = "Encrypt";
_keywords ["ENLIST"] = "Enlist";
_keywords ["INITIAL CATALOG"] = "Initial Catalog";
_keywords ["DATABASE"] = "Initial Catalog";
_keywords ["INTEGRATED SECURITY"] = "Integrated Security";
_keywords ["TRUSTED_CONNECTION"] = "Integrated Security";
_keywords ["MAX POOL SIZE"] = "Max Pool Size";
_keywords ["MIN POOL SIZE"] = "Min Pool Size";
_keywords ["MULTIPLEACTIVERESULTSETS"] = "MultipleActiveResultSets";
_keywords ["ASYNCHRONOUS PROCESSING"] = "Asynchronous Processing";
_keywords ["ASYNC"] = "Async";
_keywords ["NET"] = "Network Library";
_keywords ["NETWORK"] = "Network Library";
_keywords ["NETWORK LIBRARY"] = "Network Library";
_keywords ["PACKET SIZE"] = "Packet Size";
_keywords ["PASSWORD"] = "Password";
_keywords ["PWD"] = "Password";
_keywords ["PERSISTSECURITYINFO"] = "Persist Security Info";
_keywords ["PERSIST SECURITY INFO"] = "Persist Security Info";
_keywords ["POOLING"] = "Pooling";
_keywords ["UID"] = "User ID";
_keywords ["USER"] = "User ID";
_keywords ["USER ID"] = "User ID";
_keywords ["WSID"] = "Workstation ID";
_keywords ["WORKSTATION ID"] = "Workstation ID";
_keywords ["USER INSTANCE"] = "User Instance";
_keywords ["CONTEXT CONNECTION"] = "Context Connection";
_keywords ["TRANSACTION BINDING"] = "Transaction Binding";
_keywords ["FAILOVER PARTNER"] = "Failover Partner";
_keywords ["REPLICATION"] = "Replication";
_keywords ["TRUSTSERVERCERTIFICATE"] = "TrustServerCertificate";
_keywords ["LOAD BALANCE TIMEOUT"] = "Load Balance Timeout";
_keywords ["TYPE SYSTEM VERSION"] = "Type System Version";
_defaults = new Dictionary<string, object> ();
_defaults.Add("Data Source", DEF_DATASOURCE);
_defaults.Add("Failover Partner", DEF_FAILOVERPARTNER);
_defaults.Add("AttachDbFilename", DEF_ATTACHDBFILENAME);
_defaults.Add("Initial Catalog", DEF_INITIALCATALOG);
_defaults.Add("Integrated Security", DEF_INTEGRATEDSECURITY);
_defaults.Add("Persist Security Info", DEF_PERSISTSECURITYINFO);
_defaults.Add("User ID", DEF_USERID);
_defaults.Add("Password", DEF_PASSWORD);
_defaults.Add("Enlist", DEF_ENLIST);
_defaults.Add("Pooling", DEF_POOLING);
_defaults.Add("Min Pool Size", DEF_MINPOOLSIZE);
_defaults.Add("Max Pool Size", DEF_MAXPOOLSIZE);
_defaults.Add("Asynchronous Processing", DEF_ASYNCHRONOUSPROCESSING);
_defaults.Add("Connection Reset", DEF_CONNECTIONRESET);
_defaults.Add("MultipleActiveResultSets", DEF_MULTIPLEACTIVERESULTSETS);
_defaults.Add("Replication", DEF_REPLICATION);
_defaults.Add("Connect Timeout", DEF_CONNECTTIMEOUT);
_defaults.Add("Encrypt", DEF_ENCRYPT);
_defaults.Add("TrustServerCertificate", DEF_TRUSTSERVERCERTIFICATE);
_defaults.Add("Load Balance Timeout", DEF_LOADBALANCETIMEOUT);
_defaults.Add("Network Library", DEF_NETWORKLIBRARY);
_defaults.Add("Packet Size", DEF_PACKETSIZE);
_defaults.Add("Type System Version", DEF_TYPESYSTEMVERSION);
_defaults.Add("Application Name", DEF_APPLICATIONNAME);
_defaults.Add("Current Language", DEF_CURRENTLANGUAGE);
_defaults.Add("Workstation ID", DEF_WORKSTATIONID);
_defaults.Add("User Instance", DEF_USERINSTANCE);
_defaults.Add("Context Connection", DEF_CONTEXTCONNECTION);
_defaults.Add("Transaction Binding", DEF_TRANSACTIONBINDING);
}
#endregion // Constructors
#region Properties
[DisplayNameAttribute ("Application Name")]
[RefreshPropertiesAttribute (RefreshProperties.All)]
public string ApplicationName {
get { return _applicationName; }
set {
base ["Application Name"] = value;
_applicationName = value;
}
}
[DisplayNameAttribute ("Asynchronous Processing")]
[RefreshPropertiesAttribute (RefreshProperties.All)]
public bool AsynchronousProcessing {
get { return _asynchronousProcessing; }
set {
base ["Asynchronous Processing"] = value;
_asynchronousProcessing = value;
}
}
#if NET_2_0
[Editor ("System.Windows.Forms.Design.FileNameEditor, " + Consts.AssemblySystem_Design,
"System.Drawing.Design.UITypeEditor, " + Consts.AssemblySystem_Drawing)]
#else
[Editor ("Microsoft.VSDesigner.Data.Design.DBParametersEditor, " + Consts.AssemblyMicrosoft_VSDesigner,
"System.Drawing.Design.UITypeEditor, " + Consts.AssemblySystem_Drawing)]
#endif
[DisplayNameAttribute ("AttachDbFilename")]
[RefreshPropertiesAttribute (RefreshProperties.All)]
public string AttachDBFilename {
get { return _attachDBFilename; }
set {
base ["AttachDbFilename"] = value;
_attachDBFilename = value;
}
}
[DisplayNameAttribute ("Connection Reset")]
[RefreshPropertiesAttribute (RefreshProperties.All)]
public bool ConnectionReset {
get { return _connectionReset; }
set {
base ["Connection Reset"] = value;
_connectionReset = value;
}
}
[DisplayNameAttribute ("Connect Timeout")]
[RefreshPropertiesAttribute (RefreshProperties.All)]
public int ConnectTimeout {
get { return _connectTimeout; }
set {
base ["Connect Timeout"] = value;
_connectTimeout = value;
}
}
[DisplayNameAttribute ("Current Language")]
[RefreshPropertiesAttribute (RefreshProperties.All)]
public string CurrentLanguage {
get { return _currentLanguage; }
set {
base ["Current Language"] = value;
_currentLanguage = value;
}
}
[DisplayNameAttribute ("Data Source")]
[RefreshPropertiesAttribute (RefreshProperties.All)]
#if NET_2_0
[TypeConverterAttribute ("System.Data.SqlClient.SqlConnectionStringBuilder+SqlDataSourceConverter, " + Consts.AssemblySystem_Data)]
#endif
public string DataSource {
get { return _dataSource; }
set {
base ["Data Source"] = value;
_dataSource = value;
}
}
[DisplayNameAttribute ("Encrypt")]
[RefreshPropertiesAttribute (RefreshProperties.All)]
public bool Encrypt {
get { return _encrypt; }
set {
base ["Encrypt"] = value;
_encrypt = value;
}
}
[DisplayNameAttribute ("Enlist")]
[RefreshPropertiesAttribute (RefreshProperties.All)]
public bool Enlist {
get { return _enlist; }
set {
base ["Enlist"] = value;
_enlist = value;
}
}
[DisplayNameAttribute ("Failover Partner")]
[RefreshPropertiesAttribute (RefreshProperties.All)]
#if NET_2_0
[TypeConverterAttribute ("System.Data.SqlClient.SqlConnectionStringBuilder+SqlDataSourceConverter, " + Consts.AssemblySystem_Data)]
#endif
public string FailoverPartner {
get { return _failoverPartner; }
set {
base ["Failover Partner"] = value;
_failoverPartner = value;
}
}
[DisplayNameAttribute ("Initial Catalog")]
[RefreshPropertiesAttribute (RefreshProperties.All)]
#if NET_2_0
[TypeConverterAttribute ("System.Data.SqlClient.SqlConnectionStringBuilder+SqlInitialCatalogConverter, " + Consts.AssemblySystem_Data)]
#endif
public string InitialCatalog {
get { return _initialCatalog; }
set {
base ["Initial Catalog"] = value;
_initialCatalog = value;
}
}
[DisplayNameAttribute ("Integrated Security")]
[RefreshPropertiesAttribute (RefreshProperties.All)]
public bool IntegratedSecurity {
get { return _integratedSecurity; }
set {
base ["Integrated Security"] = value;
_integratedSecurity = value;
}
}
public override bool IsFixedSize {
get { return true; }
}
public override object this [string keyword] {
get {
string mapped = MapKeyword (keyword);
if (base.ContainsKey (mapped))
return base [mapped];
else
return _defaults [mapped];
}
set {SetValue (keyword, value);}
}
public override ICollection Keys {
get {
List<string> keys = new List<string>();
keys.Add("Data Source");
keys.Add("Failover Partner");
keys.Add("AttachDbFilename");
keys.Add("Initial Catalog");
keys.Add("Integrated Security");
keys.Add("Persist Security Info");
keys.Add("User ID");
keys.Add("Password");
keys.Add("Enlist");
keys.Add("Pooling");
keys.Add("Min Pool Size");
keys.Add("Max Pool Size");
keys.Add("Asynchronous Processing");
keys.Add("Connection Reset");
keys.Add("MultipleActiveResultSets");
keys.Add("Replication");
keys.Add("Connect Timeout");
keys.Add("Encrypt");
keys.Add("TrustServerCertificate");
keys.Add("Load Balance Timeout");
keys.Add("Network Library");
keys.Add("Packet Size");
keys.Add("Type System Version");
keys.Add("Application Name");
keys.Add("Current Language");
keys.Add("Workstation ID");
keys.Add("User Instance");
keys.Add("Context Connection");
keys.Add("Transaction Binding");
ReadOnlyCollection<string> coll = new ReadOnlyCollection<string>(keys);
return coll;
}
}
[DisplayNameAttribute ("Load Balance Timeout")]
[RefreshPropertiesAttribute (RefreshProperties.All)]
public int LoadBalanceTimeout {
get { return _loadBalanceTimeout; }
set {
base ["Load Balance Timeout"] = value;
_loadBalanceTimeout = value;
}
}
[DisplayNameAttribute ("Max Pool Size")]
[RefreshPropertiesAttribute (RefreshProperties.All)]
public int MaxPoolSize {
get { return _maxPoolSize; }
set {
base ["Max Pool Size"] = value;
_maxPoolSize = value;
}
}
[DisplayNameAttribute ("Min Pool Size")]
[RefreshPropertiesAttribute (RefreshProperties.All)]
public int MinPoolSize {
get { return _minPoolSize; }
set {
base ["Min Pool Size"] = value;
_minPoolSize = value;
}
}
[DisplayNameAttribute ("MultipleActiveResultSets")]
[RefreshPropertiesAttribute (RefreshProperties.All)]
public bool MultipleActiveResultSets {
get { return _multipleActiveResultSets; }
set {
base ["Multiple Active Resultsets"] = value;
_multipleActiveResultSets = value;
}
}
[DisplayNameAttribute ("Network Library")]
[RefreshPropertiesAttribute (RefreshProperties.All)]
#if NET_2_0
[TypeConverterAttribute ("System.Data.SqlClient.SqlConnectionStringBuilder+NetworkLibraryConverter, " + Consts.AssemblySystem_Data)]
#endif
public string NetworkLibrary {
get { return _networkLibrary; }
set {
base ["Network Library"] = value;
_networkLibrary = value;
}
}
[DisplayNameAttribute ("Packet Size")]
[RefreshPropertiesAttribute (RefreshProperties.All)]
public int PacketSize {
get { return _packetSize; }
set {
base ["Packet Size"] = value;
_packetSize = value;
}
}
[DisplayNameAttribute ("Password")]
[PasswordPropertyTextAttribute (true)]
[RefreshPropertiesAttribute (RefreshProperties.All)]
public string Password {
get { return _password; }
set {
base ["Password"] = value;
_password = value;
}
}
[DisplayNameAttribute ("Persist Security Info")]
[RefreshPropertiesAttribute (RefreshProperties.All)]
public bool PersistSecurityInfo {
get { return _persistSecurityInfo; }
set {
base ["Persist Security Info"] = value;
_persistSecurityInfo = value;
}
}
[DisplayNameAttribute ("Pooling")]
[RefreshPropertiesAttribute (RefreshProperties.All)]
public bool Pooling {
get { return _pooling; }
set {
base ["Pooling"] = value;
_pooling = value;
}
}
[DisplayNameAttribute ("Replication")]
[RefreshPropertiesAttribute (RefreshProperties.All)]
public bool Replication {
get { return _replication; }
set {
base ["Replication"] = value;
_replication = value;
}
}
[DisplayNameAttribute ("User ID")]
[RefreshPropertiesAttribute (RefreshProperties.All)]
public string UserID {
get { return _userID; }
set {
base ["User Id"]= value;
_userID = value;
}
}
public override ICollection Values {
get {
List<object> values = new List<object>();
values.Add(_dataSource);
values.Add(_failoverPartner);
values.Add(_attachDBFilename);
values.Add(_initialCatalog);
values.Add(_integratedSecurity);
values.Add(_persistSecurityInfo);
values.Add(_userID);
values.Add(_password);
values.Add(_enlist);
values.Add(_pooling);
values.Add(_minPoolSize);
values.Add(_maxPoolSize);
values.Add(_asynchronousProcessing);
values.Add(_connectionReset);
values.Add(_multipleActiveResultSets);
values.Add(_replication);
values.Add(_connectTimeout);
values.Add(_encrypt);
values.Add(_trustServerCertificate);
values.Add(_loadBalanceTimeout);
values.Add(_networkLibrary);
values.Add(_packetSize);
values.Add(_typeSystemVersion);
values.Add(_applicationName);
values.Add(_currentLanguage);
values.Add(_workstationID);
values.Add(_userInstance);
values.Add(_contextConnection);
values.Add(_transactionBinding);
ReadOnlyCollection<object> coll = new ReadOnlyCollection<object>(values);
return coll;
}
}
[DisplayNameAttribute ("Workstation ID")]
[RefreshPropertiesAttribute (RefreshProperties.All)]
public string WorkstationID {
get { return _workstationID; }
set {
base ["Workstation Id"] = value;
_workstationID = value;
}
}
[DisplayNameAttribute ("TrustServerCertificate")]
[RefreshProperties (RefreshProperties.All)]
public bool TrustServerCertificate {
get { return _trustServerCertificate; }
set {
base ["Trust Server Certificate"] = value;
_trustServerCertificate = value;
}
}
[DisplayNameAttribute ("Type System Version")]
[RefreshProperties (RefreshProperties.All)]
public string TypeSystemVersion {
get { return _typeSystemVersion; }
set {
base ["Type System Version"] = value;
_typeSystemVersion = value;
}
}
[DisplayNameAttribute ("User Instance")]
[RefreshProperties (RefreshProperties.All)]
public bool UserInstance {
get { return _userInstance; }
set {
base ["User Instance"] = value;
_userInstance = value;
}
}
[RefreshPropertiesAttribute (RefreshProperties.All)]
[DisplayNameAttribute ("Context Connection")]
public bool ContextConnection {
get { return _contextConnection; }
set {
base ["Context Connection"] = value;
_contextConnection = value;
}
}
#endregion // Properties
#region Methods
private void Init ()
{
_applicationName = DEF_APPLICATIONNAME;
_asynchronousProcessing = DEF_ASYNCHRONOUSPROCESSING;
_attachDBFilename = DEF_ATTACHDBFILENAME;
_connectionReset = DEF_CONNECTIONRESET;
_connectTimeout = DEF_CONNECTTIMEOUT;
_currentLanguage = DEF_CURRENTLANGUAGE;
_dataSource = DEF_DATASOURCE;
_encrypt = DEF_ENCRYPT;
_enlist = DEF_ENLIST;
_failoverPartner = DEF_FAILOVERPARTNER;
_initialCatalog = DEF_INITIALCATALOG;
_integratedSecurity = DEF_INTEGRATEDSECURITY;
_loadBalanceTimeout = DEF_LOADBALANCETIMEOUT;
_maxPoolSize = DEF_MAXPOOLSIZE;
_minPoolSize = DEF_MINPOOLSIZE;
_multipleActiveResultSets= DEF_MULTIPLEACTIVERESULTSETS;
_networkLibrary = DEF_NETWORKLIBRARY;
_packetSize = DEF_PACKETSIZE;
_password = DEF_PASSWORD;
_persistSecurityInfo = DEF_PERSISTSECURITYINFO;
_pooling = DEF_POOLING;
_replication = DEF_REPLICATION;
_userID = DEF_USERID;
_workstationID = DEF_WORKSTATIONID;
_trustServerCertificate = DEF_TRUSTSERVERCERTIFICATE;
_typeSystemVersion = DEF_TYPESYSTEMVERSION;
_userInstance = DEF_USERINSTANCE;
_contextConnection = DEF_CONTEXTCONNECTION;
_transactionBinding = DEF_TRANSACTIONBINDING;
}
public override void Clear ()
{
base.Clear ();
Init ();
}
public override bool ContainsKey (string keyword)
{
keyword = keyword.ToUpper ().Trim ();
if (_keywords.ContainsKey (keyword))
return base.ContainsKey (_keywords [keyword]);
return false;
}
public override bool Remove (string keyword)
{
if (!ContainsKey (keyword))
return false;
this [keyword] = null;
return true;
}
[MonoNotSupported ("")] // Note that base.ShouldSerialize() is called but not implemented
public override bool ShouldSerialize (string keyword)
{
if (!ContainsKey (keyword))
return false;
keyword = keyword.ToUpper ().Trim ();
// Assuming passwords cannot be serialized.
if (_keywords [keyword] == "Password")
return false;
return base.ShouldSerialize (_keywords [keyword]);
}
public override bool TryGetValue (string keyword, out object value)
{
if (! ContainsKey (keyword)) {
value = String.Empty;
return false;
}
return base.TryGetValue (_keywords [keyword.ToUpper ().Trim ()], out value);
}
#endregion // Methods
#region Private Methods
private string MapKeyword (string keyword)
{
keyword = keyword.ToUpper ().Trim ();
if (! _keywords.ContainsKey (keyword))
throw new ArgumentException("Keyword not supported :" + keyword);
return _keywords [keyword];
}
private void SetValue (string key, object value)
{
if (key == null)
throw new ArgumentNullException ("key cannot be null!");
string mappedKey = MapKeyword (key);
switch (mappedKey.ToUpper ().Trim ()) {
case "APPLICATION NAME" :
if (value == null) {
_applicationName = DEF_APPLICATIONNAME;
base.Remove (mappedKey);
} else
this.ApplicationName = value.ToString ();
break;
case "ATTACHDBFILENAME" :
throw new NotImplementedException ("Attachable database support is " +
"not implemented.");
case "CONNECT TIMEOUT" :
if (value == null) {
_connectTimeout = DEF_CONNECTTIMEOUT;
base.Remove (mappedKey);
} else
this.ConnectTimeout = DbConnectionStringBuilderHelper.ConvertToInt32 (value);
break;
case "CONNECTION LIFETIME" :
break;
case "CONNECTION RESET" :
if (value == null) {
_connectionReset = DEF_CONNECTIONRESET;
base.Remove (mappedKey);
} else
this.ConnectionReset = DbConnectionStringBuilderHelper.ConvertToBoolean (value);
break;
case "CURRENT LANGUAGE" :
if (value == null) {
_currentLanguage = DEF_CURRENTLANGUAGE;
base.Remove (mappedKey);
} else
this.CurrentLanguage = value.ToString ();
break;
case "CONTEXT CONNECTION" :
if (value == null) {
_contextConnection = DEF_CONTEXTCONNECTION;
base.Remove (mappedKey);
} else
this.ContextConnection = DbConnectionStringBuilderHelper.ConvertToBoolean (value);
break;
case "DATA SOURCE" :
if (value == null) {
_dataSource = DEF_DATASOURCE;
base.Remove (mappedKey);
} else
this.DataSource = value.ToString ();
break;
case "ENCRYPT":
if (value == null) {
_encrypt = DEF_ENCRYPT;
base.Remove (mappedKey);
}else if (DbConnectionStringBuilderHelper.ConvertToBoolean(value))
throw new NotImplementedException("SSL encryption for"
+ " data sent between client and server is not"
+ " implemented.");
break;
case "ENLIST" :
if (value == null) {
_enlist = DEF_ENLIST;
base.Remove (mappedKey);
} else if ( ! DbConnectionStringBuilderHelper.ConvertToBoolean(value))
throw new NotImplementedException("Disabling the automatic"
+ " enlistment of connections in the thread's current"
+ " transaction context is not implemented.");
break;
case "INITIAL CATALOG" :
if (value == null) {
_initialCatalog = DEF_INITIALCATALOG;
base.Remove (mappedKey);
} else
this.InitialCatalog = value.ToString ();
break;
case "INTEGRATED SECURITY" :
if (value == null) {
_integratedSecurity = DEF_INTEGRATEDSECURITY;
base.Remove (mappedKey);
} else
this.IntegratedSecurity = DbConnectionStringBuilderHelper.ConvertToBoolean (value);
break;
case "MAX POOL SIZE" :
if (value == null) {
_maxPoolSize = DEF_MAXPOOLSIZE;
base.Remove (mappedKey);
} else
this.MaxPoolSize = DbConnectionStringBuilderHelper.ConvertToInt32 (value);
break;
case "MIN POOL SIZE" :
if (value == null) {
_minPoolSize = DEF_MINPOOLSIZE;
base.Remove (mappedKey);
} else
this.MinPoolSize = DbConnectionStringBuilderHelper.ConvertToInt32 (value);
break;
case "MULTIPLEACTIVERESULTSETS":
if (value == null) {
_multipleActiveResultSets = DEF_MULTIPLEACTIVERESULTSETS;
base.Remove (mappedKey);
} else if ( DbConnectionStringBuilderHelper.ConvertToBoolean (value))
throw new NotImplementedException ("MARS is not yet implemented!");
break;
case "ASYNCHRONOUS PROCESSING" :
if (value == null) {
_asynchronousProcessing = DEF_ASYNCHRONOUSPROCESSING;
base.Remove (mappedKey);
} else
this.AsynchronousProcessing = DbConnectionStringBuilderHelper.ConvertToBoolean (value);
break;
case "NETWORK LIBRARY" :
if (value == null) {
_networkLibrary = DEF_NETWORKLIBRARY;
base.Remove (mappedKey);
} else {
if (!value.ToString ().ToUpper ().Equals ("DBMSSOCN"))
throw new ArgumentException ("Unsupported network library.");
this.NetworkLibrary = value.ToString ().ToLower ();
}
break;
case "LOAD BALANCE TIMEOUT":
// TODO: what is this?
break;
case "PACKET SIZE" :
if (value == null) {
_packetSize = DEF_PACKETSIZE;
base.Remove (mappedKey);
} else
this.PacketSize = DbConnectionStringBuilderHelper.ConvertToInt32 (value);
break;
case "PASSWORD" :
if (value == null) {
_password = DEF_PASSWORD;
base.Remove (mappedKey);
} else
this.Password = value.ToString ();
break;
case "PERSIST SECURITY INFO" :
if (value == null) {
_persistSecurityInfo = DEF_PERSISTSECURITYINFO;
base.Remove (mappedKey);
} else if (DbConnectionStringBuilderHelper.ConvertToBoolean (value))
throw new NotImplementedException ("Persisting security info" +
" is not yet implemented");
break;
case "POOLING" :
if (value == null) {
_pooling = DEF_POOLING;
base.Remove (mappedKey);
} else
this.Pooling = DbConnectionStringBuilderHelper.ConvertToBoolean (value);
break;
case "USER ID" :
if (value == null) {
_userID = DEF_USERID;
base.Remove (mappedKey);
} else
this.UserID = value.ToString ();
break;
case "USER INSTANCE" :
if (value == null) {
_userInstance = DEF_USERINSTANCE;
base.Remove (mappedKey);
} else
this.UserInstance = DbConnectionStringBuilderHelper.ConvertToBoolean (value);
break;
case "WORKSTATION ID" :
if (value == null) {
_workstationID = DEF_WORKSTATIONID;
base.Remove (mappedKey);
} else
this.WorkstationID = value.ToString ();
break;
case "TRANSACTION BINDING":
// TODO: what is this?
break;
default :
throw new ArgumentException("Keyword not supported :" + key);
}
}
#endregion // Private Methods
}
}
#endif // NET_2_0