ServiceController Classe

Definizione

Rappresenta un servizio Windows e consente di connettersi a un servizio in esecuzione o arrestato, manipolarlo o ottenere informazioni al riguardo.

public ref class ServiceController : System::ComponentModel::Component
public ref class ServiceController : IDisposable
public class ServiceController : System.ComponentModel.Component
public class ServiceController : IDisposable
[System.ServiceProcess.ServiceProcessDescription("ServiceControllerDesc")]
public class ServiceController : System.ComponentModel.Component
type ServiceController = class
    inherit Component
type ServiceController = class
    interface IDisposable
[<System.ServiceProcess.ServiceProcessDescription("ServiceControllerDesc")>]
type ServiceController = class
    inherit Component
Public Class ServiceController
Inherits Component
Public Class ServiceController
Implements IDisposable
Ereditarietà
ServiceController
Ereditarietà
ServiceController
Attributi
Implementazioni

Esempio

Nell'esempio seguente viene illustrato l'uso della ServiceController classe per controllare l'esempio del SimpleService servizio.

using System;
using System.ServiceProcess;
using System.Diagnostics;
using System.Threading;

namespace ServiceControllerSample
{
    class Program
    {
        public enum SimpleServiceCustomCommands
        { StopWorker = 128, RestartWorker, CheckWorker };
        static void Main(string[] args)
        {
            ServiceController[] scServices;
            scServices = ServiceController.GetServices();

            foreach (ServiceController scTemp in scServices)
            {

                if (scTemp.ServiceName == "Simple Service")
                {
                    // Display properties for the Simple Service sample
                    // from the ServiceBase example.
                    ServiceController sc = new ServiceController("Simple Service");
                    Console.WriteLine("Status = " + sc.Status);
                    Console.WriteLine("Can Pause and Continue = " + sc.CanPauseAndContinue);
                    Console.WriteLine("Can ShutDown = " + sc.CanShutdown);
                    Console.WriteLine("Can Stop = " + sc.CanStop);
                    if (sc.Status == ServiceControllerStatus.Stopped)
                    {
                        sc.Start();
                        while (sc.Status == ServiceControllerStatus.Stopped)
                        {
                            Thread.Sleep(1000);
                            sc.Refresh();
                        }
                    }
                    // Issue custom commands to the service
                    // enum SimpleServiceCustomCommands
                    //    { StopWorker = 128, RestartWorker, CheckWorker };
                    sc.ExecuteCommand((int)SimpleServiceCustomCommands.StopWorker);
                    sc.ExecuteCommand((int)SimpleServiceCustomCommands.RestartWorker);
                    sc.Pause();
                    while (sc.Status != ServiceControllerStatus.Paused)
                    {
                        Thread.Sleep(1000);
                        sc.Refresh();
                    }
                    Console.WriteLine("Status = " + sc.Status);
                    sc.Continue();
                    while (sc.Status == ServiceControllerStatus.Paused)
                    {
                        Thread.Sleep(1000);
                        sc.Refresh();
                    }
                    Console.WriteLine("Status = " + sc.Status);
                    sc.Stop();
                    while (sc.Status != ServiceControllerStatus.Stopped)
                    {
                        Thread.Sleep(1000);
                        sc.Refresh();
                    }
                    Console.WriteLine("Status = " + sc.Status);
                    String[] argArray = new string[] { "ServiceController arg1", "ServiceController arg2" };
                    sc.Start(argArray);
                    while (sc.Status == ServiceControllerStatus.Stopped)
                    {
                        Thread.Sleep(1000);
                        sc.Refresh();
                    }
                    Console.WriteLine("Status = " + sc.Status);
                    // Display the event log entries for the custom commands
                    // and the start arguments.
                    EventLog el = new EventLog("Application");
                    EventLogEntryCollection elec = el.Entries;
                    foreach (EventLogEntry ele in elec)
                    {
                        if (ele.Source.IndexOf("SimpleService.OnCustomCommand") >= 0 |
                            ele.Source.IndexOf("SimpleService.Arguments") >= 0)
                            Console.WriteLine(ele.Message);
                    }
                }
            }
        }
    }
}
// This sample displays the following output if the Simple Service
// sample is running:
//Status = Running
//Can Pause and Continue = True
//Can ShutDown = True
//Can Stop = True
//Status = Paused
//Status = Running
//Status = Stopped
//Status = Running
//4:14:49 PM - Custom command received: 128
//4:14:49 PM - Custom command received: 129
//ServiceController arg1
//ServiceController arg2
Imports System.ServiceProcess
Imports System.Diagnostics
Imports System.Threading



