mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
Adding reference source for System.Data System.Data.DataSetExtensions System.Data.Entity System.Data.Entity.Design System.Data.Linq System.Data.SqlXml System.ServiceModel System.ServiceModel.Activation System.ServiceModel.Activities System.ServiceModel.Channels System.ServiceModel.Discovery System.ServiceModel.Internals System.ServiceModel.Routing System.ServiceModel.WasHosting System.ServiceModel.Web System.Web System.Web.ApplicationServices System.Web.DynamicData System.Web.Entity System.Web.Entity.Design System.Web.Extensions System.Web.Mobile System.Web.Routing System.Web.Services System.Xml System.Xml.Linq
346 lines
13 KiB
C#
346 lines
13 KiB
C#
//---------------------------------------------------------------------
|
|
// <copyright file="EntityConnectionStringBuilder.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
//
|
|
// @owner [....]
|
|
// @backupOwner [....]
|
|
//---------------------------------------------------------------------
|
|
|
|
namespace System.Data.EntityClient
|
|
{
|
|
using System.Collections;
|
|
using System.ComponentModel;
|
|
using System.Data.Common;
|
|
using System.Data.Entity;
|
|
using System.Diagnostics.CodeAnalysis;
|
|
|
|
/// <summary>
|
|
/// Class representing a connection string builder for the entity client provider
|
|
/// </summary>
|
|
[SuppressMessage("Microsoft.Naming", "CA1710:IdentifiersShouldHaveCorrectSuffix", Justification = "EntityConnectionStringBuilder follows the naming convention of DbConnectionStringBuilder.")]
|
|
[SuppressMessage("Microsoft.Design", "CA1035:ICollectionImplementationsHaveStronglyTypedMembers", Justification = "There is no applicable strongly-typed implementation of CopyTo.")]
|
|
public sealed class EntityConnectionStringBuilder : DbConnectionStringBuilder
|
|
{
|
|
// Names of parameters to look for in the connection string
|
|
internal const string NameParameterName = "name";
|
|
internal const string MetadataParameterName = "metadata";
|
|
internal const string ProviderParameterName = "provider";
|
|
internal const string ProviderConnectionStringParameterName = "provider connection string";
|
|
|
|
// An array to hold the keywords
|
|
private static readonly string[] s_validKeywords = new string[]
|
|
{
|
|
NameParameterName,
|
|
MetadataParameterName,
|
|
ProviderParameterName,
|
|
ProviderConnectionStringParameterName
|
|
};
|
|
|
|
private static Hashtable s_synonyms;
|
|
|
|
// Information and data used by the connection
|
|
private string _namedConnectionName;
|
|
private string _providerName;
|
|
private string _metadataLocations;
|
|
private string _storeProviderConnectionString;
|
|
|
|
/// <summary>
|
|
/// Constructs the EntityConnectionStringBuilder object
|
|
/// </summary>
|
|
public EntityConnectionStringBuilder()
|
|
{
|
|
// Everything just defaults to null
|
|
}
|
|
|
|
/// <summary>
|
|
/// Constructs the EntityConnectionStringBuilder object with a connection string
|
|
/// </summary>
|
|
/// <param name="connectionString">The connection string to initialize this builder</param>
|
|
public EntityConnectionStringBuilder(string connectionString)
|
|
{
|
|
this.ConnectionString = connectionString;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the named connection name in the connection string
|
|
/// </summary>
|
|
[DisplayName("Name")]
|
|
[EntityResCategoryAttribute(EntityRes.EntityDataCategory_NamedConnectionString)]
|
|
[EntityResDescriptionAttribute(EntityRes.EntityConnectionString_Name)]
|
|
[RefreshProperties(RefreshProperties.All)]
|
|
public string Name
|
|
{
|
|
get
|
|
{
|
|
return this._namedConnectionName ?? "";
|
|
}
|
|
set
|
|
{
|
|
this._namedConnectionName = value;
|
|
base[NameParameterName] = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the name of the underlying .NET Framework data provider in the connection string
|
|
/// </summary>
|
|
[DisplayName("Provider")]
|
|
[EntityResCategoryAttribute(EntityRes.EntityDataCategory_Source)]
|
|
[EntityResDescriptionAttribute(EntityRes.EntityConnectionString_Provider)]
|
|
[RefreshProperties(RefreshProperties.All)]
|
|
public string Provider
|
|
{
|
|
get
|
|
{
|
|
return this._providerName ?? "";
|
|
}
|
|
set
|
|
{
|
|
this._providerName = value;
|
|
base[ProviderParameterName] = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the metadata locations in the connection string, which is a pipe-separated sequence
|
|
/// of paths to folders and individual files
|
|
/// </summary>
|
|
[DisplayName("Metadata")]
|
|
[EntityResCategoryAttribute(EntityRes.EntityDataCategory_Context)]
|
|
[EntityResDescriptionAttribute(EntityRes.EntityConnectionString_Metadata)]
|
|
[RefreshProperties(RefreshProperties.All)]
|
|
public string Metadata
|
|
{
|
|
get
|
|
{
|
|
return this._metadataLocations ?? "";
|
|
}
|
|
set
|
|
{
|
|
this._metadataLocations = value;
|
|
base[MetadataParameterName] = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the inner connection string in the connection string
|
|
/// </summary>
|
|
[DisplayName("Provider Connection String")]
|
|
[EntityResCategoryAttribute(EntityRes.EntityDataCategory_Source)]
|
|
[EntityResDescriptionAttribute(EntityRes.EntityConnectionString_ProviderConnectionString)]
|
|
[RefreshProperties(RefreshProperties.All)]
|
|
public string ProviderConnectionString
|
|
{
|
|
get
|
|
{
|
|
return this._storeProviderConnectionString ?? "";
|
|
}
|
|
set
|
|
{
|
|
this._storeProviderConnectionString = value;
|
|
base[ProviderConnectionStringParameterName] = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets whether the EntityConnectionStringBuilder has a fixed size
|
|
/// </summary>
|
|
public override bool IsFixedSize
|
|
{
|
|
get
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets a collection of all keywords used by EntityConnectionStringBuilder
|
|
/// </summary>
|
|
public override ICollection Keys
|
|
{
|
|
get
|
|
{
|
|
return new System.Collections.ObjectModel.ReadOnlyCollection<string>(s_validKeywords);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns a hash table object containing all the valid keywords. This is really the same as the Keys
|
|
/// property, it's just that the returned object is a hash table.
|
|
/// </summary>
|
|
internal static Hashtable Synonyms
|
|
{
|
|
get
|
|
{
|
|
// Build the synonyms table if we don't have one
|
|
if (s_synonyms == null)
|
|
{
|
|
Hashtable table = new Hashtable(s_validKeywords.Length);
|
|
foreach (string keyword in s_validKeywords)
|
|
{
|
|
table.Add(keyword, keyword);
|
|
}
|
|
s_synonyms = table;
|
|
}
|
|
return s_synonyms;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets or sets the value associated with the keyword
|
|
/// </summary>
|
|
public override object this[string keyword]
|
|
{
|
|
get
|
|
{
|
|
EntityUtil.CheckArgumentNull(keyword, "keyword");
|
|
|
|
// Just access the properties to get the value since the fields, which the properties will be accessing, will
|
|
// have already been set when the connection string is set
|
|
if (string.Compare(keyword, MetadataParameterName, StringComparison.OrdinalIgnoreCase) == 0)
|
|
{
|
|
return this.Metadata;
|
|
}
|
|
else if (string.Compare(keyword, ProviderConnectionStringParameterName, StringComparison.OrdinalIgnoreCase) == 0)
|
|
{
|
|
return this.ProviderConnectionString;
|
|
}
|
|
else if (string.Compare(keyword, NameParameterName, StringComparison.OrdinalIgnoreCase) == 0)
|
|
{
|
|
return this.Name;
|
|
}
|
|
else if (string.Compare(keyword, ProviderParameterName, StringComparison.OrdinalIgnoreCase) == 0)
|
|
{
|
|
return this.Provider;
|
|
}
|
|
|
|
throw EntityUtil.KeywordNotSupported(keyword);
|
|
}
|
|
set
|
|
{
|
|
EntityUtil.CheckArgumentNull(keyword, "keyword");
|
|
|
|
// If a null value is set, just remove the parameter and return
|
|
if (value == null)
|
|
{
|
|
this.Remove(keyword);
|
|
return;
|
|
}
|
|
|
|
// Since all of our parameters must be string value, perform the cast here and check
|
|
string stringValue = value as string;
|
|
if (stringValue == null)
|
|
{
|
|
throw EntityUtil.Argument(System.Data.Entity.Strings.EntityClient_ValueNotString, "value");
|
|
}
|
|
|
|
// Just access the properties to get the value since the fields, which the properties will be accessing, will
|
|
// have already been set when the connection string is set
|
|
if (string.Compare(keyword, MetadataParameterName, StringComparison.OrdinalIgnoreCase) == 0)
|
|
{
|
|
this.Metadata = stringValue;
|
|
}
|
|
else if (string.Compare(keyword, ProviderConnectionStringParameterName, StringComparison.OrdinalIgnoreCase) == 0)
|
|
{
|
|
this.ProviderConnectionString = stringValue;
|
|
}
|
|
else if (string.Compare(keyword, NameParameterName, StringComparison.OrdinalIgnoreCase) == 0)
|
|
{
|
|
this.Name = stringValue;
|
|
}
|
|
else if (string.Compare(keyword, ProviderParameterName, StringComparison.OrdinalIgnoreCase) == 0)
|
|
{
|
|
this.Provider = stringValue;
|
|
}
|
|
else
|
|
{
|
|
throw EntityUtil.KeywordNotSupported(keyword);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Clear all the parameters in the connection string
|
|
/// </summary>
|
|
public override void Clear()
|
|
{
|
|
base.Clear();
|
|
this._namedConnectionName = null;
|
|
this._providerName = null;
|
|
this._metadataLocations = null;
|
|
this._storeProviderConnectionString = null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Determine if this connection string builder contains a specific key
|
|
/// </summary>
|
|
/// <param name="keyword">The keyword to find in this connection string builder</param>
|
|
/// <returns>True if this connections string builder contains the specific key</returns>
|
|
public override bool ContainsKey(string keyword)
|
|
{
|
|
EntityUtil.CheckArgumentNull(keyword, "keyword");
|
|
|
|
foreach (string validKeyword in s_validKeywords)
|
|
{
|
|
if (validKeyword.Equals(keyword, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the value of the given keyword, returns false if there isn't a value with the given keyword
|
|
/// </summary>
|
|
/// <param name="keyword">The keyword specifying the name of the parameter to retrieve</param>
|
|
/// <param name="value">The value retrieved</param>
|
|
/// <returns>True if the value is retrieved</returns>
|
|
public override bool TryGetValue(string keyword, out object value)
|
|
{
|
|
EntityUtil.CheckArgumentNull(keyword, "keyword");
|
|
|
|
if (ContainsKey(keyword))
|
|
{
|
|
value = this[keyword];
|
|
return true;
|
|
}
|
|
|
|
value = null;
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Removes a parameter from the builder
|
|
/// </summary>
|
|
/// <param name="keyword">The keyword specifying the name of the parameter to remove</param>
|
|
/// <returns>True if the parameter is removed</returns>
|
|
public override bool Remove(string keyword)
|
|
{
|
|
EntityUtil.CheckArgumentNull(keyword, "keyword");
|
|
|
|
// Convert the given object into a string
|
|
if (string.Compare(keyword, MetadataParameterName, StringComparison.OrdinalIgnoreCase) == 0)
|
|
{
|
|
this._metadataLocations = null;
|
|
}
|
|
else if (string.Compare(keyword, ProviderConnectionStringParameterName, StringComparison.OrdinalIgnoreCase) == 0)
|
|
{
|
|
this._storeProviderConnectionString = null;
|
|
}
|
|
else if (string.Compare(keyword, NameParameterName, StringComparison.OrdinalIgnoreCase) == 0)
|
|
{
|
|
this._namedConnectionName = null;
|
|
}
|
|
else if (string.Compare(keyword, ProviderParameterName, StringComparison.OrdinalIgnoreCase) == 0)
|
|
{
|
|
this._providerName = null;
|
|
}
|
|
|
|
return base.Remove(keyword);
|
|
}
|
|
}
|
|
}
|