public byte[] getRequestContent( string doctype, string root, Type type, object obj) { XmlSerializer serializer = null; if (root == null) { //... root element will be the object type name serializer = new XmlSerializer(type); } else { //... root element set explicitely var xattribs = new XmlAttributes(); var xroot = new XmlRootAttribute(root); xattribs.XmlRoot = xroot; var xoverrides = new XmlAttributeOverrides(); xoverrides.Add(type, xattribs); serializer = new XmlSerializer(type, xoverrides); } XmlWriterSettings settings = new XmlWriterSettings(); settings.Indent = false; settings.OmitXmlDeclaration = false; settings.Encoding = new UTF8Encoding(false/*no BOM*/, true/*throw if input illegal*/); XmlSerializerNamespaces xmlNameSpace = new XmlSerializerNamespaces(); xmlNameSpace.Add("xsi", "http://www.w3.org/2001/XMLSchema-instance"); xmlNameSpace.Add("noNamespaceSchemaLocation", m_schemadir + "/" + doctype + "." + m_schemaext); StringWriter sw = new StringWriter(); XmlWriter xw = XmlWriter.Create( sw, settings); xw.WriteProcessingInstruction("xml", "version='1.0' encoding='UTF-8'"); serializer.Serialize(xw, obj, xmlNameSpace); return settings.Encoding.GetBytes( sw.ToString()); }
/// <summary> /// Serializes an object into an XML document /// </summary> /// <param name="obj">object to serialize</param> /// <param name="rootAttribute">root attribute to use</param> /// <param name="namespacePrefixes">namespace prefixes</param> /// <returns>a string that contains the XML document</returns> public static string Serialize(object obj, XmlRootAttribute rootAttribute, params XmlQualifiedName[] namespacePrefixes) { if (obj == null) { return null; } using (var textWriter = new StringWriterUTF8()) { var type = obj.GetType(); var xmlAttributeOverrides = new XmlAttributeOverrides(); if (rootAttribute != null) { var xmlAttributes = new XmlAttributes(); xmlAttributes.XmlRoot = rootAttribute; xmlAttributeOverrides.Add(type, xmlAttributes); } using (var xmWriter = XmlWriter.Create(textWriter, new XmlWriterSettings() { OmitXmlDeclaration = true })) { var namespaces = new XmlSerializerNamespaces(); if (namespacePrefixes != null) { foreach (var ns in namespacePrefixes) { namespaces.Add(ns.Name, ns.Namespace); } } new XmlSerializer(type, xmlAttributeOverrides).Serialize(xmWriter, obj, namespaces); } return textWriter.ToString(); } }
private async void ButtonSendErrorReport_Click(object sender, RoutedEventArgs e) { var ex = Error.ToExceptionless(); ex.SetUserDescription(string.Empty, NoteTextBox.Text); ex.AddObject(HurricaneSettings.Instance.Config, "HurricaneSettings", null, null, true); if (HurricaneSettings.Instance.IsLoaded) { using (var sw = new StringWriter()) { XmlAttributeOverrides overrides = new XmlAttributeOverrides(); //DONT serialize the passwords and send them to me! XmlAttributes attribs = new XmlAttributes {XmlIgnore = true}; attribs.XmlElements.Add(new XmlElementAttribute("Passwords")); overrides.Add(typeof(ConfigSettings), "Passwords", attribs); var xmls = new XmlSerializer(typeof(ConfigSettings), overrides); xmls.Serialize(sw, HurricaneSettings.Instance.Config); var doc = new XmlDocument(); doc.LoadXml(sw.ToString()); ex.SetProperty("HurricaneSettings", JsonConvert.SerializeXmlNode(doc)); } } ex.Submit(); ((Button)sender).IsEnabled = false; StatusProgressBar.IsIndeterminate = true; await ExceptionlessClient.Default.ProcessQueueAsync(); StatusProgressBar.IsIndeterminate = false; Application.Current.Shutdown(); }
public static PersistentVM LoadStateFromFile(string filePath) { PersistentVM persistentVM; if (File.Exists(filePath)) { XmlAttributeOverrides xmlAttributeOverride = new XmlAttributeOverrides(); XmlAttributes xmlAttribute = new XmlAttributes(); xmlAttribute.XmlIgnore = true; xmlAttributeOverride.Add(typeof(DataVirtualHardDisk), "MediaLink", xmlAttribute); xmlAttributeOverride.Add(typeof(DataVirtualHardDisk), "SourceMediaLink", xmlAttribute); xmlAttributeOverride.Add(typeof(OSVirtualHardDisk), "MediaLink", xmlAttribute); xmlAttributeOverride.Add(typeof(OSVirtualHardDisk), "SourceImageName", xmlAttribute); Type[] typeArray = new Type[1]; typeArray[0] = typeof(NetworkConfigurationSet); XmlSerializer xmlSerializer = new XmlSerializer(typeof(PersistentVM), xmlAttributeOverride, typeArray, null, null); using (FileStream fileStream = new FileStream(filePath, FileMode.Open)) { persistentVM = xmlSerializer.Deserialize(fileStream) as PersistentVM; } return persistentVM; } else { throw new ArgumentException("The file to load the role does not exist", "filePath"); } }
public void Add (Type type, string member, XmlAttributes attributes) { if(overrides[GetKey(type, member)] != null) throw new Exception("The attributes for the given type and Member already exist in the collection"); overrides.Add(GetKey(type,member), attributes); }
public static PersistentVM LoadStateFromFile(string filePath) { if (!File.Exists(filePath)) { throw new ArgumentException(Resources.MissingPersistentVMFile, "filePath"); } XmlAttributeOverrides overrides = new XmlAttributeOverrides(); XmlAttributes ignoreAttrib = new XmlAttributes(); ignoreAttrib.XmlIgnore = true; overrides.Add(typeof(DataVirtualHardDisk), "MediaLink", ignoreAttrib); overrides.Add(typeof(DataVirtualHardDisk), "SourceMediaLink", ignoreAttrib); overrides.Add(typeof(OSVirtualHardDisk), "MediaLink", ignoreAttrib); overrides.Add(typeof(OSVirtualHardDisk), "SourceImageName", ignoreAttrib); var serializer = new System.Xml.Serialization.XmlSerializer(typeof(PersistentVM), overrides, new Type[] { typeof(NetworkConfigurationSet) }, null, null); PersistentVM role = null; using (var stream = new FileStream(filePath, FileMode.Open)) { role = serializer.Deserialize(stream) as PersistentVM; } return role; }
public static XmlAttributeOverrides Create(Type objectType) { XmlAttributeOverrides xOver = null; if (!table.TryGetValue(objectType, out xOver)) { // Create XmlAttributeOverrides object. xOver = new XmlAttributeOverrides(); /* Create an XmlTypeAttribute and change the name of the XML type. */ XmlTypeAttribute xType = new XmlTypeAttribute(); xType.TypeName = objectType.Name; // Set the XmlTypeAttribute to the XmlType property. XmlAttributes attrs = new XmlAttributes(); attrs.XmlType = xType; /* Add the XmlAttributes to the XmlAttributeOverrides, specifying the member to override. */ xOver.Add(objectType, attrs); table.MergeSafe(objectType, xOver); } return xOver; }
public static T ParseXML <T>(this string @this) where T : class { if (string.IsNullOrWhiteSpace(@this)) { return((T)Activator.CreateInstance(typeof(T))); } if ([email protected]("<?xml version=\"1.0\" encoding=\"utf-16\"?>")) { @this = "<?xml version=\"1.0\" encoding=\"utf-16\"?>" + @this; } string kUtf8BOM = System.Text.Encoding.UTF8.GetString(System.Text.Encoding.UTF8.GetPreamble()); if (@this.StartsWith(kUtf8BOM)) { @this = @this.Remove(0, kUtf8BOM.Length); } if (@this.StartsWith("?xm")) { @this = "<" + @this; } StringReader Stream = null; XmlTextReader Reader = null; try { System.Xml.Serialization.XmlAttributeOverrides xOver = new System.Xml.Serialization.XmlAttributeOverrides(); System.Xml.Serialization.XmlAttributes attrs = new System.Xml.Serialization.XmlAttributes(); foreach (var Ig in typeof(T).GetProperties().Where(c => !c.PropertyType.IsSerializable || c.PropertyType.FullName.StartsWith("DynamicBusiness.BPMS.BusinessLogic") || c.PropertyType.FullName.StartsWith("DynamicBusiness.BPMS.Engine")).Select(c => c.Name)) { attrs = new System.Xml.Serialization.XmlAttributes(); attrs.XmlIgnore = true; xOver.Add(typeof(T), Ig, attrs); } XmlSerializer Serializer = new XmlSerializer(typeof(T), xOver); Stream = new StringReader(@this); Reader = new XmlTextReader(Stream); // covert reader to object return((T)Serializer.Deserialize(Reader)); } catch (Exception ex) { return(default(T)); } finally { if (Stream != null) { Stream.Close(); } if (Reader != null) { Reader.Close(); } } }
public static XmlAttributeOverrides GetExportedDefinitionsOverrides(XmlAttributeOverrides DefinitionsOverrides) { var _container = PluginContainer.GetOvalCompositionContainer(); var testTypes = _container.GetExports<TestType>().Select(exp => exp.Value.GetType()); var objectTypes = _container.GetExports<ObjectType>().Select(exp => exp.Value.GetType()); var stateTypes = _container.GetExports<StateType>().Select(exp => exp.Value.GetType()); XmlAttributes testAttributes = new XmlAttributes(); foreach (var testType in testTypes) { var xmlAttrs = (testType.GetCustomAttributes(typeof(XmlRootAttribute), false) as XmlRootAttribute[]).SingleOrDefault(); testAttributes.XmlArrayItems.Add(new XmlArrayItemAttribute(xmlAttrs.ElementName, testType) { Namespace = xmlAttrs.Namespace }); } DefinitionsOverrides.Add(typeof(oval_definitions), "tests", testAttributes); XmlAttributes objectAttributes = new XmlAttributes(); foreach (var objectType in objectTypes) { var xmlAttrs = (objectType.GetCustomAttributes(typeof(XmlRootAttribute), false) as XmlRootAttribute[]).SingleOrDefault(); objectAttributes.XmlArrayItems.Add(new XmlArrayItemAttribute(xmlAttrs.ElementName, objectType) { Namespace = xmlAttrs.Namespace }); } DefinitionsOverrides.Add(typeof(oval_definitions), "objects", objectAttributes); XmlAttributes stateAttributes = new XmlAttributes(); foreach (var stateType in stateTypes) { var xmlAttrs = (stateType.GetCustomAttributes(typeof(XmlRootAttribute), false) as XmlRootAttribute[]).SingleOrDefault(); stateAttributes.XmlArrayItems.Add(new XmlArrayItemAttribute(xmlAttrs.ElementName, stateType) { Namespace = xmlAttrs.Namespace }); } DefinitionsOverrides.Add(typeof(oval_definitions), "states", stateAttributes); return DefinitionsOverrides; }
internal override bool ReflectReturn() { MessagePart part = new MessagePart(); part.Name = "Body"; ReflectionContext.OutputMessage.Parts.Add(part); if (typeof(XmlNode).IsAssignableFrom(ReflectionContext.Method.ReturnType)) { MimeContentBinding mimeContentBinding = new MimeContentBinding(); mimeContentBinding.Type = "text/xml"; mimeContentBinding.Part = part.Name; ReflectionContext.OperationBinding.Output.Extensions.Add(mimeContentBinding); } else { MimeXmlBinding mimeXmlBinding = new MimeXmlBinding(); mimeXmlBinding.Part = part.Name; LogicalMethodInfo methodInfo = ReflectionContext.Method; XmlAttributes a = new XmlAttributes(methodInfo.ReturnTypeCustomAttributeProvider); XmlTypeMapping xmlTypeMapping = ReflectionContext.ReflectionImporter.ImportTypeMapping(methodInfo.ReturnType, a.XmlRoot); xmlTypeMapping.SetKey(methodInfo.GetKey() + ":Return"); ReflectionContext.SchemaExporter.ExportTypeMapping(xmlTypeMapping); part.Element = new XmlQualifiedName(xmlTypeMapping.XsdElementName, xmlTypeMapping.Namespace); ReflectionContext.OperationBinding.Output.Extensions.Add(mimeXmlBinding); } return true; }
public static byte[] getRequestContent(string doctype, string root, Type type, object obj) { var xattribs = new XmlAttributes(); var xroot = new XmlRootAttribute(root); xattribs.XmlRoot = xroot; var xoverrides = new XmlAttributeOverrides(); //... have to use XmlAttributeOverrides because .NET insists on the object name as root element name otherwise ([XmlRoot(..)] has no effect) xoverrides.Add(type, xattribs); XmlSerializer serializer = new XmlSerializer(type, xoverrides); StringWriter sw = new StringWriter(); XmlWriterSettings wsettings = new XmlWriterSettings(); wsettings.OmitXmlDeclaration = false; wsettings.Encoding = new UTF8Encoding(); XmlWriter xw = XmlWriter.Create(sw, wsettings); xw.WriteProcessingInstruction("xml", "version='1.0' standalone='no'"); //... have to write header by hand (OmitXmlDeclaration=false has no effect) xw.WriteDocType(root, null, doctype + ".sfrm", null); XmlSerializerNamespaces ns = new XmlSerializerNamespaces(); ns.Add("", ""); //... trick to avoid printing of xmlns:xsi xmlns:xsd attributes of the root element serializer.Serialize(xw, obj, ns); return sw.ToArray(); }
public void NewXmlAttributes () { // seems not different from Type specified ctor(). XmlAttributes atts = new XmlAttributes (); AssertNull (atts.XmlAnyAttribute); AssertNotNull (atts.XmlAnyElements); AssertEquals (0, atts.XmlAnyElements.Count); AssertNull (atts.XmlArray); AssertNotNull (atts.XmlArrayItems); AssertEquals (0, atts.XmlArrayItems.Count); AssertNull (atts.XmlAttribute); AssertNull (atts.XmlChoiceIdentifier); AssertNotNull (atts.XmlDefaultValue); // DBNull?? AssertEquals (DBNull.Value, atts.XmlDefaultValue); AssertNotNull (atts.XmlElements); AssertEquals (0, atts.XmlElements.Count); AssertNull (atts.XmlEnum); AssertNotNull (atts.XmlIgnore); AssertEquals (TypeCode.Boolean, atts.XmlIgnore.GetTypeCode ()); AssertEquals (false, atts.Xmlns); AssertNull (atts.XmlRoot); AssertNull (atts.XmlText); AssertNull (atts.XmlType); }
public void NewXmlAttributes () { // seems not different from Type specified ctor(). XmlAttributes atts = new XmlAttributes (); Assert.IsNull (atts.XmlAnyAttribute, "#1"); Assert.IsNotNull (atts.XmlAnyElements, "#2"); Assert.AreEqual (0, atts.XmlAnyElements.Count, "#3"); Assert.IsNull (atts.XmlArray, "#4"); Assert.IsNotNull (atts.XmlArrayItems, "#5"); Assert.AreEqual (0, atts.XmlArrayItems.Count, "#6"); Assert.IsNull (atts.XmlAttribute, "#7"); Assert.IsNull (atts.XmlChoiceIdentifier, "#8"); Assert.IsNotNull (atts.XmlDefaultValue, "#9"); // DBNull?? Assert.AreEqual (DBNull.Value, atts.XmlDefaultValue, "#10"); Assert.IsNotNull (atts.XmlElements, "#11"); Assert.AreEqual (0, atts.XmlElements.Count, "#12"); Assert.IsNull (atts.XmlEnum, "#13"); Assert.IsNotNull (atts.XmlIgnore, "#14"); Assert.AreEqual (TypeCode.Boolean, atts.XmlIgnore.GetTypeCode (), "#15"); Assert.AreEqual (false, atts.Xmlns, "#16"); Assert.IsNull (atts.XmlRoot, "#17"); Assert.IsNull (atts.XmlText, "#18"); Assert.IsNull (atts.XmlType, "#19"); }
internal static object[] GetInitializers(LogicalMethodInfo[] methodInfos) { if (methodInfos.Length == 0) { return new object[0]; } WebServiceAttribute attribute = WebServiceReflector.GetAttribute(methodInfos); bool serviceDefaultIsEncoded = SoapReflector.ServiceDefaultIsEncoded(WebServiceReflector.GetMostDerivedType(methodInfos)); XmlReflectionImporter importer = SoapReflector.CreateXmlImporter(attribute.Namespace, serviceDefaultIsEncoded); WebMethodReflector.IncludeTypes(methodInfos, importer); ArrayList list = new ArrayList(); bool[] flagArray = new bool[methodInfos.Length]; for (int i = 0; i < methodInfos.Length; i++) { LogicalMethodInfo methodInfo = methodInfos[i]; Type returnType = methodInfo.ReturnType; if (IsSupported(returnType) && HttpServerProtocol.AreUrlParametersSupported(methodInfo)) { XmlAttributes attributes = new XmlAttributes(methodInfo.ReturnTypeCustomAttributeProvider); XmlTypeMapping mapping = importer.ImportTypeMapping(returnType, attributes.XmlRoot); mapping.SetKey(methodInfo.GetKey() + ":Return"); list.Add(mapping); flagArray[i] = true; } } if (list.Count == 0) { return new object[0]; } XmlMapping[] mappings = (XmlMapping[]) list.ToArray(typeof(XmlMapping)); Evidence evidenceForType = GetEvidenceForType(methodInfos[0].DeclaringType); TraceMethod caller = Tracing.On ? new TraceMethod(typeof(XmlReturn), "GetInitializers", methodInfos) : null; if (Tracing.On) { Tracing.Enter(Tracing.TraceId("TraceCreateSerializer"), caller, new TraceMethod(typeof(XmlSerializer), "FromMappings", new object[] { mappings, evidenceForType })); } XmlSerializer[] serializerArray = null; if (AppDomain.CurrentDomain.IsHomogenous) { serializerArray = XmlSerializer.FromMappings(mappings); } else { serializerArray = XmlSerializer.FromMappings(mappings, evidenceForType); } if (Tracing.On) { Tracing.Exit(Tracing.TraceId("TraceCreateSerializer"), caller); } object[] objArray = new object[methodInfos.Length]; int num2 = 0; for (int j = 0; j < objArray.Length; j++) { if (flagArray[j]) { objArray[j] = serializerArray[num2++]; } } return objArray; }
//SerialSample4\form1.cs private void button1_Click(object sender, System.EventArgs e) { //create the XmlAttributes boject XmlAttributes attrs=new XmlAttributes(); //add the types of the objects that will be serialized attrs.XmlElements.Add(new XmlElementAttribute("Book",typeof(BookProduct))); attrs.XmlElements.Add(new XmlElementAttribute("Product",typeof(Product))); XmlAttributeOverrides attrOver=new XmlAttributeOverrides(); //add to the attributes collection attrOver.Add(typeof(Inventory),"InventoryItems",attrs); //create the Product and Book objects Product newProd=new Product(); BookProduct newBook=new BookProduct(); newProd.ProductID=100; newProd.ProductName="Product Thing"; newProd.SupplierID=10; newBook.ProductID=101; newBook.ProductName="How to Use Your New Product Thing"; newBook.SupplierID=10; newBook.ISBN="123456789"; Product[] addProd={newProd,newBook}; Inventory inv=new Inventory(); inv.InventoryItems=addProd; TextWriter tr=new StreamWriter("..\\..\\..\\inventory.xml"); XmlSerializer sr=new XmlSerializer(typeof(Inventory),attrOver); sr.Serialize(tr,inv); tr.Close(); MessageBox.Show("Serialized!"); }
internal override bool ReflectReturn() { MessagePart messagePart = new MessagePart { Name = "Body" }; base.ReflectionContext.OutputMessage.Parts.Add(messagePart); if (typeof(XmlNode).IsAssignableFrom(base.ReflectionContext.Method.ReturnType)) { MimeContentBinding extension = new MimeContentBinding { Type = "text/xml", Part = messagePart.Name }; base.ReflectionContext.OperationBinding.Output.Extensions.Add(extension); } else { MimeXmlBinding binding2 = new MimeXmlBinding { Part = messagePart.Name }; LogicalMethodInfo method = base.ReflectionContext.Method; XmlAttributes attributes = new XmlAttributes(method.ReturnTypeCustomAttributeProvider); XmlTypeMapping xmlTypeMapping = base.ReflectionContext.ReflectionImporter.ImportTypeMapping(method.ReturnType, attributes.XmlRoot); xmlTypeMapping.SetKey(method.GetKey() + ":Return"); base.ReflectionContext.SchemaExporter.ExportTypeMapping(xmlTypeMapping); messagePart.Element = new XmlQualifiedName(xmlTypeMapping.XsdElementName, xmlTypeMapping.Namespace); base.ReflectionContext.OperationBinding.Output.Extensions.Add(binding2); } return true; }
public void SetUp() { ov1 = new XmlAttributeOverrides(); ov2 = new XmlAttributeOverrides(); atts1 = new XmlAttributes(); atts2 = new XmlAttributes(); }
public void SameObjectWithRootAttribute() { XmlAttributeOverrides ov = new XmlAttributeOverrides(); XmlAttributes atts = new XmlAttributes(); atts.XmlRoot = new XmlRootAttribute("myRoot"); ov.Add(typeof(SerializeMe), atts); ThumbprintHelpers.SameThumbprint(ov, ov); }
public TypeTableEntry (Hashtable memberTable, XmlAttributes xmlAttributes, ArrayList elementMembers, ArrayList attributeMembers) { this.memberTable = memberTable; this.xmlAttributes = xmlAttributes; this.elementMembers = elementMembers; this.attributeMembers = attributeMembers; }
public void SameMemberName() { atts1 = new XmlAttributes(new ChoiceIdentifierAttributeProvider("myname")); atts2 = new XmlAttributes(new ChoiceIdentifierAttributeProvider("myname")); ov1.Add(typeof(SerializeMe), atts1); ov2.Add(typeof(SerializeMe), atts2); ThumbprintHelpers.SameThumbprint(ov1, ov2); }
public static ModuleConfiguration Load(string fileName, List<Type> displayList, List<Type> deviceList, List<Type> sourceList, List<Type> mappingList) { string configurationSchemaFile = Path.ChangeExtension(fileName, "xsd"); try { XmlAttributeOverrides ovr = new XmlAttributeOverrides(); XmlAttributes attrsDevice = new XmlAttributes(); XmlAttributes attrsSource = new XmlAttributes(); XmlAttributes attrsDisplay = new XmlAttributes(); XmlAttributes attrsMapping = new XmlAttributes(); attrsMapping.XmlArrayItems.Add(new XmlArrayItemAttribute(typeof (Mapping))); foreach (Type type in sourceList) attrsSource.XmlArrayItems.Add(new XmlArrayItemAttribute(type)); foreach (Type type in deviceList) attrsDevice.XmlArrayItems.Add(new XmlArrayItemAttribute(type)); foreach (Type type in displayList) attrsDisplay.XmlArrayItems.Add(new XmlArrayItemAttribute(type)); foreach (Type type in mappingList) attrsMapping.XmlArrayItems.Add(new XmlArrayItemAttribute(type)); ovr.Add(typeof (ModuleConfiguration), "DeviceList", attrsDevice); ovr.Add(typeof (ModuleConfiguration), "SourceList", attrsSource); ovr.Add(typeof (ModuleConfiguration), "DisplayList", attrsDisplay); ovr.Add(typeof (DisplayType), "MappingList", attrsMapping); XmlReaderSettings settings = new XmlReaderSettings(); settings.ValidationType = ValidationType.Schema; settings.Schemas.Add("urn:configuration-schema", configurationSchemaFile); // Проводим валидацию, отдельно от десереализации, потому-что если вместе то валится using (XmlReader reader = XmlReader.Create(fileName, settings)) while (reader.Read()) { } // Проводим десереализации без валидации, потому-что если вместе то валится XmlSerializer serializer = new XmlSerializer(typeof (ModuleConfiguration), ovr); using (XmlReader reader = XmlReader.Create(fileName)) return (ModuleConfiguration) serializer.Deserialize(reader); } catch (FileNotFoundException ex) { throw new ModuleConfigurationException(ex.FileName); } catch (XmlSchemaException ex) { throw new ModuleConfigurationException(new Uri(ex.SourceUri).AbsolutePath, ex); //configurationSchemaFile } catch (XmlException ex) { throw new ModuleConfigurationException(new Uri(ex.SourceUri).AbsolutePath, ex); } }
/// <include file='doc\XmlAttributeOverrides.uex' path='docs/doc[@for="XmlAttributeOverrides.Add1"]/*' /> /// <devdoc> /// <para>[To be supplied.]</para> /// </devdoc> public void Add(Type type, string member, XmlAttributes attributes) { Hashtable members = (Hashtable)types[type]; if (members == null) { members = new Hashtable(); types.Add(type, members); } else if (members[member] != null) { throw new InvalidOperationException(Res.GetString(Res.XmlAttributeSetAgain, type.FullName, member)); } members.Add(member, attributes); }
public void WriteTo(TextWriter tw) { XmlAttributeOverrides overrides = new XmlAttributeOverrides(); XmlAttributes attrs = new XmlAttributes {XmlIgnore = true}; overrides.Add(Object.GetType(), "Id", attributes: attrs); XmlSerializer xs = new XmlSerializer(Object.GetType(), overrides); xs.Serialize(tw, Object); }
private void InitializeSerializer() { XmlAttributes attrs = new XmlAttributes(); XmlAttributeOverrides attrOverrides = new XmlAttributeOverrides(); attrOverrides.Add(typeof(string), "File", attrs); attrOverrides.Add(typeof(List<string>), "Columns", attrs); attrOverrides.Add(typeof(List<List<string>>), "Rows", attrs); m_compositionXmlSerializer = new XmlSerializer(typeof(List<List<string>>), attrOverrides); m_mapSerializer = new TmxMapSerializer.Serializer.TmxMapSerializer(); }
public static string BuildXml <T>(this T BusinessObject) where T : class { MemoryStream Stream = null; TextWriter Writer = null; try { System.Xml.Serialization.XmlAttributeOverrides xOver = new System.Xml.Serialization.XmlAttributeOverrides(); System.Xml.Serialization.XmlAttributes attrs = new System.Xml.Serialization.XmlAttributes(); foreach (var Ig in typeof(T).GetProperties().Where(c => !c.PropertyType.IsSerializable || c.PropertyType.FullName.StartsWith("DynamicBusiness.BPMS.BusinessLogic")).Select(c => c.Name)) { attrs = new System.Xml.Serialization.XmlAttributes(); attrs.XmlIgnore = true; xOver.Add(typeof(T), Ig, attrs); } Stream = new MemoryStream(); Writer = new StreamWriter(Stream, Encoding.Unicode); XmlSerializer Serializer = new XmlSerializer(typeof(T), xOver); Serializer.Serialize(Writer, BusinessObject); int Count = (int)Stream.Length; byte[] BytesArr = new byte[Count]; Stream.Seek(0, SeekOrigin.Begin); Stream.Read(BytesArr, 0, Count); UnicodeEncoding utf = new UnicodeEncoding(); return(System.Web.HttpUtility.HtmlDecode(utf.GetString(BytesArr).Trim())); //return utf.GetString(BytesArr).Trim(); } catch (Exception exc) { DotNetNuke.Services.Exceptions.Exceptions.LogException(exc); return(string.Empty); } finally { if (Stream != null) { Stream.Close(); } if (Writer != null) { Writer.Close(); } } }
public void SaveToFile(string path) { XmlSerializer serializer = new XmlSerializer(typeof (OptionsList)); XmlAttributeOverrides overrides = new XmlAttributeOverrides(); XmlAttributes ignoreAttr = new XmlAttributes(); ignoreAttr.XmlIgnore = true; overrides.Add(typeof (Annotatable), "IsStarred", ignoreAttr); using (StreamWriter writer = File.CreateText(path)) { serializer.Serialize(writer, this); writer.Close(); } }
internal XmlAttributeOverrides GetSerializerOverrides() { var overrides = new XmlAttributeOverrides(); var attributes = new XmlAttributes(); foreach (XmlElementAttribute attribute in SerializerAttributes) { attributes.XmlElements.Add(attribute); } overrides.Add(typeof(ItemData), "Typed", attributes); return overrides; }
public void TwoObjectsWithSameRootAttributeDifferentTypes() { XmlAttributeOverrides ov1 = new XmlAttributeOverrides(); XmlAttributeOverrides ov2 = new XmlAttributeOverrides(); XmlAttributes atts1 = new XmlAttributes(); atts1.XmlRoot = new XmlRootAttribute("myRoot"); ov1.Add(typeof(SerializeMe), atts1); XmlAttributes atts2 = new XmlAttributes(); atts2.XmlRoot = new XmlRootAttribute("myRoot"); ov2.Add(typeof(SerializeMeToo), atts2); ThumbprintHelpers.DifferentThumbprint(ov1, ov2); }
public static void AddArrayItemMemberMapping(XmlAttributes at, Type type, string elementName, bool isNullable, string elementNamespace, bool isQualified, int nestingLevel) { XmlArrayItemAttribute arrayItem = AddArrayItemMemberMappingInternal(type, elementName, isNullable); if ( isQualified ) { arrayItem.Form = XmlSchemaForm.Qualified; } else { arrayItem.Form = XmlSchemaForm.Unqualified; } arrayItem.NestingLevel = nestingLevel; at.XmlArrayItems.Add(arrayItem); }
internal static object[] GetInitializers(LogicalMethodInfo[] methodInfos) { if (methodInfos.Length == 0) return new object[0]; WebServiceAttribute serviceAttribute = WebServiceReflector.GetAttribute(methodInfos); bool serviceDefaultIsEncoded = SoapReflector.ServiceDefaultIsEncoded(WebServiceReflector.GetMostDerivedType(methodInfos)); XmlReflectionImporter importer = SoapReflector.CreateXmlImporter(serviceAttribute.Namespace, serviceDefaultIsEncoded); WebMethodReflector.IncludeTypes(methodInfos, importer); ArrayList mappings = new ArrayList(); bool[] supported = new bool[methodInfos.Length]; for (int i = 0; i < methodInfos.Length; i++) { LogicalMethodInfo methodInfo = methodInfos[i]; Type type = methodInfo.ReturnType; if (IsSupported(type) && HttpServerProtocol.AreUrlParametersSupported(methodInfo)) { XmlAttributes a = new XmlAttributes(methodInfo.ReturnTypeCustomAttributeProvider); XmlTypeMapping mapping = importer.ImportTypeMapping(type, a.XmlRoot); mapping.SetKey(methodInfo.GetKey() + ":Return"); mappings.Add(mapping); supported[i] = true; } } if (mappings.Count == 0) return new object[0]; XmlMapping[] xmlMappings = (XmlMapping[])mappings.ToArray(typeof(XmlMapping)); Evidence evidence = GetEvidenceForType(methodInfos[0].DeclaringType); TraceMethod caller = Tracing.On ? new TraceMethod(typeof(XmlReturn), "GetInitializers", methodInfos) : null; if (Tracing.On) Tracing.Enter(Tracing.TraceId(Res.TraceCreateSerializer), caller, new TraceMethod(typeof(XmlSerializer), "FromMappings", xmlMappings, evidence)); XmlSerializer[] serializers = null; if (AppDomain.CurrentDomain.IsHomogenous) { serializers = XmlSerializer.FromMappings(xmlMappings); } else { #pragma warning disable 618 // If we're in a non-homogenous domain, legacy CAS mode is enabled, so passing through evidence will not fail serializers = XmlSerializer.FromMappings(xmlMappings, evidence); #pragma warning restore 618 } if (Tracing.On) Tracing.Exit(Tracing.TraceId(Res.TraceCreateSerializer), caller); object[] initializers = new object[methodInfos.Length]; int count = 0; for (int i = 0; i < initializers.Length; i++) { if (supported[i]) { initializers[i] = serializers[count++]; } } return initializers; }
public void Add(Type type, string member, XmlAttributes attributes) { Hashtable hashtable = (Hashtable) this.types[type]; if (hashtable == null) { hashtable = new Hashtable(); this.types.Add(type, hashtable); } else if (hashtable[member] != null) { throw new InvalidOperationException(Res.GetString("XmlAttributeSetAgain", new object[] { type.FullName, member })); } hashtable.Add(member, attributes); }
/// <include file='doc\XmlAttributeOverrides.uex' path='docs/doc[@for="XmlAttributeOverrides.Add1"]/*' /> /// <devdoc> /// <para>[To be supplied.]</para> /// </devdoc> public void Add(Type type, string member, XmlAttributes attributes) { Dictionary<string, XmlAttributes> members; if (!_types.TryGetValue(type, out members)) { members = new Dictionary<string, XmlAttributes>(); _types.Add(type, members); } else if (members.ContainsKey(member)) { throw new InvalidOperationException(SR.Format(SR.XmlAttributeSetAgain, type.FullName, member)); } members.Add(member, attributes); }
private static Type GetEnumeratorElementType(Type type, ref TypeFlags flags) { if (typeof(IEnumerable).IsAssignableFrom(type)) { MethodInfo enumerator = type.GetMethod("GetEnumerator", new Type[0]); if (enumerator == null || !typeof(IEnumerator).IsAssignableFrom(enumerator.ReturnType)) { // try generic implementation enumerator = null; foreach (MemberInfo member in type.GetMember("System.Collections.Generic.IEnumerable<*", BindingFlags.Public | BindingFlags.Instance | BindingFlags.NonPublic)) { enumerator = member as MethodInfo; if (enumerator != null && typeof(IEnumerator).IsAssignableFrom(enumerator.ReturnType)) { // use the first one we find flags |= TypeFlags.GenericInterface; break; } else { enumerator = null; } } if (enumerator == null) { // and finally private interface implementation flags |= TypeFlags.UsePrivateImplementation; enumerator = type.GetMethod("System.Collections.IEnumerable.GetEnumerator", BindingFlags.Public | BindingFlags.Instance | BindingFlags.NonPublic, new Type[0]); } } if (enumerator == null || !typeof(IEnumerator).IsAssignableFrom(enumerator.ReturnType)) { return(null); } XmlAttributes methodAttrs = new XmlAttributes(enumerator); if (methodAttrs.XmlIgnore) { return(null); } PropertyInfo p = enumerator.ReturnType.GetProperty("Current"); Type currentType = (p == null ? typeof(object) : p.PropertyType); MethodInfo addMethod = type.GetMethod("Add", new Type[] { currentType }); if (addMethod == null && currentType != typeof(object)) { currentType = typeof(object); addMethod = type.GetMethod("Add", new Type[] { currentType }); } if (addMethod == null) { throw new InvalidOperationException(SR.Format(SR.XmlNoAddMethod, type.FullName, currentType, "IEnumerable")); } return(currentType); } else { return(null); } }
/// <devdoc> /// <para>[To be supplied.]</para> /// </devdoc> public void Add(Type type, XmlAttributes attributes) { Add(type, string.Empty, attributes); }
internal static string GenerateKey(Type type, XmlRootAttribute?root, string?ns) { root ??= (XmlRootAttribute?)XmlAttributes.GetAttr(type, typeof(XmlRootAttribute)); return($"{type.FullName}:{(root == null ? string.Empty : root.GetKey())}:{ns ?? string.Empty}"); }
public void Add(System.Type type, System.Xml.Serialization.XmlAttributes attributes) { }