using System.Data.OleDb;

OleDbConnection con = new OleDbConnection(connectionString);
con.Open();
con.Close();

OleDbConnectionStringBuilder cb = new OleDbConnectionStringBuilder();
cb.Provider = "LCPI.IBProvider"; 
cb.Add("Location", @"localhost:d:\Program Files\Firebird\examples\EMPLOYEE.FDB");
cb.Add("User ID", "sysdba");
cb.Add("Password", "masterkey");
cb.Add("ctype", "win1251");
Console.WriteLine(cb)

OleDbConnectionStringBuilder cb = new OleDbConnectionStringBuilder();
cb.FileName = AppDomain.CurrentDomain.BaseDirectory + @"\employee.udl";
OleDbConnection con = new OleDbConnection(cb.ToString());
con.Open();

// чтение свойства с именем ConnectionString
Console.WriteLine(Properties.Settings.Default.ConnectionString); 

public void ExecuteScalarTest()
{
 using(OleDbConnection con = ConnectionProvider.CreateConnection())
 {
 con.Open();
 OleDbTransaction trans = con.BeginTransaction();
 OleDbCommand cmd = new OleDbCommand(
 "select count(*) from employee", con, trans);
 Console.WriteLine("Record count:" + cmd.ExecuteScalar().ToString());
 
 trans.Commit();
 }
}

public void ExecuteReaderTest()
{
 OleDbConnection con = ConnectionProvider.CreateConnection();
 con.Open();
 
 // Испольуем метод CreateCommand для создания команды
 OleDbCommand cmd = con.CreateCommand();
 cmd.Transaction = con.BeginTransaction();
 cmd.CommandText = "select * from employee"; 
 OleDbDataReader rdr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
 // чтение данных
 while (rdr.Read())
 { 
 string tmp ="";
 for(int i = 0; i < rdr.FieldCount - 1; i++) 
 {
 if (tmp != "")
  tmp += "\t";
 tmp += rdr[i].ToString();
 }
 Console.WriteLine(tmp);
 }
 rdr.Close();
 // после вызова OleDbDataReader.Close() подключение к БД будет закрыто
 Assert.AreEqual(ConnectionState.Closed, con.State); 
}

public void ExecuteNonQueryTest()
{
 OleDbConnection con = ConnectionProvider.CreateConnection();
 con.Open();
 OleDbTransaction trans = con.BeginTransaction();
 // INSERT 
 OleDbCommand cmd = new OleDbCommand( 
 "insert into country (country, currency) values(:country, :currency) ", 
 con, trans);
 
 cmd.Parameters.AddWithValue("country", "Russia");
 cmd.Parameters.AddWithValue("currency", "Copeck");
 // количество обработанных строк
 Assert.AreEqual(1, cmd.ExecuteNonQuery());
 
 // UPDATE
 cmd = new OleDbCommand(
 "update country set currency= :currency where country = :country", 
 con, trans);
 cmd.Parameters.AddWithValue("currency", "Rouble");
 cmd.Parameters.AddWithValue("country", "Russia");
 // количество обработанных строк
 Assert.AreEqual(1, cmd.ExecuteNonQuery());
 
 // DELETE
 cmd = new OleDbCommand(
 "delete from country where country = :country", con, trans);
 
 cmd.Parameters.AddWithValue("country", "Russia");
 // количество обработанных строк
 Assert.AreEqual(1, cmd.ExecuteNonQuery());
 trans.Commit();
 con.Close(); 
}

insert into country (country, currency) values(?, ?)

insert into country (country, currency) values(:country, :currency)

update country set currency = :currency where country = :country 

cmd.Parameters.AddWithValue("currency", "Rouble");
cmd.Parameters.AddWithValue("country", "Russia");

cmd.Parameters["country"].Value = "Latvia";
cmd.Parameters["currency"].Value = "Lat";

select * from stored_procedure_name(...)

