Tutorial: Membuat aplikasi layanan Windows

Artikel
04/08/2023

Peringatan

Dokumentasi ini bukan untuk versi terbaru Layanan Windows. Untuk konten terbaru tentang layanan Windows menggunakan BackgroundService dan templat Layanan Pekerja, lihat:

Artikel ini menunjukkan cara membuat aplikasi layanan Windows di Visual Studio yang menulis pesan ke log peristiwa.

Membuat layanan

Untuk memulai, buat proyek dan tetapkan nilai yang diperlukan agar layanan berfungsi dengan benar.

Dari menu File Visual Studio, pilih Proyek>Baru (atau tekan Ctrl+Shift+N) untuk membuka jendela Proyek Baru.
Temukan dan pilih templat proyek Windows Service (.NET Framework).

Catatan

Jika Anda tidak melihat kerangka Layanan Windows, Anda mungkin perlu memasang beban kerja .NET desktop development menggunakan Visual Studio Installer.
Untuk Nama, masukkan MyNewService, lalu pilih OK.

Tab Desain muncul (Service1.cs [Desain] atau Service1.vb [Desain]).

Template proyek menyertakan kelas komponen bernama Service1 yang mewarisi dari System.ServiceProcess.ServiceBase. Ini mencakup banyak kode layanan dasar, seperti kode untuk memulai layanan.

Ganti nama layanan

Ganti nama layanan dari Service1 menjadi MyNewService.

Di Penjelajah Solusi, pilih Service1.cs atau Service1.vb, dan pilih Ganti nama dari menu pintasan. Ganti nama file menjadi MyNewService.cs atau MyNewService.vb, lalu tekan Enter

Jendela pop-up muncul menanyakan apakah Anda ingin mengganti nama semua referensi ke elemen kode Service1.
Di jendela pop-up, pilih Ya.
Di tab Desain, pilih Properti dari menu pintasan. Dari jendela Properties, ubah nilai ServiceName menjadi MyNewService.
Pilih Simpan Semua dari menu File.

Tambahkan fitur ke layanan

Di bagian ini, Anda menambahkan log peristiwa kustom ke layanan Windows. Komponen EventLog adalah contoh jenis komponen yang dapat Anda tambahkan ke layanan Windows.

Tambahkan fungsionalitas log peristiwa khusus

Di Penjelajah Solusi, dari menu pintasan untuk MyNewService.cs atau MyNewService.vb, pilih View Designer.
Di Toolbox, luaskan Komponen, lalu seret komponen EventLog ke tab Service1.cs [Desain] atau Service1.vb [Desain].
Di Penjelajah Solusi, dari menu pintasan untuk MyNewService.cs atau MyNewService.vb, pilih Lihat Kode.

Tentukan log peristiwa khusus.

Untuk C#, edit konstruktor MyNewService() yang ada seperti yang ditunjukkan dalam cuplikan kode berikut. Untuk Visual Basic, tambahkan konstruktor New() seperti yang ditunjukkan dalam cuplikan kode berikut.

public MyNewService()
{
    InitializeComponent();
    eventLog1 = new System.Diagnostics.EventLog();
    if (!System.Diagnostics.EventLog.SourceExists("MySource"))
    {
        System.Diagnostics.EventLog.CreateEventSource(
            "MySource","MyNewLog");
    }
    eventLog1.Source = "MySource";
    eventLog1.Log = "MyNewLog";
}

' To access the constructor in Visual Basic, select New from the
' method name drop-down list. 
Public Sub New()
    MyBase.New()
    InitializeComponent()
    Me.EventLog1 = New System.Diagnostics.EventLog
    If Not System.Diagnostics.EventLog.SourceExists("MySource") Then
        System.Diagnostics.EventLog.CreateEventSource("MySource",
        "MyNewLog")
    End If
    EventLog1.Source = "MySource"
    EventLog1.Log = "MyNewLog"
End Sub

