public static extern bool LogonUser(
string userName,
string domain,
string password,
ConnectionKind connectionKind,
Provider provider,
out IntPtr token);
/// <summary>
/// Инициализирует объект процедуры.
/// </summary>
/// <param name="commandText">Текст команды (имя процедуры, SQL-скрипт).</param>
/// <param name="commandType">Тип команды.</param>
/// <param name="connectionKind">Тип подключения.</param>
protected BaseCommand(string commandText, CommandType commandType, ConnectionKind connectionKind)
{
m_ConnectionKind = connectionKind;
m_Connection = ConnectionManager.GetConnection(connectionKind);
m_DBFactory = ConnectionManager.GetDBFactory(connectionKind);
m_Command = m_Connection.CreateCommand();
m_Command.Transaction = ConnectionManager.GetCurrentTransaction(connectionKind);
m_Command.CommandText = commandText;
m_Command.CommandType = commandType;
}
public static string GetConnectionSigh(ConnectionKind connectionKind)
{
Contract.Ensures(!String.IsNullOrEmpty(Contract.Result<string>()));
if (connectionKind == ConnectionKind.None)
return NoneConnectionSign.ToString();
return connectionKind == ConnectionKind.Strict
? StrictConnectionSign.ToString()
: RelativeConnectionSign.ToString();
}
private PlayerState GetState(ConnectionKind asked)
{
var state = GetState();
if (state != null)
{
var actual = (ConnectionKind)Context.Items[nameof(ConnectionKind)];
if (actual != asked)
{
_logger.LogWarning($"Bad connection type Expected:{asked}, Actual:{actual}");
// TODO: once carefully tested, always return null !
if (actual == ConnectionKind.Spectator)
{
return(null);
}
}
}
return(state);
}
/// <summary>
/// Открывает соединение с БД.
/// </summary>
/// <param name="connection">Соединение с базой данных.</param>
public static void OpenConnection(IDbConnection connection, ConnectionKind connectionKind)
{
if (!HasConnectionInCache(connectionKind) || connection.State != ConnectionState.Open)
connection.Open();
}
/// <summary>
/// Определяет, есть ли у нас в кэше соединения (идет ли транзакция).
/// </summary>
/// <param name="connectionKind">Тип соединения.</param>
/// <returns>Есть ли у нас в кэше соединение.</returns>
public static bool HasConnectionInCache(ConnectionKind connectionKind)
{
// Если в кэше соединений есть соединение (идет транзакция),
// то возвращаем true, иначе false.
string key = GetConnectionCacheKey(connectionKind);
return (CacheManager.Cache[key] != null) ? true : false;
}
public static DbProviderFactory GetDBFactory(ConnectionKind connectionKind)
{
if (ConnectionTypeResolve == null)
throw new InvalidOperationException("Please define ConnectionTypeResolve method.");
ConnectionType type = ConnectionTypeResolve(connectionKind);
switch (type)
{
case ConnectionType.SQLServer:
return SqlClientFactory.Instance;
case ConnectionType.OLEDB:
return OleDbFactory.Instance;
case ConnectionType.Odbc:
return OdbcFactory.Instance;
default:
return SqlClientFactory.Instance;
}
}
/// <summary>
/// Возвращает текущую транзакцию.
/// </summary>
/// <param name="connectionKind">Тип соединения.</param>
/// <returns>Текущая транзакция.</returns>
public static IDbTransaction GetCurrentTransaction(ConnectionKind connectionKind)
{
object o = CacheManager.Cache[GetTransactionCacheKey(connectionKind)];
if (o == null || !(o is IDbTransaction))
return null;
else
return (IDbTransaction)o;
}
/// <summary>
/// Возвращает строку ConnectionString по типу соединения
/// из конфигурационного файла
/// </summary>
/// <param name="connKind">тип соединения</param>
/// <returns></returns>
public static string GetConnectionString(ConnectionKind connKind)
{
return (connKind == ConnectionKind.Default)
? m_DefaultConnectionString
: ConfigurationManager.ConnectionStrings[connKind.ToString()].ConnectionString;
}
private static void removeFromCache(ConnectionKind connectionKind)
{
// удаляем соединение их кэша
CacheManager.Cache.Remove(GetConnectionCacheKey(connectionKind));
// удаляем транзакцию из кэша
CacheManager.Cache.Remove(GetTransactionCacheKey(connectionKind));
}
/// <summary>
/// Закрывает соединение с БД.
/// </summary>
/// <param name="connection">Соединение с базой данных.</param>
public static void CloseConnection(IDbConnection connection, ConnectionKind connectionKind)
{
if (!HasConnectionInCache(connectionKind) || connection.State != ConnectionState.Closed)
connection.Close();
}
private IDbConnection GetConnection(ConnectionKind kind)
{
return(new MySqlConnection(_connectionString));
}
/// <summary>
/// Инициализирует объект процедуры
/// </summary>
/// <param name="procedureName">имя процедуры</param>
/// <param name="connectionKind">тип подключения</param>
public Procedure(string procedureName, ConnectionKind connectionKind)
: base(procedureName, CommandType.StoredProcedure, connectionKind)
{
}
/// <summary>
/// Инициализирует объект запроса
/// </summary>
/// <param name="sql">sql-запрос</param>
/// <param name="connectionKind">тип подключения</param>
public Query(string sql, ConnectionKind connectionKind)
: base(sql, CommandType.Text, connectionKind)
{
}
/// <summary>
/// Процедура привязки соединения к типу сервера.
/// </summary>
/// <param name="kind">Тип соединения.</param>
/// <returns>Тип сервера.</returns>
protected ConnectionType ConnectionTypeResolver(ConnectionKind kind)
{
return ConnectionType.SQLServer;
}
/// <summary>
/// Откатывает транзакцию.
/// </summary>
/// <param name="connectionKind">Тип соединения.</param>
public static void RollbackTransaction(ConnectionKind connectionKind)
{
// получаем транзакцию
IDbTransaction transaction = GetCurrentTransaction(connectionKind);
try
{
transaction.Rollback();
}
finally
{
IDbConnection connection = GetConnection(connectionKind);
connection.Close();
removeFromCache(connectionKind);
}
}
/// <summary>
/// Возвращает ключ для хранения соединения в кэше.
/// </summary>
/// <param name="connectionKind">Тип соединения.</param>
/// <returns>Ключ кэша.</returns>
private static string GetTransactionCacheKey(ConnectionKind connectionKind)
{
return String.Format("Database_Transaction_{0}_{1}", connectionKind, Thread.CurrentThread.ManagedThreadId);
}
/// <summary>
/// Завершает транзакцию.
/// </summary>
/// <param name="connectionKind">Тип соединения.</param>
public static void CommitTransaction(ConnectionKind connectionKind)
{
// получаем транзакцию
IDbTransaction transaction = GetCurrentTransaction(connectionKind);
try
{
// делаем Commit
transaction.Commit();
}
finally
{
IDbConnection connection = GetConnection(connectionKind);
connection.Close();
removeFromCache(connectionKind);
}
}
/// <summary>
/// Начинает транзацию.
/// </summary>
/// <param name="connectionKind">Тип соединения.</param>
public static void BeginTransaction(ConnectionKind connectionKind)
{
// получаем соединение
IDbConnection connection = GetConnection(connectionKind);
// помещаем соединение в кэш
CacheManager.Cache[GetConnectionCacheKey(connectionKind)] = connection;
// получаем транзакцию
IDbTransaction transaction = GetCurrentTransaction(connectionKind);
if (transaction == null)
{
// если транзакции еще нет, то открываем соединение
connection.Open();
// создаем транзакцию
transaction = connection.BeginTransaction();
CacheManager.Cache[GetTransactionCacheKey(connectionKind)] = transaction;
}
else
{
throw new CoreInvalidOperationException(Resources.ResourceManager.GetString("ParallelTransactionException"));
}
}
/// <summary>
/// Возвращает объект соединения с БД.
/// </summary>
/// <param name="connectionKind">Тип соединения.</param>
/// <returns>Соединение.</returns>
public static IDbConnection GetConnection(ConnectionKind connectionKind)
{
IDbConnection conn = null;
// Если в кэше соединений есть соединение (идет транзакция),
// то возвращаем его, иначе создаем новое.
string key = GetConnectionCacheKey(connectionKind);
object obj = CacheManager.Cache[key];
if (obj == null || !(obj is IDbConnection))
{
conn = GetDBFactory(connectionKind).CreateConnection();
conn.ConnectionString = GetConnectionString(connectionKind);
}
else
conn = (IDbConnection)obj;
return conn;
}