[C#] Dynamic Web Service Invoker

var codeCompileUnit = new CodeCompileUnit();
codeCompileUnit.Namespaces.Add(codeNamespace);
var codeProvider = CodeDomProvider.CreateProvider("CSharp");
var compilerParameters = new CompilerParameters();
...
// Potentially a shortcut to the type. If this doesn't work for you then find it by name.
Type type = result.CompiledAssembly.ExportedTypes.First();
string _mTypeName = type.Name;
string action = "TheAction";
var _mMethodInfo = type.GetMethod(action);

/// <summary>
            /// Create a soap webrequest to [Url]
            /// </summary>
            /// <returns></returns>
            public HttpWebRequest CreateWebRequest(Uri uri)
            {
                CookieContainer myContainer = new CookieContainer();

                HttpWebRequest webRequest = (HttpWebRequest)WebRequest.Create(uri);
                webRequest.Credentials = GetCredential(uri);
                webRequest.CookieContainer = myContainer;
                webRequest.PreAuthenticate = true;
                //TODO add action from config
                webRequest.Headers.Add(@"SoapAction :" + <action from config file>)
                webRequest.ContentType = "text/xml;charset=\"utf-8\"";
                webRequest.Accept = "text/xml";
                webRequest.Method = "POST";
                return webRequest;
            }

            private CredentialCache GetCredential(Uri uri)
            {
                ServicePointManager.SecurityProtocol = SecurityProtocolType.Ssl3;
                CredentialCache credentialCache = new CredentialCache();
                credentialCache.Add(uri, "NTLM", new NetworkCredential("<username>", @"pwd", "domain"));
                return credentialCache;
            }
            public XElement Execute(WebServiceInfo info)
            {
                HttpWebRequest request = CreateWebRequest(info.Address);
                XElement soapEnvelopeXml = info.Envelope;
                using (Stream stream = request.GetRequestStream())
                {
                    soapEnvelopeXml.Save(stream);
                }

                using (WebResponse response = request.GetResponse())
                {
                    using (StreamReader rd = new StreamReader(response.GetResponseStream()))
                    {
                        string soapResult = rd.ReadToEnd();
                        Console.WriteLine(soapResult);
                        return XElement.Parse(soapResult);
                    }
                }
             }

public class WebServiceInfo
        {
            private static XElement _configFile = null;
            public WebServiceInfo(XElement webServiceElement)
            {
                InitConfig();
               
                Contract.Assume(_configFile != null);
                Init(webServiceElement);
            }

            private static void InitConfig()
            {
                if (_configFile == null)
                {
                    _configFile = XElement.Load("SoapFormat.xml");
                }
            }

            private void Init(XElement webServiceElement)
            {
                InitConfig();
                Contract.Assume(webServiceElement != null);
                Contract.Assume(_configFile != null);
                
                XAttribute name = webServiceElement.Attribute("name");
                this.Name = name.Value;
                
                XElement envelope = webServiceElement.Elements().Where(elm => elm.Name.LocalName == "Envelope").SingleOrDefault();
                this.Envelope = envelope;

                XElement uriElm = webServiceElement.Element("uri");
                Contract.Assume(uriElm != null, "Webservice is missing <uri> address to service. Please add uri to configfile.");
                try
                {
                    this.Address = new Uri(uriElm.Value);
                }
                catch(Exception ex)
                {
                    Contract.Assume(false, string.Format("uri must be valid http address", ex.Message));
                }

                XElement xsltElm = webServiceElement.Element("xslt");
                Contract.Assume(xsltElm != null, "Webservice is missing <xslt> file path. Please add xslt file path to configfile.");
                try
                {
                    this.XsltPath = new FileInfo(xsltElm.Value);
                    if (this.XsltPath.Exists)
                    {
                        this.XsltTrans = new XslTransform();
                        this.XsltTrans.Load(XsltPath.FullName);

                    }
                    else
                    {
                        Contract.Assume(false, string.Format("xslt {0} must exists. Please add file, or change config xslt settings", this.XsltPath.FullName));
                    }
                }
                catch (Exception ex)
                {
                    Contract.Assume(false, string.Format("xslt must be valid file path, and must exists, and be valid xslt xml : {0}", ex.Message));
                }

                
                XElement actionElm = webServiceElement.Element("action");
                Contract.Assume(actionElm != null, "Webservice is missing <action> webservice method command. Please add <action>  to configfile.");
                try
                {
                    this.Action = actionElm.Value;
                }
                catch (Exception ex)
                {
                    Contract.Assume(false, string.Format("action cannot be loaded : {0}", ex.Message));
                }
            }
            public XslTransform XsltTrans { get; set; } 
            public string Name {get; set;}
            public Uri Address {get;set;}
            public XElement Envelope {get;set;}
            public FileInfo XsltPath {get;set;}
            public string Action { get; set; }

            public static WebServiceInfo GetWebService(string serviceName)
            {
                InitConfig();
                Contract.Assume(_configFile != null);
                XElement elm = _configFile.Descendants().Where(serviceElm => serviceElm.Name.LocalName == "webservice" && serviceElm.Attribute("name") != null && serviceElm.Attribute("name").Value == serviceName).SingleOrDefault();
                if (elm != null)
                {
                    WebServiceInfo info = new WebServiceInfo(elm);
                    return info;
                }
                return null;
            }
        }

WebServiceInfo info = WebServiceInfo.GetWebService("somefuncionalname>");
Assert.IsNotNull(info);
Assert.IsNotNull(info.Address);
Assert.IsNotNull(info.Envelope);
Assert.IsNotNull(info.XsltPath);
Assert.IsNotNull(info.XsltTrans);
Assert.IsNotNull(info.Action);
WebServiceExecutor executor = new WebServiceExecutor();
XElement result = executor.Execute(info);
Assert.IsNotNull(result);