public static string WriteXml(this DataSet dataSet, XmlWriteMode writeMode)
{
string xmlSerializedDataSet;
dataSet.WriteXml(writeMode, out xmlSerializedDataSet);
return(xmlSerializedDataSet);
}
public static void WriteCompressedXml(this DataSet dataset, Stream stream, XmlWriteMode mode)
{
using (GZipStream compressStream = new GZipStream(stream, CompressionMode.Compress))
{
dataSet.WriteXml(compressStream, mode);
}
}
public void CacheDataSet(DataSet ds, string name, XmlWriteMode mode)
{
string path = GetHashFilename(name);
// ds.WriteXml(path, mode);
EncryptDSAes(path, ds, mode);
}
public static void WriteXml(this DataSet dataSet, XmlWriteMode writeMode, out string xmlSerializedDataSet)
{
var sw = new StringWriter();
dataSet.WriteXml(sw, writeMode);
xmlSerializedDataSet = sw.ToString();
}
internal static void WriteTableList(XmlWriter writer, XmlWriteMode mode, List <DataTable> tables, DataRowVersion version)
{
foreach (DataTable table in tables)
{
DataSet.WriteTable(writer, table, mode, version);
}
}
/// <summary>
/// 테이블을 XML 문자열로 변경해서 리턴함.
/// </summary>
/// <param name="ds"></param>
/// <param name="WriteMode">XmlWriteMode.IgnoreSchema를 쓰면 스키마 없는 간단한 XML 형식을 리턴함.</param>
/// <returns></returns>
public static string WriteXmlString(DataSet ds, XmlWriteMode WriteMode)
{
StringWriter sw = new StringWriter();
ds.WriteXml(sw, WriteMode);
return(sw.ToString());
}
public void EncryptDSAes(string path, DataSet ds, XmlWriteMode mode)
{
System.Security.Cryptography.MD5 md5Hash = System.Security.Cryptography.MD5.Create();
// Convert the input string to a byte array and compute the hash.
byte[] data = md5Hash.ComputeHash(Encoding.UTF8.GetBytes(path));
// Create an AesManaged object
// with the specified key and IV.
using (AesManaged aesAlg = new AesManaged())
{
aesAlg.Key = data;
aesAlg.IV = data;
// Create a decrytor to perform the stream transform.
ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);
// Create the streams used for encryption.
using (System.IO.FileStream msEncrypt = new System.IO.FileStream(path, System.IO.FileMode.Create))
{
using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
{
ds.WriteXml(csEncrypt, mode);
}
}
}
}
virtual public string ToXml(XmlWriteMode mode)
{
DataSet dataSet = new DataSet();
dataSet.Tables.Add(_dataTable);
StringWriter writer = new StringWriter();
dataSet.WriteXml(writer, mode);
dataSet.Tables.Clear();
return(writer.ToString());
}
/// <summary> Writes the current data to the specified file as remarked XML </summary>
/// <param name="fileName"> The file name (including the path) to which to write </param>
/// <param name="writeMode"> One of the System.XmlWriteMode values. Use WriteSchema to write the schema </param>
/// <example> For a complete example, see the example under the main <see cref="RemarkedDataSet"/> class. </example>
public void WriteRemarkedXml(string fileName, XmlWriteMode writeMode)
{
// See if schema should be included
if (writeMode.Equals(XmlWriteMode.WriteSchema))
{
WriteRemarkedXml(fileName, true);
}
else
{
WriteRemarkedXml(fileName, false);
}
}
/// <summary>
/// DataTable 내용을 Xml Text로 변경한다.
/// </summary>
/// <param name="table">Instance of DataTable</param>
/// <param name="writeMode">Xml Text 생성 모드</param>
/// <returns>생성된 Xml 문자열</returns>
public static string ToXmlText(DataTable table, XmlWriteMode writeMode = XmlWriteMode.WriteSchema) {
table.ShouldNotBeNull("table");
if(IsDebugEnabled)
log.Debug("Convert DataTable to Xml Text. table=[{0}], writeMode=[{1}]", table.TableName, writeMode);
var sb = new StringBuilder();
using(var writer = new StringWriter(sb))
table.WriteXml(writer, writeMode);
return sb.ToString();
}
/// <summary>
/// 把DataSet打成XML字符串
/// </summary>
/// <param name="ds">要处理的DataSet</param>
/// <param name="mode">指定如何从 System.Data.DataSet 写入 XML 数据和关系架构</param>
/// <returns></returns>
public static string DataSetToXML(DataSet ds, XmlWriteMode mode)
{
string ret = null;
using (MemoryStream stm = new MemoryStream())
{
XmlTextWriter writer = new XmlTextWriter(stm, System.Text.Encoding.UTF8);
ds.WriteXml(writer, mode);
byte[] buffer = stm.ToArray();
ret = System.Text.Encoding.UTF8.GetString(buffer);
}
return(ret);
}
public void escribir(string Peticion, string Status)
{
XmlWriteMode xml = new XmlWriteMode();
//Creamos el nodo que deseamos insertar.
XmlNode empleado = crearNodoXml(DateTime.Now.ToString(), Peticion, Status);
//Obtenemos el nodo raiz del documento.
XmlNode nodoRaiz = documento.DocumentElement;
//Insertamos el nodo empleado al final del archivo
nodoRaiz.InsertAfter(empleado, nodoRaiz.LastChild);
documento.Save("C:\\logBusqueda.xml");
}
public void escribir(string Peticion, string Status)
{
XmlWriteMode xml = new XmlWriteMode();
//Creamos el nodo que deseamos insertar.
XmlNode empleado = crearNodoXml(DateTime.Now.ToString(),Peticion,Status);
//Obtenemos el nodo raiz del documento.
XmlNode nodoRaiz = documento.DocumentElement;
//Insertamos el nodo empleado al final del archivo
nodoRaiz.InsertAfter(empleado, nodoRaiz.LastChild);
documento.Save("C:\\logBusqueda.xml");
}
/// <summary>
/// Writes the Data from DataSet into a XML File
/// </summary>
/// <param name="dataSet">DataSet</param>
/// <param name="FileName">File Path</param>
/// <param name="XmlWriteMode">Write Mode</param>
/// <returns></returns>
public static bool WriteDataSetToXML(DataSet dataSet, StreamWriter FileName, XmlWriteMode XmlWriteMode)
{
bool isReturn = false;
try
{
dataSet.WriteXml(FileName, XmlWriteMode);
isReturn = true;
}
catch (Exception e)
{
isReturn = false;
}
return(isReturn);
}
/// <summary>
/// DataTable 내용을 Xml Text로 변경한다.
/// </summary>
/// <param name="table">Instance of DataTable</param>
/// <param name="writeMode">Xml Text 생성 모드</param>
/// <returns>생성된 Xml 문자열</returns>
public static string ToXmlText(DataTable table, XmlWriteMode writeMode = XmlWriteMode.WriteSchema)
{
table.ShouldNotBeNull("table");
if (IsDebugEnabled)
{
log.Debug("Convert DataTable to Xml Text. table=[{0}], writeMode=[{1}]", table.TableName, writeMode);
}
var sb = new StringBuilder();
using (var writer = new StringWriter(sb))
table.WriteXml(writer, writeMode);
return(sb.ToString());
}
/// <summary>
/// 找回缓存参数集合
/// </summary>
/// <param name="cacheKey">用于找回参数的关键字</param>
/// <returns>缓存的参数集合</returns>
public static SqlParameter[] GetCachedParameters(string cacheKey)
{
string cachedParms = cacheKey;
if (cachedParms == null)
{
return(null);
}
SqlParameter[] clonedParms = new SqlParameter[cachedParms.Length];
for (int i = 0, j = cachedParms.Length; i < j; i++)
{
XmlWriteMode xm = new XmlWriteMode();
}
return(clonedParms);
}
/// <summary>
/// 获取存取在DataSet的数据的xml表现形式
/// </summary>
/// <param name="dataSet">数据源DataSet</param>
/// <param name="mappingType">映射DataColumn的方式</param>
/// <param name="xmlWriteMode">指定如何从DataSet写入xml数据和关系架构</param>
/// <returns>DataSet中的数据的xml表现形式</returns>
public static string GetXml(this DataSet dataSet, MappingType mappingType, XmlWriteMode xmlWriteMode)
{
FrameDataSetExtends.SetDataSetColumnElementToAttribute(dataSet, mappingType);
MemoryStream ms = new MemoryStream();
XmlDocument dom = new XmlDocument();
try
{
dataSet.WriteXml(ms, xmlWriteMode);
ms.Flush();
ms.Seek(0, SeekOrigin.Begin);
dom.Load(ms);
}
catch (Exception ex)
{
throw ex;
}
finally
{
ms.Close();
}
return(dom.InnerXml);
}
public XmlExport(string ExportDir, XmlWriteMode writemode = XmlWriteMode.WriteSchema)
{
WriteMode = writemode;
ExportDirectory = ExportDir;
}
internal static void WriteStartElement (XmlWriter writer, XmlWriteMode mode, string nspc, string prefix, string name)
{
writer.WriteStartElement (prefix, name, nspc);
}
/// <summary>
/// Writes the current data, and optionally the schema, for the <see cref="T:System.Data.DataTable"/> using the specified
/// <see cref="T:System.Xml.XmlWriter"/> and <see cref="T:System.Data.XmlWriteMode"/>. To write the schema, set the value for the
/// <paramref name="mode"/> parameter to WriteSchema.
/// </summary>
/// <param name="writer">
/// The <see cref="T:System.Xml.XmlWriter"/> used to write the document.
/// </param>
/// <param name="mode">
/// One of the <see cref="T:System.Data.XmlWriteMode"/> values.
/// </param>
public void WriteXml(XmlWriter writer,
XmlWriteMode mode)
{
this.DataTableInstance.WriteXml(writer, mode);
}
/// <summary>
/// Writes the current data, and optionally the schema, for the <see cref="T:System.Data.DataTable"/> using the specified file and
/// <see cref="T:System.Data.XmlWriteMode"/>. To write the schema, set the value for the <paramref name="mode"/> parameter to WriteSchema.
/// </summary>
/// <param name="fileName">
/// The name of the file to which the data will be written.
/// </param>
/// <param name="mode">
/// One of the <see cref="T:System.Data.XmlWriteMode"/> values.
/// </param>
public void WriteXml(string fileName,
XmlWriteMode mode)
{
this.DataTableInstance.WriteXml(fileName, mode);
}
public void WriteXml (TextWriter writer, XmlWriteMode mode)
{
XmlTextWriter xwriter = new XmlTextWriter (writer);
xwriter.Formatting = Formatting.Indented;
WriteXml (xwriter, mode);
}
/// <summary>
/// Writes the current data, and optionally the schema, for the <see cref="T:System.Data.DataTable"/> to the specified file using the specified <see cref="T:System.Data.XmlWriteMode"/>. To write the schema, set the value for the <paramref name="mode"/> parameter to WriteSchema.
/// </summary>
/// <param name="stream">
/// The stream to which the data will be written.
/// </param>
/// <param name="mode">
/// One of the <see cref="T:System.Data.XmlWriteMode"/> values.
/// </param>
public void WriteXml(Stream stream,
XmlWriteMode mode)
{
this.DataTableInstance.WriteXml(stream, mode);
}
public void WriteXml(XmlWriter writer, XmlWriteMode mode)
{
WriteXml(writer, mode, false);
}
public void WriteXml (string fileName, XmlWriteMode mode)
{
XmlTextWriter writer = new XmlTextWriter (fileName, null);
writer.Formatting = Formatting.Indented;
writer.WriteStartDocument (true);
try {
WriteXml (writer, mode);
} finally {
writer.WriteEndDocument ();
writer.Close ();
}
}
public virtual void WriteXml(XmlWriter writer, XmlWriteMode mode)
{
_sourcedataset.WriteXml(writer, mode);
}
public void WriteXml(Stream stream, XmlWriteMode mode, bool writeHierarchy)
{
if (stream != null) {
XmlTextWriter w = new XmlTextWriter(stream, null) ;
w.Formatting = Formatting.Indented;
WriteXml( w, mode, writeHierarchy);
}
}
/// <summary>
/// 获取存取在DataSet的数据的xml表现形式，并将列映射为xml中的属性
/// </summary>
/// <param name="dataSet">>数据源DataSet</param>
/// <param name="xmlWriteMode">指定如何从DataSet写入XML数据和关系架构</param>
/// <returns>DataSet中的数据的xml表现形式</returns>
public static string GetXmlColumnToAtribute(this DataSet dataSet, XmlWriteMode xmlWriteMode)
{
return(GetXml(dataSet, MappingType.Attribute, xmlWriteMode));
}
public virtual void WriteXml(string fileName, XmlWriteMode mode)
{
_sourcedataset.WriteXml(fileName, mode);
}
// This method is modelled after the DataSet's WriteXml functionality.
internal static void WriteTables(XmlWriter writer,
XmlWriteMode mode,
List <DataTable> tables,
List <DataRelation> relations,
string mainDataTable,
string dataSetName)
{
if (mode == XmlWriteMode.DiffGram)
{
foreach (DataTable table in tables)
{
table.SetRowsID();
}
DataSet.WriteDiffGramElement(writer);
}
bool shouldOutputContent = (mode != XmlWriteMode.DiffGram);
for (int n = 0; n < tables.Count && !shouldOutputContent; n++)
{
shouldOutputContent = tables[n].Rows.Count > 0;
}
if (shouldOutputContent)
{
// We assume that tables[0] is the main table being written.
// We happen to know that the code above us does things that way.
DataSet.WriteStartElement(writer, mode, tables[0].Namespace, tables[0].Prefix, XmlHelper.Encode(dataSetName));
if (mode == XmlWriteMode.WriteSchema)
{
DataTable [] _tables = new DataTable[tables.Count];
tables.CopyTo(_tables);
DataRelation[] _relations = new DataRelation[relations.Count];
relations.CopyTo(_relations);
DataTable dt = _tables [0];
new XmlSchemaWriter(writer,
_tables,
_relations,
mainDataTable,
dataSetName,
dt.LocaleSpecified ? dt.Locale : null
).WriteSchema();
}
WriteTableList(writer, mode, tables, DataRowVersion.Default);
writer.WriteEndElement();
}
if (mode == XmlWriteMode.DiffGram)
{
List <DataTable> changedTables = new List <DataTable>();
foreach (DataTable table in tables)
{
DataTable changed = table.GetChanges(DataRowState.Modified | DataRowState.Deleted);
if (changed != null && changed.Rows.Count > 0)
{
changedTables.Add(changed);
}
}
if (changedTables.Count > 0)
{
DataSet.WriteStartElement(writer, XmlWriteMode.DiffGram, XmlConstants.DiffgrNamespace, XmlConstants.DiffgrPrefix, "before");
WriteTableList(writer, mode, changedTables, DataRowVersion.Original);
writer.WriteEndElement();
}
writer.WriteEndElement(); // diffgr:diffgram
}
writer.Flush();
}
internal static void WriteAttributeString (XmlWriter writer, XmlWriteMode mode, string nspc, string prefix, string name, string stringValue)
{
switch ( mode) {
// case XmlWriteMode.WriteSchema:
// writer.WriteAttributeString (prefix, name, nspc);
// break;
case XmlWriteMode.DiffGram:
writer.WriteAttributeString (prefix, name, nspc,stringValue);
break;
default:
writer.WriteAttributeString (name, stringValue);
break;
};
}
public void WriteXml(String fileName, XmlWriteMode mode)
{
WriteXml(fileName, mode, false);
}
internal void WriteIndividualTableContent (XmlWriter writer, DataTable table, XmlWriteMode mode)
{
if (mode == XmlWriteMode.DiffGram) {
table.SetRowsID ();
WriteDiffGramElement (writer);
}
WriteStartElement (writer, mode, Namespace, Prefix, XmlHelper.Encode (DataSetName));
WriteTable (writer, table, mode, DataRowVersion.Default);
if (mode == XmlWriteMode.DiffGram) {
writer.WriteEndElement (); //DataSet name
if (HasChanges (DataRowState.Modified | DataRowState.Deleted)) {
DataSet beforeDS = GetChanges (DataRowState.Modified | DataRowState.Deleted);
WriteStartElement (writer, XmlWriteMode.DiffGram, XmlConstants.DiffgrNamespace, XmlConstants.DiffgrPrefix, "before");
WriteTable (writer, beforeDS.Tables [table.TableName], mode, DataRowVersion.Original);
writer.WriteEndElement ();
}
}
writer.WriteEndElement (); // DataSet name or diffgr:diffgram
}
public virtual void WriteXml(Stream stream, XmlWriteMode mode)
{
_sourcedataset.WriteXml(stream, mode);
}
public void WriteXml (Stream stream, XmlWriteMode mode)
{
XmlTextWriter writer = new XmlTextWriter (stream, null);
writer.Formatting = Formatting.Indented;
WriteXml (writer, mode);
}
internal static void WriteTable (XmlWriter writer,
DataRow [] rows,
XmlWriteMode mode,
DataRowVersion version, bool skipIfNested)
{
if (rows.Length == 0) return;
DataTable table = rows[0].Table;
if (table.TableName == null || table.TableName == "")
throw new InvalidOperationException("Cannot serialize the DataTable. DataTable name is not set.");
//The columns can be attributes, hidden, elements, or simple content
//There can be 0-1 simple content cols or 0-* elements
System.Collections.ArrayList atts;
System.Collections.ArrayList elements;
DataColumn simple = null;
SplitColumns (table, out atts, out elements, out simple);
//sort out the namespacing
foreach (DataRow row in rows) {
if (skipIfNested) {
// Skip rows that is a child of any tables.
bool skip = false;
for (int i = 0; i < table.ParentRelations.Count; i++) {
DataRelation prel = table.ParentRelations [i];
if (!prel.Nested)
continue;
if (row.GetParentRow (prel) != null) {
skip = true;
continue;
}
}
if (skip)
continue;
}
if (!row.HasVersion(version) ||
(mode == XmlWriteMode.DiffGram && row.RowState == DataRowState.Unchanged
&& version == DataRowVersion.Original))
continue;
// First check are all the rows null. If they are we just write empty element
bool AllNulls = true;
foreach (DataColumn dc in table.Columns) {
if (row [dc.ColumnName, version] != DBNull.Value) {
AllNulls = false;
break;
}
}
// If all of the columns were null, we have to write empty element
if (AllNulls) {
writer.WriteElementString (XmlHelper.Encode (table.TableName), "");
continue;
}
WriteTableElement (writer, mode, table, row, version);
foreach (DataColumn col in atts)
WriteColumnAsAttribute (writer, mode, col, row, version);
if (simple != null) {
writer.WriteString (WriteObjectXml (row[simple, version]));
} else {
foreach (DataColumn col in elements)
WriteColumnAsElement (writer, mode, col, row, version);
}
foreach (DataRelation relation in table.ChildRelations) {
if (relation.Nested)
WriteTable (writer, row.GetChildRows (relation), mode, version, false);
}
writer.WriteEndElement ();
}
}
public void WriteXml (XmlWriter writer, XmlWriteMode mode)
{
if (mode == XmlWriteMode.DiffGram) {
SetRowsID();
WriteDiffGramElement(writer);
}
// It should not write when there is no content to be written
bool shouldOutputContent = (mode != XmlWriteMode.DiffGram);
for (int n = 0; n < tableCollection.Count && !shouldOutputContent; n++)
shouldOutputContent = tableCollection [n].Rows.Count > 0;
if (shouldOutputContent) {
WriteStartElement (writer, mode, Namespace, Prefix, XmlHelper.Encode (DataSetName));
if (mode == XmlWriteMode.WriteSchema)
DoWriteXmlSchema (writer);
WriteTables (writer, mode, Tables, DataRowVersion.Default);
writer.WriteEndElement ();
}
if (mode == XmlWriteMode.DiffGram) {
if (HasChanges(DataRowState.Modified | DataRowState.Deleted)) {
DataSet beforeDS = GetChanges (DataRowState.Modified | DataRowState.Deleted);
WriteStartElement (writer, XmlWriteMode.DiffGram, XmlConstants.DiffgrNamespace, XmlConstants.DiffgrPrefix, "before");
WriteTables (writer, mode, beforeDS.Tables, DataRowVersion.Original);
writer.WriteEndElement ();
}
}
if (mode == XmlWriteMode.DiffGram)
writer.WriteEndElement (); // diffgr:diffgram
writer.Flush ();
}
internal static void WriteColumnAsElement (XmlWriter writer, XmlWriteMode mode, DataColumn col, DataRow row, DataRowVersion version)
{
string colnspc = null;
object rowObject = row [col, version];
if (rowObject == null || rowObject == DBNull.Value)
return;
if (col.Namespace != String.Empty)
colnspc = col.Namespace;
//TODO check if I can get away with write element string
WriteStartElement (writer, mode, colnspc, col.Prefix, XmlHelper.Encode (col.ColumnName));
if (typeof (IXmlSerializable).IsAssignableFrom (col.DataType)
|| col.DataType == typeof (object)) {
IXmlSerializable serializableObj = rowObject as IXmlSerializable;
if (serializableObj == null)
throw new InvalidOperationException ();
((IXmlSerializable)rowObject).WriteXml (writer);
} else {
writer.WriteString (WriteObjectXml (rowObject));
}
writer.WriteEndElement ();
}
/// <summary>
/// Writes the current data, and optionally the schema, for the <see cref="T:System.Data.DataTable"/> to the specified file using the specified <see cref="T:System.Data.XmlWriteMode"/>. To write the schema, set the value for the <paramref name="mode"/> parameter to WriteSchema. To save the data for the table and all its descendants, set the <paramref name="writeHierarchy"/> parameter to true.
/// </summary>
/// <param name="stream">
/// The stream to which the data will be written.
/// </param>
/// <param name="mode">
/// One of the <see cref="T:System.Data.XmlWriteMode"/> values.
/// </param>
/// <param name="writeHierarchy">
/// If true, write the contents of the current table and all its descendants. If false (the default value), write the data for the current table only.
/// </param>
public void WriteXml(Stream stream,
XmlWriteMode mode,
bool writeHierarchy)
{
this.DataTableInstance.WriteXml(stream, mode, writeHierarchy);
}
internal static void WriteColumnAsAttribute (XmlWriter writer, XmlWriteMode mode, DataColumn col, DataRow row, DataRowVersion version)
{
if (!row.IsNull (col))
WriteAttributeString (writer, mode, col.Namespace, col.Prefix, XmlHelper.Encode (col.ColumnName), WriteObjectXml (row[col, version]));
}
/// <summary>
/// Writes the current data, and optionally the schema, for the <see cref="T:System.Data.DataTable"/> using the specified
/// <see cref="T:System.Xml.XmlWriter"/> and <see cref="T:System.Data.XmlWriteMode"/>. To write the schema, set the value for the
/// <paramref name="mode"/> parameter to WriteSchema. To save the data for the table and all its descendants, set the
/// <paramref name="writeHierarchy"/> parameter to true.
/// </summary>
/// <param name="writer">
/// The <see cref="T:System.Xml.XmlWriter"/> used to write the document.
/// </param>
/// <param name="mode">
/// One of the <see cref="T:System.Data.XmlWriteMode"/> values.
/// </param>
/// <param name="writeHierarchy">
/// If true, write the contents of the current table and all its descendants. If false (the default value), write the data for the current table only.
/// </param>
public void WriteXml(XmlWriter writer,
XmlWriteMode mode,
bool writeHierarchy)
{
this.DataTableInstance.WriteXml(writer, mode, writeHierarchy);
}
internal static void WriteTableElement (XmlWriter writer, XmlWriteMode mode, DataTable table, DataRow row, DataRowVersion version)
{
//sort out the namespacing
string nspc = (table.Namespace.Length > 0 || table.DataSet == null) ? table.Namespace : table.DataSet.Namespace;
WriteStartElement (writer, mode, nspc, table.Prefix, XmlHelper.Encode (table.TableName));
if (mode == XmlWriteMode.DiffGram) {
WriteAttributeString (writer, mode, XmlConstants.DiffgrNamespace, XmlConstants.DiffgrPrefix, "id", table.TableName + (row.XmlRowID + 1));
WriteAttributeString (writer, mode, XmlConstants.MsdataNamespace, XmlConstants.MsdataPrefix, "rowOrder", XmlConvert.ToString (row.XmlRowID));
string modeName = null;
if (row.RowState == DataRowState.Modified)
modeName = "modified";
else if (row.RowState == DataRowState.Added)
modeName = "inserted";
if (version != DataRowVersion.Original && modeName != null)
WriteAttributeString (writer, mode, XmlConstants.DiffgrNamespace, XmlConstants.DiffgrPrefix, "hasChanges", modeName);
}
}
/// <summary>
/// Writes the current data, and optionally the schema, for the <see cref="T:System.Data.DataTable"/> using the specified file and
/// <see cref="T:System.Data.XmlWriteMode"/>. To write the schema, set the value for the <paramref name="mode"/> parameter to WriteSchema.
/// To save the data for the table and all its descendants, set the <paramref name="writeHierarchy"/> parameter to true.
/// </summary>
/// <param name="fileName">
/// The name of the file to which the data will be written.
/// </param>
/// <param name="mode">
/// One of the <see cref="T:System.Data.XmlWriteMode"/> values.
/// </param>
/// <param name="writeHierarchy">
/// If true, write the contents of the current table and all its descendants. If false (the default value), write the data for the current table only.
/// </param>
public void WriteXml(string fileName,
XmlWriteMode mode,
bool writeHierarchy)
{
this.DataTableInstance.WriteXml(fileName, mode, writeHierarchy);
}
private static string WriteXmlWithSchema(Action <TextWriter, XmlWriteMode> writeMethod, XmlWriteMode xmlWriteMode = XmlWriteMode.WriteSchema)
{
StringWriter writer = new StringWriter();
writeMethod(writer, xmlWriteMode);
return(writer.ToString());
}
public void WriteXml(Stream stream, XmlWriteMode mode)
{
WriteXml(stream, mode, false);
}
public void WriteXml(string fileName, XmlWriteMode mode)
{
IntPtr ptr;
Bid.ScopeEnter(out ptr, "<ds.DataSet.WriteXml|API> %d#, fileName='%ls', mode=%d{ds.XmlWriteMode}\n", this.ObjectID, fileName, (int) mode);
XmlTextWriter xmlw = new XmlTextWriter(fileName, null);
try
{
xmlw.Formatting = Formatting.Indented;
xmlw.WriteStartDocument(true);
if (xmlw != null)
{
if (mode == XmlWriteMode.DiffGram)
{
new NewDiffgramGen(this).Save(xmlw);
}
else
{
new XmlDataTreeWriter(this).Save(xmlw, mode == XmlWriteMode.WriteSchema);
}
}
xmlw.WriteEndDocument();
}
finally
{
xmlw.Close();
Bid.ScopeLeave(ref ptr);
}
}
public void WriteXml(TextWriter writer, XmlWriteMode mode, bool writeHierarchy)
{
if (writer != null) {
XmlTextWriter w = new XmlTextWriter(writer) ;
w.Formatting = Formatting.Indented;
WriteXml(w, mode, writeHierarchy);
}
}
public void WriteXml(XmlWriter writer, XmlWriteMode mode)
{
IntPtr ptr;
Bid.ScopeEnter(out ptr, "<ds.DataSet.WriteXml|API> %d#, mode=%d{ds.XmlWriteMode}\n", this.ObjectID, (int) mode);
try
{
if (writer != null)
{
if (mode == XmlWriteMode.DiffGram)
{
new NewDiffgramGen(this).Save(writer);
}
else
{
new XmlDataTreeWriter(this).Save(writer, mode == XmlWriteMode.WriteSchema);
}
}
}
finally
{
Bid.ScopeLeave(ref ptr);
}
}
public void WriteXml(XmlWriter writer, XmlWriteMode mode, bool writeHierarchy)
{
IntPtr hscp;
Bid.ScopeEnter(out hscp, "<ds.DataTable.WriteXml|API> %d#, mode=%d{ds.XmlWriteMode}\n", ObjectID, (int)mode);
try{
if (this.tableName.Length == 0) {
throw ExceptionBuilder.CanNotSerializeDataTableWithEmptyName();
}
// Generate SchemaTree and write it out
if (writer != null) {
if (mode == XmlWriteMode.DiffGram) { // FIX THIS
// Create and save the updates
new NewDiffgramGen(this, writeHierarchy).Save(writer, this);
}
else {
// Create and save xml data
if (mode == XmlWriteMode.WriteSchema) {
DataSet ds = null;
string tablenamespace = this.tableNamespace;
if (null == this.DataSet) {
ds = new DataSet();
// if user set values on DataTable, it isn't necessary
// to set them on the DataSet because they won't be inherited
// but it is simpler to set them in both places
// if user did not set values on DataTable, it is required
// to set them on the DataSet so the table will inherit
// the value already on the Datatable
ds.SetLocaleValue(_culture, _cultureUserSet);
ds.CaseSensitive = this.CaseSensitive;
ds.Namespace = this.Namespace;
ds.RemotingFormat = this.RemotingFormat;
ds.Tables.Add(this);
}
if (writer != null) {
XmlDataTreeWriter xmldataWriter = new XmlDataTreeWriter(this, writeHierarchy);
xmldataWriter.Save(writer, /*mode == XmlWriteMode.WriteSchema*/true);
}
if (null != ds) {
ds.Tables.Remove(this);
this.tableNamespace = tablenamespace;
}
}
else {
XmlDataTreeWriter xmldataWriter = new XmlDataTreeWriter(this, writeHierarchy);
xmldataWriter.Save(writer,/*mode == XmlWriteMode.WriteSchema*/ false);
}
}
}
}
finally {
Bid.ScopeLeave(ref hscp);
}
}
private void WriteTables (XmlWriter writer, XmlWriteMode mode, DataTableCollection tableCollection, DataRowVersion version)
{
//WriteTable takes care of skipping a table if it has a
//Nested Parent Relationship
foreach (DataTable table in tableCollection)
WriteTable ( writer, table, mode, version);
}
public void WriteXml(String fileName, XmlWriteMode mode, bool writeHierarchy)
{
IntPtr hscp;
Bid.ScopeEnter(out hscp, "<ds.DataTable.WriteXml|API> %d#, fileName='%ls', mode=%d{ds.XmlWriteMode}\n", ObjectID, fileName, (int)mode);
try {
using(XmlTextWriter xw = new XmlTextWriter( fileName, null )) {
xw.Formatting = Formatting.Indented;
xw.WriteStartDocument(true);
WriteXml(xw, mode, writeHierarchy);
xw.WriteEndDocument();
}
}
finally {
Bid.ScopeLeave(ref hscp);
}
}
internal static void WriteTable (XmlWriter writer, DataTable table, XmlWriteMode mode, DataRowVersion version)
{
DataRow[] rows = table.NewRowArray(table.Rows.Count);
table.Rows.CopyTo (rows, 0);
WriteTable (writer, rows, mode, version, true);
}
