Feedback

C# - Service Helper Class

Veröffentlicht von am 25.12.2007
(2 Bewertungen)
Das Snippet besteht aus einer Klasse, die statische Funktionen für das Starten, Pausieren, Fortführen und Beenden eines Windows-Dienstes bereitstellt.

Eine genaue Beschreibung der Methoden entnehmen Sie bitte den XML Kommentaren.

Um den Dienststeuerungs-Manager ansprechen zu können, benötigt man allerdings Administrative Rechte.

benötigte Namespaces:
System.ServiceProcess

benötigte Verweise:
System.ServiceProcess
GFU-Schulungen  [Anzeige]

Visual Studio Team Foundation Server 2017/2015 (TFS) - Komplett 

VB.NET Komplett

Sie stehen vo der Aufgabe, individuelle Anwendungen für Windows zu schreiben. Hier ist VB.NET die optimale Sprache. Sie erlernt sich recht leicht und passt sich komplett in die .NET Umgebung von Microsoft ein. Nach der Schulung entwickeln Sie anwenderfreundliche Programme in VB.NET . Mit den objektorientierten Modellen in VB.NET erzeugen Sie außerdem wiederverwendbare Komponenten.

/// <summary>
/// Stellt Funktionen für das Starten, Pausieren, Fortführen und Beenden eines Windows-Dienstes dar.
/// </summary>
static class ServiceHelper
{
    /// <summary>
    /// Gibt Bezeichner an, die den Rückgabewert einer <see cref="ServiceHelper"/>-Funktion angeben.
    /// </summary>
    public enum ServiceResult
    {
        /// <summary>
        /// Der Rückgabewert der <see cref="ServiceHelper"/>-Funktion ist Ok.
        /// </summary>
        Ok = 1,
        /// <summary>
        /// Der Rückgabewert der <see cref="ServiceHelper"/>-Funktion ist Error.
        /// </summary>
        Error = 2,
        /// <summary>
        /// Der Rückgabewert der <see cref="ServiceHelper"/>-Funktion ist CanNotPause.
        /// </summary>
        CanNotPause = 3,
        /// <summary>
        /// Der Rückgabewert der <see cref="ServiceHelper"/>-Funktion ist CanNotContinue.
        /// </summary>
        CanNotContinue = 4,
        /// <summary>
        /// Der Rückgabewert der <see cref="ServiceHelper"/>-Funktion ist CanNotStop.
        /// </summary>
        CanNotStop = 5,
        /// <summary>
        /// Der Rückgabewert der <see cref="ServiceHelper"/>-Funktion ist AlreadyRunning.
        /// </summary>
        AlreadyRunning = 6,
        /// <summary>
        /// Der Rückgabewert der <see cref="ServiceHelper"/>-Funktion ist AlreadyPaused.
        /// </summary>
        AlreadyPaused = 7,
        /// <summary>
        /// Der Rückgabewert der <see cref="ServiceHelper"/>-Funktion ist AlredyStopped.
        /// </summary>
        AlredyStopped = 8,
    }

    /// <summary>
    /// Startet einen Dienst.
    /// </summary>
    /// <param name="serviceName">
    /// Der Name des Dienstes, der gestartet werden soll.
    /// </param>
    /// <param name="machineName">
    /// Der Name der Maschine, auf der der Dienst gestartet werden soll.
    /// Soll der Dienst auf der lokalen Maschine gestartet werden, muss "localhost" übergeben werden.
    /// </param>
    /// <param name="arguments">
    /// Argumente, die beim Starten des Dienstes übergeben werden sollen.
    /// </param>
    /// <param name="timeout">
    /// Die Zeitspanne, die gewartet werden soll, bis der Dienst den angegebenen Zustand annimmt.
    /// </param>
    /// <returns>
    /// Einer der <see cref="ServiceResult"/>-Werte.
    /// </returns>
    public static ServiceResult StartService(string serviceName, string machineName, string[] arguments, TimeSpan timeout)
    {
        ServiceController service = null;

        try
        {
            service = new ServiceController(serviceName, machineName == "localhost" ? "." : machineName);

            if (service.Status != ServiceControllerStatus.Running &&
                service.Status != ServiceControllerStatus.StartPending &&
                service.Status != ServiceControllerStatus.ContinuePending)
            {
                if (arguments != null)
                {
                    service.Start(arguments);
                }
                else
                {
                    service.Start();
                }
                service.WaitForStatus(ServiceControllerStatus.Running, timeout);
                return ServiceResult.Ok;
            }
            else
            {
                return ServiceResult.AlreadyRunning;
            }
        }
        catch
        {
            return ServiceResult.Error;
        }
        finally
        {
            if (service != null)
            {
                service.Close();
            }
        }
    }

