https://stackoverflow.com/questions/79581114/net-soapcore-wsdl-generation-and-xml-deserialization-mismatch-using-xmlserializ | C# Online Compiler

https://stackoverflow.com/questions/79581114/net-soapcore-wsdl-generation-and-xml-deserialization-mismatch-using-xmlserializ by dbc_MinLength

using System;
using System.Collections.Generic;
using System.Text;
using System.Linq;
using System.Xml.Serialization;
using System.Xml;
using System.Xml.Linq;
using System.IO;
using System.ServiceModel.Description;
using System.ServiceModel.Channels;
using System.ServiceModel ;

using SoapCore;

using NUnit.Framework; //NUnit.Framework.AssertionException

//https://stackoverflow.com/questions/79581114/net-soapcore-wsdl-generation-and-xml-deserialization-mismatch-using-xmlserializ

[ServiceContract, XmlSerializerFormat] // XmlSerializerFormat should be applied to the service or operation method.
public interface ISampleService
{
	[OperationContract, XmlSerializerFormat]
	public void SampleMethod(SampleRequestWrapper wrapper);
}

public static class Namespaces
{
	public const string SoapNamespace = "http://www.w3.org/2003/05/soap-envelope";
	public const string ServiceNamespace = "http://example.com/namespace/";
}

//Manually created wrapper class as per
// https://stackoverflow.com/questions/24998525/how-do-i-use-an-xml-attribute-in-a-messagecontract-type
// https://stackoverflow.com/a/64321991 by https://stackoverflow.com/users/3092184/andrew

[MessageContract(IsWrapped = false, WrapperNamespace = Namespaces.SoapNamespace)]
public class SampleRequestWrapper
{
	[MessageBodyMember(Namespace = Namespaces.ServiceNamespace)]
	public SampleRequest SampleRequest { get; set; }
}

[XmlType(Namespace = Namespaces.ServiceNamespace)]
[XmlRoot("SampleRequest", Namespace = Namespaces.ServiceNamespace)]
public class SampleRequest
{
    [XmlAttribute("track")]
    public string Track { get; set; } = string.Empty;

    [XmlElement("requestTimestamp", IsNullable = false)]
    public string RequestTimestamp { get; set; } = string.Empty;

    [XmlElement("subjectInfo", IsNullable = false)]
    public SubjectInfo SubjectInfo { get; set; } = new();
}

public class SubjectInfo
{
    [XmlElement("uniqueId", IsNullable = false)]
    public string UniqueId { get; set; } = string.Empty;
}

//Notes
//https://learn.microsoft.com/en-us/dotnet/framework/wcf/feature-details/using-message-contracts
//https://learn.microsoft.com/en-us/previous-versions/dotnet/netframework-3.5/ms734675(v=vs.90)?redirectedfrom=MSDN
//https://learn.microsoft.com/en-us/dotnet/api/system.servicemodel.messagecontractattribute?view=netframework-4.8.1
//https://devblogs.microsoft.com/dotnet/custom-asp-net-core-middleware-example/
//https://learn.microsoft.com/en-us/dotnet/api/system.servicemodel.description.typedmessageconverter
//https://learn.microsoft.com/en-us/dotnet/api/system.servicemodel.description.typedmessageconverter.tomessage
//https://learn.microsoft.com/en-us/dotnet/api/microsoft.aspnetcore.builder.iapplicationbuilder
//https://learn.microsoft.com/en-us/dotnet/api/system.servicemodel.channels.message
//https://learn.microsoft.com/en-us/dotnet/api/system.servicemodel.xmlserializerformatattribute
//
//https://github.com/DigDes/SoapCore
//https://github.com/DigDes/SoapCore/tree/develop/samples
//https://github.com/DigDes/SoapCore/blob/develop/samples/Server/SampleService.cs
//https://github.com/DigDes/SoapCore/blob/develop/samples/Models/ComplexModelInput.cs
//https://stackify.com/soap-net-core/
//
//https://stackoverflow.com/questions/79581114/net-soapcore-wsdl-generation-and-xml-deserialization-mismatch-using-xmlserializ
//https://stackoverflow.com/questions/4106196/wcf-message-body-showing-sbody-stream-sbody-after-modification
//https://stackoverflow.com/questions/46744567/wcf-messagebodymember-with-complex-type-and-namespace

