asp.net中编写 windows 服务程序如何调用

发布网友 发布时间：2022-04-27 06:10

我来回答

共3个回答

懂视网 时间：2022-05-19 18:38

    动态编译与WS服务，有关系么？今天就乱弹一番，如何使用动态编译动态生成WS服务调用的代理类，然后通过这个代理类调用WS服务。
    首先，动态编译这玩意在.NET里面是非常简单的，实际上只涉及到两个类型：CodeDomProvider以及CompilerParameters他们都位于System.CodeDom.Compiler命名空间。
    以下代码可将源码动态编译为一个程序集：
动态编译
代码如下:
CodeDomProvider provider = CodeDomProvider.CreateProvider("CSharp");
CompilerParameters codeParameters = new CompilerParameters();
codeParameters.GenerateExecutable = false; //编译为dll，如果为true则编译为exe
codeParameters.GenerateInMemory = true; //编译后的程序集保存到内存中
StringBuilder code = new StringBuilder();
//此处构造源代码
CompilerResults results = provider.CompileAssemblyFromSource(codeParameters, code.ToString());
Assembly assembly = null; //动态编译生成的程序集
if (!results.Errors.HasErrors)
{
    assembly = results.CompiledAssembly;
}

    获得assembly后，随后我们即可以通过反射获取程序集里面的类型，然后实例化，调用类型方法…
    不过在此之前，我们得构造WS服务的代理类，它是什么样子的呢？我们使用WCF框架，创建服务代理类也是十分简单的，常见的代理类结构如下：
服务调用代理类
代码如下:
[ServiceContract(Namespace="//www.gxlcms.com/")]
public interface TestService
{
    [OperationContract(Action = "//www.gxlcms.com/HelloWorld", ReplyAction = "//www.gxlcms.com/HelloWorldResponse")]
    string HelloWorld();
}
public class TestServiceClient : ClientBase<TestService>, TestService
{
    public TestServiceClient(Binding binding, EndpointAddress address) :
        base(binding, address)
    {
    }
    public string HelloWorld()
    {
        return base.Channel.HelloWorld();
    }
}

    所以，我们要动态构造出代理类源码，应该知道服务的命名空间、服务方法的Action地址、ReplyAction地址，当然还有服务方法的名称，返回类型，参数列表。这里，我们省略掉服务方法的参数列表，构造代理类，实际上就是一个字符串组装的问题，先创建一个类型，用于保存构造代理类所要用到的参数：

服务代理类构造参数
代码如下:
public class WebServiceParamaters
{
    public string address;
    public string Address
    {
        get { return address; }
        set
        {
            address = value;
        }
    }
    private string serviceNamespace;
    public string ServiceNamespace
    {
        get { return serviceNamespace; }
        set
        {
            serviceNamespace = value;
        }
    }
   private string methodAction;
    public string MethodAction
    {
        get { return methodAction; }
        set
        {
            methodAction = value;
        }
    }
    private string methodReplyAction;
    public string MethodReplyAction
    {
        get { return methodReplyAction; }
        set
        {
            methodReplyAction = value;
        }
    }
    private string methodName;
    public string MethodName
    {
        get { return methodName; }
        set
        {
            methodName = value;
        }
    }
    private string returnType;
    public string ReturnType
    {
        get { return returnType; }
        set
        {
            returnType = value;
        }
    }
}

 好，现在我们只需要构造出代理类源码，然后动态编译出代理类的程序集，最后通过反射调用服务方法：
WebServiceProxyCreator
代码如下:
public class WebServiceProxyCreator
{
    public Object WebServiceCaller(WebServiceParamaters parameters)
    {
        CodeDomProvider provider = CodeDomProvider.CreateProvider("CSharp");
        CompilerParameters codeParameters = new CompilerParameters();
        codeParameters.GenerateExecutable = false;
        codeParameters.GenerateInMemory = true;
        StringBuilder code = new StringBuilder();
        CreateProxyCode(code, parameters);
codeParameters.ReferencedAssemblies.Add("System.dll");
codeParameters.ReferencedAssemblies.Add("System.ServiceModel.dll");
        CompilerResults results = provider.CompileAssemblyFromSource(codeParameters, code.ToString());
        Assembly assembly = null;
        if (!results.Errors.HasErrors)
        {
            assembly = results.CompiledAssembly;
        }
        Type clientType = assembly.GetType("RuntimeServiceClient");
       ConstructorInfo ci = clientType.GetConstructor(new Type[] { typeof(Binding), typeof(EndpointAddress) });
        BasicHttpBinding binding = new BasicHttpBinding(); //只演示传统的WebService调用
        EndpointAddress address = new EndpointAddress(parameters.address);
        Object client = ci.Invoke(new object[] { binding, address });
        MethodInfo mi = clientType.GetMethod(parameters.MethodName);
        Object result = mi.Invoke(client, null);
        mi = clientType.GetMethod("Close"); //关闭代理
        mi.Invoke(client, null);
        return result;
   }
    public static void CreateProxyCode(StringBuilder code, WebServiceParamaters parameters)
    {
        code.AppendLine("using System;");
        code.AppendLine("using System.ServiceModel;");
        code.AppendLine("using System.ServiceModel.Channels;");
        code.Append(@"[ServiceContract(");
        if (!String.IsNullOrEmpty(parameters.ServiceNamespace))
        {
            code.Append("Namespace="").Append(parameters.ServiceNamespace).Append(""");
        }
        code.AppendLine(")]");
        code.AppendLine("public interface IRuntimeService");
        code.AppendLine("{");
        code.Append("[OperationContract(");
        if (!String.IsNullOrEmpty(parameters.MethodAction))
        {
            code.Append("Action="").Append(parameters.MethodAction).Append(""");
            if (!String.IsNullOrEmpty(parameters.MethodReplyAction))
            {
                code.Append(", ");
            }
        }
        if (!String.IsNullOrEmpty(parameters.MethodReplyAction))
        {
            code.Append("ReplyAction="").Append(parameters.MethodReplyAction).Append(""");
        }
        code.AppendLine(")]");
        code.Append(parameters.ReturnType).Append(" ");
        code.Append(parameters.MethodName).AppendLine("();");
        code.AppendLine("}");
        code.AppendLine();
        code.AppendLine("public class RuntimeServiceClient : ClientBase<IRuntimeService>, IRuntimeService");
        code.AppendLine("{");
        code.AppendLine("public RuntimeServiceClient(Binding binding, EndpointAddress address) :base(binding, address)");
        code.AppendLine("{");
        code.AppendLine("}");
        code.Append("public ").Append(parameters.ReturnType).Append(" ");
        code.Append(parameters.MethodName).AppendLine("()");
        code.AppendLine("{");
        code.Append("return base.Channel.").Append(parameters.MethodName).AppendLine("();");
        code.AppendLine("}");
        code.AppendLine("}");
    }
}

  注意，红色部分，由于代理类使用了WCF框架，所以编译时我们需要添加System.ServiceModel的引用，当然System.dll肯定是必须的，这里要注意，System.ServiceModel.dll应该保存到应用程序目录，否则动态编译时会引发异常，很简单，在工程引用中添加System.ServiceModel的引用，然后在属性中将拷贝到本地属性设置为true。
   到此，我们就可以直接通过传入的服务地址、服务方法名称以及相关的命名空间，即可调用服务(尽管我们只能调用无参服务，并且尽管我们也只能调用使用BasicHttpBinding绑定的服务，这些限制的原因是…我懒，好吧，相信只要经过一点改动即可去掉这些限制)。
   可惜，我们的程序还很傻：每次调用服务都需要去生成代码、编译、创建代理实例最后再调用，嗯…那就缓存吧：
  在WebServiceParameters类中重写GetHashCode方法：
代码如下:
 public override int GetHashCode()
  {
      return String.Concat(serviceNamespace, methodAction, methodReplyAction, methodName, returnType).GetHashCode();
  }


然后在WebServiceProxyCreator中加入缓存机制：
代码如下:
  public class WebServiceProxyCreator
   {
       private static Dictionary<int, Type> proxyTypeCatch = new Dictionary<int, Type>();

       public Object WebServiceCaller(WebServiceParamaters parameters)
       {
           int key = parameters.GetHashCode();
           Type clientType = null;
           if (proxyTypeCatch.ContainsKey(key))
          {
              clientType = proxyTypeCatch[key];
              Debug.WriteLine("使用缓存");
          }
          else
          {

              CodeDomProvider provider = CodeDomProvider.CreateProvider("CSharp");
              CompilerParameters codeParameters = new CompilerParameters();
              codeParameters.GenerateExecutable = false;
              codeParameters.GenerateInMemory = true;

              StringBuilder code = new StringBuilder();
              CreateProxyCode(code, parameters);

              codeParameters.ReferencedAssemblies.Add("System.dll");
              codeParameters.ReferencedAssemblies.Add("System.ServiceModel.dll");

              CompilerResults results = provider.CompileAssemblyFromSource(codeParameters, code.ToString());
              Assembly assembly = null;
              if (!results.Errors.HasErrors)
              {
                  assembly = results.CompiledAssembly;
              }

              clientType = assembly.GetType("RuntimeServiceClient");

              proxyTypeCatch.Add(key, clientType);
          }
          ConstructorInfo ci = clientType.GetConstructor(new Type[] { typeof(Binding), typeof(EndpointAddress) });
          BasicHttpBinding binding = new BasicHttpBinding(); //只演示传统的WebService调用
          EndpointAddress address = new EndpointAddress(parameters.address);
          Object client = ci.Invoke(new object[] { binding, address });

          MethodInfo mi = clientType.GetMethod(parameters.MethodName);
          Object result = mi.Invoke(client, null);
          mi = clientType.GetMethod("Close"); //关闭代理
          mi.Invoke(client, null);
          return result;
      }

 }

热心网友 时间：2022-05-19 15:46

大致的步骤如下（以C#.Net 为例）：
1、新建 >> 项目 >> Visual C# >> Windows >> Windows服务；
2、一般服务程序中我们都需要使用到 Timer 组件，建议不要使用 System.Windows.Forms.Timer 组件，因为它可能会产生不可预料的“罢工”问题；应使用 System.Timer 组件；可以在 Service 的 OnStart 过程中编写如下：
protected override void OnStart(string[] args)
{
Timer timer = new Timer(1000);
timer.Elapsed += new ElapsedEventHandler(DoAnything); //使用Elapsed事件，其中DoAnything就是你需要处理的事情
timer.AutoReset = true;
timer.Enabled = true;
}
private void DoAnything(object sender, System.Timers.ElapsedEventArgs e)
{
.... 你需要做的事情写这里
}
3、写完之后，最终是需要将它安装到 Windows 服务中，因此需要在现有工程中 添加 >> 新建项 >> 安装程序类，取名叫：ProjectInstaller.cs；在类中还需要两个控件支持，分别是：serviceInstaller 与 serviceProcessInstaller，这两个组件在 .net 2.0 包中已经包含，只是默认不显示在工具箱中，可以从工具箱中增加“选择项”，将它们找出来。其中serviceInstaller可以设置服务的显示名称、说明、运行方式（建议设置成自动：Automatic）等信息；serviceProcessInstaller用于设置服务运行的账户身份，推荐设置成：LocalSystem（本地账户）；
一切就绪后，Ctrl + Alt +B 编译程序，服务程序基本上就到此完成！此时服务程序只是编译好了，并未最终安装到WINDOWS 服务中，还需要写一段批处理用于注册该服务程序，以下提供批处理文件代码。
（注册与启动）
==================
C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\InstallUtil.exe 服务程序绝对路径
net start 服务名
（卸载与停止）
==================
net stop 服务名
C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\InstallUtil.exe -u 服务程序绝对路径

热心网友 时间：2022-05-19 17:04

（1）.使用DllImport特征类来申明Windows API函数：
下面是在Visual Basic .Net中使用DllImport特征类申明二个Windows API函数的具体示例：
'函数ExtractIcon，其功能是是从指定文件的指定位置导出图标的Windows句柄。
＜ System.Runtime.InteropServices.DllImport ( "Shell32.dll" , EntryPoint := "ExtractIcon" ) ＞ _
Public Function _
ExtractIcon ( ByVal src As System.IntPtr , ByVal strFileName As string , ByVal uiIconIndex As UInt32 ) As System.IntPtr
End Function
'函数Icon_Num，其功能是获得指定文件中的图标数目
＜ System.Runtime.InteropServices.DllImport ( "Shell32.dll" , EntryPoint := "ExtractIcon" ) ＞ _
Public Function _
Icon_Num ( ByVal src As System.IntPtr , ByVal strFileName As string , ByVal uiIconIndex As Integer ) As Integer
End Function

在使用DllImport特征类申明Windows API函数时，如果申明的函数名称和函数的入口点相同，则可以在申明Windows API函数时，省略定义函数入口点对应的代码，即EntryPoint对象字段对应的代码，这样声明ExtractIcon函数的代码也可以简化为如下所示：
＜ System.Runtime.InteropServices.DllImport ( "Shell32.dll" ) ＞ _
Public Function _
ExtractIcon ( ByVal src As System.IntPtr , ByVal strFileName As string , ByVal uiIconIndex As UInt32 ) As System.IntPtr
End Function

（2）.使用“Declare”语句来申明Windows API函数：
使用“Declare”语句的确比使用DllImport特征类要简单了许多，下面是在Visual Basic .Net中使用“Declare”语句来声明上述二个Windows API函数的具体方法：
Declare Auto Function ExtractIcon Lib "Shell32.dll" Alias "ExtractIcon" ( ByVal src As System.IntPtr , ByVal strFileName As string , ByVal uiIconIndex As UInt32 ) As System.IntPtr
'声明ExtractIcon函数
Declare Auto Function Icon_Num Lib "Shell32.dll" Alias "ExtractIcon" ( ByVal src As System.IntPtr , ByVal strFileName As string , ByVal uiIconIndex As Integer ) As Integer
'声明Icon_Num函数

在Visual Basic .Net中声明Windows API函数时，“Declare”语句中Alias关键字的作用相当于使用DllImport特征类中的EntryPoint对象字段。同样在使用“Declare”语句声明Windows API函数时，如果声明的函数和函数的入口点相同，也可以省略Alias关键字对应的代码，所以ExtractIcon函数也可以简化为如下：
Declare Auto Function ExtractIcon Lib "Shell32.dll" ( ByVal src As System.IntPtr , ByVal strFileName As string , ByVal uiIconIndex As UInt32 ) As System.IntPtr