public XNodeValidator(XmlSchemaSet schemas, ValidationEventHandler validationEventHandler) { this.schemas = schemas; this.validationEventHandler = validationEventHandler; XNamespace xsi = XNamespace.Get("http://www.w3.org/2001/XMLSchema-instance"); xsiTypeName = xsi.GetName("type"); xsiNilName = xsi.GetName("nil"); }
private static string GetVsixManifestVersion() { XDocument vsixManifest = XDocument.Load(VsixManifestFileName); XNamespace ns = vsixManifest.Root?.Name.Namespace ?? XNamespace.None; XElement manifestRoot = vsixManifest.Element(ns.GetName("PackageManifest")); XElement metadata = manifestRoot?.Element(ns.GetName("Metadata")); XElement identity = metadata?.Element(ns.GetName("Identity")); return(identity?.Attribute("Version")?.Value); }
public YouTubeVideo(XNamespace atomns, XElement entry, XNamespace medians) { var id = entry.Element(atomns.GetName("id")) != null && entry.Element(atomns.GetName("id")).Value != null ? entry.Element(atomns.GetName("id")).Value.Split(':').Last() : string.Empty; VideoUrl = "http://gdata.youtube.com/feeds/api/videos/" + id; VideoImageUrl = (from thumbnail in entry.Descendants(medians.GetName("thumbnail")) select thumbnail.Attribute("url").Value).FirstOrDefault(); Title = entry.Element(atomns.GetName("title")) != null ? entry.Element(atomns.GetName("title")).Value : string.Empty; Summary = entry.Element(atomns.GetName("summary")) != null ? entry.Element(atomns.GetName("summary")).Value : string.Empty; if (string.IsNullOrEmpty(Summary)) { Summary = entry.Element(atomns.GetName("content")) != null ? entry.Element(atomns.GetName("content")).Value : string.Empty; } if (string.IsNullOrEmpty(Summary)) { Summary = Title; } }
/// <summary>Initializes a new <see cref="XNodeSchemaApplier"/> instance.</summary> /// <param name="schemas">Schemas to use to predict elements and attributes.</param> private XNodeSchemaApplier(XmlSchemaSet schemas) { Debug.Assert(schemas != null, "schemas != null"); this.schemas = schemas; XNamespace xsi = XNamespace.Get("http://www.w3.org/2001/XMLSchema-instance"); this.xsiTypeName = xsi.GetName("type"); this.xsiNilName = xsi.GetName("nil"); this.namespaceManager = new XmlNamespaceManager(schemas.NameTable); }
private DateTime GetPublishDate(XNamespace atoms, XElement entry) { DateTime publish = DateTime.MinValue; if (entry.Element(atoms.GetName("published")) != null && entry.Element(atoms.GetName("published")).Value != null) { DateTime.TryParse(entry.Element(atoms.GetName("published")).Value, out publish); } return(publish); }
private string GetYouTubeTitle(XNamespace atoms, XElement entry, XNamespace medians) { string title = string.Empty; if (entry.Element(atoms.GetName("title")) != null) { title = entry.Element(atoms.GetName("title")).Value; } return(title); }
public EnglishWord(XElement elem) { doc = XDocument.Load(@"xml\dataFiles\lessons.xml"); xn = doc.Root.Name.Namespace; LettersBigShape = elem.Attribute("lettersBigShape").Value; LettersSmallShape = elem.Attribute("lettersSmallShape").Value; Word = elem.Attribute("word").Value; WordPictuer = new BitmapImage(new Uri(elem.Element(xn.GetName("wordPictuer")).Value)); WordSound = elem.Element(xn.GetName("wordSound")).Value; WordPictuerUsed = false; }
internal static void UpdateFilesInModule(SPElementDefinition elementDefinition, SPWeb web) { XElement xml = elementDefinition.XmlDefinition.ToXElement(); XNamespace xmlns = "http://schemas.microsoft.com/sharepoint/"; string featureDir = elementDefinition.FeatureDefinition.RootDirectory; Module module = (from m in xml.DescendantsAndSelf() select new Module { ProvisioningUrl = m.Attribute("Url").Value, //PhysicalPath = Path.Combine(featureDir, m.Attribute("Path").Value), Files = (from f in m.Elements(xmlns.GetName("File")) select new Module.File { Name = f.Attribute("Url").Value, PhysicalPath = Path.Combine(featureDir, f.Attribute("Path").Value), Properties = (from p in f.Elements(xmlns.GetName("Property")) select p).ToDictionary( n => n.Attribute("Name").Value, v => v.Attribute("Value").Value) }).ToArray() }).First(); if (module == null) { return; } foreach (Module.File file in module.Files) { string physicalPath = file.PhysicalPath; string virtualPath = string.Concat(web.Url, "/", module.ProvisioningUrl, "/", file.Name); if (File.Exists(physicalPath)) { using (StreamReader sreader = new StreamReader(physicalPath)) { if (!CheckOutStatus(web.GetFile(virtualPath))) { web.GetFile(virtualPath).CheckOut(); } SPFile spFile = web.Files.Add(virtualPath, sreader.BaseStream, new Hashtable(file.Properties), true); spFile.CheckIn("Updated", SPCheckinType.MajorCheckIn); if (CheckContentApproval(spFile.Item)) { spFile.Approve("Updated"); } spFile.Update(); } } } }
private XObject GenerateRecordExpression(XNamespace ns, IEdmRecordExpression record) { var recordElement = new XElement(ns.GetName("Record")); foreach (var property in record.Properties) { var propertyValueElement = new XElement(ns.GetName("PropertyValue")); propertyValueElement.Add(new XAttribute("Property", property.Name)); propertyValueElement.Add(GenerateValueExpression(ns, property.Value)); recordElement.Add(propertyValueElement); } return(recordElement); }
private static void ReadId(XElement classElement, XNamespace ns, MappingModel model) { var idElement = classElement.Element(ns.GetName("id")); var idInfo = new IdInfo(); idInfo.ColumnName = idElement.Attribute("column")?.Value; idInfo.Name = idElement.Attribute("name").Value; var stringGenerator = idElement.Element(ns.GetName("generator"))?.Attribute("class")?.Value; switch (stringGenerator) { case "guid.comb": idInfo.Generator = "Generators.GuidComb"; break; case "assigned": idInfo.Generator = "Generators.Assigned"; break; case "identity": idInfo.Generator = "Generators.Identity"; break; case "native": idInfo.Generator = "Generators.Native"; break; } if (idElement.Attribute("access")?.Value != null) { var xmlAccess = idElement.Attribute("access").Value; switch (xmlAccess.ToLower()) { case "property": idInfo.Access = "Accessor.Property"; break; case "field.camelcase-underscore": idInfo.Access = "Accessor.Field"; break; } } idInfo.UnsavedValue = idElement.Attribute("unsaved-value")?.Value; if (idInfo.UnsavedValue == Guid.Empty.ToString()) { idInfo.UnsavedValue = "System.Guid.Empty"; } model.Id = idInfo; }
/// <summary> /// Write inner values to persitance store /// </summary> /// <param name="readWriteValues"></param> /// <param name="writeOnlyValues"></param> protected override void CollectValues(out IDictionary <System.Xml.Linq.XName, object> readWriteValues, out IDictionary <System.Xml.Linq.XName, object> writeOnlyValues) { readWriteValues = new Dictionary <XName, object> { { ExtensionNamespace.GetName(NameName), _name }, { ExtensionNamespace.GetName(IdName), _id }, { ExtensionNamespace.GetName(DateName), _date } }; writeOnlyValues = null; }
/// <summary> /// Collect endpoint. /// </summary> /// <param name="collectRequest">collect request instance object.</param> /// <returns>redirect information instance object.</returns> public override RedirectInformation Collect(CollectRequest collectRequest) { XmlDocument response = new XmlDocument(); XmlDocument payload = JsonConvert.DeserializeXmlNode(collectRequest.ToJsonObject().ToString(), "payload"); XElement body = new XElement(wsdl.GetName("collect"), XElement.Parse(payload.InnerXml)); response.LoadXml(MakeRequest(body)); response = RemoveNullFields(response); XmlNode data = response.SelectSingleNode("descendant::collectResult"); JObject json = JObject.Parse(JsonConvert.SerializeXmlNode(data)); return(new RedirectInformation(json.GetValue("collectResult").ToString())); }
private string GetVideoUrl(XNamespace yt, XElement entry) { string videoUrl = string.Empty; string id = string.Empty; if (entry.Element(yt.GetName("videoid")) != null && entry.Element(yt.GetName("videoid")).Value != null) { id = entry.Element(yt.GetName("videoid")).Value.Split(':').Last(); } videoUrl = String.Format(CultureInfo.InvariantCulture, "http://gdata.youtube.com/feeds/api/videos/{0}", id); return(videoUrl); }
/// <summary> /// Converts a Wix element. /// </summary> /// <param name="element">The Wix element to convert.</param> /// <returns>The converted element.</returns> private void ConvertWixElementWithoutNamespace(XElement element) { if (this.OnError(ConverterTestType.XmlnsMissing, element, "The xmlns attribute is missing. It must be present with a value of '{0}'.", WixNamespace.NamespaceName)) { element.Name = WixNamespace.GetName(element.Name.LocalName); element.Add(new XAttribute("xmlns", WixNamespace.NamespaceName)); // set the default namespace. foreach (XElement elementWithoutNamespace in element.Elements().Where(e => XNamespace.None == e.Name.Namespace)) { elementWithoutNamespace.Name = WixNamespace.GetName(elementWithoutNamespace.Name.LocalName); } } }
/// <summary> /// Moves <paramref name="element"/> into namespace <paramref name="newNamespace"/>. /// </summary> /// <param name="element">The element that will be moved into a new namespace.</param> /// <param name="newNamespace">The new namespace for the element.</param> public static void MoveToNamespace(this XElement element, XNamespace newNamespace) { foreach (XElement el in element.DescendantsAndSelf()) { el.Name = newNamespace.GetName(el.Name.LocalName); } }
public static Packet ConvertPacketFromXml(XElement xmlElement) { foreach (var el in xmlElement.DescendantsAndSelf()) { var xAttribute = el.Attribute("xmlns"); if (xAttribute != null) { XNamespace aw = xAttribute.Value; if (el.Name.Namespace != aw) { el.Name = aw.GetName(el.Name.LocalName); } } else { if (el.Parent != null) { el.Name = el.Parent.Name.Namespace.GetName(el.Name.LocalName); } } } return(new Packet(xmlElement)); }
public letter(XElement elem) : this() { doc = XDocument.Load(@"xml\dataFiles\lessons.xml"); xn = doc.Root.Name.Namespace; ClipBig = elem.Element(xn.GetName("clipBig")).Value; ClipSmall = elem.Element(xn.GetName("clipSmall")).Value; Sound = elem.Element(xn.GetName("sound")).Value; Sound_BigletterExplanation = elem.Element(xn.GetName("sound_BigLetterExplanation")).Value; Sound_smallletterExplanation = elem.Element(xn.GetName("sound_SmallLetterExplanation")).Value; LettersBigShape = elem.Attribute("lettersBigShape").Value; LettersSmallShape = elem.Attribute("lettersSmallShape").Value; HebrewLetter = elem.Attribute("hebrewLetter").Value; setWordsForLetter(LettersBigShape); }
private XObject GenerateValueExpression(XNamespace ns, IEdmExpression expression) { // TODO: handle other than constant, other DataTypes XObject returnXObject = null; switch (expression.ExpressionKind) { case EdmExpressionKind.Null: returnXObject = new XElement(ns.GetName("Null")); break; case EdmExpressionKind.IntegerConstant: var integerConstantExpression = (IEdmIntegerConstantExpression)expression; returnXObject = new XAttribute("Int", integerConstantExpression.Value); break; case EdmExpressionKind.StringConstant: var stringConstantExpression = (IEdmStringConstantExpression)expression; returnXObject = new XAttribute("String", stringConstantExpression.Value); break; case EdmExpressionKind.Collection: returnXObject = this.GenerateCollectionExpression(ns, (IEdmCollectionExpression)expression); break; case EdmExpressionKind.Record: returnXObject = this.GenerateRecordExpression(ns, (IEdmRecordExpression)expression); break; default: throw new NotSupportedException(); } return(returnXObject); }
internal static XName GetXsiType(XElement xe) { string type = (string)xe.Attribute(XName.Get("type", XmlSchema.InstanceNamespace)); if (type != null) { string prefix = string.Empty; string localName = ParseQName(type, out prefix); XNamespace ns = null; if (prefix.Length == 0) { ns = xe.GetDefaultNamespace(); } else { ns = xe.GetNamespaceOfPrefix(prefix); } if (ns != null) { return(ns.GetName(localName)); } else { return(XName.Get(localName)); } } return(null); }
/// <summary> /// this METHOD should be commented, in release version! /// this is a helper method which can be used to create metadata xaml from data.linq entities /// this xaml can be later pasted as metadata in the user control /// and of course it needs to be corrected, but it is faster than to type all this from the start in code editor /// </summary> public override string ServiceGetXAML() { var metadata = base.GetMetadata(); var xaml = System.Windows.Markup.XamlWriter.Save(metadata); XNamespace data = "clr-namespace:RIAPP.DataService;assembly=RIAPP.DataService"; XNamespace dal = "clr-namespace:RIAppDemo.DAL;assembly=RIAppDemo.DAL"; XElement xtree = XElement.Parse(xaml); foreach (XElement el in xtree.DescendantsAndSelf()) { el.Name = data.GetName(el.Name.LocalName); if (el.Name.LocalName == "Metadata") { List <XAttribute> atList = el.Attributes().ToList(); el.Attributes().Remove(); } else if (el.Name.LocalName == "DbSetInfo") { XAttribute entityTypeAttr = el.Attributes().Where(a => a.Name.LocalName == "EntityType").First(); entityTypeAttr.Value = string.Format("{{x:Type {0}}}", entityTypeAttr.Value); } } xtree.Add(new XAttribute(XNamespace.Xmlns + "data", "clr-namespace:RIAPP.DataService;assembly=RIAPP.DataService")); return(xtree.ToString()); }
public HadLearnt(Lesson currentLesson) { doc = XDocument.Load(@"xml\dataFiles\lessons.xml"); xn = doc.Root.Name.Namespace; foreach (var lesson in doc.Descendants(xn.GetName("lesson"))) { if (int.Parse(lesson.Attribute("lessonCode").Value) <= int.Parse(currentLesson._lessonCode)) { lesson_learnt.Add(new Lesson(lesson.Attribute("lessonCode").Value)); } } foreach (var lesson in lesson_learnt) { foreach (var letter in lesson.lettersForLesson) { letterBigShape_HadLearnt.Add(letter.LettersBigShape); letterSmallShape_HadLearnt.Add(letter.LettersSmallShape); letters_HadLearnt.Add(letter); foreach (var word in letter.wordsForLetter) { pictuers_HadLearnt.Add(word); } } } }
void ComparePackages(Action <Func <IEnumerable <XElement>, IEnumerable <object> >, Func <string, string> > compare) { compare( elements => { XNamespace umlNamespace = elements.First().GetNamespaceOfPrefix("uml"); XName umlPackage = umlNamespace.GetName("Package"); return(from p in elements where (p.Name == "packagedElement" && GetXmiType(p) == "uml:Package") || p.Name == umlPackage let Name = GetName(p) let ParentName = p.Parent != null ? GetName(p.Parent) : string.Empty orderby ParentName, Name select new { Name, Visibility = GetVisibility(p), ParentName }); }, folderClause => { return(string.Format(@" select p1.Name, p2.Name as ParentName, p1.Visibility from [Microsoft.Uml2].[Packages] as p1 left join [Microsoft.Uml2].[Packages] as p2 on p2.Id = p1.OwningPackage And p1.Folder = p2.Folder join [Microsoft.Uml2].[UmlResources] ur on ur.Id = p1.ResourceId join [Microsoft.Uml2].[UmlResourceStems] us on ur.Stem = us.Id where p1.ElementKind='Package' and p1.{0} -- and p1.IsReference='false' order by ParentName, p1.Name", folderClause)); }); }
//<Snippet1> static void Main(string[] args) { // Create service host. WorkflowServiceHost host = new WorkflowServiceHost(CountingWorkflow(), new Uri(hostBaseAddress)); // Add service endpoint. host.AddServiceEndpoint("ICountingWorkflow", new BasicHttpBinding(), ""); // Define SqlWorkflowInstanceStore and assign it to host. SqlWorkflowInstanceStoreBehavior store = new SqlWorkflowInstanceStoreBehavior(connectionString); List <XName> variantProperties = new List <XName>() { xNS.GetName("Count") }; store.Promote("CountStatus", variantProperties, null); host.Description.Behaviors.Add(store); host.WorkflowExtensions.Add <CounterStatus>(() => new CounterStatus()); host.Open(); // This sample needs to be run with Admin privileges. // Otherwise the channel listener is not allowed to open ports. // See sample documentation for details. // Create a client that sends a message to create an instance of the workflow. ICountingWorkflow client = ChannelFactory <ICountingWorkflow> .CreateChannel(new BasicHttpBinding(), new EndpointAddress(hostBaseAddress)); client.start(); Console.WriteLine("(Press [Enter] at any time to terminate host)"); Console.ReadLine(); host.Close(); }
private static void SerializeXmlTree(XmlTreeAnnotation xmlTree, XElement parent) { ExceptionUtilities.CheckArgumentNotNull(xmlTree, "xmlTree"); XNamespace targetNamespace = XNamespace.Get(xmlTree.NamespaceName); if (xmlTree.IsAttribute) { CreateAttribute(parent, xmlTree.LocalName, xmlTree.NamespaceName, xmlTree.PropertyValue); } else { XElement element = parent.Element(targetNamespace.GetName(xmlTree.LocalName)); // create new element for repeatable elements if (element == null || IsRepeatableElement(element)) { element = CreateElement(parent, xmlTree.NamespacePrefix, xmlTree.LocalName, xmlTree.NamespaceName); } foreach (var child in xmlTree.Children) { SerializeXmlTree(child, element); } if (xmlTree.PropertyValue != null) { element.Value = xmlTree.PropertyValue; } } }
// FIXME: our manifest merger is hacky. // To support complete manifest merger, we will have to implement fairly complicated one, described at // http://tools.android.com/tech-docs/new-build-system/user-guide/manifest-merger void MergeLibraryManifest(string mergedManifest) { var nsResolver = new XmlNamespaceManager(new NameTable()); nsResolver.AddNamespace("android", androidNs.NamespaceName); var xdoc = XDocument.Load(mergedManifest); var package = xdoc.Root.Attribute("package")?.Value ?? string.Empty; foreach (var top in xdoc.XPathSelectElements("/manifest/*")) { var name = top.Attribute(AndroidXmlNamespace.GetName("name")); var existing = (name != null) ? doc.XPathSelectElement(string.Format("/manifest/{0}[@android:name='{1}']", top.Name.LocalName, name.Value), nsResolver) : doc.XPathSelectElement(string.Format("/manifest/{0}", top.Name.LocalName)); if (existing != null) { // if there is existing node with the same android:name, then append contents to existing node. existing.Add(FixupNameElements(package, top.Nodes())); } else { // otherwise, just add to the doc. doc.Root.Add(FixupNameElements(package, new XNode [] { top })); } } }
/// <summary> /// Constructor /// </summary> /// <param name="element">The element containing the node</param> // Revision History // MM/DD/YY who Version Issue# Description // -------- --- ------- ------ --------------------------------------- // 05/09/13 RCG 2.80.28 N/A Created public PropertyNode(XElement element) { if (element != null && element.Name.LocalName == ELEMENT_NAME) { XNamespace NameSpace = element.GetDefaultNamespace(); if (element.Attribute(ATTRIB_TYPE) != null) { m_PropertyType = EnumDescriptionRetriever.ParseToEnum <PropertyNodeType>(element.Attribute(ATTRIB_TYPE).Value); } if (element.Attribute(ATTRIB_INDEX) != null) { m_Index = sbyte.Parse(element.Attribute(ATTRIB_INDEX).Value); } m_Clients = new List <ClientNode>(); foreach (XElement ClientElement in element.Descendants(NameSpace.GetName(ClientNode.ELEMENT_NAME))) { m_Clients.Add(new ClientNode(ClientElement)); } } else { throw new ArgumentException("Not a valid property element", "element"); } }
public static XElement XElementFromElastic(ElasticObject elastic, XNamespace nameSpace = null) { // we default to empty namespace nameSpace = nameSpace ?? string.Empty; var exp = new XElement(nameSpace + elastic.InternalName); foreach (var a in elastic.Attributes.Where(a => a.Value.InternalValue != null)) { // if we have xmlns attribute add it like XNamespace instead of regular attribute if (a.Key.Equals("xmlns", StringComparison.InvariantCultureIgnoreCase)) { nameSpace = a.Value.InternalValue.ToString(); exp.Name = nameSpace.GetName(exp.Name.LocalName); } else { exp.Add(new XAttribute(a.Key, a.Value.InternalValue)); } } if (elastic.InternalContent is string) { exp.Add(new XText(elastic.InternalContent as string)); } foreach (var child in elastic.Elements.Select(c => XElementFromElastic(c, nameSpace))) { exp.Add(child); } return(exp); }
IList <string> AddMonoRuntimeProviders(XElement app) { app.Add(CreateMonoRuntimeProvider("mono.MonoRuntimeProvider", null, --AppInitOrder)); var providerNames = new List <string> (); var processAttrName = androidNs.GetName("process"); var procs = new List <string> (); foreach (XElement el in app.Elements()) { var proc = el.Attribute(processAttrName); if (proc == null) { continue; } if (procs.Contains(proc.Value)) { continue; } procs.Add(proc.Value); if (el.Name.NamespaceName != String.Empty) { continue; } switch (el.Name.LocalName) { case "provider": var autho = el.Attribute(androidNs.GetName("authorities")); if (autho != null && autho.Value.EndsWith(".__mono_init__")) { continue; } goto case "activity"; case "activity": case "receiver": case "service": string providerName = "MonoRuntimeProvider_" + procs.Count; providerNames.Add(providerName); app.Add(CreateMonoRuntimeProvider("mono." + providerName, proc.Value, --AppInitOrder)); break; } } return(providerNames); }
private CorrelationKey(string keyString, XNamespace provider) : base(GenerateKey(keyString), dictionary) { Dictionary <XName, InstanceValue> dictionary = new Dictionary <XName, InstanceValue>(2); dictionary.Add(provider.GetName("KeyString"), new InstanceValue(keyString, InstanceValueOptions.Optional)); dictionary.Add(WorkflowNamespace.KeyProvider, new InstanceValue(provider.NamespaceName, InstanceValueOptions.Optional)); this.KeyString = keyString; }
private static XAttribute CreateAttribute(XElement parent, string localName, XNamespace xmlNamespace, object value) { XName name = xmlNamespace != null?xmlNamespace.GetName(localName) : localName; XAttribute attribute = new XAttribute(name, value); parent.Add(attribute); return(attribute); }