public void ReaderToObject(System.Data.IDataReader reader, object obj)
{
if (obj is IDictionary <string, object> dynamicObject)
{
for (int i = 0; i < reader.FieldCount; i++)
{
var dbvalue = reader[i];
if (dbvalue != DBNull.Value)
{
dynamicObject[reader.GetName(i)] = dbvalue;
}
else
{
dynamicObject[reader.GetName(i)] = null;
}
}
}
else
{
if (!mLoadColumnIndex)
{
SetColumnIndex(reader);
}
for (int i = 0; i < mProperties.Count; i++)
{
ReaderToProperty(reader, obj, mProperties[i]);
}
}
}
public override void Write(int?chunkId, int?subChunkId, System.Data.IDataReader reader, string tableName)
{
if (reader == null)
{
return;
}
if (tableName.ToLower().StartsWith("_chunks"))
{
tableName = SourceSchema + "." + tableName;
}
else
{
tableName = DestinationSchema + "." + tableName;
}
var fields = new string[reader.FieldCount];
for (var i = 0; i < reader.FieldCount; i++)
{
fields[i] = reader.GetName(i);
}
var q = $"COPY {tableName} ({string.Join(",", fields)}) from STDIN (FORMAT BINARY)";
using (var inStream = _connection.BeginBinaryImport(q))
{
while (reader.Read())
{
inStream.StartRow();
for (var i = 0; i < reader.FieldCount; i++)
{
var value = reader.GetValue(i);
if (value is null)
{
inStream.WriteNull();
}
else
{
var fd = GetFieldType(reader.GetFieldType(i), reader.GetName(i));
inStream.Write(value, fd);
}
}
}
inStream.Complete();
}
}
} // GetAssemblyQualifiedNoVersionName
private static async System.Threading.Tasks.Task WriteColumnDefinition(
System.Xml.XmlWriter writer
, System.Data.IDataReader dr
, XmlRenderType_t renderType)
{
await writer.WriteStartElementAsync(null, "columns", null);
for (int i = 0; i <= dr.FieldCount - 1; i++)
{
await writer.WriteStartElementAsync(null, "column", null);
await writer.WriteAttributeStringAsync(null, "name", null, dr.GetName(i));
await writer.WriteAttributeStringAsync(null, "index", null, i.ToString(System.Globalization.CultureInfo.InvariantCulture));
if (renderType.HasFlag(XmlRenderType_t.WithDetail))
{
await writer.WriteAttributeStringAsync(null, "fieldType", null, GetTypeName(dr.GetFieldType(i), renderType));
}
await writer.WriteEndElementAsync(); // column
}
await writer.WriteEndElementAsync(); // columns
} // WriteColumnDefinition
public void OnReadAll(IDataWriter <string> dataWriter)
{
for (int i = 0; i < dbDataReader.FieldCount; i++)
{
ValueInterface.WriteValue(dataWriter[dbDataReader.GetName(i)], dbDataReader[i]);
}
}
public SimpleUser(System.Data.IDataReader reader)
{
int columnCount = reader.FieldCount;
for (int i = 0; i < columnCount; i++)
{
this.dic[reader.GetName(i)] = reader[i];
}
}
} // End Function IsSimpleType
public virtual System.Collections.Generic.List <T> GetList <T>(System.Data.IDbCommand cmd)
{
System.Collections.Generic.List <T> lsReturnValue = new System.Collections.Generic.List <T>();
T tThisValue = default(T);
System.Type tThisType = typeof(T);
using (System.Data.IDataReader idr = ExecuteReader(cmd))
{
if (IsSimpleType(tThisType))
{
while (idr.Read())
{
object objVal = idr.GetValue(0);
// tThisValue = System.Convert.ChangeType(objVal, T),
tThisValue = (T)ConvertResult <T>(objVal, true);
lsReturnValue.Add(tThisValue);
} // End while (idr.Read())
}
else
{
int iFieldCount = idr.FieldCount;
Setter_t <T>[] mems = new Setter_t <T> [iFieldCount];
for (int i = 0; i < iFieldCount; ++i)
{
string strName = idr.GetName(i);
mems[i] = LinqHelper.GetSetter <T>(strName);
} // Next i
while (idr.Read())
{
tThisValue = System.Activator.CreateInstance <T>();
for (int i = 0; i < iFieldCount; ++i)
{
Setter_t <T> setter = mems[i];
if (setter != null)
{
object objVal = idr.GetValue(i);
setter(tThisValue, objVal);
}
} // Next i
lsReturnValue.Add(tThisValue);
} // Whend
} // End if IsSimpleType(tThisType)
idr.Close();
} // End Using idr
return(lsReturnValue);
} // End Function GetList
/// <summary>
/// Obtiene las columnas asociadas al <see cref="System.Data.IDataReader"/>
/// </summary>
private List <(string, FieldType)> GetColumnsSchema(System.Data.IDataReader reader)
{
List <(string, FieldType)> columns = new List <(string, FieldType)>();
// Obtiene el esquema del dataReader
for (int index = 0; index < reader.FieldCount; index++)
{
if (!string.IsNullOrWhiteSpace(reader.GetName(index)))
{
columns.Add((reader.GetName(index), GetColumnSchemaType(reader.GetFieldType(index))));
}
else
{
columns.Add(($"Column{index}", GetColumnSchemaType(reader.GetFieldType(index))));
}
}
// Devuelve la colección de columnas
return(columns);
}
private List <String> ObtenerColumnasDelDatareader(System.Data.IDataReader resultadoDataReader)
{
var resultado = new List <String>();
for (int i = 0; i < resultadoDataReader.FieldCount; i++)
{
resultado.Add(resultadoDataReader.GetName(i));
}
return(resultado);
}
public bool ColumnExists(System.Data.IDataReader reader, string columnName)
{
for (int i = 0; i < reader.FieldCount; i++)
{
if (reader.GetName(i) == columnName)
{
return(true);
}
}
return(false);
}
public static void EntityListByEmit(System.Data.IDataReader DataReader, DbExecuteReadOnebyOneAction <T> callback)
{
Dictionary <string, string> FieldDic = new Dictionary <string, string>();
int i = 0;
while (i < DataReader.FieldCount)
{
string Name = DataReader.GetName(i);
if (!FieldDic.ContainsKey(Name.ToLower()))
{
FieldDic.Add(Name.ToLower(), Name);
}
i++;
}
EntityPropertyEmitSetter[] ps = EntityPropertyEmitSetter.GetProperties(typeof(T));
long rowNum = 0;
while (DataReader.Read())
{
T obj = new T();
int num = 0;
while (num < ps.Length)
{
string fieldName = ps[num].Info.Name;
string name = fieldName.ToLower();
object val = DataReader[FieldDic[name]];
if (FieldDic.ContainsKey(name) && val != DBNull.Value)
{
ps[num].Setter(obj, val);
}
num++;
}
rowNum++;
DbExecuteReadOnebyOneResult <T> result = new DbExecuteReadOnebyOneResult <T>(rowNum, obj);
try
{
callback(result);
}
catch
{
break;
}
if (!result.Next)
{
break;
}
}
DataReader.Close();
}
void SetIndex(System.Data.IDataReader dr)
{
var list = new List <string>();
for (var i = 0; i < dr.FieldCount; i++)
{
list.Add(dr.GetName(i).ToLower());
}
for (int i = 0; i < Fields.Count; i++)
{
Fields[i].FieldIndex = list.FindIndex(s => Fields[i].Attribute.Field.ToLower() == s);
}
IsClearIndex = true;
}
public override void Write(int?chunkId, int?subChunkId, System.Data.IDataReader reader, string tableName)
{
var folder = _cdmFolder;
folder = Path.Combine(folder, tableName);
if (!Directory.Exists(folder))
{
Directory.CreateDirectory(folder);
}
if (chunkId.HasValue)
{
_fileName = Path.Combine(folder, chunkId.Value.ToString(CultureInfo.InvariantCulture));
}
var isFirstRow = true;
using (var writer = new StreamWriter(_fileName))
{
while (reader.Read())
{
if (isFirstRow)
{
var header = new StringBuilder();
for (var i = 0; i < reader.FieldCount; i++)
{
header.Append(reader.GetName(i));
if (i != reader.FieldCount - 1)
{
header.Append("\t");
}
}
writer.WriteLine(header);
isFirstRow = false;
}
var row = new StringBuilder();
for (var i = 0; i < reader.FieldCount; i++)
{
row.Append(reader.GetValue(i));
if (i != reader.FieldCount - 1)
{
row.Append("\t");
}
}
writer.WriteLine(row);
}
}
}
public static T Entity(System.Data.IDataReader DataReader)
{
Dictionary <string, DataReaderInfo> FieldDic = new Dictionary <string, DataReaderInfo>();
int i = 0;
while (i < DataReader.FieldCount)
{
string Name = DataReader.GetName(i);
FieldDic.Add(Name.ToLower(), new DataReaderInfo {
Index = i, Name = Name, FieldType = DataReader.GetFieldType(i)
});
i++;
}
List <T> Li = new List <T>();
while (Li.Count < 1 && DataReader.Read())
{
T obj = (T)Activator.CreateInstance(typeof(T));
System.Reflection.PropertyInfo[] pis = obj.GetType().GetProperties();
int j = 0;
while (j < pis.Length)
{
string fieldName = pis[j].Name;
string name = fieldName.ToLower();
if (FieldDic.ContainsKey(name))
{
DataReaderInfo info = FieldDic[name];
string key = info.Name;
object o = DataReader[key];
if (TargetTypeIsBool(pis[j].PropertyType))
{
pis[j].SetValue(obj, ConverToBool(o), null);
}
else
{
if (DBNull.Value != o)
{
pis[j].SetValue(obj, o, null);
}
}
}
j++;
}
Li.Add(obj);
}
DataReader.Close();
return(Li.Count > 0 ? Li[0] : default(T));
}
public static object GetColumnValue(this System.Data.IDataReader pReader, string pStrColName)
{
if (pReader == null || string.IsNullOrEmpty(pStrColName))
{
return(null);
}
for (int i = 0; i < pReader.FieldCount; i++)
{
if (pReader.GetName(i).Equals(pStrColName, StringComparison.InvariantCultureIgnoreCase))
{
return(pReader[pStrColName]);
}
}
return(null);
}
internal static bool columnExists(string columnName, System.Data.IDataReader rdr)
{
if (String.IsNullOrEmpty(columnName) || rdr == null || rdr.FieldCount == 0)
{
return(false);
}
for (int i = 0; i < rdr.FieldCount; i++)
{
if (String.Equals(rdr.GetName(i), columnName, StringComparison.CurrentCultureIgnoreCase))
{
return(true);
}
}
return(false);
}
private static Type CreateType(string name, System.Data.IDataReader reader, string extraColumns)
{
string columns = string.Join("#", Enumerable.Range(0, reader.FieldCount)
.Select(i => string.Format("{0},{1},{2}",
reader.GetFieldType(i).Name,
i,
reader.GetName(Conversions.ToInteger(i))))
.ToArray());
if (extraColumns != null && extraColumns.Length > 0)
{
columns += extraColumns;// #Integer,~key1,Prueba#String,~key2,PruebaS
}
return(SmallXmlSerializer.CreateType(name, FieldInfo.FromString(columns)));
}
internal static List <DataReaderField> GetDataReaderFields(System.Data.IDataReader reader)
{
var columns = new List <DataReaderField>();
for (var i = 0; i < reader.FieldCount; i++)
{
var column = new DataReaderField(i, reader.GetName(i), reader.GetFieldType(i));
if (columns.SingleOrDefault(x => x.LowerName == column.LowerName) == null)
{
columns.Add(column);
}
}
return(columns);
}
private T Reader2Item(System.Data.IDataReader reader)
{
if (!reader.Read())
{
return(null);
}
var row = new T();
row.DataFilling = true;
for (var i = 0; i < reader.FieldCount; i++)
{
row[reader.GetName(i)] = reader.GetValue(i);
}
row.DataFilling = false;
return(row);
}
int IInserter.Execute(System.Data.IDataReader reader, string table)
{
var tablename = "{pfx}" + table;
//if (dbProvider.Prefixion.IndexOf('.') == -1)
//{
// tablename = String.Format("{1}{0}{2}", tablename, dbProvider.QuotePrefix, dbProvider.QuoteSuffix);
//}
System.Text.StringBuilder sb = new StringBuilder();
sb.AppendFormat("INSERT INTO {0}(", tablename);;
System.Text.StringBuilder sb2 = new StringBuilder();
for (int i = 0; i < reader.FieldCount; i++)
{
if (i != 0)
{
sb.Append(',');
sb2.Append(',');
}
sb.Append(this.dbProvider.QuotePrefix);
sb.AppendFormat("{0}", reader.GetName(i));
sb.Append(this.dbProvider.QuoteSuffix);
sb2.AppendFormat("{{{0}}}", i);
}
sb.AppendFormat(")VALUES({0})", sb2);
object[] objs = new object[reader.FieldCount];
var sqlText = sb.ToString();
int c = 0;
this.sqler.Execute(sc =>
{
if (reader.Read())
{
reader.GetValues(objs);
sc.Reset(sqlText, objs);
c++;
return(true);
}
else
{
return(false);
}
}, cmd => cmd.ExecuteNonQuery());
return(c);
}
/// <summary>
/// 从阅读取中获取当前数据行
/// </summary>
/// <param name="reader">数据库表游标</param>
/// <returns>用列名为key。值为value的结果集</returns>
private static Dictionary <string, object> GetDataByReader(System.Data.IDataReader reader)
{
var result = new Dictionary <string, object>();
for (var i = 0; i < reader.FieldCount; i++)
{
//读取列名，并最小化
var name = reader.GetName(i).ToLower();
if (!result.ContainsKey(name))
{
var value = reader.GetValue(i);
result.Add(name, value);
}
}
return(result);
}
} // End Function RemoveSingleLineSqlComments
public virtual T GetClass <T>(System.Data.IDbCommand cmd, T tThisClassInstance)
{
System.Type t = typeof(T);
lock (cmd)
{
using (System.Data.IDataReader idr = ExecuteReader(cmd))
{
lock (idr)
{
while (idr.Read())
{
int iFieldCount = idr.FieldCount;
Setter_t <T>[] mems = new Setter_t <T> [iFieldCount];
for (int i = 0; i < iFieldCount; ++i)
{
string strName = idr.GetName(i);
mems[i] = LinqHelper.GetSetter <T>(strName);
} // Next i
for (int i = 0; i < idr.FieldCount; ++i)
{
Setter_t <T> setter = mems[i];
if (setter != null)
{
object objVal = idr.GetValue(i);
setter(tThisClassInstance, objVal);
}
} // Next i
break;
} // Whend
idr.Close();
} // End Lock idr
} // End Using idr
} // End lock cmd
return(tThisClassInstance);
} // End Function GetClass
public override T Reverse <T>(System.Data.IDataReader reader, OrmObjectInfo obj)
{
var arry = new List <string>();
while (reader.Read())
{
var properties = new Dictionary <string, object>();
for (int i = 0; i < reader.FieldCount; i++)
{
AppendJsonObject(obj, properties, reader.GetName(i), reader[i]);
}
arry.Add(JsonConvert.SerializeObject(properties));
}
var names = obj.ObjectName.Split(',');
var typeName = string.Format("{0}[],{1}", names[0], names[1]);
var type = Type.GetType(typeName);
return((T)JsonConvert.DeserializeObject(string.Format("[{0}]", string.Join(",", arry)), type));
}
public static T GetValueOrDefault <T>(System.Data.IDataReader dataReader, string columnName, T defaultValue = default(T))
{
if (dataReader != null && !string.IsNullOrWhiteSpace(columnName))
{
for (int i = 0; i < dataReader.FieldCount; i++)
{
if (dataReader.GetName(i).Equals(columnName, StringComparison.InvariantCultureIgnoreCase))
{
if (dataReader[columnName] == DBNull.Value)
{
return(defaultValue);
}
return((T)dataReader[columnName]);
}
}
}
return(defaultValue);
}
private List <T> Reader2List(System.Data.IDataReader reader)
{
string[] fields = new string[reader.FieldCount];
for (var i = 0; i < reader.FieldCount; i++)
{
fields[i] = reader.GetName(i);
}
var list = new List <T>();
while (reader.Read())
{
var row = new T();
row.DataFilling = true;
for (var i = 0; i < reader.FieldCount; i++)
{
row[fields[i]] = reader.GetValue(i);
}
row.DataFilling = false;
list.Add(row);
}
return(list);
}
public static List <T> EntityListByEmit(System.Data.IDataReader DataReader)
{
Dictionary <string, string> FieldDic = new Dictionary <string, string>();
int i = 0;
while (i < DataReader.FieldCount)
{
string Name = DataReader.GetName(i);
if (!FieldDic.ContainsKey(Name.ToLower()))
{
FieldDic.Add(Name.ToLower(), Name);
}
i++;
}
List <T> Li = new List <T>();
EntityPropertyEmitSetter[] ps = EntityPropertyEmitSetter.GetProperties(typeof(T));
while (DataReader.Read())
{
T obj = new T();
int num = 0;
while (num < ps.Length)
{
string fieldName = ps[num].Info.Name;
string name = fieldName.ToLower();
object val = DataReader[FieldDic[name]];
if (FieldDic.ContainsKey(name) && val != DBNull.Value)
{
ps[num].Setter(obj, val);
}
num++;
}
Li.Add(obj);
}
DataReader.Close();
return(Li);
}
public static IEnumerable <Dictionary <string, object> > AsEnumerable(this System.Data.IDataReader source)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
while (source.Read())
{
Dictionary <string, object> row = new Dictionary <string, object>();
for (int i = 0; i < source.FieldCount; i++)
{
object value = source.GetValue(i);
// return an empty string for dbnull value of field type string
if (source.GetFieldType(i) == typeof(string) && source.IsDBNull(i))
{
value = string.Empty;
}
row.Add(source.GetName(i), value);
}
yield return(row);
}
}
private static void LargeDataToXML(
string table_schema
, string table_name
, System.Xml.XmlWriter writer
, System.Data.IDataReader dr)
{
writer.WriteStartDocument(true);
writer.WriteStartElement("table");
// writer.WriteStartElement(table_name);
writer.WriteAttributeString(null, "table_schema", null, table_schema);
writer.WriteAttributeString(null, "table_name", null, table_name);
writer.WriteAttributeString("xmlns", "xsi", null, System.Xml.Schema.XmlSchema.InstanceNamespace);
// writer.WriteAttributeString("xsi", "schemaLocation", null, System.Xml.Schema.XmlSchema.InstanceNamespace);
int fc = dr.FieldCount;
string[] columnNames = new string[fc];
System.Type[] columnTypes = new System.Type[fc];
for (int i = 0; i < dr.FieldCount; ++i)
{
columnNames[i] = dr.GetName(i);
columnTypes[i] = dr.GetFieldType(i);
} // Next i
while (dr.Read())
{
writer.WriteStartElement("row");
for (int i = 0; i < fc; ++i)
{
writer.WriteStartElement(columnNames[i]);
object obj = dr.GetValue(i);
if (obj != System.DBNull.Value)
{
if (object.ReferenceEquals(columnTypes[i], typeof(System.DateTime)))
{
System.DateTime dt = (System.DateTime)obj;
writer.WriteValue(dt.ToString("yyyy-MM-dd'T'HH':'mm':'ss'.'fff",
System.Globalization.CultureInfo.InvariantCulture));
}
else
{
writer.WriteValue(System.Convert.ToString(obj, System.Globalization.CultureInfo.InvariantCulture));
}
}
else
{
writer.WriteAttributeString("xsi", "nil", System.Xml.Schema.XmlSchema.InstanceNamespace, "true");
}
writer.WriteEndElement();
} // Next i
writer.WriteEndElement();
} // Whend
writer.WriteEndElement();
} // End Sub LargeDataToXML
/// <summary>
/// 使用指定的SQL查询语句查询数据库并读取多条数据库记录对象
/// </summary>
/// <param name="strSQL">SQL查询语句</param>
/// <param name="ObjectType">要读取的对象类型</param>
/// <param name="MaxObjectCount">最多读取的对象个数</param>
/// <returns>读取的对象组成的数组</returns>
public object[] ReadObjects(string strSQL, Type ObjectType, int MaxObjectCount)
{
// 检查参数
if (strSQL == null)
{
throw new ArgumentNullException("strSQL");
}
if (ObjectType == null)
{
throw new ArgumentNullException("ObjectType");
}
// 检查数据库映射信息
this.CheckBindInfo(ObjectType, false);
// 检查数据库连接
this.CheckConnetion();
// 创建SQL命令对象
using (System.Data.IDbCommand cmd = myConnection.CreateCommand())
{
// 执行SQL查询,获得一个数据读取器
cmd.CommandText = strSQL;
System.Data.IDataReader reader = cmd.ExecuteReader(
MaxObjectCount == 1 ?
System.Data.CommandBehavior.SingleRow :
System.Data.CommandBehavior.SingleResult);
System.Collections.ArrayList list = new System.Collections.ArrayList();
TableBindInfo table = this.GetBindInfo(ObjectType);
lock ( table )
{
// 设置字段序号，提高性能
foreach (FieldBindInfo field in table.Fields)
{
field.FieldIndex = -1;
}
for (int iCount = 0; iCount < reader.FieldCount; iCount++)
{
string name = reader.GetName(iCount);
foreach (FieldBindInfo field in table.Fields)
{
if (EqualsFieldName(name, field.FieldName))
{
field.FieldIndex = iCount;
}
}
}
while (reader.Read())
{
// 根据对象类型创建对象实例
object obj = System.Activator.CreateInstance(ObjectType);
// 读取对象属性值
if (InnerReadValues(obj, table, reader) > 0)
{
list.Add(obj);
}
if (MaxObjectCount > 0 || list.Count == MaxObjectCount)
{
break;
}
} //while
} //lock
reader.Close();
// 返回读取的对象数组
return(list.ToArray());
} //using
}
public static T GetItemAs <T>(this System.Data.IDataReader reader, int columnIndex)
{
return(reader.GetItemAs <T>(reader.GetName(columnIndex)));
}
} // WriteColumnDefinition
private static async System.Threading.Tasks.Task WriteAsXmlAsync(
string table_schema
, string table_name
, XmlRenderType_t format
, System.Xml.XmlWriter writer
, System.Data.IDataReader dr)
{
await writer.WriteStartDocumentAsync(true);
bool dataAsAttributes = format.HasFlag(XmlRenderType_t.DataInAttributes);
bool dataTableOnly = format.HasFlag(XmlRenderType_t.DataTable);
if (!dataTableOnly)
{
await writer.WriteStartElementAsync(null, "dataset", null);
}
do
{
await writer.WriteStartElementAsync(null, "table", null);
if (dataTableOnly)
{
if (table_schema != null)
{
await writer.WriteAttributeStringAsync(null, "table_schema", null, table_schema);
}
if (table_name != null)
{
await writer.WriteAttributeStringAsync(null, "table_name", null, table_name);
}
}
if (!dataAsAttributes)
{
await writer.WriteAttributeStringAsync("xmlns", "xsi", null, System.Xml.Schema.XmlSchema.InstanceNamespace);
}
int fc = dr.FieldCount;
if (format.HasFlag(XmlRenderType_t.WithColumnDefinition))
{
await WriteColumnDefinition(writer, dr, format);
}
string[] columnNames = new string[fc];
System.Type[] columnTypes = new System.Type[fc];
for (int i = 0; i < dr.FieldCount; ++i)
{
columnNames[i] = dr.GetName(i);
columnTypes[i] = dr.GetFieldType(i);
} // Next i
while (dr.Read())
{
await writer.WriteStartElementAsync(null, "row", null);
for (int i = 0; i < fc; ++i)
{
if (!dataAsAttributes)
{
await writer.WriteStartElementAsync(null, columnNames[i], null);
}
object obj = dr.GetValue(i);
if (obj != System.DBNull.Value)
{
string value = null;
if (object.ReferenceEquals(columnTypes[i], typeof(System.DateTime)))
{
System.DateTime dt = (System.DateTime)obj;
value = dt.ToString("yyyy-MM-dd'T'HH':'mm':'ss'.'fff", System.Globalization.CultureInfo.InvariantCulture);
}
else
{
value = System.Convert.ToString(obj, System.Globalization.CultureInfo.InvariantCulture);
}
if (dataAsAttributes)
{
await writer.WriteAttributeStringAsync(null, columnNames[i], null, value);
}
else
{
writer.WriteValue(value);
}
} // End if (obj != System.DBNull.Value)
else
{
if (!dataAsAttributes)
{
await writer.WriteAttributeStringAsync("xsi", "nil", System.Xml.Schema.XmlSchema.InstanceNamespace, "true");
}
}
if (!dataAsAttributes)
{
await writer.WriteEndElementAsync(); // column
}
} // Next i
await writer.WriteEndElementAsync(); // row
} // Whend
await writer.WriteEndElementAsync(); // table
await writer.FlushAsync();
if (dataTableOnly)
{
break;
}
} while (dr.NextResult());
if (!dataTableOnly)
{
await writer.WriteEndElementAsync(); // dataset
await writer.FlushAsync();
}
} // End Sub WriteAsXmlAsync
