public DataBaseDescriptor(Authentication authentication, IDataBase dataBase, DescriptorTypes descriptorTypes, object owner)
: base(authentication, dataBase, descriptorTypes)
{
this.dataBase = dataBase;
this.owner = owner ?? this;
this.dataBase.Dispatcher.VerifyAccess();
this.dataBaseInfo = dataBase.DataBaseInfo;
this.dataBaseState = dataBase.DataBaseState;
this.authenticationInfos = dataBase.AuthenticationInfos;
this.lockInfo = dataBase.LockInfo;
this.accessInfo = dataBase.AccessInfo;
this.accessType = dataBase.GetAccessType(authentication);
if (this.descriptorTypes.HasFlag(DescriptorTypes.IsSubscriptable) == true)
{
this.dataBase.Renamed += DataBase_Renamed;
this.dataBase.Deleted += DataBase_Deleted;
this.dataBase.Loaded += DataBase_Loaded;
this.dataBase.Unloaded += DataBase_Unloaded;
this.dataBase.AuthenticationEntered += DataBase_AuthenticationEntered;
this.dataBase.AuthenticationLeft += DataBase_AuthenticationLeft;
this.dataBase.DataBaseInfoChanged += DataBase_DataBaseInfoChanged;
this.dataBase.DataBaseStateChanged += DataBase_DataBaseStateChanged;
this.dataBase.AccessChanged += DataBase_AccessChanged;
this.dataBase.LockChanged += DataBase_LockChanged;
}
}
private static DataBaseProvider _provider; // класс реализующий сервисные функции работы с базой данных
/// <summary>
/// Выполнить инициалтзацию базы данных
/// </summary>
internal static void Initialize()
{
state = DataBaseState.Default;
s_slim = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
parameters = new DataBaseParameters(1024);
}
private DataBaseServer server; // сервер БД
/// <summary>
/// Инициализирует новый экземпляр класса
/// </summary>
public DataBaseManager()
{
mutex = new Mutex();
state = DataBaseState.Default;
adapter = new DataBaseAdapter();
server = new DataBaseServer(adapter);
dataBase = new DataBase(adapter);
server = new DataBaseServer(adapter);
}
private DataBaseState state; // текущее состояние БД
#endregion Fields
#region Constructors
/// <summary>
/// Инициализирует новый экземпляр класса
/// </summary>
public DataBaseManager()
{
mutex = new Mutex();
state = DataBaseState.Default;
adapter = new DataBaseAdapter();
server = new DataBaseServer(adapter);
dataBase = new DataBase(adapter);
server = new DataBaseServer(adapter);
}
/// <summary>
/// Инициализирует новый экземпляр класса
/// </summary>
/// <param name="info">Объект System.Runtime.Serialization.SerializationInfo для извлечения данных.</param>
/// <param name="context">Целевое местоположение сериализации.</param>
protected DataBaseManager(SerializationInfo info, StreamingContext context)
{
mutex = new Mutex();
state = DataBaseState.Default;
adapter = new DataBaseAdapter();
adapter.UserID = info.GetString("UserID");
adapter.Password = info.GetString("Password");
server = new DataBaseServer(adapter);
dataBase = new DataBase(adapter);
server = new DataBaseServer(adapter);
}
/// <summary>
/// Инициализирует новый экземпляр класса
/// </summary>
/// <param name="info">Объект System.Runtime.Serialization.SerializationInfo для извлечения данных.</param>
/// <param name="context">Целевое местоположение сериализации.</param>
protected DataBaseManager(SerializationInfo info, StreamingContext context)
{
mutex = new Mutex();
state = DataBaseState.Default;
adapter = new DataBaseAdapter();
adapter.UserID = info.GetString("UserID");
adapter.Password = info.GetString("Password");
server = new DataBaseServer(adapter);
dataBase = new DataBase(adapter);
server = new DataBaseServer(adapter);
}
/// <summary>
/// Загрузить базу данных
/// </summary>
/// <param name="provider">Класс реализующий сервисные функции работы с базой данных</param>
/// <returns>Состояние базы данных после выполнение операции загрузки БД</returns>
public static DataBaseState LoadDB(DataBaseProvider provider)
{
if (provider != null)
{
switch (State)
{
case DataBaseState.Loaded:
throw new InvalidOperationException("Не допустимая операция. Перез загрузкой БД, необходимо завершить работу с текущей.");
case DataBaseState.Unloaded:
case DataBaseState.Default:
parameters.Clear();
try
{
DataBaseParameter[] parames = provider.Parameters;
if (parames != null)
{
foreach (DataBaseParameter parameter in parames)
{
if (parameter != null)
{
parameters.Insert(parameter);
}
}
_provider = provider;
measuring = t_measuring.Virtualize(provider.Adapter);
}
State = DataBaseState.Loaded;
return(State);
}
catch (Exception ex)
{
throw new Exception(ex.Message, ex);
}
default:
break;
}
}
return(DataBaseState.Default);
}
/// <summary>
/// Закрыть базу данных
/// </summary>
public static void CloseDB()
{
switch (State)
{
case DataBaseState.Loaded:
SqlConnection.ClearAllPools();
State = DataBaseState.Unloaded;
parameters.Clear();
break;
default:
break;
}
}
/// <summary>
/// Загрузить БД
/// </summary>
/// <param name="dbName">Имя загружаемой БД</param>
public void LoadDB(string dbName)
{
bool blocked = false;
string old_dbName = string.Empty;
try
{
if (mutex.WaitOne(1000))
{
blocked = true;
old_dbName = adapter.InitialCatalog;
if (state == DataBaseState.Default)
{
adapter.InitialCatalog = dbName;
dataBase.LoadDB();
state = DataBaseState.Loaded;
}
}
else
{
throw new TimeoutException();
}
}
catch (Exception ex)
{
adapter.InitialCatalog = old_dbName;
throw new Exception(ex.Message, ex);
}
finally
{
if (blocked)
{
mutex.ReleaseMutex();
}
}
}
/// <summary>
/// Переключить в режим записи значений параметров
/// </summary>
public void TurnOnToSavingMode()
{
bool blocked = false;
try
{
if (mutex.WaitOne(1000))
{
blocked = true;
if (state == DataBaseState.Loaded)
{
dataBase.DataBaseSaver.Start();
state = DataBaseState.Saving;
}
else
{
throw new InvalidOperationException();
}
}
else
{
throw new TimeoutException();
}
}
catch (Exception ex)
{
throw new Exception(ex.Message, ex);
}
finally
{
if (blocked)
{
mutex.ReleaseMutex();
}
}
}
/// <summary>
/// Закрыть загруженную БД
/// </summary>
public void CloseDB()
{
bool blocked = false;
try
{
if (mutex.WaitOne(1000))
{
blocked = true;
if (state == DataBaseState.Loaded || state == DataBaseState.Saving)
{
dataBase.CloseDB();
state = DataBaseState.Default;
}
else
{
throw new InvalidOperationException("База данных не загружена.");
}
}
else
{
throw new TimeoutException();
}
}
catch (Exception ex)
{
throw new Exception(ex.Message, ex);
}
finally
{
if (blocked)
{
mutex.ReleaseMutex();
}
}
}
/// <summary>
/// Загрузить БД
/// </summary>
public void LoadDB()
{
bool blocked = false;
try
{
if (mutex.WaitOne(1000))
{
blocked = true;
if (state == DataBaseState.Default)
{
dataBase.LoadDB();
state = DataBaseState.Loaded;
}
else
{
throw new Exception("Текущее состояние не позволяет загрузить БД");
}
}
else
{
throw new TimeoutException();
}
}
catch (Exception ex)
{
throw new Exception(ex.Message, ex);
}
finally
{
if (blocked)
{
mutex.ReleaseMutex();
}
}
}
/// <summary>
/// Загрузить базу данных
/// </summary>
/// <param name="provider">Класс реализующий сервисные функции работы с базой данных</param>
/// <returns>Состояние базы данных после выполнение операции загрузки БД</returns>
public static DataBaseState LoadDB(DataBaseProvider provider)
{
if (provider != null)
{
switch (State)
{
case DataBaseState.Loaded:
throw new InvalidOperationException("Не допустимая операция. Перез загрузкой БД, необходимо завершить работу с текущей.");
case DataBaseState.Unloaded:
case DataBaseState.Default:
parameters.Clear();
try
{
DataBaseParameter[] parames = provider.Parameters;
if (parames != null)
{
foreach (DataBaseParameter parameter in parames)
{
if (parameter != null)
{
parameters.Insert(parameter);
}
}
_provider = provider;
measuring = t_measuring.Virtualize(provider.Adapter);
}
State = DataBaseState.Loaded;
return State;
}
catch (Exception ex)
{
throw new Exception(ex.Message, ex);
}
default:
break;
}
}
return DataBaseState.Default;
}
/// <summary>
/// Закрыть базу данных
/// </summary>
public static void CloseDB()
{
switch (State)
{
case DataBaseState.Loaded:
SqlConnection.ClearAllPools();
State = DataBaseState.Unloaded;
parameters.Clear();
break;
default:
break;
}
}
/// <summary>
/// Закрыть загруженную БД
/// </summary>
public void CloseDB()
{
bool blocked = false;
try
{
if (mutex.WaitOne(1000))
{
blocked = true;
if (state == DataBaseState.Loaded || state == DataBaseState.Saving)
{
dataBase.CloseDB();
state = DataBaseState.Default;
}
else
throw new InvalidOperationException("База данных не загружена.");
}
else
throw new TimeoutException();
}
catch (Exception ex)
{
throw new Exception(ex.Message, ex);
}
finally
{
if (blocked) mutex.ReleaseMutex();
}
}
private async void DataBase_DataBaseStateChanged(object sender, EventArgs e)
{
this.dataBaseState = this.dataBase.DataBaseState;
await this.RefreshAsync();
}
private async void DataBase_Unloaded(object sender, EventArgs e)
{
this.dataBaseState = this.dataBase.DataBaseState;
this.authenticationInfos = this.dataBase.AuthenticationInfos;
await this.RefreshAsync();
}
/// <summary>
/// Выполнить инициалтзацию базы данных
/// </summary>
internal static void Initialize()
{
state = DataBaseState.Default;
s_slim = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
parameters = new DataBaseParameters(1024);
}
/// <summary>
/// Загрузить БД
/// </summary>
public void LoadDB()
{
bool blocked = false;
try
{
if (mutex.WaitOne(1000))
{
blocked = true;
if (state == DataBaseState.Default)
{
dataBase.LoadDB();
state = DataBaseState.Loaded;
}
else
throw new Exception("Текущее состояние не позволяет загрузить БД");
}
else
throw new TimeoutException();
}
catch (Exception ex)
{
throw new Exception(ex.Message, ex);
}
finally
{
if (blocked) mutex.ReleaseMutex();
}
}
/// <summary>
/// Переключить в режим записи значений параметров
/// </summary>
public void TurnOnToSavingMode()
{
bool blocked = false;
try
{
if (mutex.WaitOne(1000))
{
blocked = true;
if (state == DataBaseState.Loaded)
{
dataBase.DataBaseSaver.Start();
state = DataBaseState.Saving;
}
else
throw new InvalidOperationException();
}
else
throw new TimeoutException();
}
catch (Exception ex)
{
throw new Exception(ex.Message, ex);
}
finally
{
if (blocked) mutex.ReleaseMutex();
}
}
/// <summary>
/// Загрузить БД
/// </summary>
/// <param name="dbName">Имя загружаемой БД</param>
public void LoadDB(string dbName)
{
bool blocked = false;
string old_dbName = string.Empty;
try
{
if (mutex.WaitOne(1000))
{
blocked = true;
old_dbName = adapter.InitialCatalog;
if (state == DataBaseState.Default)
{
adapter.InitialCatalog = dbName;
dataBase.LoadDB();
state = DataBaseState.Loaded;
}
}
else
throw new TimeoutException();
}
catch (Exception ex)
{
adapter.InitialCatalog = old_dbName;
throw new Exception(ex.Message, ex);
}
finally
{
if (blocked) mutex.ReleaseMutex();
}
}
