void IXmlSerializable.ReadXml(XmlReader r) { r.MoveToContent(); r.ReadStartElement("Employee"); r.ReadStartElement("Name"); FirstName = r.ReadElementString("First", ns); LastName = r.ReadElementString("Last", ns); r.ReadEndElement(); r.MoveToContent(); ID = Int32.Parse(r.ReadElementString("ID", ns)); r.ReadEndElement(); }
private void _ParseFromReader(XmlReader reader) { reader.MoveToContent(); string strToken; if (_GetToken(reader, out strToken) && strToken == "plist") { if (_NextToken(reader)) { _ParseDictionary(reader); } } else { throw new FormatException("Badly format PLIST -- missing opening element"); } }
/// <summary> /// /// </summary> /// <param name="reader"></param> /// <param name="transaction"></param> /// <param name="payment"></param> internal static void Read(XmlReader reader, Transaction transaction, bool payment = true) { if (reader.IsEmptyElement) { XMLParserUtils.SkipNode(reader); return; } reader.ReadStartElement(); reader.MoveToContent(); while (!reader.EOF) { if (XMLParserUtils.IsEndElement(reader, SerializerHelper.PreApproval)) { XMLParserUtils.SkipNode(reader); break; } if (reader.NodeType == XmlNodeType.Element) { switch (reader.Name) { case SerializerHelper.Code: transaction.Code = reader.ReadElementContentAsString(); break; case SerializerHelper.Date: transaction.Date = reader.ReadElementContentAsDateTime(); break; case SerializerHelper.Reference: transaction.Reference = reader.ReadElementContentAsString(); break; case SerializerHelper.TransactionType: transaction.TransactionType = reader.ReadElementContentAsInt(); break; case SerializerHelper.TransactionStatus: transaction.TransactionStatus = reader.ReadElementContentAsInt(); break; case SerializerHelper.PaymentLink: transaction.PaymentLink = reader.ReadElementContentAsString(); break; case SerializerHelper.GrossAmount: transaction.GrossAmount = reader.ReadElementContentAsDecimal(); break; case SerializerHelper.DiscountAmount: transaction.DiscountAmount = reader.ReadElementContentAsDecimal(); break; case SerializerHelper.CreditorFees: CreditorFees creditorFees = new CreditorFees(); CreditorFeesSerializer.Read(reader, creditorFees); transaction.CreditorFees = creditorFees; break; case SerializerHelper.FeeAmount: transaction.FeeAmount = reader.ReadElementContentAsDecimal(); break; case SerializerHelper.NetAmount: transaction.NetAmount = reader.ReadElementContentAsDecimal(); break; case SerializerHelper.ExtraAmount: transaction.ExtraAmount = reader.ReadElementContentAsDecimal(); break; case SerializerHelper.LastEventDate: transaction.LastEventDate = reader.ReadElementContentAsDateTime(); break; case SerializerHelper.InstallmentCount: transaction.InstallmentCount = reader.ReadElementContentAsInt(); break; case PaymentMethodSerializer.PaymentMethod: PaymentMethod paymentMethod = new PaymentMethod(); PaymentMethodSerializer.Read(reader, paymentMethod); transaction.PaymentMethod = paymentMethod; break; case ItemListSerializer.Items: ItemListSerializer.Read(reader, transaction.Items); break; case SenderSerializer.Sender: Sender sender = new Sender(); SenderSerializer.Read(reader, sender); transaction.Sender = sender; break; case ShippingSerializer.Shipping: Shipping shipping = new Shipping(); ShippingSerializer.Read(reader, shipping); transaction.Shipping = shipping; break; default: XMLParserUtils.SkipElement(reader); break; } } else { XMLParserUtils.SkipNode(reader); } } }
private void AddImage(XmlReader reader, List <RemoteImageInfo> images) { reader.MoveToContent(); string bannerType = null; string url = null; int? bannerSeason = null; int? width = null; int? height = null; string language = null; double?rating = null; int? voteCount = null; string thumbnailUrl = null; reader.MoveToContent(); reader.Read(); // Loop through each element while (!reader.EOF && reader.ReadState == ReadState.Interactive) { if (reader.NodeType == XmlNodeType.Element) { switch (reader.Name) { case "Rating": { var val = reader.ReadElementContentAsString() ?? string.Empty; double rval; if (double.TryParse(val, NumberStyles.Any, _usCulture, out rval)) { rating = rval; } break; } case "RatingCount": { var val = reader.ReadElementContentAsString() ?? string.Empty; int rval; if (int.TryParse(val, NumberStyles.Integer, _usCulture, out rval)) { voteCount = rval; } break; } case "Language": { language = reader.ReadElementContentAsString() ?? string.Empty; break; } case "ThumbnailPath": { thumbnailUrl = reader.ReadElementContentAsString() ?? string.Empty; break; } case "BannerType": { bannerType = reader.ReadElementContentAsString() ?? string.Empty; break; } case "BannerPath": { url = reader.ReadElementContentAsString() ?? string.Empty; break; } case "BannerType2": { var bannerType2 = reader.ReadElementContentAsString() ?? string.Empty; // Sometimes the resolution is stuffed in here var resolutionParts = bannerType2.Split('x'); if (resolutionParts.Length == 2) { int rval; if (int.TryParse(resolutionParts[0], NumberStyles.Integer, _usCulture, out rval)) { width = rval; } if (int.TryParse(resolutionParts[1], NumberStyles.Integer, _usCulture, out rval)) { height = rval; } } break; } case "Season": { var val = reader.ReadElementContentAsString(); if (!string.IsNullOrWhiteSpace(val)) { bannerSeason = int.Parse(val); } break; } default: reader.Skip(); break; } } else { reader.Read(); } } if (!string.IsNullOrEmpty(url) && !bannerSeason.HasValue) { var imageInfo = new RemoteImageInfo { RatingType = RatingType.Score, CommunityRating = rating, VoteCount = voteCount, Url = TVUtils.BannerUrl + url, ProviderName = Name, Language = language, Width = width, Height = height }; if (!string.IsNullOrEmpty(thumbnailUrl)) { imageInfo.ThumbnailUrl = TVUtils.BannerUrl + thumbnailUrl; } if (string.Equals(bannerType, "poster", StringComparison.OrdinalIgnoreCase)) { imageInfo.Type = ImageType.Primary; images.Add(imageInfo); } else if (string.Equals(bannerType, "series", StringComparison.OrdinalIgnoreCase)) { imageInfo.Type = ImageType.Banner; images.Add(imageInfo); } else if (string.Equals(bannerType, "fanart", StringComparison.OrdinalIgnoreCase)) { imageInfo.Type = ImageType.Backdrop; images.Add(imageInfo); } } }
private bool AnalyzeData(XmlReader xmlRdr) { xmlRdr.MoveToContent(); int readinfoChecker = 0; int checkend = 0xFFF; while (xmlRdr.Read()) { if (xmlRdr.NodeType == XmlNodeType.Element) { if (string.Compare(xmlRdr.Name, ElementHeadInfo.Name, true) == 0) { HeadInfo = ElementHeadInfo.Create(xmlRdr); readinfoChecker |= 0x1; } else if (string.Compare(xmlRdr.Name, ElementParts.Name, true) == 0) { Parts = ElementParts.Create(xmlRdr); readinfoChecker |= 0x2; } else if (string.Compare(xmlRdr.Name, ElementPackages.Name, true) == 0) { Packages = ElementPackages.Create(xmlRdr); readinfoChecker |= 0x4; } else if (string.Compare(xmlRdr.Name, ElementComponents.Name, true) == 0) { Components = ElementComponents.Create(xmlRdr); readinfoChecker |= 0x8; } else if (string.Compare(xmlRdr.Name, ElementBoardArrays.Name, true) == 0) { BoardArrays = ElementBoardArrays.Create(xmlRdr); readinfoChecker |= 0x10; } else if (string.Compare(xmlRdr.Name, ElementFootprints.Name, true) == 0) { Footprints = ElementFootprints.Create(xmlRdr); readinfoChecker |= 0x20; } else if (string.Compare(xmlRdr.Name, ElementPackageBodyShapes.Name, true) == 0) { PackageBodyShapes = ElementPackageBodyShapes.Create(xmlRdr); readinfoChecker |= 0x40; } else if (string.Compare(xmlRdr.Name, ElementPackageLeadShapes.Name, true) == 0) { PackageLeadShapes = ElementPackageLeadShapes.Create(xmlRdr); readinfoChecker |= 0x80; } else if (string.Compare(xmlRdr.Name, ElementFootprintLeadShapes.Name, true) == 0) { FootprintLeadShapes = ElementFootprintLeadShapes.Create(xmlRdr); readinfoChecker |= 0x100; } else if (string.Compare(xmlRdr.Name, ElementBoardFovs.Name, true) == 0) { Boardfovs = ElementBoardFovs.Create(xmlRdr); readinfoChecker |= 0x200; } else if (string.Compare(xmlRdr.Name, ElementFovs.Name, true) == 0) { Fovs = ElementFovs.Create(xmlRdr); readinfoChecker |= 0x400; } else if (string.Compare(xmlRdr.Name, ElementBKFovs.Name, true) == 0) { BkFovs = ElementBKFovs.Create(xmlRdr); readinfoChecker |= 0x800; } else if (!xmlRdr.IsEmptyElement) { xmlRdr.Skip(); } if ((readinfoChecker & checkend) == checkend) { break; } } } return(true); }
public void ReadXml(XmlReader reader) { bool wasEmpty = reader.IsEmptyElement; reader.Read(); if (wasEmpty) { return; } while (reader.NodeType != System.Xml.XmlNodeType.EndElement) { reader.ReadStartElement("item"); //Read key reader.ReadStartElement("key"); reader.ReadStartElement("keyValue"); FunctionKeys?fk = null; if (reader.IsStartElement("functionKey")) { reader.ReadStartElement("functionKey"); var functionKeyAsString = reader.ReadString(); FunctionKeys localFk; //Remap function keys which have changed names over time if (functionKeyAsString == "AlphaKeyboard") { functionKeyAsString = "Alpha1Keyboard"; } else if (functionKeyAsString == "ConversationAlphaKeyboard") { functionKeyAsString = "ConversationAlpha1Keyboard"; } if (Enum.TryParse(functionKeyAsString, out localFk)) { fk = localFk; } reader.ReadEndElement(); } string s = null; if (reader.IsStartElement("str")) { reader.ReadStartElement("str"); s = reader.ReadString(); reader.ReadEndElement(); } reader.ReadEndElement(); reader.ReadEndElement(); var key = new KeyValue(fk, s); //Read value reader.ReadStartElement("value"); reader.ReadStartElement("ticks"); var valueAsString = reader.ReadString(); var value = string.IsNullOrEmpty(valueAsString) ? TimeSpan.Zero : XmlConvert.ToTimeSpan(valueAsString); reader.ReadEndElement(); reader.ReadEndElement(); this.Add(key, value); reader.ReadEndElement(); reader.MoveToContent(); } reader.ReadEndElement(); }
/// <summary> /// Reads XML conforming to https://www.w3.org/TR/2001/PR-xmldsig-core-20010820/#sec-Transforms /// </summary> /// <param name="reader">a <see cref="XmlReader"/>positioned on a <Transforms> element.</param> /// <param name="reference">a <see cref="Reference"/> to attach transforms.</param> /// <exception cref="ArgumentNullException">if <paramref name="reader"/> is null.</exception> /// <exception cref="ArgumentNullException">if <paramref name="reference"/> is null.</exception> /// <exception cref="XmlReadException">if there is a problem reading the XML.</exception> public virtual void ReadTransforms(XmlReader reader, Reference reference) { if (reader == null) { throw LogArgumentNullException(nameof(reader)); } if (reference == null) { throw LogArgumentNullException(nameof(reference)); } try { // <Transforms> - optional if (!reader.IsStartElement(XmlSignatureConstants.Elements.Transforms, XmlSignatureConstants.Namespace)) { return; } if (reader.IsEmptyElement) { reader.Read(); return; } reader.Read(); // <Transform> - unbounded while (reader.IsStartElement(XmlSignatureConstants.Elements.Transform, XmlSignatureConstants.Namespace)) { var isEmptyElement = reader.IsEmptyElement; var algorithm = reader.GetAttribute(XmlSignatureConstants.Attributes.Algorithm); if (string.IsNullOrEmpty(algorithm)) { throw XmlUtil.LogReadException(LogMessages.IDX30105); } if (TransformFactory.IsSupportedTransform(algorithm)) { reference.Transforms.Add(TransformFactory.GetTransform(algorithm)); reader.Read(); } else if (TransformFactory.IsSupportedCanonicalizingTransfrom(algorithm)) { reference.CanonicalizingTransfrom = TransformFactory.GetCanonicalizingTransform(algorithm); reader.Read(); // release 5.2.1 did not require 'ec' ns. So, we need to accept names with and without a prefix. if (reader.IsStartElement(XmlSignatureConstants.Elements.InclusiveNamespaces, XmlSignatureConstants.ExclusiveC14nNamespace) || reader.IsStartElement(XmlSignatureConstants.Elements.InclusiveNamespaces)) { bool isOnEmptyElement = reader.IsEmptyElement; reference.CanonicalizingTransfrom.InclusiveNamespacesPrefixList = reader.GetAttribute(XmlSignatureConstants.Attributes.PrefixList); reader.ReadStartElement(); if (!isOnEmptyElement) { reader.ReadEndElement(); } } } else { throw XmlUtil.LogReadException(LogMessages.IDX30210, algorithm); } reader.MoveToContent(); if (!isEmptyElement) { reader.ReadEndElement(); } } // </ Transforms> reader.MoveToContent(); reader.ReadEndElement(); } catch (Exception ex) { if (ex is XmlReadException) { throw; } throw XmlUtil.LogReadException(LogMessages.IDX30016, ex, XmlSignatureConstants.Elements.Transforms); } }
public void ReadXml(XmlReader reader) { AdminId = new HashSet <ulong>(); bool wasEmpty = reader.IsEmptyElement; reader.Read(); if (wasEmpty) { return; } try { while (reader.MoveToContent() != XmlNodeType.EndElement) { var name = reader.Name; // TODO Сделать нормальный парсер (на атрибутах свойств?) switch (name) { case "Token": Token = reader.ReadElementContentAsString(); break; case "AnnouncerToken": AnnouncerToken = reader.ReadElementContentAsString(); break; case "ImageBaseUrl": ImageBaseUrl = reader.ReadElementContentAsString(); break; case "DatabasePath": DatabasePath = reader.ReadElementContentAsString(); break; case "GameChannel": GameChannel = ulong.Parse(reader.ReadElementContentAsString()); break; case "AdminID": AdminId.Add(ulong.Parse(reader.ReadElementContentAsString())); break; case "Language": LanguageStr = reader.ReadElementContentAsString(); break; case "GameType": GameType = reader.ReadElementContentAsString(); break; default: reader.Skip(); break; } } } finally { reader.ReadEndElement(); } }
/// <summary> /// /// </summary> /// <param name="reader"></param> /// <param name="transaction"></param> internal static void Read(XmlReader reader, TransactionSummary transaction) { if (reader.IsEmptyElement) { XMLParserUtils.SkipNode(reader); return; } reader.ReadStartElement(SerializerHelper.Transaction); reader.MoveToContent(); while (!reader.EOF) { if (XMLParserUtils.IsEndElement(reader, SerializerHelper.Transaction)) { XMLParserUtils.SkipNode(reader); break; } if (reader.NodeType == XmlNodeType.Element) { switch (reader.Name) { case SerializerHelper.Code: transaction.Code = reader.ReadElementContentAsString(); break; case SerializerHelper.Date: transaction.Date = reader.ReadElementContentAsDateTime(); break; case SerializerHelper.Reference: transaction.Reference = reader.ReadElementContentAsString(); break; case SerializerHelper.TransactionType: transaction.TransactionType = reader.ReadElementContentAsInt(); break; case SerializerHelper.TransactionStatus: transaction.TransactionStatus = reader.ReadElementContentAsInt(); break; case SerializerHelper.PaymentLink: transaction.PaymentLink = reader.ReadElementContentAsString(); break; case SerializerHelper.GrossAmount: transaction.GrossAmount = reader.ReadElementContentAsDecimal(); break; case SerializerHelper.DiscountAmount: transaction.DiscountAmount = reader.ReadElementContentAsDecimal(); break; case SerializerHelper.FeeAmount: transaction.FeeAmount = reader.ReadElementContentAsDecimal(); break; case SerializerHelper.NetAmount: transaction.NetAmount = reader.ReadElementContentAsDecimal(); break; case SerializerHelper.ExtraAmount: transaction.ExtraAmount = reader.ReadElementContentAsDecimal(); break; case SerializerHelper.LastEventDate: transaction.LastEventDate = reader.ReadElementContentAsDateTime(); break; case PaymentMethodSerializer.PaymentMethod: PaymentMethod paymentMethod = new PaymentMethod(); PaymentMethodSerializer.Read(reader, paymentMethod); transaction.PaymentMethod = paymentMethod; break; default: XMLParserUtils.SkipElement(reader); break; } } else { XMLParserUtils.SkipNode(reader); } } }
public void ReadXml(XmlReader reader) { reader.MoveToContent(); //read all attributes Name = reader.GetAttribute("name"); #region Min Min = Single.Parse(reader.GetAttribute("min").TrimStart('+')); #endregion #region Max Max = Single.Parse(reader.GetAttribute("max").TrimStart('+')); #endregion #region Cells Cells = UInt16.Parse(reader.GetAttribute("cells")); #endregion #region Scale if (!String.IsNullOrWhiteSpace(reader.GetAttribute("ParaScale"))) { Scale = Single.Parse(reader.GetAttribute("ParaScale")); } #endregion #region JointName if (!String.IsNullOrWhiteSpace(reader.GetAttribute("JointName"))) { JointName = reader.GetAttribute("JointName"); } #endregion #region SKey if (!String.IsNullOrWhiteSpace(reader.GetAttribute("skey"))) { SKey = Single.Parse(reader.GetAttribute("skey")); } #endregion #region EKey if (!String.IsNullOrWhiteSpace(reader.GetAttribute("ekey"))) { EKey = Single.Parse(reader.GetAttribute("ekey")); } #endregion #region Locked if (!String.IsNullOrWhiteSpace(reader.GetAttribute("locked"))) { Locked = reader.GetAttribute("locked") == "1" ? true : false; } #endregion #region DeltaExtraction if (!String.IsNullOrWhiteSpace(reader.GetAttribute("deltaextraction"))) { DeltaExtraction = reader.GetAttribute("deltaextraction") == "1" ? true : false; } #endregion #region ChooseBlendSpace if (!String.IsNullOrWhiteSpace(reader.GetAttribute("ChooseBlendSpace"))) { ChooseBlendSpace = reader.GetAttribute("ChooseBlendSpace") == "1" ? true : false; } #endregion }
public void Validate() { logger.Log($"Launch {XmlFile} validation ... "); XmlReaderSettings settings = new XmlReaderSettings { //Message:Impossible de résoudre l'attribut 'schemaLocation'. //Error while XML validation: Pour des raisons de sécurité, DTD interdite dans ce document XML. Pour activer le traitement DTD, définissez sur Parse la propriété DtdProcessing sur XmlReaderSettings et transmettez les paramètres à la méthode XmlReader.Create. * *** DtdProcessing = DtdProcessing.Parse, MaxCharactersFromEntities = 1024, ValidationType = ValidationType.Schema }; try { settings.ValidationFlags |= XmlSchemaValidationFlags.ProcessInlineSchema; settings.ValidationFlags |= XmlSchemaValidationFlags.AllowXmlAttributes; // settings.ValidationFlags |= XmlSchemaValidationFlags.ProcessIdentityConstraints; // settings.ValidationFlags |= XmlSchemaValidationFlags.ProcessSchemaLocation; if (ShowWarnings) { settings.ValidationFlags |= XmlSchemaValidationFlags.ReportValidationWarnings; } foreach (var xsd_file in XsdFiles) { if (File.Exists(xsd_file)) { settings.Schemas.Add(null, new XmlTextReader(xsd_file)); } else { logger.Log($"{xsd_file} doesn't exist"); } } settings.Schemas.Compile(); settings.ValidationEventHandler += new ValidationEventHandler(ValidationHandler); using (XmlTextReader xmltextReader = new XmlTextReader(this.XmlFile) { DtdProcessing = DtdProcessing.Parse }) { using (XmlReader reader = XmlReader.Create(xmltextReader, settings)) { reader.MoveToContent(); while (reader.Read()) { } } } logger.Log($"{XmlFile} Validation finished successfully"); } catch (Exception e) { logger.Log($"Error while XML validation: {e.Message}", true); logger.Log($"{XmlFile} Validation FAILED"); } finally { ArrayList a = new ArrayList(); foreach (var item in settings.Schemas.Schemas()) { XmlSchema xmlSchema = item as XmlSchema; if (xmlSchema != null) { a.Add(xmlSchema); } } for (int i = 0; i < a.Count; i++) { settings.Schemas.Remove(a[i] as XmlSchema); } settings.Schemas = null; settings.CloseInput = true; } }
protected internal virtual void DeserializeElement(XmlReader reader, bool serializeCollectionKey) { Hashtable readProps = new Hashtable(); reader.MoveToContent(); while (reader.MoveToNextAttribute()) { PropertyInformation prop = ElementInformation.Properties [reader.LocalName]; if (prop == null || (serializeCollectionKey && !prop.IsKey)) { /* handle the built in ConfigurationElement attributes here */ if (reader.LocalName == "lockAllAttributesExcept") { LockAllAttributesExcept.SetFromList(reader.Value); } else if (reader.LocalName == "lockAllElementsExcept") { LockAllElementsExcept.SetFromList(reader.Value); } else if (reader.LocalName == "lockAttributes") { LockAttributes.SetFromList(reader.Value); } else if (reader.LocalName == "lockElements") { LockElements.SetFromList(reader.Value); } else if (reader.LocalName == "lockItem") { LockItem = (reader.Value.ToLowerInvariant() == "true"); } else if (reader.LocalName == "xmlns") { /* ignore */ } else if (this is ConfigurationSection && reader.LocalName == "configSource") { /* ignore */ } else if (!OnDeserializeUnrecognizedAttribute(reader.LocalName, reader.Value)) { throw new ConfigurationErrorsException("Unrecognized attribute '" + reader.LocalName + "'.", reader); } continue; } if (readProps.ContainsKey(prop)) { throw new ConfigurationErrorsException("The attribute '" + prop.Name + "' may only appear once in this element.", reader); } string value = null; try { value = reader.Value; ValidateValue(prop.Property, value); prop.SetStringValue(value); } catch (ConfigurationErrorsException) { throw; } catch (ConfigurationException) { throw; } catch (Exception ex) { string msg = String.Format("The value for the property '{0}' is not valid. The error is: {1}", prop.Name, ex.Message); throw new ConfigurationErrorsException(msg, reader); } readProps [prop] = prop.Name; } reader.MoveToElement(); if (reader.IsEmptyElement) { reader.Skip(); } else { int depth = reader.Depth; reader.ReadStartElement(); reader.MoveToContent(); do { if (reader.NodeType != XmlNodeType.Element) { reader.Skip(); continue; } PropertyInformation prop = ElementInformation.Properties [reader.LocalName]; if (prop == null || (serializeCollectionKey && !prop.IsKey)) { if (!OnDeserializeUnrecognizedElement(reader.LocalName, reader)) { if (prop == null) { ConfigurationElementCollection c = GetDefaultCollection(); if (c != null && c.OnDeserializeUnrecognizedElement(reader.LocalName, reader)) { continue; } } throw new ConfigurationErrorsException("Unrecognized element '" + reader.LocalName + "'.", reader); } continue; } if (!prop.IsElement) { throw new ConfigurationException("Property '" + prop.Name + "' is not a ConfigurationElement."); } if (readProps.Contains(prop)) { throw new ConfigurationErrorsException("The element <" + prop.Name + "> may only appear once in this section.", reader); } ConfigurationElement val = (ConfigurationElement)prop.Value; val.DeserializeElement(reader, serializeCollectionKey); readProps [prop] = prop.Name; if (depth == reader.Depth) { reader.Read(); } } while (depth < reader.Depth); } modified = false; foreach (PropertyInformation prop in ElementInformation.Properties) { if (!String.IsNullOrEmpty(prop.Name) && prop.IsRequired && !readProps.ContainsKey(prop)) { PropertyInformation p = ElementInformation.Properties [prop.Name]; if (p == null) { object val = OnRequiredPropertyNotFound(prop.Name); if (!object.Equals(val, prop.DefaultValue)) { prop.Value = val; prop.IsModified = false; } } } } PostDeserialize(); }
private static DrawingTool ParseTool(XmlReader r) { r.MoveToContent(); r.ReadStartElement(); string version = r.ReadElementContentAsString("FormatVersion", ""); if (version != "1.0") { log.ErrorFormat("Unsupported format version ({0}) for tool description.", version); return(null); } Guid id = Guid.Empty; string name = ""; string displayName = ""; Bitmap icon = null; Type drawingType = null; bool attached = true; bool keepToolAfterDrawingCreation = false; bool keepToolAfterFrameChange = false; DrawingStyle style = null; while (r.NodeType == XmlNodeType.Element) { switch (r.Name) { case "Id": id = new Guid(r.ReadElementContentAsString()); break; case "Name": name = r.ReadElementContentAsString(); break; case "DisplayName": displayName = r.ReadElementContentAsString(); break; case "Icon": string iconReference = r.ReadElementContentAsString(); if (!string.IsNullOrEmpty(iconReference)) { icon = Properties.Drawings.ResourceManager.GetObject(iconReference) as Bitmap; } break; case "DrawingClass": string drawingClass = r.ReadElementContentAsString(); drawingType = FindType(drawingClass); break; case "Attached": attached = XmlHelper.ParseBoolean(r.ReadElementContentAsString()); break; case "KeepToolAfterDrawingCreation": keepToolAfterDrawingCreation = XmlHelper.ParseBoolean(r.ReadElementContentAsString()); break; case "KeepToolAfterFrameChange": keepToolAfterFrameChange = XmlHelper.ParseBoolean(r.ReadElementContentAsString()); break; case "DefaultStyle": style = new DrawingStyle(r); break; default: string unparsed = r.ReadOuterXml(); log.DebugFormat("Unparsed content in Drawing Tool XML: {0}", unparsed); break; } } r.ReadEndElement(); if (icon == null) { icon = Properties.Drawings.generic_posture; } DrawingTool tool = new DrawingTool(id, name, displayName, icon, drawingType, attached, keepToolAfterDrawingCreation, keepToolAfterFrameChange, style); return(tool); }
private void Process() { bool savedEnforceConstraints = dataset.EnforceConstraints; try { dataset.EnforceConstraints = false; reader.MoveToContent(); if (mode == XmlReadMode.Fragment) { while (reader.NodeType == XmlNodeType.Element && !reader.EOF) { ReadTopLevelElement(); } } else { ReadTopLevelElement(); } } finally { dataset.EnforceConstraints = savedEnforceConstraints; } }
void VerifyInput(MessageBuffer buf) { Message input = buf.CreateMessage(); /* * XmlWriterSettings settings = new XmlWriterSettings (); * settings.Indent = true; * using (XmlWriter w = XmlWriter.Create (Console.Error, settings)) { * buf.CreateMessage ().WriteMessage (w); * } * Console.Error.WriteLine ("******************** DONE ********************"); * Console.Error.Flush (); */ Assert.AreEqual("http://schemas.xmlsoap.org/ws/2005/02/trust/RST/Issue", input.Headers.Action, "GetToken.Request.Action"); Assert.IsNotNull(input.Headers.MessageId, "GetToken.Request.MessageID"); // in the raw Message it is "http://www.w3.org/2005/08/addressing/anonymous", but it is replaced by MessageHeaders implementation. Assert.AreEqual(new EndpointAddress("http://schemas.microsoft.com/2005/12/ServiceModel/Addressing/Anonymous"), input.Headers.ReplyTo, "GetToken.Request.ReplyTo"); // o:Security // FIXME: test WSSecurity more // <o:Security> // <u:Timestamp> // <u:Created>...</u:Created> // <u:Expires>...</u:Expires> // </u:Timestamp> // <o:BinarySecurityToken>...</o:BinarySecurityToken> // <e:EncryptedKey> // <e:EncryptionMethod><DigestMethod/></e:EncryptionMethod> // <KeyInfo> // <o:SecurityTokenReference><o:Reference/></o:SecurityTokenReference> // </KeyInfo> // <e:CipherData> // <e:CipherValue>...</e:CipherValue> // </e:CipherData> // </e:EncryptedKey> // [ // <c:DerivedKeyToken> // <o:SecurityTokenReference><o:Reference/></o:SecurityTokenReference> // <c:Offset>...</c:Offset> // <c:Length>...</c:Length> // <c:Nonce>...</c:Nonce> // </c:DerivedKeyToken> // ] // <e:ReferenceList> // [ // <e:DataReference> // ] // </e:ReferenceList> // <e:EncryptedData> // <e:EncryptionMethod/> // <KeyInfo> {{....}} </KeyInfo> // <e:CipherData> {{....}} </e:CipherData> // </e:EncryptedData> // </o:Security> int i = input.Headers.FindHeader("Security", "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd"); Assert.IsTrue(i >= 0, "Security header existence"); MessageHeaderInfo info = input.Headers [i]; Assert.IsNotNull(info, "Security header item"); XmlReader r = input.Headers.GetReaderAtHeader(i); // FIXME: test WSSecurity more // <o:Security> r.MoveToContent(); r.ReadStartElement("Security", "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd"); // <u:Timestamp> r.MoveToContent(); r.ReadStartElement("Timestamp", "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd"); // <u:Created>...</u:Created> r.MoveToContent(); r.ReadStartElement("Created", "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd"); r.ReadString(); r.MoveToContent(); r.ReadEndElement(); // <u:Expires>...</u:Expires> r.MoveToContent(); r.ReadStartElement("Expires", "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd"); r.ReadString(); r.MoveToContent(); r.ReadEndElement(); // </u:Timestamp> r.MoveToContent(); r.ReadEndElement(); // <o:BinarySecurityToken>...</o:BinarySecurityToken> r.MoveToContent(); r.ReadStartElement("BinarySecurityToken", "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd"); byte [] rawcert = Convert.FromBase64String(r.ReadString()); r.ReadEndElement(); X509Certificate2 cert = new X509Certificate2(rawcert); // FIXME: test EncryptedKey r.MoveToContent(); r.Skip(); // <e:EncryptedKey> // <e:EncryptionMethod><DigestMethod/></e:EncryptionMethod> // <KeyInfo> // <o:SecurityTokenReference><o:Reference/></o:SecurityTokenReference> // </KeyInfo> // <e:CipherData> // <e:CipherValue>...</e:CipherValue> // </e:CipherData> // </e:EncryptedKey> // FIXME: test DerivedKeyTokens r.MoveToContent(); while (r.LocalName == "DerivedKeyToken") { r.Skip(); r.MoveToContent(); } // [ // <c:DerivedKeyToken> // <o:SecurityTokenReference><o:Reference/></o:SecurityTokenReference> // <c:Offset>...</c:Offset> // <c:Length>...</c:Length> // <c:Nonce>...</c:Nonce> // </c:DerivedKeyToken> // ] // <e:ReferenceList> // [ // <e:DataReference> // ] // </e:ReferenceList> // <e:EncryptedData> // <e:EncryptionMethod/> // <KeyInfo> {{....}} </KeyInfo> // <e:CipherData> {{....}} </e:CipherData> // </e:EncryptedData> // </o:Security> // SOAP Body r = input.GetReaderAtBodyContents(); // just verifying itself ;) }
public static void ReadObjectProperties(XmlReader reader, object obj, PropertyConversionHandler handler = null) { // Build property lookup table PropertyInfo[] props = obj.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public); Dictionary<string, PropertyInfo> propHash = new Dictionary<string, PropertyInfo>(props.Length); foreach (var pi in props) if (!Attribute.IsDefined(pi, typeof(XmlIgnoreAttribute), false)) propHash.Add(GetPropertyElementName(pi), pi); while (reader.MoveToContent() == System.Xml.XmlNodeType.Element) { PropertyInfo pi; if (propHash.TryGetValue(reader.LocalName, out pi)) { if (IsStandardType(pi.PropertyType)) { object value = null; if (pi.PropertyType.IsEnum) value = Enum.Parse(pi.PropertyType, reader.ReadElementContentAsString()); else value = reader.ReadElementContentAs(pi.PropertyType, null); if (handler != null) handler(pi, obj, ref value); pi.SetValue(obj, value, null); } else { ReadObject(reader, pi.GetValue(obj, null)); } } else { reader.Skip(); reader.MoveToContent(); } } }
public override Task <XmlNodeType> MoveToContentAsync() => Task.FromResult(_reader.MoveToContent());
public void ReadXml(XmlReader reader) { bool wasEmpty = reader.IsEmptyElement; reader.Read(); if (wasEmpty) { return; } try { while (reader.MoveToContent() != XmlNodeType.EndElement) { var name = reader.Name; // TODO Сделать нормальный парсер (на атрибутах свойств?) switch (name) { case "MuteOnDeath": MuteOnDeath = bool.Parse(reader.ReadElementContentAsString()); break; case "StartFromNight": StartFromNight = bool.Parse(reader.ReadElementContentAsString()); break; case "ShowNightActions": ShowNightActions = bool.Parse(reader.ReadElementContentAsString()); break; case "IsMafiaEnabled": IsMafiaEnabled = bool.Parse(reader.ReadElementContentAsString()); break; case "IsYakuzaEnabled": IsYakuzaEnabled = bool.Parse(reader.ReadElementContentAsString()); break; case "MafPercent": MafPercent = short.Parse(reader.ReadElementContentAsString()); break; case "MinPlayers": MinPlayers = int.Parse(reader.ReadElementContentAsString()); break; case "PlayerCollectingTime": PlayerCollectingTime = int.Parse(reader.ReadElementContentAsString()); break; case "PauseTime": PauseTime = int.Parse(reader.ReadElementContentAsString()); break; case "MorningTime": MorningTime = int.Parse(reader.ReadElementContentAsString()); break; case "DayTime": DayTime = int.Parse(reader.ReadElementContentAsString()); break; case "EveningTime": EveningTime = int.Parse(reader.ReadElementContentAsString()); break; case "NightTime": NightTime = int.Parse(reader.ReadElementContentAsString()); break; case "MinNotificationInterval": MinNotificationInterval = int.Parse(reader.ReadElementContentAsString()); break; case "MaxUsersToNotify": MaxUsersToNotify = byte.Parse(reader.ReadElementContentAsString()); break; case "MaxInactiveDays": MaxInactiveDays = int.Parse(reader.ReadElementContentAsString()); break; case "InfectionChancePercent": InfectionChancePercent = short.Parse(reader.ReadElementContentAsString()); break; case "Nickname": Nickname = reader.ReadElementContentAsString(); break; case "AvatarPath": AvatarPath = reader.ReadElementContentAsString(); break; default: reader.Skip(); break; } } } finally { reader.ReadEndElement(); } }
/// <summary> /// Reads XML conforming to https://www.w3.org/TR/2001/PR-xmldsig-core-20010820/#sec-Reference /// </summary> /// <param name="reader">a <see cref="XmlReader"/>positioned on a <Reference> element.</param> /// <exception cref="ArgumentNullException">if <paramref name="reader"/> is null.</exception> /// <exception cref="XmlReadException">if there is a problem reading the XML.</exception> /// <returns><see cref="Reference"/></returns> public virtual Reference ReadReference(XmlReader reader) { XmlUtil.CheckReaderOnEntry(reader, XmlSignatureConstants.Elements.Reference, XmlSignatureConstants.Namespace); try { var reference = new Reference { Prefix = reader.Prefix, Id = reader.GetAttribute(XmlSignatureConstants.Attributes.Id, null), Type = reader.GetAttribute(XmlSignatureConstants.Attributes.Type, null), Uri = reader.GetAttribute(XmlSignatureConstants.Attributes.URI, null) }; reader.Read(); ReadTransforms(reader, reference); // <DigestMethod> - required XmlUtil.CheckReaderOnEntry(reader, XmlSignatureConstants.Elements.DigestMethod, XmlSignatureConstants.Namespace); bool isEmptyElement = reader.IsEmptyElement; var digestMethod = reader.GetAttribute(XmlSignatureConstants.Attributes.Algorithm, null); if (string.IsNullOrEmpty(digestMethod)) { throw XmlUtil.OnRequiredAttributeMissing(XmlSignatureConstants.Elements.DigestMethod, XmlSignatureConstants.Attributes.Algorithm); } reference.DigestMethod = digestMethod; reader.Read(); reader.MoveToContent(); if (!isEmptyElement) { reader.ReadEndElement(); } // <DigestValue> XmlUtil.CheckReaderOnEntry(reader, XmlSignatureConstants.Elements.DigestValue, XmlSignatureConstants.Namespace); var digestValue = reader.ReadElementContentAsString().Trim(); if (string.IsNullOrEmpty(digestValue)) { throw XmlUtil.LogReadException(LogMessages.IDX30206, reference.Uri ?? reference.Id); } reference.DigestValue = digestValue; // </Reference> reader.MoveToContent(); reader.ReadEndElement(); return(reference); } catch (Exception ex) { if (ex is XmlReadException) { throw; } throw XmlUtil.LogReadException(LogMessages.IDX30016, ex, XmlSignatureConstants.Elements.Reference); } }
internal static void Read(XmlReader reader, Transaction transaction) { if (reader == null) { throw new ArgumentNullException("reader"); } if (transaction == null) { throw new ArgumentNullException("transaction"); } if (reader.IsEmptyElement) { SerializationHelper.SkipNode(reader); return; } reader.ReadStartElement(TransactionSerializerHelper.Transaction); reader.MoveToContent(); while (!reader.EOF) { if (SerializationHelper.IsEndElement(reader, TransactionSerializerHelper.Transaction)) { SerializationHelper.SkipNode(reader); break; } if (reader.NodeType == XmlNodeType.Element) { switch (reader.Name) { case TransactionSerializerHelper.Code: transaction.Code = reader.ReadElementContentAsString(); break; case TransactionSerializerHelper.Date: transaction.Date = reader.ReadElementContentAsDateTime(); break; case TransactionSerializerHelper.Reference: transaction.Reference = reader.ReadElementContentAsString(); break; case TransactionSerializerHelper.TransactionType: transaction.TransactionType = reader.ReadElementContentAsInt(); break; case TransactionSerializerHelper.TransactionStatus: transaction.TransactionStatus = reader.ReadElementContentAsInt(); break; case TransactionSerializerHelper.GrossAmount: transaction.GrossAmount = reader.ReadElementContentAsDecimal(); break; case TransactionSerializerHelper.DiscountAmount: transaction.DiscountAmount = reader.ReadElementContentAsDecimal(); break; case TransactionSerializerHelper.FeeAmount: transaction.FeeAmount = reader.ReadElementContentAsDecimal(); break; case TransactionSerializerHelper.NetAmount: transaction.NetAmount = reader.ReadElementContentAsDecimal(); break; case TransactionSerializerHelper.ExtraAmount: transaction.ExtraAmount = reader.ReadElementContentAsDecimal(); break; case TransactionSerializerHelper.LastEventDate: transaction.LastEventDate = reader.ReadElementContentAsDateTime(); break; case TransactionSerializerHelper.InstallmentCount: transaction.InstallmentCount = reader.ReadElementContentAsInt(); break; case PaymentMethodSerializer.PaymentMethod: PaymentMethod paymentMethod = new PaymentMethod(); PaymentMethodSerializer.Read(reader, paymentMethod); transaction.PaymentMethod = paymentMethod; break; case ItemListSerializer.Items: ItemListSerializer.Read(reader, transaction.Items); break; case SenderSerializer.Sender: Sender sender = new Sender(); SenderSerializer.Read(reader, sender); transaction.Sender = sender; break; case ShippingSerializer.Shipping: Shipping shipping = new Shipping(); ShippingSerializer.Read(reader, shipping); transaction.Shipping = shipping; break; default: SerializationHelper.SkipElement(reader); break; } } else { SerializationHelper.SkipNode(reader); } } }
/// <summary> /// ストリームからデータを復元します /// </summary> /// <param name="reader"></param> /// <returns></returns> public static SequenceData Deserialize(XmlReader reader) { SequenceData ret = null; reader.ReadStartElement(typeof(SequenceData).Name); byte[] titleBytes = null, sequenceBytes = null; LabelingBorders border = null; string tmp; MemoryStream tmpStream; StreamWriter tmpWriter; for (reader.MoveToContent(); reader.NodeType != XmlNodeType.EndElement && reader.NodeType != XmlNodeType.None; reader.MoveToContent()) { if (reader.IsEmptyElement) { reader.Skip(); continue; } switch (reader.Name) { case "Title": tmp = reader.ReadElementContentAsString(); tmpStream = new MemoryStream(); tmpWriter = new StreamWriter(tmpStream); tmpWriter.Write(tmp); tmpWriter.Flush(); titleBytes = tmpStream.ToArray(); break; case "Sequence": tmp = reader.ReadElementContentAsString(); tmpStream = new MemoryStream(); tmpWriter = new StreamWriter(tmpStream); tmpWriter.Write(tmp); tmpWriter.Flush(); sequenceBytes = tmpStream.ToArray(); break; case "Border": reader.ReadStartElement(); border = LabelingBorders.Deserialize(reader.ReadSubtree()); for (reader.MoveToContent(); reader.NodeType != XmlNodeType.EndElement && reader.NodeType != XmlNodeType.None; reader.MoveToContent()) { reader.Skip(); } reader.ReadEndElement(); break; default: reader.Skip(); break; } } reader.ReadEndElement(); if (titleBytes != null && sequenceBytes != null && border != null) { ret = new SequenceData(); ret.Borders = border; using (MemoryStream stream2 = new MemoryStream(sequenceBytes)) { ret.Values = TimeSeriesValues.Deserialize(stream2); } using (MemoryStream stream2 = new MemoryStream(titleBytes)) { ret.RetrieveDataHeader(stream2); } } return(ret); }
public SilverlightClientConfiguration Load(XmlReader reader) { var ret = new SilverlightClientConfiguration(); ret.Bindings = new BindingsConfiguration(); ret.Client = new ClientConfiguration(); reader.MoveToContent(); if (reader.IsEmptyElement) { return(ret); } reader.ReadStartElement("configuration"); for (reader.MoveToContent(); reader.NodeType != XmlNodeType.EndElement; reader.MoveToContent()) { if (reader.NodeType != XmlNodeType.Element || reader.LocalName != "system.serviceModel" || reader.IsEmptyElement) { reader.Skip(); continue; } // in <system.serviceModel> reader.ReadStartElement(); for (reader.MoveToContent(); reader.NodeType != XmlNodeType.EndElement; reader.MoveToContent()) { if (reader.NodeType != XmlNodeType.Element || reader.IsEmptyElement) { reader.Skip(); continue; } switch (reader.LocalName) { case "bindings": reader.ReadStartElement(); for (reader.MoveToContent(); reader.NodeType != XmlNodeType.EndElement; reader.MoveToContent()) { if (reader.NodeType != XmlNodeType.Element || reader.IsEmptyElement) { reader.Skip(); continue; } switch (reader.LocalName) { case "customBinding": reader.ReadStartElement(); for (reader.MoveToContent(); reader.NodeType != XmlNodeType.EndElement; reader.MoveToContent()) { if (reader.NodeType != XmlNodeType.Element || reader.LocalName != "binding") { reader.Skip(); continue; } ret.Bindings.CustomBinding.Add(ReadCustomBinding(reader)); } reader.ReadEndElement(); break; case "basicHttpBinding": reader.ReadStartElement(); for (reader.MoveToContent(); reader.NodeType != XmlNodeType.EndElement; reader.MoveToContent()) { if (reader.NodeType != XmlNodeType.Element || reader.LocalName != "binding") { reader.Skip(); continue; } ret.Bindings.BasicHttpBinding.Add(ReadBasicHttpBinding(reader)); } reader.ReadEndElement(); break; } } reader.ReadEndElement(); break; case "client": reader.ReadStartElement(); for (reader.MoveToContent(); reader.NodeType != XmlNodeType.EndElement; reader.MoveToContent()) { if (reader.NodeType != XmlNodeType.Element || reader.LocalName != "endpoint") { reader.Skip(); continue; } ret.Client.Endpoints.Add(ReadEndpoint(reader)); } reader.ReadEndElement(); break; } } reader.ReadEndElement(); // out <system.serviceModel> } reader.ReadEndElement(); // out <configuration> return(ret); }
// Token: 0x0600256B RID: 9579 RVA: 0x00087AA4 File Offset: 0x00085CA4 protected override void LoadSymbolsMapFromFile(string filePath, Dictionary <string, List <ScriptSharpSymbolWrapper> > symbolMaps, Dictionary <uint, string> sourceFileIdMap, ClientWatsonFunctionNamePool functionNamePool) { Dictionary <string, int> dictionary = new Dictionary <string, int>(); Dictionary <int, List <ScriptSharpSymbolWrapper> > dictionary2 = new Dictionary <int, List <ScriptSharpSymbolWrapper> >(); Stack <ScriptSharpSourceMapLoader.ContainingMethodContext> stack = new Stack <ScriptSharpSourceMapLoader.ContainingMethodContext>(); Stack <ScriptSharpSourceMapLoader.ParentContext> stack2 = new Stack <ScriptSharpSourceMapLoader.ParentContext>(); string arg = null; string arg2 = null; int num = -1; int key = -1; int count = sourceFileIdMap.Count; using (XmlReader xmlReader = XmlReader.Create(filePath)) { while (xmlReader.Read()) { XmlNodeType xmlNodeType = xmlReader.MoveToContent(); if (xmlNodeType == XmlNodeType.Element) { if (xmlReader.Name == "Statement") { ScriptSharpSourceMapLoader.ContainingMethodContext containingMethodContext = stack.Peek(); ScriptSharpSymbol scriptSharpSymbol; if (ScriptSharpSourceMapLoader.TryParseSymbol(xmlReader, containingMethodContext.ScriptOffset, containingMethodContext.FunctionNameIndex, num, out scriptSharpSymbol)) { ScriptSharpSourceMapLoader.PopNonParentSymbolsOut(stack2, scriptSharpSymbol, dictionary2[key]); stack2.Push(new ScriptSharpSourceMapLoader.ParentContext(scriptSharpSymbol)); } } else if (xmlReader.Name == "Method") { string attribute = xmlReader.GetAttribute("SourceFile"); if (string.IsNullOrEmpty(attribute)) { ScriptSharpSourceMapLoader.SkipSubTree(xmlReader, "Method"); } else { if (!dictionary.TryGetValue(attribute, out num)) { num = dictionary.Count + count; dictionary.Add(attribute, num); } arg2 = xmlReader.GetAttribute("Name"); string name = string.Format("{0}.{1}", arg, arg2); int orAddFunctionNameIndex = functionNamePool.GetOrAddFunctionNameIndex(name); ScriptSharpSymbol symbol; if (!ScriptSharpSourceMapLoader.TryParseSymbol(xmlReader, 0, orAddFunctionNameIndex, num, out symbol)) { ScriptSharpSourceMapLoader.SkipSubTree(xmlReader, "Method"); } else if (!xmlReader.IsEmptyElement) { stack.Push(new ScriptSharpSourceMapLoader.ContainingMethodContext(symbol.ScriptStartPosition, orAddFunctionNameIndex)); stack2.Push(new ScriptSharpSourceMapLoader.ParentContext(symbol, true)); } else { dictionary2[key].Add(new ScriptSharpSymbolWrapper(symbol)); } } } else if (xmlReader.Name == "AnonymousMethod") { ScriptSharpSourceMapLoader.ContainingMethodContext containingMethodContext2 = stack.Peek(); string name2 = string.Format("{0}.<{1}>anonymous", arg, arg2); int orAddFunctionNameIndex2 = functionNamePool.GetOrAddFunctionNameIndex(name2); ScriptSharpSymbol scriptSharpSymbol2; if (!ScriptSharpSourceMapLoader.TryParseSymbol(xmlReader, containingMethodContext2.ScriptOffset, orAddFunctionNameIndex2, num, out scriptSharpSymbol2)) { ScriptSharpSourceMapLoader.SkipSubTree(xmlReader, "AnonymousMethod"); } else { List <ScriptSharpSymbolWrapper> list = dictionary2[key]; ScriptSharpSourceMapLoader.ParentContext parentContext = ScriptSharpSourceMapLoader.PopNonParentSymbolsOut(stack2, scriptSharpSymbol2, list); if (!xmlReader.IsEmptyElement) { stack.Push(new ScriptSharpSourceMapLoader.ContainingMethodContext(scriptSharpSymbol2.ScriptStartPosition, orAddFunctionNameIndex2)); stack2.Push(new ScriptSharpSourceMapLoader.ParentContext(scriptSharpSymbol2, true)); } else { parentContext.Children.Add(list.Count); list.Add(new ScriptSharpSymbolWrapper(scriptSharpSymbol2)); } } } else if (xmlReader.Name == "Type") { arg = xmlReader.GetAttribute("Name"); string attribute2 = xmlReader.GetAttribute("SegmentRef"); if (string.IsNullOrEmpty(attribute2) || !int.TryParse(attribute2, out key)) { ScriptSharpSourceMapLoader.SkipSubTree(xmlReader, "Type"); } else if (!dictionary2.ContainsKey(key)) { dictionary2.Add(key, new List <ScriptSharpSymbolWrapper>(1024)); } } else if (xmlReader.Name == "Segments") { IL_3CE: while (xmlReader.Read()) { if (xmlReader.IsStartElement("Segment")) { string attribute3 = xmlReader.GetAttribute("Id"); int key2; List <ScriptSharpSymbolWrapper> list2; if (int.TryParse(attribute3, out key2) && dictionary2.TryGetValue(key2, out list2)) { string packageName = ScriptSharpSourceMapLoader.GetPackageName(xmlReader, filePath); try { symbolMaps.Add(packageName, list2); list2.TrimExcess(); } catch (ArgumentException exception) { string extraData = string.Format("Package: {0}, File name: {1}", packageName, filePath); ExWatson.SendReport(exception, ReportOptions.DoNotCollectDumps, extraData); } } } } goto IL_3E5; } } else if (xmlNodeType == XmlNodeType.EndElement && (xmlReader.Name == "Method" || xmlReader.Name == "AnonymousMethod")) { stack.Pop(); List <ScriptSharpSymbolWrapper> symbolList = dictionary2[key]; bool flag = false; while (stack2.Count > 0 && !flag) { ScriptSharpSourceMapLoader.ParentContext parentContext2 = ScriptSharpSourceMapLoader.PopItemAndAddToList(stack2, symbolList); flag = parentContext2.IsMethod; } } } goto IL_3CE; } IL_3E5: foreach (KeyValuePair <string, int> keyValuePair in dictionary) { sourceFileIdMap.Add((uint)keyValuePair.Value, keyValuePair.Key); } }
/// <summary> /// Handler method for SOAP control requests. /// </summary> /// <param name="service">The service whose action was called.</param> /// <param name="messageStream">The stream which contains the HTTP message body with the SOAP envelope.</param> /// <param name="streamEncoding">Encoding of the <paramref name="messageStream"/>.</param> /// <param name="subscriberSupportsUPnP11">Should be set if the requester sent a user agent header which denotes a UPnP /// version of 1.1. If set to <c>false</c>, in- and out-parameters with extended data type will be deserialized/serialized /// using the string-equivalent of the values.</param> /// <param name="context">Context object holding data for the current action call.</param> /// <param name="result">SOAP result - may be an action result, a SOAP fault or <c>null</c> if no body should /// be sent in the HTTP response.</param> /// <returns>HTTP status code to be sent. Should be /// <list> /// <item><see cref="HttpStatusCode.OK"/> If the action could be evaluated correctly and produced a SOAP result.</item> /// <item><see cref="HttpStatusCode.InternalServerError"/> If the result is a SOAP fault.</item> /// <item><see cref="HttpStatusCode.BadRequest"/> If the message stream was malformed.</item> /// </list> /// </returns> public static HttpStatusCode HandleRequest(DvService service, Stream messageStream, Encoding streamEncoding, bool subscriberSupportsUPnP11, CallContext context, out string result) { UPnPError res; try { IList <object> inParameterValues = null; // Default to null if there aren't parameters, will be lazily initialized later DvAction action; using (StreamReader streamReader = new StreamReader(messageStream, streamEncoding)) using (XmlReader reader = XmlReader.Create(streamReader, UPnPConfiguration.DEFAULT_XML_READER_SETTINGS)) { reader.MoveToContent(); // Parse SOAP envelope reader.ReadStartElement("Envelope", UPnPConsts.NS_SOAP_ENVELOPE); reader.ReadStartElement("Body", UPnPConsts.NS_SOAP_ENVELOPE); // Reader is positioned at the action element string serviceTypeVersion_URN = reader.NamespaceURI; string type; int version; // Parse service and action if (!ParserHelper.TryParseTypeVersion_URN(serviceTypeVersion_URN, out type, out version)) { throw new MediaPortal.Utilities.Exceptions.InvalidDataException("Unable to parse service type and version URN '{0}'", serviceTypeVersion_URN); } string actionName = reader.LocalName; if (!service.Actions.TryGetValue(actionName, out action)) { result = CreateFaultDocument(401, "Invalid Action"); return(HttpStatusCode.InternalServerError); } IEnumerator <DvArgument> formalArgumentEnumer = action.InArguments.GetEnumerator(); if (!SoapHelper.ReadEmptyStartElement(reader)) // Action name { while (reader.NodeType != XmlNodeType.EndElement) { string argumentName = reader.Name; // Arguments don't have a namespace, so take full name if (!formalArgumentEnumer.MoveNext() || formalArgumentEnumer.Current.Name != argumentName) { // Too many arguments result = CreateFaultDocument(402, "Invalid Args"); return(HttpStatusCode.InternalServerError); } object value; if (SoapHelper.ReadNull(reader)) { value = null; } else { res = formalArgumentEnumer.Current.SoapParseArgument(reader, !subscriberSupportsUPnP11, out value); if (res != null) { result = CreateFaultDocument(res.ErrorCode, res.ErrorDescription); return(HttpStatusCode.InternalServerError); } } if (inParameterValues == null) { inParameterValues = new List <object>(); } inParameterValues.Add(value); } } if (formalArgumentEnumer.MoveNext()) { // Too few arguments result = CreateFaultDocument(402, "Invalid Args"); return(HttpStatusCode.InternalServerError); } } IList <object> outParameterValues; // Invoke action try { res = action.InvokeAction(inParameterValues, out outParameterValues, false, context); // outParameterValues can be null if the action has no output parameters. Setting it to an empty list makes // it easier to check parameter count later. if (outParameterValues == null) { outParameterValues = EMPTY_OBJECT_LIST; } } catch (Exception e) { UPnPConfiguration.LOGGER.Warn("SOAPHandler: Error invoking UPnP action '{0}'", e, action.Name); result = CreateFaultDocument(501, "Action Failed"); return(HttpStatusCode.InternalServerError); } if (res != null) { result = CreateFaultDocument(res.ErrorCode, res.ErrorDescription); return(HttpStatusCode.InternalServerError); } // Check output parameters IList <DvArgument> formalArguments = action.OutArguments; if (outParameterValues.Count != formalArguments.Count) { result = CreateFaultDocument(501, "Action Failed"); return(HttpStatusCode.InternalServerError); } IList <OutParameter> outParams = formalArguments.Select((t, i) => new OutParameter(t, outParameterValues[i])).ToList(); result = CreateResultDocument(action, outParams, !subscriberSupportsUPnP11); return(HttpStatusCode.OK); } catch (Exception e) { UPnPConfiguration.LOGGER.Warn("Error handling SOAP request: " + e.Message); // Don't log the whole exception; it's only a communication error with a client result = null; return(HttpStatusCode.BadRequest); } }
//===================================================================== /// <summary> /// Load the collection from the related file /// </summary> /// <remarks>This will be done automatically at constructor. This can /// be called to reload the collection if needed.</remarks> public void Load() { XmlReaderSettings settings = new XmlReaderSettings(); XmlReader xr = null; string defTopicId, splitTopicId; Topic t; try { this.Clear(); settings.CloseInput = true; xr = XmlReader.Create(fileItem.FullPath, settings); xr.MoveToContent(); // These are old options from versions prior to 1.9.0.0 defTopicId = xr.GetAttribute("defaultTopic"); splitTopicId = xr.GetAttribute("splitTOCTopic"); while (!xr.EOF && xr.NodeType != XmlNodeType.EndElement) { if (xr.NodeType == XmlNodeType.Element && xr.Name == "Topic") { t = new Topic(); t.ReadXml(xr); this.Add(t); } xr.Read(); } } finally { if (xr != null) { xr.Close(); } } // Set the default topic if defined from a prior version if (!String.IsNullOrEmpty(defTopicId)) { t = this[defTopicId]; if (t != null) { t.IsDefaultTopic = true; } } // Set the "split TOC" option if defined from a prior version if (!String.IsNullOrEmpty(splitTopicId)) { t = this[splitTopicId]; if (t != null) { t.ApiParentMode = ApiParentMode.InsertAfter; } } this.MatchProjectFilesToTopics(); }
private static object ReadElementAs(this XmlReader reader, string localName, Type type, ReaderState state) { reader.MoveToContent(); var isEmptyElement = reader.IsEmptyElement; if (reader.Name != localName) { if (!type.CanBeNull()) { throw new SerializationException(string.Format("Failed reading element: {0}, could not find it.", localName)); } return(null); } if (!reader.CanResolveEntity) { throw new SerializationException("!reader.CanResolveEntity"); } if (type == typeof(string)) { var value = reader.ReadElementContentAsString(); return(value); } if (type.IsEnum) { var value = Enum.Parse(type, reader.ReadElementContentAsString()); return(value); } if (ReadElementContentAsTypes.Contains(type)) { var value = reader.ReadElementValueAs(type); VerifyNullable(value, localName, type); return(value); } if (type.IsInterface) { if (typeof(IXmlSerializable).IsAssignableFrom(type)) { Type instanceType; if (state == ReaderState.ReadingListItem) { instanceType = type.Assembly.GetTypes() .Where(x => !x.IsInterface && !x.IsAbstract) .SingleOrDefault(x => x.Name == reader.LocalName); // This is on the simple side for now ^ if (instanceType == null) { throw new SerializationException(string.Format("Failed deserializing {0}", reader.Name)); } } else { reader.ReadStartElement(); instanceType = type.Assembly.GetTypes() .Where(x => !x.IsInterface && !x.IsAbstract) .SingleOrDefault(x => x.Name == reader.LocalName); // This is on the simple side for now ^ if (instanceType == null) { throw new SerializationException(string.Format("Failed deserializing {0}", reader.Name)); } } var instance = (IXmlSerializable)Activator.CreateInstance(instanceType, true); instance.ReadXml(reader); if (state != ReaderState.ReadingListItem) { reader.ReadEndElement(); } return(instance); } else { throw new NotImplementedException("Cannot write interface type that is not IXmlSerializable"); } } if (typeof(IXmlSerializable).IsAssignableFrom(type)) { var instanceType = type; var instance = (IXmlSerializable)Activator.CreateInstance(instanceType, true); instance.ReadXml(reader); return(instance); } if (type.IsList()) { var listElementType = type.ListElementType(); reader.ReadStartElement(); var values = (IList)Activator.CreateInstance(type); while (reader.NodeType == XmlNodeType.Element) { var item = reader.ReadElementAs(reader.Name, listElementType, ReaderState.ReadingListItem); values.Add(item); } if (!isEmptyElement) { reader.ReadEndElement(); } return(values); } reader.ReadStartElement(); var serializer = new XmlSerializer(type); var deserialized = serializer.Deserialize(reader); if (!isEmptyElement) { reader.ReadEndElement(); } VerifyNullable(deserialized, localName, type); return(deserialized); }
protected void ReadReferencedElements() { reader.MoveToContent(); XmlNodeType nt = reader.NodeType; while (nt != XmlNodeType.EndElement && nt != XmlNodeType.None) { whileIterationCount++; readCount++; ReadReferencedElement(); reader.MoveToContent(); nt = reader.NodeType; } whileIterationCount = 0; // Registers delayed list if (delayedListFixups != null) { foreach (DictionaryEntry entry in delayedListFixups) { AddTarget((string)entry.Key, entry.Value); } } // Fix arrays if (collItemFixups != null) { foreach (CollectionItemFixup itemFixup in collItemFixups) { itemFixup.Collection.SetValue(GetTarget(itemFixup.Id), itemFixup.Index); } } // Fills collections if (collFixups != null) { ICollection cfixups = collFixups.Values; foreach (CollectionFixup fixup in cfixups) { fixup.Callback(fixup.Collection, fixup.CollectionItems); } } // Fills class instances if (fixups != null) { foreach (Fixup fixup in fixups) { fixup.Callback(fixup); } } if (targets != null) { foreach (DictionaryEntry e in targets) { if (e.Value != null && (referencedObjects == null || !referencedObjects.Contains(e.Value))) { UnreferencedObject((string)e.Key, e.Value); } } } }
public static GAPAuthenticatorValueDTO?ReadXmlv2(XmlReader reader, string?password = null) { GAPAuthenticatorValueDTO?authenticator = null; var authenticatorType = reader.GetAttribute("type"); if (!string.IsNullOrEmpty(authenticatorType)) { authenticatorType = authenticatorType.Replace( "WindowsAuthenticator.", typeof(GAPAuthenticatorValueDTO).FullName + "."); var authenticatorType_ = Assembly.GetExecutingAssembly().GetType(authenticatorType, false, true); authenticator = Activator.CreateInstance(authenticatorType_.ThrowIsNull(nameof(authenticatorType_))) as GAPAuthenticatorValueDTO; } if (authenticator == null) { return(null); } reader.MoveToContent(); if (reader.IsEmptyElement) { reader.Read(); return(null); } reader.Read(); while (reader.EOF == false) { if (reader.IsStartElement()) { switch (reader.Name) { case "servertimediff": authenticator.ServerTimeDiff = reader.ReadElementContentAsLong(); break; //case "restorecodeverified": // authenticator.RestoreCodeVerified = reader.ReadElementContentAsBoolean(); // break; case "secretdata": var encrypted = reader.GetAttribute("encrypted"); var data = reader.ReadElementContentAsString(); var passwordType = DecodePasswordTypes(encrypted); if (passwordType != PasswordTypes.None) { // this is an old version so there is no hash data = DecryptSequence(data, passwordType, password); } authenticator.PasswordType = PasswordTypes.None; authenticator.SecretData = data; break; default: if (authenticator.ReadExtraXml(reader, reader.Name) == false) { reader.Skip(); } break; } } else { reader.Read(); break; } } return(authenticator); }
private static Dictionary <ExchangeUser, FreeBusy> ParseRasterFreeBusyResponse( ExchangeUserDict users, DateTime baseTime, Stream response) { Dictionary <ExchangeUser, FreeBusy> result = new Dictionary <ExchangeUser, FreeBusy>(); string emailAddress = null; string freeBusyRaster = null; string elementName = null; XmlReaderSettings settings = new XmlReaderSettings(); settings.XmlResolver = null; settings.IgnoreComments = true; settings.IgnoreWhitespace = true; settings.ValidationType = ValidationType.None; settings.ValidationFlags = XmlSchemaValidationFlags.None; XmlReader reader = XmlReader.Create(response, settings); reader.MoveToContent(); while (reader.Read()) { switch (reader.NodeType) { case XmlNodeType.Element: elementName = reader.LocalName; if (elementName == "item") { emailAddress = null; freeBusyRaster = null; } break; case XmlNodeType.Text: if (elementName == "email") { emailAddress = reader.Value.ToLower(); } else { if (elementName == "fbdata") { freeBusyRaster = reader.Value; } } break; case XmlNodeType.EndElement: if (reader.LocalName == "item") { ParseFreeBusyRaster(users, baseTime, emailAddress, freeBusyRaster, result); emailAddress = null; freeBusyRaster = null; } elementName = string.Empty; break; } } return(result); }
public bool ReadXml(XmlReader reader, string?password = null) { // decode the password type var encrypted = reader.GetAttribute("encrypted"); var passwordType = DecodePasswordTypes(encrypted); PasswordType = passwordType; if (passwordType != PasswordTypes.None) { // read the encrypted text from the node EncryptedData = reader.ReadElementContentAsString(); return(Unprotect(password)); //// decrypt //try //{ // string data = Authenticator.DecryptSequence(this.EncryptedData, passwordType, password); // using (MemoryStream ms = new MemoryStream(Authenticator.StringToByteArray(data))) // { // reader = XmlReader.Create(ms); // this.ReadXml(reader, password); // } //} //catch (EncryptedSecretDataException) //{ // this.RequiresPassword = true; // throw; //} //finally //{ // this.PasswordType = passwordType; //} } reader.MoveToContent(); if (reader.IsEmptyElement) { reader.Read(); return(false); } reader.Read(); while (reader.EOF == false) { if (reader.IsStartElement()) { switch (reader.Name) { case "lastservertime": LastServerTime = reader.ReadElementContentAsLong(); break; case "servertimediff": ServerTimeDiff = reader.ReadElementContentAsLong(); break; case "secretdata": SecretData = reader.ReadElementContentAsString(); break; default: if (ReadExtraXml(reader, reader.Name) == false) { reader.Skip(); } break; } } else { reader.Read(); break; } } // check if we need to sync, or if it's been a day #pragma warning disable CS0612 // 类型或成员已过时 if (this is HOTPAuthenticator) #pragma warning restore CS0612 // 类型或成员已过时 { // no time sync return(true); } else if (ServerTimeDiff == 0 || LastServerTime == 0 || LastServerTime < DateTime.Now.AddHours(-24).Ticks) { Sync(); return(true); } else { return(false); } }
private void ReadXml(XmlReader r) { try { r.MoveToContent(); if (!(r.Name == "KinoveaPostureTool")) { return; } r.ReadStartElement(); r.ReadElementContentAsString("FormatVersion", ""); while (r.NodeType == XmlNodeType.Element) { switch (r.Name) { case "Icon": r.ReadOuterXml(); break; case "Id": Id = new Guid(r.ReadElementContentAsString()); break; case "Name": Name = r.ReadElementContentAsString(); break; case "DisplayName": DisplayName = r.ReadElementContentAsString(); break; case "PointCount": ParsePointCount(r); break; case "Segments": ParseSegments(r); break; case "Ellipses": ParseEllipses(r); break; case "Angles": ParseAngles(r); break; case "Distances": ParseDistances(r); break; case "Positions": ParsePositions(r); break; case "Handles": ParseHandles(r); break; case "ComputedPoints": ParseComputedPoints(r); break; case "HitZone": ParseHitZone(r); break; case "TrackingProfile": CustomTrackingProfile.ReadXml(r); break; case "DefaultOptions": ParseDefaultOptions(r); break; case "Capabilities": ParseCapabilities(r); break; case "InitialConfiguration": ParseInitialConfiguration(r); break; default: string unparsed = r.ReadOuterXml(); log.DebugFormat("Unparsed content in XML: {0}", unparsed); break; } } r.ReadEndElement(); ImportOptionGroups(); } catch (Exception e) { log.ErrorFormat("An error occurred during the parsing of a custom tool."); log.ErrorFormat(e.ToString()); } }
/// <summary> /// Deserialize a struct member /// </summary> /// <param name="reader">XML Reader that contains XML Stream</param> /// <param name="arrayItemType">Type of Array Object</param> /// <param name="containedInArray">Indicates if a parameter is in Array</param> /// <returns>Object element</returns> private static object DeserializeParamStruct(XmlReader reader, Type arrayItemType, bool containedInArray) { Dictionary <object, object> structInfo = new Dictionary <object, object>(); Dictionary <object, XMLRpcType> structDataTypeInfo = new Dictionary <object, XMLRpcType>(); if (containedInArray) { reader.MoveToContent(); } if (reader.Read()) { if (reader.NodeType == XmlNodeType.Element) { //<struct> if (reader.Name == "struct") { if (XNode.ReadFrom(reader) is XElement el) { //get array of <member> var arrayOfProperties = el.Elements(); foreach (var property in arrayOfProperties) { //<name> var nameNode = property.FirstNode as XElement; string propertyName = NormalizePropertyName(nameNode.Value); //<value> var valueNode = property.LastNode as XElement; //Get DataType From Tag var dataTypeNode = valueNode.FirstNode as XElement; var dataType = (XMLRpcType)StringEnum.Parse(typeof(XMLRpcType), dataTypeNode.Name.LocalName, true); var readedValue = new object(); switch (dataType) { case XMLRpcType.Int: case XMLRpcType.Boolean: case XMLRpcType.Double: case XMLRpcType.String: case XMLRpcType.Datetime: readedValue = dataTypeNode.Value; break; case XMLRpcType.Array: case XMLRpcType.Struct: default: break; } structInfo.Add(propertyName, readedValue); structDataTypeInfo.Add(propertyName, dataType); } } } else { throw new InvalidCastException("Can not find the struct specification"); } } } PropertyInfo[] arrayPropertyInfos = arrayItemType.GetProperties(); Type objType = Type.GetType(arrayItemType.AssemblyQualifiedName); var newObject = Activator.CreateInstance(objType); foreach (PropertyInfo property in arrayPropertyInfos) { if (structInfo.ContainsKey(property.Name)) { property.SetValue(newObject, ConvertToType(property.PropertyType, structInfo[property.Name], property.Name)); } } return(newObject); }
public static void ReadObject(XmlReader reader, object obj, PropertyConversionHandler handler = null) { if (obj == null) throw new ArgumentNullException("obj"); reader.MoveToContent(); if (obj is IXmlSerializable) { ((IXmlSerializable)obj).ReadXml(reader); } else { object oVal = null; string oName = GetAttributeValue(obj.GetType(), typeof(XmlRootAttribute), "ElementName", true, ref oVal) ? oVal.ToString() : obj.GetType().Name; if (reader.LocalName != oName) throw new XmlException("XML element name does not match object."); if (!reader.IsEmptyElement) { reader.ReadStartElement(); reader.MoveToContent(); ReadObjectProperties(reader, obj, handler); reader.ReadEndElement(); } else reader.Skip(); } }
public void ReadXml(XmlReader reader, string password = null) { reader.MoveToContent(); if (reader.IsEmptyElement) { reader.Read(); return; } reader.Read(); while (reader.EOF == false) { if (reader.IsStartElement()) { switch (reader.Name) { case "modifiers": Modifiers = (WinAPI.KeyModifiers)BitConverter.ToInt32(Authenticator.StringToByteArray(reader.ReadElementContentAsString()), 0); break; case "hotkey": HotKey = (WinAPI.VirtualKeyCode)BitConverter.ToUInt16(Authenticator.StringToByteArray(reader.ReadElementContentAsString()), 0); break; case "windowtitle": WindowTitle = reader.ReadElementContentAsString(); break; case "windowtitleregex": WindowTitleRegex = reader.ReadElementContentAsBoolean(); break; case "processname": ProcessName = reader.ReadElementContentAsString(); break; case "advanced": Advanced = reader.ReadElementContentAsBoolean(); break; case "script": string encrypted = reader.GetAttribute("encrypted"); string data = reader.ReadElementContentAsString(); if (string.IsNullOrEmpty(encrypted) == false) { Authenticator.PasswordTypes passwordType = Authenticator.DecodePasswordTypes(encrypted); data = Authenticator.DecryptSequence(data, passwordType, password, null, true); //byte[] plain = Authenticator.StringToByteArray(data); //data = Encoding.UTF8.GetString(plain, 0, plain.Length); /* * char[] encTypes = encrypted.ToCharArray(); * // we read the string in reverse order (the order they were encrypted) * for (int i = encTypes.Length - 1; i >= 0; i--) * { * char encryptedType = encTypes[i]; * switch (encryptedType) * { * case 'u': * { * // we are going to decrypt with the Windows User account key * byte[] cipher = Authenticator.StringToByteArray(data); * byte[] plain = ProtectedData.Unprotect(cipher, null, DataProtectionScope.CurrentUser); * data = Encoding.UTF8.GetString(plain, 0, plain.Length); * break; * } * case 'm': * { * // we are going to decrypt with the Windows local machine key * byte[] cipher = Authenticator.StringToByteArray(data); * byte[] plain = ProtectedData.Unprotect(cipher, null, DataProtectionScope.LocalMachine); * data = Encoding.UTF8.GetString(plain, 0, plain.Length); * break; * } * case 'y': * { * // we use an explicit password to encrypt data * if (string.IsNullOrEmpty(password) == true) * { * throw new EncryptedSecretDataException(); * } * data = Authenticator.Decrypt(data, password, true); * byte[] plain = Authenticator.StringToByteArray(data); * data = Encoding.UTF8.GetString(plain, 0, plain.Length); * break; * } * default: * break; * } * } */ } AdvancedScript = data; break; default: reader.Skip(); break; } } else { reader.Read(); break; } } }