public class TestClass
{
	public static void Test()
	{
		var body = new SampleRequest
		{
			Track = "V",
			RequestTimestamp = "20210305113442",
			SubjectInfo = new()
			{
				UniqueId = "ABCDE1234",
			}
		};
		
		Console.WriteLine(new SampleRequestWrapper { SampleRequest = body } .ToMessageXml(null, new XmlSerializerFormatAttribute()));
		
		var requestXml = GetRequestXml();
		
		var requestMessage = MessageContractSerializerHelper.CreateMessageFromXml(requestXml, MessageVersion.Soap12WSAddressing10);
		
		Console.WriteLine();
		//Console.WriteLine(requestMessage.ToMessageString());
		
		var requestBody = requestMessage.FromMessage<SampleRequestWrapper>(null, new XmlSerializerFormatAttribute());
		requestBody.Dump();
	}
	
	static string GetRequestXml() =>
		"""
		<soap:Envelope xmlns:soap="http://www.w3.org/2003/05/soap-envelope" xmlns:add="http://www.w3.org/2005/08/addressing">
		   <soap:Body>
			  <SampleRequest xmlns="http://example.com/namespace/" track="V">
				 <requestTimestamp>20210305113442</requestTimestamp>
				 <subjectInfo>
					<uniqueId>ABCDE1234</uniqueId>
				 </subjectInfo>
			  </SampleRequest>
		   </soap:Body>
		</soap:Envelope>
		""";
}

#if false
    Snippet to create and read a System.ServiceModel.Channels.Message object representing a WCF operation invocation containing multiple parameters. 
    This is how you would use DataContractSerializer to make an entire operation call, including each individual parameter, rather than just serializing
    one object at a time. 

    https://gist.github.com/mfenniak/4707000
