将 C# 服务包装在控制台应用程序中以对其进行调试

Question

我想调试用 C# 编写的服务，而老式的方法太长了。我必须停止该服务，启动在调试模式下使用该服务的应用程序 (Visual studio 2008)，启动该服务，附加到服务进程，然后在我的 Asp.Net 应用程序中导航以触发该服务。

我基本上让服务在后台运行，等待任务。 Web 应用程序将触发服务拾取的任务。

我想做的是拥有一个控制台应用程序来触发服务，以便我进行调试。有没有人知道的简单演示？

Answer 1

您可以在主入口点

static void Main()
{
#if DEBUG
    Service1 s = new Service1();
    s.Init(); // Init() is pretty much any code you would have in OnStart().
#else
    ServiceBase[] ServicesToRun;
    ServicesToRun=new ServiceBase[] 
    { 
        new Service1() 
    };
    ServiceBase.Run(ServicesToRun);
#endif
}

和 OnStart 事件处理程序中执行类似的操作：

protected override void OnStart(string[] args)
{
    Init();
}

Answer 2

我始终采用的方法是将应用程序的所有逻辑隔离到类库中。这使得您的服务项目实际上只是一个将类库作为服务托管的外壳。

通过这样做，您可以轻松地对代码进行单元测试和调试，而不必处理通过附加到进程来调试服务的麻烦。当然，我建议进行单元测试，但如果您不这样做，那么添加一个调用与您的服务相同的入口点的控制台应用程序是可行的方法。

Answer 3

为了避免使用全局定义，我通常在运行时通过 Environment.UserInteractive 属性测试我是服务还是常规应用程序。

    [MTAThread()]
    private static void Main()
    {
        if (!Environment.UserInteractive)
        {
            ServiceBase[] aServicesToRun;

            // More than one NT Service may run within the same process. To add
            // another service to this process, change the following line to
            // create a second service object. For example,
            //
            //   ServicesToRun = New System.ServiceProcess.ServiceBase () {New ServiceMain, New MySecondUserService}
            //
            aServicesToRun = new ServiceBase[] {new ServiceMain()};

            Run(aServicesToRun);
        }
        else
        {
            var oService = new ServiceMain();
            oService.OnStart(null);
        }
   }

Answer 4

您可能还想在冒险中查看 TopShelf。

http://codebetter.com/blogs/dru.sellers /archive/2009/01/11/topshelf.aspx

http://code.google. com/p/topshelf/

Answer 5

您可以通过反射调用服务方法，如下所示。

使用Environment.UserInteractive使我们能够知道我们是作为控制台应用程序还是作为服务运行。

ServiceBase[] ServicesToRun;
ServicesToRun = new ServiceBase[]
{
    new MyService()
};

if (!Environment.UserInteractive)
{
    // This is what normally happens when the service is run.
    ServiceBase.Run(ServicesToRun);
}
else
{
    // Here we call the services OnStart via reflection.
    Type type = typeof(ServiceBase);
    BindingFlags flags = BindingFlags.Instance | BindingFlags.NonPublic;
    MethodInfo method = type.GetMethod("OnStart", flags);

    foreach (ServiceBase service in ServicesToRun)
    {
        Console.WriteLine("Running " + service.ServiceName + ".OnStart()");
        // Your Main method might not have (string[] args) but you could add that to be able to send arguments in.
        method.Invoke(service, new object[] { args });
    }

    Console.WriteLine("Finished running all OnStart Methods.");

    foreach (ServiceBase service in ServicesToRun)
    {
        Console.WriteLine("Running " + service.ServiceName + ".OnStop()");
        service.Stop();
    }
}

Answer 6

TopShelf 是另一个非常适合这种方法的项目。它允许您将进程作为服务运行，或者作为具有最少配置的常规控制台应用程序运行。

Answer 7

我倾向于使用配置设置或使用指令进行调试构建：

 #if DEBUG
    Debugger.Break();
 #endif

或者

if(Settings.DebugBreak)
            Debugger.Break();

将其放在服务组件的 OnStart 方法中。然后系统会自动提示您并附加到该流程。

Answer 8

这是一篇关于将 Windows 服务作为控制台应用程序。

您还可以创建一个新的控制台应用程序，引用与您的服务相同的逻辑来测试方法，或者对服务的逻辑设置单元测试

Answer 9

我过去曾使用单元测试来调试困难的设置，只需编写一个单元测试，使用任何参数调用任何服务方法，并在单元测试中设置调试断点。

使用 testdriven.net 或 jetbrains testrunner 会更容易。

Answer 10

我用它来检查我的进程是否作为服务运行。

public class ServiceDiagnostics
{
    readonly bool _isUserService;
    readonly bool _isLocalSystem;
    readonly bool _isInteractive;

    public ServiceDiagnostics()
    {
        var wi = WindowsIdentity.GetCurrent();
        var wp = new WindowsPrincipal(wi);

        var serviceSid = new SecurityIdentifier(WellKnownSidType.ServiceSid, null);
        var localSystemSid = new SecurityIdentifier(WellKnownSidType.LocalSystemSid, null);
        var interactiveSid = new SecurityIdentifier(WellKnownSidType.InteractiveSid, null);

        this._isUserService = wp.IsInRole(serviceSid);

        // Neither Interactive or Service was present in the current user's token, This implies 
        // that the process is running as a service, most likely running as LocalSystem.
        this._isLocalSystem = wp.IsInRole(localSystemSid);

        // This process has the Interactive SID in its token.  This means that the process is 
        // running as a console process.
        this._isInteractive = wp.IsInRole(interactiveSid);
    }

    public bool IsService
    {
        get { return this.IsUserService || this.IsLocalSystem || !this.IsInteractive; }    
    }

    public bool IsConsole
    {
        get { return !this.IsService; }
    }

    /// <summary>
    /// This process has the Service SID in its token. This means that the process is running 
    /// as a service running in a user account (not local system).
    /// </summary>
    public bool IsUserService
    {
        get { return this._isUserService; }
    }

    /// <summary>
    /// Neither Interactive or Service was present in the current user's token, This implies 
    /// that the process is running as a service, most likely running as LocalSystem.
    /// </summary>
    public bool IsLocalSystem
    {
        get { return this._isLocalSystem; }
    }

    /// <summary>
    /// This process has the Interactive SID in its token.  This means that the process is 
    /// running as a console process.
    /// </summary>
    public bool IsInteractive
    {
        get { return this._isInteractive; }
    }
}