public void StoredProcedureResultSetTest()
{
 OleDbConnection con = ConnectionProvider.CreateConnection();
 con.Open();
 OleDbTransaction trans = con.BeginTransaction();
 // выбор хранимой процедуры 
 OleDbCommand cmdInParams = 
new OleDbCommand("select cust_no from CUSTOMER", con, trans);
 
 // Выбор адрес с помощью хранимой процедуры
 OleDbCommand cmdStoredProc = 
new OleDbCommand("select * from mail_label(:cust_no)", con, trans);
 
 // добавление одного IN-параметра
 cmdStoredProc.Parameters.Add("cust_no", OleDbType.Integer);
 // Чтение
 using (OleDbDataReader rdr = 
 cmdInParams.ExecuteReader(CommandBehavior.CloseConnection))
 {
 // Для каждого № покупателя 
 while (rdr.Read())
 { 
 cmdStoredProc.Parameters["cust_no"].Value = rdr["cust_no"];
 using (OleDbDataReader rdrOut = cmdStoredProc.ExecuteReader())
 {
 Console.WriteLine("Customer №" + rdr["cust_no"]); 
 while (rdr_out.Read())
 for (int i = 0; i < rdrOut.FieldCount; i++)
 Console.WriteLine(rdrOut.GetName(i) + "=" + rdrOut [i]);
 Console.WriteLine();
 }
 }
 }
}

execute procedure stored_procedure_name

public void StoredProcedureOutParamsTest()
{
 OleDbConnection con = ConnectionProvider.CreateConnection();
 con.Open();
 OleDbTransaction trans = con.BeginTransaction();
 OleDbCommand cmdInParams =
 new OleDbCommand("select cust_no from CUSTOMER", con, trans);
 // хранимая процедура 
 OleDbCommand cmdStoredProc = 
 new OleDbCommand("execute procedure mail_label(:cust_no)", con, trans);
 // IN-параметр
 cmdStoredProc.Parameters.Add("cust_no", OleDbType.BSTR);
 // OUT-параметры
 cmdStoredProc.Parameters.Add("line1", OleDbType.BSTR)
 .Direction = ParameterDirection.Output; 
 cmdStoredProc.Parameters.Add("line2", OleDbType.BSTR)
 .Direction = ParameterDirection.Output;
 cmdStoredProc.Parameters.Add("line3", OleDbType.BSTR)
 .Direction = ParameterDirection.Output;
 cmdStoredProc.Parameters.Add("line4", OleDbType.BSTR)
 .Direction = ParameterDirection.Output;
 cmdStoredProc.Parameters.Add("line5", OleDbType.BSTR)
 .Direction = ParameterDirection.Output;
 cmdStoredProc.Parameters.Add("line6", OleDbType.BSTR)
 .Direction = ParameterDirection.Output;
 // чтение
 using (OleDbDataReader rdr = cmdInParams.ExecuteReader())
 {
 // Для каждого № покупателя
 while (rdr.Read())
 {
 cmdStoredProc.Parameters["cust_no"].Value = rdr["cust_no"];
 cmdStoredProc.ExecuteNonQuery();
 Console.WriteLine("Customer №" + rdr["cust_no"]);
 Console.WriteLine(cmdStoredProc.Parameters["line1"].Value);
 Console.WriteLine(cmdStoredProc.Parameters["line2"].Value);
 Console.WriteLine(cmdStoredProc.Parameters["line3"].Value);
 Console.WriteLine(cmdStoredProc.Parameters["line4"].Value);
 Console.WriteLine(cmdStoredProc.Parameters["line5"].Value);
 Console.WriteLine(cmdStoredProc.Parameters["line6"].Value);
 Console.WriteLine("");
 }
 }
 trans.Commit();
 con.Close();
}