#endif
    public static class MessageContractSerializerHelper
    {
        // https://social.msdn.microsoft.com/Forums/vstudio/en-US/d7e37ec7-d651-40a4-83c0-6e5727e5617b/how-to-serializedeserialize-messagecontract-tofrom-an-soap-string?forum=wcf
        //
        // But see also
        //
        // https://social.msdn.microsoft.com/Forums/vstudio/en-US/278565bc-df03-46b3-a855-e12e58ddba67/how-to-modify-systemservicemodelchannelsmessage?forum=wcf
		public static string ToMessageString(this Message message) =>
			// Use a buffered copy in case the message is streamed.
			message.CreateBufferedCopy(int.MaxValue).CreateMessage().ToString();
		
		public static Message CreateMessageFromXml(string xml, MessageVersion ver)
		{
			using var textReader = new StringReader(xml);
			using var xmlReader = XmlReader.Create(textReader);
			xmlReader.MoveToContent();
			xmlReader.ReadToFollowing("Body", "http://www.w3.org/2003/05/soap-envelope");
			xmlReader.Read();
			xmlReader.MoveToContent();
			//Console.WriteLine((xmlReader.NodeType, xmlReader.Name));
			using var subReader = xmlReader.ReadSubtree();
			// At this point the message contains streaming data that hasn't been processed yet.
			// If we dispose of the readers then the message will appear empty.
			// So, materialize it by copying it into a buffered copy.
			var streamingMessage = Message.CreateMessage(ver, null, subReader);
			MessageBuffer messageBuffer = streamingMessage.CreateBufferedCopy(int.MaxValue);
			Message bufferedMessage = messageBuffer.CreateMessage();
			
			return bufferedMessage;
		}
		
        public static T FromMessage<T>(this Message message, string action, XmlSerializerFormatAttribute attr)
        {
            var converter = TypedMessageConverter.Create(typeof(T), action, attr);
            return (T)converter.FromMessage(message);
        }
		
        public static Message ToMessage<T>(this T typedMessage, string action, XmlSerializerFormatAttribute attr)
        {
            var converter = TypedMessageConverter.Create(typedMessage.GetType(), action, attr);
            return converter.ToMessage(typedMessage);
        }

        public static string ToMessageXml<T>(this T typedMessage, string action, XmlSerializerFormatAttribute attr)
        {
            return typedMessage.ToMessage(action, attr).ToString();
        }

        public static Message ToMessage<T>(this T typedMessage, string action)
        {
            var converter = TypedMessageConverter.Create(typedMessage.GetType(), action);
            return converter.ToMessage(typedMessage);
        }

        public static string ToMessageXml<T>(this T typedMessage, string action)
        {
            return typedMessage.ToMessage(action).ToString();
        }

        public static Message ToMessage<T>(this T typedMessage, string action, string defaultNamespace)
        {
            var converter = TypedMessageConverter.Create(typedMessage.GetType(), action, defaultNamespace);
            return converter.ToMessage(typedMessage);
        }

        public static string ToMessageXml<T>(this T typedMessage, string action, string defaultNamespace)
        {
            return typedMessage.ToMessage(action, defaultNamespace).ToString();
        }
    }

    public static class XmlSerializationHelper
    {
        public static T LoadFromXml<T>(this string xmlString, XmlSerializer serial = null)
        {
            using (var reader = new StringReader(xmlString))
            {
				return (T)(serial ?? new XmlSerializer(typeof(T))).Deserialize(reader);
            }
        }

        public static string GetXml<T>(this T obj, XmlSerializer serializer = null, bool omitStandardNamespaces = false)
        {
            XmlSerializerNamespaces ns = null;
            if (omitStandardNamespaces)
            {
                ns = new XmlSerializerNamespaces();
                ns.Add("", ""); // Disable the xmlns:xsi and xmlns:xsd lines.
            }			
            using (var textWriter = new StringWriter())
            {
                var settings = new XmlWriterSettings() { Indent = true }; // For cosmetic purposes.
                using (var xmlWriter = XmlWriter.Create(textWriter, settings))
                    (serializer ?? new XmlSerializer(obj.GetType())).Serialize(xmlWriter, obj, ns);
                return textWriter.ToString();
            }
        }
		
		public static string GetOuterXml(this XmlNode node, bool indent = true)
		{
			if (node == null)
				return null;
			using (var textWriter = new StringWriter())
			{
				var settings = new XmlWriterSettings
				{
					Indent = indent,
					OmitXmlDeclaration = true,
				};
				using (var xmlWriter = XmlWriter.Create(textWriter, settings))
				{
					node.WriteTo(xmlWriter);
				}
				return textWriter.ToString();
			}
		}
    }

    public static class XmlAssert
    {
        // https://weblogs.asp.net/marianor/easy-way-to-compare-two-xmls-for-equality
        // https://stackoverflow.com/questions/7318157/best-way-to-compare-xelement-objects
        // Adapted from the answer https://stackoverflow.com/a/14463137 by https://stackoverflow.com/users/1102100/robjohnson
        public static void AreEqual(
            XElement expected,
            XElement actual)
        {
            Assert.IsTrue(XNode.DeepEquals(Normalize(expected), Normalize(actual)));
        }

        private static XElement Normalize(XElement element)
        {
            if (element.HasElements)
            {
                return new XElement(
                    element.Name,
                    element.Attributes()
                           .OrderBy(a => a.Name.ToString()),
                    element.Elements()
                           .OrderBy(a => a.Name.ToString())
                           .Select(e => Normalize(e)));

            }

            if (element.IsEmpty)
            {
                return new XElement(
                    element.Name,
                    element.Attributes()
                           .OrderBy(a => a.Name.ToString()));
            }

            return new XElement(element.Name, element.Attributes()
                .OrderBy(a => a.Name.ToString()), element.Value);
        }
    }
				
	public class Program
	{
		public static void Main()
		{
			Console.WriteLine("Environment version: {0} ({1}, {2}, NewLine: {3}).", 
							  System.Runtime.InteropServices.RuntimeInformation.FrameworkDescription , Environment.Version, Environment.OSVersion,
							  System.Text.Json.JsonSerializer.Serialize(Environment.NewLine));
			Console.WriteLine("{0} version: {1}", typeof(SoapCore.CustomMessage).Namespace, typeof(SoapCore.CustomMessage).Assembly.FullName);
			Console.WriteLine();

			try
			{
				TestClass.Test();
			}
			catch (Exception ex)
			{
				Console.WriteLine("Failed with unhandled exception: ");
				Console.WriteLine(ex);
				throw;
			}
		}
	}

