Imports System
Imports Microsoft.Win32

Class Reg

   Public Shared Sub Main()

       ' Create a RegistryKey, which will access the HKEY_USERS
       ' key in the registry of this machine.
       Dim rk As RegistryKey = Registry.Users

       ' Print out the keys.
       PrintKeys(rk)
   End Sub   

   Shared Sub PrintKeys(rkey As RegistryKey)

       ' Retrieve all the subkeys for the specified key.
       Dim names As String() = rkey.GetSubKeyNames()

       Dim icount As Integer = 0

       Console.WriteLine("Subkeys of " & rkey.Name)
       Console.WriteLine("-----------------------------------------------")

       ' Print the contents of the array to the console.
       Dim s As String
       For Each s In  names
           Console.WriteLine(s)

           ' The following code puts a limit on the number
           ' of keys displayed.  Comment it out to print the
           ' complete list.
           icount += 1           
           If icount >= 10 Then
               Exit For
           End If
       Next s
   End Sub
End Class

using System;
using Microsoft.Win32;

class Reg {
   public static void Main() {

       // Create a RegistryKey, which will access the HKEY_USERS
       // key in the registry of this machine.
       RegistryKey rk = Registry.Users;

       // Print out the keys.
       PrintKeys(rk);
   }

   static void PrintKeys(RegistryKey rkey) {

       // Retrieve all the subkeys for the specified key.
       String [] names = rkey.GetSubKeyNames();

       int icount = 0;

       Console.WriteLine("Subkeys of " + rkey.Name);
       Console.WriteLine("-----------------------------------------------");

       // Print the contents of the array to the console.
       foreach (String s in names) {
           Console.WriteLine(s);

           // The following code puts a limit on the number
           // of keys displayed.  Comment it out to print the
           // complete list.
           icount++;
           if (icount >= 10)
               break;
       }
   }
}

using namespace System;
using namespace Microsoft::Win32;
void PrintKeys( RegistryKey ^ rkey )
{

  // Retrieve all the subkeys for the specified key.
  array^names = rkey->GetSubKeyNames();
  int icount = 0;
  Console::WriteLine( "Subkeys of {0}", rkey->Name );
  Console::WriteLine( "-----------------------------------------------" );

  // Print the contents of the array to the console.
  System::Collections::IEnumerator^ enum0 = names->GetEnumerator();
  while ( enum0->MoveNext() )
  {
     String^ s = safe_cast(enum0->Current);
     Console::WriteLine( s );

     // The following code puts a limit on the number
     // of keys displayed.  Comment it out to print the
     // complete list.
     icount++;
     if ( icount >= 10 )
           break;
  }
}

int main()
{

  // Create a RegistryKey, which will access the HKEY_USERS
  // key in the registry of this machine.
  RegistryKey ^ rk = Registry::Users;

  // Print out the keys.
  PrintKeys( rk );
}

import System.*;
import Microsoft.Win32.*;

class Reg
{
   public static void main(String[] args)
   {
       // Create a RegistryKey, which will access the HKEY_USERS
       // key in the registry of this machine.
       RegistryKey rk = Registry.Users;
       // Print out the keys.
       PrintKeys(rk);
   } //main

   static void PrintKeys(RegistryKey rKey)
   {
       // Retrieve all the subkeys for the specified key.
       String names[] = rKey.GetSubKeyNames();

       int iCount = 0;

       Console.WriteLine("Subkeys of " + rKey.get_Name());
       Console.WriteLine("-----------------------------------------------");
       // Print the contents of the array to the console.
       String s = null;
       for (int iCtr = 0; iCtr < names.get_Length(); iCtr++) {
           s = names[iCtr];
           Console.WriteLine(s);
           // The following code puts a limit on the number
           // of keys displayed.  Comment it out to print the
           // complete list.
           iCount++;
           if (iCount >= 10) {
               break;
           }
       }
   } //PrintKeys
} //Reg

Imports System
Imports Microsoft.Win32

