/// <summary>
/// Parser recursiv de elemente XML.
/// </summary>
/// <param name="reader">Cititorul secvenţial care a deschis fişierul XML</param>
/// <returns>Elementul XML parsat care conţine toate atributele şi subelementele sale</returns>
private static XMLElement readCurrentElement(XmlTextReader reader)
{
if (!reader.IsStartElement()) {
return null;
}
bool hasChildren = !reader.IsEmptyElement;
XMLElement result = new XMLElement();
for (int i = 0; i < reader.AttributeCount; ++i) {
reader.MoveToAttribute(i);
result.addAttribute(reader.Name, reader.Value);
}
if (hasChildren) {
while (reader.Read() && reader.NodeType != XmlNodeType.EndElement) {
if (reader.IsStartElement()) {
result.addElement(reader.Name, readCurrentElement(reader));
}
}
}
reader.Read();
return result;
}
public static Test ParseFromXml(string pathFile)
{
var test = new Test {PathFile = pathFile};
var xtr = new XmlTextReader(pathFile) {WhitespaceHandling = WhitespaceHandling.None};
xtr.Read(); // read the XML declaration node, advance to <test> tag
xtr.Read();
test.TestName = xtr.GetAttribute("testname");
test.Order = xtr.GetAttribute("order");
test.Questions=new List<Question>();
while (!xtr.EOF)
{
if (xtr.Name == "test" && !xtr.IsStartElement()) break;
while (xtr.Name != "question" || !xtr.IsStartElement())
xtr.Read(); // advance to <question> tag
Question question;
switch (xtr.GetAttribute("type"))
{
case "Radio":
question = QuestionWithVariants(xtr);
break;
case "Checked":
question = QuestionWithVariants(xtr);
break;
default:
throw new Exception();
}
test.Questions.Add(question);
xtr.Read();// and now either at <question> tag or </test> tag
}
xtr.Close();
test.DateDownload = DateTime.Now;
return test;
}
/// <summary>
/// Loads the namespaces and properties from the file into
/// Namespace and Property objects.
/// </summary>
///
/// <param name="filename">The name of the file.</param>
/// <returns>The populated Namespace objects</returns>
///
/// <exception cref="NamespaceClashException">
/// If a namespace clash occurs.
/// </exception>
///
/// <exception cref="PropertyClashException">
/// If a property clash occurs.
/// </exception>
///
/// <exception cref="InvalidConfigFileException">
/// If the configuration file is invalid.
/// </exception>
///
/// <exception cref="UnknownFormatException">
/// If the format of the configuration file is unkown.
/// </exception>
///
/// <exception cref="IOException">
/// If an I/O error occurs.
/// </exception>
public List<Namespace> LoadFromFile(string filename)
{
try
{
var namespaces = new List<Namespace>();
using (var reader = new XmlTextReader(filename))
{
while (reader.Read())
{
if (reader.Name.ToLower() == "namespace" && reader.IsStartElement())
{
var namespaceName = reader.GetAttribute("name");
var currentNamespace = new Namespace(namespaceName);
namespaces.Add(currentNamespace);
while (reader.Read())
{
if (reader.Name.ToLower() == "property" && reader.IsStartElement())
{
var propertyName = reader.GetAttribute("name");
var valueList = new List<string>();
while (reader.Read())
{
if (reader.Name.ToLower() == "value" && reader.IsStartElement())
{
reader.Read();
valueList.Add(reader.Value);
}
else if (reader.Name.ToLower() == "property" && reader.NodeType == XmlNodeType.EndElement)
{
break;
}
}
currentNamespace.AddProperty(new Property(propertyName, valueList));
}
else if (reader.Name.ToLower() == "namespace" && reader.NodeType == XmlNodeType.EndElement)
{
break;
}
}
}
else if (reader.Name.ToLower() == "ConfigManager" && reader.NodeType == XmlNodeType.EndElement)
{
break;
}
}
}
return namespaces;
}
catch (XmlException e)
{
throw new InvalidConfigFileException("'" + filename + "' contains errors.", e);
}
}
public void LoadURLList()
{
XmlTextReader reader = null;
try
{
reader = new XmlTextReader(Configuration.Instance.UrlList);
reader.Read();
}
catch
{
if (reader != null)
reader.Close();
SaveURLList();
reader = new XmlTextReader(Configuration.Instance.UrlList);
reader.Read();
}
if(reader.Name == "URLList" && !reader.IsEmptyElement)
{
while (!(reader.Name == "URLList" && reader.NodeType == XmlNodeType.EndElement))
{
reader.Read();
if (reader.Name == "ShellURL" && reader.IsStartElement())
{
string url = "";
string password = "";
string prestring = "";
while (!(reader.Name == "ShellURL" && reader.NodeType == XmlNodeType.EndElement))
{
reader.Read();
if (reader.IsStartElement())
{
switch (reader.Name)
{
case "URL":
reader.Read();
url = reader.Value;
break;
case "Password":
reader.Read();
password = reader.Value;
break;
case "PreString":
reader.Read();
prestring = reader.Value;
break;
}
}
}
ShellURLs.Add(new ShellURL(url, password, prestring));
}
}
}
reader.Close();
}
public bool Load()
{
if (!File.Exists(this._path))
{
throw new Exception("Saved Template Input file not found: " + this._path);
}
else
{
bool inStartElement = true;
string tagName;
string projectDirPath = this._path.Substring(0, (this._path.LastIndexOf('\\') + 1));
XmlTextReader xr = new XmlTextReader(File.OpenText(this._path));
while (xr.Read())
{
inStartElement = xr.IsStartElement();
tagName = xr.LocalName;
if (inStartElement && ((tagName == "obj")) )
{
tagName = this.InputData.ReadXML(xr);
}
}
xr.Close();
return true;
}
}
public static void ReadXML(string xmlName)
{
XmlTextReader xmltextreader = new XmlTextReader(xmlName);
while (xmltextreader.Read())
{
if (xmltextreader.IsStartElement())
{
// Get element name and switch on it.
switch (xmltextreader.Name)
{
case "IRCamProperties":
irCamProperties.ReadXML(xmltextreader, "IRCamProperties");
break;
case "VICamProperties":
viCamProperties.ReadXML(xmltextreader, "VICamProperties");
break;
case "GPSProperties":
gpsProperties.ReadXML(xmltextreader, "GPSProperties");
break;
}
}
}
xmltextreader.Close();
}
public IEnumerable<DetailedQuoteQueryResultModel> RetrieveStockDetailedInfos(List<string> codeList)
{
string urlPrefix = @"https://query.yahooapis.com/v1/public/yql?q=select * from yahoo.finance.quotes where symbol in (";
string codes = string.Join(@""",""", codeList);
string urlSuffix = ")&env=store://datatables.org/alltableswithkeys";
string url = string.Format(@"{0}""{1}""{2}", urlPrefix, codes, urlSuffix);
HttpWebRequest webReq = (HttpWebRequest)WebRequest.Create(string.Format(url));
webReq.Method = "GET";
HttpWebResponse webResponse = (HttpWebResponse)webReq.GetResponse();
XmlTextReader reader = new XmlTextReader(webResponse.GetResponseStream());
XmlSerializer serializer = new XmlSerializer(typeof(DetailedQuoteQueryResultModel));
var detailedList = new List<Models.DetailedQuoteQueryResultModel>();
while(reader.Read())
{
if(reader.Name == "quote" && reader.IsStartElement())
{
DetailedQuoteQueryResultModel item = (DetailedQuoteQueryResultModel)serializer.Deserialize(reader.ReadSubtree());
detailedList.Add(item);
}
}
reader.Close();
return detailedList;
}
public Exception Load(out Dictionary<string, object> settingEntity, string path)
{
settingEntity = new Dictionary<string, object>();
try
{
using (XmlTextReader reader = new XmlTextReader(path))
{
string tag = String.Empty;
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element && reader.IsStartElement())
tag = reader.Name;
if (reader.NodeType == XmlNodeType.Text && tag != String.Empty)
settingEntity[tag] = reader.Value;
}
}
return null;
}
catch (Exception e)
{
return e;
}
}
public static void BuildPatternCache()
{
Pattern.FlushPatternCache();
Pattern.sPatternCategories.Clear();
Pattern.sPatternCache.Clear();
KeySearch search = new KeySearch(0xd4d9fbe5);
foreach (ResourceKey key in search)
{
string xmlFragment = Simulator.LoadXMLString(key);
if ((xmlFragment != null) && (xmlFragment != string.Empty))
{
XmlTextReader reader = new XmlTextReader(xmlFragment, XmlNodeType.Document, null);
while (reader.Read())
{
if (reader.IsStartElement("patternlist"))
{
try
{
Pattern.ParseCategories(reader);
}
catch (Exception e)
{
Common.Exception("ResourceKey: " + key, e);
}
}
}
}
}
Pattern.sCacheBuilt = true;
}
internal static Dictionary<string, string> ReturnGitHubChecksumDictionary()
{
Dictionary<string, string> returnValues = new Dictionary<string, string>();
try
{
using (XmlTextReader reader = new XmlTextReader(GitHubProjectUrl))
{
// simply (and easily) skip the junk at the beginning
reader.MoveToContent();
//reader.ReadToDescendant("FileList");
while (reader.Read())
{
if ((reader.NodeType == XmlNodeType.Element) &&
(reader.IsStartElement()) &&
reader.HasAttributes)
{
string fileName = reader.GetAttribute(0);
string fileHash = reader.GetAttribute(1);
returnValues.Add(fileName, fileHash);
}
}
}
}
catch (Exception)
{
}
return returnValues;
}
public void ReadKey(string keyId, Domain domain, string keyName, Type dataType, object defaultVal, string inputStr)
{
//<key id="nd0" for="node" attr.name="X1" attr.type="string" />
var keyReader = new KeyReader();
var reader = new XmlTextReader(new StringReader(inputStr));
reader.Read();
Assert.True(reader.IsStartElement());
Assert.True(string.Compare("key", reader.Name, true) == 0, string.Format("Reader.Name should match expected, not: \"{0}\"", reader.Name));
string retrievedKeyId;
Domain retrievedDomain;
string retrievedAttribName;
Type retrievedType;
object retrievedDefault;
keyReader.Read(out retrievedKeyId, out retrievedDomain, out retrievedAttribName, out retrievedType, out retrievedDefault, reader);
Assert.Equal(keyId, retrievedKeyId);
Assert.Equal(domain, retrievedDomain);
Assert.Equal(keyName, retrievedAttribName);
Assert.Equal(dataType, retrievedType);
Assert.Equal(defaultVal, retrievedDefault);
if (!reader.IsEmptyElement)
Assert.True(string.Compare("key", reader.Name, true) == 0, string.Format("End Reader.Name should match expected, not: \"{0}\"", reader.Name));
}
private ConfigurationContainer ReadConfiguration(string file)
{
ConfigurationContainer container = new ConfigurationContainer();
XmlTextReader reader = null;
try {
reader = new XmlTextReader(new StreamReader(file));
while (!reader.EOF) {
reader.Read();
if (reader.IsStartElement()) {
if (reader.Name == "WaitTime") {
reader.MoveToContent();
reader.Read();
container.WaitTime = int.Parse(reader.Value);
}
else if (reader.Name == "AutoStart") {
reader.MoveToContent();
reader.Read();
container.AutoStart = bool.Parse(reader.Value);
}
else if (reader.Name == "MaxRetryCount") {
reader.MoveToContent();
reader.Read();
container.MaxRetryCount = int.Parse(reader.Value);
}
}
}
return container;
}
catch { return null; }
finally { if (reader != null) reader.Close(); }
}
static void PopulateCache(Dictionary<Key, GenericXmlSecurityToken> cache, Stream stream)
{
XmlTextReader reader = new XmlTextReader(stream);
while (reader.IsStartElement("Entry"))
{
reader.ReadStartElement();
Uri target = new Uri(reader.ReadElementString("Target"));
string issuerStr = reader.ReadElementString("Issuer");
Uri issuer = string.IsNullOrEmpty(issuerStr) ? null : new Uri(issuerStr);
reader.ReadStartElement("Token");
reader.ReadStartElement("XML");
XmlDocument doc = new XmlDocument();
XmlElement tokenXml = doc.ReadNode(reader) as XmlElement;
reader.ReadEndElement();
byte[] key = Convert.FromBase64String(reader.ReadElementString("Key"));
reader.ReadElementString("Id");
DateTime validFrom = Convert.ToDateTime(reader.ReadElementString("ValidFrom"));
DateTime validTo = Convert.ToDateTime(reader.ReadElementString("ValidTo"));
WSSecurityTokenSerializer serializer = new WSSecurityTokenSerializer();
reader.ReadStartElement("InternalTokenReference");
SecurityKeyIdentifierClause internalReference = serializer.ReadKeyIdentifierClause(reader);
reader.ReadEndElement();
reader.ReadStartElement("ExternalTokenReference");
SecurityKeyIdentifierClause externalReference = serializer.ReadKeyIdentifierClause(reader);
reader.ReadEndElement();
reader.ReadEndElement(); // token
reader.ReadEndElement(); // entry
List<IAuthorizationPolicy> policies = new List<IAuthorizationPolicy>();
GenericXmlSecurityToken token = new GenericXmlSecurityToken(tokenXml, new BinarySecretSecurityToken(key), validFrom, validTo, internalReference, externalReference,
new ReadOnlyCollection<IAuthorizationPolicy>(policies));
cache.Add(new Key(target, issuer), token);
}
}
public TriviaServer(int port)
{
IPAddress ipAddress = Dns.Resolve(Dns.GetHostName()).AddressList[0];
this.port = port;
this.connector = new TCPIPconnectorServer(port, ipAddress);
this.dbConnected = true;
string login = "";
string password = "";
string dbName = "";
XmlTextReader reader;
try
{
reader = new XmlTextReader("config.xml");
while (reader.Read())
{
if (reader.IsStartElement())
{
if (reader.Name == "login")
{
login = reader.ReadString();
}
if (reader.Name == "password")
{
password = reader.ReadString();
}
if (reader.Name == "dbName")
{
dbName = reader.ReadString();
}
}
}
reader.Close();
}
catch (Exception e)
{
Logging.LogEvent("Constructor|XmlTextReader", e.Message);
}
try
{
this.DBConnector = new DatabaseConnector("localhost", login, password, dbName);
TriviaServer.answerID = this.DBConnector.GetNumberOfUserAnswer() + 1;
}
catch (Exception e)
{
Logging.LogEvent("Constructor|DatabaseConnector", e.Message + " " + login + " " + password + " " + dbName);
this.dbConnected = false;
}
this.userList = new List<User>();
this.userThread = new List<Thread>();
this.mutex = new ManualResetEvent(true);
}
public static VexObject Load(string fileFullPathAndName)
{
VexObject vo;
string rootFolder = Path.GetDirectoryName(fileFullPathAndName);
string fileNameOnly = Path.GetFileNameWithoutExtension(fileFullPathAndName);
Environment.CurrentDirectory = rootFolder;
string definitionsFolder = "";
string instancesFolder = "";
uint rootId = 0;
vo = new VexObject(fileNameOnly);
FileStream fs = new FileStream(fileFullPathAndName, FileMode.Open);
XmlTextReader r = new XmlTextReader(fs);
r.ReadStartElement("UIL");
while (r.Read())
{
if (r.IsStartElement())
{
switch (r.Name)
{
case "DefinitionsFolder":
if (r.Read())
{
definitionsFolder = r.Value.Trim();
}
break;
case "InstancesFolder":
if (r.Read())
{
instancesFolder = r.Value.Trim();
}
break;
case "RootId":
if (r.Read())
{
rootId = uint.Parse(r.Value.Trim(), NumberStyles.Any);
}
break;
}
}
}
fs.Close();
string defsPath = rootFolder + Path.DirectorySeparatorChar + fileNameOnly + definitionsFolder;
LoadDefinitions(defsPath, vo);
string instsPath = rootFolder + Path.DirectorySeparatorChar + fileNameOnly + instancesFolder;
LoadInstances(instsPath, vo);
vo.Root = (Timeline)vo.Definitions[rootId];
return vo;
}
//----------------------------- Wikipedia ---------------------------------------------------//
private void button8_Click(object sender, EventArgs e) //vytvor subor - zjednodusenie velkeho suboru pre wikipediu
{
cestaSuborWiki = textBox1.Text;
string nadpis = "";
string abstraktWikiSubor = "";
bool zapisalTitle = false;
bool zapisalAbs = false;
bool zapisalSom = false;
XmlTextReader citam = new XmlTextReader(cestaSuborWiki);
using (System.IO.StreamWriter subor = new System.IO.StreamWriter(@"d:\Vyhladavanie info\wiki-abstract-vycuc.txt"))
{
while (citam.Read())
{
if (citam.IsStartElement())
{
switch (citam.Name)
{
case "doc":
zapisalSom = false;
break;
case "title":
nadpis = citam.ReadString();
nadpis = nadpis.Remove(0, 11);
nadpis = nadpis.ToLower();
zapisalTitle = true;
break;
case "abstract":
abstraktWikiSubor = citam.ReadString();
zapisalAbs = true;
break;
case "links":
if (!zapisalSom)
{
MessageBox.Show("Zmena štruktúry XML súboru. Oprav zdrojový kód!"); //ochrana pred zmenou struktury XML suboru
break;
}
break;
}
}
if (zapisalTitle && zapisalAbs)
{
subor.WriteLine(nadpis + ";|?" + abstraktWikiSubor);
zapisalSom = true;
zapisalAbs = false;
zapisalTitle = false;
}
}
}
}
private Dictionary<string, ClassInfo> Parse(XmlTextReader reader)
{
XmlNamespaceManager nps = new XmlNamespaceManager(reader.NameTable);
Dictionary<string, ClassInfo> table = new Dictionary<string, ClassInfo>();
ParentInfo parent = null;
string previousNode = null;
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element ||
reader.NodeType == XmlNodeType.EndElement)
{
////Got an element. This will be the name of a class.
string className = reader.LocalName;
if (className.Equals("rss", StringComparison.OrdinalIgnoreCase))
{
nps = new XmlNamespaceManager(reader.NameTable);
for (int index = 0; index < reader.AttributeCount; index++)
{
{
reader.MoveToAttribute(index);
if (reader.Name.StartsWith("xmlns"))
{
nps.AddNamespace(reader.LocalName, reader.Value);
}
}
}
}
if (reader.IsStartElement() || reader.IsEmptyElement)
{
ParseStartElements(reader, table, parent, nps, className);
}
else
{
ParseEndElements(table, className);
}
previousNode = className;
}
else if (reader.NodeType == XmlNodeType.Text)
{
if (!string.IsNullOrEmpty(previousNode))
{
ClassInfo classInfo = table[previousNode];
classInfo.IsText = true;
}
}
}
return table;
}
void Load(string fileName)
{
// chargement des valeurs des options depuis le fichier Config.xml
try
{
using (XmlTextReader reader = new XmlTextReader(fileName))
{
reader.ReadStartElement("Config");
do
{
if (!reader.IsStartElement()) continue;
string value = reader.ReadString();
switch (reader.Name)
{
case "VLCPath": VLCPath = value; break;
case "DVDLetter": DVDLetter = value; break;
case "VlcPort": VlcPort = value; break;
case "SoundExts": SoundExts = value; break;
case "PictureExts": PictureExts = value; break;
case "VideoExts": VideoExts = value; break;
case "AudioLanguage": AudioLanguage = value; break;
case "SubLanguage": SubLanguage = value; break;
case "ShowVLC": ShowVLC = (value == "1") || (value == System.Boolean.TrueString); break;
case "Transcode":
switch (value.ToUpper())
{
case "MPGA": TranscodeAudio = AudioTranscode.MPGA; break;
case "A52": TranscodeAudio = AudioTranscode.A52; break;
case "PC": TranscodeAudio = AudioTranscode.PC; break;
default: TranscodeAudio = AudioTranscode.None; break;
}
break;
case "StartMinimized": StartMinimized = (value == "1") || (value == System.Boolean.TrueString); break;
case "MinimizeToTray": MinimizeToTray = (value == "1") || (value == System.Boolean.TrueString); break;
case "FFMpegInterlace": FFMpegInterlace = (value == "1") || (value == System.Boolean.TrueString); break;
case "HalfScale": HalfScale = (value == "1") || (value == System.Boolean.TrueString); break;
case "LIRCActive": LIRCActive = (value == "1") || (value == System.Boolean.TrueString); break;
case "TranscodeVB": TranscodeVB = value; break;
case "PCControlAllowed": PCControlAllowed = Convert.ToBoolean(value); break;
case "LessIconsInExplorer": LessIconsInExplorer = Convert.ToBoolean(value); break;
case "BlackBkgnds": BlackBkgnds = Convert.ToBoolean(value); break;
case "TranscodeVideo":
switch (value.ToUpper())
{
case "MPG2": TranscodeVideo = VideoTranscode.MPG2; break;
default: TranscodeVideo = VideoTranscode.None; break;
}
break;
}
} while (reader.Read());
}
}
catch (FileNotFoundException) { }
}
public RuleDataModel ReadCustomRules()
{
string line = String.Empty;
RuleDataModel ruleDataObj = new RuleDataModel();
try
{
var fileName = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData) + "\\Ruleset.xml";
if (!File.Exists(fileName))
{
CreateXml();
}
using (XmlTextReader reader = new XmlTextReader(fileName))
{
while (reader.Read())
{
if (reader.IsStartElement())
{
switch (reader.Name)
{
case "AllowBody":
reader.Read();
ruleDataObj.SearchForBodyTags = reader.Value.Split(',').ToList();
break;
case "AllowSubject":
reader.Read();
ruleDataObj.SearchForSubject = reader.Value.Split(',').ToList();
break;
case "AllowTo":
reader.Read();
ruleDataObj.SearchForToRecepients = reader.Value.Split(',').ToList();
break;
case "DenyBody":
reader.Read();
ruleDataObj.SearchForDenyBodyTags = reader.Value.Split(',').ToList();
break;
case "DenySubject":
reader.Read();
ruleDataObj.SearchForDenySubject = reader.Value.Split(',').ToList();
break;
case "DenyDepartments":
reader.Read();
ruleDataObj.SearchForDenyDepartments = reader.Value.Split(',').ToList();
break;
}
}
}
}
}
catch (System.Exception ex)
{
}
return ruleDataObj;
}
/// <summary>
/// Decodes an <see cref="Error"/> object from its default XML
/// representation.
/// </summary>
public static Error DecodeString(string xml)
{
using (StringReader sr = new StringReader(xml))
{
XmlTextReader reader = new XmlTextReader(sr);
if (!reader.IsStartElement("error"))
throw new ApplicationException("The error XML is not in the expected format.");
return Decode(reader);
}
}
/// <summary>
/// Processes the specified reader.
/// </summary>
/// <param name="reader">The reader. 指向具体的一个配置XML文件</param>
/// <param name="configurationStore">The configuration store.用于访问XML文件的工具类</param>
public virtual void Process(XmlTextReader reader, IConfigurationStore configurationStore)
{
bool lastElementEmpty = false;
while (reader.Read())
{
//判断是元素的开始或结束情况
if (reader.NodeType == XmlNodeType.Element || reader.NodeType == XmlNodeType.EndElement)
{
if (!reader.IsStartElement())//判断是不是开始元素标签
{
//pop off because we reached a closing tag
elementStack.Pop();
continue;
}
else if (lastElementEmpty)//上一个元素是否为空
{
//pop off because this is not a sub-element of last
elementStack.Pop();
}
Tag parent = elementStack.Count == 0 ? null : elementStack.Peek();
Tag tag = new Tag(reader, parent, configurationStore);
elementStack.Push(tag);//压入栈中的永远是Element开始或结束类型
XmlTagHandler handler = null;
if (handlers.TryGetValue(tag.Name, out handler))
{
handler(tag, configurationStore);//configurationStore会被多次递归传递
}
lastElementEmpty = reader.IsEmptyElement;
}
//判断是文本内容的情况
else if (reader.NodeType == XmlNodeType.Text || reader.NodeType == XmlNodeType.CDATA)
{
Tag parent = elementStack.Count == 0 ? null : elementStack.Peek();
if (parent.Name == ConfigConstants.ELEMENT_INCLUDE)//"include"情况
{
parent = parent.Parent;
}
Tag tag = new Tag(reader, parent, configurationStore);
XmlTagHandler handler = null;
if (handlers.TryGetValue(ConfigConstants.ELEMENT_TEXT, out handler))
{
handler(tag, configurationStore);
}
}
}
}
public void makeJob()
{
if (languages.Count == 0)
{
scanLanguages();
}
using (reader = new XmlTextReader(path)) {
while (reader.Read())
{
if (reader.IsStartElement() && reader.LocalName == "tu")
{
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.LoadXml(reader.ReadOuterXml());
foreach (XmlNode item in xmlDoc.FirstChild.ChildNodes)
{
if (item.LocalName == "tuv")
{
string lang;
if (null == item.Attributes["xml:lang"])
{
lang = item.Attributes["lang"].Value;
}
else
{
lang = item.Attributes["xml:lang"].Value;
}
int columnNumber = languages[lang];
foreach (XmlNode seg in item.ChildNodes)
{
if (seg.LocalName == "seg")
{
foreach (XmlNode txt in seg.ChildNodes)
{
if (txt.NodeType == XmlNodeType.Text)
{
output.addCell(columnNumber, txt.Value);
}
}
}
}
}
}
output.writeRow();
}
}
}
output.Close();
}
public string readConnection()
{
string connectionString = "";
XmlTextReader m_xmlr = default(XmlTextReader);
//Create the XML Reader
m_xmlr = new XmlTextReader("product.xml");
//Disable whitespace so that you don't have to read over whitespaces
m_xmlr.WhitespaceHandling = WhitespaceHandling.None;
//read the xml declaration and advance to family tag
m_xmlr.Read();
//read the family tag
m_xmlr.Read();
//Load the Loop
while (!m_xmlr.EOF)
{
//Go to the name tag
m_xmlr.Read();
//if not start element exit while loop
if (!m_xmlr.IsStartElement())
{
break; // TODO: might not be correct. Was : Exit While
}
//Get the Gender Attribute Value
dynamic Attribute = m_xmlr.GetAttribute("Application_Configaration");
//Read elements firstname and lastname
m_xmlr.Read();
//Get the firstName Element Value
connectionString = m_xmlr.ReadElementString("Connection_String");
}
//close the reader
m_xmlr.Close();
return connectionString;
}
public static string GetProjectType(Stream st)
{
XmlTextReader rd = new XmlTextReader(st);
using (rd)
{
if (!rd.IsStartElement())
return "";
rd.ReadStartElement("Project");
rd.ReadToNextSibling("PropertyGroup");
rd.ReadStartElement("PropertyGroup");
rd.ReadToNextSibling("OutputType");
return rd.ReadString();
}
}
private JobsContainer ReadJobs(string file)
{
JobsContainer container = new JobsContainer();
XmlTextReader reader = null;
try {
reader = new XmlTextReader(new StreamReader(file));
JobContainer job = null;
bool valuesAdded = false;
while (!reader.EOF) {
reader.Read();
if (reader.IsStartElement()) {
if (reader.Name == "JobContainer") {
if (job != null) container.Jobs.Add(job);
job = new JobContainer();
}
else if (reader.Name == "WatchSubDirectories") {
reader.MoveToContent();
reader.Read();
job.WatchSubDirectories = bool.Parse(reader.Value);
valuesAdded = true;
}
else if (reader.Name == "SourceDirectory") {
reader.MoveToContent();
reader.Read();
job.SourceDirectory = reader.Value;
valuesAdded = true;
}
else if (reader.Name == "DestinationDirectory") {
reader.MoveToContent();
reader.Read();
job.DestinationDirectory = reader.Value;
valuesAdded = true;
}
else if (reader.Name == "Name") {
reader.MoveToContent();
reader.Read();
job.Name = reader.Value;
valuesAdded = true;
}
}
}
if (valuesAdded) container.Jobs.Add(job); //add the final job that is never added because it has no job behind it
return container;
}
catch {//(Exception e){
//System.Windows.Forms.MessageBox.Show(e.ToString());
return null;
}
finally { if (reader != null) reader.Close(); }
}
public void ReadDefault(string expectedVal, string inputStr)
{
var keyReader = new KeyReader();
var reader = new XmlTextReader(new StringReader(inputStr));
reader.Read();
Assert.True(reader.IsStartElement());
Assert.True(string.Compare("default", reader.Name, true) == 0, string.Format( "Reader.Name should match expected, not: \"{0}\"", reader.Name));
string defalutValStr;
keyReader.ReadDefault(out defalutValStr, reader);
Assert.Equal(expectedVal, defalutValStr);
if (!reader.IsEmptyElement)
Assert.True(string.Compare("default", reader.Name, true) == 0, string.Format("End Reader.Name should match expected, not: \"{0}\"", reader.Name));
}
/// <summary>
/// Parsează un fişier XML.
/// </summary>
/// <param name="parh">Calea către fişierul XML</param>
/// <returns>Elementul XML rădăcină parsat care conţine toate atributele şi subelementele sale</returns>
public static XMLElement parse(string path)
{
try {
XmlTextReader reader = new XmlTextReader(path);
while (reader.Read() && !reader.IsStartElement());
return readCurrentElement(reader);
}
catch (Exception) {
return null;
}
}
public LocationResponse(WebResponse response)
: base(response)
{
try
{
XmlTextReader r = new XmlTextReader(response.GetResponseStream());
while (r.Read() && !r.IsStartElement())
;
this.location = r.ReadElementString("LocationConstraint");
if (this.location == null)
this.location = "";
}
catch (XmlException)
{
}
}
private TopicTree Read(DirectoryPath root, Stream stream)
{
var result = new List<TopicSection>();
var reader = new XmlTextReader(stream);
while (reader.Read())
{
if (reader.IsStartElement() && reader.Name == "section")
{
var section = ReadSection(reader, root);
if (section != null)
{
result.Add(section);
}
}
}
return new TopicTree(result);
}
public override void InitializeService()
{
base.InitializeService ();
if (!File.Exists (file))
return;
// restore values
XmlTextReader reader = new XmlTextReader (file);
SourceLanguage lang = null;
try {
while (reader.Read ()) {
if (reader.IsStartElement ()) {
switch (reader.Name) {
case "SourceTag":
if (lang == null) continue;
string name = reader.GetAttribute ("name");
SourceTagStyle sts = lang.GetTagStyle (name);
sts.Bold = bool.Parse (reader.GetAttribute ("bold"));
sts.Italic = bool.Parse (reader.GetAttribute ("italic"));
sts.Underline = bool.Parse (reader.GetAttribute ("underline"));
sts.Strikethrough = bool.Parse (reader.GetAttribute ("strikethrough"));
sts.IsDefault = false;
ParseColor (reader.GetAttribute ("foreground"), ref sts.Foreground);
ParseColor (reader.GetAttribute ("background"), ref sts.Background);
lang.SetTagStyle (name, sts);
Runtime.LoggingService.InfoFormat ("Overrode style {0} {1}", lang.Name, name);
break;
case "SourceLanguage":
lang = FindLanguage (reader.GetAttribute ("name"));
break;
case "SyntaxHighlighting":
default:
break;
}
}
}
}
catch (XmlException e) {
Runtime.LoggingService.Warn (e.ToString ());
}
reader.Close ();
}
private int ReadXmlCommandFile(string filename)
{
string planFilePath = Path.GetDirectoryName(filename);
this.MergeListFileArray = new List <MergeListFiles>();
this.MergeListInfo = new MergeListInfoDefn();
MergeListFiles mergeElement = null;
System.Xml.XmlTextReader reader = new System.Xml.XmlTextReader(filename);
int fileNotFoundCount = 0;
while (reader.Read())
{
if (reader.IsStartElement())
{
switch (reader.Name.ToLower())
{
case "file":
if (mergeElement != null)
{
this.MergeListFileArray.Add(mergeElement);
}
mergeElement = new MergeListFiles();
object exclude = reader.GetAttribute("exclude");
if (exclude != null)
{
if (exclude.ToString() == "1")
{
mergeElement.Include = false;
}
}
break;
case "path":
mergeElement.Path = reader.ReadElementContentAsString();
// resolve paths, if files were moved
if (File.Exists(mergeElement.Path) == false)
{
++fileNotFoundCount;
}
break;
case "pages":
mergeElement.Pages = reader.ReadElementContentAsString();
break;
case "bookmark":
mergeElement.Bookmark = reader.ReadElementContentAsString();
break;
case "level":
mergeElement.Level = reader.ReadElementContentAsInt();
break;
case "info":
this.MergeListInfo.HasInfo = true;
break;
case "author":
this.MergeListInfo.HasInfo = true;
this.MergeListInfo.InfoAuthor = reader.ReadElementContentAsString();
break;
case "title":
this.MergeListInfo.HasInfo = true;
this.MergeListInfo.InfoTitle = reader.ReadElementContentAsString();
break;
case "subject":
this.MergeListInfo.HasInfo = true;
this.MergeListInfo.InfoSubject = reader.ReadElementContentAsString();
break;
case "annotation":
this.MergeListInfo.Annotation = reader.ReadElementContentAsString();
break;
case "outfile":
this.MergeListInfo.OutFilename = reader.ReadElementContentAsString();
break;
case "startpage":
this.MergeListInfo.StartPage = int.Parse(reader.ReadElementContentAsString());
this.MergeListInfo.NumberPages = true;
break;
case "paginationformat":
try
{
this.MergeListInfo.PaginationFormat = (PaginationFormatting.PaginationFormats) int.Parse(reader.ReadElementContentAsString());
}
catch
{
throw new Exception("Invalid value for pagination format in command file");
}
break;
}
}
}
if (mergeElement != null)
{
this.MergeListFileArray.Add(mergeElement);
}
reader.Close();
return(fileNotFoundCount);
}