#if false
public static class SoapCoreExtensions
{
	public static Message CreateResponseMessage(
		OperationDescription operation,
		object responseObject,
		Dictionary<string, object> resultOutDictionary,
		string soapAction,
		Message? requestMessage,
		XmlNamespaceManager xmlNamespaceManager,
		MessageVersion messageVersion,
		SoapOptions _options,
		SoapMessageEncoder soapMessageEncoder) where T_MESSAGE : CustomMessage, new()
	{
			T_MESSAGE responseMessage;

			// Create response message
			BodyWriter bodyWriter = new ServiceBodyWriter(_options.SoapSerializer, operation, responseObject, resultOutDictionary);
			//var xmlNamespaceManager = GetXmlNamespaceManager(soapMessageEncoder);

			
			if (soapMessageEncoder.MessageVersion.Addressing == AddressingVersion.WSAddressing10)
			{
			}
			else
			{
			}

			var underlyingMessage = Message.CreateMessage(soapMessageEncoder.MessageVersion, 
														  soapMessageEncoder.MessageVersion.Addressing == AddressingVersion.WSAddressing10 ? soapAction : null,
														  bodyWriter);
		
			if (soapMessageEncoder.MessageVersion.Addressing == AddressingVersion.WSAddressing10)
			{
				responseMessage = new CustomMessage(underlyingMessage)
				{
					StandAloneAttribute = _options.StandAloneAttribute,
					Message = Message.CreateMessage(soapMessageEncoder.MessageVersion, soapAction, bodyWriter),
					AdditionalEnvelopeXmlnsAttributes = _options.AdditionalEnvelopeXmlnsAttributes,
					NamespaceManager = xmlNamespaceManager
				};

				responseMessage.Headers.Action = operation.ReplyAction;
				responseMessage.Headers.RelatesTo = requestMessage.Headers.MessageId;
				responseMessage.Headers.To = requestMessage.Headers.ReplyTo?.Uri;
			}
			else
			{
				responseMessage = new CustomMessage(underlyingMessage)
				{
					StandAloneAttribute = _options.StandAloneAttribute,
					Message = Message.CreateMessage(soapMessageEncoder.MessageVersion, null, bodyWriter),
					AdditionalEnvelopeXmlnsAttributes = _options.AdditionalEnvelopeXmlnsAttributes,
					NamespaceManager = xmlNamespaceManager
				};
			}

			if (responseObject != null)
			{
				var messageHeaderMembers = responseObject.GetType().GetMembersWithAttribute<MessageHeaderAttribute>();
				foreach (var messageHeaderMember in messageHeaderMembers)
				{
					var messageHeaderAttribute = messageHeaderMember.Attribute;
					responseMessage.Headers.Add(MessageHeader.CreateHeader(messageHeaderAttribute.Name ?? messageHeaderMember.Member.Name, messageHeaderAttribute.Namespace ?? operation.Contract.Namespace, messageHeaderMember.Member.GetPropertyOrFieldValue(responseObject), messageHeaderAttribute.MustUnderstand));
				}
			}

			return responseMessage;

	}
}
#endif

