public override bool CreateDatabase(BaseLoginInfo loginInfo)
{
bool ret = false;
LoginInfo_SqlServer info = loginInfo as LoginInfo_SqlServer;
try
{
string cmdStr = string.Format("Create Database {0} on (NAME={1},FILENAME='{2}',SIZE={3}MB,FILEGROWTH={4}MB) log on (NAME={0},FILENAME='{5}',SIZE={3}MB,FILEGROWTH={4}MB)",
info.CreateDatabaseObject.DbName,
info.CreateDatabaseObject.DbName + "xxssyy",
info.CreateDatabaseObject.DbLocation,
info.CreateDatabaseObject.InitSize,
info.CreateDatabaseObject.FileGrowth,
info.CreateDatabaseObject.DbLogFileLocation);
DbCommand cmd = GetNewStringCommand(cmdStr);
Debug.WriteLine("Create database sql \r\n" + cmdStr);
cmd.ExecuteNonQuery();
ret = true;
}
catch (Exception ee)
{
throw ee;
}
return(ret);
}
/// <summary>
/// Notice:
/// Because OleDB Suppor many db types .
/// So the UsingOleDbType property in LoginInfo should be specifed. otherwise will use default db type -->Here is Oracle
/// </summary>
/// <param name="pInfo"></param>
public override void Open(BaseLoginInfo pInfo)
{
//Record to base class (Vital)
baseLoginInfo = pInfo;
LoginInfo_Oracle myInfo = pInfo as LoginInfo_Oracle;
LoginInfo_ForAllDbTypes allInfo = pInfo as LoginInfo_ForAllDbTypes;
if ((myInfo == null) && (allInfo == null))
{
throw new ArgumentException("Only Support Oledb login info and AllDBTypes Info");
}
if (IsOpened)
{
return;
}
string myConnString = string.Empty;
try
{
if (allInfo != null)
{
myInfo = new LoginInfo_Oracle();
//Acctually the SID is the global db name in Oracle
//It is different from other db types
myInfo.SID = allInfo.Database;
myInfo.Username = allInfo.Username;
myInfo.Password = allInfo.Pwd;
myInfo.Port = allInfo.Port;
//The hostname can be ip address of server or machine name
myInfo.HostName = allInfo.Server;
}
myConnString = DbConnectionString.Oracle.ConnectionStringWithoutClient(myInfo.HostName, myInfo.Port.ToString(),
myInfo.SID, myInfo.Username, myInfo.Password);
//Here just use the dll in odp.net
//but we need confirm the right version of current client
baseConn = new OracleConnection(myConnString);
baseConn.Open();
invalidator = new Invalidation.InvalidationBase();
CurDatabase = myInfo.SID;
CurPwd = myInfo.Password;
}
catch (Exception e)
{
throw e;
}
}
public virtual bool InvalidLogin(BaseLoginInfo info)
{
if (info == null)
{
return(true);
}
return(false);
}
public override bool CreateDatabase(BaseLoginInfo loginInfo)
{
LoginInfo_Oledb myInfo = loginInfo as LoginInfo_Oledb;
Debug.Assert(myInfo != null);
bool result = false;
return(result);
}
public override bool CreateDatabase(BaseLoginInfo loginInfo)
{
throw new NotImplement();
//LoginInfo_Oracle myInfo = loginInfo as LoginInfo_Oracle;
//Debug.Assert(myInfo != null);
//bool result = false;
//return result;
}
public sealed override void Open(BaseLoginInfo pInfo)
{
//Record to base class (Vital)
baseLoginInfo = pInfo;
LoginInfo_Sqlite myInfo = pInfo as LoginInfo_Sqlite;
LoginInfo_ForAllDbTypes allInfo = pInfo as LoginInfo_ForAllDbTypes;
if ((myInfo == null) && (allInfo == null))
{
throw new ArgumentException("Only Support Sqlite login info and AllDBTypes Info");
}
if (IsOpened)
{
return;
}
try
{
string connectionStr = string.Empty;
if (allInfo != null)
{
myInfo = new LoginInfo_Sqlite();
myInfo.Pwd = allInfo.Pwd;
myInfo.IsUnicode = allInfo.IsUnicode;
myInfo.IsReadOnly = false;
myInfo.DbFile = allInfo.Database;
}
connectionStr = DbConnectionString.Sqlite.Standard(
myInfo.DbFile, myInfo.IsReadOnly, myInfo.IsUnicode, myInfo.Pwd);
baseConn = new SQLiteConnection(connectionStr);
baseConn.Open();
CurDatabase = myInfo.DbFile;
invalidator = new InvalidatorSqlite();
}
catch (SQLiteException ee)
{
throw ee;
}
catch (DbException eee)
{
throw eee;
}
}
/// <summary>
/// Here notice :
/// The database in the connection is a folder name
/// And the database name is the file name
/// In CSV the filename is just the database name and the table name
///
/// </summary>
/// <param name="pInfo"></param>
public override void Open(BaseLoginInfo pInfo)
{
//Record to base class (Vital)
baseLoginInfo = pInfo;
LoginInfo_CSV myInfo = pInfo as LoginInfo_CSV;
LoginInfo_ForAllDbTypes allInfo = pInfo as LoginInfo_ForAllDbTypes;
if ((myInfo == null) && (allInfo == null))
{
throw new ArgumentException("Only Support Oledb login info and AllDBTypes Info");
}
if (IsOpened)
{
return;
}
string myConnString = string.Empty;
try
{
if (allInfo != null)
{
myInfo = new LoginInfo_CSV();
myInfo.Database = allInfo.Database;
myInfo.Pwd = allInfo.Pwd;
myInfo.Username = allInfo.Username;
}
//Process Database name
myInfo.Database = Directory.GetParent(myInfo.Database).FullName;
myConnString = DbConnectionString.TxtFile.OleDb_DelimitedColumns(myInfo.Database, myInfo.IsFirstRowIsColumnName);
baseConn = new OleDbConnection(myConnString);
baseConn.Open();
invalidator = new InvalidatorForOledb();
CurDatabase = myInfo.Database;
CurPwd = myInfo.Pwd;
}
catch (Exception e)
{
throw e;
}
}
/// <summary>
/// Notice:
/// Because OleDB Suppor many db types .
/// So the UsingOleDbType property in LoginInfo should be specifed. otherwise will use default db type -->Here is Access
/// </summary>
/// <param name="pInfo"></param>
public override void Open(BaseLoginInfo pInfo)
{
//Record to base class (Vital)
baseLoginInfo = pInfo;
LoginInfo_Effiproz myInfo = pInfo as LoginInfo_Effiproz;
LoginInfo_ForAllDbTypes allInfo = pInfo as LoginInfo_ForAllDbTypes;
if ((myInfo == null) && (allInfo == null))
{
throw new ArgumentException("Only Support Effiproz login info and AllDBTypes Info");
}
if (IsOpened)
{
return;
}
string myConnString = string.Empty;
try
{
if (allInfo != null)
{
myInfo = new LoginInfo_Effiproz();
myInfo.InitialCatalog = allInfo.Database;
myInfo.Username = allInfo.Username;
myInfo.Password = allInfo.Pwd;
}
myConnString = ConnSTR.DbConnectionString.EffiprozConnStr.GetConnectionString(myInfo.DBConnectionType, myInfo.InitialCatalog,
myInfo.Username, myInfo.Password);
baseConn = new EfzConnection(myConnString);
baseConn.Open();
invalidator = new InvalidatorEffiproz();
CurDatabase = myInfo.InitialCatalog;
CurPwd = myInfo.Password;
}
catch (Exception e)
{
throw e;
}
}
public sealed override bool CreateDatabase(BaseLoginInfo loginInfo)
{
LoginInfo_Sqlite myInfo = loginInfo as LoginInfo_Sqlite;
if (string.IsNullOrEmpty(myInfo.DbFile))
{
throw new ArgumentException("Db name can't be empty or null");
}
try
{
SQLiteConnection.CreateFile(myInfo.DbFile);
return(true);
}
catch (SQLiteException ee)
{
Debug.WriteLine(ee.Message);
return(false);
}
}
public sealed override bool CreateDatabase(BaseLoginInfo loginInfo)
{
LoginInfo_SSCE myInfo = loginInfo as LoginInfo_SSCE;
bool result = false;
string createTabelCommand = string.Empty;
//Use "" for filter Special Chars
createTabelCommand = string.Format("DataSource=\"{0}\"", myInfo.DbName);
if (!string.IsNullOrEmpty(myInfo.Pwd))
{
createTabelCommand = string.Format("{0} ;Password={1}", createTabelCommand, myInfo.Pwd);
}
else
{
createTabelCommand = string.Format("{0} ;Password=''", createTabelCommand, myInfo.Pwd);
}
createTabelCommand = string.Format("{0} ;Encrypt={1}", createTabelCommand, myInfo.IsEncrypted);
//Add Case Sensitive Support
//This feautre only support after SqlCE3.5 Sp1
if (myInfo.IsCaseSensitive)
{
createTabelCommand = createTabelCommand + ";Case Sensitive=true";
}
try
{
SqlCeEngine eg = new SqlCeEngine(createTabelCommand);
eg.CreateDatabase();
result = true;
}
catch (Exception ce)
{
throw ce;
}
return(result);
}
public override bool CreateDatabase(BaseLoginInfo loginInfo)
{
LoginInfo_CSV myInfo = loginInfo as LoginInfo_CSV;
Debug.Assert(myInfo != null);
bool result = false;
try
{
File.Create(myInfo.Database);
result = true;
}
catch (Exception ee)
{
throw ee;
}
return(result);
}
public void EditUserProviderInfo(long idLoginInfo)
{
BaseLoginInfo loginInfo = CurrentManager.Get <BaseLoginInfo>(idLoginInfo);
if (loginInfo != null)
{
View.CurrentIdProvider = 0;
if (typeof(InternalLoginInfo) == loginInfo.GetType())
{
View.EditInternalUserInfo(idLoginInfo, ((InternalLoginInfo)loginInfo).Login);
}
else
{
View.CurrentIdProvider = ((ExternalLoginInfo)loginInfo).Provider.Id;
View.EditExternalUserInfo(idLoginInfo, Service.GetProfileProvider(View.idProfile, ((ExternalLoginInfo)loginInfo).Provider.Id, UserContext.Language.Id), new dtoExternalCredentials()
{
IdentifierLong = ((ExternalLoginInfo)loginInfo).IdExternalLong, IdentifierString = ((ExternalLoginInfo)loginInfo).IdExternalString
});
}
}
}
public override bool CreateDatabase(BaseLoginInfo loginInfo)
{
bool result = false;
string createCmd = string.Empty;
LoginInfo_Effiproz myInfo = loginInfo as LoginInfo_Effiproz;
Debug.Assert(myInfo != null);
createCmd = ConnSTR.DbConnectionString.EffiprozConnStr.GetConnectionString(myInfo.DBConnectionType, myInfo.InitialCatalog, myInfo.Username, myInfo.Password);
try
{
EfzConnection conn = new EfzConnection(createCmd);
conn.Open();
result = true;
}
catch (Exception ee)
{
Debug.Write(ee.Message);
}
return(result);
}
public override bool CreateDatabase(BaseLoginInfo loginInfo)
{
LoginInfo_Oledb myInfo = loginInfo as LoginInfo_Oledb;
Debug.Assert(myInfo != null);
bool result = false;
try
{
ADOX.CatalogClass cat = new ADOX.CatalogClass();
cat.Create(String.Format("Provider=Microsoft.Jet.OLEDB.4.0;" +
"Data Source={0};" +
"Jet OLEDB:Engine Type=5", myInfo.Database));
result = true;
}
catch (Exception ee)
{
throw ee;
}
return(result);
}
/// <summary>
///
/// When to use trust connection string (Connect to online )
/// When to ues not trust connection string (Connect to remote or local)
///
/// </summary>
/// <param name="pInfo"></param>
public sealed override void Open(BaseLoginInfo pInfo)
{
//Record to base class (Vital)
baseLoginInfo = pInfo;
LoginInfo_SqlServer myInfo = pInfo as LoginInfo_SqlServer;
LoginInfo_ForAllDbTypes allInfo = pInfo as LoginInfo_ForAllDbTypes;
if ((myInfo == null) && (allInfo == null))
{
throw new ArgumentException("Only Support Sqlserver login info and AllDBTypes Info");
}
if (IsOpened)
{
return;
}
string myConnString = string.Empty;
if (allInfo != null)
{
myInfo = new LoginInfo_SqlServer();
myInfo.IsTrustedConn = allInfo.IsTrustedConn;
myInfo.X_Database = allInfo.Database;
myInfo.X_Pwd = allInfo.Pwd;
myInfo.X_Server = allInfo.Server;
myInfo.X_TableName = allInfo.TableName;
myInfo.X_UserName = allInfo.Username;
myInfo.X_CurDbConnectionMode = allInfo.CurConnMode;
myInfo.AttchFile = allInfo.AttachedFileName;
}
if (myInfo.IsTrustedConn)
{
switch (myInfo.X_CurDbConnectionMode)
{
case CurDbServerConnMode.Local:
myConnString = DbConnectionString.Sqlserver.GetConnectionString(myInfo.X_Server, myInfo.X_UserName, myInfo.X_Pwd, myInfo.X_Database);
break;
case CurDbServerConnMode.Standard:
myConnString = DbConnectionString.Sqlserver.Standard_WithTrustOrNot(myInfo.X_Server, myInfo.X_Database, myInfo.X_UserName, myInfo.X_Pwd, true);
break;
case CurDbServerConnMode.SqlServer2005Express:
myConnString = DbConnectionString.Sqlserver.GetSqlServerExpressCS(myInfo.X_Server, myInfo.X_Database, myInfo.X_UserName, myInfo.X_Pwd, myInfo.IsTrustedConn);
break;
case CurDbServerConnMode.SqlServer2000:
myConnString = DbConnectionString.Sqlserver.SqlServerConnectionString(myInfo.X_Server, myInfo.X_UserName, myInfo.X_Pwd, myInfo.X_Database);
break;
case CurDbServerConnMode.OleDb:
myConnString = DbConnectionString.Sqlserver.GetOledbConnectionString_Trust(myInfo.X_Server, myInfo.X_UserName, myInfo.X_Pwd, myInfo.X_Database);
break;
case CurDbServerConnMode.AttachFile:
// myConnString = DbConnectionString.Sqlserver.AttachFile(myInfo.X_Server, myInfo.AttchFile);
myConnString = DbConnectionString.Sqlserver.AttachFileEx(myInfo.X_Server, myInfo.AttchFile);
break;
case CurDbServerConnMode.SqlServer2008Express:
myConnString = DbConnectionString.Sqlserver.GetSqlServer2008_Trust(myInfo.X_Server, myInfo.X_Database);
break;
case CurDbServerConnMode.SqlServer2005:
myConnString = DbConnectionString.Sqlserver.Connection_Mars(myInfo.X_Server, myInfo.X_Database);
break;
}
}
else
{
switch (myInfo.X_CurDbConnectionMode)
{
case CurDbServerConnMode.OleDb:
myConnString = DbConnectionString.Sqlserver.GetOledbConnectionString_NoTrust(myInfo.X_Server, myInfo.X_UserName, myInfo.X_Pwd, myInfo.X_Database);
break;
case CurDbServerConnMode.Local:
myConnString = DbConnectionString.Sqlserver.GetConnectionString(myInfo.X_Server, myInfo.X_UserName, myInfo.X_Pwd, myInfo.X_Database);
break;
case CurDbServerConnMode.Standard:
myConnString = DbConnectionString.Sqlserver.Standard_WithTrustOrNot(myInfo.X_Server, myInfo.X_Database, myInfo.X_UserName, myInfo.X_Pwd, false);
break;
case CurDbServerConnMode.SqlServer2000:
myConnString = DbConnectionString.Sqlserver.SqlServerConnectionString(myInfo.X_Server, myInfo.X_UserName, myInfo.X_Pwd, myInfo.X_Database);
break;
case CurDbServerConnMode.SqlServer2005Express:
myConnString = DbConnectionString.Sqlserver.GetSqlServerExpressCS(myInfo.X_Server, myInfo.X_Database, myInfo.X_UserName, myInfo.X_Pwd, myInfo.IsTrustedConn);
break;
case CurDbServerConnMode.AttachFile:
throw new Exception("Attach File mode need TrustConnection");
case CurDbServerConnMode.SqlServer2008Express:
myConnString = DbConnectionString.Sqlserver.GetSqlServer2008_StandardSecurity(
myInfo.X_Server, myInfo.X_Database, myInfo.X_UserName, myInfo.X_Pwd
);
break;
case CurDbServerConnMode.SqlServer2005:
myConnString = DbConnectionString.Sqlserver.Connection_Mars_NoTrust(
myInfo.X_Server, myInfo.X_Database, myInfo.X_UserName, myInfo.X_Pwd);
break;
}
}
try
{
baseConn = new SqlConnection(myConnString);
baseConn.Open();
CurDatabase = myInfo.X_Database;
CurPwd = myInfo.X_Pwd;
invalidator = new InvalidatorForSqlServer();
}
catch (DataException ee)
{
throw ee;
}
}
/// <summary> /// 如果当前的HANDLE 已经打开或者拥有CONNECTION则不会再次创建联接 /// </summary> /// <param name="info"></param> public abstract void Open(BaseLoginInfo info);
public abstract bool CreateDatabase(BaseLoginInfo loginInfo);
public sealed override void Open(BaseLoginInfo pInfo)
{
//Record to base class (Vital)
baseLoginInfo = pInfo;
LoginInfo_SSCE myInfo = pInfo as LoginInfo_SSCE;
LoginInfo_ForAllDbTypes allInfo = pInfo as LoginInfo_ForAllDbTypes;
if ((myInfo == null) && (allInfo == null))
{
throw new ArgumentException("Only Support SSCE login info and AllDBTypes Info");
}
if (IsOpened)
{
return;
}
string myConnString = string.Empty;
try
{
if (allInfo != null)
{
myInfo = new LoginInfo_SSCE();
myInfo.DbName = allInfo.Database;
myInfo.Pwd = allInfo.Pwd;
myInfo.IsEncrypted = allInfo.IsEncrypt;
}
OpenModeClass op = new OpenModeClass();
op.mode = myInfo.CurOpenMode;
switch (myInfo.CurOpenMode)
{
case OpenMode.ReadWrite:
op.modeDisplayName = "Read Write";
break;
case OpenMode.ReadOnly:
op.modeDisplayName = "Read Only";
break;
case OpenMode.Exclusive:
op.modeDisplayName = "Exclusive";
break;
case OpenMode.SharedRead:
op.modeDisplayName = "Shared Read";
break;
default:
op.modeDisplayName = "Read Write";
break;
}
if (myInfo.MaxBufferSize == 0)
{
myInfo.MaxBufferSize = 1024;
}
if (myInfo.MaxDbSize == 0)
{
myInfo.MaxDbSize = 4000;
}
myConnString = DbConnectionString.SSCE.GetSSCEConnectionString(
myInfo.DbName, myInfo.Pwd, myInfo.IsEncrypted, op, myInfo.MaxDbSize, myInfo.MaxBufferSize);
baseConn = new SqlCeConnection(myConnString);
baseConn.Open();
CurDatabase = myInfo.DbName;
CurPwd = myInfo.Pwd;
invalidator = new InvalidatorForSqlCe();
}
catch (Exception e)
{
throw e;
}
}
/// <summary>
/// Notice:
/// Because OleDB Suppor many db types .
/// So the UsingOleDbType property in LoginInfo should be specifed. otherwise will use default db type -->Here is Access
/// </summary>
/// <param name="pInfo"></param>
public override void Open(BaseLoginInfo pInfo)
{
//Record to base class (Vital)
baseLoginInfo = pInfo;
LoginInfo_Excel myInfo = pInfo as LoginInfo_Excel;
LoginInfo_ForAllDbTypes allInfo = pInfo as LoginInfo_ForAllDbTypes;
if ((myInfo == null) && (allInfo == null))
{
throw new ArgumentException("Only Support Oledb login info and AllDBTypes Info");
}
if (IsOpened)
{
return;
}
string myConnString = string.Empty;
try
{
if (allInfo != null)
{
myInfo = new LoginInfo_Excel();
myInfo.Database = allInfo.Database;
myInfo.Pwd = allInfo.Pwd;
myInfo.Username = allInfo.Username;
myInfo.CurrentOleDBVersion = allInfo.CurrentOleDBVersion;
}
switch (myInfo.CurrentOleDBVersion)
{
case OleDBVersion.Is2003:
myConnString = DbConnectionString.Excel.GetOleDbConnectionString(myInfo.Database, myInfo.IsFirstRowIsColumnName);
break;
case OleDBVersion.Is2007:
myConnString = DbConnectionString.Excel2007.GetOleDBString(myInfo.Database, myInfo.IsFirstRowIsColumnName);
break;
default:
myConnString = DbConnectionString.Excel.GetOleDbConnectionString(myInfo.Database, myInfo.IsFirstRowIsColumnName);
break;
}
baseConn = new OleDbConnection(myConnString);
baseConn.Open();
invalidator = new InvalidatorForOledb();
CurDatabase = myInfo.Database;
CurPwd = myInfo.Pwd;
}
catch (Exception e)
{
throw e;
}
}
public sealed override bool CreateDatabase(BaseLoginInfo loginInfo)
{
throw new NotImplementedException();
}
public sealed override void Open(BaseLoginInfo pInfo)
{
//Record to base class (Vital)
baseLoginInfo = pInfo;
LoginInfo_MySql myInfo = pInfo as LoginInfo_MySql;
LoginInfo_ForAllDbTypes allInfo = pInfo as LoginInfo_ForAllDbTypes;
if ((myInfo == null) && (allInfo == null))
{
throw new ArgumentException("Only Support MySql login info and AllDBTypes Info");
}
if (IsOpened)
{
return;
}
try
{
string myConnString = string.Empty;
if (allInfo != null)
{
myInfo = new LoginInfo_MySql();
myInfo.Database = allInfo.Database;
myInfo.Pwd = allInfo.Pwd;
myInfo.Server = allInfo.Server;
myInfo.Username = allInfo.Username;
myInfo.Port = allInfo.Port;
}
myConnString = DbConnectionString.MySql.GetMySqlConnectionString(
myInfo.Server,
myInfo.Username,
myInfo.Pwd,
myInfo.Port,
myInfo.Database,
myInfo.ConnectionTimeOut,
50,
myInfo.IsPolling
);
baseConn = new MySqlConnection(myConnString);
baseConn.Open();
Debug.WriteLine("Connection Timeout is " + baseConn.ConnectionTimeout);
invalidator = new InvalidatorForMySql();
//Set Current Opened Database
base.CurDatabase = myInfo.Database;
base.CurPwd = myInfo.Pwd;
if (string.IsNullOrEmpty(myInfo.Database))
{
DoExecuteNonQuery("use mysql;");
}
else
{
DoExecuteNonQuery("use " + myInfo.Database + ";");
}
}
catch (Exception ee)
{
throw ee;
}
}
/// <summary>
/// Notice:
/// Because OleDB Suppor many db types .
/// So the UsingOleDbType property in LoginInfo should be specifed. otherwise will use default db type -->Here is Access
/// </summary>
/// <param name="pInfo"></param>
public override void Open(BaseLoginInfo pInfo)
{
//Record to base class (Vital)
baseLoginInfo = pInfo;
LoginInfo_Oledb myInfo = pInfo as LoginInfo_Oledb;
LoginInfo_ForAllDbTypes allInfo = pInfo as LoginInfo_ForAllDbTypes;
if ((myInfo == null) && (allInfo == null))
{
throw new ArgumentException("Only Support Oledb login info and AllDBTypes Info");
}
if (IsOpened)
{
return;
}
string myConnString = string.Empty;
try
{
if (allInfo != null)
{
myInfo = new LoginInfo_Oledb();
myInfo.Database = allInfo.Database;
myInfo.Pwd = allInfo.Pwd;
myInfo.Username = allInfo.Username;
myInfo.CurrentOleDBVersion = allInfo.CurrentOleDBVersion;
//myInfo.CurOleDBType=allInfo.
}
#region Get Connection String
switch (myInfo.CurrentOleDBVersion)
{
case OleDBVersion.Is2003:
if (string.IsNullOrEmpty(myInfo.Pwd))
{
myConnString = DbConnectionString.Access.GetOledbAccess(myInfo.Database, myInfo.Username, myInfo.Pwd);
}
else
{
myConnString = DbConnectionString.Access.GetOleDbAccessWithPassword(myInfo.Database, myInfo.Pwd);
}
break;
case OleDBVersion.Is2007:
if (string.IsNullOrEmpty(myInfo.Pwd))
{
myConnString = DbConnectionString.Access2007.GetOleDBString(myInfo.Database, "");
}
else
{
myConnString = DbConnectionString.Access2007.GetOleDBString(myInfo.Database, myInfo.Pwd);
}
break;
default:
if (string.IsNullOrEmpty(myInfo.Pwd))
{
myConnString = DbConnectionString.Access.GetOledbAccess(myInfo.Database, myInfo.Username, myInfo.Pwd);
}
else
{
myConnString = DbConnectionString.Access.GetOleDbAccessWithPassword(myInfo.Database, myInfo.Pwd);
}
break;
}
#endregion
baseConn = new OleDbConnection(myConnString);
baseConn.Open();
invalidator = new InvalidatorForOledb();
CurDatabase = myInfo.Database;
CurPwd = myInfo.Pwd;
}
catch (Exception e)
{
throw e;
}
}
