/// <summary>
/// Reading DataSet from an XML file
/// </summary>
/// <param name="Path">XML File Path</param>
/// <param name="XmlReadMode">Read Mode</param>
/// <returns>Dataset</returns>
public static DataSet ReadDataSetFromXML(string Path, XmlReadMode XmlReadMode)
{
DataSet ObjdataSet = new DataSet();
ObjdataSet.ReadXml(Path, XmlReadMode);
return(ObjdataSet);
}
public DataSet J_ConvertXmlToDataSet(string xmlPhysicalFilePath, XmlReadMode readMode)
{
DataSet J_DataSet = new DataSet();
J_DataSet.ReadXml(xmlPhysicalFilePath, readMode);
return(J_DataSet);
}
public override void OnAuthorization(HttpActionContext actionContext)
{
var authHeader = actionContext.Request.Headers.Authorization;
if (authHeader != null)
{
var authenticationToken = actionContext.Request.Headers.Authorization.Parameter;
var decodedAuthenticationToken = Encoding.UTF8.GetString(Convert.FromBase64String(authenticationToken));
var usernamePasswordArray = decodedAuthenticationToken.Split(':');
var userName = usernamePasswordArray[0];
var password = usernamePasswordArray[1];
DataSet ds = new DataSet();
XmlReadMode xmlReadMode = ds.ReadXml(Path.Combine(HttpContext.Current.Request.PhysicalApplicationPath, @"App_Data\UserInfo.xml"));
var lstUser = ds.Tables[0].AsEnumerable().Select(dr => new Users {
UserName = dr.Field <string>("Name"), Password = dr.Field <string>("Password")
}).ToList <Users>();
Users usr = lstUser.Where <Users>(x => x.UserName.ToUpper() == userName.ToUpper() && x.Password == password).FirstOrDefault();
if (usr != null)
{
var principal = new GenericPrincipal(new GenericIdentity(usr.UserName), null);
Thread.CurrentPrincipal = principal;
actionContext.Response =
actionContext.Request.CreateResponse(HttpStatusCode.OK,
"User " + userName + " successfully authenticated");
return;
}
}
HandleUnathorized(actionContext);
}
private void buttonGenerate_Click(object sender, EventArgs e)
{
string xml = _ctrlCSBMsg.GetXmlString();
if (string.IsNullOrEmpty(xml))
{
return;
}
MSG.Message msg = XObjectManager.CreateObject <MSG.Message>(xml);
if (msg == null)
{
MessageBox.Show(this, "Deserialize CSB DataSet Message failed. See the log file for details.", this.Text);
return;
}
try
{
DataSet ds = new DataSet();
XmlReadMode m = ds.ReadXml(XmlReader.Create(new StringReader(msg.Body)));
this.dataGridViewDS.DataSource = ds.Tables[0];
}
catch (Exception err)
{
Program.Context.Log.Write(err);
MessageBox.Show(this, "Deserialize DataSet XML failed. See the log file for details.\r\n\r\nMessage: " + err.Message, this.Text);
}
}
private void button1_Click(object sender, EventArgs e)
{
DataSet ds = new DataSet();
XmlReadMode mode = XmlReadMode.Auto;
if (radioButton1.Checked)
{
mode = XmlReadMode.Auto;
}
if (radioButton2.Checked)
{
mode = XmlReadMode.DiffGram;
}
if (radioButton3.Checked)
{
mode = XmlReadMode.Fragment;
}
if (radioButton4.Checked)
{
mode = XmlReadMode.IgnoreSchema;
}
if (radioButton5.Checked)
{
mode = XmlReadMode.InferSchema;
}
if (radioButton6.Checked)
{
mode = XmlReadMode.ReadSchema;
}
ds.ReadXml(textBox1.Text, mode);
MessageBox.Show("XML file read successfully!");
}
public XmlReadMode LoadData(XmlReader reader, XmlReadMode mode)
{
XmlReadMode Result = mode;
switch (mode)
{
case XmlReadMode.Auto:
Result = DSet.Tables.Count == 0 ? XmlReadMode.InferSchema : XmlReadMode.IgnoreSchema;
ReadModeSchema(reader, DSet.Tables.Count == 0 ? XmlReadMode.Auto : XmlReadMode.IgnoreSchema);
break;
case XmlReadMode.InferSchema:
Result = XmlReadMode.InferSchema;
ReadModeSchema(reader, mode);
break;
case XmlReadMode.IgnoreSchema:
Result = XmlReadMode.IgnoreSchema;
ReadModeSchema(reader, mode);
break;
default:
reader.Skip();
break;
}
return(Result);
}
/// <summary>
/// 将xml文件按照一定的模式格式化成DataSet
/// </summary>
/// <param name="fileName">xml文件名</param>
/// <param name="xmlReadMode">XmlReadMode</param>
/// <returns>DataSet格式数据</returns>
public static DataSet GetDataSet(string fileName, XmlReadMode xmlReadMode)
{
DataSet dataSet = new DataSet();
dataSet.ReadXml(fileName, xmlReadMode);
return(dataSet);
}
/// <summary>
///
/// </summary>
/// <param name="vWriteToLog"></param>
/// <param name="vFirstRunDone">This is the first time the app runs</param>
/// <returns></returns>
public DataSet ReadXML(String vSettingsFullPath)
{
DataSet output = new DataSet();
if (System.IO.File.Exists(vSettingsFullPath))
{
TextReader tr;
XmlTextReader reader;
tr = new StreamReader(vSettingsFullPath);
reader = new XmlTextReader(tr)
{
DtdProcessing = DtdProcessing.Prohibit
};
try
{
//XmlReadMode mode = output.ReadXml(settingsFullPath, XmlReadMode.ReadSchema);
XmlReadMode mode = output.ReadXml(reader, XmlReadMode.ReadSchema);
if (mode != XmlReadMode.ReadSchema)
{
//ErrorHandling.ProcessError(null, ErrorHandling.ErrorMessageType.XMLFileRead, true, false, string.Format(CultureInfo.InvariantCulture, ""), vSettingsFullPath);
//TODO: Error here
}
}
catch (FileLoadException ex)
{
//FileFunctions.WriteToLog(MainFunctions.GetErrorLogFullPath(Properties.Settings.Default.Portable), "Error 008: Settings file is corrupt, a new one will be created.", vWriteToLog);
//MessageBox.Show("Error reading settings file (" + settingsFullPath +").\n\n" + ex.Message.ToString(CultureInfo.InvariantCulture));
//MessageBox.Show("Your Settings file (" + settingsFullPath + ") is corrupt.\n\n A new one will be created.\n\nError: " + ex.Message, "Settings File Does Not Exist", MessageBoxButtons.OK, MessageBoxIcon.Warning);
//TODO: Error here
//ErrorHandling.ProcessError(ex, ErrorHandling.ErrorMessageType.ReadingSettingsXML, false, false, string.Format(CultureInfo.InvariantCulture, ""), vSettingsFullPath);
//throw;
}
catch (XmlException ex)
{
//TODO: Error here
//ErrorHandling.ProcessError(ex, ErrorHandling.ErrorMessageType.ReadingSettingsXML, false, false, string.Format(CultureInfo.InvariantCulture, ""), vSettingsFullPath);
output = null; // no xml file loaded!
}
finally
{
reader.Close();
//if (tr != null) tr.Close();
}
}
else
{
// dont log an error if this is the first time the app has run, and needs to create the settings file
//if (vFirstRunDone)
// ErrorHandling.ProcessError(null, ErrorHandling.ErrorMessageType.SettingsNotFound, false, false, string.Format(CultureInfo.InvariantCulture, ""), vSettingsFullPath);
//FileFunctions.WriteToLog(MainFunctions.GetErrorLogFullPath(Properties.Settings.Default.Portable), "Warning 001: Settings file not found, a new one will be created.", vWriteToLog);
//MessageBox.Show("This is your first time running LAWC.\n\n A new settings file will be created (" + settingsFullPath + ").", "Settings File Does Not Exist", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
return(output);
}
virtual public void FromXml(string xml, XmlReadMode mode)
{
DataSet dataSet = new DataSet();
StringReader reader = new StringReader(xml);
dataSet.ReadXml(reader, mode);
this.DataTable = dataSet.Tables[0];
dataSet.Tables.Clear();
}
public XmlReadMode ReadXml(Stream stream, XmlReadMode mode)
{
XmlReader reader = XmlReader.Create(stream);
this.Clear();
ReadXml(reader);
return(mode);
}
/// <summary>
/// 将xml文件流按照一定的模式格式化成DataSet
/// </summary>
/// <param name="stream">xml文件流</param>
/// <param name="xmlReadMode">XmlReadMode</param>
/// <returns>DataSet格式数据</returns>
public static DataSet GetDataSet(Stream stream, XmlReadMode xmlReadMode)
{
DataSet dataSet = new DataSet();
DataTable DT = new DataTable();
dataSet.ReadXml(stream, xmlReadMode);
return(dataSet);
}
public XmlReadMode ReadXml(TextReader reader, XmlReadMode mode)
{
if (reader is StreamReader)
{
StreamReader sreader = (StreamReader)reader;
return(ReadXml(sreader.BaseStream, mode));
}
throw new Exception($"{nameof(DataLake)} reader({reader.GetType().FullName}) is not {nameof(StreamReader)}");
}
private void btnSiguiente_Click(object sender, EventArgs e)
{
if (tbRespuesta.Text == 3)
{
this.Hide();
Form4 x = new Form4();
XmlReadMode.ShowDialog();
}
}
/// <summary>
/// XML字符串转成DataSet
/// </summary>
/// <param name="xml">xml字符串</param>
/// <param name="mode">指定如何将 XML 数据和关系架构读入 System.Data.DataSet</param>
/// <returns></returns>
public static DataSet XMLToDataSet(string xml, XmlReadMode mode)
{
DataSet ds = new DataSet();
using (MemoryStream stm = new MemoryStream())
{
byte[] buffer = System.Text.Encoding.UTF8.GetBytes(xml);
stm.Write(buffer, 0, buffer.Length);
stm.Position = 0;
ds.ReadXml(stm, mode);
}
return(ds);
}
private XmlDataInferenceLoader(DataSet ds, XmlDocument doc, XmlReadMode mode, string [] ignoredNamespaces)
{
dataset = ds;
document = doc;
this.mode = mode;
this.ignoredNamespaces = ignoredNamespaces != null ? new ArrayList(ignoredNamespaces) : new ArrayList();
// Fill existing table info
foreach (DataTable dt in dataset.Tables)
{
tables.Add(new TableMapping(dt));
}
}
public static DataSet LoadDataSetFromFile(string filename)
{
DataSet ds = new DataSet();
try
{
XmlReadMode xrm = ds.ReadXml(filename);
}
catch (Exception e)
{
MessageBox.Show("读取文件出错：" + e.Message);
}
return(ds);
}
public static DataTable LoadTableFromFile(string filename)
{
DataTable data = new DataTable();
try
{
XmlReadMode xrm = data.ReadXml(filename);
}
catch (Exception e)
{
MessageBox.Show("读取文件出错：" + e.Message);
}
return(data);
}
// a bit detailed version
public static void AssertReadXml(DataSet ds, string label, string xml, XmlReadMode readMode, XmlReadMode resultMode, string datasetName, int tableCount, ReadState state, string readerLocalName, string readerNS)
{
XmlReader xtr = new XmlTextReader(xml, XmlNodeType.Element, null);
Assert.Equal(resultMode, ds.ReadXml(xtr, readMode));
AssertDataSet(label + ".dataset", ds, datasetName, tableCount, -1);
Assert.Equal(state, xtr.ReadState);
if (readerLocalName != null)
{
Assert.Equal(readerLocalName, xtr.LocalName);
}
if (readerNS != null)
{
Assert.Equal(readerNS, xtr.NamespaceURI);
}
}
public void Load(string fileName, DataSet ds, XmlReadMode readMode = XmlReadMode.IgnoreSchema)
{
string ext = Path.GetExtension(fileName);
if (ext == ".xml")
{
ds.ReadXml(fileName, readMode);
FillCollections(ds);
}
else
{
throw new Exception(
"Сховище не підтримує завантаження "
+ "з файлу формату " + ext.ToUpper());
}
}
static public bool ReadPlog(String filename, DataTable messageTable, DataTable metaTable, out String lastError)
{
lastError = "";
if (!File.Exists(filename))
{
lastError = String.Format("Cannot find file: {0}", filename);
return(false);
}
// Чтение файла
String fullTableFilter = messageTable.DefaultView.RowFilter;
XmlReadMode readMode = XmlReadMode.Auto;
DataSet dataset = new DataSet();
dataset.Tables.Add(metaTable);
dataset.Tables.Add(messageTable);
readMode = dataset.ReadXml(filename);
dataset.Tables.Clear();
//При добавлении таблицы в DataSet у ней сбрасывается DataView
messageTable.DefaultView.RowFilter = fullTableFilter;
messageTable.DefaultView.AllowNew = false;
if (readMode == XmlReadMode.IgnoreSchema)
{
lastError = "Incorrect log format";
return(false);
}
// Проверка версии
int version = 0;
object plogVersion = metaTable.Rows[0][DataColumnNames.PlogVersion];
int.TryParse(plogVersion.ToString(), out version);
if (version <= 0 || version > DataTableUtils.PlogVersion)
{
lastError = "Incorrect version of plog-file";
return(false);
}
else if (version > 0 && version < DataTableUtils.PlogVersion)
{
DataTableUtils.UpgradePlog(messageTable, metaTable, filename);
}
return(true);
}
private void buttonGenDS_Click(object sender, EventArgs e)
{
string xml = _ctrlCSBMsg.GetXmlString();
if (string.IsNullOrEmpty(xml))
{
return;
}
MSG.Message msg = XObjectManager.CreateObject <MSG.Message>(xml);
if (msg == null)
{
MessageBox.Show(this, "Deserialize CSB DataSet Message failed. See the log file for details.", this.Text);
return;
}
try
{
DataSet ds = new DataSet();
XmlReadMode m = ds.ReadXml(XmlReader.Create(new StringReader(msg.Body)));
//MessageBox.Show(this, string.Format(
// "Data Set Name: {0}\r\n" +
// "Table Count: {1}\r\n" +
// "Row Count: {2}\r\n",
// ds.DataSetName,
// ds.Tables.Count,
// (ds.Tables.Count > 0) ? ds.Tables[0].Rows.Count : 0),
// m.ToString());
if (ds.Tables.Count > 0)
{
this.dataGridViewDS.DataSource = ds.Tables[0];
this.labelDSName.Text = ds.DataSetName + " (" + ds.Tables[0].Rows.Count + ")";
}
else
{
this.dataGridViewDS.DataSource = null;
this.labelDSName.Text = ds.DataSetName + " (0)";
}
}
catch (Exception err)
{
Program.Log.Write(err);
MessageBox.Show(this, "Deserialize DataSet XML failed. See the log file for details.\r\n\r\nMessage: " + err.Message, this.Text);
}
}
private DataSet GenerateCSBrokerDataSet(string csbDataSetXml)
{
try
{
_entity.Context.Log.Write("Begin deserialize CS Broker DataSet.");
DataSet ds = new DataSet();
XmlReadMode m = ds.ReadXml(XmlReader.Create(new StringReader(csbDataSetXml)));
_entity.Context.Log.Write(string.Format("Finish deserialize CS Broker DataSet. Name: {0}, RowCount: {1}, XmlReadMode: {2}.",
ds.DataSetName, ds.Tables.Count > 0 ? ds.Tables[0].Rows.Count : -1, m));
return(ds);
}
catch (Exception err)
{
_entity.Context.Log.Write(err);
return(null);
}
}
/// <summary>
/// 将指定的 XML 数据载入到 DataSet 中.
/// </summary>
/// <param name="dataSet">要载入数据的 DataSet.</param>
/// <param name="xmlFilePath">XML 文件路径.</param>
/// <param name="isClear">当指定 XML 文件存在时, 是否清空原有数据.</param>
/// <param name="mode">读取模式.</param>
public static void Load ( DataSet dataSet, string xmlFilePath, bool isClear, XmlReadMode mode )
#endif
{
try
{
if ( null == dataSet || string.IsNullOrEmpty ( xmlFilePath ) || !File.Exists ( xmlFilePath ) )
return;
if ( isClear )
dataSet.Clear ();
dataSet.ReadXml ( xmlFilePath, mode );
}
catch { }
}
public static List <T> GetKeyValueData <T>(string dataCategory) where T : class, new()
{
List <KeyValueDataAccessSetting> list = KeyValueDataAccessSettingManager.GetAllSettings();
KeyValueDataAccessSetting setting = list.Find(f => f.DataCategory.ToUpper().Trim() == dataCategory.Trim().ToUpper());
if (setting == null)
{
throw new NullReferenceException("没有找到" + dataCategory + "在KeyValueDataAccessSetting.config中的配置！");
}
if (!m_CacheData.ContainsKey(dataCategory.ToUpper().Trim()))
{
string xmlFileFullPath = Path.Combine(GetBaseFolderPath(), setting.DataCategoryPath, setting.DataCategory + ".xml");
if (!File.Exists(xmlFileFullPath))
{
return(null);
}
DataTable dt = null;
try
{
DataSet ds = new DataSet();
XmlReadMode mode = ds.ReadXml(xmlFileFullPath, XmlReadMode.ReadSchema);
dt = ds.Tables[0];
}
catch (Exception)
{
return(null);
}
if (dt != null)
{
List <T> tlist = BuildEntityListFromDataTable <T>(dt);
m_CacheData.Add(dataCategory.ToUpper().Trim(), tlist);
return(tlist);
}
return(null);
}
else
{
lock (m_SyncObj)
{
return((List <T>)m_CacheData[dataCategory.ToUpper().Trim()]);
}
}
}
internal static DataSet ImportWebsites(String vFilePath, String vSettingsFullPath)
{
//String settingsFullPath = MainFunctions.GetSettingsFullPath(); // Application.StartupPath + "\\" + vSettingsFilename; // read file from app path
DataSet output = new DataSet();
if (System.IO.File.Exists(vFilePath))
{
try
{
//XmlReadMode mode = output.ReadXml(vFilePath, XmlReadMode.ReadSchema);
TextReader tr = new StreamReader(vFilePath);
XmlTextReader reader = new XmlTextReader(tr)
{
DtdProcessing = DtdProcessing.Prohibit
};
XmlReadMode mode = output.ReadXml(reader, XmlReadMode.ReadSchema);
if (mode != XmlReadMode.ReadSchema)
{
ErrorHandling.ProcessError(null, ErrorHandling.ErrorMessageType.XMLFileRead, true, false, string.Format(CultureInfo.InvariantCulture, ""), vSettingsFullPath);
}
}
catch (IOException ex)
{
//FileFunctions.WriteToLog(MainFunctions.GetErrorLogFullPath(Properties.Settings.Default.Portable), "Error 008: Website List file is corrupt.", true);
//MessageBox.Show("Unable to read the XML file.\n\nError: " + ex.Message, "Import Websites Problem", MessageBoxButtons.OK, MessageBoxIcon.Warning);
ErrorHandling.ProcessError(ex, ErrorHandling.ErrorMessageType.XMLFileRead, true, false, string.Format(CultureInfo.InvariantCulture, ""), vSettingsFullPath);
//throw;
}
}
else
{
ErrorHandling.ProcessError(null, ErrorHandling.ErrorMessageType.WebsiteListNotFound, true, false, string.Format(CultureInfo.InvariantCulture, ""), vSettingsFullPath);
//FileFunctions.WriteToLog(MainFunctions.GetErrorLogFullPath(Properties.Settings.Default.Portable), "Warning 001: Website List file not found", true);
//MessageBox.Show("This is your first time running LAWC.\n\n A new settings file will be created (" + settingsFullPath + ").", "Settings File Does Not Exist", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
return(output);
}
/// <summary>
/// 从DataSet Xml 配置文件中获取 DataTable.
/// </summary>
/// <param name="file">完全限定路径配置文件。</param>
/// <returns>DataTable数据集。</returns>
public static DataTable LoadXmlDataTable(string file)
{
// if file does not exist, no log
if (!File.Exists(file))
{
return(null);
}
try
{
DataSet ds = new DataSet();
XmlReadMode mode = ds.ReadXml(file, XmlReadMode.ReadSchema);
return(ds.Tables[0]);
}
catch (Exception)
{
return(null);
}
}
/// <summary>
/// 将指定的 XML 数据载入到 DataSet 中.
/// </summary>
/// <param name="dataSet">要载入数据的 DataSet.</param>
/// <param name="xmlFilePath">XML 文件路径.</param>
/// <param name="isClear">当指定 XML 文件存在时, 是否清空原有数据.</param>
/// <param name="mode">读取模式.</param>
public static void Load(DataSet dataSet, string xmlFilePath, bool isClear, XmlReadMode mode)
#endif
{
try
{
if (null == dataSet || string.IsNullOrEmpty(xmlFilePath) || !File.Exists(xmlFilePath))
{
return;
}
if (isClear)
{
dataSet.Clear();
}
dataSet.ReadXml(xmlFilePath, mode);
}
catch { }
}
private void button1_Click(object sender, EventArgs e)
{
if (!System.IO.File.Exists(textBox1.Text))
{
MessageBox.Show("Invalid source file name");
return;
}
DataSet ds = new DataSet();
XmlReadMode mode = XmlReadMode.Auto;
if (radioButton1.Checked)
{
mode = XmlReadMode.Auto;
}
if (radioButton2.Checked)
{
mode = XmlReadMode.DiffGram;
}
if (radioButton3.Checked)
{
mode = XmlReadMode.Fragment;
}
if (radioButton4.Checked)
{
mode = XmlReadMode.IgnoreSchema;
}
if (radioButton5.Checked)
{
mode = XmlReadMode.InferSchema;
}
if (radioButton6.Checked)
{
mode = XmlReadMode.ReadSchema;
}
ds.ReadXml(textBox1.Text, mode);
MessageBox.Show("XML file read successfully!");
}
public XmlReadMode LoadData (XmlReader reader, XmlReadMode mode)
{
XmlReadMode Result = mode;
switch (mode) {
case XmlReadMode.Auto:
Result = DSet.Tables.Count == 0 ? XmlReadMode.InferSchema : XmlReadMode.IgnoreSchema;
ReadModeSchema (reader, DSet.Tables.Count == 0 ? XmlReadMode.Auto : XmlReadMode.IgnoreSchema);
break;
case XmlReadMode.InferSchema:
Result = XmlReadMode.InferSchema;
ReadModeSchema (reader, mode);
break;
case XmlReadMode.IgnoreSchema:
Result = XmlReadMode.IgnoreSchema;
ReadModeSchema (reader, mode);
break;
default:
reader.Skip ();
break;
}
return Result;
}
// ***************************************************************************
// ***************************************************************************
// Read and display the specified XML file and loads it into a DataSet
void LoadAndDisplay(string fileName)
{
// Display the XML source in a textbox
StreamReader fr = new StreamReader(fileName);
Data.Text = fr.ReadToEnd();
fr.Close();
// Load a DataSet
XmlReadMode mode = (XmlReadMode)Enum.Parse(typeof(XmlReadMode), ReadMode.SelectedItem.ToString());
DataSet ds = new DataSet();
XmlReadMode used = ds.ReadXml(fileName, mode);
// Show the DataSet
grid.DataSource = ds;
ModeUsed.Text = "Used \"" + used.ToString() + "\"";
// Show the recognized (and used) schema
StringWriter writer = new StringWriter();
ds.WriteXmlSchema(writer);
FinalSchema.Text = writer.ToString();
writer.Close();
}
internal void InferSchema(XmlDocument xdoc, string[] excludedNamespaces, XmlReadMode mode)
{
IntPtr ptr;
Bid.ScopeEnter(out ptr, "<ds.DataSet.InferSchema|INFO> %d#, mode=%d{ds.XmlReadMode}\n", this.ObjectID, (int) mode);
try
{
string namespaceURI = xdoc.DocumentElement.NamespaceURI;
if (excludedNamespaces == null)
{
excludedNamespaces = new string[0];
}
XmlNodeReader instanceDocument = new XmlIgnoreNamespaceReader(xdoc, excludedNamespaces);
XmlSchemaInference inference = new XmlSchemaInference {
Occurrence = XmlSchemaInference.InferenceOption.Relaxed
};
if (mode == XmlReadMode.InferTypedSchema)
{
inference.TypeInference = XmlSchemaInference.InferenceOption.Restricted;
}
else
{
inference.TypeInference = XmlSchemaInference.InferenceOption.Relaxed;
}
XmlSchemaSet schemaSet = inference.InferSchema(instanceDocument);
schemaSet.Compile();
XSDSchema schema = new XSDSchema {
FromInference = true
};
try
{
schema.LoadSchema(schemaSet, this);
}
finally
{
schema.FromInference = false;
}
}
finally
{
Bid.ScopeLeave(ref ptr);
}
}
public XmlReadMode ReadXml(XmlReader reader, XmlReadMode mode)
{
return this.ReadXml(reader, mode, false);
}
internal XmlReadMode ReadXml(XmlReader reader, XmlReadMode mode, bool denyResolving)
{
XmlReadMode mode3;
IntPtr ptr;
Bid.ScopeEnter(out ptr, "<ds.DataSet.ReadXml|INFO> %d#, mode=%d{ds.XmlReadMode}, denyResolving=%d{bool}\n", this.ObjectID, (int) mode, denyResolving);
try
{
bool flag2 = false;
bool flag3 = false;
bool isXdr = false;
int depth = -1;
XmlReadMode diffGram = mode;
if (reader == null)
{
return diffGram;
}
if (mode == XmlReadMode.Auto)
{
return this.ReadXml(reader);
}
if (reader is XmlTextReader)
{
((XmlTextReader) reader).WhitespaceHandling = WhitespaceHandling.Significant;
}
XmlDocument xdoc = new XmlDocument();
if ((mode != XmlReadMode.Fragment) && (reader.NodeType == XmlNodeType.Element))
{
depth = reader.Depth;
}
reader.MoveToContent();
XmlDataLoader loader = null;
if (reader.NodeType == XmlNodeType.Element)
{
XmlElement topNode = null;
if (mode == XmlReadMode.Fragment)
{
xdoc.AppendChild(xdoc.CreateElement("ds_sqlXmlWraPPeR"));
topNode = xdoc.DocumentElement;
}
else
{
if ((reader.LocalName == "diffgram") && (reader.NamespaceURI == "urn:schemas-microsoft-com:xml-diffgram-v1"))
{
if ((mode == XmlReadMode.DiffGram) || (mode == XmlReadMode.IgnoreSchema))
{
this.ReadXmlDiffgram(reader);
this.ReadEndElement(reader);
return diffGram;
}
reader.Skip();
return diffGram;
}
if ((reader.LocalName == "Schema") && (reader.NamespaceURI == "urn:schemas-microsoft-com:xml-data"))
{
if (((mode != XmlReadMode.IgnoreSchema) && (mode != XmlReadMode.InferSchema)) && (mode != XmlReadMode.InferTypedSchema))
{
this.ReadXDRSchema(reader);
return diffGram;
}
reader.Skip();
return diffGram;
}
if ((reader.LocalName == "schema") && (reader.NamespaceURI == "http://www.w3.org/2001/XMLSchema"))
{
if (((mode != XmlReadMode.IgnoreSchema) && (mode != XmlReadMode.InferSchema)) && (mode != XmlReadMode.InferTypedSchema))
{
this.ReadXSDSchema(reader, denyResolving);
return diffGram;
}
reader.Skip();
return diffGram;
}
if ((reader.LocalName == "schema") && reader.NamespaceURI.StartsWith("http://www.w3.org/", StringComparison.Ordinal))
{
throw ExceptionBuilder.DataSetUnsupportedSchema("http://www.w3.org/2001/XMLSchema");
}
topNode = xdoc.CreateElement(reader.Prefix, reader.LocalName, reader.NamespaceURI);
if (reader.HasAttributes)
{
int attributeCount = reader.AttributeCount;
for (int i = 0; i < attributeCount; i++)
{
reader.MoveToAttribute(i);
if (reader.NamespaceURI.Equals("http://www.w3.org/2000/xmlns/"))
{
topNode.SetAttribute(reader.Name, reader.GetAttribute(i));
}
else
{
XmlAttribute attribute = topNode.SetAttributeNode(reader.LocalName, reader.NamespaceURI);
attribute.Prefix = reader.Prefix;
attribute.Value = reader.GetAttribute(i);
}
}
}
reader.Read();
}
while (this.MoveToElement(reader, depth))
{
if ((reader.LocalName == "Schema") && (reader.NamespaceURI == "urn:schemas-microsoft-com:xml-data"))
{
if (((!flag2 && !flag3) && ((mode != XmlReadMode.IgnoreSchema) && (mode != XmlReadMode.InferSchema))) && (mode != XmlReadMode.InferTypedSchema))
{
this.ReadXDRSchema(reader);
flag2 = true;
isXdr = true;
}
else
{
reader.Skip();
}
}
else
{
if ((reader.LocalName == "schema") && (reader.NamespaceURI == "http://www.w3.org/2001/XMLSchema"))
{
if (((mode != XmlReadMode.IgnoreSchema) && (mode != XmlReadMode.InferSchema)) && (mode != XmlReadMode.InferTypedSchema))
{
this.ReadXSDSchema(reader, denyResolving);
flag2 = true;
}
else
{
reader.Skip();
}
continue;
}
if ((reader.LocalName == "diffgram") && (reader.NamespaceURI == "urn:schemas-microsoft-com:xml-diffgram-v1"))
{
if ((mode == XmlReadMode.DiffGram) || (mode == XmlReadMode.IgnoreSchema))
{
this.ReadXmlDiffgram(reader);
diffGram = XmlReadMode.DiffGram;
}
else
{
reader.Skip();
}
continue;
}
if ((reader.LocalName == "schema") && reader.NamespaceURI.StartsWith("http://www.w3.org/", StringComparison.Ordinal))
{
throw ExceptionBuilder.DataSetUnsupportedSchema("http://www.w3.org/2001/XMLSchema");
}
if (mode == XmlReadMode.DiffGram)
{
reader.Skip();
}
else
{
flag3 = true;
if ((mode == XmlReadMode.InferSchema) || (mode == XmlReadMode.InferTypedSchema))
{
XmlNode newChild = xdoc.ReadNode(reader);
topNode.AppendChild(newChild);
continue;
}
if (loader == null)
{
loader = new XmlDataLoader(this, isXdr, topNode, mode == XmlReadMode.IgnoreSchema);
}
loader.LoadData(reader);
}
}
}
this.ReadEndElement(reader);
xdoc.AppendChild(topNode);
if (loader == null)
{
loader = new XmlDataLoader(this, isXdr, mode == XmlReadMode.IgnoreSchema);
}
if (mode == XmlReadMode.DiffGram)
{
return diffGram;
}
if ((mode == XmlReadMode.InferSchema) || (mode == XmlReadMode.InferTypedSchema))
{
this.InferSchema(xdoc, null, mode);
diffGram = XmlReadMode.InferSchema;
loader.FromInference = true;
try
{
loader.LoadData(xdoc);
}
finally
{
loader.FromInference = false;
}
}
}
mode3 = diffGram;
}
finally
{
Bid.ScopeLeave(ref ptr);
}
return mode3;
}
private XmlReadMode ReadXmlReadSchema (XmlReader input, XmlReadMode mode, bool checkRecurse)
{
if (input.LocalName == "schema" &&
input.NamespaceURI == XmlSchema.Namespace) {
ReadXmlSchema (input);
}
else if (checkRecurse && !input.IsEmptyElement) {
int depth = input.Depth;
input.Read ();
input.MoveToContent ();
ReadXmlReadSchema (input, mode, false);
while (input.Depth > depth)
input.Skip ();
if (input.NodeType == XmlNodeType.EndElement)
input.ReadEndElement ();
}
else
input.Skip ();
input.MoveToContent ();
return XmlReadMode.ReadSchema;
}
private XmlDataInferenceLoader (DataSet ds, XmlDocument doc, XmlReadMode mode, string [] ignoredNamespaces)
{
dataset = ds;
document = doc;
this.mode = mode;
this.ignoredNamespaces = ignoredNamespaces != null ? new ArrayList (ignoredNamespaces) : new ArrayList ();
// Fill existing table info
foreach (DataTable dt in dataset.Tables)
tables.Add (new TableMapping (dt));
}
public XmlReadMode ReadXml (TextReader reader, XmlReadMode mode)
{
return ReadXml (new XmlTextReader (reader), mode);
}
public static void ReadXml (
DataSet dataset, XmlReader reader, XmlReadMode mode)
{
new XmlDataReader (dataset, reader, mode).Process ();
}
/// <devdoc>
/// </devdoc>
public XmlReadMode ReadXml(Stream stream, XmlReadMode mode)
{
if (stream == null)
return XmlReadMode.Auto;
XmlTextReader reader = (mode == XmlReadMode.Fragment) ? new XmlTextReader(stream, XmlNodeType.Element, null) : new XmlTextReader(stream);
// Prevent Dtd entity in dataset
reader.XmlResolver = null;
return ReadXml(reader, mode, false);
}
public void AssertReadXml (DataSet ds, string label, string xml, XmlReadMode readMode, XmlReadMode resultMode, string datasetName, int tableCount, ReadState state)
{
AssertReadXml (ds, label, xml, readMode, resultMode, datasetName, tableCount, state, null, null);
}
internal XmlReadMode ReadXml(XmlReader reader, XmlReadMode mode, bool denyResolving)
{
IntPtr hscp;
Bid.ScopeEnter(out hscp, "<ds.DataSet.ReadXml|INFO> %d#, mode=%d{ds.XmlReadMode}, denyResolving=%d{bool}\n", ObjectID, (int)mode, denyResolving);
try {
XmlReadMode ret = mode;
if (reader == null)
return ret;
if (mode == XmlReadMode.Auto) {
// Dev11 915079: nested ReadXml calls on the same DataSet must be done outside of RowDiffIdUsage scope
return ReadXml(reader);
}
DataTable.DSRowDiffIdUsageSection rowDiffIdUsage = new DataTable.DSRowDiffIdUsageSection();
try {
bool fSchemaFound = false;
bool fDataFound = false;
bool fIsXdr = false;
int iCurrentDepth = -1;
// Dev11 904428: prepare and cleanup rowDiffId hashtable
rowDiffIdUsage.Prepare(this);
if (reader is XmlTextReader)
((XmlTextReader)reader).WhitespaceHandling = WhitespaceHandling.Significant;
XmlDocument xdoc = new XmlDocument(); // we may need this to infer the schema
if ((mode != XmlReadMode.Fragment) && (reader.NodeType == XmlNodeType.Element))
iCurrentDepth = reader.Depth;
reader.MoveToContent();
XmlDataLoader xmlload = null;
if (reader.NodeType == XmlNodeType.Element) {
XmlElement topNode = null;
if (mode == XmlReadMode.Fragment) {
xdoc.AppendChild(xdoc.CreateElement("ds_sqlXmlWraPPeR"));
topNode = xdoc.DocumentElement;
}
else { //handle the top node
if ((reader.LocalName == Keywords.DIFFGRAM) && (reader.NamespaceURI == Keywords.DFFNS)) {
if ((mode == XmlReadMode.DiffGram) || (mode == XmlReadMode.IgnoreSchema)) {
this.ReadXmlDiffgram(reader);
// read the closing tag of the current element
ReadEndElement(reader);
}
else {
reader.Skip();
}
return ret;
}
if (reader.LocalName == Keywords.XDR_SCHEMA && reader.NamespaceURI == Keywords.XDRNS) {
// load XDR schema and exit
if ((mode != XmlReadMode.IgnoreSchema) && (mode != XmlReadMode.InferSchema) &&
(mode != XmlReadMode.InferTypedSchema))
{
ReadXDRSchema(reader);
}
else {
reader.Skip();
}
return ret; //since the top level element is a schema return
}
if (reader.LocalName == Keywords.XSD_SCHEMA && reader.NamespaceURI == Keywords.XSDNS) {
// load XSD schema and exit
if ((mode != XmlReadMode.IgnoreSchema) && (mode != XmlReadMode.InferSchema) &&
(mode != XmlReadMode.InferTypedSchema))
{
ReadXSDSchema(reader, denyResolving);
}
else
reader.Skip();
return ret; //since the top level element is a schema return
}
if (reader.LocalName == Keywords.XSD_SCHEMA && reader.NamespaceURI.StartsWith(Keywords.XSD_NS_START, StringComparison.Ordinal))
throw ExceptionBuilder.DataSetUnsupportedSchema(Keywords.XSDNS);
// now either the top level node is a table and we load it through dataReader...
// ... or backup the top node and all its attributes
topNode = xdoc.CreateElement(reader.Prefix, reader.LocalName, reader.NamespaceURI);
if (reader.HasAttributes) {
int attrCount = reader.AttributeCount;
for (int i = 0; i < attrCount; i++) {
reader.MoveToAttribute(i);
if (reader.NamespaceURI.Equals(Keywords.XSD_XMLNS_NS))
topNode.SetAttribute(reader.Name, reader.GetAttribute(i));
else {
XmlAttribute attr = topNode.SetAttributeNode(reader.LocalName, reader.NamespaceURI);
attr.Prefix = reader.Prefix;
attr.Value = reader.GetAttribute(i);
}
}
}
reader.Read();
}
while (MoveToElement(reader, iCurrentDepth)) {
if (reader.LocalName == Keywords.XDR_SCHEMA && reader.NamespaceURI == Keywords.XDRNS) {
// load XDR schema
if (!fSchemaFound && !fDataFound && (mode != XmlReadMode.IgnoreSchema) && (mode != XmlReadMode.InferSchema) &&
(mode != XmlReadMode.InferTypedSchema))
{
ReadXDRSchema(reader);
fSchemaFound = true;
fIsXdr = true;
}
else {
reader.Skip();
}
continue;
}
if (reader.LocalName == Keywords.XSD_SCHEMA && reader.NamespaceURI == Keywords.XSDNS) {
// load XSD schema and exit
if ((mode != XmlReadMode.IgnoreSchema) && (mode != XmlReadMode.InferSchema) &&
(mode != XmlReadMode.InferTypedSchema))
{
ReadXSDSchema(reader, denyResolving);
fSchemaFound = true;
}
else {
reader.Skip();
}
continue;
}
if ((reader.LocalName == Keywords.DIFFGRAM) && (reader.NamespaceURI == Keywords.DFFNS)) {
if ((mode == XmlReadMode.DiffGram) || (mode == XmlReadMode.IgnoreSchema)) {
this.ReadXmlDiffgram(reader);
ret = XmlReadMode.DiffGram;
}
else {
reader.Skip();
}
continue;
}
if (reader.LocalName == Keywords.XSD_SCHEMA && reader.NamespaceURI.StartsWith(Keywords.XSD_NS_START, StringComparison.Ordinal))
throw ExceptionBuilder.DataSetUnsupportedSchema(Keywords.XSDNS);
if (mode == XmlReadMode.DiffGram) {
reader.Skip();
continue; // we do not read data in diffgram mode
}
// if we are here we found some data
fDataFound = true;
if (mode == XmlReadMode.InferSchema || mode == XmlReadMode.InferTypedSchema) { //save the node in DOM until the end;
XmlNode node = xdoc.ReadNode(reader);
topNode.AppendChild(node);
}
else {
if (xmlload == null)
xmlload = new XmlDataLoader(this, fIsXdr, topNode, mode == XmlReadMode.IgnoreSchema);
xmlload.LoadData(reader);
}
} //end of the while
// read the closing tag of the current element
ReadEndElement(reader);
// now top node contains the data part
xdoc.AppendChild(topNode);
if (xmlload == null)
xmlload = new XmlDataLoader(this, fIsXdr, mode == XmlReadMode.IgnoreSchema);
if (mode == XmlReadMode.DiffGram) {
// we already got the diffs through XmlReader interface
return ret;
}
// Load Data
if (mode == XmlReadMode.InferSchema || mode == XmlReadMode.InferTypedSchema) {
InferSchema(xdoc, null, mode);
ret = XmlReadMode.InferSchema;
xmlload.FromInference = true;
// }
try {
xmlload.LoadData(xdoc);
}
finally {
xmlload.FromInference = false;
}
}
}
return ret;
}
finally {
// Dev11 904428: prepare and cleanup rowDiffId hashtable
rowDiffIdUsage.Cleanup();
}
}
finally {
Bid.ScopeLeave(ref hscp);
}
}
public XmlDataReader (DataSet ds, XmlReader xr, XmlReadMode m)
{
dataset = ds;
reader =xr;
mode = m;
}
internal void InferSchema(XmlDocument xdoc, string[] excludedNamespaces, XmlReadMode mode) {
IntPtr hscp;
Bid.ScopeEnter(out hscp, "<ds.DataSet.InferSchema|INFO> %d#, mode=%d{ds.XmlReadMode}\n", ObjectID, (int)mode);
try {
string ns = xdoc.DocumentElement.NamespaceURI;
if (null == excludedNamespaces) {
excludedNamespaces = new string[0];
}
XmlNodeReader xnr = new XmlIgnoreNamespaceReader(xdoc, excludedNamespaces);
System.Xml.Schema.XmlSchemaInference infer = new System.Xml.Schema.XmlSchemaInference();
infer.Occurrence = XmlSchemaInference.InferenceOption.Relaxed;
if (mode == XmlReadMode.InferTypedSchema)
infer.TypeInference = XmlSchemaInference.InferenceOption.Restricted;
else
infer.TypeInference = XmlSchemaInference.InferenceOption.Relaxed;
XmlSchemaSet schemaSet = infer.InferSchema(xnr);
schemaSet.Compile();
XSDSchema schema = new XSDSchema();
schema.FromInference = true;
try {
schema.LoadSchema(schemaSet, this);
}
finally {
schema.FromInference = false; // this is always false if you are not calling fron inference
}
}
finally {
Bid.ScopeLeave(ref hscp);
}
}
public static void Infer (DataSet dataset, XmlDocument document, XmlReadMode mode, string [] ignoredNamespaces)
{
new XmlDataInferenceLoader (dataset, document, mode, ignoredNamespaces).ReadXml ();
}
// LAMESPEC: XmlReadMode.Fragment is far from presisely
// documented. MS.NET infers schema against this mode.
public XmlReadMode ReadXml (XmlReader input, XmlReadMode mode)
{
switch (input.ReadState) {
case ReadState.EndOfFile:
case ReadState.Error:
case ReadState.Closed:
return mode;
}
// Skip XML declaration and prolog
input.MoveToContent ();
if (input.EOF)
return mode;
// FIXME: We need more decent code here, but for now
// I don't know the precise MS.NET behavior, I just
// delegate to specific read process.
switch (mode) {
case XmlReadMode.IgnoreSchema:
return ReadXmlIgnoreSchema (input, mode, true);
case XmlReadMode.ReadSchema:
return ReadXmlReadSchema (input, mode, true);
}
// remaining modes are: Auto, InferSchema, Fragment, Diffgram
XmlReader reader = input;
int depth = reader.Depth;
XmlReadMode result = mode;
bool skippedTopLevelElement = false;
string potentialDataSetName = null;
XmlDocument doc = null;
bool shouldReadData = mode != XmlReadMode.DiffGram;
bool shouldNotInfer = Tables.Count > 0;
switch (mode) {
case XmlReadMode.Auto:
case XmlReadMode.InferSchema:
doc = new XmlDocument ();
do {
doc.AppendChild (doc.ReadNode (reader));
} while (!reader.EOF &&
doc.DocumentElement == null);
reader = new XmlNodeReader (doc);
reader.MoveToContent ();
break;
case XmlReadMode.DiffGram:
if (!(reader.LocalName == "diffgram" &&
reader.NamespaceURI == XmlConstants.DiffgrNamespace))
goto case XmlReadMode.Auto;
break;
}
switch (mode) {
case XmlReadMode.Auto:
case XmlReadMode.InferSchema:
case XmlReadMode.ReadSchema:
if (!(reader.LocalName == "diffgram" &&
reader.NamespaceURI == XmlConstants.DiffgrNamespace) &&
!(reader.LocalName == "schema" &&
reader.NamespaceURI == XmlSchema.Namespace))
potentialDataSetName = reader.LocalName;
goto default;
case XmlReadMode.Fragment:
break;
default:
if (!(reader.LocalName == "diffgram" &&
reader.NamespaceURI == XmlConstants.DiffgrNamespace) &&
!(reader.LocalName == "schema" &&
reader.NamespaceURI == XmlSchema.Namespace)) {
if (!reader.IsEmptyElement) {
reader.Read ();
reader.MoveToContent ();
skippedTopLevelElement = true;
}
else {
switch (mode) {
case XmlReadMode.Auto:
case XmlReadMode.InferSchema:
DataSetName = reader.LocalName;
break;
}
reader.Read ();
}
}
break;
}
// If schema, then read the first element as schema
if (reader.LocalName == "schema" && reader.NamespaceURI == XmlSchema.Namespace) {
shouldNotInfer = true;
switch (mode) {
case XmlReadMode.IgnoreSchema:
case XmlReadMode.InferSchema:
reader.Skip ();
break;
case XmlReadMode.Fragment:
ReadXmlSchema (reader);
break;
case XmlReadMode.DiffGram:
case XmlReadMode.Auto:
if (Tables.Count == 0) {
ReadXmlSchema (reader);
if (mode == XmlReadMode.Auto)
result = XmlReadMode.ReadSchema;
} else {
// otherwise just ignore and return IgnoreSchema
reader.Skip ();
result = XmlReadMode.IgnoreSchema;
}
break;
case XmlReadMode.ReadSchema:
ReadXmlSchema (reader);
break;
}
}
// If diffgram, then read the first element as diffgram
if (reader.LocalName == "diffgram" && reader.NamespaceURI == XmlConstants.DiffgrNamespace) {
switch (mode) {
case XmlReadMode.Auto:
case XmlReadMode.IgnoreSchema:
case XmlReadMode.DiffGram:
XmlDiffLoader DiffLoader = new XmlDiffLoader (this);
DiffLoader.Load (reader);
if (mode == XmlReadMode.Auto)
result = XmlReadMode.DiffGram;
shouldReadData = false;
break;
case XmlReadMode.Fragment:
reader.Skip ();
break;
default:
reader.Skip ();
break;
}
}
// if schema after diffgram, just skip it.
if (!shouldReadData && reader.LocalName == "schema" && reader.NamespaceURI == XmlSchema.Namespace) {
shouldNotInfer = true;
switch (mode) {
default:
reader.Skip ();
break;
case XmlReadMode.ReadSchema:
case XmlReadMode.DiffGram:
if (Tables.Count == 0)
ReadXmlSchema (reader);
break;
}
}
if (reader.EOF)
return result == XmlReadMode.Auto ?
potentialDataSetName != null && !shouldNotInfer ?
XmlReadMode.InferSchema :
XmlReadMode.IgnoreSchema : result;
// Otherwise, read as dataset... but only when required.
if (shouldReadData && !shouldNotInfer) {
switch (mode) {
case XmlReadMode.Auto:
if (Tables.Count > 0)
goto case XmlReadMode.IgnoreSchema;
else
goto case XmlReadMode.InferSchema;
case XmlReadMode.InferSchema:
InferXmlSchema (doc, null);
if (mode == XmlReadMode.Auto)
result = XmlReadMode.InferSchema;
break;
case XmlReadMode.IgnoreSchema:
case XmlReadMode.Fragment:
case XmlReadMode.DiffGram:
break;
default:
shouldReadData = false;
break;
}
}
if (shouldReadData) {
XmlReader dataReader = reader;
if (doc != null) {
dataReader = new XmlNodeReader (doc);
dataReader.MoveToContent ();
}
if (reader.NodeType == XmlNodeType.Element)
XmlDataReader.ReadXml (this, dataReader,
mode);
}
if (skippedTopLevelElement) {
switch (result) {
case XmlReadMode.Auto:
case XmlReadMode.InferSchema:
// DataSetName = potentialDataSetName;
// result = XmlReadMode.InferSchema;
break;
}
if (reader.NodeType == XmlNodeType.EndElement)
reader.ReadEndElement ();
}
//*
while (input.Depth > depth)
input.Read ();
if (input.NodeType == XmlNodeType.EndElement)
input.Read ();
//*/
input.MoveToContent ();
return result == XmlReadMode.Auto ?
XmlReadMode.IgnoreSchema : result;
}
public XmlReadMode ReadXml (Stream stream, XmlReadMode mode)
{
return ReadXml (new XmlTextReader (stream), mode);
}
// a bit detailed version
public void AssertReadXml (DataSet ds, string label, string xml, XmlReadMode readMode, XmlReadMode resultMode, string datasetName, int tableCount, ReadState state, string readerLocalName, string readerNS)
{
XmlReader xtr = new XmlTextReader (xml, XmlNodeType.Element, null);
AssertEquals (label + ".return", resultMode, ds.ReadXml (xtr, readMode));
AssertDataSet (label + ".dataset", ds, datasetName, tableCount, -1);
AssertEquals (label + ".readstate", state, xtr.ReadState);
if (readerLocalName != null)
AssertEquals (label + ".reader-localName",
readerLocalName, xtr.LocalName);
if (readerNS != null)
AssertEquals (label + ".reader-ns", readerNS, xtr.NamespaceURI);
}
public XmlReadMode ReadXml (string fileName, XmlReadMode mode)
{
XmlTextReader reader = new XmlTextReader (fileName);
try {
return ReadXml (reader, mode);
} finally {
reader.Close ();
}
}
// Read information from the reader.
private void ReadModeSchema (XmlReader reader, XmlReadMode mode)
{
bool inferSchema = mode == XmlReadMode.InferSchema || mode == XmlReadMode.Auto;
bool fillRows = mode != XmlReadMode.InferSchema;
// This check is required for full DiffGram.
// It is not described in MSDN and it is impossible
// with WriteXml(), but when writing XML using
// XmlSerializer, the output is like this:
// <dataset>
// <schema>...</schema>
// <diffgram>...</diffgram>
// </dataset>
//
// FIXME: This, this check should (also) be done
// after reading the top-level element.
//check if the current element is schema.
if (reader.LocalName == "schema") {
if (mode != XmlReadMode.Auto)
reader.Skip(); // skip the schema node.
else
DSet.ReadXmlSchema(reader);
reader.MoveToContent();
}
// load an XmlDocument from the reader.
XmlDocument doc = new XmlDocument ();
doc.Load (reader);
if (doc.DocumentElement == null)
return;
// treatment for .net compliancy :
// if xml representing dataset has exactly depth of 2 elements,
// than the root element actually represents datatable and not dataset
// so we add new root element to doc
// in order to create an element representing dataset.
//
// FIXME: Consider attributes.
// <root a='1' b='2' /> is regarded as a valid DataTable.
int rootNodeDepth = XmlNodeElementsDepth(doc.DocumentElement);
switch (rootNodeDepth) {
case 1:
if (inferSchema) {
DSet.DataSetName = doc.DocumentElement.LocalName;
DSet.Prefix = doc.DocumentElement.Prefix;
DSet.Namespace = doc.DocumentElement.NamespaceURI;
}
return;
case 2:
// create new document
XmlDocument newDoc = new XmlDocument();
// create element for dataset
XmlElement datasetElement = newDoc.CreateElement("dummy");
// make the new created element to be the new doc root
newDoc.AppendChild(datasetElement);
// import all the elements from doc and insert them into new doc
XmlNode root = newDoc.ImportNode(doc.DocumentElement,true);
datasetElement.AppendChild(root);
doc = newDoc;
break;
default:
if (inferSchema) {
DSet.DataSetName = doc.DocumentElement.LocalName;
DSet.Prefix = doc.DocumentElement.Prefix;
DSet.Namespace = doc.DocumentElement.NamespaceURI;
}
break;
}
// set EnforceConstraint to false - we do not want any validation during
// load time.
bool origEnforceConstraint = DSet.EnforceConstraints;
DSet.EnforceConstraints = false;
// The childs are tables.
XmlNodeList nList = doc.DocumentElement.ChildNodes;
// FIXME: When reading DataTable (not DataSet),
// the nodes are column items, not rows.
for (int i = 0; i < nList.Count; i++) {
XmlNode node = nList[i];
// node represents a table onky if it is of type XmlNodeType.Element
if (node.NodeType == XmlNodeType.Element) {
AddRowToTable(node, null, inferSchema, fillRows);
}
}
// set the EnforceConstraints to original value;
DSet.EnforceConstraints = origEnforceConstraint;
}
// LAMESPEC: XmlReadMode.Fragment is far from presisely
// documented. MS.NET infers schema against this mode.
public XmlReadMode ReadXml (XmlReader reader, XmlReadMode mode)
{
if (reader == null)
return mode;
switch (reader.ReadState) {
case ReadState.EndOfFile:
case ReadState.Error:
case ReadState.Closed:
return mode;
}
// Skip XML declaration and prolog
reader.MoveToContent ();
if (reader.EOF)
return mode;
if (reader is XmlTextReader) {
// we dont need whitespace
((XmlTextReader) reader).WhitespaceHandling = WhitespaceHandling.None;
}
XmlDiffLoader DiffLoader = null;
// If diffgram, then read the first element as diffgram
if (reader.LocalName == "diffgram" && reader.NamespaceURI == XmlConstants.DiffgrNamespace) {
switch (mode) {
case XmlReadMode.Auto:
case XmlReadMode.DiffGram:
if (DiffLoader == null)
DiffLoader = new XmlDiffLoader (this);
DiffLoader.Load (reader);
// (and leave rest of the reader as is)
return XmlReadMode.DiffGram;
case XmlReadMode.Fragment:
reader.Skip ();
// (and continue to read)
break;
default:
reader.Skip ();
// (and leave rest of the reader as is)
return mode;
}
}
// If schema, then read the first element as schema
if (reader.LocalName == "schema" && reader.NamespaceURI == XmlSchema.Namespace) {
switch (mode) {
case XmlReadMode.IgnoreSchema:
case XmlReadMode.InferSchema:
reader.Skip ();
// (and break up read)
return mode;
case XmlReadMode.Fragment:
ReadXmlSchema (reader);
// (and continue to read)
break;
case XmlReadMode.Auto:
if (Tables.Count == 0) {
ReadXmlSchema (reader);
return XmlReadMode.ReadSchema;
} else {
// otherwise just ignore and return IgnoreSchema
reader.Skip ();
return XmlReadMode.IgnoreSchema;
}
default:
ReadXmlSchema (reader);
// (and leave rest of the reader as is)
return mode; // When DiffGram, return DiffGram
}
}
if (reader.EOF)
return mode;
int depth = (reader.NodeType == XmlNodeType.Element) ? reader.Depth : -1;
XmlDocument doc = new XmlDocument ();
XmlElement root = doc.CreateElement(reader.Prefix, reader.LocalName, reader.NamespaceURI);
if (reader.HasAttributes) {
for (int i = 0; i < reader.AttributeCount; i++) {
reader.MoveToAttribute(i);
if (reader.NamespaceURI == XmlConstants.XmlnsNS)
root.SetAttribute(reader.Name, reader.GetAttribute(i));
else {
XmlAttribute attr = root.SetAttributeNode(reader.LocalName, reader.NamespaceURI);
attr.Prefix = reader.Prefix;
attr.Value = reader.GetAttribute(i);
}
}
}
reader.Read();
XmlReadMode retMode = mode;
bool schemaLoaded = false;
for (;;) {
if( reader.Depth == depth ||
reader.NodeType == XmlNodeType.EndElement)
break;
if (reader.NodeType != XmlNodeType.Element) {
if (!reader.Read())
break;
continue;
}
if (reader.LocalName == "schema" && reader.NamespaceURI == XmlSchema.Namespace) {
switch (mode) {
case XmlReadMode.IgnoreSchema:
case XmlReadMode.InferSchema:
reader.Skip ();
break;
default:
ReadXmlSchema (reader);
retMode = XmlReadMode.ReadSchema;
schemaLoaded = true;
// (and leave rest of the reader as is)
break;
}
continue;
}
if ((reader.LocalName == "diffgram") && (reader.NamespaceURI == XmlConstants.DiffgrNamespace)) {
if ((mode == XmlReadMode.DiffGram) || (mode == XmlReadMode.IgnoreSchema)
|| mode == XmlReadMode.Auto) {
if (DiffLoader == null)
DiffLoader = new XmlDiffLoader (this);
DiffLoader.Load (reader);
// (and leave rest of the reader as is)
retMode = XmlReadMode.DiffGram;
}
else
reader.Skip();
continue;
}
//collect data
XmlNode n = doc.ReadNode(reader);
root.AppendChild(n);
}
if (reader.NodeType == XmlNodeType.EndElement)
reader.Read ();
reader.MoveToContent();
if (mode == XmlReadMode.DiffGram) {
return retMode;
}
doc.AppendChild(root);
if (!schemaLoaded &&
retMode != XmlReadMode.ReadSchema &&
mode != XmlReadMode.IgnoreSchema &&
mode != XmlReadMode.Fragment &&
(Tables.Count == 0 || mode == XmlReadMode.InferSchema)) {
InferXmlSchema(doc, null);
if (mode == XmlReadMode.Auto)
retMode = XmlReadMode.InferSchema;
}
reader = new XmlNodeReader (doc);
XmlDataReader.ReadXml (this, reader, mode);
return retMode == XmlReadMode.Auto ?
XmlReadMode.IgnoreSchema : retMode;
}
public static void AssertReadXml(DataSet ds, string label, string xml, XmlReadMode readMode, XmlReadMode resultMode, string datasetName, int tableCount, ReadState state)
{
DataSetAssertion.AssertReadXml(ds, label, xml, readMode, resultMode, datasetName, tableCount, state, null, null);
}
public XmlReadMode ReadXml(Stream stream, XmlReadMode mode)
{
if (stream == null)
{
return XmlReadMode.Auto;
}
XmlTextReader reader = (mode == XmlReadMode.Fragment) ? new XmlTextReader(stream, XmlNodeType.Element, null) : new XmlTextReader(stream);
return this.ReadXml(reader, mode, false);
}
public XmlReadMode ReadXml(string fileName, XmlReadMode mode);
public XmlReadMode ReadXml(TextReader reader, XmlReadMode mode)
{
if (reader == null)
{
return XmlReadMode.Auto;
}
XmlTextReader reader2 = (mode == XmlReadMode.Fragment) ? new XmlTextReader(reader.ReadToEnd(), XmlNodeType.Element, null) : new XmlTextReader(reader);
return this.ReadXml(reader2, mode, false);
}
public XmlReadMode ReadXml(string fileName, XmlReadMode mode)
{
XmlTextReader reader = null;
XmlReadMode mode2;
if (mode == XmlReadMode.Fragment)
{
FileStream xmlFragment = new FileStream(fileName, FileMode.Open);
reader = new XmlTextReader(xmlFragment, XmlNodeType.Element, null);
}
else
{
reader = new XmlTextReader(fileName);
}
try
{
mode2 = this.ReadXml(reader, mode, false);
}
finally
{
reader.Close();
}
return mode2;
}
public XmlReadMode ReadXml(string fileName, XmlReadMode mode)
{
XmlTextReader xr = null;
if (mode == XmlReadMode.Fragment) {
FileStream stream = new FileStream(fileName, FileMode.Open);
xr = new XmlTextReader(stream, XmlNodeType.Element, null);
}
else
xr = new XmlTextReader(fileName);
try {
return ReadXml(xr, mode, false);
}
finally {
xr.Close();
}
}
/// <summary>
/// Reload the contents obtained from a previous call to <see cref="ToXml"/>. Use the mode
/// parameter for finer control.
/// </summary>
/// <param name="xml">The string to reload</param>
/// <param name="mode">See the .NET XmlReadMode enum for more help.</param>
/// <example>
/// VB.NET
/// <code>
/// Dim emps As New Employees
/// emps.Query.Load() ' emps.RowCount = 200
/// emps.FirstName = "Griffinski" ' Change first row
/// emps.GetChanges() ' emps.RowCount now = 1
///
/// ' Now reload that single record into a new Employees object and Save it
/// Dim xml As String = emps.ToXml()
/// Dim empsClone As New Employees
/// empsClone.FromXml(xml)
/// empsClone.Save()
/// </code>
/// C#
/// <code>
/// Employees emps = new Employees();
/// emps.LoadAll(); // emps.RowCount = 200
/// emps.LastName = "Griffinski"; // Change first row
/// emps.GetChanges(); // emps.RowCount now = 1
///
/// // Now reload that single record into a new Employees object and Save it
/// string str = emps.ToXml();
/// Employees empsClone = new Employees();
/// empsClone.FromXml(str);
/// empsClone.Save();
/// </code>
/// </example>
public virtual void FromXml(string xml, XmlReadMode mode)
{
DataSet dataSet = new DataSet();
StringReader reader = new StringReader(xml);
dataSet.ReadXml(reader, mode);
this.DataTable = dataSet.Tables[0];
dataSet.Tables.Clear();
}
// Read information from the reader.
private void ReadModeSchema(XmlReader reader, XmlReadMode mode)
{
bool inferSchema = mode == XmlReadMode.InferSchema || mode == XmlReadMode.Auto;
bool fillRows = mode != XmlReadMode.InferSchema;
// This check is required for full DiffGram.
// It is not described in MSDN and it is impossible
// with WriteXml(), but when writing XML using
// XmlSerializer, the output is like this:
// <dataset>
// <schema>...</schema>
// <diffgram>...</diffgram>
// </dataset>
//
// FIXME: This, this check should (also) be done
// after reading the top-level element.
//check if the current element is schema.
if (reader.LocalName == "schema")
{
if (mode != XmlReadMode.Auto)
{
reader.Skip(); // skip the schema node.
}
else
{
DSet.ReadXmlSchema(reader);
}
reader.MoveToContent();
}
// load an XmlDocument from the reader.
XmlDocument doc = new XmlDocument();
doc.Load(reader);
if (doc.DocumentElement == null)
{
return;
}
// treatment for .net compliancy :
// if xml representing dataset has exactly depth of 2 elements,
// than the root element actually represents datatable and not dataset
// so we add new root element to doc
// in order to create an element representing dataset.
//
// FIXME: Consider attributes.
// <root a='1' b='2' /> is regarded as a valid DataTable.
int rootNodeDepth = XmlNodeElementsDepth(doc.DocumentElement);
switch (rootNodeDepth)
{
case 1:
if (inferSchema)
{
DSet.DataSetName = doc.DocumentElement.LocalName;
DSet.Prefix = doc.DocumentElement.Prefix;
DSet.Namespace = doc.DocumentElement.NamespaceURI;
}
return;
case 2:
// create new document
XmlDocument newDoc = new XmlDocument();
// create element for dataset
XmlElement datasetElement = newDoc.CreateElement("dummy");
// make the new created element to be the new doc root
newDoc.AppendChild(datasetElement);
// import all the elements from doc and insert them into new doc
XmlNode root = newDoc.ImportNode(doc.DocumentElement, true);
datasetElement.AppendChild(root);
doc = newDoc;
break;
default:
if (inferSchema)
{
DSet.DataSetName = doc.DocumentElement.LocalName;
DSet.Prefix = doc.DocumentElement.Prefix;
DSet.Namespace = doc.DocumentElement.NamespaceURI;
}
break;
}
// set EnforceConstraint to false - we do not want any validation during
// load time.
bool origEnforceConstraint = DSet.EnforceConstraints;
DSet.EnforceConstraints = false;
// The childs are tables.
XmlNodeList nList = doc.DocumentElement.ChildNodes;
// FIXME: When reading DataTable (not DataSet),
// the nodes are column items, not rows.
for (int i = 0; i < nList.Count; i++)
{
XmlNode node = nList[i];
// node represents a table onky if it is of type XmlNodeType.Element
if (node.NodeType == XmlNodeType.Element)
{
AddRowToTable(node, null, inferSchema, fillRows);
}
}
// set the EnforceConstraints to original value;
DSet.EnforceConstraints = origEnforceConstraint;
}
/// <devdoc>
/// </devdoc>
public XmlReadMode ReadXml(TextReader reader, XmlReadMode mode)
{
if (reader == null)
return XmlReadMode.Auto;
XmlTextReader xmlreader = (mode == XmlReadMode.Fragment) ? new XmlTextReader(reader.ReadToEnd(), XmlNodeType.Element, null) : new XmlTextReader(reader);
// Prevent Dtd entity in dataset
xmlreader.XmlResolver = null;
return ReadXml(xmlreader, mode, false);
}
internal XmlReadMode ReadXml(XmlReader reader, XmlReadMode mode, bool denyResolving)
{
DataTable.RowDiffIdUsageSection rowDiffIdUsage = new DataTable.RowDiffIdUsageSection();
try {
bool fSchemaFound = false;
bool fDataFound = false;
bool fIsXdr = false;
int iCurrentDepth = -1;
XmlReadMode ret = mode;
// Dev11 904428: prepare and cleanup rowDiffId hashtable
rowDiffIdUsage.Prepare(this);
if (reader == null)
return ret;
bool originalEnforceConstraint = false;
if (this.DataSet != null) {
originalEnforceConstraint = this.DataSet.EnforceConstraints;
this.DataSet.EnforceConstraints = false;
}
else {
originalEnforceConstraint = this.EnforceConstraints;
this.EnforceConstraints = false;
}
if (reader is XmlTextReader)
((XmlTextReader) reader).WhitespaceHandling = WhitespaceHandling.Significant;
XmlDocument xdoc = new XmlDocument(); // we may need this to infer the schema
if ((mode != XmlReadMode.Fragment) && (reader.NodeType == XmlNodeType.Element))
iCurrentDepth = reader.Depth;
reader.MoveToContent();
if (Columns.Count == 0) {
if (IsEmptyXml(reader)) {
reader.Read();
return ret;
}
}
XmlDataLoader xmlload = null;
if (reader.NodeType == XmlNodeType.Element) {
XmlElement topNode = null;
if (mode == XmlReadMode.Fragment) {
xdoc.AppendChild(xdoc.CreateElement("ds_sqlXmlWraPPeR"));
topNode = xdoc.DocumentElement;
}
else { //handle the top node
if ((reader.LocalName == Keywords.DIFFGRAM) && (reader.NamespaceURI == Keywords.DFFNS)) {
if ((mode == XmlReadMode.DiffGram) || (mode == XmlReadMode.IgnoreSchema)) {
if (Columns.Count == 0) {
if(reader.IsEmptyElement) {
reader.Read();
return XmlReadMode.DiffGram;
}
throw ExceptionBuilder.DataTableInferenceNotSupported();
}
this.ReadXmlDiffgram(reader);
// read the closing tag of the current element
ReadEndElement(reader);
}
else {
reader.Skip();
}
RestoreConstraint(originalEnforceConstraint);
return ret;
}
if (reader.LocalName == Keywords.XDR_SCHEMA && reader.NamespaceURI==Keywords.XDRNS) {
// load XDR schema and exit
if ((mode != XmlReadMode.IgnoreSchema) && (mode != XmlReadMode.InferSchema)) {
ReadXDRSchema(reader);
}
else {
reader.Skip();
}
RestoreConstraint(originalEnforceConstraint);
return ret; //since the top level element is a schema return
}
if (reader.LocalName == Keywords.XSD_SCHEMA && reader.NamespaceURI==Keywords.XSDNS) {
// load XSD schema and exit
if ((mode != XmlReadMode.IgnoreSchema) && (mode != XmlReadMode.InferSchema)) {
ReadXmlSchema(reader, denyResolving);
}
else
reader.Skip();
RestoreConstraint(originalEnforceConstraint);
return ret; //since the top level element is a schema return
}
if (reader.LocalName == Keywords.XSD_SCHEMA && reader.NamespaceURI.StartsWith(Keywords.XSD_NS_START, StringComparison.Ordinal)) {
if (this.DataSet != null) { // we should not throw for constraint, we already will throw for unsupported schema, so restore enforce cost, but not via property
this.DataSet.RestoreEnforceConstraints(originalEnforceConstraint);
}
else {
this.enforceConstraints = originalEnforceConstraint;
}
throw ExceptionBuilder.DataSetUnsupportedSchema(Keywords.XSDNS);
}
// now either the top level node is a table and we load it through dataReader...
// ... or backup the top node and all its attributes
topNode = xdoc.CreateElement(reader.Prefix, reader.LocalName, reader.NamespaceURI);
if (reader.HasAttributes) {
int attrCount = reader.AttributeCount;
for (int i=0;i<attrCount;i++) {
reader.MoveToAttribute(i);
if (reader.NamespaceURI.Equals(Keywords.XSD_XMLNS_NS))
topNode.SetAttribute(reader.Name, reader.GetAttribute(i));
else {
XmlAttribute attr = topNode.SetAttributeNode(reader.LocalName, reader.NamespaceURI);
attr.Prefix = reader.Prefix;
attr.Value = reader.GetAttribute(i);
}
}
}
reader.Read();
}
while(MoveToElement(reader, iCurrentDepth)) {
if (reader.LocalName == Keywords.XDR_SCHEMA && reader.NamespaceURI==Keywords.XDRNS) {
// load XDR schema
if (!fSchemaFound && !fDataFound && (mode != XmlReadMode.IgnoreSchema) && (mode != XmlReadMode.InferSchema)) {
ReadXDRSchema(reader);
fSchemaFound = true;
fIsXdr = true;
}
else {
reader.Skip();
}
continue;
}
if (reader.LocalName == Keywords.XSD_SCHEMA && reader.NamespaceURI==Keywords.XSDNS) {
// load XSD schema and exit
if ((mode != XmlReadMode.IgnoreSchema) && (mode != XmlReadMode.InferSchema)) {
ReadXmlSchema(reader, denyResolving);
fSchemaFound = true;
}
else {
reader.Skip();
}
continue;
}
if ((reader.LocalName == Keywords.DIFFGRAM) && (reader.NamespaceURI == Keywords.DFFNS)) {
if ((mode == XmlReadMode.DiffGram) || (mode == XmlReadMode.IgnoreSchema)) {
if (Columns.Count == 0) {
if(reader.IsEmptyElement) {
reader.Read();
return XmlReadMode.DiffGram;
}
throw ExceptionBuilder.DataTableInferenceNotSupported();
}
this.ReadXmlDiffgram(reader);
ret = XmlReadMode.DiffGram;
}
else {
reader.Skip();
}
continue;
}
if (reader.LocalName == Keywords.XSD_SCHEMA && reader.NamespaceURI.StartsWith(Keywords.XSD_NS_START, StringComparison.Ordinal)) {
if (this.DataSet != null) { // we should not throw for constraint, we already will throw for unsupported schema, so restore enforce cost, but not via property
this.DataSet.RestoreEnforceConstraints(originalEnforceConstraint);
}
else {
this.enforceConstraints = originalEnforceConstraint;
}
throw ExceptionBuilder.DataSetUnsupportedSchema(Keywords.XSDNS);
}
if (mode == XmlReadMode.DiffGram) {
reader.Skip();
continue; // we do not read data in diffgram mode
}
// if we are here we found some data
fDataFound = true;
if (mode == XmlReadMode.InferSchema) { //save the node in DOM until the end;
XmlNode node = xdoc.ReadNode(reader);
topNode.AppendChild(node);
}
else {
if (Columns.Count == 0) {
throw ExceptionBuilder.DataTableInferenceNotSupported();
}
if (xmlload == null)
xmlload = new XmlDataLoader(this, fIsXdr, topNode, mode == XmlReadMode.IgnoreSchema);
xmlload.LoadData(reader);
}
} //end of the while
// read the closing tag of the current element
ReadEndElement(reader);
// now top node contains the data part
xdoc.AppendChild(topNode);
if (xmlload == null)
xmlload = new XmlDataLoader(this, fIsXdr, mode == XmlReadMode.IgnoreSchema);
if (mode == XmlReadMode.DiffGram) {
// we already got the diffs through XmlReader interface
RestoreConstraint(originalEnforceConstraint);
return ret;
}
//todo
// Load Data
if (mode == XmlReadMode.InferSchema) {
if (Columns.Count == 0) {
throw ExceptionBuilder.DataTableInferenceNotSupported();
}
// [....] xmlload.InferSchema(xdoc, null);
// [....] xmlload.LoadData(xdoc);
}
}
RestoreConstraint(originalEnforceConstraint);
return ret;
}
finally {
// Dev11 904428: prepare and cleanup rowDiffId hashtable
rowDiffIdUsage.Cleanup();
}
}
private XmlReadMode ReadXmlIgnoreSchema (XmlReader input, XmlReadMode mode, bool checkRecurse)
{
if (input.LocalName == "schema" &&
input.NamespaceURI == XmlSchema.Namespace) {
input.Skip ();
}
else if (input.LocalName == "diffgram" &&
input.NamespaceURI == XmlConstants.DiffgrNamespace) {
XmlDiffLoader DiffLoader = new XmlDiffLoader (this);
DiffLoader.Load (input);
}
else if (checkRecurse ||
input.LocalName == DataSetName &&
input.NamespaceURI == Namespace) {
XmlDataReader.ReadXml (this, input, mode);
}
else if (checkRecurse && !input.IsEmptyElement) {
int depth = input.Depth;
input.Read ();
input.MoveToContent ();
ReadXmlIgnoreSchema (input, mode, false);
while (input.Depth > depth)
input.Skip ();
if (input.NodeType == XmlNodeType.EndElement)
input.ReadEndElement ();
}
input.MoveToContent ();
return XmlReadMode.IgnoreSchema;
}