​x
 
using System;
using System.Collections.Generic;
using System.Text;
using System.Linq;
using System.Xml.Serialization;
using System.Xml;
using System.Xml.Linq;
using System.IO;
using System.ServiceModel.Description;
using System.ServiceModel.Channels;
using System.ServiceModel ;
​
using SoapCore;
​
using NUnit.Framework; //NUnit.Framework.AssertionException
​
//https://stackoverflow.com/questions/79581114/net-soapcore-wsdl-generation-and-xml-deserialization-mismatch-using-xmlserializ
​
[ServiceContract, XmlSerializerFormat] // XmlSerializerFormat should be applied to the service or operation method.
public interface ISampleService
{
    [OperationContract, XmlSerializerFormat]
    public void SampleMethod(SampleRequestWrapper wrapper);
}
​
public static class Namespaces
{
    public const string SoapNamespace = "http://www.w3.org/2003/05/soap-envelope";
    public const string ServiceNamespace = "http://example.com/namespace/";
}
​
//Manually created wrapper class as per
// https://stackoverflow.com/questions/24998525/how-do-i-use-an-xml-attribute-in-a-messagecontract-type
// https://stackoverflow.com/a/64321991 by https://stackoverflow.com/users/3092184/andrew
​
[MessageContract(IsWrapped = false, WrapperNamespace = Namespaces.SoapNamespace)]
public class SampleRequestWrapper
{
    [MessageBodyMember(Namespace = Namespaces.ServiceNamespace)]
    public SampleRequest SampleRequest { get; set; }
}
​
[XmlType(Namespace = Namespaces.ServiceNamespace)]
[XmlRoot("SampleRequest", Namespace = Namespaces.ServiceNamespace)]
public class SampleRequest
{
    [XmlAttribute("track")]
    public string Track { get; set; } = string.Empty;
​
    [XmlElement("requestTimestamp", IsNullable = false)]
    public string RequestTimestamp { get; set; } = string.Empty;
​
    [XmlElement("subjectInfo", IsNullable = false)]
    public SubjectInfo SubjectInfo { get; set; } = new();
}
​
public class SubjectInfo
{
    [XmlElement("uniqueId", IsNullable = false)]
    public string UniqueId { get; set; } = string.Empty;
}
​
//Notes
//https://learn.microsoft.com/en-us/dotnet/framework/wcf/feature-details/using-message-contracts
//https://learn.microsoft.com/en-us/previous-versions/dotnet/netframework-3.5/ms734675(v=vs.90)?redirectedfrom=MSDN
//https://learn.microsoft.com/en-us/dotnet/api/system.servicemodel.messagecontractattribute?view=netframework-4.8.1
//https://devblogs.microsoft.com/dotnet/custom-asp-net-core-middleware-example/
//https://learn.microsoft.com/en-us/dotnet/api/system.servicemodel.description.typedmessageconverter
//https://learn.microsoft.com/en-us/dotnet/api/system.servicemodel.description.typedmessageconverter.tomessage
//https://learn.microsoft.com/en-us/dotnet/api/microsoft.aspnetcore.builder.iapplicationbuilder
//https://learn.microsoft.com/en-us/dotnet/api/system.servicemodel.channels.message
//https://learn.microsoft.com/en-us/dotnet/api/system.servicemodel.xmlserializerformatattribute
//
//https://github.com/DigDes/SoapCore
//https://github.com/DigDes/SoapCore/tree/develop/samples
//https://github.com/DigDes/SoapCore/blob/develop/samples/Server/SampleService.cs
//https://github.com/DigDes/SoapCore/blob/develop/samples/Models/ComplexModelInput.cs
//https://stackify.com/soap-net-core/
//
//https://stackoverflow.com/questions/79581114/net-soapcore-wsdl-generation-and-xml-deserialization-mismatch-using-xmlserializ
//https://stackoverflow.com/questions/4106196/wcf-message-body-showing-sbody-stream-sbody-after-modification
//https://stackoverflow.com/questions/46744567/wcf-messagebodymember-with-complex-type-and-namespace
​
public class TestClass
{
    public static void Test()
    {
        var body = new SampleRequest
        {
            Track = "V",
            RequestTimestamp = "20210305113442",
            SubjectInfo = new()
            {
                UniqueId = "ABCDE1234",
            }
        };
        
        Console.WriteLine(new SampleRequestWrapper { SampleRequest = body } .ToMessageXml(null, new XmlSerializerFormatAttribute()));
        
        var requestXml = GetRequestXml();
        
        var requestMessage = MessageContractSerializerHelper.CreateMessageFromXml(requestXml, MessageVersion.Soap12WSAddressing10);
        
        Console.WriteLine();
        //Console.WriteLine(requestMessage.ToMessageString());
        
        var requestBody = requestMessage.FromMessage<SampleRequestWrapper>(null, new XmlSerializerFormatAttribute());
        requestBody.Dump();
    }
    
