किसी ऑब्जेक्ट को XML स्ट्रिंग में कनवर्ट करें

Question 1

मुझे एक वर्ग मिला है जिसका नाम WebserviceTypeमुझे XSD फ़ाइल से उपकरण xsd.exe से मिला है।

अब मैं WebServiceTypeएक स्ट्रिंग के लिए एक वस्तु का उदाहरण देना चाहता हूँ । मैं यह कैसे कर सकता हूँ?

MethodCheckTypeवस्तु एक पैरामीटर के रूप में है WebServiceTypeसरणी।

मेरी पहली कोशिश यह थी कि मैंने इसे क्रमबद्ध किया: एक XmlSerializerऔर एक StringWriter(धारावाहिक करते समय मैंने इस्तेमाल किया StringReader) के साथ।

यह वह विधि है जिसमें मैं WebServiceTypeवस्तु को क्रमबद्ध करता हूं :

XmlSerializer serializer = new XmlSerializer(typeof(MethodCheckType));
        MethodCheckType output = null;
        StringReader reader = null;

        // catch global exception, logg it and throw it
        try
        {
            reader = new StringReader(path);
            output = (MethodCheckType)serializer.Deserialize(reader);
        }
        catch (Exception)
        {
            throw;
        }
        finally
        {
            reader.Dispose();
        }

        return output.WebService;

संपादित करें:

शायद मैं इसे अलग-अलग शब्दों में कह सकता था: मुझे इस MethodCheckTypeऑब्जेक्ट का एक उदाहरण मिला है दूसरी तरफ मुझे एक्सएमएल दस्तावेज़ मिला है जिसमें से मैंने इस ऑब्जेक्ट को क्रमबद्ध किया है। अब मैं इस उदाहरण को एक स्ट्रिंग के रूप में XML दस्तावेज़ में बदलना चाहता हूं। इसके बाद मुझे यह प्रमाणित करना होगा कि क्या दोनों तार (XML दस्तावेजों के) समान हैं। यह मुझे करना है, क्योंकि मैं पहली विधि की इकाई परीक्षण करता हूं जिसमें मैं एक XML दस्तावेज़ को एक में पढ़ता हूं StringReaderऔर इसे एक MethodCheckTypeवस्तु में अनुक्रमित करता हूं ।

Question 2

यहां दोनों तरीकों के लिए रूपांतरण विधि दी गई है। यह आपकी कक्षा का उदाहरण है

public string ToXML()
    {
        using(var stringwriter = new System.IO.StringWriter())
        { 
            var serializer = new XmlSerializer(this.GetType());
            serializer.Serialize(stringwriter, this);
            return stringwriter.ToString();
        }
    }

 public static YourClass LoadFromXMLString(string xmlText)
    {
        using(var stringReader = new System.IO.StringReader(xmlText))
        {
            var serializer = new XmlSerializer(typeof(YourClass ));
            return serializer.Deserialize(stringReader) as YourClass ;
        }
    }

Question 3

मुझे लगता है कि यह एक बहुत पुरानी पोस्ट है, लेकिन एलबी की प्रतिक्रिया को देखने के बाद मैंने सोचा कि मैं स्वीकृत उत्तर पर कैसे सुधार कर सकता हूं और इसे अपने स्वयं के आवेदन के लिए सामान्य बना सकता हूं। यहाँ मैं क्या लेकर आया हूँ:

public static string Serialize<T>(T dataToSerialize)
{
    try
    {
        var stringwriter = new System.IO.StringWriter();
        var serializer = new XmlSerializer(typeof(T));
        serializer.Serialize(stringwriter, dataToSerialize);
        return stringwriter.ToString();
    }
    catch
    {
        throw;
    }
}

public static T Deserialize<T>(string xmlText)
{
    try
    {
        var stringReader = new System.IO.StringReader(xmlText);
        var serializer = new XmlSerializer(typeof(T));
        return (T)serializer.Deserialize(stringReader);
    }
    catch
    {
        throw;
    }
}

इन विधियों को अब एक स्थिर सहायक वर्ग में रखा जा सकता है, जिसका अर्थ है कि हर वर्ग के लिए कोई कोड दोहराव नहीं है जिसे क्रमबद्ध करने की आवश्यकता है।

Question 4

    public static string Serialize(object dataToSerialize)
    {
        if(dataToSerialize==null) return null;

        using (StringWriter stringwriter = new System.IO.StringWriter())
        {
            var serializer = new XmlSerializer(dataToSerialize.GetType());
            serializer.Serialize(stringwriter, dataToSerialize);
            return stringwriter.ToString();
        }
    }

    public static T Deserialize<T>(string xmlText)
    {
        if(String.IsNullOrWhiteSpace(xmlText)) return default(T);

        using (StringReader stringReader = new System.IO.StringReader(xmlText))
        {
            var serializer = new XmlSerializer(typeof(T));
            return (T)serializer.Deserialize(stringReader);
        }
    }

Question 5

यह मेरा समाधान है, किसी भी सूची ऑब्जेक्ट के लिए आप इस कोड को xml लेआउट में कनवर्ट करने के लिए उपयोग कर सकते हैं। KeyFather आपका प्रमुख टैग है और KeySon वह जगह है जहाँ से आपका फ़ोरच शुरू होता है।

public string BuildXml<T>(ICollection<T> anyObject, string keyFather, string keySon)
    {
        var settings = new XmlWriterSettings
        {
            Indent = true
        };
        PropertyDescriptorCollection props = TypeDescriptor.GetProperties(typeof(T));
        StringBuilder builder = new StringBuilder();
        using (XmlWriter writer = XmlWriter.Create(builder, settings))
        {
            writer.WriteStartDocument();
            writer.WriteStartElement(keyFather);
            foreach (var objeto in anyObject)
            {
                writer.WriteStartElement(keySon);
                foreach (PropertyDescriptor item in props)
                {
                    writer.WriteStartElement(item.DisplayName);
                    writer.WriteString(props[item.DisplayName].GetValue(objeto).ToString());
                    writer.WriteEndElement();
                }
                writer.WriteEndElement();
            }
            writer.WriteFullEndElement();
            writer.WriteEndDocument();
            writer.Flush();
            return builder.ToString();
        }
    }

Question 6

 public static class XMLHelper
    {
        /// <summary>
        /// Usage: var xmlString = XMLHelper.Serialize<MyObject>(value);
        /// </summary>
        /// <typeparam name="T">Kiểu dữ liệu</typeparam>
        /// <param name="value">giá trị</param>
        /// <param name="omitXmlDeclaration">bỏ qua declare</param>
        /// <param name="removeEncodingDeclaration">xóa encode declare</param>
        /// <returns>xml string</returns>
        public static string Serialize<T>(T value, bool omitXmlDeclaration = false, bool omitEncodingDeclaration = true)
        {
            if (value == null)
            {
                return string.Empty;
            }
            try
            {
                var xmlWriterSettings = new XmlWriterSettings
                {
                    Indent = true,
                    OmitXmlDeclaration = omitXmlDeclaration, //true: remove <?xml version="1.0" encoding="utf-8"?>
                    Encoding = Encoding.UTF8,
                    NewLineChars = "", // remove \r\n
                };

                var xmlserializer = new XmlSerializer(typeof(T));

                using (var memoryStream = new MemoryStream())
                {
                    using (var xmlWriter = XmlWriter.Create(memoryStream, xmlWriterSettings))
                    {
                        xmlserializer.Serialize(xmlWriter, value);
                        //return stringWriter.ToString();
                    }

                    memoryStream.Position = 0;
                    using (var sr = new StreamReader(memoryStream))
                    {
                        var pureResult = sr.ReadToEnd();
                        var resultAfterOmitEncoding = ReplaceFirst(pureResult, " encoding=\"utf-8\"", "");
                        if (omitEncodingDeclaration)
                            return resultAfterOmitEncoding;
                        return pureResult;
                    }
                }
            }
            catch (Exception ex)
            {
                throw new Exception("XMLSerialize error: ", ex);
            }
        }

        private static string ReplaceFirst(string text, string search, string replace)
        {
            int pos = text.IndexOf(search);

            if (pos < 0)
            {
                return text;
            }

            return text.Substring(0, pos) + replace + text.Substring(pos + search.Length);
        }
    }