ServiceBase-Klasse
Stellt eine Basisklasse für einen Dienst als Teil einer Dienstanwendung bereit. ServiceBase muss abgeleitet werden, wenn eine neue Dienstklasse erstellt wird.
Namespace: System.ServiceProcess
Assembly: System.ServiceProcess (in system.serviceprocess.dll)
Syntax
'Declaration
Public Class ServiceBase
Inherits Component
'Usage
Dim instance As ServiceBase
public class ServiceBase : Component
public ref class ServiceBase : public Component
public class ServiceBase extends Component
public class ServiceBase extends Component
Hinweise
Leiten Sie ServiceBase ab, wenn Sie Ihre Dienstklasse in einer Dienstanwendung definieren. Die OnStart-Methode und die OnStop-Methode werden von allen funktionalen Diensten überschrieben. Um weitere Funktionen zu erhalten, können Sie als Reaktion auf Änderungen im Dienstzustand OnPause und OnContinue mit einem bestimmten Verhalten überschreiben.
Bei einem Dienst handelt es sich um ein Programm im Dauerbetrieb, das keine Benutzeroberfläche unterstützt und möglicherweise nicht unter dem angemeldeten Benutzerkonto ausgeführt wird. Ein Dienst kann ausgeführt werden, ohne dass ein Benutzer am Computer angemeldet ist.
Standardmäßig werden Dienste unter dem Systemkonto des Computers ausgeführt. Dieses ist nicht mit dem Administratorkonto identisch. Die Rechte des Systemkontos können nicht geändert werden. Sie können auch mit ServiceProcessInstaller ein Benutzerkonto festlegen, unter dem der Dienst ausgeführt werden soll.
Eine ausführbare Datei kann mehrere Dienste enthalten, dabei muss allerdings jeweils ein eigener ServiceInstaller vorhanden sein. Die ServiceInstaller-Instanz meldet den Dienst beim System an. Das Installationsprogramm ordnet jedem Dienst ein Ereignisprotokoll zu, das zur Aufzeichnung von Dienstbefehlen verwendet werden kann. Die main()-Funktion in der ausführbaren Datei definiert, welche Dienste ausgeführt werden sollen. Das aktuelle Arbeitsverzeichnis des Diensts ist das Systemverzeichnis und nicht das Verzeichnis, in dem sich die ausführbare Datei befindet.
Beim Starten eines Diensts sucht das System die ausführbare Datei und führt die OnStart-Methode des Diensts aus, die in der ausführbaren Datei enthalten ist. Es besteht jedoch ein Unterschied zwischen dem Ausführen des Diensts und dem Ausführen der Programmdatei. Die Programmdatei lädt den Dienst lediglich. Auf den Dienst wird über den Dienststeuerungs-Manager zugegriffen (z. B. zum Starten oder Beenden).
Die ausführbare Datei ruft den Konstruktor der von ServiceBase abgeleiteten Klasse auf, sobald Sie für den Dienst Start aufrufen. Die OnStart-Methode zur Befehlsbehandlung wird unmittelbar nach dem Ausführen des Konstruktors aufgerufen. Der Konstruktor wird nach dem ersten Laden des Diensts nicht mehr ausgeführt. Deshalb müssen die vom Konstruktor ausgeführten Verarbeitungsvorgänge von den durch OnStart ausgeführten getrennt werden. Alle Ressourcen, die durch OnStop freigegeben werden können, müssen in OnStart erstellt werden. Durch Erstellen von Ressourcen im Konstruktor wird verhindert, dass diese ordnungsgemäß erstellt werden, wenn nach der Freigabe der Ressourcen durch OnStop der Dienst erneut gestartet wird.
Der Dienststeuerungs-Manager stellt eine Möglichkeit für die Interaktion mit dem Dienst bereit. Sie können mit dem Dienststeuerungs-Manager die Befehle Starten, Beenden, Anhalten und Fortsetzen sowie benutzerdefinierte Befehle an den Dienst übergeben. Der Dienststeuerungs-Manager bestimmt anhand der Werte von CanStop und CanPauseAndContinue, ob der Dienst die Befehle Beenden, Anhalten oder Fortsetzen zulässt. Beenden, Anhalten und Fortsetzen sind nur dann in den Kontextmenüs des Dienststeuerungs-Managers aktiviert, wenn CanStop oder CanPauseAndContinue der entsprechenden Eigenschaft in der Dienstklasse true ist. Wenn der Befehl aktiviert ist, wird er an den Dienst übergeben, und es wird OnStop, OnPause oder OnContinue aufgerufen. Wenn CanStop, CanShutdown oder CanPauseAndContinue den Wert false hat, wird die entsprechende Methode zur Befehlsbehandlung (z. B. OnStop) nicht verarbeitet, selbst wenn Sie diese implementiert haben.
Sie können mit der ServiceController-Klasse programmgesteuert die Tasks ausführen, die der Dienststeuerungs-Manager mithilfe der Benutzeroberfläche ausführt. Sie können die in der Konsole verfügbaren Aufgaben automatisieren. Wenn CanStop, CanShutdown oder CanPauseAndContinue den Wert true hat, jedoch keine entsprechende Methode zur Befehlsbehandlung (z. B. OnStop) implementiert ist, löst das System eine Ausnahme aus und ignoriert den Befehl.
Es ist nicht erforderlich, OnStart, OnStop oder eine andere Methode in ServiceBase zu implementieren. Das Verhalten des Diensts wird jedoch in OnStart beschrieben, deshalb muss zumindest dieser Member überschrieben werden. Sie müssen den Dienstnamen des Diensts in der main()-Funktion der ausführbaren Datei festlegen. Der Dienstname, den Sie in main() festlegen, muss mit der ServiceName-Eigenschaft des Dienstinstallationsprogramms genau übereinstimmen.
Sie können mit InstallUtil.exe Dienste im System installieren.
Hinweis
Sie können für Benachrichtigungen über Aufrufe von Diensten ein anderes Protokoll als das Anwendungsereignisprotokoll angeben, die AutoLog-Eigenschaft und die EventLog-Eigenschaft können jedoch nicht in ein benutzerdefiniertes Protokoll geschrieben werden. Legen Sie AutoLog auf false fest, wenn keine automatische Protokollierung ausgeführt werden soll.
Beispiel
Im folgenden Beispiel wird eine einfache Dienstimplementierung von der ServiceBase-Klasse abgeleitet. Der Dienst behandelt eine Reihe von Dienstbefehlen, einschließlich der Befehle Beenden, Starten, Anhalten, Fortsetzen und benutzerdefinierte Befehle.
// Turn on logging to the event log.
#define LOGEVENTS
using System;
using System.IO;
using System.Threading;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.ServiceProcess;
using System.Text;
using Microsoft.Win32;
using System.Runtime.InteropServices;
using System.Windows.Forms;
namespace ServiceSample
{
// Define custom commands for the SimpleService.
public enum SimpleServiceCustomCommands { StopWorker = 128, RestartWorker, CheckWorker };
[StructLayout(LayoutKind.Sequential)]
public struct SERVICE_STATUS
{
public int serviceType;
public int currentState;
public int controlsAccepted;
public int win32ExitCode;
public int serviceSpecificExitCode;
public int checkPoint;
public int waitHint;
}
public enum State
{
SERVICE_STOPPED = 0x00000001,
SERVICE_START_PENDING = 0x00000002,
SERVICE_STOP_PENDING = 0x00000003,
SERVICE_RUNNING = 0x00000004,
SERVICE_CONTINUE_PENDING = 0x00000005,
SERVICE_PAUSE_PENDING = 0x00000006,
SERVICE_PAUSED = 0x00000007,
}
// Define a simple service implementation.
public class SimpleService : System.ServiceProcess.ServiceBase
{
private static int userCount = 0;
private static ManualResetEvent pause = new ManualResetEvent(false);
[DllImport("ADVAPI32.DLL", EntryPoint = "SetServiceStatus")]
public static extern bool SetServiceStatus(
IntPtr hServiceStatus,
SERVICE_STATUS lpServiceStatus
);
private SERVICE_STATUS myServiceStatus;
private Thread workerThread = null;
public SimpleService()
{
CanPauseAndContinue = true;
CanHandleSessionChangeEvent = true;
ServiceName = "SimpleService";
}
static void Main()
{
#if LOGEVENTS
EventLog.WriteEntry("SimpleService.Main", DateTime.Now.ToLongTimeString() +
" - Service main method starting...");
#endif
// Load the service into memory.
System.ServiceProcess.ServiceBase.Run(new SimpleService());
#if LOGEVENTS
EventLog.WriteEntry("SimpleService.Main", DateTime.Now.ToLongTimeString() +
" - Service main method exiting...");
#endif
}
private void InitializeComponent()
{
// Initialize the operating properties for the service.
this.CanPauseAndContinue = true;
this.CanShutdown = true;
this.CanHandleSessionChangeEvent = true;
this.ServiceName = "SimpleService";
}
// Start the service.
protected override void OnStart(string[] args)
{
IntPtr handle = this.ServiceHandle;
myServiceStatus.currentState = (int)State.SERVICE_START_PENDING;
SetServiceStatus(handle, myServiceStatus);
// Start a separate thread that does the actual work.
if ((workerThread == null) ||
((workerThread.ThreadState &
(System.Threading.ThreadState.Unstarted | System.Threading.ThreadState.Stopped)) != 0))
{
#if LOGEVENTS
EventLog.WriteEntry("SimpleService.OnStart", DateTime.Now.ToLongTimeString() +
" - Starting the service worker thread.");
#endif
workerThread = new Thread(new ThreadStart(ServiceWorkerMethod));
workerThread.Start();
}
if (workerThread != null)
{
#if LOGEVENTS
EventLog.WriteEntry("SimpleService.OnStart", DateTime.Now.ToLongTimeString() +
" - Worker thread state = " +
workerThread.ThreadState.ToString());
#endif
}
myServiceStatus.currentState = (int)State.SERVICE_RUNNING;
SetServiceStatus(handle, myServiceStatus);
}
// Stop this service.
protected override void OnStop()
{
// New in .NET Framework version 2.0.
this.RequestAdditionalTime(4000);
// Signal the worker thread to exit.
if ((workerThread != null) && (workerThread.IsAlive))
{
#if LOGEVENTS
EventLog.WriteEntry("SimpleService.OnStop", DateTime.Now.ToLongTimeString() +
" - Stopping the service worker thread.");
#endif
pause.Reset();
Thread.Sleep(5000);
workerThread.Abort();
}
if (workerThread != null)
{
#if LOGEVENTS
EventLog.WriteEntry("SimpleService.OnStop", DateTime.Now.ToLongTimeString() +
" - OnStop Worker thread state = " +
workerThread.ThreadState.ToString());
#endif
}
// Indicate a successful exit.
this.ExitCode = 0;
}
// Pause the service.
protected override void OnPause()
{
// Pause the worker thread.
if ((workerThread != null) &&
(workerThread.IsAlive) &&
((workerThread.ThreadState &
(System.Threading.ThreadState.Suspended | System.Threading.ThreadState.SuspendRequested)) == 0))
{
#if LOGEVENTS
EventLog.WriteEntry("SimpleService.OnPause", DateTime.Now.ToLongTimeString() +
" - Pausing the service worker thread.");
#endif
pause.Reset();
Thread.Sleep(5000);
}
if (workerThread != null)
{
#if LOGEVENTS
EventLog.WriteEntry("SimpleService.OnPause", DateTime.Now.ToLongTimeString() +
" OnPause - Worker thread state = " +
workerThread.ThreadState.ToString());
#endif
}
}
// Continue a paused service.
protected override void OnContinue()
{
// Signal the worker thread to continue.
if ((workerThread != null) &&
((workerThread.ThreadState &
(System.Threading.ThreadState.Suspended | System.Threading.ThreadState.SuspendRequested)) != 0))
{
#if LOGEVENTS
EventLog.WriteEntry("SimpleService.OnContinue", DateTime.Now.ToLongTimeString() +
" - Resuming the service worker thread.");
#endif
pause.Set();
}
if (workerThread != null)
{
#if LOGEVENTS
EventLog.WriteEntry("SimpleService.OnContinue", DateTime.Now.ToLongTimeString() +
" OnContinue - Worker thread state = " +
workerThread.ThreadState.ToString());
#endif
}
}
// Handle a custom command.
protected override void OnCustomCommand(int command)
{
#if LOGEVENTS
EventLog.WriteEntry("SimpleService.OnCustomCommand", DateTime.Now.ToLongTimeString() +
" - Custom command received: " +
command.ToString());
#endif
// If the custom command is recognized,
// signal the worker thread appropriately.
switch (command)
{
case (int)SimpleServiceCustomCommands.StopWorker:
// Signal the worker thread to terminate.
// For this custom command, the main service
// continues to run without a worker thread.
OnStop();
break;
case (int)SimpleServiceCustomCommands.RestartWorker:
// Restart the worker thread if necessary.
OnStart(null);
break;
case (int)SimpleServiceCustomCommands.CheckWorker:
#if LOGEVENTS
// Log the current worker thread state.
EventLog.WriteEntry("SimpleService.OnCustomCommand", DateTime.Now.ToLongTimeString() +
" OnCustomCommand - Worker thread state = " +
workerThread.ThreadState.ToString());
#endif
break;
default:
#if LOGEVENTS
EventLog.WriteEntry("SimpleService.OnCustomCommand",
DateTime.Now.ToLongTimeString());
#endif
break;
}
}
// Handle a session change notice
protected override void OnSessionChange(SessionChangeDescription changeDescription)
{
#if LOGEVENTS
EventLog.WriteEntry("SimpleService.OnSessionChange", DateTime.Now.ToLongTimeString() +
" - Session change notice received: " +
changeDescription.Reason.ToString() + " Session ID: " +
changeDescription.SessionId.ToString());
#endif
switch (changeDescription.Reason)
{
case SessionChangeReason.SessionLogon:
userCount += 1;
#if LOGEVENTS
EventLog.WriteEntry("SimpleService.OnSessionChange",
DateTime.Now.ToLongTimeString() +
" SessionLogon, total users: " +
userCount.ToString());
#endif
break;
case SessionChangeReason.SessionLogoff:
userCount -= 1;
#if LOGEVENTS
EventLog.WriteEntry("SimpleService.OnSessionChange",
DateTime.Now.ToLongTimeString() +
" SessionLogoff, total users: " +
userCount.ToString());
#endif
break;
case SessionChangeReason.RemoteConnect:
userCount += 1;
#if LOGEVENTS
EventLog.WriteEntry("SimpleService.OnSessionChange",
DateTime.Now.ToLongTimeString() +
" RemoteConnect, total users: " +
userCount.ToString());
#endif
break;
case SessionChangeReason.RemoteDisconnect:
userCount -= 1;
#if LOGEVENTS
EventLog.WriteEntry("SimpleService.OnSessionChange",
DateTime.Now.ToLongTimeString() +
" RemoteDisconnect, total users: " +
userCount.ToString());
#endif
break;
case SessionChangeReason.SessionLock:
#if LOGEVENTS
EventLog.WriteEntry("SimpleService.OnSessionChange",
DateTime.Now.ToLongTimeString() +
" SessionLock");
#endif
break;
case SessionChangeReason.SessionUnlock:
#if LOGEVENTS
EventLog.WriteEntry("SimpleService.OnSessionChange",
DateTime.Now.ToLongTimeString() +
" SessionUnlock");
#endif
break;
default:
break;
}
}
// Define a simple method that runs as the worker thread for
// the service.
public void ServiceWorkerMethod()
{
#if LOGEVENTS
EventLog.WriteEntry("SimpleService.WorkerThread", DateTime.Now.ToLongTimeString() +
" - Starting the service worker thread.");
#endif
try
{
do
{
// Simulate 4 seconds of work.
Thread.Sleep(4000);
// Block if the service is paused or is shutting down.
pause.WaitOne();
#if LOGEVENTS
EventLog.WriteEntry("SimpleService.WorkerThread", DateTime.Now.ToLongTimeString() +
" - heartbeat cycle.");
#endif
}
while (true);
}
catch (ThreadAbortException)
{
// Another thread has signalled that this worker
// thread must terminate. Typically, this occurs when
// the main service thread receives a service stop
// command.
// Write a trace line indicating that the worker thread
// is exiting. Notice that this simple thread does
// not have any local objects or data to clean up.
#if LOGEVENTS
EventLog.WriteEntry("SimpleService.WorkerThread", DateTime.Now.ToLongTimeString() +
" - Thread abort signaled.");
#endif
}
#if LOGEVENTS
EventLog.WriteEntry("SimpleService.WorkerThread", DateTime.Now.ToLongTimeString() +
" - Exiting the service worker thread.");
#endif
}
}
}
// Turn on the constant for trace output.
#define TRACE
#using <System.ServiceProcess.dll>
#using <System.dll>
using namespace System;
using namespace System::ComponentModel;
using namespace System::IO;
using namespace System::ServiceProcess;
using namespace System::Threading;
using namespace System::Diagnostics;
// Define custom commands for the SimpleService.
public enum class SimpleServiceCustomCommands
{
StopWorker = 128,
RestartWorker, CheckWorker
};
// Define a simple service implementation.
public ref class SimpleService: public System::ServiceProcess::ServiceBase
{
private:
Thread^ workerThread;
int userCount;
public:
SimpleService()
{
CanPauseAndContinue = true;
ServiceName = "SimpleService";
workerThread = nullptr;
CanHandleSessionChangeEvent = true;
}
private:
void InitializeComponent()
{
// Initialize the operating properties for the service.
this->CanPauseAndContinue = true;
this->CanShutdown = true;
this->ServiceName = "SimpleService";
this->CanHandleSessionChangeEvent = true;
}
// Start the service.
protected:
virtual void OnStart( array<String^>^ ) override
{
// Start a separate thread that does the actual work.
if ( (workerThread == nullptr) || ((workerThread->ThreadState & (System::Threading::ThreadState::Unstarted | System::Threading::ThreadState::Stopped)) != (System::Threading::ThreadState)0) )
{
Trace::WriteLine( DateTime::Now.ToLongTimeString() + " - Starting the service worker thread.", "OnStart" );
workerThread = gcnew Thread( gcnew ThreadStart( this,&SimpleService::ServiceWorkerMethod ) );
workerThread->Start();
}
if ( workerThread != nullptr )
{
Trace::WriteLine( DateTime::Now.ToLongTimeString() + " - Worker thread state = " + workerThread->ThreadState.ToString(), "OnStart" );
}
}
// Stop this service.
protected:
virtual void OnStop() override
{
// Signal the worker thread to exit.
if ( (workerThread != nullptr) && (workerThread->IsAlive) )
{
Trace::WriteLine( DateTime::Now.ToLongTimeString() + " - Stopping the service worker thread.", "OnStop" );
workerThread->Abort();
// Wait up to 500 milliseconds for the thread to terminate.
workerThread->Join( 500 );
}
if ( workerThread != nullptr )
{
Trace::WriteLine( DateTime::Now.ToLongTimeString() + " - Worker thread state = " + workerThread->ThreadState.ToString(), "OnStop" );
}
}
// Pause the service.
protected:
virtual void OnPause() override
{
// Pause the worker thread.
if ( (workerThread != nullptr) && (workerThread->IsAlive) && ((workerThread->ThreadState & (System::Threading::ThreadState::Suspended | System::Threading::ThreadState::SuspendRequested)) == (System::Threading::ThreadState)0) )
{
Trace::WriteLine( DateTime::Now.ToLongTimeString() + " - Suspending the service worker thread.", "OnPause" );
workerThread->Suspend();
}
if ( workerThread != nullptr )
{
Trace::WriteLine( DateTime::Now.ToLongTimeString() + " - Worker thread state = " + workerThread->ThreadState.ToString(), "OnPause" );
}
}
// Continue a paused service.
protected:
virtual void OnContinue() override
{
// Signal the worker thread to continue.
if ( (workerThread != nullptr) && ((workerThread->ThreadState & (System::Threading::ThreadState::Suspended | System::Threading::ThreadState::SuspendRequested)) != (System::Threading::ThreadState)0) )
{
Trace::WriteLine( DateTime::Now.ToLongTimeString() + " - Resuming the service worker thread.", "OnContinue" );
workerThread->Resume();
}
if ( workerThread != nullptr )
{
Trace::WriteLine( DateTime::Now.ToLongTimeString() + " - Worker thread state = " + workerThread->ThreadState.ToString(), "OnContinue" );
}
}
// Handle a custom command.
protected:
virtual void OnCustomCommand( int command ) override
{
Trace::WriteLine( DateTime::Now.ToLongTimeString() + " - Custom command received: " + command, "OnCustomCommand" );
// If the custom command is recognized,
// signal the worker thread appropriately.
switch ( command )
{
case (int)SimpleServiceCustomCommands::StopWorker:
// Signal the worker thread to terminate.
// For this custom command, the main service
// continues to run without a worker thread.
OnStop();
break;
case (int)SimpleServiceCustomCommands::RestartWorker:
// Restart the worker thread if necessary.
OnStart( nullptr );
break;
case (int)SimpleServiceCustomCommands::CheckWorker:
// Log the current worker thread state.
Trace::WriteLine( DateTime::Now.ToLongTimeString() + " - Worker thread state = " + workerThread->ThreadState.ToString(), "OnCustomCommand" );
break;
default:
Trace::WriteLine( DateTime::Now.ToLongTimeString() + " - Unrecognized custom command ignored!", "OnCustomCommand" );
break;
}
}
protected:
virtual void OnSessionChange(SessionChangeDescription changeDescription) override
{
Trace::WriteLine( DateTime::Now.ToLongTimeString() + " - Change description received: "
+ changeDescription.ToString(), "OnSessionChange" );
switch (changeDescription.Reason)
{
case SessionChangeReason::SessionLogon:
userCount += 1;
Trace::WriteLine( DateTime::Now.ToLongTimeString() +
" SessionLogon, total users: " +
userCount.ToString(), "OnSessionChange" );
break;
case SessionChangeReason::SessionLogoff:
userCount -= 1;
Trace::WriteLine( DateTime::Now.ToLongTimeString() +
" SessionLogoff, total users: " +
userCount.ToString(), "OnSessionChange" );
break;
case SessionChangeReason::RemoteConnect:
userCount += 1;
Trace::WriteLine( DateTime::Now.ToLongTimeString() +
" RemoteConnect, total users: " +
userCount.ToString(), "OnSessionChange" );
break;
case SessionChangeReason::RemoteDisconnect:
userCount -= 1;
Trace::WriteLine( DateTime::Now.ToLongTimeString() +
" RemoteDisconnect, total users: " +
userCount.ToString(), "OnSessionChange" );
break;
case SessionChangeReason::SessionLock:
Trace::WriteLine( DateTime::Now.ToLongTimeString() +
" SessionLock", "OnSessionChange" );
break;
case SessionChangeReason::SessionUnlock:
Trace::WriteLine( DateTime::Now.ToLongTimeString() +
" SessionUnlock", "OnSessionChange" );
break;
default:
Trace::WriteLine( DateTime::Now.ToLongTimeString() +
" - Unhandled session change event.", "OnSessionChange" );
break;
}
}
// Define a simple method that runs as the worker thread for
// the service.
public:
void ServiceWorkerMethod()
{
Trace::WriteLine( DateTime::Now.ToLongTimeString() + " - Starting the service worker thread.", "Worker" );
try
{
for ( ; ; )
{
// Wake up every 10 seconds and write
// a message to the trace output.
Thread::Sleep( 10000 );
Trace::WriteLine( DateTime::Now.ToLongTimeString() + " - heartbeat cycle.", "Worker" );
}
}
catch ( ThreadAbortException^ )
{
// Another thread has signalled that this worker
// thread must terminate. Typically, this occurs when
// the main service thread receives a service stop
// command.
// Write a trace line indicating that the worker thread
// is exiting. Notice that this simple thread does
// not have any local objects or data to clean up.
Trace::WriteLine( DateTime::Now.ToLongTimeString() + " - Thread abort signaled.", "Worker" );
}
Trace::WriteLine( DateTime::Now.ToLongTimeString() + " - Exiting the service worker thread.", "Worker" );
}
};
int main()
{
String^ logFile = "C:\\service_log.txt";
TextWriterTraceListener^ serviceTraceListener = nullptr;
// Create a log file for trace output.
// A new file is created each time. If a
// previous log file exists, it is overwritten.
StreamWriter^ myFile = File::CreateText( logFile );
// Create a new trace listener that writes to the text file,
// and add it to the collection of trace listeners.
serviceTraceListener = gcnew TextWriterTraceListener( myFile );
Trace::Listeners->Add( serviceTraceListener );
Trace::AutoFlush = true;
Trace::WriteLine( DateTime::Now.ToLongTimeString() + " - Service main method starting...", "Main" );
// Load the service into memory.
System::ServiceProcess::ServiceBase::Run( gcnew SimpleService );
Trace::WriteLine( DateTime::Now.ToLongTimeString() + " - Service main method exiting...", "Main" );
// Remove and close the trace listener for this service.
Trace::Listeners->Remove( serviceTraceListener );
serviceTraceListener->Close();
serviceTraceListener = nullptr;
myFile->Close();
}
Vererbungshierarchie
System.Object
System.MarshalByRefObject
System.ComponentModel.Component
System.ServiceProcess.ServiceBase
Threadsicherheit
Alle öffentlichen statischen (Shared in Visual Basic) Member dieses Typs sind threadsicher. Bei Instanzmembern ist die Threadsicherheit nicht gewährleistet.
Plattformen
Windows 98, Windows 2000 SP4, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition
.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.
Versionsinformationen
.NET Framework
Unterstützt in: 2.0, 1.1, 1.0
Siehe auch
Referenz
ServiceBase-Member
System.ServiceProcess-Namespace
ServiceProcessInstaller
ServiceInstaller