    static string GetRequestXml() =>
        """
        <soap:Envelope xmlns:soap="http://www.w3.org/2003/05/soap-envelope" xmlns:add="http://www.w3.org/2005/08/addressing">
           <soap:Body>
              <SampleRequest xmlns="http://example.com/namespace/" track="V">
                 <requestTimestamp>20210305113442</requestTimestamp>
                 <subjectInfo>
                    <uniqueId>ABCDE1234</uniqueId>
                 </subjectInfo>
              </SampleRequest>
           </soap:Body>
        </soap:Envelope>
        """;
}
​
#if false
    Snippet to create and read a System.ServiceModel.Channels.Message object representing a WCF operation invocation containing multiple parameters. 
    This is how you would use DataContractSerializer to make an entire operation call, including each individual parameter, rather than just serializing
    one object at a time. 
​
    https://gist.github.com/mfenniak/4707000
#endif
    public static class MessageContractSerializerHelper
    {
        // https://social.msdn.microsoft.com/Forums/vstudio/en-US/d7e37ec7-d651-40a4-83c0-6e5727e5617b/how-to-serializedeserialize-messagecontract-tofrom-an-soap-string?forum=wcf
        //
        // But see also
        //
        // https://social.msdn.microsoft.com/Forums/vstudio/en-US/278565bc-df03-46b3-a855-e12e58ddba67/how-to-modify-systemservicemodelchannelsmessage?forum=wcf
        public static string ToMessageString(this Message message) =>
            // Use a buffered copy in case the message is streamed.
            message.CreateBufferedCopy(int.MaxValue).CreateMessage().ToString();
        
        public static Message CreateMessageFromXml(string xml, MessageVersion ver)
        {
            using var textReader = new StringReader(xml);
            using var xmlReader = XmlReader.Create(textReader);
            xmlReader.MoveToContent();
            xmlReader.ReadToFollowing("Body", "http://www.w3.org/2003/05/soap-envelope");
            xmlReader.Read();
            xmlReader.MoveToContent();
            //Console.WriteLine((xmlReader.NodeType, xmlReader.Name));
            using var subReader = xmlReader.ReadSubtree();
            // At this point the message contains streaming data that hasn't been processed yet.
            // If we dispose of the readers then the message will appear empty.
            // So, materialize it by copying it into a buffered copy.
            var streamingMessage = Message.CreateMessage(ver, null, subReader);
            MessageBuffer messageBuffer = streamingMessage.CreateBufferedCopy(int.MaxValue);
            Message bufferedMessage = messageBuffer.CreateMessage();
            
            return bufferedMessage;
        }
        
        public static T FromMessage<T>(this Message message, string action, XmlSerializerFormatAttribute attr)
        {
            var converter = TypedMessageConverter.Create(typeof(T), action, attr);
            return (T)converter.FromMessage(message);
        }
        
        public static Message ToMessage<T>(this T typedMessage, string action, XmlSerializerFormatAttribute attr)
        {
            var converter = TypedMessageConverter.Create(typedMessage.GetType(), action, attr);
            return converter.ToMessage(typedMessage);
        }
​
        public static string ToMessageXml<T>(this T typedMessage, string action, XmlSerializerFormatAttribute attr)
        {
            return typedMessage.ToMessage(action, attr).ToString();
        }
​
        public static Message ToMessage<T>(this T typedMessage, string action)
        {
            var converter = TypedMessageConverter.Create(typedMessage.GetType(), action);
            return converter.ToMessage(typedMessage);
        }
​
        public static string ToMessageXml<T>(this T typedMessage, string action)
        {
            return typedMessage.ToMessage(action).ToString();
        }
​
        public static Message ToMessage<T>(this T typedMessage, string action, string defaultNamespace)
        {
            var converter = TypedMessageConverter.Create(typedMessage.GetType(), action, defaultNamespace);
            return converter.ToMessage(typedMessage);
        }
​
        public static string ToMessageXml<T>(this T typedMessage, string action, string defaultNamespace)
        {
            return typedMessage.ToMessage(action, defaultNamespace).ToString();
        }
    }