Class Program

    Public Enum SimpleServiceCustomCommands
        StopWorker = 128
        RestartWorker
        CheckWorker
    End Enum 'SimpleServiceCustomCommands

    Shared Sub Main(ByVal args() As String)
        Dim scServices() As ServiceController
        scServices = ServiceController.GetServices()

        Dim scTemp As ServiceController
        For Each scTemp In scServices

            If scTemp.ServiceName = "Simple Service" Then
                ' Display properties for the Simple Service sample 
                ' from the ServiceBase example
                Dim sc As New ServiceController("Simple Service")
                Console.WriteLine("Status = " + sc.Status.ToString())
                Console.WriteLine("Can Pause and Continue = " + _
                    sc.CanPauseAndContinue.ToString())
                Console.WriteLine("Can ShutDown = " + sc.CanShutdown.ToString())
                Console.WriteLine("Can Stop = " + sc.CanStop.ToString())
                If sc.Status = ServiceControllerStatus.Stopped Then
                    sc.Start()
                    While sc.Status = ServiceControllerStatus.Stopped
                        Thread.Sleep(1000)
                        sc.Refresh()
                    End While
                End If
                ' Issue custom commands to the service
                ' enum SimpleServiceCustomCommands 
                '    { StopWorker = 128, RestartWorker, CheckWorker };
                sc.ExecuteCommand(Fix(SimpleServiceCustomCommands.StopWorker))
                sc.ExecuteCommand(Fix(SimpleServiceCustomCommands.RestartWorker))
                sc.Pause()
                While sc.Status <> ServiceControllerStatus.Paused
                    Thread.Sleep(1000)
                    sc.Refresh()
                End While
                Console.WriteLine("Status = " + sc.Status.ToString())
                sc.Continue()
                While sc.Status = ServiceControllerStatus.Paused
                    Thread.Sleep(1000)
                    sc.Refresh()
                End While
                Console.WriteLine("Status = " + sc.Status.ToString())
                sc.Stop()
                While sc.Status <> ServiceControllerStatus.Stopped
                    Thread.Sleep(1000)
                    sc.Refresh()
                End While
                Console.WriteLine("Status = " + sc.Status.ToString())
                Dim argArray() As String = {"ServiceController arg1", "ServiceController arg2"}
                sc.Start(argArray)
                While sc.Status = ServiceControllerStatus.Stopped
                    Thread.Sleep(1000)
                    sc.Refresh()
                End While
                Console.WriteLine("Status = " + sc.Status.ToString())
                ' Display the event log entries for the custom commands
                ' and the start arguments.
                Dim el As New EventLog("Application")
                Dim elec As EventLogEntryCollection = el.Entries
                Dim ele As EventLogEntry
                For Each ele In elec
                    If ele.Source.IndexOf("SimpleService.OnCustomCommand") >= 0 Or ele.Source.IndexOf("SimpleService.Arguments") >= 0 Then
                        Console.WriteLine(ele.Message)
                    End If
                Next ele
            End If
        Next scTemp

    End Sub
End Class
' This sample displays the following output if the Simple Service
' sample is running:
'Status = Running
'Can Pause and Continue = True
'Can ShutDown = True
'Can Stop = True
'Status = Paused
'Status = Running
'Status = Stopped
'Status = Running
'4:14:49 PM - Custom command received: 128
'4:14:49 PM - Custom command received: 129
'ServiceController arg1
'ServiceController arg2

Commenti

È possibile usare la ServiceController classe per connettersi e controllare il comportamento dei servizi esistenti. Quando si crea un'istanza della ServiceController classe , si impostano le relative proprietà in modo che interagisca con un servizio Windows specifico. È quindi possibile usare la classe per avviare, arrestare e modificare in altro modo il servizio.

Probabilmente si userà il ServiceController componente in una capacità amministrativa. Ad esempio, è possibile creare un'applicazione Windows o Web che invia comandi personalizzati a un servizio tramite l'istanza ServiceController di . Ciò sarebbe utile perché lo snap-in Service Control Manager (SCM) Microsoft Management Console non supporta i comandi personalizzati.

Dopo aver creato un'istanza di ServiceController, è necessario impostare due proprietà su di esso per identificare il servizio con cui interagisce: il nome del computer e il nome del servizio che si vuole controllare.

Nota

Per impostazione predefinita, MachineName è impostato sul computer locale, pertanto non è necessario modificarlo a meno che non si voglia impostare l'istanza in modo che punti a un altro computer.

In genere, l'autore del servizio scrive codice che personalizza l'azione associata a un comando specifico. Ad esempio, un servizio può contenere codice per rispondere a un ServiceBase.OnPause comando. In tal caso, l'elaborazione personalizzata per l'attività Pause viene eseguita prima che il sistema sospende il servizio.

Il set di comandi che un servizio può elaborare dipende dalle relative proprietà; Ad esempio, è possibile impostare la CanStop proprietà per un servizio su false. Questa impostazione rende il Stop comando non disponibile in quel particolare servizio. Impedisce di arrestare il servizio da Gestione configurazione sito disabilitando il pulsante necessario. Se si tenta di arrestare il servizio dal codice, il sistema genera un errore e visualizza il messaggio di errore "Failed to stop servicename".

Costruttori

ServiceController()

Inizializza una nuova istanza della classe ServiceController non associata a un servizio specifico.

ServiceController(String)

Inizializza una nuova istanza della classe ServiceController associata a un servizio esistente sul computer locale.

ServiceController(String, String)