Public Class Example
   Public Shared Sub Main()
       ' The name of the key must include a valid root.
       Const userRoot As String = "HKEY_CURRENT_USER"
       Const subkey As String = "RegistrySetValueExample"
       Const keyName As String = userRoot & "\" & subkey

       ' Integer values can be stored without specifying the
       ' registry data type, but Long values will be stored
       ' as strings unless you specify the type. Note that
       ' the integer is stored in the default name/value
       ' pair.
       Registry.SetValue(keyName, "", 5280)
       Registry.SetValue(keyName, "TestLong", 12345678901234, _
           RegistryValueKind.QWord)

       ' Strings with expandable environment variables are
       ' stored as ordinary strings unless you specify the
       ' data type.
       Registry.SetValue(keyName, "TestExpand", "My path: %path%")
       Registry.SetValue(keyName, "TestExpand2", "My path: %path%", _
           RegistryValueKind.ExpandString)

       ' Arrays of strings are stored automatically as 
       ' MultiString. Similarly, arrays of Byte are stored
       ' automatically as Binary.
       Dim strings() As String = {"One", "Two", "Three"}
       Registry.SetValue(keyName, "TestArray", strings)

       ' Your default value is returned if the name/value pair
       ' does not exist.
       Dim noSuch As String = _
           Registry.GetValue(keyName, "NoSuchName", _
           "Return this default if NoSuchName does not exist.")
       Console.WriteLine(vbCrLf & "NoSuchName: {0}", noSuch)

       ' Retrieve the Integer and Long values, specifying 
       ' numeric default values in case the name/value pairs
       ' do not exist. The Integer value is retrieved from the
       ' default (nameless) name/value pair for the key.
       Dim tInteger As Integer = _
           Registry.GetValue(keyName, "", -1)
       Console.WriteLine("(Default): {0}", tInteger)
       Dim tLong As Long = Registry.GetValue(keyName, _
            "TestLong", Long.MinValue)
       Console.WriteLine("TestLong: {0}", tLong)

       ' When retrieving a MultiString value, you can specify
       ' an array for the default return value. The value is
       ' declared inline, but could also be declared as:
       ' Dim default() As String = {"Default value."}
       '
       Dim tArray() As String = _
           Registry.GetValue(keyName, "TestArray", _
           New String() {"Default if TestArray does not exist."})
       For i As Integer = 0 To tArray.Length - 1
           Console.WriteLine("TestArray({0}): {1}", i, tArray(i))
       Next

       ' A string with embedded environment variables is not
       ' expanded if it was stored as an ordinary string.
       Dim tExpand As String = Registry.GetValue(keyName, _
            "TestExpand", "Default if TestExpand does not exist.")
       Console.WriteLine("TestExpand: {0}", tExpand)

       ' A string stored as ExpandString is expanded.
       Dim tExpand2 As String = Registry.GetValue(keyName, _
            "TestExpand2", "Default if TestExpand2 does not exist.")
       Console.WriteLine("TestExpand2: {0}...", _
           tExpand2.Substring(0, 40))

       Console.WriteLine(vbCrLf & _
           "Use the registry editor to examine the key.")
       Console.WriteLine("Press the Enter key to delete the key.")
       Console.ReadLine()
       Registry.CurrentUser.DeleteSubKey(subkey)
   End Sub
End Class
'
' This code example produces output similar to the following:
'
'NoSuchName: Return this default if NoSuchName does not exist.
'(Default): 5280
'TestLong: 12345678901234
'TestArray(0): One
'TestArray(1): Two
'TestArray(2): Three
'TestExpand: My path: %path%
'TestExpand2: My path: D:\Program Files\Microsoft.NET\...
'
'Use the registry editor to examine the key.
'Press the Enter key to delete the key.

using System;
using Microsoft.Win32;

