public static List<Issue> GetIssueListFromXmlStream(Stream stream) { List<Issue> issues = new List<Issue>(); XmlTextReader reader = new XmlTextReader(stream); XmlDocument doc = new XmlDocument(); doc.Load(reader); reader.Close(); XmlNodeList list = doc.DocumentElement.GetElementsByTagName("item"); XmlSerializer s = new XmlSerializer(typeof(Issue)); //Create the XmlNamespaceManager. NameTable nt = new NameTable(); XmlNamespaceManager nsmgr = new XmlNamespaceManager(nt); nsmgr.AddNamespace("jc", "urn:jiraconn"); //Create the XmlParserContext. XmlParserContext context = new XmlParserContext(null, nsmgr, null, XmlSpace.None); foreach (XmlNode item in list) { //Create the reader. XmlTextReader itemReader = new XmlTextReader(item.OuterXml, XmlNodeType.Element, context); Issue issue = (Issue)s.Deserialize(itemReader); issues.Add(issue); } return issues; }
/// <summary> /// Implements ParseXML /// </summary> /// <returns></returns> public IXmlResult ParseIATIXML(string url) { IXmlResult xmlResult; var serializer = new XmlSerializer(typeof(XmlResultv1), new XmlRootAttribute("result")); // Create an XmlNamespaceManager to resolve namespaces. NameTable nameTable = new NameTable(); XmlNamespaceManager nsmgr = new XmlNamespaceManager(nameTable); nsmgr.AddNamespace("iati-extra", ""); // Create an XmlParserContext. The XmlParserContext contains all the information // required to parse the XML fragment, including the entity information and the // XmlNamespaceManager to use for namespace resolution. XmlParserContext xmlParserContext = new XmlParserContext(nameTable, nsmgr, null, XmlSpace.None); // Create the reader. XmlReaderSettings xmlReaderSettings = new XmlReaderSettings(); xmlReaderSettings.NameTable = nameTable; using (var Reader = XmlReader.Create(url, xmlReaderSettings, xmlParserContext)) { xmlResult = (XmlResultv1)serializer.Deserialize(Reader); } return xmlResult; }
public Package(BinaryReader reader) : this() { header = new PackageHeader(reader); nameTable = new NameTable(reader); exportTable = new ExportTable(reader); importTable = new ImportTable(reader); }
/// <summary> /// Creates a namespace manager needed for XML XPath queries /// </summary> /// <param name="prefix"></param> /// <returns></returns> public static XmlNamespaceManager CreateTableauXmlNamespaceManager(string prefix) { var msTable = new NameTable(); var ns = new XmlNamespaceManager(msTable); ns.AddNamespace(prefix, "http://tableausoftware.com/api"); return ns; }
public XPathContext(NameTable nameTable) : base(nameTable) { Arguments = new XsltArgumentList(); AddNamespace("xsi", Xsi); AddNamespace("xsd", Xsd); AddNamespace(Prefix, NamespaceUri); AddFunction(Prefix, "match", MatchFunction.Instance); }
public XPathContext(NameTable nameTable) : base(nameTable) { prefixCount = 0; Arguments = new XsltArgumentList(); functions = new Dictionary<string, Func<IXsltContextFunction>>(); AddNamespace("xsi", Xsi); AddNamespace("xsd", Xsd); AddNamespace(Prefix, NamespaceUri); AddFunction(Prefix, "match", MatchFunction.Instance); }
// Test the default namespace manager properties. public void TestXmlNamespaceManagerDefaults() { NameTable table = new NameTable(); XmlNamespaceManager ns = new XmlNamespaceManager(table); AssertEquals("Defaults (1)", "http://www.w3.org/XML/1998/namespace", ns.LookupNamespace("xml")); AssertEquals("Defaults (2)", "http://www.w3.org/2000/xmlns/", ns.LookupNamespace("xmlns")); AssertEquals("Defaults (3)", "", ns.LookupNamespace("")); Assert("Defaults (4)", ReferenceEquals(table, ns.NameTable)); AssertEquals("Defaults (5)", "", ns.DefaultNamespace); AssertNull("Defaults (6)", ns.LookupNamespace("foo")); }
// Test parser context creation. public void TestXmlParserContextConstruct() { NameTable nt = new NameTable(); NameTable nt2 = new NameTable(); XmlNamespaceManager ns = new XmlNamespaceManager(nt); XmlParserContext ctx; // Try to construct with the wrong name table. try { ctx = new XmlParserContext(nt2, ns, null, XmlSpace.None); Fail("Construct (1)"); } catch(XmlException) { // Success } // Check default property values. ctx = new XmlParserContext(null, ns, null, XmlSpace.None); AssertEquals("Construct (2)", "", ctx.BaseURI); AssertEquals("Construct (3)", "", ctx.DocTypeName); AssertEquals("Construct (4)", null, ctx.Encoding); AssertEquals("Construct (5)", "", ctx.InternalSubset); AssertEquals("Construct (6)", nt, ctx.NameTable); AssertEquals("Construct (7)", ns, ctx.NamespaceManager); AssertEquals("Construct (8)", "", ctx.PublicId); AssertEquals("Construct (9)", "", ctx.SystemId); AssertEquals("Construct (10)", "", ctx.XmlLang); AssertEquals("Construct (11)", XmlSpace.None, ctx.XmlSpace); // Check overridden property values. ctx = new XmlParserContext(nt, null, "doctype", "pubid", "sysid", "internal", "base", "lang", XmlSpace.Preserve, Encoding.UTF8); AssertEquals("Construct (12)", "base", ctx.BaseURI); AssertEquals("Construct (13)", "doctype", ctx.DocTypeName); AssertEquals("Construct (14)", Encoding.UTF8, ctx.Encoding); AssertEquals("Construct (15)", "internal", ctx.InternalSubset); AssertEquals("Construct (16)", nt, ctx.NameTable); AssertEquals("Construct (17)", null, ctx.NamespaceManager); AssertEquals("Construct (18)", "pubid", ctx.PublicId); AssertEquals("Construct (19)", "sysid", ctx.SystemId); AssertEquals("Construct (20)", "lang", ctx.XmlLang); AssertEquals("Construct (21)", XmlSpace.Preserve, ctx.XmlSpace); }
protected void Page_Load(object sender, EventArgs e) { int bookcount = 0; decimal booktotal = 0; XmlReaderSettings settings = new XmlReaderSettings(); NameTable nt = new NameTable(); object book = nt.Add("book"); object price = nt.Add("price"); settings.NameTable = nt; string booksSchemaFile = Path.Combine(Request.PhysicalApplicationPath, "books.xsd"); settings.Schemas.Add(null, XmlReader.Create(booksSchemaFile)); settings.ValidationType = ValidationType.Schema; settings.ValidationFlags = XmlSchemaValidationFlags.ReportValidationWarnings; settings.ValidationEventHandler += new ValidationEventHandler(settings_ValidationEventHandler); settings.IgnoreWhitespace = true; settings.IgnoreComments = true; string booksFile = Path.Combine(Request.PhysicalApplicationPath, "books.xml"); using (XmlReader reader = XmlReader.Create(booksFile, settings)) { while (reader.Read()) { if (reader.NodeType == XmlNodeType.Element && book.Equals(reader.LocalName)) //A subtle, but significant change! { bookcount++; } if (reader.NodeType == XmlNodeType.Element && price.Equals(reader.LocalName)) { booktotal += reader.ReadElementContentAsDecimal(); } } } Response.Write(String.Format("Found {0} books that total {1:C}!", bookcount, booktotal)); }
protected void Page_Load(object sender, EventArgs e) { //Create factory early XmlSerializerFactory factory = new XmlSerializerFactory(); XmlReaderSettings settings = new XmlReaderSettings(); NameTable nt = new NameTable(); object book = nt.Add("book"); object price = nt.Add("price"); object author = nt.Add("author"); settings.NameTable = nt; string booksSchemaFile = Path.Combine(Request.PhysicalApplicationPath, "books.xsd"); settings.Schemas.Add(null, XmlReader.Create(booksSchemaFile)); settings.ValidationType = ValidationType.Schema; settings.ValidationFlags = XmlSchemaValidationFlags.ReportValidationWarnings; settings.ValidationEventHandler += new ValidationEventHandler(settings_ValidationEventHandler); settings.IgnoreWhitespace = true; settings.IgnoreComments = true; string booksFile = Path.Combine(Request.PhysicalApplicationPath, "books.xml"); using (XmlReader reader = XmlReader.Create(booksFile, settings)) { while (reader.Read()) { if (reader.NodeType == XmlNodeType.Element && author.Equals(reader.LocalName)) { //Then use the factory to create and cache serializers XmlSerializer xs = factory.CreateSerializer(typeof(Author)); Author a = (Author)xs.Deserialize(reader.ReadSubtree()); Response.Write(String.Format("Author: {1}, {0}<BR/>", a.FirstName, a.LastName)); } } } }
protected XsltContext(NameTable table) : base(table) { }
public static void FixReferralSpam (string path) { string bad = ConfigurationManager.AppSettings["badWords"]; long badWordsCount = 0; long totalBadWordsCount = 0; DirectoryInfo info = new DirectoryInfo("../../"); ReferralBlackListFactory.AddBlacklist(new MovableTypeBlacklist(), Path.Combine(info.FullName, "blacklist.txt")); if (bad != null && bad.Length > 0) ReferralBlackListFactory.AddBlacklist(new ReferralUrlBlacklist(), bad); string ourNamespace = "urn:newtelligence-com:dasblog:runtime:data"; foreach (string file in Directory.GetFiles(path,"*.dayfeedback.xml")) { badWordsCount = 0; NameTable nt = new NameTable(); object permaLink = nt.Add("PermaLink"); XmlNamespaceManager ns = new XmlNamespaceManager(nt); ns.AddNamespace("def", ourNamespace); XmlDocument x = new XmlDocument(nt); try { x.Load(file); } catch (XmlException ex) { WriteLine(String.Format("ERROR: Malformed Xml in file: {0}",file)); WriteLine(ex.ToString()); Console.WriteLine("Press ENTER to continue..."); Console.ReadLine(); } XmlNodeList nodes = x.SelectNodes("/def:DayExtra/def:Trackings/def:Tracking", ns); Console.WriteLine("Found {0} trackings/referrals in {1}",nodes.Count,file); for (int i = 0; i < nodes.Count; i++) { XmlNode node = nodes[i]; XmlNode permaLinkNode = node[(string)permaLink]; if (permaLinkNode != null && IsBadNode(permaLinkNode.InnerText)) { badWordsCount++; totalBadWordsCount++; node.ParentNode.RemoveChild(node); } } if (badWordsCount > 0) { x.Save(file); } WriteLine(String.Format("Found {0} bad words in {1}...", badWordsCount, Path.GetFileName(file))); } }
public static int Main(string[] args) { ParseCommandLine(args); CommandLineTraceHandler.Enable(); if (s_listRules) { CompositionHost c = GetCompositionHost(); ExportCciSettings.StaticSettings = CciComparers.Default.GetEqualityComparer <ITypeReference>(); var rules = c.GetExports <IDifferenceRule>(); foreach (var rule in rules.Select(r => r.GetType().Name).OrderBy(r => r, StringComparer.OrdinalIgnoreCase)) { Console.WriteLine(rule); } return(0); } using (TextWriter output = GetOutput()) { if (DifferenceWriter.ExitCode != 0) { return(0); } if (output != Console.Out) { Trace.Listeners.Add(new TextWriterTraceListener(output) { Filter = new EventTypeFilter(SourceLevels.Error | SourceLevels.Warning) }); } try { BaselineDifferenceFilter filter = GetBaselineDifferenceFilter(); NameTable sharedNameTable = new NameTable(); HostEnvironment contractHost = new HostEnvironment(sharedNameTable); contractHost.UnableToResolve += new EventHandler <UnresolvedReference <IUnit, AssemblyIdentity> >(contractHost_UnableToResolve); contractHost.ResolveAgainstRunningFramework = s_resolveFx; contractHost.UnifyToLibPath = s_unifyToLibPaths; contractHost.AddLibPaths(HostEnvironment.SplitPaths(s_contractLibDirs)); IEnumerable <IAssembly> contractAssemblies = contractHost.LoadAssemblies(s_contractSet, s_contractCoreAssembly); if (s_ignoreDesignTimeFacades) { contractAssemblies = contractAssemblies.Where(a => !a.IsFacade()); } HostEnvironment implHost = new HostEnvironment(sharedNameTable); implHost.UnableToResolve += new EventHandler <UnresolvedReference <IUnit, AssemblyIdentity> >(implHost_UnableToResolve); implHost.ResolveAgainstRunningFramework = s_resolveFx; implHost.UnifyToLibPath = s_unifyToLibPaths; implHost.AddLibPaths(HostEnvironment.SplitPaths(s_implDirs)); if (s_warnOnMissingAssemblies) { implHost.LoadErrorTreatment = ErrorTreatment.TreatAsWarning; } // The list of contractAssemblies already has the core assembly as the first one (if _contractCoreAssembly was specified). IEnumerable <IAssembly> implAssemblies = implHost.LoadAssemblies(contractAssemblies.Select(a => a.AssemblyIdentity), s_warnOnIncorrectVersion); // Exit after loading if the code is set to non-zero if (DifferenceWriter.ExitCode != 0) { return(0); } ICciDifferenceWriter writer = GetDifferenceWriter(output, filter); writer.Write(s_implDirs, implAssemblies, s_contractSet, contractAssemblies); return(0); } catch (FileNotFoundException) { // FileNotFoundException will be thrown by GetBaselineDifferenceFilter if it doesn't find the baseline file // OR if GetComparers doesn't find the remap file. return(2); } } }
/// <summary> /// Same as <see cref="XmlNamespaceManager"/>. /// </summary> public override string?LookupNamespace(string prefix) { var key = NameTable?.Get(prefix); return(key == null ? null : base.LookupNamespace(key)); }
// Test parser context property changes. public void TestXmlParserContextProperties() { NameTable nt = new NameTable(); NameTable nt2 = new NameTable(); XmlNamespaceManager ns = new XmlNamespaceManager(nt); XmlParserContext ctx = new XmlParserContext (nt, ns, null, XmlSpace.None); // Set and check the various properties. ctx.BaseURI = "xyzzy"; AssertEquals("BaseURI (1)", "xyzzy", ctx.BaseURI); ctx.BaseURI = null; AssertEquals("BaseURI (2)", "", ctx.BaseURI); ctx.DocTypeName = "xyzzy"; AssertEquals("DocTypeName (1)", "xyzzy", ctx.DocTypeName); ctx.DocTypeName = null; AssertEquals("DocTypeName (2)", "", ctx.DocTypeName); ctx.Encoding = Encoding.UTF8; AssertEquals("Encoding (1)", Encoding.UTF8, ctx.Encoding); ctx.Encoding = null; AssertEquals("Encoding (2)", null, ctx.Encoding); ctx.InternalSubset = "xyzzy"; AssertEquals("InternalSubset (1)", "xyzzy", ctx.InternalSubset); ctx.InternalSubset = null; AssertEquals("InternalSubset (2)", "", ctx.InternalSubset); ctx.NameTable = nt2; AssertEquals("NameTable (1)", nt2, ctx.NameTable); ctx.NameTable = null; AssertEquals("NameTable (2)", null, ctx.NameTable); ctx.NamespaceManager = null; AssertEquals("NamespaceManager (1)", null, ctx.NamespaceManager); ctx.NamespaceManager = ns; AssertEquals("NamespaceManager (2)", ns, ctx.NamespaceManager); ctx.PublicId = "xyzzy"; AssertEquals("PublicId (1)", "xyzzy", ctx.PublicId); ctx.PublicId = null; AssertEquals("PublicId (2)", "", ctx.PublicId); ctx.SystemId = "xyzzy"; AssertEquals("SystemId (1)", "xyzzy", ctx.SystemId); ctx.SystemId = null; AssertEquals("PublicId (2)", "", ctx.SystemId); ctx.XmlLang = "xyzzy"; AssertEquals("XmlLang (1)", "xyzzy", ctx.XmlLang); ctx.XmlLang = null; AssertEquals("XmlLang (2)", "", ctx.XmlLang); ctx.XmlSpace = XmlSpace.Default; AssertEquals("XmlSpace (1)", XmlSpace.Default, ctx.XmlSpace); ctx.XmlSpace = XmlSpace.None; AssertEquals("XmlSpace (2)", XmlSpace.None, ctx.XmlSpace); }
// Check the "RemoveNamespace" method. public void TestXmlNamespaceManagerRemove() { NameTable table = new NameTable(); XmlNamespaceManager ns = new XmlNamespaceManager(table); // Test the exception behaviour. try { ns.AddNamespace(null, "uri"); Fail("Remove (1)"); } catch(ArgumentNullException) { // Success } try { ns.AddNamespace("prefix", null); Fail("Remove (2)"); } catch(ArgumentNullException) { // Success } // Cannot remove standard namespaces. ns.RemoveNamespace ("xml", "http://www.w3.org/XML/1998/namespace"); AssertEquals("Remove (3)", "http://www.w3.org/XML/1998/namespace", ns.LookupNamespace("xml")); ns.RemoveNamespace ("xmlns", "http://www.w3.org/2000/xmlns/"); AssertEquals("Remove (3)", "http://www.w3.org/2000/xmlns/", ns.LookupNamespace("xmlns")); // Add and remove a particular namespace. ns.AddNamespace("foo", "uri"); ns.RemoveNamespace("foo", "uri"); AssertNull("Remove (4)", ns.LookupNamespace("foo")); // Make sure that we cannot remove namespaces in parent scopes. ns.AddNamespace("foo", "uri"); ns.PushScope(); ns.RemoveNamespace("foo", "uri"); AssertEquals("Remove (5)", "uri", ns.LookupNamespace("foo")); // Try removing a namespace with the wrong URI or prefix. ns.AddNamespace("foo", "uri2"); ns.RemoveNamespace("foo", "uri"); AssertEquals("Remove (6)", "uri2", ns.LookupNamespace("foo")); ns.RemoveNamespace("foo2", "uri"); AssertEquals("Remove (7)", "uri2", ns.LookupNamespace("foo")); }
public static bool Execute( string seeds, string contracts, string facadePath, Version assemblyFileVersion = null, bool clearBuildAndRevision = false, bool ignoreMissingTypes = false, bool ignoreBuildAndRevisionMismatch = false, bool buildDesignTimeFacades = false, string inclusionContracts = null, ErrorTreatment seedLoadErrorTreatment = ErrorTreatment.Default, ErrorTreatment contractLoadErrorTreatment = ErrorTreatment.Default, string[] seedTypePreferencesUnsplit = null, bool forceZeroVersionSeeds = false, bool producePdb = true, string partialFacadeAssemblyPath = null, bool buildPartialReferenceFacade = false) { if (!Directory.Exists(facadePath)) { Directory.CreateDirectory(facadePath); } var nameTable = new NameTable(); var internFactory = new InternFactory(); try { Dictionary <string, string> seedTypePreferences = ParseSeedTypePreferences(seedTypePreferencesUnsplit); using (var contractHost = new HostEnvironment(nameTable, internFactory)) using (var seedHost = new HostEnvironment(nameTable, internFactory)) { contractHost.LoadErrorTreatment = contractLoadErrorTreatment; seedHost.LoadErrorTreatment = seedLoadErrorTreatment; var contractAssemblies = LoadAssemblies(contractHost, contracts); IReadOnlyDictionary <string, IEnumerable <string> > docIdTable = GenerateDocIdTable(contractAssemblies, inclusionContracts); IAssembly[] seedAssemblies = LoadAssemblies(seedHost, seeds).ToArray(); IAssemblyReference seedCoreAssemblyRef = ((Microsoft.Cci.Immutable.PlatformType)seedHost.PlatformType).CoreAssemblyRef; if (forceZeroVersionSeeds) { // Create a deep copier, copy the seed assemblies, and zero out their versions. var copier = new MetadataDeepCopier(seedHost); for (int i = 0; i < seedAssemblies.Length; i++) { var mutableSeed = copier.Copy(seedAssemblies[i]); mutableSeed.Version = new Version(0, 0, 0, 0); // Copy the modified seed assembly back. seedAssemblies[i] = mutableSeed; if (mutableSeed.Name.UniqueKey == seedCoreAssemblyRef.Name.UniqueKey) { seedCoreAssemblyRef = mutableSeed; } } } var typeTable = GenerateTypeTable(seedAssemblies); var facadeGenerator = new FacadeGenerator(seedHost, contractHost, docIdTable, typeTable, seedTypePreferences, clearBuildAndRevision, buildDesignTimeFacades, assemblyFileVersion); if (buildPartialReferenceFacade && ignoreMissingTypes) { throw new FacadeGenerationException( "When buildPartialReferenceFacade is specified ignoreMissingTypes must not be specified."); } if (partialFacadeAssemblyPath != null) { if (contractAssemblies.Count() != 1) { throw new FacadeGenerationException( "When partialFacadeAssemblyPath is specified, only exactly one corresponding contract assembly can be specified."); } if (buildPartialReferenceFacade) { throw new FacadeGenerationException( "When partialFacadeAssemblyPath is specified, buildPartialReferenceFacade must not be specified."); } IAssembly contractAssembly = contractAssemblies.First(); IAssembly partialFacadeAssembly = seedHost.LoadAssembly(partialFacadeAssemblyPath); if (contractAssembly.Name != partialFacadeAssembly.Name || contractAssembly.Version.Major != partialFacadeAssembly.Version.Major || contractAssembly.Version.Minor != partialFacadeAssembly.Version.Minor || (!ignoreBuildAndRevisionMismatch && contractAssembly.Version.Build != partialFacadeAssembly.Version.Build) || (!ignoreBuildAndRevisionMismatch && contractAssembly.Version.Revision != partialFacadeAssembly.Version.Revision) || contractAssembly.GetPublicKeyToken() != partialFacadeAssembly.GetPublicKeyToken()) { throw new FacadeGenerationException( string.Format("The partial facade assembly's name, version, and public key token must exactly match the contract to be filled. Contract: {0}, Facade: {1}", contractAssembly.AssemblyIdentity, partialFacadeAssembly.AssemblyIdentity)); } Assembly filledPartialFacade = facadeGenerator.GenerateFacade(contractAssembly, seedCoreAssemblyRef, ignoreMissingTypes, overrideContractAssembly: partialFacadeAssembly, forceAssemblyReferenceVersionsToZero: forceZeroVersionSeeds); if (filledPartialFacade == null) { Trace.TraceError("Errors were encountered while generating the facade."); return(false); } string pdbLocation = null; if (producePdb) { string pdbFolder = Path.GetDirectoryName(partialFacadeAssemblyPath); pdbLocation = Path.Combine(pdbFolder, contractAssembly.Name + ".pdb"); if (producePdb && !File.Exists(pdbLocation)) { pdbLocation = null; Trace.TraceWarning("No PDB file present for un-transformed partial facade. No PDB will be generated."); } } OutputFacadeToFile(facadePath, seedHost, filledPartialFacade, contractAssembly, pdbLocation); } else { foreach (var contract in contractAssemblies) { Assembly facade = facadeGenerator.GenerateFacade(contract, seedCoreAssemblyRef, ignoreMissingTypes, buildPartialReferenceFacade: buildPartialReferenceFacade); if (facade == null) { #if !COREFX Debug.Assert(Environment.ExitCode != 0); #endif return(false); } OutputFacadeToFile(facadePath, seedHost, facade, contract); } } } return(true); } catch (FacadeGenerationException ex) { Trace.TraceError(ex.Message); #if !COREFX Debug.Assert(Environment.ExitCode != 0); #endif return(false); } }
static void Main(string[] args) { //if (args.Length < 1) //{ // System.Console.Out.WriteLine("usage: SQLBibleAddRegEx connString"); // return; //} connString = null; if (args.Length > 0) { connString = args[0]; } else { connString = @"Server=localhost\SQLEXPRESS2014;Initial Catalog=AnalyzeBible_Dev;Trusted_Connection=true"; } if (args.Length > 1) { outputFile = args[1]; } else { //outputFile = Environment.ExpandEnvironmentVariables(@"%USERPROFILE%\documents\RDF\bible.rdf"); outputFile = Environment.ExpandEnvironmentVariables(@"%USERPROFILE%\documents\RDF\genesis.rdf"); System.IO.FileInfo fileInfo = new System.IO.FileInfo(outputFile); if (!fileInfo.Directory.Exists) { fileInfo.Directory.Create(); } } XmlNameTable nameTable = new NameTable(); XmlNamespaceManager namespaceManager = new XmlNamespaceManager(nameTable); namespaceManager.AddNamespace("person", "http://www.rdfbible.com/dev3/ns/person.owl"); namespaceManager.AddNamespace("xsd", "http://www.w3.org/2001/XMLSchema#"); namespaceManager.AddNamespace("rdf", "http://www.w3.org/1999/02/22-rdf-syntax-ns#"); namespaceManager.AddNamespace("rdfs", "http://www.w3.org/2000/01/rdf-schema#"); XmlDocument xmlDocument = new XmlDocument(namespaceManager.NameTable); XmlNode root = xmlDocument.CreateElement("rdf", "RDF", "http://www.w3.org/1999/02/22-rdf-syntax-ns#"); xmlDocument.AppendChild(root); Dictionary <string, HashSet <string> > parentChildren = new Dictionary <string, HashSet <string> >(); Dictionary <string, Tuple <string, bool, bool> > nameGenderVisionDreams = new Dictionary <string, Tuple <string, bool, bool> >(); BibleEdition bibleEdition = new BibleEdition(); bibleEdition.BibleKey = "kjv"; bibleEdition.BibleName = "KJV"; bibleEdition.BibleBooks = new List <BibleBook>(); using (SqlConnection con = new SqlConnection(connString)) { con.Open(); using (SqlCommand cmd = new SqlCommand()) { cmd.Connection = con; cmd.CommandText = "dbo.GetBibleVerses"; cmd.CommandType = System.Data.CommandType.StoredProcedure; cmd.Parameters.AddWithValue("@BibleName", "KJV"); cmd.Parameters.AddWithValue("@BibleBook", "Genesis"); using (SqlDataReader reader = cmd.ExecuteReader()) { while (reader.Read()) { string bookName = (string)reader["BookName"]; short chapterNumber = (short)reader["ChapterNumber"]; short verseNumber = (short)reader["VerseNumber"]; string verseText = (string)reader["VerseText"]; BibleBook book = GetBook(bibleEdition, bookName); BibleChapter chapter = GetChapter(book, chapterNumber); BibleVerse verse = GetVerse(chapter, verseNumber); verse.VerseText = verseText; List <string> words = GetWords(verseText).ToList(); SetWords(verse, words); } } } } XmlNode xbibleEdition = xmlDocument.CreateElement("bible", "BibleEdition", "http://www.rdfbible.com/dev3/ns/bible.owl"); root.AppendChild(xbibleEdition); XmlAttribute id = xmlDocument.CreateAttribute("rdf", "ID", "http://www.w3.org/1999/02/22-rdf-syntax-ns#"); id.Value = bibleEdition.BibleKey; xbibleEdition.Attributes.Append(id); XmlNode editionName = xmlDocument.CreateElement("bible", "name", "http://www.rdfbible.com/dev3/ns/bible.owl"); editionName.InnerText = bibleEdition.BibleName; xbibleEdition.AppendChild(editionName); foreach (var bibleBook in bibleEdition.BibleBooks) { XmlNode book = xmlDocument.CreateElement("bible", "BibleBook", "http://www.rdfbible.com/dev3/ns/bible.owl"); root.AppendChild(book); XmlAttribute id2 = xmlDocument.CreateAttribute("rdf", "ID", "http://www.w3.org/1999/02/22-rdf-syntax-ns#"); id2.Value = bibleBook.BookKey; book.Attributes.Append(id2); XmlNode bookName = xmlDocument.CreateElement("bible", "name", "http://www.rdfbible.com/dev3/ns/bible.owl"); bookName.InnerText = bibleBook.BookName; book.AppendChild(bookName); XmlNode hasBibleBook = xmlDocument.CreateElement("bible", "hasBibleBook", "http://www.rdfbible.com/dev3/ns/bible.owl"); xbibleEdition.AppendChild(hasBibleBook); XmlAttribute hasBibleBookReference = xmlDocument.CreateAttribute("rdf", "resource", "http://www.w3.org/1999/02/22-rdf-syntax-ns#"); hasBibleBookReference.Value = "#" + bibleBook.BookKey; hasBibleBook.Attributes.Append(hasBibleBookReference); foreach (var bibleChapter in bibleBook.BibleChapters) { XmlNode chapter = xmlDocument.CreateElement("bible", "BibleChapter", "http://www.rdfbible.com/dev3/ns/bible.owl"); root.AppendChild(chapter); XmlAttribute id3 = xmlDocument.CreateAttribute("rdf", "ID", "http://www.w3.org/1999/02/22-rdf-syntax-ns#"); id3.Value = bibleChapter.ChapterKey; chapter.Attributes.Append(id3); XmlNode chapterNumber = xmlDocument.CreateElement("bible", "number", "http://www.rdfbible.com/dev3/ns/bible.owl"); chapterNumber.InnerText = bibleChapter.ChapterNumber.ToString(); chapter.AppendChild(chapterNumber); XmlNode hasBibleChapter = xmlDocument.CreateElement("bible", "hasBibleChapter", "http://www.w3.org/1999/02/22-rdf-syntax-ns#"); book.AppendChild(hasBibleChapter); XmlAttribute hasBibleChapterReference = xmlDocument.CreateAttribute("rdf", "resource", "http://www.w3.org/1999/02/22-rdf-syntax-ns#"); hasBibleChapterReference.Value = "#" + bibleChapter.ChapterKey; hasBibleChapter.Attributes.Append(hasBibleChapterReference); foreach (var bibleVerse in bibleChapter.BibleVerses) { XmlNode verse = xmlDocument.CreateElement("bible", "BibleVerse", "http://www.rdfbible.com/dev3/ns/bible.owl"); root.AppendChild(verse); XmlAttribute id4 = xmlDocument.CreateAttribute("rdf", "ID", "http://www.w3.org/1999/02/22-rdf-syntax-ns#"); id4.Value = bibleVerse.VerseKey; verse.Attributes.Append(id4); XmlNode verseNumber = xmlDocument.CreateElement("bible", "number", "http://www.rdfbible.com/dev3/ns/bible.owl"); verseNumber.InnerText = bibleVerse.VerseNumber.ToString(); verse.AppendChild(verseNumber); XmlNode verseText = xmlDocument.CreateElement("bible", "text", "http://www.rdfbible.com/dev3/ns/bible.owl"); verseText.InnerText = bibleVerse.VerseText; verse.AppendChild(verseText); XmlNode hasBibleVerse = xmlDocument.CreateElement("bible", "hasBibleVerse", "http://www.rdfbible.com/dev3/ns/bible.owl"); chapter.AppendChild(hasBibleVerse); XmlAttribute hasBibleVerseReference = xmlDocument.CreateAttribute("rdf", "resource", "http://www.w3.org/1999/02/22-rdf-syntax-ns#"); hasBibleVerseReference.Value = "#" + bibleVerse.VerseKey; hasBibleVerse.Attributes.Append(hasBibleVerseReference); foreach (var bibleWord in bibleVerse.Words) { XmlNode word = xmlDocument.CreateElement("bible", "BibleWord", "http://www.rdfbible.com/dev3/ns/bible.owl"); root.AppendChild(word); XmlAttribute id5 = xmlDocument.CreateAttribute("rdf", "ID", "http://www.w3.org/1999/02/22-rdf-syntax-ns#"); id5.Value = bibleWord.WordKey; word.Attributes.Append(id5); XmlElement wordText = xmlDocument.CreateElement("bible", "text", "http://www.rdfbible.com/dev3/ns/bible.owl"); wordText.InnerText = bibleWord.Word; word.AppendChild(wordText); XmlNode hasBibleWord = xmlDocument.CreateElement("bible", "hasBibleWord", "http://www.rdfbible.com/dev3/ns/bible.owl"); verse.AppendChild(hasBibleWord); XmlAttribute hasBibleWordReference = xmlDocument.CreateAttribute("rdf", "resource", "http://www.rdfbible.com/dev3/ns/bible.owl"); hasBibleWordReference.Value = "#" + bibleWord.WordKey; hasBibleWord.Attributes.Append(hasBibleWordReference); } } } } xmlDocument.Save(outputFile); }
public override IEnumerable <LogItem> GetEntries(string dataSource, FilterParams filter) { var settings = new XmlReaderSettings { ConformanceLevel = ConformanceLevel.Fragment }; var nt = new NameTable(); var mgr = new XmlNamespaceManager(nt); mgr.AddNamespace("log4j", Constants.LAYOUT_LOG4J); var pc = new XmlParserContext(nt, mgr, string.Empty, XmlSpace.Default); var date = new DateTime(1970, 1, 1, 0, 0, 0, 0); using (var stream = new FileStream(dataSource, FileMode.OpenOrCreate, FileAccess.Read, FileShare.ReadWrite)) { using (var reader = new StreamReader(stream, System.Text.Encoding.Default, true)) { using (var xmlTextReader = XmlReader.Create(reader, settings, pc)) { var entryId = 1; DateTime?prevTimeStamp = null; while (xmlTextReader.Read()) { if ((xmlTextReader.NodeType != XmlNodeType.Element) || (xmlTextReader.Name != "log4j:event")) { continue; } var entry = new LogItem { Id = entryId, Path = dataSource }; entry.Logger = xmlTextReader.GetAttribute("logger"); entry.TimeStamp = date.AddMilliseconds(Convert.ToDouble(xmlTextReader.GetAttribute("timestamp"))).ToLocalTime(); if (prevTimeStamp.HasValue) { entry.Delta = (entry.TimeStamp - prevTimeStamp.Value).TotalSeconds; } prevTimeStamp = entry.TimeStamp; entry.Level = xmlTextReader.GetAttribute("level"); entry.Thread = xmlTextReader.GetAttribute("thread"); while (xmlTextReader.Read()) { var breakLoop = false; switch (xmlTextReader.Name) { case "log4j:event": breakLoop = true; break; default: switch (xmlTextReader.Name) { case ("log4j:message"): entry.Message = xmlTextReader.ReadString(); break; case ("log4j:data"): switch (xmlTextReader.GetAttribute("name")) { case ("log4net:UserName"): entry.UserName = xmlTextReader.GetAttribute("value"); break; case ("log4japp"): entry.App = xmlTextReader.GetAttribute("value"); break; case ("log4jmachinename"): entry.MachineName = xmlTextReader.GetAttribute("value"); break; case ("log4net:HostName"): entry.HostName = xmlTextReader.GetAttribute("value"); break; } break; case ("log4j:throwable"): entry.Throwable = xmlTextReader.ReadString(); break; case ("log4j:locationInfo"): entry.Class = xmlTextReader.GetAttribute("class"); entry.Method = xmlTextReader.GetAttribute("method"); entry.File = xmlTextReader.GetAttribute("file"); entry.Line = xmlTextReader.GetAttribute("line"); break; } break; } if (breakLoop) { break; } } if (filterByParameters(entry, filter)) { yield return(entry); entryId++; } } } } } }
public static IInitializeDocumentSpec InitializeDocumentSpec(IDocumentSpec documentSpec, string documentSpecName, string schemaFileName, ArrayList propertyAnnotations) { IInitializeDocumentSpec spec = (IInitializeDocumentSpec)documentSpec; XmlDocument xmlDocument = new XmlDocument(); xmlDocument.Load(new XmlTextReader(schemaFileName)); string documentType = GetDocumentType(xmlDocument); string targetNamespace = GetTargetNamespace(xmlDocument); string bodyXPath = GetBodyXPath(xmlDocument); Hashtable schemaList = new Hashtable(); schemaList.Add(targetNamespace, new FileStream(schemaFileName, FileMode.Open, FileAccess.Read)); spec.Initialize(targetNamespace, documentSpecName, documentType, bodyXPath, schemaList); NameTable nameTable = new NameTable(); XmlNamespaceManager nsmgr = new XmlNamespaceManager(nameTable); nsmgr.AddNamespace("xs", "http://www.w3.org/2001/XMLSchema"); nsmgr.AddNamespace("b", "http://schemas.microsoft.com/BizTalk/2003"); Hashtable hashtable2 = new Hashtable(); Hashtable hashtable3 = new Hashtable(); foreach (XmlNode node in xmlDocument.SelectNodes("/xs:schema/xs:annotation/xs:appinfo/b:imports/b:namespace", nsmgr)) { hashtable2.Add(node.Attributes["prefix"].InnerText, node.Attributes["uri"].InnerText); string innerText = node.Attributes["location"].InnerText; if (new FileInfo(innerText).Exists) { XmlDocument document2 = new XmlDocument(); document2.Load(innerText); hashtable3.Add(node.Attributes["uri"].InnerText, document2); } } foreach (XmlNode node2 in xmlDocument.SelectNodes("/xs:schema//xs:annotation/xs:appinfo/b:properties/b:property[not(@distinguished='true')]", nsmgr)) { PropertyAnnotation annotation = new PropertyAnnotation(); string str5 = node2.Attributes["name"].InnerText; annotation.Name = str5.Split(new char[] { ':' })[1]; annotation.Namespace = (string)hashtable2[str5.Split(new char[] { ':' })[0]]; annotation.XPath = node2.Attributes["xpath"].InnerText; annotation.XSDType = null; XmlDocument document3 = (XmlDocument)hashtable3[annotation.Namespace]; if (document3 != null) { XmlNode node3 = document3.SelectSingleNode(string.Format(CultureInfo.CurrentCulture, "/xs:schema/xs:element[@name='{0}']", new object[] { annotation.Name }), nsmgr); if (node3 != null) { XmlNode node4 = node3.Attributes["type"]; if (node4 != null) { string[] strArray = node4.InnerText.Split(new char[] { ':' }); if (2 == strArray.Length) { annotation.XSDType = strArray[1]; } else if (1 == strArray.Length) { annotation.XSDType = strArray[0]; } } } } if (annotation.XSDType == null) { annotation.XSDType = "string"; } if (propertyAnnotations != null) { propertyAnnotations.Add(annotation); } spec.AddAnnotation(annotation); } return(spec); }
public static bool Import(TextReader streamReader, IResource rootGroup, bool addToWorkspace, Hashtable namespaces) { bool hasOPML = false; bool lastOutlineIsGroup = false; try { NameTable nt = new NameTable(); // Fill name table if (namespaces != null) { foreach (string key in namespaces.Keys) { nt.Add(key); nt.Add(namespaces[key] as string); } } XmlNamespaceManager nsmgr = new LooseNSManager(nt, namespaces); XmlParserContext ctx = new XmlParserContext(nt, nsmgr, null, XmlSpace.None); string xml = Utils.StreamReaderReadToEnd(streamReader); XmlTextReader reader = new XmlTextReader(xml, XmlNodeType.Document, ctx); try { IResource curGroup = rootGroup; while (reader.Read()) { if (reader.NodeType == XmlNodeType.Element) { if (reader.LocalName == "opml") { hasOPML = true; } else if (hasOPML && reader.LocalName == "outline") { if (reader.MoveToAttribute("xmlUrl") || reader.MoveToAttribute("xmlurl")) { ProcessFeed(reader, curGroup, addToWorkspace); } else if (reader.MoveToAttribute("text") || reader.MoveToAttribute("title")) { IResource group = FindOrCreateGroup(curGroup, reader.Value); reader.MoveToElement(); if (!reader.IsEmptyElement) { curGroup = group; lastOutlineIsGroup = true; } } } } else if (reader.NodeType == XmlNodeType.EndElement) { if (reader.LocalName == "outline") { if (lastOutlineIsGroup) { curGroup = curGroup.GetLinkProp("Parent"); lastOutlineIsGroup = true; } } } } } finally { reader.Close(); } } finally { streamReader.Close(); } return(hasOPML); }
public override string LookupPrefix(string uri) { var key = NameTable.Get(uri); return(key == null ? null : base.LookupPrefix(key)); }
/// <summary> /// Main entry point for sample application. /// </summary> /// <param name="args"></param> public static void Main(string[] args) { XmlSchema myXmlSchema; XmlTextWriter myXmlTextWriter; try { Console.WriteLine("Creating Schema in the Schema Object Model..."); // Setup console output. myXmlTextWriter = new XmlTextWriter(Console.Out); myXmlTextWriter.Formatting = Formatting.Indented; myXmlTextWriter.Indentation = 2; //Create an XmlNameTable. XmlNameTable myXmlNameTable = new NameTable(); //Add the nametable to the XmlSchemaCollection. XmlSchemaCollection myXmlSchemaCollection = new XmlSchemaCollection(myXmlNameTable); //Add some schemas to the XmlSchemaCollection. Console.WriteLine("Reading and adding {0} schema.", BOOKSCHEMA); myXmlSchemaCollection.Add(null, BOOKSCHEMA); Console.WriteLine("Reading and adding {0} schema.", POSCHEMA); myXmlSchemaCollection.Add(null, POSCHEMA); Console.WriteLine("Added schemas successfully ..."); Console.WriteLine("Showing added schemas"); foreach (XmlSchema myTempXmlSchema in myXmlSchemaCollection) { myXmlSchema = myTempXmlSchema; Console.WriteLine(); string outfile = myTempXmlSchema.SourceUri.Replace("file:///", ""); Console.WriteLine("Schema from: {0}", outfile); Console.WriteLine(); Console.WriteLine("=== Start of Schema ==="); Console.WriteLine(); // Write out the various schema parts WriteXSDSchema(myXmlSchema, myXmlTextWriter); Console.WriteLine(); Console.WriteLine(); Console.WriteLine("=== End of Schema ==="); Console.WriteLine(); Console.WriteLine("Example of possible XML contents for: {0}", outfile); Console.WriteLine(); Console.WriteLine("=== Start of Example ==="); // Write out an example of the XML for the schema WriteExample(myXmlSchema, myXmlTextWriter); Console.WriteLine(); Console.WriteLine(); Console.WriteLine("=== End of Example ==="); } //foreach } //try catch (Exception e) { Console.WriteLine("Exception: {0}", e.ToString()); } //catch } //Main()
/// <summary> /// Constructor /// </summary> /// <param name="nametable"></param> public ExtendedXPathFunctions(NameTable nametable) : base(nametable) { }
// Check the "HasNamespace" method. public void TestXmlNamespaceManagerHas() { NameTable table = new NameTable(); XmlNamespaceManager ns = new XmlNamespaceManager(table); Assert("Has (1)", ns.HasNamespace("xml")); Assert("Has (2)", ns.HasNamespace("xmlns")); Assert("Has (3)", ns.HasNamespace("")); Assert("Has (4)", !ns.HasNamespace("foo")); ns.AddNamespace("foo", "uri"); Assert("Has (5)", ns.HasNamespace("xml")); Assert("Has (6)", ns.HasNamespace("xmlns")); Assert("Has (7)", ns.HasNamespace("")); Assert("Has (8)", ns.HasNamespace("foo")); ns.PushScope(); ns.AddNamespace("bar", "uri2"); Assert("Has (9)", ns.HasNamespace("xml")); Assert("Has (10)", ns.HasNamespace("xmlns")); Assert("Has (11)", ns.HasNamespace("")); Assert("Has (12)", ns.HasNamespace("foo")); Assert("Has (13)", ns.HasNamespace("bar")); ns.PopScope(); Assert("Has (14)", ns.HasNamespace("xml")); Assert("Has (15)", ns.HasNamespace("xmlns")); Assert("Has (16)", ns.HasNamespace("")); Assert("Has (17)", ns.HasNamespace("foo")); Assert("Has (18)", !ns.HasNamespace("bar")); ns.RemoveNamespace("foo", "uri"); Assert("Has (19)", ns.HasNamespace("xml")); Assert("Has (20)", ns.HasNamespace("xmlns")); Assert("Has (21)", ns.HasNamespace("")); Assert("Has (22)", !ns.HasNamespace("foo")); Assert("Has (23)", !ns.HasNamespace("bar")); ns.RemoveNamespace("", ""); Assert("Has (24)", ns.HasNamespace("xml")); Assert("Has (25)", ns.HasNamespace("xmlns")); Assert("Has (26)", ns.HasNamespace("")); Assert("Has (27)", !ns.HasNamespace("foo")); Assert("Has (28)", !ns.HasNamespace("bar")); Assert("Has (29)", !ns.HasNamespace(null)); }
/// <summary> /// Constructor /// </summary> /// <param name="nametable"></param> /// <param name="Args"></param> public ExtendedXPathFunctions(NameTable nametable, XsltArgumentList Args) : base(nametable) { ArgumentList = Args; }
public DynamicContext(NameTable table) : base(table) { }
private NameManager(NameTable nameTable) { _names = nameTable; InitKnownNames(); }
/// <summary> /// Creates new ExsltContext instance. /// </summary> public ExsltContext(NameTable nt, ExsltFunctionNamespace supportedFunctions) : this(nt) { SupportedFunctions = supportedFunctions; }
void WebClient_OpenReadCompleted(object sender, OpenReadCompletedEventArgs e) { if (e.Cancelled || _targetItem == null) { return; } Exception ex = e.Error; if (ex == null) { try { if (_targetItem.Tile == null) { var doc = new XmlDocument(); doc.Load(e.Result); var nameTable = new NameTable(); var nm = new XmlNamespaceManager(nameTable); nm.AddNamespace("ns", "http://www.w3.org/2005/Atom"); nm.AddNamespace("flickr", "urn:flickr:user"); List <FlickrPhoto> result = new List <FlickrPhoto>(); TileCollection tiles = flickrTiles.Groups[0].Tiles; bool keepExistent = _targetItem.IsBuddyIcon; foreach (XmlNode node in doc.DocumentElement.SelectNodes("ns:entry", nm)) { string id = node.SelectSingleNode("ns:id", nm).InnerText; if (keepExistent) { bool found = false; foreach (Tile tile in tiles) { if (((FlickrPhoto)tile.Tag).ID == id) { found = true; break; } } if (found) { continue; } } var photo = new FlickrPhoto(); photo.ID = id; photo.Title = PrepareTitle(node.SelectSingleNode("ns:title", nm).InnerText); var authorNode = node.SelectSingleNode("ns:author", nm); if (authorNode != null) { photo.AuthorName = authorNode.SelectSingleNode("ns:name", nm).InnerText; photo.AuthorBuddyIconUri = authorNode.SelectSingleNode("flickr:buddyicon", nm).InnerText; } var linkNode = node.SelectSingleNode("ns:link[@rel='enclosure']", nm); if (linkNode != null) { photo.ContentUri = linkNode.Attributes["href"].Value; photo.ThumbnailUri = photo.ContentUri.Replace("_b.jpg", "_m.jpg"); } result.Add(photo); } UpdatePhotos(result, tiles, keepExistent); } else { Image img = Image.FromStream(e.Result); Tile tile = _targetItem.Tile; if (!_targetItem.IsBuddyIcon) { tile.Image = img; } else { tile.Image1 = img; } } } catch (Exception exception) { ex = exception; } } if (ex != null && _targetItem.Tile == null && !_targetItem.IsBuddyIcon) { _targetItem = null; _lastError = ex.Message; ShowErrorTile(); } else { _targetItem = null; _lastError = null; if (_outOfTurnItem != null) { _targetItem = _outOfTurnItem; _outOfTurnItem = null; } else if (_downloadQueue.Count > 0) { _targetItem = _downloadQueue.Dequeue(); } if (_targetItem != null) { _client.OpenReadAsync(new Uri(_targetItem.Uri)); } } waitLabel.Visible = false; }
/// <summary>Initializes a new instance of the <see cref="FortifyConverter"/> class.</summary> public FortifyConverter() { _nameTable = new NameTable(); _strings = new FortifyStrings(_nameTable); }
public override SubscribeResponse Subscribe([System.Xml.Serialization.XmlElementAttribute("Subscribe", Namespace = "http://docs.oasis-open.org/wsn/b-2")] Subscribe Subscribe1) { ConfStorageLoad(); EventServerLoad(); SubscribeResponse res = new SubscribeResponse(); DateTime terminationTime; try { TimeSpan timeSpan = System.Xml.XmlConvert.ToTimeSpan(Subscribe1.InitialTerminationTime); terminationTime = DateTime.Now.Add(timeSpan); } catch (Exception) { try { terminationTime = System.Xml.XmlConvert.ToDateTime(Subscribe1.InitialTerminationTime, XmlDateTimeSerializationMode.Utc); } catch (Exception) { throw FaultLib.GetSoapException(FaultType.General, "Wrong Initial Termination Time."); } } string rawRequest = RequestListener.Take(); XmlElement filterElement = Utils.GetFilterElements(rawRequest); EventServer.AddSubscribtion(Subscribe1.ConsumerReference.Address.Value, Subscribe1.Filter, filterElement, terminationTime, false); res.CurrentTimeSpecified = true; res.CurrentTime = DateTime.Now; res.TerminationTimeSpecified = true; res.TerminationTime = terminationTime; res.SubscriptionReference = new EndpointReferenceType(); res.SubscriptionReference.Address = new AttributedURIType(); string hostAndPort = HttpContext.Current.Request.Url.Authority; res.SubscriptionReference.Address.Value = "http://" + hostAndPort + "/ServiceEvents10/NotificationProducer.asmx"; res.SubscriptionReference.ReferenceParameters = new ReferenceParametersType(); res.SubscriptionReference.ReferenceParameters.Any = new System.Xml.XmlElement[1]; NameTable nt = new NameTable(); XmlNamespaceManager nsmgr = new XmlNamespaceManager(nt); nsmgr.AddNamespace("xs", "http://www.w3.org/2001/XMLSchema"); nsmgr.AddNamespace("dut", "http://dut"); nsmgr.AddNamespace("tdc", "http://www.onvif.org/ver10/doorcontrol/wsdl"); XmlDocument referenceParameters = new XmlDocument(nt); res.SubscriptionReference.ReferenceParameters.Any[0] = referenceParameters.CreateElement("dut", "id", "http://dut"); EventServerSave(); ConfStorageSave(); throw new NotImplementedException(); }
public JsonXPathNavigator(JsonXPathNavigator source) { copyState(source._state); _nameTable = source._nameTable; }
public ActionResult dqSync() { using (var dm = new DatasetManager()) { List <long> datasetIds = dm.GetDatasetLatestIds(); //get latest EntityPermissionManager entityPermissionManager = new EntityPermissionManager(); DataStructureManager dsm = new DataStructureManager(); try { //datasetManager.SyncView(datasetIds, ViewCreationBehavior.Create | ViewCreationBehavior.Refresh); // if the viewData has a model error, the redirect forgets about it. string pathPerformers = @"C:\Data\DatasetQualities\Performers.csv"; StreamWriter writerPerformers = new StreamWriter(pathPerformers); string pathPerformerDataset = @"C:\Data\DatasetQualities\PerformerDataset.csv"; StreamWriter writerPerformerDataset = new StreamWriter(pathPerformerDataset); string pathComparison = @"C:\Data\DatasetQualities\Comparison.csv"; StreamWriter writerComparison = new StreamWriter(pathComparison); string pathDatasets = @"C:\Data\DatasetQualities\datasetInfo.csv"; StreamWriter writerDatasets = new StreamWriter(pathDatasets); string pathVariable = @"C:\Data\DatasetQualities\Variables.csv"; StreamWriter writerVariable = new StreamWriter(pathVariable); string pathFiles = @"C:\Data\DatasetQualities\Files.csv"; StreamWriter writerFiles = new StreamWriter(pathFiles); string variableHeader = "datasetId,VarLabel,varType,varDescription,varUse,varMissing"; writerVariable.WriteLine(variableHeader); string performer; List <string> performerDataset = new List <string>(); Dictionary <string, int> performerCount = new Dictionary <string, int>(); List <int> metadataRates = new List <int>(); int allValidMetadas = 0; //int publicDatasets = 0; //could not get result //int restrictedDatasets = 0; //could not get result List <int> dsDescLength = new List <int>(); List <int> dstrDescLength = new List <int>(); List <int> dstrUsage = new List <int>(); List <int> datasetSizeTabular = new List <int>(); List <int> datasetRows = new List <int>(); List <int> datasetCols = new List <int>(); List <double> datasetSizeFiles = new List <double>(); //all files in all datasets List <int> datasetFileNumber = new List <int>(); List <int> sizeTabular = new List <int>(); //collect size, column number, and row number for one dataset int fileDatasets = 0; int tabularDatasets = 0; int fileNumber = 0; List <double> datasetTotalSize = new List <double>(); //total file size of each dataset List <double> sizeFile = new List <double>(); /////////////////////////// foreach (long datasetId in datasetIds) { DatasetVersion datasetLatestVersion = dm.GetDatasetLatestVersion(datasetId); //get last dataset versions DataStructure dataStr = dsm.AllTypesDataStructureRepo.Get(datasetLatestVersion.Dataset.DataStructure.Id); //get data structure #region performers List <string> pers = new List <string>(); var dsvs = dm.GetDatasetVersions(datasetId); foreach (var d in dsvs) { performer = d.ModificationInfo.Performer; if (performer != null && !pers.Contains(performer)) { pers.Add(performer); //a list of performers } } foreach (var p in pers) { writerPerformerDataset.WriteLine(p + "," + datasetId); //fill the file PerformerDataset with a list of 'performer,datasetId' if (performerCount.ContainsKey(p)) { performerCount[p] += 1; } else { performerCount.Add(p, 1); } } #endregion #region allValidmetadatas long metadataStructureId = dm.DatasetRepo.Get(datasetId).MetadataStructure.Id; int validMetadata = 0; if (datasetLatestVersion.StateInfo != null) { validMetadata = DatasetStateInfo.Valid.ToString().Equals(datasetLatestVersion.StateInfo.State) ? 1 : 0; //1:valid; 0:invalid. } else { validMetadata = 0; } if (validMetadata == 1) //count how many datasets have valid metadata { allValidMetadas += 1; } #endregion #region metadataRates XmlDocument metadata = datasetLatestVersion.Metadata; string xmlFrag = metadata.OuterXml; List <int> metaInfo = new List <int>(); NameTable nt = new NameTable(); XmlNamespaceManager nsmgr = new XmlNamespaceManager(nt); // Create the XmlParserContext. XmlParserContext context = new XmlParserContext(null, nsmgr, null, XmlSpace.None); // Create the reader. XmlTextReader reader = new XmlTextReader(xmlFrag, XmlNodeType.Element, context); int countMetaAttr = 0; int countMetaComplition = 0; // Parse the XML and display each node. while (reader.Read()) { //XmlTextReader myReader = reader; if (reader.NodeType == XmlNodeType.Element) { if (reader.HasAttributes && reader.GetAttribute("type") == "MetadataAttribute") { countMetaAttr += 1; reader.Read(); if (reader.NodeType == XmlNodeType.Text) { string text = reader.Value; countMetaComplition += 1; } } } } // Close the reader. reader.Close(); int rate = (countMetaComplition * 100) / countMetaAttr; //percentage of all metadata fields contains information metadataRates.Add(rate); #endregion ////find how many public dataset exist //int publicRights = entityPermissionManager.GetRights(null, 1, datasetId); //1:public; 0:restricted //if (publicRights == 1) { publicDatasets += 1; } //if (publicRights == 0) { restrictedDatasets += 1; } ///issue here is that when a dataset has an empty dataset description field, the datasetLatestVersion.Description has the "not available" as value. int datasetLatestVersionDescriptionLength = 0; if (datasetLatestVersion.Description == "not available") { dsDescLength.Add(0); } else { dsDescLength.Add(datasetLatestVersion.Description.Length); //get dataset description length datasetLatestVersionDescriptionLength = datasetLatestVersion.Description.Length; } dstrDescLength.Add(datasetLatestVersion.Dataset.DataStructure.Description.Length); //get data structure description length dstrUsage.Add(dataStr.Datasets.Count() - 1); //data structure is used in how many other datasets (doesn't contain the current one) string type = "file"; if (dataStr.Self.GetType() == typeof(StructuredDataStructure)) { type = "tabular"; } //get dataset type int colNum = 0; int rowNum = 0; #region tabular dataset if (type == "tabular") { tabularDatasets += 1; try { DataTable table = dm.GetLatestDatasetVersionTuples(datasetId, true); DataRowCollection rowss = table.Rows; DataColumnCollection columns = table.Columns; StructuredDataStructure sds = dsm.StructuredDataStructureRepo.Get(datasetLatestVersion.Dataset.DataStructure.Id); //get data structure var variables = sds.Variables; //get variables //sizeTabular[1] = variables.Count; //columns.Count - 4; //if (sizeTabular[1] < 0) //if data structure has not been designed. //{ // sizeTabular[1] = 0; //} //sizeTabular[2] = rowss.Count; //sizeTabular[0] = sizeTabular[1] * sizeTabular[2]; colNum = variables.Count; rowNum = rowss.Count; #region variables int columnNumber = -1; //First four columns are added from system. if (variables.Count() > 0) { foreach (var variable in variables) { columnNumber += 1; //string missingValue = variable.MissingValue; //MISSING VALUE List <string> missingValues = new List <string>(); //creat a list contains missing values DataTable missTable = new DataTable(); foreach (var missValue in variable.MissingValues) //if data is equal missing value { missingValues.Add(missValue.Placeholder); } var varUse = variable.DataAttribute.UsagesAsVariable.Count() - 1; string varType = variable.DataAttribute.DataType.SystemType; int varMissing = 100; //suppose 100% is completed try { if (rowss.Count > 0) { int missing = rowss.Count; foreach (DataRow row in rowss) { var value = row.ItemArray[columnNumber]; //.ToString(); if (value == null || missingValues.Contains(value.ToString())) //check if cell is emty or contains a missing value { missing -= 1; } } varMissing = 100 * missing / rowss.Count; //% of existing values } else { varMissing = 0; } } catch { varMissing = 0; } string variableLine = datasetId + "," //0: dataset Id + variable.Label + "," //1: variable name + varType + "," //2: data type + variable.Description.Count() + "," //3: variable description length + varUse + "," //4: variable usage + varMissing; //5: % completed writerVariable.WriteLine(variableLine); } } #endregion } catch { colNum = 0; rowNum = 0; //sizeTabular.Add(0); //sizeTabular.Add(0); //sizeTabular.Add(0); } datasetSizeTabular.Add(colNum * rowNum); //sizeTabular[0]); datasetCols.Add(colNum); // sizeTabular[1]); //column number datasetRows.Add(rowNum); // sizeTabular[2]); //row number } #endregion #region file dataset else if (type == "file") { fileDatasets += 1; List <ContentDescriptor> contentDescriptors = datasetLatestVersion.ContentDescriptors.ToList(); fileNumber = contentDescriptors.Count; //datasetFileNumber.Add(fileNumber); //sizeFile.Add(fileNumber); int fileNum = 0; double totalSize = 0; string fileInDataset = ""; if (contentDescriptors.Count > 0) { foreach (ContentDescriptor cd in contentDescriptors) { if (cd.Name.ToLower().Equals("unstructureddata")) { fileNum += 1; string uri = cd.URI; String path = Server.UrlDecode(uri); path = Path.Combine(AppConfiguration.DataPath, path); try { Stream fileStream = System.IO.File.OpenRead(path); FileStream fs = fileStream as FileStream; if (fs != null) { FileInformation fileInfo = new FileInformation(fs.Name.Split('\\').LastOrDefault(), MimeMapping.GetMimeMapping(fs.Name), (uint)fs.Length, uri); totalSize += fileInfo.Size; fileInDataset = datasetId + "," + fileInfo.Name.Split('.')[0] + "," + fileInfo.Name.Split('.')[1].ToLower() + "," + fileInfo.Size; //datasetId,file name,file extension,file size writerFiles.WriteLine(fileInDataset); } } catch { datasetSizeFiles.Add(0); //file size } } } datasetFileNumber.Add(fileNum); datasetTotalSize.Add(totalSize); } else { datasetFileNumber.Add(0); datasetTotalSize.Add(0); } } #endregion //[0]datasetId, [1]dataType, [2]IsValid, [3]metadataComplitionRate, //[4]datasetDescLength, [5]dataStrDescrLength, [6]DataStrUsage, //[7]columns, [8]rows, [9]file numbers, [10]file sizes, [11]performers string datasetInfo = datasetId + ";" + type + ";" + validMetadata + ";" + rate + ";" + datasetLatestVersionDescriptionLength + ";" + datasetLatestVersion.Dataset.DataStructure.Description.Length + ";" + (dataStr.Datasets.Count() - 1); if (type == "tabular") { datasetInfo = datasetInfo + ";" + datasetCols.Last() //column number + ";" + datasetRows.Last() //row number + ";0;0"; //file number and size } if (type == "file") { datasetInfo = datasetInfo + ";0;0" //column and row number + ";" + datasetFileNumber.Last() //sizeFile[0] //file number + ";" + datasetTotalSize.Last(); //sizeFile[1]; //total size } string prfmrs = ""; foreach (string p in pers) { prfmrs = prfmrs + FindPerformerNameFromUsername(p) + ","; } prfmrs.Remove(prfmrs.Length - 1, 1); datasetInfo = datasetInfo + ";" + prfmrs; writerDatasets.WriteLine(datasetInfo); } writerDatasets.Close(); #region performersInFile //write a list of 'performer,activity' in Performers.csv foreach (string p in performerCount.Keys) { string l = p + "," + performerCount[p]; writerPerformers.WriteLine(l); } // performer activities int performerMin = performerCount.Values.Min(); int performerMax = performerCount.Values.Max(); List <int> performerActivities = new List <int>(); foreach (int s in performerCount.Values) { performerActivities.Add(s); } double performerMedian = medianCalc(performerActivities); string performerCompare = "performersActivity," + performerMin + "," + performerMedian + "," + performerMax; writerComparison.WriteLine(performerCompare); //performersActivity writerPerformers.Close(); writerPerformerDataset.Close(); #endregion #region datasetInfo in file #endregion //datasetInfo in file #region compare in file string m = "metadataRates," + metadataRates.Min() + "," + medianCalc(metadataRates) + "," + metadataRates.Max(); writerComparison.WriteLine(m); string allValids = "allValidMetadas," + allValidMetadas; writerComparison.WriteLine(allValids); //string pd = "publicDatasets," + publicDatasets; //string rd = "restrictedDatasets," + restrictedDatasets; //writerComparison.WriteLine(pd); //writerComparison.WriteLine(rd); string datasetDescriptionLength = "datasetDescriptionLength," + dsDescLength.Min() + "," + medianCalc(dsDescLength) + "," + dsDescLength.Max(); string dataStrDescriptionLength = "dataStrDescriptionLength," + dstrDescLength.Min() + "," + medianCalc(dstrDescLength) + "," + dstrDescLength.Max(); string dataStrUsage = "dataStrUsage," + dstrUsage.Min() + "," + medianCalc(dstrUsage) + "," + dstrUsage.Max(); writerComparison.WriteLine(datasetDescriptionLength); writerComparison.WriteLine(dataStrDescriptionLength); writerComparison.WriteLine(dataStrUsage); string typeDataset = "type," + (tabularDatasets + fileDatasets) + "," + tabularDatasets + "," + fileDatasets; writerComparison.WriteLine(typeDataset); string cols = "datasetColNumber," + datasetCols.Min() + "," + medianCalc(datasetCols) + "," + datasetCols.Max(); string rows = "datasetRowNumber," + datasetRows.Min() + "," + medianCalc(datasetRows) + "," + datasetRows.Max(); string fileNums = ""; string fileSizes = ""; string totalFileSize = ""; //if (datasetFileNumber.Count > 0) //{ fileNums = "datasetFileNumber," + datasetFileNumber.Min() + "," + medianCalc(datasetFileNumber) + "," + datasetFileNumber.Max(); //fileSizes = "datasetSizeFiles," + datasetSizeFiles.Min() + "," + medianCalc(datasetSizeFiles) + "," + datasetSizeFiles.Max(); totalFileSize = "datasetTotalSizeFiles," + datasetTotalSize.Min() + "," + medianCalc(datasetTotalSize) + "," + datasetTotalSize.Max(); //} //else //{ // fileNums = "datasetFileNumber," + 0 + "," + 0 + "," + 0; // //fileSizes = "datasetSizeFiles," + 0 + "," + 0 + "," + 0; // totalFileSize = "datasetTotalSizeFiles," + 0 + "," + 0 + "," + 0; //} writerComparison.WriteLine(cols); writerComparison.WriteLine(rows); writerComparison.WriteLine(fileNums); writerComparison.WriteLine(fileSizes); writerComparison.WriteLine(totalFileSize); #endregion writerComparison.Close(); //writerDatasets.Close(); writerVariable.Close(); writerFiles.Close(); return(View()); //return RedirectToAction("Index", new { area = "dqm" }); } catch (Exception ex) { ViewData.ModelState.AddModelError("", $@"'{ex.Message}'"); return(RedirectToAction("dqError", new { area = "dqm" })); } } }
public static void YankReferrals (string path) { string ourNamespace = "urn:newtelligence-com:dasblog:runtime:data"; foreach (string file in Directory.GetFiles(path,"*.dayfeedback.xml")) { NameTable nt = new NameTable(); object permaLink = nt.Add("PermaLink"); XmlNamespaceManager ns = new XmlNamespaceManager(nt); ns.AddNamespace("def", ourNamespace); XmlDocument x = new XmlDocument(nt); try { x.Load(file); } catch (XmlException ex) { WriteLine(String.Format("ERROR: Malformed Xml in file: {0}",file)); WriteLine(ex.ToString()); Console.WriteLine("Press ENTER to continue..."); Console.ReadLine(); } XmlNodeList nodes = x.SelectNodes("/def:DayExtra/def:Trackings/def:Tracking[def:TrackingType = \"Referral\"]", ns); for (int i = 0; i < nodes.Count; i++) { XmlNode node = nodes[i]; node.ParentNode.RemoveChild(node); } if (nodes.Count > 0) { x.Save(file); } WriteLine(String.Format("Removed {0} referrals in {1}",nodes.Count,file)); } }
/// <summary> /// xmlファイルをマージする /// </summary> /// <param name="patchedXml">パッチされるxml</param> /// <param name="patchXml">パッチ用xml</param> public void MergeXML(XDocument patchedXml, XDocument patchXml) { if (patchXml.Root.Name.LocalName == "diff") { var nsTbl = new NameTable(); var nsMng = new XmlNamespaceManager(nsTbl); foreach (var attr in patchXml.Root.Attributes()) { // 名前空間の場合 if (attr.IsNamespaceDeclaration) { if (attr.Name.LocalName.StartsWith("xmlns")) { nsMng.AddNamespace(attr.Name.NamespaceName, attr.Value); } else { nsMng.AddNamespace(attr.Name.LocalName, attr.Value); } } } foreach (var elm in patchXml.Root.Elements()) { var sel = patchedXml.XPathEvaluate(elm.Attribute("sel").Value, nsMng); if (!(sel is IEnumerable enumerable)) { continue; } var targetNode = enumerable.OfType <XObject>().FirstOrDefault(); if (targetNode == null) { continue; } switch (elm.Name.LocalName) { case "add": AddNode(elm, targetNode); break; case "replace": Replace(elm, targetNode); break; case "remove": Remove(patchedXml, targetNode); break; default: break; } } } else { patchedXml.Root.Add(patchXml.Root.Elements()); } }
public XmlParserContext GetParserContext() { NameTable nt = new NameTable(); XmlParserContext pc = new XmlParserContext(nt, new XmlNamespaceManager(nt), null, XmlSpace.Default); return pc; }
/// <summary> /// Test various xpath expressionss /// </summary> static void TestXpaths() { Console.WriteLine("== Test various xpath expressionss"); // From: http://www.csharp-examples.net/xpath-top-xml-nodes/ // get top 2 nodes <book> nodes use XPath expression // http://www.java2s.com/Code/CSharp/XML/FindElementswithanXPathSearch.htm String xmlStr = "<Names>" + "<Name>James</Name>" + "<Name>John</Name>" + "<Name>Robert</Name>" + "<Name>Michael</Name>" + "<Name>William</Name>" + "<Name>David</Name>" + "<Name>Richard</Name>" + "</Names>"; XmlDocument xml = new XmlDocument(); xml.LoadXml(xmlStr); XmlNodeList xnList = xml.SelectNodes("/Names/Name[position() <= 3]"); foreach (XmlNode xn in xnList) { Console.WriteLine(xn.InnerText); } Console.WriteLine("== Test Write XML To String"); // From: http://www.fincher.org/tips/Languages/csharp.shtml //read an xml file and then write to a string //(no error checking) // http://www.java2s.com/Code/CSharp/XML/XPathQueryDemo.htm // XmlDocument xmlDocument = new XmlDocument(); // xmlDocument.Load(args[0]); StringWriter stringWriter = new StringWriter(); XmlTextWriter xmlTextWriter = new XmlTextWriter(stringWriter); xmlTextWriter.Formatting = Formatting.Indented; xml.WriteTo(xmlTextWriter); // xmlDocument xmlTextWriter.Flush(); Console.WriteLine(stringWriter.ToString()); Console.WriteLine("== Test more xpath expressionss"); // From: http://mydotnet.wordpress.com/2008/05/29/worlds-smallest-xml-xpath-tutorial/ XmlDocument xmlDocument = new XmlDocument(); xmlDocument.Load(@"d:\books2.xml"); XmlElement root = xmlDocument.DocumentElement; // define name space manager XmlNameTable xmlNameTable = new NameTable(); XmlNamespaceManager manager = new XmlNamespaceManager(xmlNameTable); manager.AddNamespace("bk", "http://www.contoso.com/books"); // select the first Node under the root node ("bookstore") which matches the name "book" XmlNode xnRecord = root.SelectSingleNode("bk:book", manager); Console.WriteLine(xnRecord.InnerText); // Searching XMLNode by Attribute value: book genre="novel" xnRecord = root.SelectSingleNode("bk:book[@genre='novel']", manager); Console.WriteLine(xnRecord.InnerText); // Searching XMLNode by ChildNode’s inner text: <price>9.99</price> xnRecord = root.SelectSingleNode("bk:book[bk:price='9.99']", manager); Console.WriteLine(xnRecord.InnerXml); // Searching XMLNodeList XmlNodeList xnlRecords = root.SelectNodes("bk:book", manager); // Sorting Console.WriteLine("== Test Xml Sorting"); XPathNavigator navigator = xml.CreateNavigator(); //XPathExpression selectExpression = navigator.Compile(navigateNode); //selectExpression.SetContext(manager); //selectExpression.AddSort("@EmpId", XmlSortOrder.Ascending, XmlCaseOrder.None, "", XmlDataType.Number); XPathNodeIterator nodeIterator = navigator.Select("/Names/Name"); while (nodeIterator.MoveNext()) { XmlElement xnm = (XmlElement)((IHasXmlNode)nodeIterator.Current).GetNode(); //Do other required operations here ?? Console.WriteLine(xnm.InnerText); } }
private void Ilogin(AuthorizationContext filterContext) { try { var path = filterContext.HttpContext.Request.CurrentExecutionFilePath.ToLower(); string[] urlItems = path.ToLower().Split('/'); string pageName = urlItems[urlItems.Length - 1]; string casTicket = filterContext.HttpContext.Request.QueryString["ticket"]; Code.LogHelper.Info("casTicket:" + casTicket); //返回地址 string serviceUrl = filterContext.HttpContext.Request.Url.GetLeftPart(UriPartial.Path).ToLower().Split(new string[] { "/islogin", "/login" }, StringSplitOptions.None)[0]; if (!string.IsNullOrEmpty(ServerUrl)) { serviceUrl = ServerUrl + serviceUrl.Replace("http://" + filterContext.HttpContext.Request.Url.Authority, ""); if (Code.Common.IsMobile) { if (casTicket == null || casTicket.Length == 0) { serviceUrl += "/sys/sysindex/login";//接入微信入口单点跳转地址不对 } } } if (casTicket == null || casTicket.Length == 0) { string redir = casLogin + "?service=" + serviceUrl; if (Code.Common.IsMobile) { Code.LogHelper.Info("IsMobile!"); redir = serviceUrl; } filterContext.HttpContext.Response.Redirect(redir); return; } else { string validateurl = casValidate + "?ticket=" + casTicket + "&" + "service=" + serviceUrl; WebClient client = new WebClient(); StreamReader Reader = new StreamReader(client.OpenRead(validateurl)); string resp = Reader.ReadToEnd(); StackTrace st = new StackTrace(new StackFrame(true)); NameTable nt = new NameTable(); XmlNamespaceManager nsmgr = new XmlNamespaceManager(nt); XmlParserContext context = new XmlParserContext(null, nsmgr, null, XmlSpace.None); XmlTextReader reader = new XmlTextReader(resp, XmlNodeType.Element, context); string netid = null; while (reader.Read()) { if (reader.IsStartElement()) { string tag = reader.LocalName; if (tag == "user" && !string.IsNullOrEmpty(casTicket)) { netid = reader.ReadString(); break; } } } reader.Close(); if (netid == null) { if (XkSystem.Code.Common.UserId != 0) { return; } else { string redir = casLogin + "?service=" + serviceUrl; filterContext.HttpContext.Response.Redirect(redir); return; } } else { var rootPath = filterContext.HttpContext.Request.ApplicationPath; if (!rootPath.EndsWith("/")) { rootPath = rootPath + "/"; } if (XkSystem.Code.Common.UserId == 0) { //XkSystem.Code.Common.UserId = UserId(netid); UserId(netid); } HttpContext.Current.Response.Cookies[Code.Common.AppName + "casTicket"].Value = casTicket; filterContext.HttpContext.Response.Redirect(ServerUrl + "/" + Code.Common.FolderName + "/Sys/SysIndex/IsLogin?code=" + netid); } } } catch (Exception) { throw; } }
// Test adding items to a namespace manager. public void TestXmlNamespaceManagerAdd() { NameTable table = new NameTable(); XmlNamespaceManager ns = new XmlNamespaceManager(table); // Test exception behaviour. try { ns.AddNamespace(null, "uri"); Fail("Add (1)"); } catch(ArgumentNullException) { // Success } try { ns.AddNamespace("prefix", null); Fail("Add (2)"); } catch(ArgumentNullException) { // Success } try { ns.AddNamespace("xml", "uri"); Fail("Add (3)"); } catch(ArgumentException) { // Success } try { ns.AddNamespace("xmlns", "uri"); Fail("Add (4)"); } catch(ArgumentException) { // Success } try { // Work around intern'ed string handling in the engine. ns.AddNamespace(String.Concat("xml", "ns"), "uri"); Fail("Add (5)"); } catch(ArgumentException) { // Success } // Try changing the default namespace. ns.AddNamespace("", "defuri"); AssertEquals("Add (6)", "defuri", ns.LookupNamespace("")); AssertEquals("Add (7)", "defuri", ns.DefaultNamespace); AssertEquals("Add (8)", "", ns.LookupPrefix("defuri")); // Try changing some other namespace. ns.AddNamespace("foo", "uri"); AssertEquals("Add (9)", "uri", ns.LookupNamespace("foo")); AssertEquals("Add (10)", "foo", ns.LookupPrefix("uri")); // Make sure that the standard are still set to their // correct values after the modifications above. AssertEquals("Add (11)", "http://www.w3.org/XML/1998/namespace", ns.LookupNamespace("xml")); AssertEquals("Add (12)", "http://www.w3.org/2000/xmlns/", ns.LookupNamespace("xmlns")); AssertEquals("Add (13)", "defuri", ns.LookupNamespace("")); }
// Test enumerating over a namespace manager. public void TestXmlNamespaceManagerEnumerate() { NameTable table = new NameTable(); XmlNamespaceManager ns = new XmlNamespaceManager(table); ns.AddNamespace("foo", "uri1"); CheckEnum(ns, "uri1"); ns.PushScope(); ns.AddNamespace("foo", "uri2"); CheckEnum(ns, "uri2"); ns.AddNamespace("foo", "uri3"); CheckEnum(ns, "uri3"); ns.PopScope(); ns.AddNamespace("", ""); CheckEnum(ns, "uri1"); }
public static TracebackInfo ConstructTracebackInfo(UInt32 tracebackID, ArraySegment<UInt32> rawFrames, IDictionary<UInt32, TracebackFrame> symbols) { var tracebackFunctions = new NameTable(StringComparer.Ordinal); var tracebackModules = new NameTable(StringComparer.Ordinal); var tracebackFrames = ImmutableArrayPool<TracebackFrame>.Allocate(rawFrames.Count); for (int i = 0, o = tracebackFrames.Offset, c = tracebackFrames.Count; i < c; i++) { var rawFrame = rawFrames.Array[rawFrames.Offset + i]; var symbol = symbols[rawFrame]; if ((symbol.Offset == 0) && (!symbol.Offset2.HasValue)) tracebackFrames.Array[i + o] = new TracebackFrame(rawFrame); else tracebackFrames.Array[i + o] = symbol; if (symbol.Function != null) tracebackFunctions.Add(symbol.Function); if (symbol.Module != null) tracebackModules.Add(symbol.Module); } return new TracebackInfo { Frames = tracebackFrames, Functions = tracebackFunctions, Modules = tracebackModules, TraceId = tracebackID }; }
// Check the "PopScope" method. public void TestXmlNamespaceManagerPopScope() { NameTable table = new NameTable(); XmlNamespaceManager ns = new XmlNamespaceManager(table); Assert("PopScope (1)", !ns.PopScope()); ns.PushScope(); Assert("PopScope (2)", ns.PopScope()); }
public IEnumerator<object> ResolveTracebackSymbols( IEnumerable<HeapSnapshot.Traceback> unresolvedTracebacks, Dictionary<UInt32, TracebackInfo> resolvedTracebacks, NameTable functionNames ) { Dictionary<UInt32, TracebackFrame> frameSymbols; { var rawFrames = new HashSet<UInt32>(); yield return Future.RunInThread(() => { foreach (var traceback in unresolvedTracebacks) foreach (var rawFrame in traceback) rawFrames.Add(rawFrame); }); var fSymbols = Database.SymbolCache.Select(rawFrames); using (fSymbols) yield return fSymbols; var fSymbolDict = Future.RunInThread(() => SequenceUtils.ToDictionary(rawFrames, fSymbols.Result) ); yield return fSymbolDict; frameSymbols = fSymbolDict.Result; } yield return Future.RunInThread(() => { if (functionNames != null) foreach (var tf in frameSymbols.Values) { if (tf.Function != null) functionNames.Add(tf.Function); } foreach (var traceback in unresolvedTracebacks) { resolvedTracebacks[traceback.ID] = ConstructTracebackInfo( traceback.ID, traceback.Frames, frameSymbols ); } }); }
public SimpleXsltContext(NameTable nameTable) : base(nameTable) { }
/// <summary> /// Initializes a new instance of the <see cref="CustomQueryContext"/> class. /// </summary> /// <param name="table">A NameTable instance</param> public CustomQueryContext(NameTable table) : base(table) { }
public NameTableDataSource(NameTable nameTable) : base(nameTable.items.Count) { dataGetters = new PackageTableDataGetter[] { new PackageTableDataGetter { column = "#", sort = (i => { return nameTable[i].index; }), data = (i => { return nameTable[i].index.ToString(); }), }, new PackageTableDataGetter { column = "offset", sort = (i => { return nameTable[i].offset; }), data = (i => { return String.Format("{0:X8}", nameTable[i].offset); }), }, new PackageTableDataGetter { column = "name", sort = (i => { return nameTable[i].name; }), data = (i => { return nameTable[i].name.ToString(); }), }, new PackageTableDataGetter { column = "flags", sort = (i => { return nameTable[i].flags; }), data = (i => { return nameTable[i].flags.ToString(); }), }, }; }
static ThemeColorSet getColorSetFromTheme(Stream thmxFile) { XDocument themeDoc = null; StreamResourceInfo thmxSRI = new StreamResourceInfo(thmxFile, null); StreamResourceInfo sri = Application.GetResourceStream(thmxSRI, new Uri(ThmxThemeUri, UriKind.Relative)); //Add the namespace manager NameTable nameTable = new NameTable(); XmlNamespaceManager manager = new XmlNamespaceManager(nameTable); manager.AddNamespace("a", ThmxNamespace); //Create XDocument from thmx stream themeDoc = XDocument.Load(sri.Stream); XDocument xDocTheme = XDocument.Parse(themeDoc.ToString()); //Get RGB Values for the 12 theme colors string dk1 = getRGBFromTheme(xDocTheme, thmx_dk1, true); //Text string dk2 = getRGBFromTheme(xDocTheme, thmx_dk2); //Main Dark Color string lt1 = getRGBFromTheme(xDocTheme, thmx_lt1, true); //Window Background string lt2 = getRGBFromTheme(xDocTheme, thmx_lt2); //Main Light Color string a1 = getRGBFromTheme(xDocTheme, thmx_a1); //Accent1 string a2 = getRGBFromTheme(xDocTheme, thmx_a2); //Accent2 string a3 = getRGBFromTheme(xDocTheme, thmx_a3); //Accent3 string a4 = getRGBFromTheme(xDocTheme, thmx_a4); //Accent4 string a5 = getRGBFromTheme(xDocTheme, thmx_a5); //Accent5 string a6 = getRGBFromTheme(xDocTheme, thmx_a6); //Accent6 string hlink = getRGBFromTheme(xDocTheme, thmx_hlink); //Hyperlink string flink = getRGBFromTheme(xDocTheme, thmx_flink); //Followed Link //Get the two fonts string majFont = getFontFamilyFromTheme(xDocTheme, thmx_majfont); //Heading Font string minFont = getFontFamilyFromTheme(xDocTheme, thmx_minfont); //Body Font ThemeColorSet theme = new ThemeColorSet() { TextBackgroundDark1 = fromHex(dk1), TextBackgroundDark2 = fromHex(dk2), TextBackgroundLight1 = fromHex(lt1), TextBackgroundLight2 = fromHex(lt2), Accent1 = fromHex(a1), Accent2 = fromHex(a2), Accent3 = fromHex(a3), Accent4 = fromHex(a4), Accent5 = fromHex(a5), Accent6 = fromHex(a6), Hyperlink = fromHex(hlink), FollowedHyperlink = fromHex(flink), }; //Color bkStart = fromHex(dk2); //Color bkEnd = fromHex(lt2); //Color text = fromHex(dk1); //Color winBkgd = fromHex(lt1); //Color separator = fromHex(a1); //Color selected = fromHex(flink); //Color mouseOver = fromHex(hlink); //ApplicationColorSet appSet = new ApplicationColorSet() //{ // ChildWindowColorSet = new ChildWindowColorSet() // { // BackgroundStartGradientColor = bkStart, // //BackgroundEndGradientColor = bkEnd, // TitleBarColor = winBkgd, // TitleBarForegroundColor = text, // }, // SidePanelControlColorSet = new SidePanelControlColorSet() // { // BackgroundStartGradientColor = bkStart, // //BackgroundEndGradientColor = bkEnd, // MouseOverFillColor = mouseOver, // SelectedStateFillColor = selected, // SeparatorLineColor = separator, // }, //}; return(theme); }
public IEnumerator<object> DiffSnapshots(HeapSnapshotInfo first, HeapSnapshotInfo last) { var moduleNames = new NameTable(StringComparer.Ordinal); var heapIds = new HashSet<UInt32>(); var functionNames = new NameTable(); var deltas = new List<DeltaInfo>(); var tracebacks = new Dictionary<UInt32, TracebackInfo>(); { var fModulesFirst = Database.SnapshotModules.Get(first.Index); var fModulesLast = Database.SnapshotModules.Get(last.Index); var fHeapsFirst = Database.SnapshotHeaps.Get(first.Index); var fHeapsLast = Database.SnapshotHeaps.Get(last.Index); yield return fModulesFirst; foreach (var moduleName in fModulesFirst.Result) moduleNames.Add(Path.GetFileNameWithoutExtension(moduleName)); yield return fHeapsFirst; heapIds.UnionWith(from heap in fHeapsFirst.Result select heap.HeapID); yield return fModulesLast; foreach (var moduleName in fModulesLast.Result) moduleNames.Add(Path.GetFileNameWithoutExtension(moduleName)); yield return fHeapsLast; heapIds.UnionWith(from heap in fHeapsLast.Result select heap.HeapID); } var allocationIds = new HashSet<UInt32>(); { var fAllocations = Database.HeapAllocations.Select(heapIds); using (fAllocations) yield return fAllocations; yield return Future.RunInThread(() => { foreach (var ids in fAllocations.Result) allocationIds.UnionWith(ids); }); } { var tracebackIds = new HashSet<UInt32>(); var oldCounts = new Dictionary<UInt32, int>(); var oldBytes = new Dictionary<UInt32, int>(); var newCounts = new Dictionary<UInt32, int>(); var newBytes = new Dictionary<UInt32, int>(); var deallocs = new Dictionary<UInt32, DeltaInfo>(); var allocs = new Dictionary<UInt32, DeltaInfo>(); var fAllocationRanges = Database.Allocations.Select(allocationIds); using (fAllocationRanges) yield return fAllocationRanges; yield return Future.RunInThread(() => { DeltaInfo delta; foreach (var item in fAllocationRanges.Result) { var ranges = item.Ranges.Array; for (int i = 0, c = item.Ranges.Count, o = item.Ranges.Offset; i < c; i++) { var range = ranges[i + o]; bool aliveAtStart = (range.First <= first.Index) && (range.Last > first.Index); bool aliveAtEnd = (range.First <= last.Index) && (range.Last > last.Index); bool allocatedInWindow = (range.First >= first.Index) && (range.First <= last.Index); bool deallocatedInWindow = (range.Last >= first.Index) && (range.Last <= last.Index); if (!aliveAtStart && !aliveAtEnd && !allocatedInWindow && !deallocatedInWindow) continue; if (aliveAtStart) { int value; if (!oldCounts.TryGetValue(range.TracebackID, out value)) value = 0; oldCounts[range.TracebackID] = value + 1; if (!oldBytes.TryGetValue(range.TracebackID, out value)) value = 0; oldBytes[range.TracebackID] = (int)(value + range.Size); } if (aliveAtEnd) { int value; if (!newCounts.TryGetValue(range.TracebackID, out value)) value = 0; newCounts[range.TracebackID] = value + 1; if (!newBytes.TryGetValue(range.TracebackID, out value)) value = 0; newBytes[range.TracebackID] = (int)(value + range.Size); } if (allocatedInWindow) { // allocation if (allocs.TryGetValue(range.TracebackID, out delta)) { delta.CountDelta += 1; delta.BytesDelta += (int)(range.Size); } else { allocs.Add(range.TracebackID, new DeltaInfo { BytesDelta = (int)(range.Size), CountDelta = 1, TracebackID = range.TracebackID, Traceback = null }); } tracebackIds.Add(range.TracebackID); } if (deallocatedInWindow) { // deallocation if (deallocs.TryGetValue(range.TracebackID, out delta)) { delta.CountDelta -= 1; delta.BytesDelta -= (int)(range.Size); } else { deallocs.Add(range.TracebackID, new DeltaInfo { BytesDelta = -(int)(range.Size), CountDelta = -1, TracebackID = range.TracebackID, Traceback = null }); } tracebackIds.Add(range.TracebackID); } } } foreach (var tracebackId in tracebackIds) { DeltaInfo alloc = null, dealloc = null; if (allocs.TryGetValue(tracebackId, out alloc) | deallocs.TryGetValue(tracebackId, out dealloc)) { int currentOldBytes, currentOldCount; int currentNewBytes, currentNewCount; oldBytes.TryGetValue(tracebackId, out currentOldBytes); oldCounts.TryGetValue(tracebackId, out currentOldCount); newBytes.TryGetValue(tracebackId, out currentNewBytes); newCounts.TryGetValue(tracebackId, out currentNewCount); if (alloc != null) { alloc.OldBytes = currentOldBytes; alloc.OldCount = currentOldCount; alloc.NewBytes = currentNewBytes; alloc.NewCount = currentNewCount; deltas.Add(alloc); } if (dealloc != null) { dealloc.OldBytes = currentOldBytes; dealloc.OldCount = currentOldCount; dealloc.NewBytes = currentNewBytes; dealloc.NewCount = currentNewCount; deltas.Add(dealloc); } } } }); var fTracebacks = Database.FilteredTracebacks.CascadingSelect( new [] { Database.Tracebacks }, tracebackIds ); using (fTracebacks) yield return fTracebacks; yield return ResolveTracebackSymbols( fTracebacks.Result, tracebacks, functionNames ); yield return Future.RunInThread(() => { foreach (var d in deltas) d.Traceback = tracebacks[d.TracebackID]; }); } yield return Future.RunInThread(() => deltas.Sort((lhs, rhs) => { var lhsBytes = lhs.BytesDelta; var rhsBytes = rhs.BytesDelta; return rhsBytes.CompareTo(lhsBytes); }) ); yield return Result.New(new HeapDiff( null, moduleNames, functionNames, deltas, tracebacks )); }
static XmlNameTable CreateNameTable() { XmlNameTable nameTable = new NameTable(); nameTable.Add(string.Empty); nameTable.Add(XNamespace.xmlnsPrefixNamespace); nameTable.Add(XNamespace.xmlPrefixNamespace); return nameTable; }
/// <summary> /// Initializes the task and verifies parameters. /// </summary> /// <param name="TaskNode">Node that contains the XML fragment used to define this task instance.</param> protected override void InitializeTask(XmlNode TaskNode) { XmlElement taskXml = (XmlElement) TaskNode.Clone(); // Expand all properties in the task and its child elements if (taskXml.ChildNodes != null) { ExpandPropertiesInNodes(taskXml.ChildNodes); if (taskXml.Attributes != null) { foreach (XmlAttribute attr in taskXml.Attributes) { attr.Value = Properties.ExpandProperties(attr.Value, Location); } } } // Get the [SchemaValidator(type)] attribute SchemaValidatorAttribute[] taskValidators = (SchemaValidatorAttribute[])GetType().GetCustomAttributes( typeof(SchemaValidatorAttribute), true); if (taskValidators.Length > 0) { SchemaValidatorAttribute taskValidator = taskValidators[0]; XmlSerializer taskSerializer = new XmlSerializer(taskValidator.ValidatorType); // get embedded schema resource stream Stream schemaStream = Assembly.GetExecutingAssembly().GetManifestResourceStream( taskValidator.ValidatorType.Namespace); // ensure schema resource was embedded if (schemaStream == null) { throw new BuildException(string.Format(CultureInfo.InvariantCulture, "Schema resource '{0}' could not be found.", taskValidator.ValidatorType.Namespace), Location); } // load schema resource XmlTextReader tr = new XmlTextReader( schemaStream, XmlNodeType.Element, null); // Add the schema to a schema collection XmlSchema schema = XmlSchema.Read(tr, null); XmlSchemaCollection schemas = new XmlSchemaCollection(); schemas.Add(schema); string xmlNamespace = (taskValidator.XmlNamespace != null ? taskValidator.XmlNamespace : GetType().FullName); // Create a namespace manager with the schema's namespace NameTable nt = new NameTable(); XmlNamespaceManager nsmgr = new XmlNamespaceManager(nt); nsmgr.AddNamespace(string.Empty, xmlNamespace); // Create a textreader containing just the Task's Node XmlParserContext ctx = new XmlParserContext( null, nsmgr, null, XmlSpace.None); taskXml.SetAttribute("xmlns", xmlNamespace); XmlTextReader textReader = new XmlTextReader(taskXml.OuterXml, XmlNodeType.Element, ctx); // Copy the node from the TextReader and indent it (for error // reporting, since NAnt does not retain formatting during a load) StringWriter stringWriter = new StringWriter(); XmlTextWriter textWriter = new XmlTextWriter(stringWriter); textWriter.Formatting = Formatting.Indented; textWriter.WriteNode(textReader, true); //textWriter.Close(); XmlTextReader formattedTextReader = new XmlTextReader( stringWriter.ToString(), XmlNodeType.Document, ctx); // Validate the Task's XML against its schema XmlValidatingReader validatingReader = new XmlValidatingReader( formattedTextReader); validatingReader.ValidationType = ValidationType.Schema; validatingReader.Schemas.Add(schemas); validatingReader.ValidationEventHandler += new ValidationEventHandler(Task_OnSchemaValidate); while (validatingReader.Read()) { // Read strictly for validation purposes } validatingReader.Close(); if (!_validated) { // Log any validation errors that have ocurred for (int i = 0; i < _validationExceptions.Count; i++) { BuildException ve = (BuildException) _validationExceptions[i]; if (i == _validationExceptions.Count - 1) { // If this is the last validation error, throw it throw ve; } Log(Level.Info, ve.Message); } } NameTable taskNameTable = new NameTable(); XmlNamespaceManager taskNSMgr = new XmlNamespaceManager(taskNameTable); taskNSMgr.AddNamespace(string.Empty, xmlNamespace); XmlParserContext context = new XmlParserContext( null, taskNSMgr, null, XmlSpace.None); XmlTextReader taskSchemaReader = new XmlTextReader( taskXml.OuterXml, XmlNodeType.Element, context); // Deserialize from the Task's XML to the schema wrapper object _schemaObject = taskSerializer.Deserialize(taskSchemaReader); } }
protected void DiffLoaded(HeapDiff diff, string filename) { Modules = diff.Modules; FunctionNames = diff.FunctionNames; Deltas = diff.Deltas; FilteredDeltas = null; StackGraph = null; TracebackFilter.AutoCompleteItems = FunctionNames; Text = "Diff Viewer - " + filename; Filename = filename; RefreshModules(); if (PendingRefresh != null) PendingRefresh.Dispose(); PendingRefresh = Start(RefreshDeltas()); MainMenuStrip.Enabled = true; LoadingPanel.Visible = false; MainSplit.Visible = true; Timeline.Enabled = true; UseWaitCursor = false; }
/// <summary> /// Initializes a new instance of the <see cref="AndroidStudioConverter"/> class. /// </summary> public AndroidStudioConverter() { _nameTable = new NameTable(); _strings = new AndroidStudioStrings(_nameTable); }
/// <summary> /// Generates a random name using the specified name table. /// </summary> public static string RandomName(NameTable name = NameTable.FirstGenericMale) { return(NWScript.RandomName((int)name)); }
private static XmlNameTable PopulateNameTable ( XmlReaderSettings settings) { XmlNameTable nameTable = settings.NameTable; if (nameTable == null) nameTable = new NameTable (); return nameTable; }
/// <summary> /// Creates a new instance of the ExcelColumn class. /// For internal use only! /// </summary> /// <param name="Worksheet"></param> /// <param name="col"></param> protected internal ExcelColumn(ExcelWorksheet Worksheet, int col) { NameTable nt = new NameTable(); _nsManager = new XmlNamespaceManager(nt); _nsManager.AddNamespace("d", ExcelPackage.schemaMain.NamespaceName); _xlWorksheet = Worksheet; var parent = Worksheet.WorksheetXml.XPathSelectElement("//d:cols", _nsManager); if (parent == null) { parent = ExtensonMethods.NewElement("cols"); var refChild = Worksheet.WorksheetXml.XPathSelectElement("//d:sheetData", _nsManager); refChild.AddBeforeSelf(parent); } XAttribute minAttr; XAttribute maxAttr; XElement insertBefore = null; // the column definitions cover a range of columns, so find the one we want bool insertBeforeFound = false; foreach (XElement colNode in parent.Nodes()) { int min = 1; int max = 1; minAttr = colNode.Attribute("min"); if (minAttr != null) { min = int.Parse(minAttr.Value); } maxAttr = colNode.Attribute("max"); if (maxAttr != null) { max = int.Parse(maxAttr.Value); } if (!insertBeforeFound && (col <= min || col <= max)) { insertBeforeFound = true; insertBefore = colNode; } if (col >= min && col <= max) { _colElement = colNode; break; } } if (_colElement == null) { // create the new column definition _colElement = ExtensonMethods.NewElement("col"); _colElement.SetAttribute("min", col.ToString()); _colElement.SetAttribute("max", col.ToString()); if (insertBefore != null) { insertBefore.AddBeforeSelf(_colElement); } else { parent.Add(_colElement); } } }
internal NameManager(NameTable nameTable) { _names = nameTable; this.InitKnownNames(); }
public async Task Load(string fileName, ProgressUtility progress) { flights.Clear(); // CSV doesn't have realtime clock, so go with the file date instead. this.startTime = File.GetLastWriteTime(fileName); // time (us) long min = long.MaxValue; long max = long.MinValue; await Task.Run(() => { timeElementName = null; using (Stream s = File.OpenRead(fileName)) { XmlNameTable nametable = new NameTable(); using (XmlCsvReader reader = new XmlCsvReader(s, System.Text.Encoding.UTF8, new Uri(fileName), nametable)) { progress.ShowProgress(0, s.Length, s.Position); reader.FirstRowHasColumnNames = true; data = XDocument.Load(reader); this.schema = new LogItemSchema() { Name = "CsvLog", Type = "Root" }; var item = new LogItemSchema() { Name = System.IO.Path.GetFileName(fileName), Type = "Item" }; // create the schema List <LogItemSchema> children = new List <Model.LogItemSchema>(); foreach (String name in reader.ColumnNames) { if (timeElementName == null && name.Contains("time")) { timeElementName = name; } children.Add(new LogItemSchema() { Name = name, Parent = this.schema, Type = "Double" }); } item.ChildItems = children; this.schema.ChildItems = new List <Model.LogItemSchema>(new LogItemSchema[] { item }); progress.ShowProgress(0, s.Length, s.Position); } } foreach (var e in data.Root.Elements()) { long?i = GetTimeMicroseconds(e); if (i.HasValue) { if (i.Value < min) { min = i.Value; } if (i > max) { max = i.Value; } } } }); // this log has no absolute UTC time, only ticks since board was booted, so we make up a start time. DateTime end = this.startTime.AddMilliseconds((max - min) / 1000); var flight = new Flight() { Log = this, StartTime = this.startTime, Duration = end - this.startTime }; this.duration = end - this.startTime; this.flights.Add(flight); }
IEnumerator<object> ReloadTracebacks() { var keys = from delta in Deltas select delta.TracebackID; var fTracebacks = Instance.Database.FilteredTracebacks.CascadingSelect( new[] { Instance.Database.Tracebacks }, keys ); yield return fTracebacks; var resolvedTracebacks = new Dictionary<UInt32, TracebackInfo>(); var functionNames = new NameTable(); yield return Instance.ResolveTracebackSymbols( fTracebacks.Result, resolvedTracebacks, functionNames ); foreach (var delta in Deltas) delta.Traceback = resolvedTracebacks[delta.TracebackID]; FunctionNames = functionNames; DoneReloadingTracebacks(); }
static void Main(string[] args) { try { int curArgIndex = 0; bool bFragment = false; // decode options XmlDiffOptions options = XmlDiffOptions.None; string optionsString = string.Empty; while (curArgIndex < args.Length && (args[curArgIndex][0] == '/' || args[curArgIndex][0] == '-')) { if (args[curArgIndex].Length != 2) { System.Console.Write("Invalid option: " + args[curArgIndex] + "\n"); return; } switch (args[curArgIndex][1]) { case '?': WriteUsage(); return; case 'o': options |= XmlDiffOptions.IgnoreChildOrder; break; case 'c': options |= XmlDiffOptions.IgnoreComments; break; case 'p': options |= XmlDiffOptions.IgnorePI; break; case 'w': options |= XmlDiffOptions.IgnoreWhitespace; break; case 'n': options |= XmlDiffOptions.IgnoreNamespaces; break; case 'r': options |= XmlDiffOptions.IgnorePrefixes; break; case 'x': options |= XmlDiffOptions.IgnoreXmlDecl; break; case 'd': options |= XmlDiffOptions.IgnoreDtd; break; case 'f': bFragment = true; break; default: System.Console.Write("Invalid option: " + args[curArgIndex] + "\n"); return; } optionsString += args[curArgIndex][1]; curArgIndex++; } if (args.Length - curArgIndex < 3) { WriteUsage(); return; } bool includeIngnore = (args.Length - curArgIndex > 3); string sourceXmlFile = args[curArgIndex]; string changedXmlFile = args[curArgIndex + 1]; string resultHtmlViewFile = args[curArgIndex + 2]; string diffgramFile = args[curArgIndex + 3]; string ignoreFile = includeIngnore ? args[curArgIndex + 4] : null; MemoryStream diffgram = new MemoryStream(); XmlTextWriter diffgramWriter = new XmlTextWriter(new StreamWriter(diffgram)); var msg = "Comparing " + sourceXmlFile + " to " + changedXmlFile + " using ignore config " + ignoreFile; log.Info(msg); Console.WriteLine(msg); XmlDiff xmlDiff = new XmlDiff(options); bool bIdentical = true; try { bIdentical = xmlDiff.Compare(sourceXmlFile, changedXmlFile, bFragment, diffgramWriter, ignoreFile); } catch (Exception e) { log.Error(e.Message, e); Console.WriteLine(e.Message); return; } msg = "Files compared " + (bIdentical ? "identical." : "different."); log.Info(msg); Console.WriteLine(msg); msg = "Generating " + resultHtmlViewFile + " view file"; log.Info(msg); Console.WriteLine(msg); TextWriter resultHtml = new StreamWriter(new FileStream(resultHtmlViewFile, FileMode.Create, FileAccess.Write)); resultHtml.WriteLine("<html><head>"); resultHtml.WriteLine("<style TYPE='text/css' MEDIA='screen'>"); resultHtml.Write("<!-- td { font-family: Courier New; font-size:14; } " + "th { font-family: Arial; } " + "p { font-family: Arial; } -->"); resultHtml.WriteLine("</style></head>"); resultHtml.WriteLine("<body><h3 style='font-family:Arial'>XmlDiff view</h3><table border='0'><tr><td><table border='0'>"); resultHtml.WriteLine("<tr><th>" + sourceXmlFile + "</th><th>" + changedXmlFile + "</th></tr>" + "<tr><td colspan=2><hr size=1></td></tr>"); if (bIdentical) { resultHtml.WriteLine("<tr><td colspan='2' align='middle'>Files are identical.</td></tr>"); } else { resultHtml.WriteLine("<tr><td colspan='2' align='middle'>Files are different.</td></tr>"); } diffgram.Seek(0, SeekOrigin.Begin); Microsoft.XmlDiffPatch.XmlDiffView xmlDiffView = new Microsoft.XmlDiffPatch.XmlDiffView(); XmlTextReader sourceReader; if (bFragment) { NameTable nt = new NameTable(); sourceReader = new XmlTextReader(new FileStream(sourceXmlFile, FileMode.Open, FileAccess.Read), XmlNodeType.Element, new XmlParserContext(nt, new XmlNamespaceManager(nt), string.Empty, XmlSpace.Default)); } else { sourceReader = new XmlTextReader(sourceXmlFile); } sourceReader.XmlResolver = null; xmlDiffView.Load(sourceReader, new XmlTextReader(diffgram)); xmlDiffView.GetHtml(resultHtml); resultHtml.WriteLine("</table></table></body></html>"); resultHtml.Close(); msg = resultHtmlViewFile + " saved successfully."; log.Info(msg); Console.WriteLine(msg); msg = "saving diffgram file"; log.Info(msg); Console.WriteLine(msg); using (FileStream file = new FileStream(diffgramFile, FileMode.Create, FileAccess.Write)) { diffgram.WriteTo(file); } msg = "diffgram file saved to " + diffgramFile; log.Info(msg); Console.WriteLine(msg); } catch (Exception e) { log.Error(e.Message, e); Console.WriteLine("Error: " + e.Message); } if (System.Diagnostics.Debugger.IsAttached) { Console.Write("\nPress enter...\n"); Console.Read(); } }