​
    public static class XmlSerializationHelper
    {
        public static T LoadFromXml<T>(this string xmlString, XmlSerializer serial = null)
        {
            using (var reader = new StringReader(xmlString))
            {
                return (T)(serial ?? new XmlSerializer(typeof(T))).Deserialize(reader);
            }
        }
​
        public static string GetXml<T>(this T obj, XmlSerializer serializer = null, bool omitStandardNamespaces = false)
        {
            XmlSerializerNamespaces ns = null;
            if (omitStandardNamespaces)
            {
                ns = new XmlSerializerNamespaces();
                ns.Add("", ""); // Disable the xmlns:xsi and xmlns:xsd lines.
            }           
            using (var textWriter = new StringWriter())
            {
                var settings = new XmlWriterSettings() { Indent = true }; // For cosmetic purposes.
                using (var xmlWriter = XmlWriter.Create(textWriter, settings))
                    (serializer ?? new XmlSerializer(obj.GetType())).Serialize(xmlWriter, obj, ns);
                return textWriter.ToString();
            }
        }
        
        public static string GetOuterXml(this XmlNode node, bool indent = true)
        {
            if (node == null)
                return null;
            using (var textWriter = new StringWriter())
            {
                var settings = new XmlWriterSettings
                {
                    Indent = indent,
                    OmitXmlDeclaration = true,
                };
                using (var xmlWriter = XmlWriter.Create(textWriter, settings))
                {
                    node.WriteTo(xmlWriter);
                }
                return textWriter.ToString();
            }
        }
    }
​
    public static class XmlAssert
    {
        // https://weblogs.asp.net/marianor/easy-way-to-compare-two-xmls-for-equality
        // https://stackoverflow.com/questions/7318157/best-way-to-compare-xelement-objects
        // Adapted from the answer https://stackoverflow.com/a/14463137 by https://stackoverflow.com/users/1102100/robjohnson
        public static void AreEqual(
            XElement expected,
            XElement actual)
        {
            Assert.IsTrue(XNode.DeepEquals(Normalize(expected), Normalize(actual)));
        }
​
        private static XElement Normalize(XElement element)
        {
            if (element.HasElements)
            {
                return new XElement(
                    element.Name,
                    element.Attributes()
                           .OrderBy(a => a.Name.ToString()),
                    element.Elements()
                           .OrderBy(a => a.Name.ToString())
                           .Select(e => Normalize(e)));
​
            }
​
            if (element.IsEmpty)
            {
                return new XElement(
                    element.Name,
                    element.Attributes()
                           .OrderBy(a => a.Name.ToString()));
            }
​
            return new XElement(element.Name, element.Attributes()
                .OrderBy(a => a.Name.ToString()), element.Value);
        }
    }
                
    public class Program
    {
        public static void Main()
        {
            Console.WriteLine("Environment version: {0} ({1}, {2}, NewLine: {3}).", 
                              System.Runtime.InteropServices.RuntimeInformation.FrameworkDescription , Environment.Version, Environment.OSVersion,
                              System.Text.Json.JsonSerializer.Serialize(Environment.NewLine));
            Console.WriteLine("{0} version: {1}", typeof(SoapCore.CustomMessage).Namespace, typeof(SoapCore.CustomMessage).Assembly.FullName);
            Console.WriteLine();
​
            try
            {
                TestClass.Test();
            }
            catch (Exception ex)
            {
                Console.WriteLine("Failed with unhandled exception: ");
                Console.WriteLine(ex);
                throw;
            }
        }
    }