public class Example
{
   public static void Main()
   {
       // The name of the key must include a valid root.
       const string userRoot = "HKEY_CURRENT_USER";
       const string subkey = "RegistrySetValueExample";
       const string keyName = userRoot + "\\" + subkey;

       // An int value can be stored without specifying the
       // registry data type, but long values will be stored
       // as strings unless you specify the type. Note that
       // the int is stored in the default name/value
       // pair.
       Registry.SetValue(keyName, "", 5280);
       Registry.SetValue(keyName, "TestLong", 12345678901234,
           RegistryValueKind.QWord);

       // Strings with expandable environment variables are
       // stored as ordinary strings unless you specify the
       // data type.
       Registry.SetValue(keyName, "TestExpand", "My path: %path%");
       Registry.SetValue(keyName, "TestExpand2", "My path: %path%",
           RegistryValueKind.ExpandString);

       // Arrays of strings are stored automatically as 
       // MultiString. Similarly, arrays of Byte are stored
       // automatically as Binary.
       string[] strings = {"One", "Two", "Three"};
       Registry.SetValue(keyName, "TestArray", strings);

       // Your default value is returned if the name/value pair
       // does not exist.
       string noSuch = (string) Registry.GetValue(keyName,
           "NoSuchName",
           "Return this default if NoSuchName does not exist.");
       Console.WriteLine("\r\nNoSuchName: {0}", noSuch);

       // Retrieve the int and long values, specifying 
       // numeric default values in case the name/value pairs
       // do not exist. The int value is retrieved from the
       // default (nameless) name/value pair for the key.
       int tInteger = (int) Registry.GetValue(keyName, "", -1);
       Console.WriteLine("(Default): {0}", tInteger);
       long tLong = (long) Registry.GetValue(keyName, "TestLong",
           long.MinValue);
       Console.WriteLine("TestLong: {0}", tLong);

       // When retrieving a MultiString value, you can specify
       // an array for the default return value. 
       string[] tArray = (string[]) Registry.GetValue(keyName,
           "TestArray",
           new string[] {"Default if TestArray does not exist."});
       for(int i=0; i       {
           Console.WriteLine("TestArray({0}): {1}", i, tArray[i]);
       }

       // A string with embedded environment variables is not
       // expanded if it was stored as an ordinary string.
       string tExpand = (string) Registry.GetValue(keyName,
            "TestExpand",
            "Default if TestExpand does not exist.");
       Console.WriteLine("TestExpand: {0}", tExpand);

       // A string stored as ExpandString is expanded.
       string tExpand2 = (string) Registry.GetValue(keyName,
           "TestExpand2",
           "Default if TestExpand2 does not exist.");
       Console.WriteLine("TestExpand2: {0}...",
           tExpand2.Substring(0, 40));

       Console.WriteLine("\r\nUse the registry editor to examine the key.");
       Console.WriteLine("Press the Enter key to delete the key.");
       Console.ReadLine();
       Registry.CurrentUser.DeleteSubKey(subkey);
   }
}
//
// This code example produces output similar to the following:
//
//NoSuchName: Return this default if NoSuchName does not exist.
//(Default): 5280
//TestLong: 12345678901234
//TestArray(0): One
//TestArray(1): Two
//TestArray(2): Three
//TestExpand: My path: %path%
//TestExpand2: My path: D:\Program Files\Microsoft.NET\...
//
//Use the registry editor to examine the key.
//Press the Enter key to delete the key.

using namespace System;
using namespace Microsoft::Win32;

int main()
{  
   // The name of the key must include a valid root.
   String^ userRoot = "HKEY_CURRENT_USER";
   String^ subKey = "RegistrySetValueExample2";
   String^ keyName = String::Concat(userRoot, "\\", subKey);

   // An int value can be stored without specifying the
   // registry data type, but Int64 values will be stored
   // as strings unless you specify the type. Note that
   // the int is stored in the default name/value
   // pair.
   Registry::SetValue(keyName, "", 5280);
   Registry::SetValue(keyName, "TestInt64", 12345678901234,
       RegistryValueKind::QWord);

   // Strings with expandable environment variables are
   // stored as ordinary strings unless you specify the
   // data type.
   Registry::SetValue(keyName, "TestExpand", "My path: %path%");
   Registry::SetValue(keyName, "TestExpand2", "My path: %path%",
       RegistryValueKind::ExpandString);

   // Arrays of strings are stored automatically as 
   // MultiString. Similarly, arrays of Byte are stored
   // automatically as Binary.
   array^ strings  = {"One", "Two", "Three"};
   Registry::SetValue(keyName, "TestArray", strings);

   // Your default value is returned if the name/value pair
   // does not exist.
   String^ noSuch = (String^)Registry::GetValue(keyName,
       "NoSuchName",
       "Return this default if NoSuchName does not exist.");
   Console::WriteLine("\r\nNoSuchName: {0}", noSuch);

   // Retrieve the int and Int64 values, specifying 
   // numeric default values in case the name/value pairs
   // do not exist. The int value is retrieved from the
   // default (nameless) name/value pair for the key.
   int testInteger = (int)Registry::GetValue(keyName, "", -1);
   Console::WriteLine("(Default): {0}", testInteger);
   long long testInt64 = (long long)Registry::GetValue(keyName,
       "TestInt64", System::Int64::MinValue);
   Console::WriteLine("TestInt64: {0}", testInt64);

   // When retrieving a MultiString value, you can specify
   // an array for the default return value. 
   array^ testArray = (array^)Registry::GetValue(
       keyName, "TestArray",
       gcnew array {"Default if TestArray does not exist."});
   for (int i = 0; i <>Length; i++)
   {
       Console::WriteLine("TestArray({0}): {1}", i, testArray[i]);
   }

   // A string with embedded environment variables is not
   // expanded if it was stored as an ordinary string.
   String^ testExpand = (String^)Registry::GetValue(keyName,
       "TestExpand", "Default if TestExpand does not exist.");
   Console::WriteLine("TestExpand: {0}", testExpand);

   // A string stored as ExpandString is expanded.
   String^ testExpand2 = (String^)Registry::GetValue(keyName,
       "TestExpand2", "Default if TestExpand2 does not exist.");
   Console::WriteLine(
       "TestExpand2: {0}...", testExpand2->Substring(0, 40));
   Console::WriteLine(
       "\r\nUse the registry editor to examine the key.");
   Console::WriteLine("Press the Enter key to delete the key.");
   Console::ReadLine();
   Registry::CurrentUser->DeleteSubKey(subKey);
}
//
// This code example produces output similar to the following:
//
// NoSuchName: Return this default if NoSuchName does not exist.
// (Default): 5280
// TestInt64: 12345678901234
// TestArray(0): One
// TestArray(1): Two
// TestArray(2): Three
// TestExpand: My path: %path%
// TestExpand2: My path: D:\Program Files\Microsoft.NET\...
//
// Use the registry editor to examine the key.
// Press the Enter key to delete the key.