Tambahkan pernyataan using ke MyNewService.cs (jika belum ada), atau pernyataan Imports ke MyNewService.vb, untuk namespace System.Diagnostics:
```
using System.Diagnostics;
```
```
Imports System.Diagnostics
```
Pilih Simpan Semua dari menu File.

Tentukan apa yang terjadi ketika layanan dimulai

Di editor kode untuk MyNewService.cs atau MyNewService.vb, temukan metode OnStart. Visual Studio secara otomatis membuat definisi metode kosong saat Anda membuat proyek. Tambahkan kode yang menulis entri ke log peristiwa saat layanan dimulai:

protected override void OnStart(string[] args)
{
    eventLog1.WriteEntry("In OnStart.");
}

' To access the OnStart in Visual Basic, select OnStart from the
' method name drop-down list. 
Protected Overrides Sub OnStart(ByVal args() As String)
    EventLog1.WriteEntry("In OnStart")
End Sub

Polling

Karena aplikasi layanan dirancang untuk berjalan lama, biasanya aplikasi tersebut melakukan polling atau memantau sistem, yang Anda siapkan dalam metode OnStart. Metode OnStart harus kembali ke sistem operasi setelah operasi layanan dimulai agar sistem tidak diblokir.

Untuk menyiapkan mekanisme polling sederhana, gunakan komponen System.Timers.Timer. Timer menampilkan peristiwa Elapsed secara berkala, saat layanan Anda dapat melakukan pemantauannya. Anda menggunakan komponen Timer sebagai berikut:

Setel properti komponen Timer dalam metode MyNewService.OnStart.
Mulai pengatur waktu dengan memanggil metode Start.

Siapkan mekanisme pemungutan suara

Tambahkan pernyataan using ke MyNewService.cs, atau pernyataan Imports ke MyNewService.vb, untuk namespace System.Timers:
```
using System.Timers;
```
```
Imports System.Timers
```

Tambahkan kode berikut di peristiwa MyNewService.OnStart untuk menyiapkan mekanisme polling:

// Set up a timer that triggers every minute.
Timer timer = new Timer();
timer.Interval = 60000; // 60 seconds
timer.Elapsed += new ElapsedEventHandler(this.OnTimer);
timer.Start();

' Set up a timer that triggers every minute.
Dim timer As Timer = New Timer()
timer.Interval = 60000 ' 60 seconds
AddHandler timer.Elapsed, AddressOf Me.OnTimer
timer.Start()

Di kelas MyNewService, tambahkan variabel anggota. Ini berisi pengidentifikasi peristiwa berikutnya untuk ditulis ke dalam log peristiwa:
```
private int eventId = 1;
```
```
Private eventId As Integer = 1
```

Di kelas MyNewService, tambahkan metode OnTimer untuk menangani peristiwa Timer.Elapsed:

public void OnTimer(object sender, ElapsedEventArgs args)
{
    // TODO: Insert monitoring activities here.
    eventLog1.WriteEntry("Monitoring the System", EventLogEntryType.Information, eventId++);
}

Private Sub OnTimer(sender As Object, e As Timers.ElapsedEventArgs)
   ' TODO: Insert monitoring activities here.
   eventLog1.WriteEntry("Monitoring the System", EventLogEntryType.Information, eventId)
   eventId = eventId + 1
End Sub

Alih-alih menjalankan semua pekerjaan Anda di rangkaian utama, Anda dapat menjalankan tugas dengan menggunakan rangkaian pekerja latar belakang. Untuk informasi selengkapnya, lihat System.ComponentModel.BackgroundWorker.

Tentukan apa yang terjadi ketika layanan dihentikan

Sisipkan baris kode dalam metode OnStop yang menambahkan entri ke log peristiwa saat layanan dihentikan:

protected override void OnStop()
{
    eventLog1.WriteEntry("In OnStop.");
}

Protected Overrides Sub OnStop()
    EventLog1.WriteEntry("In OnStop.")
End Sub

Tentukan tindakan lain untuk layanan

Anda dapat mengganti metode OnPause, OnContinue, dan OnShutdown untuk menentukan pemrosesan tambahan untuk komponen Anda.

Kode berikut menunjukkan bagaimana Anda dapat mengambil alih OnContinue metode di MyNewService kelas :

protected override void OnContinue()
{
    eventLog1.WriteEntry("In OnContinue.");
}

Protected Overrides Sub OnContinue()
    EventLog1.WriteEntry("In OnContinue.")
End Sub

Tetapkan status layanan

Layanan melaporkan statusnya ke Pengelola Kontrol Layanan sehingga pengguna dapat mengetahui apakah layanan berfungsi dengan benar. Secara default, layanan yang mewarisi dari ServiceBase melaporkan serangkaian pengaturan status terbatas, yang mencakup SERVICE_STOPPED, SERVICE_PAUSED, dan SERVICE_RUNNING. Jika layanan memerlukan waktu beberapa saat untuk memulai, akan berguna untuk melaporkan status SERVICE_START_PENDING.

Anda dapat menerapkan pengaturan status SERVICE_START_PENDING dan SERVICE_STOP_PENDING dengan menambahkan kode yang memanggil fungsi SetServiceStatus Windows.

Terapkan status tertunda layanan

Tambahkan pernyataan using ke MyNewService.cs, atau pernyataan Imports ke MyNewService.vb, untuk namespace System.Runtime.InteropServices:
```
using System.Runtime.InteropServices;
```
```
Imports System.Runtime.InteropServices
```

Tambahkan kode berikut ke MyNewService.cs, atau MyNewService.vb, untuk mendeklarasikan nilai ServiceState dan untuk menambahkan struktur status, yang akan Anda gunakan di platform panggil panggilan:

public enum ServiceState
{
    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,
}

[StructLayout(LayoutKind.Sequential)]
public struct ServiceStatus
{
    public int dwServiceType;
    public ServiceState dwCurrentState;
    public int dwControlsAccepted;
    public int dwWin32ExitCode;
    public int dwServiceSpecificExitCode;
    public int dwCheckPoint;
    public int dwWaitHint;
};

Public Enum ServiceState
    SERVICE_STOPPED = 1
    SERVICE_START_PENDING = 2
    SERVICE_STOP_PENDING = 3
    SERVICE_RUNNING = 4
    SERVICE_CONTINUE_PENDING = 5
    SERVICE_PAUSE_PENDING = 6
    SERVICE_PAUSED = 7
End Enum

<StructLayout(LayoutKind.Sequential)>
Public Structure ServiceStatus
    Public dwServiceType As Long
    Public dwCurrentState As ServiceState
    Public dwControlsAccepted As Long
    Public dwWin32ExitCode As Long
    Public dwServiceSpecificExitCode As Long
    Public dwCheckPoint As Long
    Public dwWaitHint As Long
End Structure

Catatan

Pengelola Kontrol Layanan menggunakan anggota dwWaitHint dan dwCheckpoint dari struktur SERVICE_STATUS untuk menentukan berapa lama waktu yang dibutuhkan untuk menunggu layanan Windows dimulai atau dimatikan. Jika metode OnStart dan OnStop Anda berjalan lama, layanan Anda dapat meminta lebih banyak waktu dengan memanggil SetServiceStatus lagi dengan nilai dwCheckPoint yang bertambah.

Di kelas MyNewService, nyatakan fungsi SetServiceStatus dengan menggunakan platform memanggil:

[DllImport("advapi32.dll", SetLastError = true)]
private static extern bool SetServiceStatus(System.IntPtr handle, ref ServiceStatus serviceStatus);

Declare Auto Function SetServiceStatus Lib "advapi32.dll" (ByVal handle As IntPtr, ByRef serviceStatus As ServiceStatus) As Boolean