​
#if false
public static class SoapCoreExtensions
{
    public static Message CreateResponseMessage(
        OperationDescription operation,
        object responseObject,
        Dictionary<string, object> resultOutDictionary,
        string soapAction,
        Message? requestMessage,
        XmlNamespaceManager xmlNamespaceManager,
        MessageVersion messageVersion,
        SoapOptions _options,
        SoapMessageEncoder soapMessageEncoder) where T_MESSAGE : CustomMessage, new()
    {
            T_MESSAGE responseMessage;
​
            // Create response message
            BodyWriter bodyWriter = new ServiceBodyWriter(_options.SoapSerializer, operation, responseObject, resultOutDictionary);
            //var xmlNamespaceManager = GetXmlNamespaceManager(soapMessageEncoder);
​
            
            if (soapMessageEncoder.MessageVersion.Addressing == AddressingVersion.WSAddressing10)
            {
            }
            else
            {
            }
​
            var underlyingMessage = Message.CreateMessage(soapMessageEncoder.MessageVersion, 
                                                          soapMessageEncoder.MessageVersion.Addressing == AddressingVersion.WSAddressing10 ? soapAction : null,
                                                          bodyWriter);
        
            if (soapMessageEncoder.MessageVersion.Addressing == AddressingVersion.WSAddressing10)
            {
                responseMessage = new CustomMessage(underlyingMessage)
                {
                    StandAloneAttribute = _options.StandAloneAttribute,
                    Message = Message.CreateMessage(soapMessageEncoder.MessageVersion, soapAction, bodyWriter),
                    AdditionalEnvelopeXmlnsAttributes = _options.AdditionalEnvelopeXmlnsAttributes,
                    NamespaceManager = xmlNamespaceManager
                };
​
                responseMessage.Headers.Action = operation.ReplyAction;
                responseMessage.Headers.RelatesTo = requestMessage.Headers.MessageId;
                responseMessage.Headers.To = requestMessage.Headers.ReplyTo?.Uri;
            }
            else
            {
                responseMessage = new CustomMessage(underlyingMessage)
                {
                    StandAloneAttribute = _options.StandAloneAttribute,
                    Message = Message.CreateMessage(soapMessageEncoder.MessageVersion, null, bodyWriter),
                    AdditionalEnvelopeXmlnsAttributes = _options.AdditionalEnvelopeXmlnsAttributes,
                    NamespaceManager = xmlNamespaceManager
                };
            }
​
            if (responseObject != null)
            {
                var messageHeaderMembers = responseObject.GetType().GetMembersWithAttribute<MessageHeaderAttribute>();
                foreach (var messageHeaderMember in messageHeaderMembers)
                {
                    var messageHeaderAttribute = messageHeaderMember.Attribute;
                    responseMessage.Headers.Add(MessageHeader.CreateHeader(messageHeaderAttribute.Name ?? messageHeaderMember.Member.Name, messageHeaderAttribute.Namespace ?? operation.Contract.Namespace, messageHeaderMember.Member.GetPropertyOrFieldValue(responseObject), messageHeaderAttribute.MustUnderstand));
                }
            }
​
            return responseMessage;
​
    }
}
#endif
​
​

View IL Code