Gewusst wie: Erstellen von Protokolldateien
Aktualisiert: November 2007
Sie können Protokolldateien mit Diagnoseinformationen zur Interoperabilität, zum Laden des Programms und zum Netzwerk erstellen. Zum Aktivieren der Protokollierung legen Sie die Registrierungsschlüssel fest. Legen Sie zunächst einen Registrierungsschlüssel zum Aktivieren der allgemeinen Protokollierung und anschließend die Registrierungsschlüssel für die gewünschte Protokollierungskomponente und die entsprechenden Optionen fest.
Sie können die folgenden Methoden zum Festlegen von Registrierungsschlüsseln verwenden:
Verwenden Sie den Remote Registry Editor in Visual Studio.
Verwenden Sie im .NET Compact Framework 2.0 Service Pack 1 die Protokollierungsoptionen in Remote Performance Monitor. Weitere Informationen über den Remote Performance Monitor finden Sie unter Gewusst wie: Überwachen der Leistung zur Laufzeit.
In .NET Compact Framework 3.5 können Sie das Protokollierungstool NetCFLogging.exe verwenden, das eine einfache grafische Benutzeroberfläche zum Aktivieren und Deaktivieren der Protokollierung bereitstellt. Dieses Tool ist in den Power Toys für .NET Compact Framework enthalten. Weitere Informationen finden Sie unter Power Toys for .NET Compact Framework.
Verwenden Sie die Registry-Klasse und die RegistryKey-Klasse, die in .NET Compact Framework Version 2.0 und höheren Versionen unterstützt werden.
Die Protokolldateien sind in der folgenden Tabelle zusammengefasst.
Protokollierungskomponente |
Inhalt der Protokolldatei |
|---|---|
Interop |
Protokolliert COM-Interop-Aufrufe. Stellt Informationen zu Plattformaufrufen und Marshalling bereit. |
Fehler |
Protokolliert alle nicht behandelten und systemeigenen Ausnahmen. Fehler werden in einer Protokolldatei und in OutputDebugString protokolliert. Die Protokolldatei wird für jede Assembly im aktuellen Pfad erstellt und bezieht sich auf die aktuelle Sitzung. Nach dem ersten Auftreten einer nicht behandelten oder systemeigenen Ausnahme wird die Protokolldatei überschrieben. |
Loader |
Protokolliert Informationen über das Laden des Programms. Dieser Dateiheader enthält die folgenden Informationen:
Die Datei enthält die folgenden Informationen:
Sie können auch Informationen über den globalen Assemblycache einschließen. |
Networking |
Protokolliert den Netzwerkverkehr. Die Netzwerkprotokolldatei ist binär, sodass ohne den .NET Compact Framework-Protokoll-Viewer, Logviewer.exe, nicht darauf zugegriffen werden kann. In .NET Compact Framework 3.5 und höher ist der Protokoll-Viewer in den Power Toys für .NET Compact Framework enthalten. Weitere Informationen finden Sie unter Power Toys for .NET Compact Framework. Da die Netzwerkprotokollierung auf der Windows Sockets-Ebene erfolgt, enthält die Protokolldatei nur Informationen über Netzwerkpakete. Dazu gehören die über das Netzwerk gesendeten Daten, die sensibel sein können, falls sie nicht verschlüsselt sind. |
Finalizer |
Protokolliert den Klassennamen von Objekten, die nicht freigegeben wurden, bevor sie vom Garbage Collector verworfen wurden. Dieses Protokoll wird in .NET Compact Framework 3.5 und höheren Versionen unterstützt. Die Objektnamen sind im Protokoll nicht enthalten, da die Namen für die Common Language Runtime (CLR) nicht verfügbar sind. Die Klassennamen nicht freigegebener Objekte können jedoch bei der Identifizierung dieser Objekte helfen. Nicht freigegebene Objekte können in Anwendungen zu Leistungseinbußen führen. .gif "Hinweis") Hinweis:
In einigen Fällen wird der Finalizer von .NET Compact Framework statt vom Anwendungscode aufgerufen.
Diese Datei enthält die folgenden Informationen:
|
Trace |
Protokolliert Ausnahmen im Code für Windows Communication Foundation (WCF). Auf dem Desktop unterstützt .NET Framework drei Arten der Protokollierung: Ablaufverfolgung, Messaging und Ereignisprotokollierung. WCF auf .NET Compact Framework unterstützt nur die Ablaufverfolgungsprotokollierung zur Verfolgung von Codeausnahmen. Warn- und Fehlermeldungen werden jedoch nicht protokolliert. Dieses Protokoll wird in .NET Compact Framework 3.5 und höheren Versionen unterstützt. |
Standardmäßig werden Protokolldateien in das Verzeichnis geschrieben, das auch die Anwendung enthält, für die die Diagnose erstellt wird. Sie können jedoch mithilfe von Registrierungsschlüsseln auch einen anderen Pfad und weitere Optionen angeben. Dabei haben Sie folgende Möglichkeiten:
Verwenden Sie einen alternativen Pfad für die Protokolldateien. Dies erfordert privilegierten Zugriff auf die sichere Registrierung.
Schließen Sie den Anwendungsnamen in den Namen der Protokolldatei ein.
Schließen Sie die Prozess-ID in den Namen der Protokolldatei ein.
Der Name einer Protokolldatei ist in die folgenden Teile gegliedert, wobei die Komponente als "Interop", "Error", "Loader", "Network", "Finalizer" oder "Trace" angegeben wird:
netcf_application-name_Komponente_processID.log
Der Anwendungsname und die Prozess-ID sind optional und basieren auf Registrierungseinstellungen.
Beispielsweise könnte eine Ladeprogrammprotokolldatei für eine Anwendung mit dem Namen MyApp.exe wie folgt genannt werden:
netcf_MyApp_Loader_2066923010.log
Informationen zum Überprüfen von Protokolldateien, wie z. B. die Interop- oder Loader-Protokolldatei, finden Sie unter Protokolldateiinformationen.
So aktivieren Sie die Protokollierung
Legen Sie den Wert des folgenden Schlüssels Enabled auf 1 fest:
HKLM\Software\Microsoft\.NETCompactFramework\Diagnostics\Logging\Enabled
Dieser Schlüsselwert muss festgelegt werden, um die sechs Typen der Protokollierung zu aktivieren: Interop, Loader, Error, Networking, Finalizer und Trace. Beachten Sie, dass die Unterschlüssel unter Logging standardmäßig nicht vorhanden sind.
Sie können die Protokollierung vollständig deaktivieren, indem Sie diesen Wert auf 0 (null) festlegen.
So geben Sie einen Pfad für die Protokolldatei an (optional)
Legen Sie den Wert des folgenden Schlüssels Path auf eine Zeichenfolge fest, die den Speicherort für die Protokolldateien darstellt:
HKLM\Security\.NETCompactFramework\Diagnostics\Logging\Path
Auf diesen Schlüssel können nur Anwendungen zugreifen, die in die sichere Registrierung schreiben können. Wenn kein Pfad angegeben wird, wird die Protokolldatei in das Verzeichnis geschrieben, in dem auch die Anwendung enthalten ist.
So schließen Sie die Anwendung in den Namen ein (optional)
Legen Sie den Wert des folgenden Schlüssels UseApp auf 1 fest:
HKLM\Software\Microsoft\.NETCompactFramework\Diagnostics\Logging\UseApp
Dieser Schlüssel ist nützlich, wenn Sie mehrere Anwendungen ausführen und separate Protokolldateien für die einzelnen Anwendungen erstellen möchten. Wenn zwei Anwendungen Protokolldateien in dasselbe Verzeichnis schreiben, wird bei Ausführung der zweiten Anwendung immer die ältere Protokolldatei durch die neuere überschrieben. Der Schlüssel UseApp kann zum Differenzieren der Protokolldateien verwendet werden.
So schließen Sie die Prozess-ID in den Namen ein (optional)
Legen Sie den Wert des folgenden Schlüssels UsePid auf 1 fest:
HKLM\Software\Microsoft\.NETCompactFramework\Diagnostics\Logging\UsePid
Dieser Schlüssel ist nützlich, wenn Sie eine Anwendung mehrere Male ausführen und separate Protokolldateien für die einzelnen Instanzen erstellen möchten. Durch diese Einstellung wird dem Namen der Protokolldatei die Prozess-ID hinzugefügt, sodass bei jeder Instanz der Anwendung eine neue Protokolldatei mit einem anderen Namen erstellt wird.
So protokollieren Sie Ereignisse sofort nach dem Auftreten (optional)
Legen Sie den Wert des folgenden Schlüssels Flush auf 1 fest:
HKLM\Software\Microsoft\.NETCompactFramework\Diagnostics\Logging\Flush
Dieser Wert bewirkt, dass die Common Language Runtime (CLR) Ereignisse sofort nach dem Auftreten in die Protokolldatei schreibt, statt diese im Puffer zu abzulegen und erst in das Protokoll zu schreiben, wenn der Puffer voll ist. Diese Einstellung wirkt sich nachteilig auf die Anwendungsleistung aus und kann das Timing der Anwendung geringfügig verändern. Sie kann jedoch für Diagnoseprobleme im Zusammenhang mit Anwendungsfehlern oder anderen Fehlern hilfreich sein, bei denen die letzten wenigen Ereignisse, die zum Fehler geführt haben, angezeigt werden sollen. Wenn dieser Schlüssel nicht vorhanden oder nicht festgelegt ist, werden Daten erst in die Protokolldateien geschrieben, wenn der Puffer voll ist.
Interop-Protokollierung
So aktivieren Sie die Interop-Protokollierung
Legen Sie den Wert des folgenden Schlüssels Enabled auf 1 fest:
HKLM\Software\Microsoft\.NETCompactFramework\Diagnostics\Logging\Interop\Enabled
Fehlerprotokollierung
So aktivieren Sie die Fehlerprotokollierung
Legen Sie den folgenden Wert von Enabled auf 1 fest:
HKLM\Software\Microsoft\.NETCompactFramework\Diagnostics\Logging\Error\Enabled
Ladeprogrammprotokollierung
So aktivieren Sie die Ladeprogrammprotokollierung
Legen Sie den folgenden Wert von Enabled auf 1 fest, um die Protokollierung für das Ladeprogramm zu aktivieren, oder auf 2, um die Protokollierung für das Ladeprogramm und den globalen Assemblycache zu aktivieren.
HKLM\Software\Microsoft\.NETCompactFramework\Diagnostics\Logging\Loader\Enabled
Netzwerkprotokollierung
So aktivieren Sie die Netzwerkprotokollierung
Legen Sie den folgenden Wert von Enabled auf 1 fest:
HKLM\Software\Microsoft\.NETCompactFramework\Diagnostics\Logging\Networking\Enabled
Die Netzwerkprotokolldatei ist eine Binärdatei, die ohne den .NET Compact Framework-Protokoll-Viewer, Logviewer.exe, der das Protokoll vom Binärformat in lesbares Format übersetzt wird, nicht gelesen werden kann. In .NET Compact Framework 3.5 und höher ist der Protokoll-Viewer in den Power Toys für .NET Compact Framework enthalten. Sie können dieses Tool von der .NET Compact Framework-Downloadseite herunterladen.
Finalizerprotokollierung
So aktivieren Sie die Finalizerprotokollierung
Legen Sie den folgenden Wert von Enabled auf 1 fest:
HKLM\Software\Microsoft\.NETCompactFramework\Diagnostics\Logging\Finalizer\Enabled
Ablaufverfolgungsprotokollierung
So aktivieren Sie die WCF-Ablaufverfolgungsprotokollierung
Legen Sie den folgenden Wert von Enabled auf 1 fest:
HKLM\Software\Microsoft\.NETCompactFramework\Diagnostics\Logging\WCF\Enabled
Beispiel
Sie können Werte für Registrierungsschlüssel mit dem Remote Registry Editor festlegen oder eine Anwendung schreiben, durch die die Werte festgelegt werden. Das Beispiel in diesem Abschnitt enthält die folgenden Methoden, durch die die erforderlichen Registrierungsaufgaben behandelt werden:
Durch die EnableLogging-Methode wird die allgemeine Protokollierung aktiviert. Sie enthält Parameter zum Angeben eines alternativen Protokolldateipfads sowie dazu, ob Anwendungsname und Prozess-ID dem Protokolldateinamen hinzugefügt werden und ob Ereignisse bei ihrem Eintreten protokolliert werden sollen.
Mit der SetInteropLogging-Methode, der SetLoaderLogging-Methode und der SetNetworkLogging-Methode wird der entsprechende Wert des Schlüssel Enabled auf den Wert 1 festgelegt, wodurch die Protokollierung für die entsprechende Komponente aktiviert wird.
Mit der DisableLogging-Methode wird die Protokollierung vollständig deaktiviert.
Mit der WriteLoggingSettings-Methode werden die Schlüssel unter dem Unterschlüssel Logging rekursiv untersucht und die entsprechenden Namen und Werte in eine Protokolldatei geschrieben. Die Protokolldatei hat den Namen logsettings.txt und befindet sich in dem Verzeichnis, in dem diese Beispielanwendung enthalten ist.
' This method enables general logging. It contains parameters
' to specify a path, and Boolean values of true to include
' the application name, process ID, and events in the log.
Private Sub EnableLogging(ByVal useApp As Boolean, ByVal usePid As Boolean, ByVal useFlush As Boolean)
' Specify values for setting the registry.
Dim userRoot As String = "HKEY_LOCAL_MACHINE"
Dim subkey As String = "SOFTWARE\Microsoft\.NETCompactFramework\Diagnostics\Logging"
Dim keyName As String = userRoot + "\" + subkey
' Set the Enabled registry value.
Registry.SetValue(keyName, "Enabled", 1)
If useApp = True Then
Registry.SetValue(keyName, "UseApp", 1)
Else
Registry.SetValue(keyName, "UseApp", 0)
End If
If usePid = True Then
Registry.SetValue(keyName, "UsePid", 1)
Else
Registry.SetValue(keyName, "UsePid", 0)
End If
If useFlush = True Then
Registry.SetValue(keyName, "UseFlush", 1)
Else
Registry.SetValue(keyName, "UseFlush", 0)
End If
End Sub
' This method sets the Enabled key value to 1
' so that logging for Interoperability is enabled.
Private Sub SetInteropLogging(ByVal logOn As Boolean)
' Specify values for setting the registry.
Dim userRoot As String = "HKEY_LOCAL_MACHINE"
Dim subkey As String = "Software\Microsoft\.NETCompactFramework\Diagnostics\Logging\Interop"
Dim keyName As String = userRoot + "\" + subkey
Dim logSet As Integer
If logOn = True Then
logSet = 1
Else
logSet = 0
End If
' Set the registry value.
Try
Registry.SetValue(keyName, "Enabled", logSet)
If logOn = True Then
MessageBox.Show("Interop Logging On")
Else
MessageBox.Show("Interop Logging Off")
End If
Catch ex As System.Exception
MessageBox.Show(ex.Message)
End Try
End Sub
' This method sets the Enabled key value to 1
' so that logging for class loading is enabled.
Private Sub SetLoaderLogging(ByVal logOn As Boolean)
' Specify values for setting the registry.
Dim userRoot As String = "HKEY_LOCAL_MACHINE"
Dim subkey As String = "Software\Microsoft\.NETCompactFramework\Diagnostics\Logging\Loader"
Dim keyName As String = userRoot + "\" + subkey
Dim logSet As Integer
If logOn = True Then
logSet = 1
Else
logSet = 0
End If
' Set the registry value.
Try
Registry.SetValue(keyName, "Enabled", logSet)
If logOn = True Then
MessageBox.Show("Loader Logging On")
Else
MessageBox.Show("Loader Loggin Off")
End If
Catch ex As System.Exception
MessageBox.Show(ex.Message)
End Try
End Sub
' This method sets the Enabled key value to 1,
' so that logging for networking is enabled.
Private Sub SetNetworkLogging(ByVal logOn As Boolean)
' Specify values for setting the registry.
Dim userRoot As String = "HKEY_LOCAL_MACHINE"
Dim subkey As String = "Software\Microsoft\.NETCompactFramework\Diagnostics\Logging\Networking"
Dim keyName As String = userRoot + "\" + subkey
Dim logSet As Integer
If logOn = True Then
logSet = 1
Else
logSet = 0
End If
' Set the registry value.
Try
Registry.SetValue(keyName, "Enabled", logSet)
If logOn = True Then
MessageBox.Show("Networking Logging On")
Else
MessageBox.Show("Networking Logging Off")
End If
Catch ex As System.Exception
MessageBox.Show(ex.Message)
End Try
End Sub
' This method disables all logging.
Private Sub DisableLogging()
' Specify values for setting the registry.
Dim userRoot As String = "HKEY_LOCAL_MACHINE"
Dim subkey As String = "SOFTWARE\Microsoft\.NETCompactFramework\Diagnostics\Logging"
Dim keyName As String = userRoot + "\" + subkey
' Set the Enabled registry value.
Registry.SetValue(keyName, "Enabled", 0)
MessageBox.Show("Logging Disabled")
End Sub
' This method recursively examines the keys
' under the Logging subkey and writes their
' key names and values to a log file. It saves
' the information in "logsettings.txt", located
' in the directory that contains this example
' application.
Private Sub WriteLoggingSettings()
Dim sw As New StreamWriter("logsettings.txt", False)
sw.WriteLine("General Logging Settings:")
Dim rkLogging As RegistryKey = Registry.LocalMachine.OpenSubKey("SOFTWARE\Microsoft\.NETCompactFramework\Diagnostics\Logging")
Dim valNames As String() = rkLogging.GetValueNames()
Dim x As Integer
For x = 0 To valNames.Length
sw.WriteLine(valNames(x).ToString() + ": " + rkLogging.GetValue(valNames(x)).ToString())
Next x
sw.WriteLine()
sw.WriteLine("Interop Logging:")
Dim rkInterop As RegistryKey = Registry.LocalMachine.OpenSubKey("SOFTWARE\Microsoft\.NETCompactFramework\Diagnostics\Logging\Interop")
Dim interopNames As String() = rkInterop.GetValueNames()
For x = 0 To interopNames.Length
sw.WriteLine(interopNames(x).ToString() + ": " + rkInterop.GetValue(interopNames(x)).ToString())
Next x
sw.WriteLine()
sw.WriteLine("Loader Logging:")
Dim rkLoader As RegistryKey = Registry.LocalMachine.OpenSubKey("SOFTWARE\Microsoft\.NETCompactFramework\Diagnostics\Logging\Loader")
Dim loaderNames As String() = rkLoader.GetValueNames()
For x = 0 To loaderNames.Length
sw.WriteLine(loaderNames(x).ToString() + ": " + rkLoader.GetValue(loaderNames(x)).ToString())
Next x
sw.WriteLine()
sw.WriteLine("Networking Logging:")
Dim rkNetworking As RegistryKey = Registry.LocalMachine.OpenSubKey("SOFTWARE\Microsoft\.NETCompactFramework\Diagnostics\Logging\Networking")
Dim netNames As String() = rkNetworking.GetValueNames()
For x = 0 To netNames.Length
sw.WriteLine(netNames(x).ToString() + ": " + rkNetworking.GetValue(netNames(x)).ToString())
Next x
sw.Close()
End Sub
// This method enables general logging. It contains parameters
// to specify a path, and Boolean values of true to include
// the application name, process ID, and events in the log.
private void EnableLogging(bool useApp, bool usePid, bool useFlush)
{
// Specify values for setting the registry.
string userRoot = "HKEY_LOCAL_MACHINE";
string subkey = "SOFTWARE\\Microsoft\\.NETCompactFramework\\Diagnostics\\Logging";
string keyName = userRoot + "\\" + subkey;
// Set the Enabled registry value.
Registry.SetValue(keyName, "Enabled", 1);
if (useApp == true)
Registry.SetValue(keyName, "UseApp", 1);
else
Registry.SetValue(keyName, "UseApp", 0);
if (usePid == true)
Registry.SetValue(keyName, "UsePid", 1);
else
Registry.SetValue(keyName, "UsePid", 0);
if (useFlush == true)
Registry.SetValue(keyName, "UseFlush", 1);
else
Registry.SetValue(keyName, "UseFlush", 0);
}
// This method sets the Enabled key value to 1
// so that logging for Interoperability is enabled.
private void SetInteropLogging(bool logOn)
{
// Specify values for setting the registry.
string userRoot = "HKEY_LOCAL_MACHINE";
string subkey = "Software\\Microsoft\\.NETCompactFramework\\Diagnostics\\Logging\\Interop";
string keyName = userRoot + "\\" + subkey;
int logSet;
if(logOn == true)
logSet = 1;
else
logSet = 0;
// Set the registry value.
try
{
Registry.SetValue(keyName, "Enabled", logSet);
if(logOn == true)
MessageBox.Show("Interop Logging On");
else
MessageBox.Show("Interop Logging Off");
}
catch(System.Exception ex)
{
MessageBox.Show(ex.Message);
}
}
// This method sets the Enabled key value to 1
// so that logging for class loading is enabled.
private void SetLoaderLogging(bool logOn)
{
// Specify values for setting the registry.
string userRoot = "HKEY_LOCAL_MACHINE";
string subkey = "Software\\Microsoft\\.NETCompactFramework\\Diagnostics\\Logging\\Loader";
string keyName = userRoot + "\\" + subkey;
int logSet;
if(logOn == true)
logSet = 1;
else
logSet = 0;
// Set the registry value.
try
{
Registry.SetValue(keyName, "Enabled", logSet);
if(logOn == true)
MessageBox.Show("Loader Logging On");
else
MessageBox.Show("Loader Logging Off");
}
catch(System.Exception ex)
{
MessageBox.Show(ex.Message);
}
}
// This method sets the Enabled key value to 1
// so that logging for networking is enabled.
private void SetNetworkLogging(bool logOn)
{
// Specify values for setting the registry.
string userRoot = "HKEY_LOCAL_MACHINE";
string subkey = "Software\\Microsoft\\.NETCompactFramework\\Diagnostics\\Logging\\Networking";
string keyName = userRoot + "\\" + subkey;
int logSet;
if(logOn == true)
logSet = 1;
else
logSet = 0;
// Set the registry value.
try
{
Registry.SetValue(keyName, "Enabled", logSet);
if(logOn == true)
MessageBox.Show("Networking Logging On");
else
MessageBox.Show("Networking Loggin Off");
}
catch(System.Exception ex)
{
MessageBox.Show(ex.Message);
}
}
// This method disables all logging.
private void DisableLogging()
{
// Specify values for setting the registry.
string userRoot = "HKEY_LOCAL_MACHINE";
string subkey = "SOFTWARE\\Microsoft\\.NETCompactFramework\\Diagnostics\\Logging";
string keyName = userRoot + "\\" + subkey;
// Set the Enabled registry value.
Registry.SetValue(keyName, "Enabled", 0);
MessageBox.Show("Logging Disabled");
}
// This method recursively examines the keys
// under the Logging subkey and writes their
// key names and values to a log file. It saves
// the information in "logsettings.txt" located
// in the directory that contains this
// example application.
private void WriteLoggingSettings()
{
StreamWriter sw = new StreamWriter("logsettings.txt",false);
sw.WriteLine("General Logging Settings:");
RegistryKey rkLogging = Registry.LocalMachine.OpenSubKey("SOFTWARE\\Microsoft\\.NETCompactFramework\\Diagnostics\\Logging");
string[] valNames = rkLogging.GetValueNames();
for (int x = 0; x < valNames.Length; x++)
{
sw.WriteLine(valNames[x].ToString() + ": " + rkLogging.GetValue(valNames[x]).ToString());
}
sw.WriteLine();
sw.WriteLine("Interop Logging:");
RegistryKey rkInterop = Registry.LocalMachine.OpenSubKey("SOFTWARE\\Microsoft\\.NETCompactFramework\\Diagnostics\\Logging\\Interop");
string[] interopNames = rkInterop.GetValueNames();
for (int x = 0; x < interopNames.Length; x++)
{
sw.WriteLine(interopNames[x].ToString() + ": " + rkInterop.GetValue(interopNames[x]).ToString());
}
sw.WriteLine();
sw.WriteLine("Loader Logging:");
RegistryKey rkLoader = Registry.LocalMachine.OpenSubKey("SOFTWARE\\Microsoft\\.NETCompactFramework\\Diagnostics\\Logging\\Loader");
string[] loaderNames = rkLoader.GetValueNames();
for (int x = 0; x < loaderNames.Length; x++)
{
sw.WriteLine(loaderNames[x].ToString() + ": " + rkLoader.GetValue(loaderNames[x]).ToString());
}
sw.WriteLine();
sw.WriteLine("Networking Logging:");
RegistryKey rkNetworking = Registry.LocalMachine.OpenSubKey("SOFTWARE\\Microsoft\\.NETCompactFramework\\Diagnostics\\Logging\\Networking");
string[] netNames = rkNetworking.GetValueNames();
for (int x = 0; x < netNames.Length; x++)
{
sw.WriteLine(netNames[x].ToString() + ": " + rkNetworking.GetValue(netNames[x]).ToString());
}
sw.Close();
}
Kompilieren des Codes
Für dieses Beispiel sind Verweise auf die folgenden Namespaces erforderlich: