|
public Configure ( |
||
| connection | ||
| Результат | void | |
/// <include file='docs/MySqlConnection.xml' path='docs/Open/*'/>
public void Open()
{
if (state == ConnectionState.Open)
{
throw new InvalidOperationException(
Resources.GetString("ConnectionAlreadyOpen"));
}
SetState(ConnectionState.Connecting);
try
{
if (settings.Pooling)
{
driver = MySqlPoolManager.GetConnection(settings);
}
else
{
driver = Driver.Create(settings);
}
}
catch (Exception)
{
SetState(ConnectionState.Closed);
throw;
}
// if the user is using old syntax, let them know
if (driver.Settings.UseOldSyntax)
{
Logger.LogWarning("You are using old syntax that will be removed in future versions");
}
SetState(ConnectionState.Open);
driver.Configure(this);
if (settings.Database != null && settings.Database.Length != 0)
{
ChangeDatabase(settings.Database);
}
hasBeenOpen = true;
}
/// <include file='docs/MySqlConnection.xml' path='docs/Open/*'/>
public override void Open()
{
if (State == ConnectionState.Open)
{
Throw(new InvalidOperationException(Resources.ConnectionAlreadyOpen));
}
// start up our interceptors
_exceptionInterceptor = new ExceptionInterceptor(this);
commandInterceptor = new CommandInterceptor(this);
SetState(ConnectionState.Connecting, true);
#if !NETSTANDARD1_3
AssertPermissions();
//TODO: SUPPORT FOR 452 AND 46X
// if we are auto enlisting in a current transaction, then we will be
// treating the connection as pooled
if (Settings.AutoEnlist && Transaction.Current != null)
{
driver = DriverTransactionManager.GetDriverInTransaction(Transaction.Current);
if (driver != null &&
(driver.IsInActiveUse ||
!driver.Settings.EquivalentTo(this.Settings)))
{
Throw(new NotSupportedException(Resources.MultipleConnectionsInTransactionNotSupported));
}
}
#endif
try
{
MySqlConnectionStringBuilder currentSettings = Settings;
//TODO: SUPPORT FOR 452 AND 46X
// Load balancing
#if !NETSTANDARD1_3
if (ReplicationManager.IsReplicationGroup(Settings.Server))
{
if (driver == null)
{
ReplicationManager.GetNewConnection(Settings.Server, false, this);
}
else
{
currentSettings = driver.Settings;
}
}
#endif
if (Settings.Pooling)
{
MySqlPool pool = MySqlPoolManager.GetPool(currentSettings);
if (driver == null || !driver.IsOpen)
{
driver = pool.GetConnection();
}
ProcedureCache = pool.ProcedureCache;
}
else
{
if (driver == null || !driver.IsOpen)
{
driver = Driver.Create(currentSettings);
}
ProcedureCache = new ProcedureCache((int)Settings.ProcedureCacheSize);
}
}
catch (Exception)
{
SetState(ConnectionState.Closed, true);
throw;
}
SetState(ConnectionState.Open, false);
driver.Configure(this);
if (!(driver.SupportsPasswordExpiration && driver.IsPasswordExpired))
{
if (!string.IsNullOrEmpty(Settings.Database))
{
ChangeDatabase(Settings.Database);
}
}
// setup our schema provider
_schemaProvider = new ISSchemaProvider(this);
PerfMonitor = new PerformanceMonitor(this);
// if we are opening up inside a current transaction, then autoenlist
// TODO: control this with a connection string option
#if !NETSTANDARD1_3
if (Transaction.Current != null && Settings.AutoEnlist)
{
EnlistTransaction(Transaction.Current);
}
#endif
hasBeenOpen = true;
SetState(ConnectionState.Open, true);
}
/// <include file='docs/MySqlConnection.xml' path='docs/Open/*'/>
public override void Open()
{
if (State == ConnectionState.Open)
{
Throw(new InvalidOperationException(Resources.ConnectionAlreadyOpen));
}
#if !RT
// start up our interceptors
exceptionInterceptor = new ExceptionInterceptor(this);
commandInterceptor = new CommandInterceptor(this);
#endif
SetState(ConnectionState.Connecting, true);
AssertPermissions();
#if !RT
// if we are auto enlisting in a current transaction, then we will be
// treating the connection as pooled
if (Settings.AutoEnlist && Transaction.Current != null)
{
driver = DriverTransactionManager.GetDriverInTransaction(Transaction.Current);
if (driver != null &&
(driver.IsInActiveUse ||
!driver.Settings.EquivalentTo(this.Settings)))
{
Throw(new NotSupportedException(Resources.MultipleConnectionsInTransactionNotSupported));
}
}
#endif
try
{
MySqlConnectionStringBuilder currentSettings = Settings;
// Load balancing
if (ReplicationManager.IsReplicationGroup(Settings.Server))
{
if (driver == null)
{
ReplicationManager.GetNewConnection(Settings.Server, false, this);
}
else
{
currentSettings = driver.Settings;
}
}
if (Settings.Pooling)
{
MySqlPool pool = MySqlPoolManager.GetPool(currentSettings);
if (driver == null || !driver.IsOpen)
{
driver = pool.GetConnection();
}
procedureCache = pool.ProcedureCache;
}
else
{
if (driver == null || !driver.IsOpen)
{
driver = Driver.Create(currentSettings);
}
procedureCache = new ProcedureCache((int)Settings.ProcedureCacheSize);
}
}
catch (Exception ex)
{
SetState(ConnectionState.Closed, true);
throw;
}
// if the user is using old syntax, let them know
if (driver.Settings.UseOldSyntax)
{
MySqlTrace.LogWarning(ServerThread,
"You are using old syntax that will be removed in future versions");
}
SetState(ConnectionState.Open, false);
driver.Configure(this);
if (!(driver.SupportsPasswordExpiration && driver.IsPasswordExpired))
{
if (Settings.Database != null && Settings.Database != String.Empty)
{
ChangeDatabase(Settings.Database);
}
}
// setup our schema provider
schemaProvider = new ISSchemaProvider(this);
perfMonitor = new PerformanceMonitor(this);
// if we are opening up inside a current transaction, then autoenlist
// TODO: control this with a connection string option
#if !MONO && !RT
if (Transaction.Current != null && Settings.AutoEnlist)
{
EnlistTransaction(Transaction.Current);
}
#endif
hasBeenOpen = true;
SetState(ConnectionState.Open, true);
}
/// <include file='docs/MySqlConnection.xml' path='docs/Open/*'/>
public override void Open()
{
if (State == ConnectionState.Open)
{
throw new InvalidOperationException(Resources.ConnectionAlreadyOpen);
}
SetState(ConnectionState.Connecting);
try
{
if (settings.Pooling)
{
MySqlPool pool = MySqlPoolManager.GetPool(settings);
driver = pool.GetConnection();
procedureCache = pool.ProcedureCache;
}
else
{
driver = Driver.Create(settings);
procedureCache = new ProcedureCache(settings.ProcedureCacheSize);
}
}
catch (Exception)
{
SetState(ConnectionState.Closed);
throw;
}
// if the user is using old syntax, let them know
if (driver.Settings.UseOldSyntax)
{
Logger.LogWarning("You are using old syntax that will be removed in future versions");
}
SetState(ConnectionState.Open);
driver.Configure(this);
if (settings.Database != null && settings.Database != String.Empty)
{
ChangeDatabase(settings.Database);
}
// setup our schema provider
if (driver.Version.isAtLeast(5, 0, 0))
{
schemaProvider = new ISSchemaProvider(this);
}
else
{
schemaProvider = new SchemaProvider(this);
}
perfMonitor = new PerformanceMonitor(this);
// if we are opening up inside a current transaction, then autoenlist
// TODO: control this with a connection string option
#if !MONO
if (System.Transactions.Transaction.Current != null)
{
EnlistTransaction(System.Transactions.Transaction.Current);
}
#endif
hasBeenOpen = true;
}
/// <include file='docs/MySqlConnection.xml' path='docs/Open/*'/>
public override void Open()
{
if (State == ConnectionState.Open)
{
throw new InvalidOperationException(Resources.ConnectionAlreadyOpen);
}
SetState(ConnectionState.Connecting, true);
#if !CF
// if we are auto enlisting in a current transaction, then we will be
// treating the connection as pooled
if (settings.AutoEnlist && Transaction.Current != null)
{
driver = DriverTransactionManager.GetDriverInTransaction(Transaction.Current);
if (driver != null &&
(driver.IsInActiveUse ||
!driver.Settings.EquivalentTo(this.Settings)))
{
throw new NotSupportedException(Resources.MultipleConnectionsInTransactionNotSupported);
}
}
#endif
try
{
if (settings.Pooling)
{
MySqlPool pool = MySqlPoolManager.GetPool(settings);
if (driver == null || !driver.IsOpen)
{
driver = pool.GetConnection();
}
procedureCache = pool.ProcedureCache;
}
else
{
if (driver == null || !driver.IsOpen)
{
driver = Driver.Create(settings);
}
procedureCache = new ProcedureCache((int)settings.ProcedureCacheSize);
}
}
catch (Exception)
{
SetState(ConnectionState.Closed, true);
throw;
}
// if the user is using old syntax, let them know
if (driver.Settings.UseOldSyntax)
{
MySqlTrace.LogWarning(ServerThread,
"You are using old syntax that will be removed in future versions");
}
SetState(ConnectionState.Open, false);
driver.Configure(this);
if (settings.Database != null && settings.Database != String.Empty)
{
ChangeDatabase(settings.Database);
}
// setup our schema provider
schemaProvider = new ISSchemaProvider(this);
#if !CF
perfMonitor = new PerformanceMonitor(this);
#endif
// if we are opening up inside a current transaction, then autoenlist
// TODO: control this with a connection string option
#if !MONO && !CF
if (Transaction.Current != null && settings.AutoEnlist)
{
EnlistTransaction(Transaction.Current);
}
#endif
hasBeenOpen = true;
SetState(ConnectionState.Open, true);
}
/// <include file='docs/MySqlConnection.xml' path='docs/Open/*'/>
public override void Open()
{
if (State == ConnectionState.Open)
{
Throw(new InvalidOperationException(Resources.ConnectionAlreadyOpen));
}
// start up our interceptors
_exceptionInterceptor = new ExceptionInterceptor(this);
commandInterceptor = new CommandInterceptor(this);
SetState(ConnectionState.Connecting, true);
AssertPermissions();
//TODO: SUPPORT FOR 452 AND 46X
// if we are auto enlisting in a current transaction, then we will be
// treating the connection as pooled
if (Settings.AutoEnlist && Transaction.Current != null)
{
driver = DriverTransactionManager.GetDriverInTransaction(Transaction.Current);
if (driver != null &&
(driver.IsInActiveUse ||
!driver.Settings.EquivalentTo(this.Settings)))
{
Throw(new NotSupportedException(Resources.MultipleConnectionsInTransactionNotSupported));
}
}
MySqlConnectionStringBuilder currentSettings = Settings;
try
{
if (Settings.ConnectionProtocol == MySqlConnectionProtocol.Tcp && Settings.IsSshEnabled())
{
_sshHandler = new Ssh(
Settings.SshHostName,
Settings.SshUserName,
Settings.SshPassword,
Settings.SshKeyFile,
Settings.SshPassphrase,
Settings.SshPort,
Settings.Server,
Settings.Port,
false
);
_sshHandler.StartClient();
}
if (!Settings.Pooling || MySqlPoolManager.Hosts == null)
{
FailoverManager.Reset();
if (Settings.DnsSrv)
{
var dnsSrvRecords = DnsResolver.GetDnsSrvRecords(Settings.Server);
FailoverManager.SetHostList(dnsSrvRecords.ConvertAll(r => new FailoverServer(r.Target, r.Port, null)),
FailoverMethod.Sequential);
}
else
{
FailoverManager.ParseHostList(Settings.Server, false);
}
}
// Load balancing && Failover
if (ReplicationManager.IsReplicationGroup(Settings.Server))
{
if (driver == null)
{
ReplicationManager.GetNewConnection(Settings.Server, false, this);
}
else
{
currentSettings = driver.Settings;
}
}
else if (FailoverManager.FailoverGroup != null && !Settings.Pooling)
{
FailoverManager.AttemptConnection(this, Settings.ConnectionString, out string connectionString);
currentSettings.ConnectionString = connectionString;
}
if (Settings.Pooling)
{
if (FailoverManager.FailoverGroup != null)
{
FailoverManager.AttemptConnection(this, Settings.ConnectionString, out string connectionString, true);
currentSettings.ConnectionString = connectionString;
}
MySqlPool pool = MySqlPoolManager.GetPool(currentSettings);
if (driver == null || !driver.IsOpen)
{
driver = pool.GetConnection();
}
ProcedureCache = pool.ProcedureCache;
}
else
{
if (driver == null || !driver.IsOpen)
{
driver = Driver.Create(currentSettings);
}
ProcedureCache = new ProcedureCache((int)Settings.ProcedureCacheSize);
}
}
catch (Exception)
{
SetState(ConnectionState.Closed, true);
throw;
}
SetState(ConnectionState.Open, false);
driver.Configure(this);
if (driver.IsPasswordExpired && Settings.Pooling)
{
MySqlPoolManager.ClearPool(currentSettings);
}
if (!(driver.SupportsPasswordExpiration && driver.IsPasswordExpired))
{
if (!string.IsNullOrEmpty(Settings.Database))
{
ChangeDatabase(Settings.Database);
}
}
// setup our schema provider
_schemaProvider = new ISSchemaProvider(this);
PerfMonitor = new PerformanceMonitor(this);
// if we are opening up inside a current transaction, then autoenlist
// TODO: control this with a connection string option
if (Transaction.Current != null && Settings.AutoEnlist)
{
EnlistTransaction(Transaction.Current);
}
hasBeenOpen = true;
SetState(ConnectionState.Open, true);
}
/// <include file='docs/MySqlConnection.xml' path='docs/Open/*'/>
public override void Open()
{
if (State == ConnectionState.Open)
{
Throw(new InvalidOperationException(Resources.ConnectionAlreadyOpen));
}
// start up our interceptors
_exceptionInterceptor = new ExceptionInterceptor(this);
commandInterceptor = new CommandInterceptor(this);
SetState(ConnectionState.Connecting, true);
try
{
MySqlConnectionStringBuilder currentSettings = Settings;
//TODO: SUPPORT FOR 452 AND 46X
// Load balancing
if (Settings.Pooling)
{
MySqlPool pool = MySqlPoolManager.GetPool(currentSettings);
if (driver == null || !driver.IsOpen)
{
driver = pool.GetConnection();
}
ProcedureCache = pool.ProcedureCache;
}
else
{
if (driver == null || !driver.IsOpen)
{
driver = Driver.Create(currentSettings);
}
ProcedureCache = new ProcedureCache((int)Settings.ProcedureCacheSize);
}
}
catch (Exception)
{
SetState(ConnectionState.Closed, true);
throw;
}
SetState(ConnectionState.Open, false);
driver.Configure(this);
if (!(driver.SupportsPasswordExpiration && driver.IsPasswordExpired))
{
if (!string.IsNullOrEmpty(Settings.Database))
{
ChangeDatabase(Settings.Database);
}
}
// setup our schema provider
_schemaProvider = new ISSchemaProvider(this);
PerfMonitor = new PerformanceMonitor(this);
// if we are opening up inside a current transaction, then autoenlist
// TODO: control this with a connection string option
hasBeenOpen = true;
SetState(ConnectionState.Open, true);
}
/// <include file='docs/MySqlConnection.xml' path='docs/Open/*'/>
public override void Open()
{
if (State == ConnectionState.Open)
{
throw new InvalidOperationException("Resources.ConnectionAlreadyOpen");
}
SetState(ConnectionState.Connecting, true);
//AssertPermissions();
try
{
MySqlConnectionStringBuilder currentSettings = Settings;
if (Settings.Pooling)
{
MySqlPool pool = MySqlPoolManager.GetPool(currentSettings);
if (driver == null || !driver.IsOpen)
{
driver = pool.GetConnection();
}
procedureCache = pool.ProcedureCache;
}
else
{
if (driver == null || !driver.IsOpen)
{
driver = Driver.Create(currentSettings);
}
procedureCache = new ProcedureCache((int)Settings.ProcedureCacheSize);
}
}
catch (Exception ex)
{
SetState(ConnectionState.Closed, true);
throw;
}
// if the user is using old syntax, let them know
//if (driver.Settings.UseOldSyntax)
//MySqlTrace.LogWarning(ServerThread,
// "You are using old syntax that will be removed in future versions");
SetState(ConnectionState.Open, false);
driver.Configure(this);
if (!(driver.SupportsPasswordExpiration && driver.IsPasswordExpired))
{
if (Settings.Database != null && Settings.Database != String.Empty)
{
ChangeDatabase(Settings.Database);
}
}
// setup our schema provider
schemaProvider = new ISSchemaProvider(this);
// // if we are opening up inside a current transaction, then autoenlist
// // TODO: control this with a connection string option
//#if !MONO && !CF && !RT
// if (Transaction.Current != null && Settings.AutoEnlist)
// EnlistTransaction(Transaction.Current);
//#endif
hasBeenOpen = true;
SetState(ConnectionState.Open, true);
}