Untuk menerapkan status SERVICE_START_PENDING, tambahkan kode berikut ke awal metode OnStart:

// Update the service state to Start Pending.
ServiceStatus serviceStatus = new ServiceStatus();
serviceStatus.dwCurrentState = ServiceState.SERVICE_START_PENDING;
serviceStatus.dwWaitHint = 100000;
SetServiceStatus(this.ServiceHandle, ref serviceStatus);

' Update the service state to Start Pending.
Dim serviceStatus As ServiceStatus = New ServiceStatus()
serviceStatus.dwCurrentState = ServiceState.SERVICE_START_PENDING
serviceStatus.dwWaitHint = 100000
SetServiceStatus(Me.ServiceHandle, serviceStatus)

Tambahkan kode di akhir metode OnStart untuk mengatur status ke SERVICE_RUNNING:

// Update the service state to Running.
serviceStatus.dwCurrentState = ServiceState.SERVICE_RUNNING;
SetServiceStatus(this.ServiceHandle, ref serviceStatus);

' Update the service state to Running.
serviceStatus.dwCurrentState = ServiceState.SERVICE_RUNNING
SetServiceStatus(Me.ServiceHandle, serviceStatus)

(Opsional) Jika OnStop adalah metode yang berjalan lama, ulangi prosedur ini dalam metode OnStop. Terapkan status SERVICE_STOP_PENDING dan kembalikan status SERVICE_STOPPED sebelum metode OnStop keluar.

Contohnya:

// Update the service state to Stop Pending.
ServiceStatus serviceStatus = new ServiceStatus();
serviceStatus.dwCurrentState = ServiceState.SERVICE_STOP_PENDING;
serviceStatus.dwWaitHint = 100000;
SetServiceStatus(this.ServiceHandle, ref serviceStatus);

// Update the service state to Stopped.
serviceStatus.dwCurrentState = ServiceState.SERVICE_STOPPED;
SetServiceStatus(this.ServiceHandle, ref serviceStatus);

' Update the service state to Stop Pending.
Dim serviceStatus As ServiceStatus = New ServiceStatus()
serviceStatus.dwCurrentState = ServiceState.SERVICE_STOP_PENDING
serviceStatus.dwWaitHint = 100000
SetServiceStatus(Me.ServiceHandle, serviceStatus)

' Update the service state to Stopped.
serviceStatus.dwCurrentState = ServiceState.SERVICE_STOPPED
SetServiceStatus(Me.ServiceHandle, serviceStatus)

Tambahkan penginstal ke layanan

Sebelum Anda menjalankan layanan Windows, Anda perlu menginstalnya, yang mendaftarkannya ke Service Control Manager. Tambahkan penginstal ke proyek Anda untuk menangani detail pendaftaran.

Di Penjelajah Solusi, dari menu pintasan untuk MyNewService.cs, atau MyNewService.vb, pilih View Designer.
Pada tampilan Desain, pilih area latar belakang, lalu pilih Tambahkan Pemasang dari menu pintasan.

Secara default, Visual Studio menambahkan kelas komponen bernama ProjectInstaller, yang berisi dua penginstal, ke proyek Anda. Pemasang ini untuk layanan Anda dan untuk proses terkait layanan.
Pada tampilan Desain untuk ProjectInstaller, pilih serviceInstaller1 untuk proyek Visual C#, atau ServiceInstaller1 untuk proyek Visual Basic, lalu pilih Properti dari menu pintasan.
Di jendela Properties, pastikan properti ServiceName diatur ke MyNewService.
Tambahkan teks ke properti Description, seperti Layanan sampel.

Teks ini muncul di kolom Deskripsi pada jendela Layanan dan menjelaskan layanan kepada pengguna.
Tambahkan teks ke properti DisplayName. Misalnya, Nama Tampilan LayananBaruku.

Teks ini muncul di kolom Nama Tampilan pada jendela Layanan. Nama ini dapat berbeda dari properti ServiceName, yang merupakan nama yang digunakan sistem (misalnya, nama yang Anda gunakan untuk perintah net start untuk memulai layanan Anda).
Setel properti StartType ke Automatic dari daftar tarik-turun.
Setelah selesai, jendela Properties akan terlihat seperti gambar berikut:
Pada tampilan Desain untuk ProjectInstaller, pilih serviceProcessInstaller1 untuk proyek Visual C#, atau ServiceProcessInstaller1 untuk proyek Visual Basic, lalu pilih Properti dari menu pintasan. Setel properti Account ke LocalSystem dari daftar tarik-turun.

Pengaturan ini menginstal layanan dan menjalankannya dengan menggunakan akun sistem lokal.

Penting

Akun LocalSystem memiliki izin yang luas, termasuk kemampuan untuk menulis ke log peristiwa. Gunakan akun ini dengan hati-hati, karena dapat meningkatkan risiko serangan dari perangkat lunak berbahaya. Untuk tugas lain, pertimbangkan untuk menggunakan akun LocalService, yang bertindak sebagai pengguna yang tidak memiliki hak istimewa di komputer lokal dan memberikan kredensial anonim ke server jauh mana pun. Contoh ini gagal jika Anda mencoba menggunakan akun LocalService, karena memerlukan izin untuk menulis ke log peristiwa.

Untuk informasi selengkapnya tentang pemasang, lihat Cara: Menambahkan pemasang ke aplikasi layanan Anda.

(Opsional) Setel parameter startup

Catatan

Sebelum Anda memutuskan untuk menambahkan parameter startup, pertimbangkan apakah itu cara terbaik untuk meneruskan informasi ke layanan Anda. Meskipun mudah digunakan dan diuraikan, dan pengguna dapat dengan mudah menimpanya, mereka mungkin lebih sulit ditemukan dan digunakan oleh pengguna tanpa dokumentasi. Umumnya, jika layanan Anda memerlukan lebih dari beberapa parameter startup, Anda harus menggunakan registri atau file konfigurasi.

Layanan Windows dapat menerima argumen baris perintah, atau parameter startup. Saat Anda menambahkan kode untuk memproses parameter startup, pengguna dapat memulai layanan Anda dengan parameter startup kustom mereka sendiri di jendela properti layanan. Namun, parameter startup ini tidak bertahan saat layanan dimulai lagi. Untuk mengatur parameter startup secara permanen, atur di registri.

Setiap layanan Windows memiliki entri registri di bawah subkunci HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services. Di bawah setiap subkunci layanan, gunakan subkunci Parameters untuk menyimpan informasi yang dapat diakses oleh layanan Anda. Anda dapat menggunakan file konfigurasi aplikasi untuk layanan Windows dengan cara yang sama seperti yang Anda lakukan untuk jenis program lainnya. Untuk kode sampel, lihat ConfigurationManager.AppSettings.

Untuk menambahkan parameter startup

Pilih Program.cs, atau MyNewService.Designer.vb, lalu pilih Lihat Kode dari menu pintasan. Dalam metode Main, ubah kode untuk menambahkan parameter input dan berikan ke konstruktor layanan:

static void Main(string[] args)
{
    ServiceBase[] ServicesToRun;
    ServicesToRun = new ServiceBase[]
    {
        new MyNewService(args)
    };
    ServiceBase.Run(ServicesToRun);
}

Shared Sub Main(ByVal cmdArgs() As String)
    Dim ServicesToRun() As System.ServiceProcess.ServiceBase = New System.ServiceProcess.ServiceBase() {New MyNewService(cmdArgs)}
    System.ServiceProcess.ServiceBase.Run(ServicesToRun)
End Sub

Di MyNewService.cs, atau MyNewService.vb, ubah konstruktor MyNewService untuk memproses parameter input sebagai berikut:

using System.Diagnostics;