Inizializza una nuova istanza della classe ServiceController associata a un servizio esistente sul computer specificato.

Proprietà

CanPauseAndContinue

Ottiene un valore che indica se il servizio può essere sospeso e riattivato.

CanRaiseEvents

Ottiene un valore che indica se il componente può generare un evento.

(Ereditato da Component)
CanShutdown

Ottiene un valore che indica se è necessario che il servizio riceva una notifica quando il sistema è in fase di arresto.

CanStop

Ottiene un valore che indica se il servizio, una volta avviato, può essere arrestato.

Container

Ottiene l'oggetto IContainer che contiene Component.

(Ereditato da Component)
DependentServices

Ottiene il set di servizi che dipende dal servizio associato a questa istanza di ServiceController.

DesignMode

Ottiene un valore che indica se il Component si trova in modalità progettazione.

(Ereditato da Component)
DisplayName

Ottiene o imposta un nome descrittivo per il servizio.

Events

Ottiene l'elenco dei gestori eventi allegati a questo Component.

(Ereditato da Component)
MachineName

Ottiene o imposta il nome del computer su cui si trova il servizio.

ServiceHandle

Ottiene l'handle del servizio.

ServiceName

Ottiene o imposta il nome che identifica il servizio a cui l'istanza fa riferimento.

ServicesDependedOn

Set di servizi da cui dipende questo servizio.

ServiceType

Ottiene il tipo di servizio a cui fa riferimento questo oggetto.

Site

Ottiene o imposta l'oggetto ISite di Component.

(Ereditato da Component)
StartType

Ottiene un valore che indica come viene avviato il servizio rappresentato dall'oggetto ServiceController.

Status

Ottiene lo stato del servizio a cui questa istanza fa riferimento.

Metodi

Close()

Disconnette l'istanza di questo oggetto ServiceController dal servizio e libera tutte le risorse allocate dall'istanza.

Continue()

Riprende un servizio dopo che è stato sospeso.

CreateObjRef(Type)

Consente di creare un oggetto che contiene tutte le informazioni rilevanti necessarie per la generazione del proxy utilizzato per effettuare la comunicazione con un oggetto remoto.

(Ereditato da MarshalByRefObject)
Dispose()

Esegue attività definite dall'applicazione, come rilasciare o reimpostare risorse non gestite.

Dispose()

Rilascia tutte le risorse usate da Component.

(Ereditato da Component)
Dispose(Boolean)

Rilascia le risorse non gestite usate da ServiceController e, facoltativamente, le risorse gestite.

Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.

(Ereditato da Object)
ExecuteCommand(Int32)

Esegue un comando personalizzato sul servizio.

GetDevices()

Recupera tutti i servizi del driver di dispositivo sul computer locale.

GetDevices(String)

Recupera i servizi del driver di dispositivo sul computer specificato.

GetHashCode()

Funge da funzione hash predefinita.

(Ereditato da Object)
GetLifetimeService()
Obsoleti.

Consente di recuperare l'oggetto servizio di durata corrente per controllare i criteri di durata per l'istanza.

(Ereditato da MarshalByRefObject)
GetService(Type)

Consente di restituire un oggetto che rappresenta un servizio fornito da Component o dal relativo Container.

(Ereditato da Component)
GetServices()

Recupera tutti i servizi sul computer locale, fatta eccezione per i servizi del driver di dispositivo.

GetServices(String)

Recupera tutti i servizi sul computer specificato, fatta eccezione per i servizi del driver di dispositivo.

GetType()

Ottiene l'oggetto Type dell'istanza corrente.

(Ereditato da Object)
InitializeLifetimeService()
Obsoleti.

Ottiene un oggetto servizio di durata per controllare i criteri di durata per questa istanza.

(Ereditato da MarshalByRefObject)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.

(Ereditato da Object)
MemberwiseClone(Boolean)

Crea una copia dei riferimenti dell'oggetto MarshalByRefObject corrente.

(Ereditato da MarshalByRefObject)
Pause()

Sospende il funzionamento di un servizio.

Refresh()

Aggiorna i valori delle proprietà reimpostando le proprietà sui valori correnti.

Start()

Avvia il servizio, senza passare argomenti.

Start(String[])

Avvia il servizio, passando gli argomenti specificati.

Stop()

Arresta questo servizio e tutti i servizi da esso dipendenti.

Stop(Boolean)

Arresta il servizio e, facoltativamente, tutti i servizi dipendenti da questo servizio.

ToString()

Restituisce un oggetto String che contiene il nome dell'eventuale oggetto Component. Questo metodo non deve essere sottoposto a override.

(Ereditato da Component)
ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.

(Ereditato da Object)
WaitForStatus(ServiceControllerStatus)

Attende che il servizio raggiunga lo stato specificato senza limiti di tempo.

WaitForStatus(ServiceControllerStatus, TimeSpan)

Attende che il servizio raggiunga lo stato specificato oppure la scadenza del timeout specificato.

Eventi

Disposed

Si verifica quando il componente viene eliminato da una chiamata al metodo Dispose().

(Ereditato da Component)

Si applica a

Vedi anche