public void ArrayReadWriteTest()
{
 using(OleDbConnection con = ConnectionProvider.CreateConnection())
 {
 con.Open();
 OleDbTransaction trans = con.BeginTransaction();
 OleDbCommand cmd = new OleDbCommand(
 "select job_code, job_grade, job_country, job_title, \n" +
 "language_req from job", con, trans);
 OleDbCommand cmdUpd = new OleDbCommand(
 "update job set language_req = :language_reg where \n" +
 "job_code = :job_code and job_grade = :job_grade and \n" + 
 "job_country = :job_country", con, trans);
 cmdUpd.Parameters.Add("language_req", OleDbType.Variant);
 cmdUpd.Parameters.Add("job_code", OleDbType.BSTR);
 cmdUpd.Parameters.Add("job_grade", OleDbType.BSTR);
 cmdUpd.Parameters.Add("job_country", OleDbType.BSTR);
 using (OleDbDataReader rdr = cmd.ExecuteReader())
 {
 while (rdr.Read())
 {
 Console.WriteLine("JOB TITLE:" + rdr["job_title"].ToString());
 // чтение массива
 if (rdr["language_req"] != DBNull.Value)
 {
 Array strs = (Array)rdr["language_req"];
 for (int i = strs.GetLowerBound(0); 
 	 i <= strs.GetUpperBound(0); i++)
 {
 // усечение символа \n на концах элементов массива
 string trimmedValue = 
 strs.GetValue(i).ToString().Replace("\n", "");
 
 strs.SetValue(trimmedValue, i);
 // вывод значения
 if (trimmedValue != "")
 Console.WriteLine(trimmedValue);
 }
 // запись новых значений элементов массива без символа \n 
 cmdUpd.Parameters["language_req"].Value = strs;
 cmdUpd.Parameters["job_code"].Value = rdr["job_code"];
 cmdUpd.Parameters["job_grade"].Value = rdr["job_grade"];
 cmdUpd.Parameters["job_country"].Value = rdr["job_country"];
 // передача изменений в БД
 Assert.IsTrue(cmdUpd.ExecuteNonQuery() == 1);
 }
 else
 Console.WriteLine("No language specified");
 Console.WriteLine("");
 }
 }
 //откат сделанных изменений 
 trans.Rollback();
 }
} 

public void BLOBReadWriteTest()
{
 using(OleDbConnection con = ConnectionProvider.CreateConnection())
 {
 con.Open();
 OleDbTransaction trans = con.BeginTransaction();
 // Команда, читающая BLOB-поле
 OleDbCommand cmd = new OleDbCommand(
 "select proj_id, proj_name, proj_desc from project", con, trans);
 // Команда, записывающая BLOB-поле
 OleDbCommand cmdUpdate = new OleDbCommand(
 "update project set proj_desc= :proj_desc where proj_id= :proj_id", 
 con, trans);
 
 // Создание параметров типа BSTR
 cmdUpdate.Parameters.Add("proj_desc", OleDbType.BSTR);
 cmdUpdate.Parameters.Add("proj_id", OleDbType.BSTR);
 using (OleDbDataReader rdr = cmd.ExecuteReader())
 {
 while (rdr.Read())
 {
 // чтение BLOB 
 Console.WriteLine("PROJECT: " + rdr["proj_name"]);
 Console.WriteLine(rdr["proj_desc"]);
 
 // запись BLOB
 cmdUpdate.Parameters["proj_id"].Value = rdr["proj_id"];
 // каждый раз меняем регистр в BLOB-поле
 string newProjectDescription = rdr["proj_desc"].ToString();
 if (new_project_description.ToUpper() != newProjectDescription)
 newProjectDescription = newProjectDescription.ToUpper();
 else
 newProjectDescription = newProjectDescription.ToLower(); 
 cmdUpdate.Parameters["proj_desc"].Value = newProjectDescription;
 Assert.AreEqual(1, cmdUpdate.ExecuteNonQuery());
 }
 }
 trans.Commit(); 
 } //будет вызван метод IDispose.Dispose(). Соединение будет закрыто
}