public MyNewService(string[] args)
{
    InitializeComponent();

    string eventSourceName = "MySource";
    string logName = "MyNewLog";

    if (args.Length > 0)
    {
       eventSourceName = args[0];
    }

    if (args.Length > 1)
    {
        logName = args[1];
    }

    eventLog1 = new EventLog();

    if (!EventLog.SourceExists(eventSourceName))
    {
        EventLog.CreateEventSource(eventSourceName, logName);
    }

    eventLog1.Source = eventSourceName;
    eventLog1.Log = logName;
}

Imports System.Diagnostics

Public Sub New(ByVal cmdArgs() As String)
    InitializeComponent()
    Dim eventSourceName As String = "MySource"
    Dim logName As String = "MyNewLog"
    If (cmdArgs.Count() > 0) Then
        eventSourceName = cmdArgs(0)
    End If
    If (cmdArgs.Count() > 1) Then
        logName = cmdArgs(1)
    End If
    eventLog1 = New EventLog()
    If (Not EventLog.SourceExists(eventSourceName)) Then
        EventLog.CreateEventSource(eventSourceName, logName)
    End If
    eventLog1.Source = eventSourceName
    eventLog1.Log = logName
End Sub

Kode ini menetapkan sumber peristiwa dan nama log sesuai dengan parameter startup yang disediakan pengguna. Jika tidak ada argumen yang diberikan, ia menggunakan nilai default.

Untuk menentukan argumen baris perintah, tambahkan kode berikut ke kelas ProjectInstaller di ProjectInstaller.cs, atau ProjectInstaller.vb:
```
protected override void OnBeforeInstall(IDictionary savedState)
{
    string parameter = "MySource1\" \"MyLogFile1";
    Context.Parameters["assemblypath"] = "\"" + Context.Parameters["assemblypath"] + "\" \"" + parameter + "\"";
    base.OnBeforeInstall(savedState);
}
```
```
Protected Overrides Sub OnBeforeInstall(ByVal savedState As IDictionary)
    Dim parameter As String = "MySource1"" ""MyLogFile1"
    Context.Parameters("assemblypath") = """" + Context.Parameters("assemblypath") + """ """ + parameter + """"
    MyBase.OnBeforeInstall(savedState)
End Sub
```
Biasanya, nilai ini berisi path lengkap ke executable untuk layanan Windows. Untuk memulai layanan dengan benar, pengguna harus memberikan tanda kutip untuk jalur dan setiap parameter individu. Pengguna dapat mengubah parameter di entri registri ImagePath untuk mengubah parameter startup untuk layanan Windows. Namun, cara yang lebih baik adalah mengubah nilai secara terprogram dan mengekspos fungsionalitas dengan cara yang mudah digunakan, seperti dengan menggunakan utilitas manajemen atau konfigurasi.

Bangun layanan

Di Penjelajah Solusi, pilih Properties dari menu pintasan untuk proyek MyNewService.

Halaman properti untuk proyek Anda muncul.
Pada tab Application, dalam daftar Startup object, pilih MyNewService.Program, atau Sub Main untuk proyek Visual Basic.
Untuk membangun proyek, di Penjelajah Solusi, pilih Bangun dari menu pintasan untuk proyek Anda (atau tekan Ctrl+Shift+B).

Instal layanan

Sekarang setelah Anda membangun layanan Windows, Anda dapat menginstalnya. Untuk menginstal layanan Windows, Anda harus memiliki kredensial administrator di komputer tempat layanan tersebut diinstal.

Buka Prompt Perintah Pengembang untuk Visual Studio dengan kredensial administratif.
Di Prompt Perintah Pengembang untuk Visual Studio, navigasikan ke folder yang berisi output proyek Anda (secara default, subdirektori \bin\Debug proyek Anda).
Masukkan perintah berikut:
```
installutil MyNewService.exe
```
Jika layanan berhasil diinstal, perintah melaporkan keberhasilan.

