public When_reading_from_a_stream_containing_multiple_data_tables_with_big_buffer()
{
var testData = new DataSet
{
Tables =
{
TestData.GenerateRandomDataTable(10, 50),
TestData.GenerateRandomDataTable(5, 100),
TestData.GenerateRandomDataTable(20, 10000)
}
};
using (var r = testData.CreateDataReader())
using (var memoryStream = new MemoryStream())
{
DataSerializer.Serialize(memoryStream, r);
this.expectedBytes = memoryStream.GetTrimmedBuffer();
}
this.reader = testData.CreateDataReader();
using (var stream = new ProtoDataStream(this.reader, 50 * 1024 * 1024)) // 50 Mb buffer which
using (var memoryStream = new MemoryStream())
{
stream.CopyTo(memoryStream);
this.actualBytes = memoryStream.GetTrimmedBuffer();
}
}
public void SetUp()
{
var testData = new DataSet
{
Tables =
{
TestData.GenerateRandomDataTable(10, 50),
TestData.GenerateRandomDataTable(5, 100),
TestData.GenerateRandomDataTable(20, 10000)
}
};
using (var r = testData.CreateDataReader())
using (var memoryStream = new MemoryStream())
{
DataSerializer.Serialize(memoryStream, r);
expectedBytes = memoryStream.GetTrimmedBuffer();
}
reader = testData.CreateDataReader();
using (var stream = new ProtoDataStream(reader))
using (var memoryStream = new MemoryStream())
{
stream.CopyTo(memoryStream);
actualBytes = memoryStream.GetTrimmedBuffer();
}
}
public void populateComboBox(string itemUnidade = null, string itemGrupo = null)
{
DataSet ds = null;
DataTableReader dr = null;
string sql = "";
sql = "EXEC PRC_GET_UNIDADES";
ds = cnn.DataSet_Pesquisa(sql);
dr = ds.CreateDataReader();
cmbUnidade.Items.Clear();
while (dr.Read())
{
cmbUnidade.Items.Add(dr["UNI_NOME"].ToString());
}
if (itemUnidade != null)
{
cmbUnidade.SelectedIndex = cmbUnidade.Items.IndexOf(itemUnidade);
}
else
{
cmbUnidade.SelectedIndex = 0;
}
sql = "EXEC PRC_GET_GRUPOS";
ds = cnn.DataSet_Pesquisa(sql);
dr = ds.CreateDataReader();
cmbGrupo.Items.Clear();
while (dr.Read())
{
cmbGrupo.Items.Add(dr["GRU_NOME"].ToString());
}
if (itemGrupo != null)
{
cmbGrupo.SelectedIndex = cmbGrupo.Items.IndexOf(itemGrupo);
}
else
{
cmbGrupo.SelectedIndex = 0;
}
radAtivo.Checked = true;
}
public void populateData(string codigo = null)
{
DataSet ds = null;
DataTableReader dr = null;
string sql = "";
if (codigo != null)
{
gruCodigo = codigo;
sql = "EXEC PRC_GRUPOS_SEARCH NULL, '" + gruCodigo + "'";
ds = cnn.DataSet_Pesquisa(sql);
dr = ds.CreateDataReader();
if (dr.Read())
{
txtNome.Text = dr["GRU_NOME"].ToString();
radAtivo.Checked = false;
radInativo.Checked = false;
if (Convert.ToBoolean(dr["GRU_STATUS"]) == true)
{
radAtivo.Checked = true;
}
else
{
radInativo.Checked = true;
}
populatePermissoes();
}
}
else
{
radAtivo.Checked = true;
sql = "EXEC PRC_GRUPO_SAVE NULL, '', '-1'";
ds = cnn.DataSet_Pesquisa(sql);
dr = ds.CreateDataReader();
dr.Read();
gruCodigo = dr["GRU_CODIGO"].ToString();
}
}
/// <inheritdoc/>
public TableDataModel GetTable(TableViewModel table)
{
using (var connection = new SqlConnection(config.ConnectionString))
{
connection.Open();
var adapter = new SqlDataAdapter(new SqlCommand(SqlExpression.GetTableInfoExpression, connection));
adapter.SelectCommand.Parameters.Add(new SqlParameter("@p1", table.Name));
adapter.SelectCommand.Parameters.Add(new SqlParameter("@p2", table.Schema));
var set = new DataSet();
adapter.Fill(set);
var columns = new Dictionary <string, ColumnTypes>();
using (var reader = set.CreateDataReader())
{
while (reader.Read())
{
columns.Add(reader.GetString(0), EnumConverter.ConvertToColumnType(reader.GetString(1)));
}
reader.Close();
}
connection.Close();
return(new TableDataModel()
{
TableId = table.Id,
Name = $"{table.Schema}.{table.Name}",
Columns = columns.OrderBy(x => x.Key).ToDictionary(x => x.Key, x => x.Value)
});
}
}
/// <summary>
/// This is the page to add staff member details
/// <code></code>
/// </summary>
public StaffContactAdd()
{
InitializeComponent();
// Get Staff table from database
DataSet dataSource = SqlQueryExecutor.SelectAllFromTable("Staff");
DataTableReader reader = dataSource.CreateDataReader();
}
public static DataTableReader Procedure(string name, params SqlParameter[] parameter)
{
try
{
DataSet ds = new DataSet();
using (SqlConnection con = new SqlConnection(_DBConnection))
{
using (SqlCommand cmd = new SqlCommand(name, con)
{
CommandType = CommandType.StoredProcedure
})
{
cmd.Parameters.AddRange(parameter);
cmd.Prepare();
con.Open();
SqlDataAdapter Adapter = new SqlDataAdapter(cmd);
Adapter.Fill(ds);
con.Close();
if (ds.Tables.Count == 0)
{
return(null);
}
return(ds.CreateDataReader());
}
}
}
catch (Exception exception)
{
throw new Exception(name, exception);
}
}
public static DataTableReader Query(string query)
{
try
{
DataSet ds = new DataSet();
using (SqlConnection con = new SqlConnection(_DBConnection))
{
using (SqlCommand cmd = new SqlCommand(query, con))
{
cmd.Prepare();
con.Open();
SqlDataAdapter Adapter = new SqlDataAdapter(cmd);
Adapter.Fill(ds);
con.Close();
if (ds.Tables.Count > 0)
{
return(ds.CreateDataReader());
}
else
{
//table is empty
return(null);
}
}
}
}
catch (Exception Exception)
{
throw new Exception(query, Exception);
}
}
public bool isExists(MatchedFirm t)
{
try
{
string query = String.Format("SELECT Id FROM dbo.MatchedFirm WHERE MusteriKodu = '{0}' AND Unvan = '{1}' AND Tel = '{2}'",
t.MusteriKodu,
t.Unvan,
t.Tel);
DataSet dataSet = manager.GetDataSet(query);
DataTable dataTable = new DataTable();
DataTableReader reader = dataSet.CreateDataReader();
dataTable.Load(reader);
if (dataTable.Rows.Count > 0)
{
return(true);
}
else
{
return(false);
}
}
catch (Exception e)
{
PrintConsole.LOG(e.StackTrace, e.Message);
return(false);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ProtoDataStream"/> class.
/// </summary>
/// <param name="dataSet">The <see cref="DataSet"/>who's contents to serialize.</param>
/// <param name="options"><see cref="ProtoDataWriterOptions"/> specifying any custom serialization options.</param>
/// <param name="bufferSize">Buffer size to use when serializing rows.
/// You should not need to change this unless you have exceptionally
/// large rows or an exceptionally high number of columns.</param>
public ProtoDataStream(
DataSet dataSet,
ProtoDataWriterOptions options,
int bufferSize = DefaultBufferSize)
: this(dataSet.CreateDataReader(), options, bufferSize)
{
}
private List <Bug> ReadExcelData(OleDbConnection conn, string sheetName)
{
var excelDbCommand = new OleDbCommand(@"SELECT * FROM [" + sheetName + "]", conn);
using (var oleDbDataAdapter = new OleDbDataAdapter(excelDbCommand))
{
DataSet ds = new DataSet();
oleDbDataAdapter.Fill(ds);
var bugs = new List <Bug>();
using (var reader = ds.CreateDataReader())
{
while (reader.Read())
{
var bug = new Bug();
bug.Description = reader["Description"].ToString();
bug.PriorityId = int.Parse(reader["Priority"].ToString());
bug.SpecialityId = int.Parse(reader["Speciality"].ToString());
var tempDate = new DateTime();
if (DateTime.TryParse(reader["solvedOn"].ToString(), out tempDate))
{
bug.solvedOn = tempDate;
}
else
{
bug.solvedOn = null;
}
bugs.Add(bug);
}
}
return(bugs);
}
}
public void ShouldSerializeSuccessiveResultColumns()
{
// Arrange
var dataSet = new DataSet();
dataSet.Tables.Add(new DataTable());
dataSet.Tables.Add(new DataTable());
dataSet.Tables[0].Columns.Add("foo", typeof(int));
dataSet.Tables[0].Rows.Add(1);
var columnName = "bar";
dataSet.Tables[1].Columns.Add(columnName, typeof(int));
dataSet.Tables[1].Rows.Add(1);
var dataReader = dataSet.CreateDataReader();
var stream = new ProtoDataStream(dataReader);
// Act
var reader = ProtoReader.Create(this.CopyStream(stream), null, null);
// Assert
var readerContext = new ProtoReaderContext(reader);
readerContext.ReadUntilResultEnd();
readerContext.ReadUntilColumnName();
Assert.Equal(columnName, reader.ReadString());
}
private User GetUserById(int id)
{
User user = null;
var connection = new SqlConnection(System.Configuration.ConfigurationManager.AppSettings["ConnnectionString"].ToString());
connection.Open();
var command = connection.CreateCommand();
command.CommandType = System.Data.CommandType.Text;
command.CommandText = "SELECT * FROM dbo.[TruUsers] WHERE Id = " + id;
var dataAdapter = new SqlDataAdapter(command);
var dataSet = new DataSet();
dataAdapter.Fill(dataSet);
var dataReader = dataSet.CreateDataReader();
while (dataReader.Read())
{
user = new User();
user.Id = (int)dataReader["Id"];
user.FirstName = (string)dataReader["FirstName"];
user.LastName = (string)dataReader["LastName"];
user.UserName = (string)dataReader["UserName"];
user.EmailAddress = (string)dataReader["EmailAddress"];
user.Active = (bool)dataReader["Active"];
}
return(user);
}
//Assuming at least one CreditCard PaymentMethod has been created using the Orders UI
public Guid GetPaymentMethodID()
{
Guid creditCardPaymentMethodId = Guid.Empty;
Boolean ccPmtMethodFound = false;
//Get all PaymentMethods
DataSet pmtMethods = orderCtx.GetPaymentMethods();
DataTableReader reader = pmtMethods.CreateDataReader();
IEnumerator readerEnum = reader.GetEnumerator();
while (readerEnum.MoveNext() && !ccPmtMethodFound)
{
DbDataRecord rec = (DbDataRecord)readerEnum.Current;
switch (rec.GetInt32(rec.GetOrdinal("PaymentType")))
{
case (int)PaymentMethodTypes.CreditCard:
creditCardPaymentMethodId = rec.GetGuid(rec.GetOrdinal("PaymentMethodId"));
ccPmtMethodFound = true;
break;
}
}
if (Guid.Empty == creditCardPaymentMethodId)
{
throw new ApplicationException("This demo requires at least one CreditCard type of PaymentMethod to be defined!");
}
return(creditCardPaymentMethodId);
}
//Assuming at least one ShippingMethod has been created using the Orders UI
public Guid GetShippingMethodID()
{
Guid shippingMethodId = Guid.Empty;
Boolean shipMethodFound = false;
//Get all PaymentMethods in default language - Hopefully there is one of each type
DataSet shipMethods = orderCtx.GetShippingMethods();
DataTableReader reader = shipMethods.CreateDataReader();
IEnumerator readerEnum = reader.GetEnumerator();
while (readerEnum.MoveNext() && !shipMethodFound)
{
DbDataRecord rec = (DbDataRecord)readerEnum.Current;
shippingMethodId = rec.GetGuid(rec.GetOrdinal("ShippingMethodId"));
shipMethodFound = true;
}
if (Guid.Empty == shippingMethodId)
{
throw new ApplicationException("This demo requires at least one ShippingMethod to be defined!");
}
return(shippingMethodId);
}
/// <summary>
/// Reads a single Excel sheet and performs action of your choice.
/// </summary>
/// <param name="fileName">The file you want to read.</param>
/// <param name="sheetName">The sheet you want to read.</param>
/// <param name="actionForEachRow">Action to perform on the returned DataTableReader.</param>
public void ReadExcelSheet(string fileName, string sheetName, Action <DataTableReader> actionForEachRow)
{
var connectionString = string.Format(ExcelSettings.Default.ExcelConnectionStringFormat, fileName);
using (var excelConnection = new OleDbConnection(connectionString))
{
excelConnection.Open();
if (sheetName == null)
{
var excelSchema = excelConnection.GetOleDbSchemaTable(OleDbSchemaGuid.Tables, null);
sheetName = excelSchema.Rows[0]["TABLE_NAME"].ToString();
}
var excelDbCommand = new OleDbCommand(@"SELECT * FROM [" + sheetName + "]", excelConnection);
using (var oleDbDataAdapter = new OleDbDataAdapter(excelDbCommand))
{
DataSet dataSet = new DataSet();
oleDbDataAdapter.Fill(dataSet);
using (var reader = dataSet.CreateDataReader())
{
while (reader.Read())
{
actionForEachRow(reader);
}
}
}
}
}
public void populateData(string codigo = null)
{
DataSet ds = null;
DataTableReader dr = null;
string sql = "";
if (codigo != null)
{
resCodigo = codigo;
sql = "EXEC PRC_RESIDUOS_SEARCH NULL, '" + resCodigo + "'";
ds = cnn.DataSet_Pesquisa(sql);
dr = ds.CreateDataReader();
if (dr.Read())
{
txtNome.Text = dr["RES_NOME"].ToString();
populateComboBox(dr["TIPO"].ToString());
radAtivo.Checked = false;
radInativo.Checked = false;
if (Convert.ToBoolean(dr["RES_STATUS"]) == true)
{
radAtivo.Checked = true;
}
else
{
radInativo.Checked = true;
}
}
}
}
static void Main(string[] args)
{
SqlConnection connexion = new SqlConnection("Data Source =.\\sqlexpress; Initial Catalog = demonstration; Integrated Security = True");
SqlDataAdapter DemoDataAdapter = new SqlDataAdapter("select * from annuaire", connexion);
DataSet DemoDataSet = new DataSet();
DemoDataAdapter.Fill(DemoDataSet, "Annuaire");
DataTable AnnuaireTable = DemoDataSet.Tables["Annuaire"];
DataTableReader AnnuaireReader = DemoDataSet.CreateDataReader(AnnuaireTable);
while (AnnuaireReader.Read())
{
Console.WriteLine(String.Format("{0} {1}", AnnuaireReader["nom"], AnnuaireReader["age"]));
}
SqlCommandBuilder DemoSqlCommandBuilder = new SqlCommandBuilder(DemoDataAdapter);
DemoDataAdapter.MissingSchemaAction = MissingSchemaAction.AddWithKey;
DataRow AnnuaireDataRow = AnnuaireTable.NewRow();
AnnuaireDataRow["nom"] = "jean";
AnnuaireDataRow["age"] = "99";
AnnuaireTable.Rows.Add(AnnuaireDataRow);
DemoDataAdapter.Update(DemoDataSet, "Annuaire");
}
static void Main()
{
var excelConnection = new OleDbConnection(Settings.Default.excelConnection);
excelConnection.Open();
DataTable excelSchema = excelConnection.GetOleDbSchemaTable(OleDbSchemaGuid.Tables, null);
string sheetName = excelSchema.Rows[0]["TABLE_NAME"].ToString();
OleDbCommand excelCommand = new OleDbCommand(@"SELECT *
FROM [" + sheetName + "]", excelConnection);
using (excelConnection)
{
using (OleDbDataAdapter oleDbDataAdapter = new OleDbDataAdapter(excelCommand))
{
DataSet dataSet = new DataSet();
oleDbDataAdapter.Fill(dataSet);
using (DataTableReader reader = dataSet.CreateDataReader())
{
while (reader.Read())
{
var fullName = reader["Name"];
var score = reader["Score"];
Console.WriteLine(fullName + " -> " + score);
}
}
}
}
}
static void Main()
{
string excelConnectionString = "Provider=Microsoft.ACE.OLEDB.12.0;Data Source=../../score_db.xlsx;Extended Properties='Excel 12.0 xml;HDR=Yes';";
var excelConnection = new OleDbConnection(excelConnectionString);
excelConnection.Open();
DataTable excelSchema = excelConnection.GetOleDbSchemaTable(OleDbSchemaGuid.Tables, null);
string sheetName = excelSchema.Rows[0]["TABLE_NAME"].ToString();
OleDbCommand excelCommand = new OleDbCommand("SELECT * FROM [" + sheetName + "]", excelConnection);
using (excelConnection)
{
using (OleDbDataAdapter adapter = new OleDbDataAdapter(excelCommand))
{
DataSet dataSet = new DataSet();
adapter.Fill(dataSet);
using (DataTableReader reader = dataSet.CreateDataReader())
{
while (reader.Read())
{
var userName = reader["Name"];
var score = reader["Score"];
Console.WriteLine(userName + " -> " + score);
}
}
}
}
}
/// <summary>
/// [MusteriKod] [Email]
/// </summary>
/// <returns></returns>
public List <Email> getAllInfos()
{
try
{
string query = "SELECT * FROM dbo.VFirmaEmailler";
manager.Close();
manager.Open();
DataSet dataSet = manager.GetDataSet(query);
DataTable dataTable = new DataTable();
DataTableReader reader = dataSet.CreateDataReader();
dataTable.Load(reader);
manager.Close();
var emailList = new List <Email>(dataTable.Rows.Count);
foreach (DataRow row in dataTable.Rows)
{
var values = row.ItemArray;
var email = new Email()
{
MusteriKod = Convert.ToDecimal(values[0]),
MailAdresi = Convert.ToString(values[1])
};
emailList.Add(email);
}
return(emailList);
}
catch (Exception e)
{
PrintConsole.LOG(e.StackTrace, e.Message);
return(null);
}
}
public List <T> ReaderToList <T>(DataSet ds)
{
DbDataReader dbDataReader = ds.CreateDataReader();
List <T> result;
using (dbDataReader)
{
List <string> list = new List <string>(dbDataReader.FieldCount);
for (int i = 0; i < dbDataReader.FieldCount; i++)
{
list.Add(dbDataReader.GetName(i).ToLower());
}
List <T> list2 = new List <T>();
while (dbDataReader.Read())
{
T t = Activator.CreateInstance <T>();
PropertyInfo[] properties = t.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.GetProperty);
for (int j = 0; j < properties.Length; j++)
{
PropertyInfo propertyInfo = properties[j];
if (list.Contains(propertyInfo.Name.ToLower()))
{
if (!IsNullOrDbNull(dbDataReader[propertyInfo.Name]))
{
propertyInfo.SetValue(t, HackType(dbDataReader[propertyInfo.Name], propertyInfo.PropertyType), null);
}
}
}
list2.Add(t);
}
result = list2;
}
return(result);
}
private static void TestCreateDataReader(DataSet dataSet)
{
// Given a DataSet, retrieve a DataTableReader
// allowing access to all the DataSet's data.
// Even though the dataset contains three DataTables,
// this code will only display the contents of two of them,
// because the code has limited the results to the
// DataTables stored in the tables array. Because this
// parameter is declared using the ParamArray keyword,
// you could also include a list of DataTable instances
// individually, as opposed to supplying an array of
// DataTables, as in this example:
using (DataTableReader reader =
dataSet.CreateDataReader(productTable, emptyTable))
{
do
{
if (!reader.HasRows)
{
Console.WriteLine("Empty DataTableReader");
}
else
{
PrintColumns(reader);
}
Console.WriteLine("========================");
} while (reader.NextResult());
}
}
private static void ReadExcelData()
{
using (var excelConnection = new OleDbConnection())
{
var path = "../NamesAndScores.xlsx";
// Prolly there would be some provider issues
excelConnection.ConnectionString = "Provider=Microsoft.ACE.OLEDB.12.0;Data Source=" + path + ";" + "Extended Properties='Excel 12.0 Xml;HDR=YES;IMEX=1;MAXSCANROWS=0'";
excelConnection.Open();
var sheetName = GetSheetName(excelConnection);
var excelCommand = GetOleDbCommand(sheetName, excelConnection);
using (var oleDbDataAdapter = new OleDbDataAdapter(excelCommand))
{
var dataSet = new DataSet();
oleDbDataAdapter.Fill(dataSet);
using (var reader = dataSet.CreateDataReader())
{
while (reader.Read())
{
var fullName = reader["Name"];
var score = reader["Score"];
Console.WriteLine(fullName + " -> " + score);
}
}
}
}
}
protected override IEnumerable <IDataObject> GetDataInternal()
{
var str = ConnectionString ?? MapConfig.Current.Variables["ConnectionString"].ToString();
using (var connection = new SqlConnection(str))
{
SqlDataAdapter adapter = new SqlDataAdapter();
adapter.SelectCommand = new SqlCommand(ActualQuery, connection);
DataSet dataset = new DataSet();
adapter.Fill(dataset);
using (DataTableReader reader = dataset.CreateDataReader())
{
while (reader.Read())
{
DataObject result = new DataObject();
for (int fieldIndex = 0; fieldIndex < reader.FieldCount; fieldIndex++)
{
result.SetValue(reader.GetName(fieldIndex), reader.GetValue(fieldIndex));
}
yield return(result);
}
}
}
}
private void ReadSheet(ExcelSalesReport report, string Name, OleDbConnection connection)
{
OleDbCommand excelCommand = new OleDbCommand("SELECT * FROM [" + Name + " Sales$]", connection);
using (var oleDbDataAdapter = new OleDbDataAdapter(excelCommand))
{
var dataSet = new DataSet();
oleDbDataAdapter.Fill(dataSet);
using (var reader = dataSet.CreateDataReader())
{
reader.Read();
if (string.IsNullOrEmpty(reader[0].ToString()))
{
LeftOffset = 1;
}
else
{
LeftOffset = 0;
}
report.DistributorName = reader[LeftOffset + 0].ToString();
reader.Read(); // this skips column names
this.GetReportEntries(reader, Name, report.Records);
}
}
}
private List <Movy> ReadExcelData(OleDbConnection conn, string sheetName)
{
Console.WriteLine("Reading data from excel...");
var excelDbCommand = new OleDbCommand(@"SELECT * FROM [" + sheetName + "]", conn);
using (var oleDbDataAdapter = new OleDbDataAdapter(excelDbCommand))
{
DataSet ds = new DataSet();
oleDbDataAdapter.Fill(ds);
var movies = new List <Movy>();
using (var reader = ds.CreateDataReader())
{
while (reader.Read())
{
var movie = new Movy();
movie.Name = reader["Name"].ToString();
var readerRating = reader["Rating"].ToString();
double rat = double.Parse(readerRating);
movie.Rating = rat;
var d = reader["Year"];
movie.Year = (DateTime)(d);
movie.Duration = reader["Duration"].ToString();
movie.Description = reader["Description"].ToString();
movies.Add(movie);
}
}
return(movies);
}
}
private static void ReadExcelData()
{
using (var excelConnection = new OleDbConnection(Settings.Default.excelConnection))
{
excelConnection.Open();
string sheetName = GetSheetName(excelConnection);
OleDbCommand excelCommand = GetOleDbCommand(sheetName, excelConnection);
using (OleDbDataAdapter oleDbDataAdapter = new OleDbDataAdapter(excelCommand))
{
DataSet dataSet = new DataSet();
oleDbDataAdapter.Fill(dataSet);
using (DataTableReader reader = dataSet.CreateDataReader())
{
while (reader.Read())
{
var fullName = reader["Name"];
var score = reader["Score"];
Console.WriteLine(fullName + " -> " + score);
}
}
}
}
}
private static void ReadExcelData()
{
var connectionString = GetConnectionString();
using (var oleDbConnection = new OleDbConnection(connectionString))
{
oleDbConnection.Open();
var sheetName = GetSheetName(oleDbConnection);
var cmd = GetOleDbCommand(sheetName, oleDbConnection);
using (var oleDbAdapter = new OleDbDataAdapter(cmd))
{
var dataSet = new DataSet();
oleDbAdapter.Fill(dataSet);
using (var reader = dataSet.CreateDataReader())
{
while (reader.Read())
{
var name = reader["Name"];
var score = reader["Score"];
Console.WriteLine("{0}: {1}", name, score);
}
}
}
}
}
public void ShouldSerializeMultipleResults()
{
// Arrange
var dataSet = new DataSet();
dataSet.Tables.Add(new DataTable());
dataSet.Tables.Add(new DataTable());
dataSet.Tables[0].Columns.Add("foo", typeof(int));
dataSet.Tables[0].Rows.Add(1);
dataSet.Tables[1].Columns.Add("bar", typeof(int));
dataSet.Tables[1].Rows.Add(1);
var dataReader = dataSet.CreateDataReader();
// Act
var reader = new ProtoReader(this.Serialize(dataReader), null, null);
// Assert
var readerContext = new ProtoReaderContext(reader);
readerContext.ReadUntilResultEnd();
Assert.Equal(ResultFieldHeader, reader.ReadFieldHeader());
}
public void CreateDataReaderNoTable()
{
DataSet dsr = new DataSet();
Assert.Throws<ArgumentException>(() =>
{
DataTableReader dtr = dsr.CreateDataReader();
});
}
public void LoadTest2()
{
DataSet ds1 = new DataSet();
DataSet ds2 = new DataSet();
DataTable dt1 = new DataTable("T1");
DataTable dt2 = new DataTable("T2");
DataTable dt3 = new DataTable("T1");
DataTable dt4 = new DataTable("T2");
dt1.Columns.Add("ID", typeof(int));
dt1.Columns.Add("Name", typeof(string));
dt2.Columns.Add("EmpNO", typeof(int));
dt2.Columns.Add("EmpName", typeof(string));
dt1.Rows.Add(new object[] { 1, "Andrews" });
dt1.Rows.Add(new object[] { 2, "Mathew" });
dt1.Rows.Add(new object[] { 3, "Jaccob" });
dt2.Rows.Add(new object[] { 1, "Arul" });
dt2.Rows.Add(new object[] { 2, "Jothi" });
dt2.Rows.Add(new object[] { 3, "Murugan" });
ds2.Tables.Add(dt1);
ds2.Tables.Add(dt2);
ds1.Tables.Add(dt3);
ds1.Tables.Add(dt4);
DataTableReader reader = ds2.CreateDataReader();
//ds1.Load (reader, LoadOption.PreserveChanges, dt3, dt4);
ds1.Load(reader, LoadOption.OverwriteChanges, dt3, dt4);
Assert.Equal(ds2.Tables.Count, ds1.Tables.Count);
int i = 0;
foreach (DataTable dt in ds1.Tables)
{
DataTable dt5 = ds2.Tables[i];
Assert.Equal(dt5.Rows.Count, dt.Rows.Count);
int j = 0;
DataRow row1;
foreach (DataRow row in dt.Rows)
{
row1 = dt5.Rows[j];
for (int k = 0; k < dt.Columns.Count; k++)
{
Assert.Equal(row1[k], row[k]);
}
j++;
}
i++;
}
}