public void AutoCommitSessionTest()
{
 OleDbConnectionStringBuilder builder = 
 ConnectionProvider.GetConnectionStringBuilder();
 builder.Add("auto_commit", true);
 builder.Add("auto_commit_level", 
 Convert.ToInt32(System.Data.IsolationLevel.RepeatableRead));
 using(OleDbConnection con = new OleDbConnection(builder.ToString()))
 {
 con.Open();
 OleDbCommand cmd =
 new OleDbCommand("select count(*) from employee", con);
 Assert.IsTrue((int)cmd.ExecuteScalar() > 0);
 }
}

public void InternalTransactionTest()
{
 OleDbConnectionStringBuilder builder = 
 ConnectionProvider.GetConnectionStringBuilderFromUDL();
 // включить вложенные транзакции
 builder.Add("nested_trans", true); 
 using(OleDbConnection con1 = new OleDbConnection(builder.ToString()))
 { 
 con1.Open();
 
 // основная транзакция
 OleDbTransaction trans = con1.BeginTransaction();
 // добавить новую запись
 OleDbCommand cmdInsert = new OleDbCommand(
 "insert into country (country, currency) values (:country, :currency)",
 con1, trans);
 cmdInsert.Parameters.AddWithValue(":country", "Russia");
 cmdInsert.Parameters.AddWithValue(":currency", "Ruble");
 Assert.AreEqual(1, cmdInsert.ExecuteNonQuery());
 // запустить вложенную транзакцию
 OleDbTransaction internalTransaction = trans.Begin();
 // запустить вложенную транзакцию внутри вложенной
 OleDbTransaction internalTransaction2 = internalTransaction.Begin();
 // удалить запись во вложенной транзакции третьего уровня
 OleDbCommand cmdDelete = new OleDbCommand(
 "delete from country where country = ?", con1, internalTransaction2);
 cmdDelete.Parameters.AddWithValue("?", "Russia");
 Assert.AreEqual(1, cmdDelete.ExecuteNonQuery());
 
 // откатить вложенную транзакцию третьего уровня
 internalTransaction2.Rollback();
 // проверить, что запись не была удалена в транзакции второго уровня
 OleDbCommand cmdCheck = new OleDbCommand(
 "select count(*) from country where country = ?", 
 con1, internalTransaction);
 cmdCheck.Parameters.AddWithValue("?", "Russia");
 Assert.AreEqual (1, cmdCheck.ExecuteScalar());
 
 // удалить запись
 cmdDelete.Transaction = internal_transaction;
 Assert.AreEqual(1, cmdDelete.ExecuteNonQuery());
 // зафиксировать изменения
 internalTransaction.Commit();
 // проверить в основной транзакции, что запись удалена из БД
 cmd_check.Transaction = trans;
 Assert.AreEqual(0, cmdCheck.ExecuteScalar());
 
 trans.Commit();
 }
}

public void TransactionScopeTest()
{
 // TransactionScrope автоматически свяжет локальные транзакции с 
 // распределенной. В данном контексте будет две локальных транзакции 
 // на каждое подключение и одна распределенная.
 using (TransactionScope scope = new TransactionScope())
 {
 // автоматически будет создана локальная транзакция
 using(OleDbConnection con1 = ConnectionProvider.CreateConnection())
 {
 con1.Open();
 // команда вставки
 OleDbCommand cmdInsert = new OleDbCommand(
 "insert into country (country, currency) values (:country, :currency)",
  con1);
 cmdInsert.Parameters.AddWithValue("country", "Russia");
 cmdInsert.Parameters.AddWithValue("currency", "Rouble");
 Assert.AreEqual(1, cmdInsert.ExecuteNonQuery());
 
 // автоматически будет создана ещё одна локальная транзакция 
 OleDbConnection con2 = ConnectionProvider.CreateConnection();
 con2.Open();
 cmdInsert.Connection = con2;
 cmdInsert.Parameters["country"].Value = "Latvia";
 cmdInsert.Parameters["currency"].Value = "Lat";
 Assert.AreEqual(1, cmdInsert.ExecuteNonQuery());
 } 
 
 // Фиксация распределенной транзакции.
 // Для всех локальных транзакций будет вызван метод Commit().
 scope.Complete(); 
 // Если ранее распределенная транзакция не была завершена, для всех локальных
 // транзакций будет вызван метод Rollback при вызове IDispose.Dispose()
 } 
 
 // TransactionScope будет использовать локальную транзакцию, 
 // т.к. все команды выполняются в одном контексте
 using (TransactionScope scope = new TransactionScope())
 {
 using(OleDbConnection con1 = ConnectionProvider.CreateConnection())
 {
 con1.Open();
 // Проверяем, что в предыдущем контексте были добавлены записи
 OleDbCommand cmdSelect = new OleDbCommand(
 "select count(*) from country where country= :country", con1);
 cmdSelect.Parameters.Add("country", OleDbType.BSTR);
 // Удаляем записи 
 OleDbCommand cmdDelete = new OleDbCommand(
 "delete from country where country= :country", con1);
 cmdDelete.Parameters.Add("country", OleDbType.BSTR);
 cmdSelect.Parameters["country"].Value = "Russia";
 cmdDelete.Parameters["country"].Value = "Russia";
 Assert.AreEqual(1, cmdSelect.ExecuteScalar());
 Assert.AreEqual(1, cmdDelete.ExecuteNonQuery());
 cmdSelect.Parameters["country"].Value = "Latvia";
 cmdDelete.Parameters["country"].Value = "Latvia";
 Assert.AreEqual(1, cmdSelect.ExecuteScalar());
 Assert.AreEqual(1, cmdDelete.ExecuteNonQuery());
 }
 
 scope.Complete(); // фиксирование транзакции
 } // откат транзакции, в случае возникновения ошибки
}

public void SQLTransactionTest()
{
 using(OleDbConnection con1 = ConnectionProvider.CreateConnection())
 {
 con1.Open();
 OleDbCommand cmd = new OleDbCommand(
 "SET TRANSACTION READ ONLY WAIT ISOLATION LEVEL READ COMMITTED", con1);
 cmd.ExecuteNonQuery();
 cmd.CommandText = "select count(*) from employee";
 Assert.AreNotEqual(0, cmd.ExecuteScalar()); 
 // подтверждение транзакции с последующим использованием её контекста
 cmd.CommandText = "COMMIT RETAIN";
 cmd.ExecuteNonQuery();
 cmd.CommandText = "select count(*) from employee";
 Assert.AreNotEqual(0, cmd.ExecuteScalar());
 cmd.CommandText = "COMMIT";
 cmd.ExecuteNonQuery();
 } 
}

SAVEPOINT save_point_name

ROLLBACK TO SAVEPOINT save_point_name 

COMMIT TO SAVEPOINT save_point_name

public void SavePointTest()
{
 using(OleDbConnection con1 = ConnectionProvider.CreateConnection())
 {
 con1.Open();
 OleDbTransaction transaction = con1.BeginTransaction();
 OleDbCommand cmd_insert = new OleDbCommand(
 "insert into country (country, currency) values (:country, :currency)", 
 con1, transaction);
 cmdInsert.Parameters.AddWithValue(":country", "Russia");
 cmdInsert.Parameters.AddWithValue(":currency", "Ruble");
 Assert.AreEqual(1, cmdInsert.ExecuteNonQuery());
 new OleDbCommand("SAVEPOINT AFTER_INSERT_POINT", 
 con1, transaction).ExecuteNonQuery();
 // удаляем запись, добавленную до точки сохранения
 OleDbCommand cmdDelete = new OleDbCommand(
 "delete from country where country = ?", con1, transaction);
 cmdDelete.Parameters.AddWithValue("?", "Russia");
 Assert.AreEqual(1, cmdDelete.ExecuteNonQuery());
 // отменяем операцию удаления, откатывая транзакцию до точки 
 // сохранения AFTER_INSERT_POINT
 new OleDbCommand("ROLLBACK TO SAVEPOINT AFTER_INSERT_POINT", 
 con1, transaction).ExecuteNonQuery();
 // проверяем, что запись не была удаления из БД
 OleDbCommand cmdCheck = new OleDbCommand(
 "select count(*) from country where country = ?", con1, transaction);
 cmdCheck.Parameters.AddWithValue("?", "Russia");
 Assert.AreEqual(1, cmdCheck.ExecuteScalar());
 // откат всех сделанных изменений
 transaction.Rollback();
 }
}

try
 {
 OleDbConnection con = 
 new OleDbConnection("Provider=LCPI.IBProvider;Data Source=Empty;");
 con.Open(); 
 con.Close();
 }
 catch (OleDbException oleEx)
 {
 foreach (OleDbError err in oleEx.Errors)
 {
 Console.WriteLine("Message: " + err.Message);
 Console.WriteLine("Native Error: " + err.NativeError);
 Console.WriteLine("Source: " + err.Source);
 Console.WriteLine("SQL State : " + err.SQLState); 
 } 
 }
 catch (Exception ex)
 {
 Console.WriteLine(ex.Message); 
 }

Message: Не определено обязательное свойство инициализации "Password".
Native Error: 0
Source: LCPI.IBProvider.2
SQL State : 
Message: Не определено обязательное свойство инициализации "User ID".
Native Error: 0
Source: LCPI.IBProvider.2
SQL State :

public void ReadPropertiesTest()
{
 using(OleDbConnection con = ConnectionProvider.CreateConnection())
 { 
 con.Open();
 // Свойства OleDbConnection
 OleDbProperties properties = OleDbProperties.GetPropertiesFor(con);
 Assert.AreNotEqual(0, properties.Count);
 PrintProperties(properties);
 // Свойства OleDbCommand
 OleDbCommand cmd = 
 new OleDbCommand("select * from country", con, con.BeginTransaction());
 
 properties = OleDbProperties.GetPropertiesFor(cmd);
 Assert.AreNotEqual(0, properties.Count);
 PrintProperties(properties);
 // Свойство из группы Rowset можно изменить
 properties["Use Bookmarks"].Value = true;
 Assert.IsTrue(Convert.ToBoolean(properties["Use Bookmarks"].Value)); 
 // Свойства OleDbDataReader 
 using (OleDbDataReader rdr = cmd.ExecuteReader())
 {
 properties = OleDbProperties.GetPropertiesFor(rdr);
 PrintProperties(properties);
 }
 }
}
private void PrintProperties(OleDbProperties properties)
{
 foreach (OleDbProperty prop in properties.Values)
 Console.WriteLine((prop.Required ? "[r] " : "") 
 + prop.Name + "=" + prop.ValueString);
}

public void OleDbServicesTest()
{
 const int connectionCount = 50;
 // Хранит результат работы по всем операциям
 Dictionary<string, double> timeResults = new Dictionary<string, double>();
 OleDbConnectionStringBuilder builder = 
 ConnectionProvider.GetConnectionStringBuilderFromUDL();
 // Все сервисы включены
 builder.OleDbServices = OleDbServicesValues.EnableAll;
 timeResults.Add(
 String.Format("OLE DB Services=EnableAll ({0})", builder.OleDbServices),
 DoConnections(builder, connectionCount));
 // Все сервисы отключены 
 builder.OleDbServices = OleDbServicesValues.DisableAll; 
 timeResults.Add(
 String.Format("OLE DB Services=DisableAll ({0})", builder.OleDbServices),
 DoConnections(builder,connectionCount));
 // Все включено, за исключением клиентских курсоров
 // и работы за пределами сессии 
 builder.OleDbServices = (OleDbServicesValues.EnableAll 
 & ~OleDbServicesValues.ClientCursor 
 & ~OleDbServicesValues.AggregationAfterSession);
 timeResults.Add(
 String.Format("OLE DB Services=\n" 
 + "\tEnableAll \n" 
 + "\t& ~ClientCursor \n" 
 + "\t& ~AggregationAfterSession ({0})", builder.OleDbServices),
 DoConnections(builder, connectionCount));
 foreach (string key in timeResults.Keys)
 Console.WriteLine(key + ". Seconds elapsed: " + timeResults[key]);
}
/// <summary>
/// Открывает и закрывает много подключений, а также начинает транзакции
/// </summary>
/// <param name="builder"></param>
/// <param name="cntConnectioncntConnection"></param>
/// <returns>Сколько секунд выполнялось</returns> 
private double DoConnections(OleDbConnectionStringBuilder builder, 
 int connectionCount)
{
 System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
 sw.Start(); 
 
 for (int i = 1; i <= connectionCount; i++)
 {
 using(OleDbConnection con = new OleDbConnection(builder.ToString()))
 {
 con.Open();
 OleDbTransaction trans = con.BeginTransaction();
 trans.Commit(); 
 }
 }
 sw.Stop();
 return sw.Elapsed.TotalSeconds;
} 

public void FillDataSetFromDataAdapter()
{
 DataSet dataSet = new DataSet();
 using (System.Transactions.TransactionScope scope =
 new System.Transactions.TransactionScope())
 {
 OleDbConnection con = ConnectionProvider.CreateConnection();
 con.Open();
 OleDbDataAdapter adapter = 
 new OleDbDataAdapter("select * from EMPLOYEE", con);
 adapter.Fill(dataSet);
 Assert.IsTrue(dataSet.Tables[0].Rows.Count > 0); 
 scope.Complete(); 
 }
}

public void FillDataSetFromDBReaderTest()
{
 using(OleDbConnection con = ConnectionProvider.CreateConnection())
 {
 con.Open();
 OleDbCommand cmd =
 new OleDbCommand("select * from EMPLOYEE", con, con.BeginTransaction()); 
 DataSet dataSet = new DataSet();
 DataTable tbl = dataSet.Tables.Add("EMPLOYEE");
 using (OleDbDataReader reader = cmd.ExecuteReader())
 {
 dataSet.Load(reader, LoadOption.OverwriteChanges, tbl); 
 }
 }
}

public void GetDBReaderFromDataTable()
{
 DataSet dataSet = new DataSet();
 DataTable tbl = dataSet.Tables.Add("EMPLOYEE");
 // загрузка данных в DataSet  
 using(OleDbConnection con = ConnectionProvider.CreateConnection())
 {
 con.Open();
 OleDbTransaction trans = con.BeginTransaction();
 dataSet.Load(new OleDbCommand(
 "select * from EMPLOYEE", con, trans).ExecuteReader(), 
 LoadOption.OverwriteChanges, tbl); 
 
 // Печать данных из DataTable
 this.PrintDBDataReader(new DataTableReader(tbl));
 // Чтение данных полученных с помощью OleDbDataReader
 this.PrintDBDataReader(
 new OleDbCommand("select * from EMPLOYEE", con, trans).ExecuteReader());
 trans.Commit();
 }
}
// / <summary>
// / Выводит в консоль данные из DBDataReader
// / </summary>
// / <param name="reader"></param>
public void PrintDBDataReader(System.Data.Common.DbDataReader reader)
{
 while (reader.Read())
 {
 Console.WriteLine("*********************************");
 for (int i = 0; i < reader.FieldCount; i++)
 Console.WriteLine(reader.GetName(i) + "=" + reader[i]);
 }
 reader.Close(); 
}