    /// <summary>
    /// Hält einen Dienst an.
    /// </summary>
    /// <param name="serviceName">
    /// Der Name des Dienstes, der angehalten werden soll.
    /// </param>
    /// <param name="machineName">
    /// Der Name der Maschine, auf der der anzuhaltende Dienst läuft.
    /// Läuft der Dienst auf der lokalen Maschine, muss "localhost" übergeben werden.
    /// </param>
    /// <param name="timeout">
    /// Die Zeitspanne, die gewartet werden soll, bis der Dienst den angegebenen Zustand annimmt.
    /// </param>
    /// <returns>
    /// Einer der <see cref="ServiceResult"/>-Werte.
    /// </returns>
    public static ServiceResult PauseService(string serviceName, string machineName, TimeSpan timeout)
    {
        ServiceController service = null;

        try
        {
            service = new ServiceController(serviceName, machineName == "localhost" ? "." : machineName);

            if (service.CanPauseAndContinue == true)
            {
                if (service.Status != ServiceControllerStatus.Paused &&
                    service.Status != ServiceControllerStatus.PausePending &&
                    service.Status != ServiceControllerStatus.StopPending)
                {
                    service.Pause();
                    service.WaitForStatus(ServiceControllerStatus.Paused, timeout);
                    return ServiceResult.Ok;
                }
                else
                {
                    return ServiceResult.AlreadyPaused;
                }
            }
            else
            {
                return ServiceResult.CanNotPause;
            }
        }
        catch
        {
            return ServiceResult.Error;
        }
        finally
        {
            if (service != null)
            {
                service.Close();
            }
        }
    }


    /// <summary>
    /// Führt einen angehaltenen Dienst fort.
    /// </summary>
    /// <param name="serviceName">
    /// Der Name des Dienstes, der fortgefürt werden soll.
    /// </param>
    /// <param name="machineName">
    /// Der Name der Maschine, auf der der Dienst fortgeführt werden soll.
    /// Soll der Dienst auf der lokalen Maschine fortgeführt werden, muss "localhost" übergeben werden.
    /// </param>
    /// <param name="timeout">
    /// Die Zeitspanne, die gewartet werden soll, bis der Dienst den angegebenen Zustand annimmt.
    /// </param>
    /// <returns>
    /// Einer der <see cref="ServiceResult"/>-Werte.
    /// </returns>
    public static ServiceResult ContinueService(string serviceName, string machineName, TimeSpan timeout)
    {
        ServiceController service = null;

        try
        {
            service = new ServiceController(serviceName, machineName == "localhost" ? "." : machineName);

            if (service.CanPauseAndContinue == true)
            {
                if (service.Status != ServiceControllerStatus.Running &&
                    service.Status != ServiceControllerStatus.StartPending &&
                    service.Status != ServiceControllerStatus.ContinuePending)
                {
                    service.Continue();
                    service.WaitForStatus(ServiceControllerStatus.Running, timeout);
                    return ServiceResult.Ok;
                }
                else
                {
                    return ServiceResult.AlreadyRunning;
                }
            }
            else
            {
                return ServiceResult.CanNotContinue;
            }
        }
        catch
        {
            return ServiceResult.Error;
        }
        finally
        {
            if (service != null)
            {
                service.Close();
            }
        }
    }

    /// <summary>
    /// Stoppt einen Dienst.
    /// </summary>
    /// <param name="serviceName">
    /// Der Name des Dienstes, der gestoppt werden soll.
    /// </param>
    /// <param name="machineName">
    /// Der Name der Maschine, auf der der zu stoppende Dienst läuft.
    /// Läuft der Dienst auf der lokalen Maschine, muss "localhost" übergeben werden.
    /// </param>
    /// <param name="timeout">
    /// Die Zeitspanne, die gewartet werden soll, bis der Dienst den angegebenen Zustand annimmt.
    /// </param>
    /// <returns>
    /// Einer der <see cref="ServiceResult"/>-Werte.
    /// </returns>
    public static ServiceResult StopService(string serviceName, string machineName, TimeSpan timeout)
    {
        ServiceController service = null;

        try
        {
            service = new ServiceController(serviceName, machineName == "localhost" ? "." : machineName);

            if (service.CanStop == true)
            {
                if (service.Status != ServiceControllerStatus.Stopped &&
                    service.Status != ServiceControllerStatus.StopPending)
                {
                    service.Stop();
                    service.WaitForStatus(ServiceControllerStatus.Stopped, timeout);
                    return ServiceResult.Ok;
                }
                else
                {
                    return ServiceResult.AlredyStopped;
                }
            }
            else
            {
                return ServiceResult.CanNotStop;
            }
        }
        catch
        {
            return ServiceResult.Error;
        }
        finally
        {
            if (service != null)
            {
                service.Close();
            }
        }
    }
}
Abgelegt unter Process, Service, Dienst, Utility, Utilities.

Kommentare zum Snippet

 

Logge dich ein, um hier zu kommentieren!