2c051c3d51
Former-commit-id: 4f1f69b42e04def9a697c2550b23b9cae645ef29
865 lines
29 KiB
C#
865 lines
29 KiB
C#
//
|
|
// System.Data.SqlClient.SqlConnectionStringBuilder.cs
|
|
//
|
|
// Author:
|
|
// Sureshkumar T (tsureshkumar@novell.com)
|
|
//
|
|
// 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.
|
|
//
|
|
|
|
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")]
|
|
[TypeConverterAttribute ("System.Data.SqlClient.SqlConnectionStringBuilder+SqlConnectionStringBuilderConverter, " + Consts.AssemblySystem_Data)]
|
|
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;
|
|
}
|
|
}
|
|
|
|
[Editor ("System.Windows.Forms.Design.FileNameEditor, " + Consts.AssemblySystem_Design,
|
|
"System.Drawing.Design.UITypeEditor, " + Consts.AssemblySystem_Drawing)]
|
|
[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)]
|
|
[TypeConverterAttribute ("System.Data.SqlClient.SqlConnectionStringBuilder+SqlDataSourceConverter, " + Consts.AssemblySystem_Data)]
|
|
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)]
|
|
[TypeConverterAttribute ("System.Data.SqlClient.SqlConnectionStringBuilder+SqlDataSourceConverter, " + Consts.AssemblySystem_Data)]
|
|
public string FailoverPartner {
|
|
get { return _failoverPartner; }
|
|
set {
|
|
base ["Failover Partner"] = value;
|
|
_failoverPartner = value;
|
|
}
|
|
}
|
|
|
|
[DisplayNameAttribute ("Initial Catalog")]
|
|
[RefreshPropertiesAttribute (RefreshProperties.All)]
|
|
[TypeConverterAttribute ("System.Data.SqlClient.SqlConnectionStringBuilder+SqlInitialCatalogConverter, " + Consts.AssemblySystem_Data)]
|
|
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)]
|
|
[TypeConverterAttribute ("System.Data.SqlClient.SqlConnectionStringBuilder+NetworkLibraryConverter, " + Consts.AssemblySystem_Data)]
|
|
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
|
|
}
|
|
|
|
|
|
}
|