object CreateWebServiceFromWsdl(byte[] wsdl) {
// generate CodeDom from WSDL
ServiceDescription sd = ServiceDescription.Read(new MemoryStream(wsdl));
ServiceDescriptionImporter importer = new ServiceDescriptionImporter();
importer.ServiceDescriptions.Add(sd);
CodeCompileUnit codeCompileUnit = new CodeCompileUnit();
CodeNamespace codeNamespace = new CodeNamespace("");
codeCompileUnit.Namespaces.Add(codeNamespace);
importer.CodeGenerationOptions = CodeGenerationOptions.GenerateNewAsync | CodeGenerationOptions.GenerateOldAsync;
importer.Import(codeNamespace, codeCompileUnit);
// update web service proxy CodeDom tree to add dynamic support
string wsProxyTypeName = FindProxyTypeAndAugmentCodeDom(codeNamespace);
// compile CodeDom tree into an Assembly
CodeDomProvider provider = CodeDomProvider.CreateProvider("CS");
CompilerParameters compilerParams = new CompilerParameters();
compilerParams.GenerateInMemory = true;
compilerParams.IncludeDebugInformation = false;
compilerParams.ReferencedAssemblies.Add(typeof(Ops).Assembly.Location); //DLR
CompilerResults results = provider.CompileAssemblyFromDom(compilerParams, codeCompileUnit);
Assembly generatedAssembly = results.CompiledAssembly;
// find the type derived from SoapHttpClientProtocol
Type wsProxyType = generatedAssembly.GetType(wsProxyTypeName);
if (wsProxyType == null) {
throw new InvalidOperationException("Web service proxy type not generated.");
}
// create an instance of the web proxy type
return Activator.CreateInstance(wsProxyType);
}
/// <summary<
/// Constructor
/// </summary<
/// <param name="url"<</param<
public JstWebServiceAgent(string url)
{
try
{
XmlTextReader reader = new XmlTextReader(url + "?wsdl");
//建立 WSDL格式文档
ServiceDescription sd = ServiceDescription.Read(reader);
//客户端代理
ServiceDescriptionImporter sdi = new ServiceDescriptionImporter();
sdi.AddServiceDescription(sd, null, null);
//使用CodeDom 动态编译代理类
CodeNamespace cn = new CodeNamespace(CODE_NAMESPACE);
CodeCompileUnit ccu = new CodeCompileUnit();
ccu.Namespaces.Add(cn);
sdi.Import(cn, ccu);
Microsoft.CSharp.CSharpCodeProvider icc = new Microsoft.CSharp.CSharpCodeProvider();
CompilerParameters cp = new CompilerParameters();
CompilerResults cr = icc.CompileAssemblyFromDom(cp, ccu);
agentType = cr.CompiledAssembly.GetTypes()[0];
agent = Activator.CreateInstance(agentType);
WriteTextLog("日志", "初始化成功", DateTime.Now);
}
catch (Exception ex)
{
WriteTextLog("错误", ex.ToString(), DateTime.Now);
throw;
}
}
public void ImportHttpOnlyWsdl()
{
ServiceDescriptionImporter imp =
new ServiceDescriptionImporter();
imp.AddServiceDescription(ServiceDescription.Read("Test/System.Web.Services.Description/test3.wsdl"), null, null);
CodeNamespace cns = new CodeNamespace();
CodeCompileUnit ccu = new CodeCompileUnit();
ccu.Namespaces.Add(cns);
imp.Import(cns, ccu);
// FIXME: this test could require more precise result
bool verified = false;
Assert.AreEqual(1, ccu.Namespaces.Count, "#1");
Assert.AreEqual(1, ccu.Namespaces [0].Types.Count, "#2");
foreach (CodeTypeDeclaration cd in ccu.Namespaces[0].Types)
{
Console.WriteLine("***" + cd.Name);
if (cd.Name != "MyService")
{
continue;
}
Assert.AreEqual("System.Web.Services.Protocols.HttpGetClientProtocol", cd.BaseTypes [0].BaseType);
verified = true;
}
Assert.IsTrue(verified, "verified");
}
public static void Generate(string nameSpace, string serviceUri, string srcFile)
{
WebClient client = new WebClient();
Stream stream = client.OpenRead(serviceUri.EndsWith("?wsdl") ? serviceUri : (serviceUri + "?wsdl"));
ServiceDescription desc = ServiceDescription.Read(stream);
ServiceDescriptionImporter importor = new ServiceDescriptionImporter();
importor.ProtocolName = "Soap";
importor.Style = ServiceDescriptionImportStyle.Client;
importor.CodeGenerationOptions = CodeGenerationOptions.GenerateProperties | CodeGenerationOptions.GenerateNewAsync;
importor.AddServiceDescription(desc, null, null);
CodeNamespace nsp = string.IsNullOrEmpty(nameSpace) ? new CodeNamespace() : new CodeNamespace(nameSpace);
CodeCompileUnit unit = new CodeCompileUnit();
unit.Namespaces.Add(nsp);
ServiceDescriptionImportWarnings warnings = importor.Import(nsp, unit);
CodeDomProvider codeProvider = CodeDomProvider.CreateProvider("CSharp");
TextWriter tWriter = File.CreateText(srcFile);
codeProvider.GenerateCodeFromCompileUnit(unit, tWriter, null);
tWriter.Flush();
tWriter.Close();
}
/// <summary>
/// get an Assembly according to wsdl path.
/// </summary>
/// <param name="wsdl">wsdl path</param>
/// <param name="nameSpace">namespace</param>
/// <returns>return Assembly</returns>
public static Assembly GetWebServiceAssembly(string wsdl, string nameSpace)
{
try
{
System.Net.WebClient webClient = new System.Net.WebClient();
System.IO.Stream webStream = webClient.OpenRead(wsdl);
ServiceDescription serviceDescription = ServiceDescription.Read(webStream);
ServiceDescriptionImporter serviceDescroptImporter = new ServiceDescriptionImporter();
serviceDescroptImporter.AddServiceDescription(serviceDescription, "", "");
System.CodeDom.CodeNamespace codeNameSpace = new System.CodeDom.CodeNamespace(nameSpace);
System.CodeDom.CodeCompileUnit codeCompileUnit = new System.CodeDom.CodeCompileUnit();
codeCompileUnit.Namespaces.Add(codeNameSpace);
serviceDescroptImporter.Import(codeNameSpace, codeCompileUnit);
System.CodeDom.Compiler.CodeDomProvider codeDom = new Microsoft.CSharp.CSharpCodeProvider();
System.CodeDom.Compiler.CompilerParameters codeParameters = new System.CodeDom.Compiler.CompilerParameters();
codeParameters.GenerateExecutable = false;
codeParameters.GenerateInMemory = true;
codeParameters.ReferencedAssemblies.Add("System.dll");
codeParameters.ReferencedAssemblies.Add("System.XML.dll");
codeParameters.ReferencedAssemblies.Add("System.Web.Services.dll");
codeParameters.ReferencedAssemblies.Add("System.Data.dll");
System.CodeDom.Compiler.CompilerResults compilerResults = codeDom.CompileAssemblyFromDom(codeParameters, codeCompileUnit);
return(compilerResults.CompiledAssembly);
}
catch (Exception ex)
{
throw ex;
}
}
private static Assembly CompileAssembly(ServiceDescriptionImporter descriptionImporter)
{
CodeNamespace codeNamespace = new CodeNamespace();
CodeCompileUnit codeUnit = new CodeCompileUnit();
codeUnit.Namespaces.Add(codeNamespace);
ServiceDescriptionImportWarnings importWarnings = descriptionImporter.Import(codeNamespace, codeUnit);
if (importWarnings == 0)
{
CodeDomProvider compiler = CodeDomProvider.CreateProvider("CSharp");
string[] references = { "System.Web.Services.dll", "System.Xml.dll" };
CompilerParameters parameters = new CompilerParameters(references);
CompilerResults results = compiler.CompileAssemblyFromDom(parameters, codeUnit);
if (results.Errors.Count > 0)
{
throw new Exception("Compilation Error Creating Assembly");
}
return(results.CompiledAssembly);
}
else
{
throw new Exception("Invalid WSDL");
}
}
/// <summary>
/// 动态调用web服务
/// </summary>
/// <param name="url">WSDL服务地址</param>
/// <param name="classname">服务接口类名</param>
/// <param name="methodname">方法名</param>
/// <param name="args">参数值</param>
/// <returns></returns>
public static object InvokeWebService(string url, string classname, string methodname, object[] args)
{
string @namespace = "EnterpriseServerBase.WebService.DynamicWebCalling";
if ((classname == null) || (classname == ""))
{
classname = WebServiceHelper.GetWsClassName(url);
}
try
{
//获取WSDL
WebClient wc = new WebClient();
Stream stream = wc.OpenRead(url + "?WSDL");
ServiceDescription sd = ServiceDescription.Read(stream);
//注意classname一定要赋值获取
classname = sd.Services[0].Name;
ServiceDescriptionImporter sdi = new ServiceDescriptionImporter();
sdi.AddServiceDescription(sd, "", "");
CodeNamespace cn = new CodeNamespace(@namespace);
//生成客户端代理类代码
CodeCompileUnit ccu = new CodeCompileUnit();
ccu.Namespaces.Add(cn);
sdi.Import(cn, ccu);
CSharpCodeProvider icc = new CSharpCodeProvider();
//设定编译参数
CompilerParameters cplist = new CompilerParameters();
cplist.GenerateExecutable = false;
cplist.GenerateInMemory = true;
cplist.ReferencedAssemblies.Add("System.dll");
cplist.ReferencedAssemblies.Add("System.XML.dll");
cplist.ReferencedAssemblies.Add("System.Web.Services.dll");
cplist.ReferencedAssemblies.Add("System.Data.dll");
//编译代理类
CompilerResults cr = icc.CompileAssemblyFromDom(cplist, ccu);
if (true == cr.Errors.HasErrors)
{
System.Text.StringBuilder sb = new System.Text.StringBuilder();
foreach (System.CodeDom.Compiler.CompilerError ce in cr.Errors)
{
sb.Append(ce.ToString());
sb.Append(System.Environment.NewLine);
}
throw new Exception(sb.ToString());
}
//生成代理实例，并调用方法
System.Reflection.Assembly assembly = cr.CompiledAssembly;
Type t = assembly.GetType(@namespace + "." + classname, true, true);
object obj = Activator.CreateInstance(t);
System.Reflection.MethodInfo mi = t.GetMethod(methodname);
return(mi.Invoke(obj, args));
}
catch (Exception ex)
{
throw new Exception(ex.Message, new Exception(ex.StackTrace));
}
}
/// <summary<
/// 构造函数
/// </summary<
/// <param name="url"<</param<
public WebServiceAgent(string url)
{
XmlTextReader reader = new XmlTextReader(url + "?wsdl");
//创建和格式化 WSDL 文档
ServiceDescription sd = ServiceDescription.Read(reader);
//创建客户端代理代理类
ServiceDescriptionImporter sdi = new ServiceDescriptionImporter();
sdi.AddServiceDescription(sd, null, null);
//使用 CodeDom 编译客户端代理类
CodeNamespace cn = new CodeNamespace(CODE_NAMESPACE);
CodeCompileUnit ccu = new CodeCompileUnit();
ccu.Namespaces.Add(cn);
sdi.Import(cn, ccu);
Microsoft.CSharp.CSharpCodeProvider icc = new Microsoft.CSharp.CSharpCodeProvider();
CompilerParameters cp = new CompilerParameters();
CompilerResults cr = icc.CompileAssemblyFromDom(cp, ccu);
agentType = cr.CompiledAssembly.GetTypes()[0];
agent = Activator.CreateInstance(agentType);
}
private void ImportMetadata()
{
this._codeCompileUnit = new CodeCompileUnit();
this._codeDomProvider = CodeDomProvider.CreateProvider(this._setupInfo.Language.ToString());
CodeNamespace codeNamespace = new CodeNamespace();
this._codeCompileUnit.Namespaces.Add(codeNamespace);
ServiceDescriptionImporter serviceDescriptionImporter = new ServiceDescriptionImporter();
serviceDescriptionImporter.CodeGenerationOptions = CodeGenerationOptions.GenerateProperties | CodeGenerationOptions.GenerateOrder | CodeGenerationOptions.EnableDataBinding;
if (this._setupInfo.GenerateAsync)
{
serviceDescriptionImporter.CodeGenerationOptions |= CodeGenerationOptions.GenerateNewAsync | CodeGenerationOptions.GenerateOldAsync;
}
foreach (var serviceDescription in this.Metadata)
{
serviceDescriptionImporter.AddServiceDescription(serviceDescription, null, null);
}
this.ImportWarnings = serviceDescriptionImporter.Import(codeNamespace, this._codeCompileUnit);
}
private bool BuildWSDL(WebProperties WebProps, IntegrationLog Log)
{
try
{
Uri uri = new Uri(WebProps.Properties["WSDL"].ToString());
//byte[] byteArray = Encoding.ASCII.GetBytes(WebProps.Properties["WSDL"].ToString());
//MemoryStream stream = new MemoryStream(byteArray);
WebRequest webRequest = WebRequest.Create(uri);
System.IO.Stream stream = webRequest.GetResponse().GetResponseStream();
ServiceDescription sd = ServiceDescription.Read(stream);
string sdName = sd.Services[0].Name;
// Initialize a service description servImport
ServiceDescriptionImporter servImport = new ServiceDescriptionImporter();
servImport.AddServiceDescription(sd, String.Empty, String.Empty);
servImport.ProtocolName = "Soap";
servImport.CodeGenerationOptions = CodeGenerationOptions.GenerateProperties;
CodeNamespace nameSpace = new CodeNamespace();
CodeCompileUnit codeCompileUnit = new CodeCompileUnit();
codeCompileUnit.Namespaces.Add(nameSpace);
ServiceDescriptionImportWarnings warnings = servImport.Import(nameSpace, codeCompileUnit);
if (warnings == 0)
{
using (var stringWriter = new StringWriter(CultureInfo.CurrentCulture))
{
var prov = new CSharpCodeProvider();
prov.GenerateCodeFromNamespace(nameSpace, stringWriter, new CodeGeneratorOptions());
var assemblyReferences = new string[2] {
"System.Web.Services.dll", "System.Xml.dll"
};
var param = new CompilerParameters(assemblyReferences)
{
GenerateExecutable = false,
GenerateInMemory = true,
TreatWarningsAsErrors = false,
WarningLevel = 4,
};
var results = new CompilerResults(new TempFileCollection());
results = prov.CompileAssemblyFromDom(param, codeCompileUnit);
var assembly = results.CompiledAssembly;
service = assembly.GetType(sdName);
methodInfo = service.GetMethods();
}
}
return(true);
}
catch (Exception ex)
{
Log.LogMessage(ex.Message, IntegrationLogType.Error);
}
return(false);
}
public static object InvokeWebService(string url, string classname, string methodname, object[] args)
{
var @namespace = "iPem.Core.WebService";
if (string.IsNullOrWhiteSpace(classname))
{
classname = GetWsClassName(url);
}
try {
if (!url.EndsWith("wsdl", StringComparison.CurrentCultureIgnoreCase))
{
url = string.Format("{0}?{1}", url, "wsdl");
}
//获取wsdl
var wc = new WebClient();
var stream = wc.OpenRead(url);
var sd = ServiceDescription.Read(stream);
var sdi = new ServiceDescriptionImporter();
sdi.AddServiceDescription(sd, "", "");
var cn = new CodeNamespace(@namespace);
var ccu = new CodeCompileUnit();
ccu.Namespaces.Add(cn);
sdi.Import(cn, ccu);
//设定编译参数
var cplist = new CompilerParameters();
cplist.GenerateExecutable = false;
cplist.GenerateInMemory = true;
cplist.ReferencedAssemblies.Add("System.dll");
cplist.ReferencedAssemblies.Add("System.XML.dll");
cplist.ReferencedAssemblies.Add("System.Web.Services.dll");
cplist.ReferencedAssemblies.Add("System.Data.dll");
//编译代理类
var icc = new CSharpCodeProvider();
var cr = icc.CompileAssemblyFromDom(cplist, ccu);
if (true == cr.Errors.HasErrors)
{
var sb = new System.Text.StringBuilder();
foreach (CompilerError ce in cr.Errors)
{
sb.AppendLine(ce.ToString());
}
throw new Exception(sb.ToString());
}
//生成代理实例，并调用方法
var assembly = cr.CompiledAssembly;
var t = assembly.GetType(@namespace + "." + classname, true, true);
var obj = Activator.CreateInstance(t);
var mi = t.GetMethod(methodname);
return(mi.Invoke(obj, args));
} catch (Exception ex) {
throw new Exception(ex.InnerException.Message, new Exception(ex.InnerException.StackTrace));
}
}
void GenerateCode(HttpContext context, string langId)
{
context.Response.ContentType = "text/plain; charset=utf-8";
CodeNamespace codeNamespace = new CodeNamespace();
CodeCompileUnit codeUnit = new CodeCompileUnit();
codeUnit.Namespaces.Add(codeNamespace);
ServiceDescriptionImporter importer = new ServiceDescriptionImporter();
foreach (ServiceDescription sd in GetDescriptions())
{
importer.AddServiceDescription(sd, null, null);
}
foreach (XmlSchema sc in GetSchemas())
{
importer.Schemas.Add(sc);
}
importer.Import(codeNamespace, codeUnit);
if (langId == null || langId == "")
{
langId = "cs";
}
CodeDomProvider provider = GetProvider(langId);
ICodeGenerator generator = provider.CreateGenerator();
CodeGeneratorOptions options = new CodeGeneratorOptions();
generator.GenerateCodeFromCompileUnit(codeUnit, context.Response.Output, options);
}
/// <summary>
/// 实例化WebServices
/// </summary>
/// <param name="url">WebServices地址</param>
/// <param name="methodname">调用的方法</param>
/// <param name="args">把webservices里需要的参数按顺序放到这个object[]里</param>
public static object InvokeWebService(string url, string methodname, object[] args)
{
//这里的namespace是需引用的webservices的命名空间，我没有改过，也可以使用。也可以加一个参数从外面传进来。
//string @namespace = "client";
string @namespace = assemblyName;
try
{
//获取WSDL
WebClient wc = new WebClient();
Stream stream = wc.OpenRead(url + "?WSDL");
ServiceDescription sd = ServiceDescription.Read(stream);
string classname = sd.Services[0].Name;
ServiceDescriptionImporter sdi = new ServiceDescriptionImporter();
sdi.AddServiceDescription(sd, "", "");
CodeNamespace cn = new CodeNamespace(@namespace);
//生成客户端代理类代码
CodeCompileUnit ccu = new CodeCompileUnit();
ccu.Namespaces.Add(cn);
sdi.Import(cn, ccu);
CSharpCodeProvider csc = new CSharpCodeProvider();
//ICodeCompiler icc = csc.CreateCompiler();
//设定编译参数
CompilerParameters cplist = new CompilerParameters();
cplist.GenerateExecutable = false;
cplist.GenerateInMemory = true;
cplist.ReferencedAssemblies.Add("System.dll");
cplist.ReferencedAssemblies.Add("System.XML.dll");
cplist.ReferencedAssemblies.Add("System.Web.Services.dll");
cplist.ReferencedAssemblies.Add("System.Data.dll");
//编译代理类
CompilerResults cr = csc.CompileAssemblyFromDom(cplist, ccu);
if (true == cr.Errors.HasErrors)
{
System.Text.StringBuilder sb = new System.Text.StringBuilder();
foreach (System.CodeDom.Compiler.CompilerError ce in cr.Errors)
{
sb.Append(ce.ToString());
sb.Append(System.Environment.NewLine);
}
throw new Exception(sb.ToString());
}
//生成代理实例，并调用方法
System.Reflection.Assembly assembly = cr.CompiledAssembly;
Type t = assembly.GetType(@namespace + "." + classname, true, true);
object obj = Activator.CreateInstance(t);
System.Reflection.MethodInfo mi = t.GetMethod(methodname);
return(mi.Invoke(obj, args));
}
catch (Exception ex)
{
throw ex.InnerException;//throw ex.InnerException; 看到的是原始异常
//return null;
}
}
private static Assembly GenerateAssemblyFromWsdl(string wsdlUrl)
{
var importer = new ServiceDescriptionImporter();
using (var webClient = new WebClient())
{
var wsdl = webClient.DownloadString(wsdlUrl);
var serviceDescription = ServiceDescription.Read(new StringReader(wsdl));
importer.AddServiceDescription(serviceDescription, null, null);
}
importer.Style = ServiceDescriptionImportStyle.Client;
importer.CodeGenerationOptions = System.Xml.Serialization.CodeGenerationOptions.GenerateProperties;
var @namespace = new CodeNamespace();
var compilationUnit = new CodeCompileUnit();
compilationUnit.Namespaces.Add(@namespace);
importer.Import(@namespace, compilationUnit);
var cSharpProvider = CodeDomProvider.CreateProvider("C#");
var parms = new CompilerParameters(new[]
{ "System.dll", "System.Web.Services.dll", "System.Web.dll", "System.Xml.dll", "System.Data.dll" })
{
GenerateInMemory = true
};
var results = cSharpProvider.CompileAssemblyFromDom(parms, compilationUnit);
var assembly = results.CompiledAssembly;
if (results.Errors.Count > 0)
{
}
return(assembly);
}
/// <summary>
/// Gerar a estrutura e o grafo da classe
/// </summary>
private CodeNamespace GerarGrafo()
{
#region Gerar a estrutura da classe do serviço
//Gerar a estrutura da classe do serviço
ServiceDescriptionImporter importer = new ServiceDescriptionImporter();
importer.AddServiceDescription(this.serviceDescription, string.Empty, string.Empty);
//Definir o nome do protocolo a ser utilizado
//Não posso definir, tenho que deixar por conta do WSDL definir, ou pode dar erro em alguns estados
//importer.ProtocolName = "Soap12";
//importer.ProtocolName = "Soap";
//Tipos deste serviço devem ser gerados como propriedades e não como simples campos
importer.CodeGenerationOptions = CodeGenerationOptions.GenerateProperties;
#endregion
#region Gerar o o grafo da classe para depois gerar o código
CodeNamespace @namespace = new CodeNamespace();
CodeCompileUnit unit = new CodeCompileUnit();
unit.Namespaces.Add(@namespace);
ServiceDescriptionImportWarnings warmings = importer.Import(@namespace, unit);
#endregion
return(@namespace);
}
/// <summary>
/// 使用CodeDom编译客户端代理类
/// </summary>
/// <param name="connection">WebService数据源提供程序的连接类的实例</param>
protected CommandBase(Connection connection)
{
Connection = connection;
//如果还没有获取服务说明则先获取服务说明
if (connection.ServiceDescription == null)
{
connection.LoadServiceDescription();
}
//创建客户端代理类
var serviceDescriptionImporter = new ServiceDescriptionImporter
{
ProtocolName = "Soap", // 指定访问协议。
Style = ServiceDescriptionImportStyle.Client, // 生成客户端代理
CodeGenerationOptions = CodeGenerationOptions.GenerateProperties //| CodeGenerationOptions.GenerateNewAsync
};
serviceDescriptionImporter.AddServiceDescription(connection.ServiceDescription, null, null); // 添加 WSDL 文档
//使用CodeDom编译客户端代理类
var codeNamespace = new CodeNamespace(); // 为代理类添加命名空间，缺省为全局空间
CodeCompileUnit = new CodeCompileUnit();
CodeCompileUnit.Namespaces.Add(codeNamespace);
serviceDescriptionImporter.Import(codeNamespace, CodeCompileUnit);
}
/// <summary>
/// 得到WSDL信息，生成本地代理类并编译为DLL
/// </summary>
private void CreateServiceAssembly()
{
if (this.checkCache())
{
this.initTypeName();
return;
}
if (string.IsNullOrEmpty(this._wsdlUrl))
{
return;
}
try
{
//使用WebClient下载WSDL信息
WebClient web = new WebClient();
Stream stream = web.OpenRead(this._wsdlUrl);
ServiceDescription description = ServiceDescription.Read(stream);//创建和格式化WSDL文档
stream.Close();
web.Dispose();
ServiceDescriptionImporter importer = new ServiceDescriptionImporter(); //创建客户端代理代理类
importer.ProtocolName = "Soap";
importer.Style = ServiceDescriptionImportStyle.Client; //生成客户端代理
importer.CodeGenerationOptions = CodeGenerationOptions.GenerateProperties | CodeGenerationOptions.GenerateNewAsync;
importer.AddServiceDescription(description, null, null); //添加WSDL文档
//使用CodeDom编译客户端代理类
CodeNamespace nmspace = new CodeNamespace(_assName); //为代理类添加命名空间
CodeCompileUnit unit = new CodeCompileUnit();
unit.Namespaces.Add(nmspace);
this.checkForImports(this._wsdlUrl, importer);
ServiceDescriptionImportWarnings warning = importer.Import(nmspace, unit);
CodeDomProvider provider = CodeDomProvider.CreateProvider("CSharp");
CompilerParameters parameter = new CompilerParameters();
parameter.ReferencedAssemblies.Add("System.dll");
parameter.ReferencedAssemblies.Add("System.XML.dll");
parameter.ReferencedAssemblies.Add("System.Web.Services.dll");
parameter.ReferencedAssemblies.Add("System.Data.dll");
parameter.GenerateExecutable = false;
parameter.GenerateInMemory = false;
parameter.IncludeDebugInformation = false;
CompilerResults result = provider.CompileAssemblyFromDom(parameter, unit);
provider.Dispose();
if (result.Errors.HasErrors)
{
string errors = string.Format(@"编译错误:{0}错误！", result.Errors.Count);
foreach (CompilerError error in result.Errors)
{
errors += error.ErrorText;
}
throw new Exception(errors);
}
this.copyTempAssembly(result.PathToAssembly);
this.initTypeName();
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
/// <summary>
/// 创建一个调用webservice的本地代理DLL
/// </summary>
/// <param name="url"></param>
public static void CreateWebServiceDLL()
{
string smsfile = HttpContext.Current.Server.MapPath("~") + "dll" + "\\SMSWebservice.dll";
if (!File.Exists(smsfile))
{
return;
}
try
{
string url = smsWSDL;
url = url.ToUpper().Contains("?WSDL") ? url : (url + "?WSDL");
// 1. 使用 WebClient 下载 WSDL 信息。
WebClient web = new WebClient();
Stream stream = web.OpenRead(url);
// 2. 创建和格式化 WSDL 文档。
ServiceDescription description = ServiceDescription.Read(stream);
// 3. 创建客户端代理代理类。
ServiceDescriptionImporter importer = new ServiceDescriptionImporter();
importer.ProtocolName = "Soap"; // 指定访问协议。
importer.Style = ServiceDescriptionImportStyle.Client; // 生成客户端代理。
importer.CodeGenerationOptions = CodeGenerationOptions.GenerateProperties | CodeGenerationOptions.GenerateNewAsync;
importer.AddServiceDescription(description, null, null); // 添加 WSDL 文档。
// 4. 使用 CodeDom 编译客户端代理类。
CodeNamespace nmspace = new CodeNamespace(); // 为代理类添加命名空间，缺省为全局空间。
CodeCompileUnit unit = new CodeCompileUnit();
unit.Namespaces.Add(nmspace);
ServiceDescriptionImportWarnings warning = importer.Import(nmspace, unit);
CodeDomProvider provider = CodeDomProvider.CreateProvider("CSharp");
CompilerParameters parameter = new CompilerParameters();
parameter.GenerateExecutable = false;
string file = HttpContext.Current.Server.MapPath("~") + "dll";
if (!Directory.Exists(file))
{
Directory.CreateDirectory(file);
}
parameter.OutputAssembly = file + "\\SMSWebservice.dll"; // 可以指定你所需的任何文件名。
parameter.ReferencedAssemblies.Add("System.dll");
parameter.ReferencedAssemblies.Add("System.XML.dll");
parameter.ReferencedAssemblies.Add("System.Web.Services.dll");
parameter.ReferencedAssemblies.Add("System.Data.dll");
CompilerResults result = provider.CompileAssemblyFromDom(parameter, unit);
if (result.Errors.HasErrors)
{
// 显示编译错误信息
System.Text.StringBuilder sb = new StringBuilder();
foreach (CompilerError ce in result.Errors)
{
sb.Append(ce.ToString());
sb.Append(System.Environment.NewLine);
}
throw new Exception(sb.ToString());
}
}
catch (Exception ex)
{
throw ex;
}
}
public static Type GetWsProxyType(string wsUrl, string classname)
{
string name = "CJBasic.WebService.DynamicWebCalling";
if ((classname == null) || (classname == ""))
{
classname = GetWsClassName(wsUrl);
}
string key = wsUrl + "@" + classname;
if (WSProxyTypeDictionary.ContainsKey(key))
{
return(WSProxyTypeDictionary[key]);
}
WebClient client = new WebClient();
ServiceDescription serviceDescription = ServiceDescription.Read(client.OpenRead(wsUrl + "?WSDL"));
ServiceDescriptionImporter importer = new ServiceDescriptionImporter();
importer.AddServiceDescription(serviceDescription, "", "");
CodeNamespace namespace2 = new CodeNamespace(name);
CodeCompileUnit codeCompileUnit = new CodeCompileUnit();
codeCompileUnit.Namespaces.Add(namespace2);
importer.Import(namespace2, codeCompileUnit);
CSharpCodeProvider provider = new CSharpCodeProvider();
CompilerParameters options = new CompilerParameters();
options.GenerateExecutable = false;
options.GenerateInMemory = true;
options.ReferencedAssemblies.Add("System.dll");
options.ReferencedAssemblies.Add("System.XML.dll");
options.ReferencedAssemblies.Add("System.Web.Services.dll");
options.ReferencedAssemblies.Add("System.Data.dll");
CompilerResults results = provider.CompileAssemblyFromDom(options, new CodeCompileUnit[] { codeCompileUnit });
if (results.Errors.HasErrors)
{
StringBuilder builder = new StringBuilder();
foreach (CompilerError error in results.Errors)
{
builder.Append(error.ToString());
builder.Append(Environment.NewLine);
}
throw new Exception(builder.ToString());
}
Assembly compiledAssembly = results.CompiledAssembly;
Type[] types = compiledAssembly.GetTypes();
Type type = compiledAssembly.GetType(name + "." + classname, true, true);
lock (WSProxyTypeDictionary)
{
if (!WSProxyTypeDictionary.ContainsKey(key))
{
WSProxyTypeDictionary.Add(key, type);
}
}
return(type);
}
/// <summary>
/// 获取webService远程对象
/// </summary>
/// <param name="url"></param>
/// <param name="classname"></param>
/// <returns></returns>
public static object GetWebServiceClassObject(string url, string classname)
{
string @namespace = "ServiceBase.WebService.DynamicWebLoad";
if (string.IsNullOrWhiteSpace(classname))
{
classname = GetClassName(url);
}
if (!url.EndsWith("?WSDL", StringComparison.OrdinalIgnoreCase))
{
url = url + "?WSDL";
}
///动态调用类所执行的过程
//1.获取服务描述语言(WSDL)
WebClient wc = new WebClient();
Stream stream = wc.OpenRead(url);
ServiceDescription sd = ServiceDescription.Read(stream); //设置Web服务描述语言
ServiceDescriptionImporter sdi = new ServiceDescriptionImporter(); //生成客户端代理类
sdi.AddServiceDescription(sd, "", "");
CodeNamespace cn = new CodeNamespace(@namespace); //声明命名空间
//2.生成客户端代理类代码
CodeCompileUnit ccu = new CodeCompileUnit(); //为CodeDOM程序图形提供容器
ccu.Namespaces.Add(cn); //获取命名空间集合
sdi.Import(cn, ccu);
CSharpCodeProvider csc = new CSharpCodeProvider(); //提供对 C# 代码生成器和代码编译器的实例的访问
//ICodeCompiler icc = csc.CreateCompiler();//定义用于调用源代码编译的接口或使用指定编译器的 CodeDOM 树
//3.设定编译器的参数
CompilerParameters cplist = new CompilerParameters();
cplist.GenerateExecutable = false; //设置是否为可执行文件
cplist.GenerateInMemory = true; //设置是否在内存中生成输出
cplist.ReferencedAssemblies.Add("System.dll");
cplist.ReferencedAssemblies.Add("System.XML.dll");
cplist.ReferencedAssemblies.Add("System.Web.Services.dll");
cplist.ReferencedAssemblies.Add("System.Data.dll");
//4.编译代理类
CompilerResults cr = csc.CompileAssemblyFromDom(cplist, ccu);// icc.CompileAssemblyFromDom(cplist, ccu);//使用指定的编译器设置编译程序集
if (true == cr.Errors.HasErrors)
{
System.Text.StringBuilder sb = new StringBuilder();
foreach (CompilerError ce in cr.Errors)
{
sb.Append(ce.ToString());
sb.Append(System.Environment.NewLine);
}
throw new Exception(sb.ToString());
}
//5.生成代理实例,并调用方法
System.Reflection.Assembly assembly = cr.CompiledAssembly; //获取或设置已编译的程序集
Type t = assembly.GetType(@namespace + "." + classname, true, true);
object obj = Activator.CreateInstance(t); //为 COM 对象提供对方法的版本无关的访问
return(obj);
}
/// <summary>
/// 动态调用WebService
/// </summary>
/// <param name="url">WebService地址</param>
/// <param name="classname">类名</param>
/// <param name="methodname">方法名(模块名)</param>
/// <param name="args">参数列表</param>
/// <returns>object</returns>
public static object InvokeWebService(string url, string classname, string methodname, object[] args)
{
string @namespace = "WebService.webservice";
if (classname == null || classname == "")
{
classname = WebServiceHelper.GetClassName(url);
}
WebClient wc = new WebClient();
Stream stream = wc.OpenRead(url + "?WSDL"); //获取服务描述语言(WSDL)
ServiceDescription sd = ServiceDescription.Read(stream); //通过直接从 Stream实例加载 XML 来初始化ServiceDescription类的实例。
ServiceDescriptionImporter sdi = new ServiceDescriptionImporter();
sdi.AddServiceDescription(sd, "", "");
CodeNamespace cn = new CodeNamespace(@namespace); //CodeNamespace表示命名空间声明。
//生成客户端代理类代码
CodeCompileUnit ccu = new CodeCompileUnit();
ccu.Namespaces.Add(cn);
sdi.Import(cn, ccu);
//CSharpCodeProvider csc = new CSharpCodeProvider();
//ICodeCompiler icc = csc.CreateCompiler();//取得C#程式码编译器的执行个体
CSharpCodeProvider icc = new CSharpCodeProvider();
//设定编译器的参数
CompilerParameters cplist = new CompilerParameters();//创建编译器的参数实例
cplist.GenerateExecutable = false;
cplist.GenerateInMemory = true;
cplist.ReferencedAssemblies.Add("System.dll");
cplist.ReferencedAssemblies.Add("System.XML.dll");
cplist.ReferencedAssemblies.Add("System.Web.Services.dll");
cplist.ReferencedAssemblies.Add("System.Data.dll");
//编译代理类
CompilerResults cr = icc.CompileAssemblyFromDom(cplist, ccu);
if (true == cr.Errors.HasErrors)
{
System.Text.StringBuilder sb = new StringBuilder();
foreach (CompilerError ce in cr.Errors)
{
sb.Append(ce.ToString());
sb.Append(System.Environment.NewLine);
}
throw new Exception(sb.ToString());
}
//生成代理实例,并调用方法
System.Reflection.Assembly assembly = cr.CompiledAssembly;
Type t = assembly.GetType(@namespace + "." + classname, true, true);
object obj = Activator.CreateInstance(t);
System.Reflection.MethodInfo mi = t.GetMethod(methodname);//MethodInfo 的实例可以通过调用GetMethods或者Type对象或派生自Type的对象的GetMethod方法来获取，还可以通过调用表示泛型方法定义的 MethodInfo 的MakeGenericMethod方法来获取。
return(mi.Invoke(obj, args));
}
/// <summary>
/// 动态调用WebService
/// </summary>
/// <param name="url">WebService地址</param>
/// <param name="classname">类名</param>
/// <param name="methodname">方法名(模块名)</param>
/// <param name="args">参数列表</param>
/// <returns>object</returns>
public static object InvokeWebService(string url, string classname, string methodname, object[] args)
{
string @namespace = "fangqm.Netbank.WebService.webservice";
if (classname == null || classname == "")
{
classname = WebServiceHelper.GetClassName(url);
}
//获取服务描述语言(WSDL)
WebClient wc = new WebClient();
Stream stream = wc.OpenRead(url + "?WSDL"); //【1】
ServiceDescription sd = ServiceDescription.Read(stream); //【2】
ServiceDescriptionImporter sdi = new ServiceDescriptionImporter(); //【3】
sdi.AddServiceDescription(sd, "", "");
CodeNamespace cn = new CodeNamespace(@namespace);//【4】
//生成客户端代理类代码
CodeCompileUnit ccu = new CodeCompileUnit();//【5】
ccu.Namespaces.Add(cn);
sdi.Import(cn, ccu);
CSharpCodeProvider csc = new CSharpCodeProvider(); //【6】
CodeDomProvider icc = CodeDomProvider.CreateProvider("CSharp"); //【7】
//设定编译器的参数
CompilerParameters cplist = new CompilerParameters();//【8】
cplist.GenerateExecutable = false;
cplist.GenerateInMemory = true;
cplist.ReferencedAssemblies.Add("System.dll");
cplist.ReferencedAssemblies.Add("System.XML.dll");
cplist.ReferencedAssemblies.Add("System.Web.Services.dll");
cplist.ReferencedAssemblies.Add("System.Data.dll");
//编译代理类
CompilerResults cr = icc.CompileAssemblyFromDom(cplist, ccu);//【9】
if (true == cr.Errors.HasErrors)
{
System.Text.StringBuilder sb = new StringBuilder();
foreach (CompilerError ce in cr.Errors)
{
sb.Append(ce.ToString());
sb.Append(System.Environment.NewLine);
}
throw new Exception(sb.ToString());
}
//生成代理实例,并调用方法
System.Reflection.Assembly assembly = cr.CompiledAssembly;
Type t = assembly.GetType(@namespace + "." + classname, true, true);
object obj = Activator.CreateInstance(t); //【10】
System.Reflection.MethodInfo mi = t.GetMethod(methodname); //【11】
return(mi.Invoke(obj, args));
}
/// < summary>
/// 动态调用web服务
/// < /summary>
/// < param name="url">WSDL服务地址< /param>
/// < param name="classname">类名< /param>
/// < param name="methodname">方法名< /param>
/// < param name="args">参数< /param>
/// < returns>< /returns>
public object InvokeWebService(string url, string classname, string methodname, object arg)
{
string @namespace = "EnterpriseServerBase.WebService.DynamicWebCalling";
try
{
//获取WSDL
WebClient wc = new WebClient();
if (!url.ToUpper().Contains("WSDL"))
{
url = string.Format("{0}?{1}", url, "WSDL");
}
Stream stream = wc.OpenRead(url);
ServiceDescription sd = ServiceDescription.Read(stream);
ServiceDescriptionImporter sdi = new ServiceDescriptionImporter();
sdi.AddServiceDescription(sd, "", "");
CodeNamespace cn = new CodeNamespace(@namespace);
//生成客户端代理类代码
CodeCompileUnit ccu = new CodeCompileUnit();
ccu.Namespaces.Add(cn);
sdi.Import(cn, ccu);
CSharpCodeProvider icc = new CSharpCodeProvider();
//设定编译参数
CompilerParameters cplist = new CompilerParameters();
cplist.GenerateExecutable = false;
cplist.GenerateInMemory = true;
cplist.ReferencedAssemblies.Add("System.dll");
cplist.ReferencedAssemblies.Add("System.XML.dll");
cplist.ReferencedAssemblies.Add("System.Web.Services.dll");
cplist.ReferencedAssemblies.Add("System.Data.dll");
//编译代理类
CompilerResults cr = icc.CompileAssemblyFromDom(cplist, ccu);
if (true == cr.Errors.HasErrors)
{
System.Text.StringBuilder sb = new System.Text.StringBuilder();
foreach (CompilerError ce in cr.Errors)
{
sb.Append(ce.ToString());
sb.Append(Environment.NewLine);
}
throw new Exception(sb.ToString());
}
//生成代理实例，并调用方法
System.Reflection.Assembly assembly = cr.CompiledAssembly;
Type t = assembly.GetType(@namespace + "." + classname, true, true);
object obj = Activator.CreateInstance(t);
System.Reflection.MethodInfo mi = t.GetMethod(methodname);
//设置WebService超时时间
((System.Web.Services.Protocols.WebClientProtocol)(obj)).Timeout = this.outTime;
var jsonStr = JsonConvert.SerializeObject(arg);
var miParType = mi.GetParameters()[0].ParameterType;
return(mi.Invoke(obj, new object[] { JsonConvert.DeserializeObject(jsonStr, miParType) }));
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// 动态调用WebService（基于反射）
/// </summary>
/// <param name="url">WebService地址</param>
/// <param name="classname">类名</param>
/// <param name="methodname">方法名</param>
/// <param name="args">参数列表</param>
/// <returns>调用接口的返回值</returns>
public static object InvokeWebService(string url, string classname, string methodname, object[] args)
{
string @namespace = "ServiceBase.WebService.DynamicWebLoad";
if (string.IsNullOrWhiteSpace(classname))
{
classname = GetClassName(url);
}
//获取服务描述语言(WSDL)
WebClient wc = new WebClient();
ServiceDescription sd;
using (Stream stream = wc.OpenRead(url + "?WSDL"))
{
sd = ServiceDescription.Read(stream);
}
ServiceDescriptionImporter sdi = new ServiceDescriptionImporter();
sdi.AddServiceDescription(sd, "", "");
CodeNamespace cn = new CodeNamespace(@namespace);
//生成客户端代码类代码
CodeCompileUnit ccu = new CodeCompileUnit();
ccu.Namespaces.Add(cn);
sdi.Import(cn, ccu);
CodeDomProvider csc = new CSharpCodeProvider();
//ICodeCompiler icc = csc.CreateCompiler();
//设定编译器的参数
CompilerParameters cplist = new CompilerParameters
{
GenerateExecutable = false,
GenerateInMemory = true
};
cplist.ReferencedAssemblies.Add("System.dll");
cplist.ReferencedAssemblies.Add("System.XML.dll");
cplist.ReferencedAssemblies.Add("System.Web.Services.dll");
cplist.ReferencedAssemblies.Add("System.Data.dll");
//编译代理类
CompilerResults cr = csc.CompileAssemblyFromDom(cplist, ccu);//icc.CompileAssemblyFromDom(cplist, ccu);
if (cr.Errors.HasErrors)
{
StringBuilder sb = new StringBuilder();
foreach (CompilerError ce in cr.Errors)
{
sb.Append(ce.ToString() + Environment.NewLine);
}
throw new Exception(sb.ToString());
}
// 生成代理实例并调用方法
Assembly assembly = cr.CompiledAssembly;
Type t = assembly.GetType(@namespace + "." + classname, true, true);
object obj = Activator.CreateInstance(t);
MethodInfo mi = t.GetMethod(methodname);
return(mi?.Invoke(obj, args));
}
private Assembly CompileAssembly(ServiceDescriptionImporter serviceImporter, bool inMemory = true)
{
if (serviceImporter == null)
{
return(null);
}
// Initialize a Code-DOM tree into which we will import the service.
var compileUnit = new CodeCompileUnit();
var nameSpace = new CodeNamespace();
compileUnit.Namespaces.Add(nameSpace);
// Import the service into the Code-DOM tree. This creates proxy code that uses the service.
var warnings = serviceImporter.Import(nameSpace, compileUnit);
if (warnings == 0)
{
// create a c# compiler
var codeProvider = CodeDomProvider.CreateProvider("CSharp");
// include the assembly references needed to compile
var parameters = new CompilerParameters();
parameters.ReferencedAssemblies.Add("System.dll");
parameters.ReferencedAssemblies.Add("System.Web.Services.dll");
parameters.ReferencedAssemblies.Add("System.Web.dll");
parameters.ReferencedAssemblies.Add("System.Xml.dll");
parameters.ReferencedAssemblies.Add("System.Data.dll");
// parameters.OutputAssembly = "";
parameters.GenerateExecutable = !inMemory;
parameters.GenerateInMemory = inMemory;
parameters.TreatWarningsAsErrors = false;
parameters.WarningLevel = 4;
// compile into assembly
var results = codeProvider.CompileAssemblyFromDom(parameters, compileUnit);
// Check For Errors
if (results.Errors.Count > 0)
{
var errorText = "";
var i = 1;
foreach (CompilerError error in results.Errors)
{
errorText += "Error (" + i + "): " + error.ErrorText + Environment.NewLine;
i++;
}
throw new Exception(string.Format("Error on compiling proxy assembly for service '{0}'", this.ServiceUrl) + Environment.NewLine + errorText);
}
return(results.CompiledAssembly);
}
else
{
return(null);
}
}
///// <summary>
///// 获取地址
///// </summary>
///// <param name="lab"></param>
///// <returns></returns>
//public static string getURL(string lab)
//{
// string URL = string.Empty;
// bool IsExist = ConfigurationSettings.AppSettings.AllKeys.Contains(lab);
// if (IsExist)
// {
// URL = ConfigurationSettings.AppSettings[lab];
// }
// return URL;
//}
///// <summary>
///// 执行各地webservice方法
///// </summary>
///// <param name="lab"></param>
///// <returns></returns>
//public static string Execute(string lab, string methodname, object[] obj)
//{
// if (lab == string.Empty) { return ErrorCode.Login_1001; }
// string url = getURL(lab);
// if (url == string.Empty)
// {
// return string.Format(ErrorCode.Login_1002 + " 分点代码[ {0} ]！", lab);
// }
// return InvokeWebservice(url, "LISWebService", "LISService", methodname, obj).ToString();
//}
/// <summary>
/// 根据指定的信息，调用远程WebService方法
/// </summary>
/// <param name="url">WebService的http形式的地址</param>
/// <param name="namespace">欲调用的WebService的命名空间</param>
/// <param name="classname">欲调用的WebService的类名（不包括命名空间前缀）</param>
/// <param name="methodname">欲调用的WebService的方法名</param>
/// <param name="args">参数列表</param>
/// <returns>WebService的执行结果</returns>
/// <remarks>
/// 如果调用失败，将会抛出Exception。请调用的时候，适当截获异常。
/// 异常信息可能会发生在两个地方：
/// 1、动态构造WebService的时候，CompileAssembly失败。
/// 2、WebService本身执行失败。
/// </remarks>
/// <example>
/// <code>
/// object obj = InvokeWebservice("http://localhost/GSP_WorkflowWebservice/common.asmx","Genersoft.Platform.Service.Workflow","Common","GetToolType",new object[]{"1"});
/// </code>
/// </example>
public static object InvokeWebservice(string url, string @namespace, string classname, string methodname, object[] args)
{
WebClient wc = null;
Stream stream = null;
try
{
wc = new WebClient();
stream = wc.OpenRead(url + "?WSDL");
ServiceDescription sd = ServiceDescription.Read(stream);
ServiceDescriptionImporter sdi = new ServiceDescriptionImporter();
sdi.AddServiceDescription(sd, "", "");
CodeNamespace cn = new CodeNamespace(@namespace);
CodeCompileUnit ccu = new CodeCompileUnit();
ccu.Namespaces.Add(cn);
sdi.Import(cn, ccu);
CSharpCodeProvider csc = new CSharpCodeProvider();
//CodeDomProvider icc = csc.crete;
CompilerParameters cplist = new CompilerParameters();
cplist.GenerateExecutable = false;
cplist.GenerateInMemory = true;
cplist.ReferencedAssemblies.Add("System.dll");
cplist.ReferencedAssemblies.Add("System.XML.dll");
cplist.ReferencedAssemblies.Add("System.Web.Services.dll");
cplist.ReferencedAssemblies.Add("System.Data.dll");
CompilerResults cr = CodeDomProvider.CreateProvider("C#").CompileAssemblyFromDom(cplist, ccu);
if (true == cr.Errors.HasErrors)
{
StringBuilder sb = new StringBuilder();
foreach (CompilerError ce in cr.Errors)
{
sb.Append(ce.ToString());
sb.Append(System.Environment.NewLine);
}
throw new Exception(sb.ToString());
}
Assembly assembly = cr.CompiledAssembly;
Type t = assembly.GetType(@namespace + "." + classname, true, true);
object obj = Activator.CreateInstance(t);
MethodInfo mi = t.GetMethod(methodname);
csc.Dispose();
return(mi.Invoke(obj, args));
}
catch (Exception ex)
{
return(string.Format(" {0} \r\n 请求地址：[ {1} ] \r\n {2}", ex.Message, url, ex.InnerException == null ? "" : ex.InnerException.Message));
}
finally
{
stream.Close();
wc.Dispose();
GC.Collect();
}
}
public bool SetWebServiceInstance(string webServiceAsmxUrl, string serviceName)
{
bool success = false;
string lastStep = "";
try
{
LastError = "";
lastStep = "Getting web service description/specification";
WebClient client = new WebClient();
Stream stream = client.OpenRead(webServiceAsmxUrl + "?wsdl");
ServiceDescription description = ServiceDescription.Read(stream);
ServiceDescriptionImporter importer = new ServiceDescriptionImporter();
//ServiceContractGenerator
importer.ProtocolName = "Soap12";
importer.AddServiceDescription(description, null, null);
importer.Style = ServiceDescriptionImportStyle.Client;
importer.CodeGenerationOptions = System.Xml.Serialization.CodeGenerationOptions.GenerateProperties;
CodeNamespace nmspace = new CodeNamespace();
CodeCompileUnit unit1 = new CodeCompileUnit();
unit1.Namespaces.Add(nmspace);
ServiceDescriptionImportWarnings warning = importer.Import(nmspace, unit1);
if (warning == 0)
{
CodeDomProvider provider1 = CodeDomProvider.CreateProvider("CSharp");
string[] assemblyReferences = new string[] { "System.dll",
"System.Web.Services.dll", "System.Web.dll",
"System.Xml.dll", "System.Data.dll" };
CompilerParameters parms = new CompilerParameters(assemblyReferences);
parms.GenerateInMemory = true;
CompilerResults results = provider1.CompileAssemblyFromDom(parms, unit1);
if (results.Errors.Count > 0)
{
foreach (CompilerError oops in results.Errors)
{
System.Diagnostics.Debug.WriteLine("========Compiler error============");
System.Diagnostics.Debug.WriteLine(oops.ErrorText);
}
throw new System.Exception("Compile Error Occurred calling webservice.");
}
lastStep = "Creating instance of web service client";
WebServiceInstance = results.CompiledAssembly.CreateInstance(serviceName);
success = true;
}
else
{
LastError = string.Format("ServiceDescriptionImporter returned {0}", warning);
}
}
catch (Exception ex)
{
LastError = string.Format("Last step: {0}\r\n{1}", lastStep, ex.ToString());
}
return(success);
}
public static void DisplayWarning(string myWSDLFileName)
{
// <Snippet1>
String myDisplay;
// Read wsdl file.
ServiceDescription myServiceDescription = ServiceDescription.Read
(myWSDLFileName);
ServiceDescriptionImporter myServiceDescriptionImporter = new
ServiceDescriptionImporter();
// Add 'myServiceDescription' to 'myServiceDescriptionImporter'.
myServiceDescriptionImporter.AddServiceDescription
(myServiceDescription, "", "");
myServiceDescriptionImporter.ProtocolName = "HttpGet";
CodeNamespace myCodeNamespace = new CodeNamespace();
CodeCompileUnit myCodeCompileUnit = new CodeCompileUnit();
// Invoke 'Import' method.
ServiceDescriptionImportWarnings myWarning =
myServiceDescriptionImporter.Import(myCodeNamespace,
myCodeCompileUnit);
switch (myWarning)
{
case ServiceDescriptionImportWarnings.NoCodeGenerated:
myDisplay = "NoCodeGenerated";
break;
case ServiceDescriptionImportWarnings.NoMethodsGenerated:
myDisplay = "NoMethodsGenerated";
break;
case ServiceDescriptionImportWarnings.UnsupportedOperationsIgnored:
myDisplay = "UnsupportedOperationsIgnored";
break;
case ServiceDescriptionImportWarnings.OptionalExtensionsIgnored:
myDisplay = "OptionalExtensionsIgnored";
break;
case ServiceDescriptionImportWarnings.RequiredExtensionsIgnored:
myDisplay = "RequiredExtensionsIgnored";
break;
case ServiceDescriptionImportWarnings.UnsupportedBindingsIgnored:
myDisplay = "UnsupportedBindingsIgnored";
break;
default:
myDisplay = "General Warning";
break;
}
Console.WriteLine("Warning : " + myDisplay);
// </Snippet1>
}
/// <summary>
/// 带服务地址构造函数
/// </summary>
/// <param name="serviceUrl">服务地址</param>
public CoreClient(string serviceUrl)
{
ServiceUrl = serviceUrl.TrimEnd('/');
try
{
//获取WSDL
var wc = new WebClient();
var stream = wc.OpenRead(ServiceUrl + "?WSDL");
wc.Dispose();
if (stream == null)
{
_type = null;
return;
}
var sd = ServiceDescription.Read(stream);
var classname = sd.Services[0].Name;
var sdi = new ServiceDescriptionImporter();
sdi.AddServiceDescription(sd, "", "");
var cn = new CodeNamespace();
//生成客户端代理类代码
var ccu = new CodeCompileUnit();
ccu.Namespaces.Add(cn);
sdi.Import(cn, ccu);
var csc = new CSharpCodeProvider();
//设定编译参数
var cplist = new CompilerParameters
{
GenerateExecutable = false,
GenerateInMemory = true
};
//动态编译后的程序集不生成可执行文件
//动态编译后的程序集只存在于内存中，不在硬盘的文件上
cplist.ReferencedAssemblies.Add("System.dll");
cplist.ReferencedAssemblies.Add("System.XML.dll");
cplist.ReferencedAssemblies.Add("System.Web.Services.dll");
cplist.ReferencedAssemblies.Add("System.Data.dll");
//编译代理类
var cr = csc.CompileAssemblyFromDom(cplist, ccu);
if (cr.Errors.HasErrors)
{
var sb = new StringBuilder();
foreach (CompilerError ce in cr.Errors)
{
sb.Append(ce);
sb.Append(Environment.NewLine);
}
throw new Exception(sb.ToString());
}
//生成代理实例，并调用方法
var assembly = cr.CompiledAssembly;
_type = assembly.GetType(classname, true, true);
}
catch (Exception e)
{
CoreLog.Error(e);
}
}
/// <summary>
/// 动态调用web服务
/// </summary>
/// <param name="url">WSDL服务地址</param>
/// <param name="classname">类名</param>
/// <param name="methodname">方法名</param>
/// <param name="args">参数</param>
/// <returns></returns>
public static object InvokeWebService(string url, string classname, string methodname, object[] args)
{
const string @namespace = "EnterpriseServerBase.WebService.DynamicWebCalling";
if (string.IsNullOrEmpty(classname))
{
classname = GetWsClassName(url);
}
try
{ //获取WSDL
var wc = new WebClient();
var stream = wc.OpenRead(url + "?WSDL");
if (stream != null)
{
var sd = ServiceDescription.Read(stream);
var sdi = new ServiceDescriptionImporter();
sdi.AddServiceDescription(sd, "", "");
var cn = new CodeNamespace(@namespace);
//生成客户端代理类代码
var ccu = new CodeCompileUnit();
ccu.Namespaces.Add(cn);
sdi.Import(cn, ccu);
var icc = new CSharpCodeProvider();
//设定编译参数
var cplist = new CompilerParameters {
GenerateExecutable = false, GenerateInMemory = true
};
cplist.ReferencedAssemblies.Add("System.dll");
cplist.ReferencedAssemblies.Add("System.XML.dll");
cplist.ReferencedAssemblies.Add("System.Web.Services.dll");
cplist.ReferencedAssemblies.Add("System.Data.dll");
//编译代理类
var cr = icc.CompileAssemblyFromDom(cplist, ccu);
if (cr.Errors.HasErrors)
{
var sb = new StringBuilder();
foreach (CompilerError ce in cr.Errors)
{
sb.Append(ce);
sb.Append(Environment.NewLine);
}
throw new Exception(sb.ToString());
}
//生成代理实例，并调用方法
var assembly = cr.CompiledAssembly;
var t = assembly.GetType(@namespace + "." + classname, true, true);
var obj = Activator.CreateInstance(t);
var mi = t.GetMethod(methodname);
return(mi.Invoke(obj, args));
}
return("");
}
catch (Exception ex)
{
throw new Exception(ex.InnerException.Message, new Exception(ex.InnerException.StackTrace));
}
}
/// <summary>
/// 调用WebService
/// </summary>
/// <param name="wsUrl">WebService地址</param>
/// <param name="className">类名</param>
/// <param name="methodName">方法名称</param>
/// <param name="hashtable">参数列表</param>
/// <returns></returns>
public static object InvokeWebService(string wsUrl, string className, string methodName, Hashtable hashtable)
{
object[] args = Hashtable2Object(hashtable);
const string @namespace = "EnterpriseServerBase.WebService.DynamicWebCalling";
if (string.IsNullOrEmpty(className))
{
className = GetClassName(wsUrl);
}
try
{
//获取WSDL
WebClient wc = new WebClient();
Stream stream = wc.OpenRead(wsUrl + "?wsdl");
ServiceDescription sd = ServiceDescription.Read(stream);
ServiceDescriptionImporter sdi = new ServiceDescriptionImporter();
sdi.AddServiceDescription(sd, "", "");
CodeNamespace cn = new CodeNamespace(@namespace);
//生成客户端代理类代码
CodeCompileUnit ccu = new CodeCompileUnit();
ccu.Namespaces.Add(cn);
sdi.Import(cn, ccu);
CSharpCodeProvider csc = new CSharpCodeProvider();
// ReSharper disable once CSharpWarnings::CS0618
ICodeCompiler icc = csc.CreateCompiler();
//设定编译参数
CompilerParameters cplist = new CompilerParameters {
GenerateExecutable = false, GenerateInMemory = true
};
cplist.ReferencedAssemblies.Add("System.dll");
cplist.ReferencedAssemblies.Add("System.XML.dll");
cplist.ReferencedAssemblies.Add("System.Web.Services.dll");
cplist.ReferencedAssemblies.Add("System.Data.dll");
//编译代理类
CompilerResults cr = icc.CompileAssemblyFromDom(cplist, ccu);
if (cr.Errors.HasErrors)
{
System.Text.StringBuilder sb = new System.Text.StringBuilder();
foreach (System.CodeDom.Compiler.CompilerError ce in cr.Errors)
{
sb.Append(ce);
sb.Append(System.Environment.NewLine);
}
throw new Exception(sb.ToString());
}
//生成代理实例，并调用方法
System.Reflection.Assembly assembly = cr.CompiledAssembly;
Type t = assembly.GetType(@namespace + "." + className, true, true);
object obj = Activator.CreateInstance(t);
System.Reflection.MethodInfo mi = t.GetMethod(methodName);
return(mi.Invoke(obj, args));
}
catch (Exception ex)
{
throw new Exception(ex.InnerException.Message, new Exception(ex.InnerException.StackTrace));
}
}
private int CreateServices(string wsdl_text)
{
Type service;
try
{
//Try Database Connection
SqlConnection conn = new SqlConnection(ConfigurationManager.ConnectionStrings["SAASDB"].ToString());
try
{
conn.Open();
}
catch (Exception e)
{
//Return Error
return -1;
}
localhost.Service serviceObj = new localhost.Service();
//Insert into Data Table the services
int count = 0;
List<string> fieldnames = new List<string>();
List<localhost.Field> fieldlist = new List<localhost.Field>();
localhost.Field[] fields = serviceObj.ReadField(11, 30);
fieldlist = new List<localhost.Field>(fields);
foreach (localhost.Field item in fieldlist)
{
fieldnames.Add(count.ToString());
count++;
}
Uri uri = new Uri(wsdl_text);
WebRequest webRequest = WebRequest.Create(uri);
System.IO.Stream requestStream = webRequest.GetResponse().GetResponseStream();
// Get a WSDL file describing a service
ServiceDescription sd = ServiceDescription.Read(requestStream);
string sdName = sd.Services[0].Name;
// Initialize a service description servImport
ServiceDescriptionImporter servImport = new ServiceDescriptionImporter();
servImport.AddServiceDescription(sd, String.Empty, String.Empty);
servImport.ProtocolName = "Soap";
servImport.CodeGenerationOptions = CodeGenerationOptions.GenerateProperties;
CodeNamespace nameSpace = new CodeNamespace();
CodeCompileUnit codeCompileUnit = new CodeCompileUnit();
codeCompileUnit.Namespaces.Add(nameSpace);
// Set Warnings
ServiceDescriptionImportWarnings warnings = servImport.Import(nameSpace, codeCompileUnit);
if (warnings == 0)
{
StringWriter stringWriter = new StringWriter(System.Globalization.CultureInfo.CurrentCulture);
Microsoft.CSharp.CSharpCodeProvider prov = new Microsoft.CSharp.CSharpCodeProvider();
prov.GenerateCodeFromNamespace(nameSpace, stringWriter, new CodeGeneratorOptions());
// Compile the assembly with the appropriate references
string[] assemblyReferences = new string[2] { "System.Web.Services.dll", "System.Xml.dll" };
CompilerParameters param = new CompilerParameters(assemblyReferences);
param.GenerateExecutable = false;
param.GenerateInMemory = true;
param.TreatWarningsAsErrors = false;
param.WarningLevel = 4;
CompilerResults results = new CompilerResults(new TempFileCollection());
results = prov.CompileAssemblyFromDom(param, codeCompileUnit);
Assembly assembly = results.CompiledAssembly;
service = assembly.GetType(sdName);
string input_params = "";
string return_type = "";
MethodInfo[] methodInfo = service.GetMethods();
foreach (MethodInfo t in methodInfo)
{
List<string> valueNames = new List<string>();
if (t.Name == "Discover")
break;
input_params = "";
return_type = "";
foreach (ParameterInfo parameter in t.GetParameters())
{
//paramname.Text = "(" + temp.ParameterType.Name + " " + temp.Name + ")";
input_params = input_params + parameter.Name + ":" + parameter.ParameterType.Name + " ";
}
//Get The Return type of the Service(Method)
return_type = t.ReturnType.ToString();
//Insert into Service Object(Methods Table)
valueNames.Add(Session["OrgID"].ToString());
valueNames.Add(wsdl_text);
valueNames.Add(t.Name);
valueNames.Add(input_params);
valueNames.Add(return_type);
bool success = serviceObj.InsertData(11, 30, "WSDL-Instance", fieldnames.ToArray(), valueNames.ToArray());
if (success == false)
{
return -1;
}
}
return 1;
}
else
{
return -1;
}
}
catch (Exception ex)
{
return -1;
}
}
void GetServiceDetails()
{
var url = Request["service"];
if (string.IsNullOrEmpty(url))
{
return;
}
if (!url.ToLowerInvariant().EndsWith("?wsdl"))
url += "?wsdl";
try
{
using (WebClient wc = new WebClient())
{
string content = wc.DownloadString(url);
var des = wc.DownloadString(url);
var sd = ServiceDescription.Read(new StringReader(des));
ServiceDescriptionImporter im = new ServiceDescriptionImporter();
im.AddServiceDescription(sd, null, null);
im.Style = ServiceDescriptionImportStyle.Client;
im.CodeGenerationOptions = CodeGenerationOptions.GenerateProperties;
CodeNamespace ns = new CodeNamespace();
CodeCompileUnit unit = new CodeCompileUnit();
unit.Namespaces.Add(ns);
ServiceDescriptionImportWarnings warning = im.Import(ns, unit);
if (warning == 0)
{
var domProvider = CodeDomProvider.CreateProvider("CSharp");
var assemblyReferences = new string[] { "System.Web.Services.dll", "System.Xml.dll" };
var parms = new CompilerParameters(assemblyReferences);
var results = domProvider.CompileAssemblyFromDom(parms, unit);
if (results.Errors.Count > 0)
{
Response.Output.WriteLine("{ 'error' : [");
foreach (CompilerError ce in results.Errors)
{
Response.Output.WriteLine("'{0}',", Utils.EscapeString(ce.ErrorText));
}
Response.Output.WriteLine("]}");
}
object o = results.CompiledAssembly.CreateInstance("WebService");
Type t = o.GetType();
}
else
{
Console.WriteLine("Warning: " + warning);
}
}
}
catch (Exception e)
{
Response.Output.WriteLine("{{ 'error' : '{0}' }}", Utils.EscapeString(e.Message));
}
}
private string InvokeMethod(string wsdl_text,string MethodName,Object[] param1)
{
try
{
Uri uri = new Uri(wsdl_text);
WebRequest webRequest = WebRequest.Create(uri);
System.IO.Stream requestStream = webRequest.GetResponse().GetResponseStream();
// Get a WSDL file describing a service
ServiceDescription sd = ServiceDescription.Read(requestStream);
string sdName = sd.Services[0].Name;
// Initialize a service description servImport
ServiceDescriptionImporter servImport = new ServiceDescriptionImporter();
servImport.AddServiceDescription(sd, String.Empty, String.Empty);
servImport.ProtocolName = "Soap";
servImport.CodeGenerationOptions = CodeGenerationOptions.GenerateProperties;
CodeNamespace nameSpace = new CodeNamespace();
CodeCompileUnit codeCompileUnit = new CodeCompileUnit();
codeCompileUnit.Namespaces.Add(nameSpace);
// Set Warnings
ServiceDescriptionImportWarnings warnings = servImport.Import(nameSpace, codeCompileUnit);
if (warnings == 0)
{
StringWriter stringWriter = new StringWriter(System.Globalization.CultureInfo.CurrentCulture);
Microsoft.CSharp.CSharpCodeProvider prov = new Microsoft.CSharp.CSharpCodeProvider();
prov.GenerateCodeFromNamespace(nameSpace, stringWriter, new CodeGeneratorOptions());
// Compile the assembly with the appropriate references
string[] assemblyReferences = new string[2] { "System.Web.Services.dll", "System.Xml.dll" };
CompilerParameters param = new CompilerParameters(assemblyReferences);
param.GenerateExecutable = false;
param.GenerateInMemory = true;
param.TreatWarningsAsErrors = false;
param.WarningLevel = 4;
CompilerResults results = new CompilerResults(new TempFileCollection());
results = prov.CompileAssemblyFromDom(param, codeCompileUnit);
Assembly assembly = results.CompiledAssembly;
service = assembly.GetType(sdName);
MethodInfo[] methodinfo = service.GetMethods();
string result = null;
foreach (MethodInfo t in methodinfo)
if (t.Name == MethodName)
{
//Invoke Method
Object obj = Activator.CreateInstance(service);
Object response = t.Invoke(obj, param1);
Array myArrayList = response as Array;
if (myArrayList != null)
{
List<Object> result_obj = new List<Object>();
foreach (var item in myArrayList)
{
foreach (var currentPropertyInformation in item.GetType().GetProperties())
{
//currentPropertyInformation.GetValue(item, null);
//Result.Text = Result.Text + currentPropertyInformation.Name + ":" + currentPropertyInformation.GetValue(item, null);
result = currentPropertyInformation.GetValue(item, null).ToString();
}
}
}
else if(response.GetType().ToString() != "System.String")
{
foreach (var currentPropertyInformation in response.GetType().GetProperties())
{
//currentPropertyInformation.GetValue(item, null);
//Result.Text = Result.Text + currentPropertyInformation.Name + ":" + currentPropertyInformation.GetValue(item, null);
if (currentPropertyInformation.GetValue(response, null) != null)
{
result = result + currentPropertyInformation.Name + ":" + currentPropertyInformation.GetValue(response, null) + "|";
}
else
{
result = result + currentPropertyInformation.Name + ":NULL,";
}
}
}
if(response!=null && result==null)
{
result = response.ToString();
}
break;
}
return result;
}
else
{
return null;
}
}
catch (Exception ex)
{
return null;
}
}
private void DynamicInvocation(string wsUrl, TreeView tv, ref MethodInfo[] methodInfo)
{
try
{
Uri uri = new Uri(wsUrl); //txtUrl.Text);
WebRequest webRequest = WebRequest.Create(uri);
System.IO.Stream requestStream = webRequest.GetResponse().GetResponseStream();
// Get a WSDL file describing a service
ServiceDescription sd = ServiceDescription.Read(requestStream);
string sdName = sd.Services[0].Name;
// Add in tree view
TreeNode n = new TreeNode(sdName);
tv.Nodes.Add(n);
//treMethods.Nodes.Add(n);
// Initialize a service description servImport
ServiceDescriptionImporter servImport = new ServiceDescriptionImporter();
servImport.AddServiceDescription(sd, String.Empty, String.Empty);
servImport.ProtocolName = "Soap";
servImport.CodeGenerationOptions = CodeGenerationOptions.GenerateProperties;
CodeNamespace nameSpace = new CodeNamespace();
CodeCompileUnit codeCompileUnit = new CodeCompileUnit();
codeCompileUnit.Namespaces.Add(nameSpace);
// Set Warnings
ServiceDescriptionImportWarnings warnings = servImport.Import(nameSpace, codeCompileUnit);
if (warnings == 0)
{
StringWriter stringWriter = new StringWriter(System.Globalization.CultureInfo.CurrentCulture);
Microsoft.CSharp.CSharpCodeProvider prov = new Microsoft.CSharp.CSharpCodeProvider();
prov.GenerateCodeFromNamespace(nameSpace, stringWriter, new CodeGeneratorOptions());
// Compile the assembly with the appropriate references
string[] assemblyReferences = new string[2] { "System.Web.Services.dll", "System.Xml.dll" };
CompilerParameters par = new CompilerParameters(assemblyReferences);
par.GenerateExecutable = false;
par.GenerateInMemory = true;
par.TreatWarningsAsErrors = false;
par.WarningLevel = 4;
CompilerResults results = new CompilerResults(new TempFileCollection());
results = prov.CompileAssemblyFromDom(par, codeCompileUnit);
Assembly assembly = results.CompiledAssembly;
service = assembly.GetType(sdName);
methodInfo = service.GetMethods();
foreach (MethodInfo t in methodInfo)
{
if (t.Name == "Discover")
break;
n = new TreeNode(t.Name);
tv.Nodes[0].ChildNodes.Add(n);
}
tv.Nodes[0].Expand();
}
else
lblMsg.Text += warnings;
}
catch (Exception ex)
{
lblMsg.Text += "\r\n" + ex.Message + "\r\n\r\n" + ex.ToString(); ;
}
}