Jika sistem tidak dapat menemukan installutil.exe, pastikan itu ada di komputer Anda. Alat ini dipasang dengan .NET Framework ke folder %windir%\Microsoft.NET\Framework[64]\<versi kerangka>. Misalnya, jalur default untuk versi 64-bit adalah %windir%\Microsoft.NET\Framework64\v4.0.30319\InstallUtil.exe.

Jika proses installutil.exe gagal, periksa log pemasangan untuk mengetahui alasannya. Secara default, log berada di folder yang sama dengan layanan yang dapat dieksekusi. Instalasi dapat gagal jika:
- Kelas RunInstallerAttribute tidak ada di kelas ProjectInstaller.
- Atribut tidak diatur ke true.
- Kelas ProjectInstaller tidak didefinisikan sebagai public.

Untuk informasi selengkapnya, lihat Cara: Menginstal dan menghapus instalan layanan.

Mulai dan jalankan layanan

Di Windows, buka aplikasi desktop Layanan. Tekan Windows+R untuk membuka kotak Run, masukkan services.msc, lalu tekan Enter atau pilih Oke.

Anda akan melihat layanan Anda terdaftar di Layanan, ditampilkan menurut abjad dengan nama tampilan yang Anda tetapkan untuknya.
Untuk memulai layanan, pilih Mulai dari menu pintasan layanan.
Untuk menghentikan layanan, pilih Stop dari menu pintasan layanan.
(Opsional) Dari baris perintah, gunakan perintah net start <service name> dan net stop <service name> untuk memulai dan menghentikan layanan Anda.

Verifikasi output log peristiwa dari layanan Anda

Di Windows, buka aplikasi desktop Pemantau Peristiwa. Masukkan Pemantau Peristiwa di bilah penelusuran Windows, lalu pilih Pemantau Peristiwa dari hasil penelusuran.

Tip

Di Visual Studio, Anda dapat mengakses log peristiwa dengan membuka Server Explorer dari menu Tampilan (atau tekan Ctrl+Alt+S) dan memperluas node Log Peristiwa untuk komputer lokal.
Di Pemantau Peristiwa, luaskan Aplikasi dan Log Layanan.
Temukan cantuman untuk MyNewLog (atau MyLogFile1 jika Anda mengikuti prosedur untuk menambahkan argumen baris perintah) dan perluas. Anda akan melihat entri untuk dua tindakan (mulai dan hentikan) yang dilakukan layanan Anda.

Membersihkan sumber daya

Jika Anda tidak lagi membutuhkan aplikasi layanan Windows, Anda dapat menghapusnya.

Buka Prompt Perintah Pengembang untuk Visual Studio dengan kredensial administratif.
Di jendela Developer Command Prompt untuk Visual Studio, navigasikan ke folder yang berisi output proyek Anda.
Masukkan perintah berikut:
```
installutil.exe /u MyNewService.exe
```
Jika layanan berhasil dihapus, perintah melaporkan bahwa layanan Anda berhasil dihapus. Untuk informasi selengkapnya, lihat Cara: Menginstal dan menghapus instalan layanan.

Langkah berikutnya

Sekarang setelah Anda membuat layanan, Anda dapat:

Buat program pengaturan mandiri untuk digunakan orang lain untuk menginstal layanan Windows Anda. Gunakan WiX Toolset untuk membuat penginstal untuk layanan Windows. Untuk gagasan lain, lihat Membuat paket pemasang.
Jelajahi komponen ServiceController, yang memungkinkan Anda mengirim perintah ke layanan yang telah Anda pasang.
Daripada membuat log peristiwa saat aplikasi berjalan, gunakan penginstal untuk membuat log peristiwa saat Anda menginstal aplikasi. Log peristiwa dihapus oleh penginstal saat Anda menghapus instalan aplikasi. Untuk informasi selengkapnya, lihat EventLogInstaller.