|
//------------------------------------------------------------------------------
// <copyright file="DbConnectionStringBuilder.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
// <owner current="true" primary="true">Microsoft</owner>
// <owner current="true" primary="false">Microsoft</owner>
//------------------------------------------------------------------------------
namespace System.Data.Common {
using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Data.Common;
using System.Diagnostics;
using System.Globalization;
using System.Runtime.Serialization;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Diagnostics.CodeAnalysis;
public class DbConnectionStringBuilder : System.Collections.IDictionary, ICustomTypeDescriptor {
// keyword->value currently listed in the connection string
private Dictionary<string,object> _currentValues;
// cached connectionstring to avoid constant rebuilding
// and to return a user's connectionstring as is until editing occurs
private string _connectionString = "";
private PropertyDescriptorCollection _propertyDescriptors;
private bool _browsableConnectionString = true;
private readonly bool UseOdbcRules;
private static int _objectTypeCount; // Bid counter
internal readonly int _objectID = System.Threading.Interlocked.Increment(ref _objectTypeCount);
public DbConnectionStringBuilder() {
}
public DbConnectionStringBuilder(bool useOdbcRules) {
UseOdbcRules = useOdbcRules;
}
private ICollection Collection {
get { return (ICollection)CurrentValues; }
}
private IDictionary Dictionary {
get { return (IDictionary)CurrentValues; }
}
private Dictionary<string,object> CurrentValues {
get {
Dictionary<string,object> values = _currentValues;
if (null == values) {
values = new Dictionary<string,object>(StringComparer.OrdinalIgnoreCase);
_currentValues = values;
}
return values;
}
}
object System.Collections.IDictionary.this[object keyword] {
// delegate to this[string keyword]
get { return this[ObjectToString(keyword)]; }
set { this[ObjectToString(keyword)] = value; }
}
[Browsable(false)]
public virtual object this[string keyword] {
get {
Bid.Trace("<comm.DbConnectionStringBuilder.get_Item|API> %d#, keyword='%ls'\n", ObjectID, keyword);
ADP.CheckArgumentNull(keyword, "keyword");
object value;
if (CurrentValues.TryGetValue(keyword, out value)) {
return value;
}
throw ADP.KeywordNotSupported(keyword);
}
set {
ADP.CheckArgumentNull(keyword, "keyword");
bool flag = false;
if (null != value) {
string keyvalue = DbConnectionStringBuilderUtil.ConvertToString(value);
DbConnectionOptions.ValidateKeyValuePair(keyword, keyvalue);
flag = CurrentValues.ContainsKey(keyword);
// store keyword/value pair
CurrentValues[keyword] = keyvalue;
}
else {
flag = Remove(keyword);
}
_connectionString = null;
if (flag) {
_propertyDescriptors = null;
}
}
}
[Browsable(false)]
[DesignOnly(true)]
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
[EditorBrowsableAttribute(EditorBrowsableState.Never)]
public bool BrowsableConnectionString {
get {
return _browsableConnectionString;
}
set {
_browsableConnectionString = value;
_propertyDescriptors = null;
}
}
[RefreshPropertiesAttribute(RefreshProperties.All)]
[ResCategoryAttribute(Res.DataCategory_Data)]
[ResDescriptionAttribute(Res.DbConnectionString_ConnectionString)]
public string ConnectionString {
get {
Bid.Trace("<comm.DbConnectionStringBuilder.get_ConnectionString|API> %d#\n", ObjectID);
string connectionString = _connectionString;
if (null == connectionString) {
StringBuilder builder = new StringBuilder();
foreach(string keyword in Keys) {
object value;
if (ShouldSerialize(keyword) && TryGetValue(keyword, out value)) {
string keyvalue = ConvertValueToString(value);
AppendKeyValuePair(builder, keyword, keyvalue, UseOdbcRules);
}
}
connectionString = builder.ToString();
_connectionString = connectionString;
}
return connectionString;
}
set {
Bid.Trace("<comm.DbConnectionStringBuilder.set_ConnectionString|API> %d#\n", ObjectID);
DbConnectionOptions constr = new DbConnectionOptions(value, null, UseOdbcRules);
string originalValue = ConnectionString;
Clear();
try {
for(NameValuePair pair = constr.KeyChain; null != pair; pair = pair.Next) {
if (null != pair.Value) {
this[pair.Name] = pair.Value;
}
else {
Remove(pair.Name);
}
}
_connectionString = null;
}
catch(ArgumentException) { // restore original string
ConnectionString = originalValue;
_connectionString = originalValue;
throw;
}
}
}
[Browsable(false)]
public virtual int Count {
get { return CurrentValues.Count; }
}
[Browsable(false)]
public bool IsReadOnly {
get { return false; }
}
[Browsable(false)]
public virtual bool IsFixedSize {
get { return false; }
}
bool System.Collections.ICollection.IsSynchronized {
get { return Collection.IsSynchronized; }
}
[Browsable(false)]
public virtual ICollection Keys {
get {
Bid.Trace("<comm.DbConnectionStringBuilder.Keys|API> %d#\n", ObjectID);
return Dictionary.Keys;
}
}
internal int ObjectID {
get {
return _objectID;
}
}
object System.Collections.ICollection.SyncRoot {
get { return Collection.SyncRoot; }
}
[Browsable(false)]
public virtual ICollection Values {
get {
Bid.Trace("<comm.DbConnectionStringBuilder.Values|API> %d#\n", ObjectID);
System.Collections.Generic.ICollection<string> keys = (System.Collections.Generic.ICollection<string>)Keys;
System.Collections.Generic.IEnumerator<string> keylist = keys.GetEnumerator();
object[] values = new object[keys.Count];
for(int i = 0; i < values.Length; ++i) {
keylist.MoveNext();
values[i] = this[keylist.Current];
Debug.Assert(null != values[i], "null value " + keylist.Current);
}
return new System.Data.Common.ReadOnlyCollection<object>(values);
}
}
internal virtual string ConvertValueToString(object value) {
return (value == null) ? (string)null : Convert.ToString(value, CultureInfo.InvariantCulture);
}
void System.Collections.IDictionary.Add(object keyword, object value) {
Add(ObjectToString(keyword), value);
}
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>\n");
_connectionString = "";
_propertyDescriptors = null;
CurrentValues.Clear();
}
protected internal void ClearPropertyDescriptors() {
_propertyDescriptors = null;
}
// does the keyword exist as a strongly typed keyword or as a stored value
bool System.Collections.IDictionary.Contains(object keyword) {
return ContainsKey(ObjectToString(keyword));
}
public virtual bool ContainsKey(string keyword) {
ADP.CheckArgumentNull(keyword, "keyword");
return CurrentValues.ContainsKey(keyword);
}
void ICollection.CopyTo(Array array, int index) {
Bid.Trace("<comm.DbConnectionStringBuilder.ICollection.CopyTo|API> %d#\n", ObjectID);
Collection.CopyTo(array, index);
}
public virtual bool EquivalentTo(DbConnectionStringBuilder connectionStringBuilder) {
ADP.CheckArgumentNull(connectionStringBuilder, "connectionStringBuilder");
Bid.Trace("<comm.DbConnectionStringBuilder.EquivalentTo|API> %d#, connectionStringBuilder=%d#\n", ObjectID, connectionStringBuilder.ObjectID);
if ((GetType() != connectionStringBuilder.GetType()) || (CurrentValues.Count != connectionStringBuilder.CurrentValues.Count)) {
return false;
}
object value;
foreach(KeyValuePair<string, object> entry in CurrentValues) {
if (!connectionStringBuilder.CurrentValues.TryGetValue(entry.Key, out value) || !entry.Value.Equals(value)) {
return false;
}
}
return true;
}
IEnumerator System.Collections.IEnumerable.GetEnumerator() {
Bid.Trace("<comm.DbConnectionStringBuilder.IEnumerable.GetEnumerator|API> %d#\n", ObjectID);
return Collection.GetEnumerator();
}
IDictionaryEnumerator System.Collections.IDictionary.GetEnumerator() {
Bid.Trace("<comm.DbConnectionStringBuilder.IDictionary.GetEnumerator|API> %d#\n", ObjectID);
return Dictionary.GetEnumerator();
}
[SuppressMessage("Microsoft.Usage", "CA2208:InstantiateArgumentExceptionsCorrectly", Justification = "See Dev11 bug 875012")]
private string ObjectToString(object keyword) {
try {
return (string)keyword;
}
catch(InvalidCastException) {
//
throw new ArgumentException("keyword", "not a string");
}
}
void System.Collections.IDictionary.Remove(object keyword) {
Remove(ObjectToString(keyword));
}
public virtual bool Remove(string keyword) {
Bid.Trace("<comm.DbConnectionStringBuilder.Remove|API> %d#, keyword='%ls'\n", ObjectID, keyword);
ADP.CheckArgumentNull(keyword, "keyword");
if (CurrentValues.Remove(keyword)) {
_connectionString = null;
_propertyDescriptors = null;
return true;
}
return false;
}
// does the keyword exist as a stored value or something that should always be persisted
public virtual bool ShouldSerialize(string keyword) {
ADP.CheckArgumentNull(keyword, "keyword");
return CurrentValues.ContainsKey(keyword);
}
public override string ToString() {
return ConnectionString;
}
public virtual bool TryGetValue(string keyword, out object value) {
ADP.CheckArgumentNull(keyword, "keyword");
return CurrentValues.TryGetValue(keyword, out value);
}
internal Attribute[] GetAttributesFromCollection(AttributeCollection collection) {
Attribute[] attributes = new Attribute[collection.Count];
collection.CopyTo(attributes, 0);
return attributes;
}
private PropertyDescriptorCollection GetProperties() {
PropertyDescriptorCollection propertyDescriptors = _propertyDescriptors;
if (null == propertyDescriptors) {
IntPtr hscp;
Bid.ScopeEnter(out hscp, "<comm.DbConnectionStringBuilder.GetProperties|INFO> %d#", ObjectID);
try {
Hashtable descriptors = new Hashtable(StringComparer.OrdinalIgnoreCase);
GetProperties(descriptors);
PropertyDescriptor[] properties = new PropertyDescriptor[descriptors.Count];
descriptors.Values.CopyTo(properties, 0);
propertyDescriptors = new PropertyDescriptorCollection(properties);
_propertyDescriptors = propertyDescriptors;
}
finally {
Bid.ScopeLeave(ref hscp);
}
}
return propertyDescriptors;
}
protected virtual void GetProperties(Hashtable propertyDescriptors) {
IntPtr hscp;
Bid.ScopeEnter(out hscp, "<comm.DbConnectionStringBuilder.GetProperties|API> %d#", ObjectID);
try {
// show all strongly typed properties (not already added)
// except ConnectionString iff BrowsableConnectionString
Attribute[] attributes;
foreach(PropertyDescriptor reflected in TypeDescriptor.GetProperties(this, true)) {
if (ADP.ConnectionString != reflected.Name) {
string displayName = reflected.DisplayName;
if (!propertyDescriptors.ContainsKey(displayName)) {
attributes = GetAttributesFromCollection(reflected.Attributes);
PropertyDescriptor descriptor = new DbConnectionStringBuilderDescriptor(reflected.Name,
reflected.ComponentType, reflected.PropertyType, reflected.IsReadOnly, attributes);
propertyDescriptors[displayName] = descriptor;
}
// else added by derived class first
}
else if (BrowsableConnectionString) {
propertyDescriptors[ADP.ConnectionString] = reflected;
}
else {
propertyDescriptors.Remove(ADP.ConnectionString);
}
}
// all keywords in Keys list that do not have strongly typed property, ODBC case
// ignore 'Workaround Oracle Bug 914652' via IsFixedSize
if (!IsFixedSize) {
attributes = null;
foreach(string keyword in Keys) {
if (!propertyDescriptors.ContainsKey(keyword)) {
object value = this[keyword];
Type vtype;
if (null != value) {
vtype = value.GetType();
if (typeof(string) == vtype) {
int tmp1;
if (Int32.TryParse((string)value, out tmp1)) {
vtype = typeof(Int32);
}
else {
bool tmp2;
if (Boolean.TryParse((string)value, out tmp2)) {
vtype = typeof(Boolean);
}
}
}
}
else {
vtype = typeof(string);
}
Attribute[] useAttributes = attributes;
if (StringComparer.OrdinalIgnoreCase.Equals(DbConnectionStringKeywords.Password, keyword) ||
StringComparer.OrdinalIgnoreCase.Equals(DbConnectionStringSynonyms.Pwd, keyword)) {
useAttributes = new Attribute[] {
BrowsableAttribute.Yes,
PasswordPropertyTextAttribute.Yes,
new ResCategoryAttribute(Res.DataCategory_Security),
RefreshPropertiesAttribute.All,
};
}
else if (null == attributes) {
attributes = new Attribute[] {
BrowsableAttribute.Yes,
RefreshPropertiesAttribute.All,
};
useAttributes = attributes;
}
PropertyDescriptor descriptor = new DbConnectionStringBuilderDescriptor(keyword,
this.GetType(), vtype, false, useAttributes);
propertyDescriptors[keyword] = descriptor;
}
}
}
}
finally {
Bid.ScopeLeave(ref hscp);
}
}
private PropertyDescriptorCollection GetProperties(Attribute[] attributes) {
PropertyDescriptorCollection propertyDescriptors = GetProperties();
if ((null == attributes) || (0 == attributes.Length)) {
// Basic case has no filtering
return propertyDescriptors;
}
// Create an array that is guaranteed to hold all attributes
PropertyDescriptor[] propertiesArray = new PropertyDescriptor[propertyDescriptors.Count];
// Create an index to reference into this array
int index = 0;
// Iterate over each property
foreach (PropertyDescriptor property in propertyDescriptors) {
// Identify if this property's attributes match the specification
bool match = true;
foreach (Attribute attribute in attributes) {
Attribute attr = property.Attributes[attribute.GetType()];
if ((attr == null && !attribute.IsDefaultAttribute()) || !attr.Match(attribute)) {
match = false;
break;
}
}
// If this property matches, add it to the array
if (match) {
propertiesArray[index] = property;
index++;
}
}
// Create a new array that only contains the filtered properties
PropertyDescriptor[] filteredPropertiesArray = new PropertyDescriptor[index];
Array.Copy(propertiesArray, filteredPropertiesArray, index);
return new PropertyDescriptorCollection(filteredPropertiesArray);
}
string ICustomTypeDescriptor.GetClassName() {
return TypeDescriptor.GetClassName(this, true);
}
string ICustomTypeDescriptor.GetComponentName() {
return TypeDescriptor.GetComponentName(this, true);
}
AttributeCollection ICustomTypeDescriptor.GetAttributes() {
return TypeDescriptor.GetAttributes(this, true);
}
object ICustomTypeDescriptor.GetEditor(Type editorBaseType) {
return TypeDescriptor.GetEditor(this, editorBaseType, true);
}
TypeConverter ICustomTypeDescriptor.GetConverter() {
return TypeDescriptor.GetConverter(this, true);
}
PropertyDescriptor ICustomTypeDescriptor.GetDefaultProperty() {
return TypeDescriptor.GetDefaultProperty(this, true);
}
PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties() {
return GetProperties();
}
PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties(Attribute[] attributes) {
return GetProperties(attributes);
}
EventDescriptor ICustomTypeDescriptor.GetDefaultEvent() {
return TypeDescriptor.GetDefaultEvent(this, true);
}
EventDescriptorCollection ICustomTypeDescriptor.GetEvents() {
return TypeDescriptor.GetEvents(this, true);
}
EventDescriptorCollection ICustomTypeDescriptor.GetEvents(Attribute[] attributes) {
return TypeDescriptor.GetEvents(this, attributes, true);
}
object ICustomTypeDescriptor.GetPropertyOwner(PropertyDescriptor pd) {
return this;
}
}
}
|