' This example demonstrates the 
'     Environment.GetEnvironmentVariable,
'     Environment.SetEnvironmentVariable, and 
'     Environment.GetEnvironmentVariables overloaded methods.
Imports System
Imports System.Collections
Imports Microsoft.Win32
Imports Microsoft.VisualBasic

Class Sample
   '-------------------------------------------------------------------------------------
   ' Globals: 
   '-------------------------------------------------------------------------------------
   Protected Shared fmtNameValue As String = "  {0} {1}."
   Protected Shared myVarSuffix As String = "_GETSET_ENVAR_SAMPLE"
   
   ' Four relatively unique environment variable names.
   Protected Shared myVarA As String = "A" & myVarSuffix ' default process
   Protected Shared myVarB As String = "B" & myVarSuffix ' Current Process
   Protected Shared myVarC As String = "C" & myVarSuffix ' Current User
   Protected Shared myVarD As String = "D" & myVarSuffix ' Local Machine
   '=====================================================================================
   ' EachVariable: 
   ' Test whether a specific environment variable exists in a target.
   ' This section demonstrates Environment.GetEnvironmentVariable.
   '-------------------------------------------------------------------------------------
   Protected Shared Sub EachVariable(var As String, tgt As EnvironmentVariableTarget)
      Dim str As String
      '
      If 0 = tgt Then ' Zero means use the default target.
         str = Environment.GetEnvironmentVariable(var)
      Else
         str = Environment.GetEnvironmentVariable(var, tgt)
      End If
      Console.WriteLine(fmtNameValue, var, IIf(String.IsNullOrEmpty(str), _
                                              "doesn't exist", str))
   End Sub 'EachVariable
   
   '-------------------------------------------------------------------------------------
   ' CheckEachVariable: 
   ' Uses EachVariable to test whether each environment variable exists in a target.
   '-------------------------------------------------------------------------------------
   Protected Shared Sub CheckEachVariable()
      Console.WriteLine("Process:")
      EachVariable(myVarA, 0) ' Check the default target (current process)
      EachVariable(myVarB, EnvironmentVariableTarget.Process)
      EachVariable(myVarC, EnvironmentVariableTarget.Process)
      EachVariable(myVarD, EnvironmentVariableTarget.Process)
      Console.WriteLine()
      
      Console.WriteLine("User:")
      EachVariable(myVarA, EnvironmentVariableTarget.User)
      EachVariable(myVarB, EnvironmentVariableTarget.User)
      EachVariable(myVarC, EnvironmentVariableTarget.User)
      EachVariable(myVarD, EnvironmentVariableTarget.User)
      Console.WriteLine()
      
      Console.WriteLine("Machine:")
      EachVariable(myVarA, EnvironmentVariableTarget.Machine)
      EachVariable(myVarB, EnvironmentVariableTarget.Machine)
      EachVariable(myVarC, EnvironmentVariableTarget.Machine)
      EachVariable(myVarD, EnvironmentVariableTarget.Machine)
      Console.WriteLine()
   End Sub 'CheckEachVariable
   
   '=====================================================================================
   ' AllVariables: CheckAllVariables helper function.
   ' This section demonstrates Environment.GetEnvironmentVariables.
   '-------------------------------------------------------------------------------------
   Private Shared Sub AllVariables(tgt As EnvironmentVariableTarget)
      Dim value As String
      Dim key As String
      
      Dim de As DictionaryEntry
      For Each de In Environment.GetEnvironmentVariables(tgt)
         key = CStr(de.Key)
         value = CStr(de.Value)
         If key.Contains(myVarSuffix) Then
            Console.WriteLine(fmtNameValue, key, value)
         End If
      Next de
      Console.WriteLine()
   End Sub 'AllVariables
   
   '=====================================================================================
   ' CheckAllVariables: 
   ' Uses AllVariables to test whether each environment variable exists in a target.
   '-------------------------------------------------------------------------------------
   Protected Shared Sub CheckAllVariables()
      Console.WriteLine("Process:")
      AllVariables(EnvironmentVariableTarget.Process)
      
      Console.WriteLine("User:")
      AllVariables(EnvironmentVariableTarget.User)
      
      Console.WriteLine("Machine:")
      AllVariables(EnvironmentVariableTarget.Machine)
   End Sub 'CheckAllVariables
   
   '=====================================================================================
   ' ChkReg: CheckRegistry helper function.
   ' This function filters out irrelevant environment variables. 
   '-------------------------------------------------------------------------------------
   Private Shared Sub ChkReg(rk As RegistryKey)
      Dim exists As Boolean = False
      Dim registryNone As String = "  Environment variable doesn't exist."
      
      Dim s As String
      For Each s In rk.GetValueNames()
         If s.Contains(myVarSuffix) Then
            Console.WriteLine(fmtNameValue, s, CStr(rk.GetValue(s)))
            exists = True
         End If
      Next s
      If exists = False Then
         Console.WriteLine(registryNone)
      End If
      Console.WriteLine()
   End Sub 'ChkReg
   
   '-------------------------------------------------------------------------------------
   ' CheckRegistry: 
   ' Uses ChkReg to display the User and Machine environment variables in the registry.
   '-------------------------------------------------------------------------------------
   Protected Shared Sub CheckRegistry()
      Dim subkeyU As String = "Environment"
      Dim subkeyM As String = "System\CurrentControlSet\Control\Session Manager\Environment"
      Dim fmtSubkey As String = """{0}"" key:"
      
      Console.WriteLine(fmtSubkey, subkeyU)
      ChkReg(Registry.CurrentUser.OpenSubKey(subkeyU))
      
      Console.WriteLine(fmtSubkey, subkeyM)
      ChkReg(Registry.LocalMachine.OpenSubKey(subkeyM))
   End Sub 'CheckRegistry
   
   '=====================================================================================
   ' Main:
   '-------------------------------------------------------------------------------------
   Public Shared Sub Main()
      '-------------------------------------------------------------------------------------
      ' Environment variable values
      '-------------------------------------------------------------------------------------
      Dim existsA As String = "exists in the default target (Process)"
      Dim existsB As String = "exists in Process"
      Dim existsC As String = "exists in User"
      Dim existsD As String = "exists in Machine"
      '-------------------------------------------------------------------------------------
      ' Messages:
      '-------------------------------------------------------------------------------------
      Dim msg1  As String = "Step 1:" & vbCrLf & _
                            "  Check whether the environment variables already exist in " _
                 & vbCrLf & "  the various targets..." & vbCrLf
      Dim msg2  As String = "Step 2:" & vbCrLf & _
                            "  Set the environment variable for each target..." & vbCrLf
      Dim msg31 As String = "Step 3, part 1:" & vbCrLf & _
                            "  Display the environment variables in each target..." & vbCrLf
      Dim msg32 As String = "Step 3, part 2:" & vbCrLf & _
                            "  Check whether the User and Machine environment variables " _
                 & vbCrLf & "  were created in the Windows operating system registry..." _
                 & vbCrLf
      Dim msg41 As String = "Step 4, part 1:" & vbCrLf & _
                            "  Delete the environment variables created for this sample..." _
                 & vbCrLf
      Dim msg42 As String = "Step 4, part 2:" & vbCrLf & _
                            "  Check whether the environment variables were deleted " _
                 & vbCrLf & "  in each target..." & vbCrLf
      Dim msg43 As String = "Step 4, part 3:" & vbCrLf & _
                            "  Check whether the User and Machine environment variables " _
                 & vbCrLf & "  were deleted from the Windows operating system registry..." _
                 & vbCrLf
      Dim fmt2x As String = "  {0,9}: Set {1} = ""{2}"""
      '-------------------------------------------------------------------------------------
      ' Step 1:
      ' Check whether the sample environment variables already exist.
      ' WARNING: These variables will be deleted at the end of this sample.
      '-------------------------------------------------------------------------------------
      Console.WriteLine(msg1)
      CheckEachVariable()
      Console.WriteLine()
      '-------------------------------------------------------------------------------------
      ' Step 2:
      ' Set the environment variable for each target.
      ' This section demonstrates Environment.SetEnvironmentVariable.
      '-------------------------------------------------------------------------------------
      Console.WriteLine(msg2)
      ' Set the environment variable for the default target (the current process).
      Console.WriteLine(fmt2x, "(default)", myVarA, existsA)
      Environment.SetEnvironmentVariable(myVarA, existsA)
      
      ' Set the environment variable for the the current process.
      Console.WriteLine(fmt2x, "Process", myVarB, existsB)
      Environment.SetEnvironmentVariable(myVarB, existsB, EnvironmentVariableTarget.Process)
      
      ' Set the environment variable for the the current user.
      Console.WriteLine(fmt2x, "User", myVarC, existsC)
      Environment.SetEnvironmentVariable(myVarC, existsC, EnvironmentVariableTarget.User)
      
      ' Set the environment variable for the the local machine.
      Console.WriteLine(fmt2x, "Machine", myVarD, existsD)
      Environment.SetEnvironmentVariable(myVarD, existsD, EnvironmentVariableTarget.Machine)
      Console.WriteLine()
      '-------------------------------------------------------------------------------------
      ' Step 3, part 1:
      ' Display the environment variables in each target.
      '-------------------------------------------------------------------------------------
      Console.WriteLine(msg31)
      CheckAllVariables()
      Console.WriteLine()
      '-------------------------------------------------------------------------------------
      ' Step 3, part 2:
      ' Check whether the User and Machine environment variables were created in the Windows 
      ' operating system registry.
      '-------------------------------------------------------------------------------------
      Console.WriteLine(msg32)
      CheckRegistry()
      Console.WriteLine()
      '-------------------------------------------------------------------------------------
      ' Step 4, part 1:
      ' Delete the environment variables created for this sample.
      ' This section demonstrates using Environment.SetEnvironmentVariable to delete an 
      ' environment variable.
      '-------------------------------------------------------------------------------------
      Console.WriteLine(msg41)
      Environment.SetEnvironmentVariable(myVarA, Nothing)
      Environment.SetEnvironmentVariable(myVarB, Nothing, EnvironmentVariableTarget.Process)
      Environment.SetEnvironmentVariable(myVarC, Nothing, EnvironmentVariableTarget.User)
      Environment.SetEnvironmentVariable(myVarD, Nothing, EnvironmentVariableTarget.Machine)
      '-------------------------------------------------------------------------------------
      ' Step 4, part 2:
      ' Check whether the environment variables were deleted in each target.
      '-------------------------------------------------------------------------------------
      Console.WriteLine(msg42)
      CheckEachVariable()
      '-------------------------------------------------------------------------------------
      ' Step 4, part 3:
      ' Check whether the User and Machine environment variables were deleted from the 
      ' Windows operating system registry.
      '-------------------------------------------------------------------------------------
      Console.WriteLine(msg43)
      CheckRegistry()
   End Sub 'Main
End Class 'Sample
'
'This example produces the following results:
'
'Step 1:
'  Check whether the environment variables already exist in
'  the various targets...
'
'Process:
'  A_GETSET_ENVAR_SAMPLE doesn't exist.
'  B_GETSET_ENVAR_SAMPLE doesn't exist.
'  C_GETSET_ENVAR_SAMPLE doesn't exist.
'  D_GETSET_ENVAR_SAMPLE doesn't exist.
'
'User:
'  A_GETSET_ENVAR_SAMPLE doesn't exist.
'  B_GETSET_ENVAR_SAMPLE doesn't exist.
'  C_GETSET_ENVAR_SAMPLE doesn't exist.
'  D_GETSET_ENVAR_SAMPLE doesn't exist.
'
'Machine:
'  A_GETSET_ENVAR_SAMPLE doesn't exist.
'  B_GETSET_ENVAR_SAMPLE doesn't exist.
'  C_GETSET_ENVAR_SAMPLE doesn't exist.
'  D_GETSET_ENVAR_SAMPLE doesn't exist.
'
'
'Step 2:
'  Set the environment variable for each target...
'
'  (default): Set A_GETSET_ENVAR_SAMPLE = "exists in the default target (Process)"
'    Process: Set B_GETSET_ENVAR_SAMPLE = "exists in Process"
'       User: Set C_GETSET_ENVAR_SAMPLE = "exists in User"
'    Machine: Set D_GETSET_ENVAR_SAMPLE = "exists in Machine"
'
'Step 3, part 1:
'  Display the environment variables in each target...
'
'Process:
'  B_GETSET_ENVAR_SAMPLE exists in Process.
'  A_GETSET_ENVAR_SAMPLE exists in the default target (Process).
'
'User:
'  C_GETSET_ENVAR_SAMPLE exists in User.
'
'Machine:
'  D_GETSET_ENVAR_SAMPLE exists in Machine.
'
'
'Step 3, part 2:
'  Check whether the User and Machine environment variables
'  were created in the Windows operating system registry...
'
'"Environment" key:
'  C_GETSET_ENVAR_SAMPLE exists in User.
'
'"System\CurrentControlSet\Control\Session Manager\Environment" key:
'  D_GETSET_ENVAR_SAMPLE exists in Machine.
'
'
'Step 4, part 1:
'  Delete the environment variables created for this sample...
'
'Step 4, part 2:
'  Check whether the environment variables were deleted
'  in each target...
'
'Process:
'  A_GETSET_ENVAR_SAMPLE doesn't exist.
'  B_GETSET_ENVAR_SAMPLE doesn't exist.
'  C_GETSET_ENVAR_SAMPLE doesn't exist.
'  D_GETSET_ENVAR_SAMPLE doesn't exist.
'
'User:
'  A_GETSET_ENVAR_SAMPLE doesn't exist.
'  B_GETSET_ENVAR_SAMPLE doesn't exist.
'  C_GETSET_ENVAR_SAMPLE doesn't exist.
'  D_GETSET_ENVAR_SAMPLE doesn't exist.
'
'Machine:
'  A_GETSET_ENVAR_SAMPLE doesn't exist.
'  B_GETSET_ENVAR_SAMPLE doesn't exist.
'  C_GETSET_ENVAR_SAMPLE doesn't exist.
'  D_GETSET_ENVAR_SAMPLE doesn't exist.
'
'Step 4, part 3:
'  Check whether the User and Machine environment variables
'  were deleted from the Windows operating system registry...
'
'"Environment" key:
'  Environment variable doesn't exist.
'
'"System\CurrentControlSet\Control\Session Manager\Environment" key:
'  Environment variable doesn't exist.
'

// This example demonstrates the 
//     Environment.GetEnvironmentVariable,
//     Environment.SetEnvironmentVariable, and 
//     Environment.GetEnvironmentVariables overloaded methods.

using System;
using System.Collections;
using Microsoft.Win32;

class Sample 
{
//-------------------------------------------------------------------------------------
// Globals: 
//-------------------------------------------------------------------------------------
    protected static string fmtNameValue = "  {0} {1}.";
    protected static string myVarSuffix = "_GETSET_ENVAR_SAMPLE";

// Four relatively unique environment variable names.
    protected static string myVarA = "A" + myVarSuffix; // default process
    protected static string myVarB = "B" + myVarSuffix; // Current Process
    protected static string myVarC = "C" + myVarSuffix; // Current User
    protected static string myVarD = "D" + myVarSuffix; // Local Machine
//=====================================================================================
// EachVariable: 
// Test whether a specific environment variable exists in a target.
// This section demonstrates Environment.GetEnvironmentVariable.
//-------------------------------------------------------------------------------------
    protected static void EachVariable(string var, EnvironmentVariableTarget tgt)
    {
    string str;
    //
    if (0 == tgt)          // Zero means use the default target.
        str = Environment.GetEnvironmentVariable(var);
    else
        str = Environment.GetEnvironmentVariable(var, tgt);
    Console.WriteLine(fmtNameValue, 
                      var, (String.IsNullOrEmpty(str) ? "doesn't exist" : str));
    }
//-------------------------------------------------------------------------------------
// CheckEachVariable: 
// Uses EachVariable to test whether each environment variable exists in a target.
//-------------------------------------------------------------------------------------
    protected static void CheckEachVariable()
    {
    Console.WriteLine("Process:");
    EachVariable(myVarA, 0);  // Check the default target (current process)
    EachVariable(myVarB, EnvironmentVariableTarget.Process);
    EachVariable(myVarC, EnvironmentVariableTarget.Process);
    EachVariable(myVarD, EnvironmentVariableTarget.Process);
    Console.WriteLine();

    Console.WriteLine("User:");
    EachVariable(myVarA, EnvironmentVariableTarget.User);
    EachVariable(myVarB, EnvironmentVariableTarget.User);
    EachVariable(myVarC, EnvironmentVariableTarget.User);
    EachVariable(myVarD, EnvironmentVariableTarget.User);
    Console.WriteLine();

    Console.WriteLine("Machine:");
    EachVariable(myVarA, EnvironmentVariableTarget.Machine);
    EachVariable(myVarB, EnvironmentVariableTarget.Machine);
    EachVariable(myVarC, EnvironmentVariableTarget.Machine);
    EachVariable(myVarD, EnvironmentVariableTarget.Machine);
    Console.WriteLine();
    }
//=====================================================================================
// AllVariables: CheckAllVariables helper function.
// This section demonstrates Environment.GetEnvironmentVariables.
//-------------------------------------------------------------------------------------
    private static void AllVariables(EnvironmentVariableTarget tgt)
    {
    string value;
    string key;

    foreach(DictionaryEntry de in Environment.GetEnvironmentVariables(tgt))
        {
        key   = (string)de.Key;
        value = (string)de.Value;
        if (key.Contains(myVarSuffix))
            Console.WriteLine(fmtNameValue, key, value);
        }
    Console.WriteLine();
    }
//=====================================================================================
// CheckAllVariables: 
// Uses AllVariables to test whether each environment variable exists in a target.
//-------------------------------------------------------------------------------------
    protected static void CheckAllVariables()
    {
    Console.WriteLine("Process:");
    AllVariables(EnvironmentVariableTarget.Process);

    Console.WriteLine("User:");
    AllVariables(EnvironmentVariableTarget.User);

    Console.WriteLine("Machine:");
    AllVariables(EnvironmentVariableTarget.Machine);
    }
//=====================================================================================
// ChkReg: CheckRegistry helper function.
// This function filters out irrelevant environment variables. 
//-------------------------------------------------------------------------------------
    private static void ChkReg(RegistryKey rk)
    {
    bool exists = false;
    string registryNone = "  Environment variable doesn't exist.";

    foreach (string s in rk.GetValueNames())
        {
        if (s.Contains(myVarSuffix))
            {
            Console.WriteLine(fmtNameValue, s, (string)rk.GetValue(s));
            exists = true;
            }
        }
    if (exists == false)
        Console.WriteLine(registryNone);
    Console.WriteLine();
    }
//-------------------------------------------------------------------------------------
// CheckRegistry: 
// Uses ChkReg to display the User and Machine environment variables in the registry.
//-------------------------------------------------------------------------------------
    protected static void CheckRegistry()
    {
    string subkeyU = @"Environment";
    string subkeyM = @"System\CurrentControlSet\Control\Session Manager\Environment";
    string fmtSubkey = "\"{0}\" key:";

    Console.WriteLine(fmtSubkey, subkeyU);
    ChkReg(Registry.CurrentUser.OpenSubKey(subkeyU));

    Console.WriteLine(fmtSubkey, subkeyM);
    ChkReg(Registry.LocalMachine.OpenSubKey(subkeyM));
    }
//=====================================================================================
// Main:
//-------------------------------------------------------------------------------------
    public static void Main() 
    {
//-------------------------------------------------------------------------------------
// Environment variable values
//-------------------------------------------------------------------------------------
    string existsA = "exists in the default target (Process)";
    string existsB = "exists in Process";
    string existsC = "exists in User";
    string existsD = "exists in Machine";
//-------------------------------------------------------------------------------------
// Messages:
//-------------------------------------------------------------------------------------
    string msg1  = "Step 1:\n" +
                       "  Check whether the environment variables already exist in \n" + 
                       "  the various targets...\n";
    string msg2  = "Step 2:\n" +
                       "  Set the environment variable for each target...\n";
    string msg31 = "Step 3, part 1:\n" + 
                       "  Display the environment variables in each target...\n";
    string msg32 = "Step 3, part 2:\n" +
                       "  Check whether the User and Machine environment variables \n" +
                       "  were created in the Windows operating system registry...\n";
    string msg41 = "Step 4, part 1:\n" +
                       "  Delete the environment variables created for this sample...\n";
    string msg42 = "Step 4, part 2:\n" +
                       "  Check whether the environment variables were deleted \n" +
                       "  in each target...\n";
    string msg43 = "Step 4, part 3:\n" + 
                       "  Check whether the User and Machine environment variables \n" +
                       "  were deleted from the Windows operating system registry...\n";
    string fmt2x   = "  {0,9}: Set {1} = \"{2}\"";
//-------------------------------------------------------------------------------------
// Step 1:
// Check whether the sample environment variables already exist.
// WARNING: These variables will be deleted at the end of this sample.
//-------------------------------------------------------------------------------------
    Console.WriteLine(msg1);
    CheckEachVariable();
    Console.WriteLine();
//-------------------------------------------------------------------------------------
// Step 2:
// Set the environment variable for each target.
// This section demonstrates Environment.SetEnvironmentVariable.
//-------------------------------------------------------------------------------------
    Console.WriteLine(msg2);
// Set the environment variable for the default target (the current process).
    Console.WriteLine(fmt2x, "(default)", myVarA, existsA);
    Environment.SetEnvironmentVariable(myVarA, existsA);

// Set the environment variable for the the current process.
    Console.WriteLine(fmt2x, "Process", myVarB, existsB);
    Environment.SetEnvironmentVariable(myVarB, existsB, 
        EnvironmentVariableTarget.Process);

// Set the environment variable for the the current user.
    Console.WriteLine(fmt2x, "User", myVarC, existsC);
    Environment.SetEnvironmentVariable(myVarC, existsC, 
        EnvironmentVariableTarget.User);

// Set the environment variable for the the local machine.
    Console.WriteLine(fmt2x, "Machine", myVarD, existsD);
    Environment.SetEnvironmentVariable(myVarD, existsD, 
        EnvironmentVariableTarget.Machine);
    Console.WriteLine();
//-------------------------------------------------------------------------------------
// Step 3, part 1:
// Display the environment variables in each target.
//-------------------------------------------------------------------------------------
    Console.WriteLine(msg31);
    CheckAllVariables();
    Console.WriteLine();
//-------------------------------------------------------------------------------------
// Step 3, part 2:
// Check whether the User and Machine environment variables were created in the Windows 
// operating system registry.
//-------------------------------------------------------------------------------------
    Console.WriteLine(msg32);
    CheckRegistry();
    Console.WriteLine();
//-------------------------------------------------------------------------------------
// Step 4, part 1:
// Delete the environment variables created for this sample.
// This section demonstrates using Environment.SetEnvironmentVariable to delete an 
// environment variable.
//-------------------------------------------------------------------------------------
    Console.WriteLine(msg41);
    Environment.SetEnvironmentVariable(myVarA, null);
    Environment.SetEnvironmentVariable(myVarB, null, EnvironmentVariableTarget.Process);
    Environment.SetEnvironmentVariable(myVarC, null, EnvironmentVariableTarget.User);
    Environment.SetEnvironmentVariable(myVarD, null, EnvironmentVariableTarget.Machine);
//-------------------------------------------------------------------------------------
// Step 4, part 2:
// Check whether the environment variables were deleted in each target.
//-------------------------------------------------------------------------------------
    Console.WriteLine(msg42);
    CheckEachVariable();
//-------------------------------------------------------------------------------------
// Step 4, part 3:
// Check whether the User and Machine environment variables were deleted from the 
// Windows operating system registry.
//-------------------------------------------------------------------------------------
    Console.WriteLine(msg43);
    CheckRegistry();
    }
}
/*
This example produces the following results:

Step 1:
  Check whether the environment variables already exist in
  the various targets...

Process:
  A_GETSET_ENVAR_SAMPLE doesn't exist.
  B_GETSET_ENVAR_SAMPLE doesn't exist.
  C_GETSET_ENVAR_SAMPLE doesn't exist.
  D_GETSET_ENVAR_SAMPLE doesn't exist.

User:
  A_GETSET_ENVAR_SAMPLE doesn't exist.
  B_GETSET_ENVAR_SAMPLE doesn't exist.
  C_GETSET_ENVAR_SAMPLE doesn't exist.
  D_GETSET_ENVAR_SAMPLE doesn't exist.

Machine:
  A_GETSET_ENVAR_SAMPLE doesn't exist.
  B_GETSET_ENVAR_SAMPLE doesn't exist.
  C_GETSET_ENVAR_SAMPLE doesn't exist.
  D_GETSET_ENVAR_SAMPLE doesn't exist.


Step 2:
  Set the environment variable for each target...

  (default): Set A_GETSET_ENVAR_SAMPLE = "exists in the default target (Process)"
    Process: Set B_GETSET_ENVAR_SAMPLE = "exists in Process"
       User: Set C_GETSET_ENVAR_SAMPLE = "exists in User"
    Machine: Set D_GETSET_ENVAR_SAMPLE = "exists in Machine"

Step 3, part 1:
  Display the environment variables in each target...

Process:
  B_GETSET_ENVAR_SAMPLE exists in Process.
  A_GETSET_ENVAR_SAMPLE exists in the default target (Process).

User:
  C_GETSET_ENVAR_SAMPLE exists in User.

Machine:
  D_GETSET_ENVAR_SAMPLE exists in Machine.


Step 3, part 2:
  Check whether the User and Machine environment variables
  were created in the Windows operating system registry...

"Environment" key:
  C_GETSET_ENVAR_SAMPLE exists in User.

"System\CurrentControlSet\Control\Session Manager\Environment" key:
  D_GETSET_ENVAR_SAMPLE exists in Machine.


Step 4, part 1:
  Delete the environment variables created for this sample...

Step 4, part 2:
  Check whether the environment variables were deleted
  in each target...

Process:
  A_GETSET_ENVAR_SAMPLE doesn't exist.
  B_GETSET_ENVAR_SAMPLE doesn't exist.
  C_GETSET_ENVAR_SAMPLE doesn't exist.
  D_GETSET_ENVAR_SAMPLE doesn't exist.

User:
  A_GETSET_ENVAR_SAMPLE doesn't exist.
  B_GETSET_ENVAR_SAMPLE doesn't exist.
  C_GETSET_ENVAR_SAMPLE doesn't exist.
  D_GETSET_ENVAR_SAMPLE doesn't exist.

Machine:
  A_GETSET_ENVAR_SAMPLE doesn't exist.
  B_GETSET_ENVAR_SAMPLE doesn't exist.
  C_GETSET_ENVAR_SAMPLE doesn't exist.
  D_GETSET_ENVAR_SAMPLE doesn't exist.

Step 4, part 3:
  Check whether the User and Machine environment variables
  were deleted from the Windows operating system registry...

"Environment" key:
  Environment variable doesn't exist.

"System\CurrentControlSet\Control\Session Manager\Environment" key:
  Environment variable doesn't exist.
*/

// This example demonstrates the
//     Environment.GetEnvironmentVariable,
//     Environment.SetEnvironmentVariable, and
//     Environment.GetEnvironmentVariables overloaded methods.

using namespace System;
using namespace System::Collections;
using namespace Microsoft::Win32;

namespace EnvironmentVariablesSample
{
    public ref class TestEnvironmentVariables sealed
    {
    public:
        // DoTest: Test get/set environment variables
        static void DoTest()
        {     
            // Environment variable values
            String^ existsA = "exists in the default target"
                " (Process)";
            String^ existsB = "exists in Process";
            String^ existsC = "exists in User";
            String^ existsD = "exists in Machine";     
            // Messages:
            String^ messageStep1 = "Step 1:\n"
                "  Check whether the environment variables already"
                " exist in \n"
                "  the various targets...\n";
            String^ messageStep2 = "Step 2:\n"
                "  Set the environment variable for each"
                " target...\n";
            String^ messageStep3Part1 = "Step 3, part 1:\n"
                "  Display the environment variables in each"
                " target...\n";
            String^ messageStep3Part2 = "Step 3, part 2:\n"
                "  Check whether the User and Machine "
                " environment variables \n"
                "  were created in the Windows operating"
                " system registry...\n";
            String^ messageStep4Part1 = "Step 4, part 1:\n"
                "  Delete the environment variables created "
                "for this sample...\n";
            String^ messageStep4Part2 = "Step 4, part 2:\n"
                "  Check whether the environment variables were "
                "deleted \n"
                "  in each target...\n";
            String^ messageStep4Part3 = "Step 4, part 3:\n"
                "  Check whether the User and Machine environment "
                "variables \n"
                "  were deleted from the Windows operating system "
                "registry...\n";
            String^ step2Format = "  {0,9}: Set {1} = \"{2}\"";  

            // Step 1:
            // Check whether the sample environment variables already
            // exist.
            // WARNING: These variables will be deleted at the end of
            // this sample.
            Console::WriteLine(messageStep1);
            CheckVariables();
            Console::WriteLine();   

            // Step 2:
            // Set the environment variable for each target.
            // This section demonstrates
            // Environment.SetEnvironmentVariable.
            Console::WriteLine(messageStep2);     

            // Set the environment variable for the default target
            // (the current process).
            Console::WriteLine(step2Format, "(default)", VariableA,
                existsA);
            Environment::SetEnvironmentVariable(VariableA, existsA);  

            // Set the environment variable
            // for the the current process.
            Console::WriteLine(step2Format, "Process", VariableB,
                existsB);
            Environment::SetEnvironmentVariable(VariableB, existsB,
                EnvironmentVariableTarget::Process);

            // Set the environment variable for the the current user.
            Console::WriteLine(step2Format, "User", VariableC,
                existsC);
            Environment::SetEnvironmentVariable(VariableC, existsC,
                EnvironmentVariableTarget::User);

            // Set the environment variable for the the local machine.
            Console::WriteLine(step2Format, "Machine", VariableD,
                existsD);
            Environment::SetEnvironmentVariable(VariableD, existsD,
                EnvironmentVariableTarget::Machine);
            Console::WriteLine();      

            // Step 3, part 1:
            // Display the environment variables in each target.
            Console::WriteLine(messageStep3Part1);
            PrintVariables();
            Console::WriteLine();     

            // Step 3, part 2:
            // Check whether the User and Machine environment
            // variables were created in the Windows operating system
            // registry.
            Console::WriteLine(messageStep3Part2);
            CheckRegistryVariables();
            Console::WriteLine();

            // Step 4, part 1:
            // Delete the environment variables created for this
            // sample. This section demonstrates using 
            // Environment.SetEnvironmentVariable to delete an 
            // environment variable.
            Console::WriteLine(messageStep4Part1);
            Environment::SetEnvironmentVariable(VariableA, nullptr);
            Environment::SetEnvironmentVariable(VariableB, nullptr,
                EnvironmentVariableTarget::Process);
            Environment::SetEnvironmentVariable(VariableC, nullptr,
                EnvironmentVariableTarget::User);
            Environment::SetEnvironmentVariable(VariableD, nullptr,
                EnvironmentVariableTarget::Machine);     

            // Step 4, part 2:
            // Check whether the environment variables were deleted 
            // in each target.
            Console::WriteLine(messageStep4Part2);
            CheckVariables();

            // Step 4, part 3:
            // Check whether the User and Machine environment
            // variables were deleted from the Windows operating
            // system registry.
            Console::WriteLine(messageStep4Part3);
            CheckRegistryVariables();
        }

    protected:
        // Globals:
        literal String^ NameValueFormat = "  {0} {1}.";
        literal String^ VariableSuffix = "_GETSET_ENVAR_SAMPLE";

        // Four relatively unique environment variable names.
        // default process

        literal String^ VariableA = "A_GETSET_ENVAR_SAMPLE";

        // Current Process
        literal String^ VariableB = "B_GETSET_ENVAR_SAMPLE";

        // Current User
        literal String^ VariableC = "C_GETSET_ENVAR_SAMPLE";

        // Local Machine
        literal String^ VariableD = "D_GETSET_ENVAR_SAMPLE";

    private:
        // CheckVariablesInTarget:
        // Test whether a specific environment variable exists
        // in a target. This section demonstrates
        // Environment.GetEnvironmentVariable.
        static void CheckVariablesInTarget(String^ variable,
            EnvironmentVariableTarget target)
        {
            String^ variableName;

            // Zero means use the default target.
            if (target == (EnvironmentVariableTarget) 0)
            {
                variableName =
                    Environment::GetEnvironmentVariable(variable);
            }
            else
            {
                variableName = Environment::GetEnvironmentVariable(
                    variable, target);
            }
            Console::WriteLine(NameValueFormat, variable,
                (String::IsNullOrEmpty(variableName) ?
                "doesn't exist" : variableName));
        }

        // CheckVariable:
        // Uses CheckVariablesInTarget to test whether each
        // environment variable exists in a target.
        static void CheckVariables()
        {
            Console::WriteLine("Process:");

            // Check the default target(current process)
            CheckVariablesInTarget(VariableA,
                (EnvironmentVariableTarget) 0);
            CheckVariablesInTarget(VariableB,
                EnvironmentVariableTarget::Process);
            CheckVariablesInTarget(VariableC,
                EnvironmentVariableTarget::Process);
            CheckVariablesInTarget(VariableD,
                EnvironmentVariableTarget::Process);
            Console::WriteLine();

            Console::WriteLine("User:");
            CheckVariablesInTarget(VariableA,
                EnvironmentVariableTarget::User);
            CheckVariablesInTarget(VariableB,
                EnvironmentVariableTarget::User);
            CheckVariablesInTarget(VariableC,
                EnvironmentVariableTarget::User);
            CheckVariablesInTarget(VariableD,
                EnvironmentVariableTarget::User);
            Console::WriteLine();

            Console::WriteLine("Machine:");
            CheckVariablesInTarget(VariableA,
                EnvironmentVariableTarget::Machine);
            CheckVariablesInTarget(VariableB,
                EnvironmentVariableTarget::Machine);
            CheckVariablesInTarget(VariableC,
                EnvironmentVariableTarget::Machine);
            CheckVariablesInTarget(VariableD,
                EnvironmentVariableTarget::Machine);
            Console::WriteLine();
        }

        // PrintVariablesFromTarget: PrintVariables helper function.
        // This section demonstrates
        // Environment.GetEnvironmentVariables.
        static void PrintVariablesFromTarget(
            EnvironmentVariableTarget target)
        {
            String^ valueString;
            String^ keyString;

            for each (DictionaryEntry^ dictionary in
                Environment::GetEnvironmentVariables(target))
            {
                keyString = safe_cast<String^> (dictionary->Key);
                valueString = safe_cast<String^> (dictionary->Value);
                if (keyString->Contains(VariableSuffix))
                    Console::WriteLine(NameValueFormat, keyString,
                    valueString);
            }
            Console::WriteLine();
        }

        // PrintVariables:
        // Uses PrintVariablesFromTarget to test whether
        // each environment variable exists in a target.
        static void PrintVariables()
        {
            Console::WriteLine("Process:");
            PrintVariablesFromTarget(EnvironmentVariableTarget::Process);

            Console::WriteLine("User:");
            PrintVariablesFromTarget(EnvironmentVariableTarget::User);

            Console::WriteLine("Machine:");
            PrintVariablesFromTarget(EnvironmentVariableTarget::Machine);
        }

        // CheckRegistryVariablesForKey: CheckRegistryVariables
        // helper function. This function filters out irrelevant
        // environment variables.
        static void CheckRegistryVariablesForKey(RegistryKey^ targetKey)
        {
            bool exists = false;            

            for each (
                String^ variableName in targetKey->GetValueNames())
            {
                if (variableName->Contains(VariableSuffix))
                {
                    String^ variableValue =
                        safe_cast<String^>
                        (targetKey->GetValue(variableName));
                    Console::WriteLine(NameValueFormat, variableName,
                        variableValue);
                    exists = true;
                }
            }
            if (!exists)
            {
                Console::WriteLine(
                    "  Environment variable doesn't exist.");
            }
            Console::WriteLine();
        }

        // CheckRegistryVariables:
        // Uses CheckRegistryVariables to display the User and
        // Machine environment variables in the registry.
        static void CheckRegistryVariables()
        {
            String^ subkeyUser = "Environment";
            String^ subkeyMachine = "System\\CurrentControlSet\\"
                "Control\\Session Manager\\Environment";
            String^ subkeyFormat = "\"{0}\" key:";

            Console::WriteLine(subkeyFormat, subkeyUser);
            CheckRegistryVariablesForKey(
                Registry::CurrentUser->OpenSubKey(subkeyUser));

            Console::WriteLine(subkeyFormat, subkeyMachine);
            CheckRegistryVariablesForKey(
                Registry::LocalMachine->OpenSubKey(subkeyMachine));
        }
    };
};

using namespace EnvironmentVariablesSample;

int main()
{
    TestEnvironmentVariables::DoTest();
}

/*
This example produces the following results:

Step 1:
Check whether the environment variables already exist in
the various targets...

Process:
A_GETSET_ENVAR_SAMPLE doesn't exist.
B_GETSET_ENVAR_SAMPLE doesn't exist.
C_GETSET_ENVAR_SAMPLE doesn't exist.
D_GETSET_ENVAR_SAMPLE doesn't exist.

User:
A_GETSET_ENVAR_SAMPLE doesn't exist.
B_GETSET_ENVAR_SAMPLE doesn't exist.
C_GETSET_ENVAR_SAMPLE doesn't exist.
D_GETSET_ENVAR_SAMPLE doesn't exist.

Machine:
A_GETSET_ENVAR_SAMPLE doesn't exist.
B_GETSET_ENVAR_SAMPLE doesn't exist.
C_GETSET_ENVAR_SAMPLE doesn't exist.
D_GETSET_ENVAR_SAMPLE doesn't exist.


Step 2:
Set the environment variable for each target...

(default): Set A_GETSET_ENVAR_SAMPLE = "exists in the default target (Process)"
Process: Set B_GETSET_ENVAR_SAMPLE = "exists in Process"
User: Set C_GETSET_ENVAR_SAMPLE = "exists in User"
Machine: Set D_GETSET_ENVAR_SAMPLE = "exists in Machine"

Step 3, part 1:
Display the environment variables in each target...

Process:
B_GETSET_ENVAR_SAMPLE exists in Process.
A_GETSET_ENVAR_SAMPLE exists in the default target (Process).

User:
C_GETSET_ENVAR_SAMPLE exists in User.

Machine:
D_GETSET_ENVAR_SAMPLE exists in Machine.


Step 3, part 2:
Check whether the User and Machine environment variables
were created in the Windows operating system registry...

"Environment" key:
C_GETSET_ENVAR_SAMPLE exists in User.

"System\CurrentControlSet\Control\Session Manager\Environment" key:
D_GETSET_ENVAR_SAMPLE exists in Machine.


Step 4, part 1:
Delete the environment variables created for this sample...

Step 4, part 2:
Check whether the environment variables were deleted
in each target...

Process:
A_GETSET_ENVAR_SAMPLE doesn't exist.
B_GETSET_ENVAR_SAMPLE doesn't exist.
C_GETSET_ENVAR_SAMPLE doesn't exist.
D_GETSET_ENVAR_SAMPLE doesn't exist.

User:
A_GETSET_ENVAR_SAMPLE doesn't exist.
B_GETSET_ENVAR_SAMPLE doesn't exist.
C_GETSET_ENVAR_SAMPLE doesn't exist.
D_GETSET_ENVAR_SAMPLE doesn't exist.

Machine:
A_GETSET_ENVAR_SAMPLE doesn't exist.
B_GETSET_ENVAR_SAMPLE doesn't exist.
C_GETSET_ENVAR_SAMPLE doesn't exist.
D_GETSET_ENVAR_SAMPLE doesn't exist.

Step 4, part 3:
Check whether the User and Machine environment variables
were deleted from the Windows operating system registry...

"Environment" key:
Environment variable doesn't exist.

"System\CurrentControlSet\Control\Session Manager\Environment" key:
Environment variable doesn't exist.
*/

// This example demonstrates the 
//     Environment.GetEnvironmentVariable,
//     Environment.SetEnvironmentVariable, and 
//     Environment.GetEnvironmentVariables overloaded methods.
import System.*;
import System.Collections.*;
import Microsoft.Win32.*;

class Sample
{
    //-------------------------------------------------------------------------
    // Globals: 
    //-------------------------------------------------------------------------
    protected static String fmtNameValue = "  {0} {1}.";
    protected static String myVarSuffix = "_GETSET_ENVAR_SAMPLE";

    // Four relatively unique environment variable names.
    protected static String myVarA = "A" + myVarSuffix; // default process
    protected static String myVarB = "B" + myVarSuffix; // Current Process
    protected static String myVarC = "C" + myVarSuffix; // Current User
    protected static String myVarD = "D" + myVarSuffix;

    // Local Machine
    //=========================================================================
    // EachVariable: 
    // Test whether a specific environment variable exists in a target.
    // This section demonstrates Environment.GetEnvironmentVariable.
    //-------------------------------------------------------------------------
    protected static void EachVariable(String var, 
        EnvironmentVariableTarget tgt)
    {
        String str;
        //
        if (tgt.Equals((EnvironmentVariableTarget)0)) {
            // Zero means use the default target.
            str = Environment.GetEnvironmentVariable(var);
        }
        else {
            str = Environment.GetEnvironmentVariable(var, tgt);
        }
        Console.WriteLine(fmtNameValue, var,
            (String.IsNullOrEmpty(str)) ? "doesn't exist" : str);
    } //EachVariable

    //-------------------------------------------------------------------------
    // CheckEachVariable: 
    // Uses EachVariable to test whether each environment variable exists in a
    // target.
    //-------------------------------------------------------------------------
    protected static void CheckEachVariable()
    {
        Console.WriteLine("Process:");
        // Check the default target (current process)
        EachVariable(myVarA, (EnvironmentVariableTarget)0); 
        EachVariable(myVarB, EnvironmentVariableTarget.Process);
        EachVariable(myVarC, EnvironmentVariableTarget.Process);
        EachVariable(myVarD, EnvironmentVariableTarget.Process);
        Console.WriteLine();

        Console.WriteLine("User:");
        EachVariable(myVarA, EnvironmentVariableTarget.User);
        EachVariable(myVarB, EnvironmentVariableTarget.User);
        EachVariable(myVarC, EnvironmentVariableTarget.User);
        EachVariable(myVarD, EnvironmentVariableTarget.User);
        Console.WriteLine();

        Console.WriteLine("Machine:");
        EachVariable(myVarA, EnvironmentVariableTarget.Machine);
        EachVariable(myVarB, EnvironmentVariableTarget.Machine);
        EachVariable(myVarC, EnvironmentVariableTarget.Machine);
        EachVariable(myVarD, EnvironmentVariableTarget.Machine);
        Console.WriteLine();
    } //CheckEachVariable

    //=========================================================================
    // AllVariables: CheckAllVariables helper function.
    // This section demonstrates Environment.GetEnvironmentVariables.
    //-------------------------------------------------------------------------
    private static void AllVariables(EnvironmentVariableTarget tgt)
    {
        String value;
        String key;        
        DictionaryEntry de;
        IEnumerator objEnum = 
            Environment.GetEnvironmentVariables(tgt).GetEnumerator();
        while (objEnum.MoveNext()) {
            de = (DictionaryEntry)objEnum.get_Current();
            key = (System.String)(de.get_Key());
            value = (System.String)(de.get_Value());
            if (key.Contains(myVarSuffix)) {
                Console.WriteLine(fmtNameValue, key, value);
            }
        }
        Console.WriteLine();
    } //AllVariables

    //=========================================================================
    // CheckAllVariables: 
    // Uses AllVariables to test whether each environment variable exists in a
    // target.
    //-------------------------------------------------------------------------
    protected static void CheckAllVariables()
    {
        Console.WriteLine("Process:");
        AllVariables(EnvironmentVariableTarget.Process);

        Console.WriteLine("User:");
        AllVariables(EnvironmentVariableTarget.User);

        Console.WriteLine("Machine:");
        AllVariables(EnvironmentVariableTarget.Machine);
    } //CheckAllVariables

    //=========================================================================
    // ChkReg: CheckRegistry helper function.
    // This function filters out irrelevant environment variables. 
    //-------------------------------------------------------------------------
    private static void ChkReg(RegistryKey rk)
    {
        boolean exists = false;
        String registryNone = "  Environment variable doesn't exist.";
        for (int iCtr = 0; iCtr < rk.GetValueNames().get_Length(); iCtr++) {
            String s = ( String)rk.GetValueNames().get_Item(iCtr);
            if (s.Contains(myVarSuffix)) {
                Console.WriteLine(fmtNameValue, s,
                    (System.String)(rk.GetValue(s)));
                exists = true;
            }
        }
        if (exists == false) {
            Console.WriteLine(registryNone);
        }
        Console.WriteLine();
    } //ChkReg

    //-------------------------------------------------------------------------
    // CheckRegistry: 
    // Uses ChkReg to display the User and Machine environment variables in the
    // registry.
    //-------------------------------------------------------------------------
    protected static void CheckRegistry()
    {
        String subkeyU = "Environment";
        String subkeyM = 
            "System\\CurrentControlSet\\Control\\Session Manager\\Environment";
        String fmtSubkey = "\"{0}\" key:";

        Console.WriteLine(fmtSubkey, subkeyU);
        ChkReg(Registry.CurrentUser.OpenSubKey(subkeyU));

        Console.WriteLine(fmtSubkey, subkeyM);
        ChkReg(Registry.LocalMachine.OpenSubKey(subkeyM));
    } //CheckRegistry

    //=========================================================================
    // main:
    //-------------------------------------------------------------------------
    public static void main(String[] args)
    {
        //---------------------------------------------------------------------
        // Environment variable values
        //---------------------------------------------------------------------
        String existsA = "exists in the default target (Process)";
        String existsB = "exists in Process";
        String existsC = "exists in User";
        String existsD = "exists in Machine";
        //---------------------------------------------------------------------
        // Messages:
        //---------------------------------------------------------------------
        String msg1 = "Step 1:\n" 
            + "  Check whether the environment variables already exist in \n" 
            + "  the various targets...\n";
        String msg2 = "Step 2:\n" 
            +"  Set the environment variable for each target...\n";
        String msg31 = "Step 3, part 1:\n" 
            +"  Display the environment variables in each target...\n";
        String msg32 = "Step 3, part 2:\n" 
            +"  Check whether the User and Machine environment variables \n" 
            +"  were created in the Windows operating system registry...\n";
        String msg41 = "Step 4, part 1:\n" 
            +"  Delete the environment variables created for this sample...\n";
        String msg42 = "Step 4, part 2:\n" 
            +"  Check whether the environment variables were deleted \n" 
            +"  in each target...\n";
        String msg43 = "Step 4, part 3:\n" 
            +"  Check whether the User and Machine environment variables \n" 
            +"  were deleted from the Windows operating system registry...\n";
        String fmt2x = "  {0,9}: Set {1} = \"{2}\"";
        //---------------------------------------------------------------------
        // Step 1:
        // Check whether the sample environment variables already exist.
        // WARNING: These variables will be deleted at the end of this sample.
        //---------------------------------------------------------------------
        Console.WriteLine(msg1);
        CheckEachVariable();
        Console.WriteLine();
        //---------------------------------------------------------------------
        // Step 2:
        // Set the environment variable for each target.
        // This section demonstrates Environment.SetEnvironmentVariable.
        //---------------------------------------------------------------------
        Console.WriteLine(msg2);

        // Set the environment variable for the default target
        // (the current process).
        Console.WriteLine(fmt2x, "(default)", myVarA, existsA);
        Environment.SetEnvironmentVariable(myVarA, existsA);

        // Set the environment variable for the the current process.
        Console.WriteLine(fmt2x, "Process", myVarB, existsB);
        Environment.SetEnvironmentVariable(myVarB, existsB,
            EnvironmentVariableTarget.Process);

        // Set the environment variable for the the current user.
        Console.WriteLine(fmt2x, "User", myVarC, existsC);
        Environment.SetEnvironmentVariable(myVarC, existsC,
            EnvironmentVariableTarget.User);

        // Set the environment variable for the the local machine.
        Console.WriteLine(fmt2x, "Machine", myVarD, existsD);
        Environment.SetEnvironmentVariable(myVarD, existsD,
            EnvironmentVariableTarget.Machine);
        Console.WriteLine();
        //---------------------------------------------------------------------
        // Step 3, part 1:
        // Display the environment variables in each target.
        //---------------------------------------------------------------------
        Console.WriteLine(msg31);
        CheckAllVariables();
        Console.WriteLine();
        //---------------------------------------------------------------------
        // Step 3, part 2:
        // Check whether the User and Machine environment variables were
        // created in the Windows operating system registry.
        //---------------------------------------------------------------------
        Console.WriteLine(msg32);
        CheckRegistry();
        Console.WriteLine();
        //---------------------------------------------------------------------
        // Step 4, part 1:
        // Delete the environment variables created for this sample.
        // This section demonstrates using Environment.SetEnvironmentVariable
        // to delete an environment variable.
        //---------------------------------------------------------------------       
        Console.WriteLine(msg41);
        Environment.SetEnvironmentVariable(myVarA, null);
        Environment.SetEnvironmentVariable(myVarB, null,
            EnvironmentVariableTarget.Process);
        Environment.SetEnvironmentVariable(myVarC, null,
            EnvironmentVariableTarget.User);
        Environment.SetEnvironmentVariable(myVarD, null,
            EnvironmentVariableTarget.Machine);
        //---------------------------------------------------------------------
        // Step 4, part 2:
        // Check whether the environment variables were deleted in each target.
        //---------------------------------------------------------------------        
        Console.WriteLine(msg42);
        CheckEachVariable();
        //---------------------------------------------------------------------
        // Step 4, part 3:
        // Check whether the User and Machine environment variables were
        // deleted from the Windows operating system registry.
        //---------------------------------------------------------------------
        Console.WriteLine(msg43);
        CheckRegistry();
    } //main
} //Sample
/*
This example produces the following results:

Step 1:
  Check whether the environment variables already exist in
  the various targets...

Process:
  A_GETSET_ENVAR_SAMPLE doesn't exist.
  B_GETSET_ENVAR_SAMPLE doesn't exist.
  C_GETSET_ENVAR_SAMPLE doesn't exist.
  D_GETSET_ENVAR_SAMPLE doesn't exist.

User:
  A_GETSET_ENVAR_SAMPLE doesn't exist.
  B_GETSET_ENVAR_SAMPLE doesn't exist.
  C_GETSET_ENVAR_SAMPLE doesn't exist.
  D_GETSET_ENVAR_SAMPLE doesn't exist.

Machine:
  A_GETSET_ENVAR_SAMPLE doesn't exist.
  B_GETSET_ENVAR_SAMPLE doesn't exist.
  C_GETSET_ENVAR_SAMPLE doesn't exist.
  D_GETSET_ENVAR_SAMPLE doesn't exist.


Step 2:
  Set the environment variable for each target...

  (default): Set A_GETSET_ENVAR_SAMPLE = "exists in the default target (Process)"
    Process: Set B_GETSET_ENVAR_SAMPLE = "exists in Process"
       User: Set C_GETSET_ENVAR_SAMPLE = "exists in User"
    Machine: Set D_GETSET_ENVAR_SAMPLE = "exists in Machine"

Step 3, part 1:
  Display the environment variables in each target...

Process:
  B_GETSET_ENVAR_SAMPLE exists in Process.
  A_GETSET_ENVAR_SAMPLE exists in the default target (Process).

User:
  C_GETSET_ENVAR_SAMPLE exists in User.

Machine:
  D_GETSET_ENVAR_SAMPLE exists in Machine.


Step 3, part 2:
  Check whether the User and Machine environment variables
  were created in the Windows operating system registry...

"Environment" key:
  C_GETSET_ENVAR_SAMPLE exists in User.

"System\CurrentControlSet\Control\Session Manager\Environment" key:
  D_GETSET_ENVAR_SAMPLE exists in Machine.


Step 4, part 1:
  Delete the environment variables created for this sample...

Step 4, part 2:
  Check whether the environment variables were deleted
  in each target...

Process:
  A_GETSET_ENVAR_SAMPLE doesn't exist.
  B_GETSET_ENVAR_SAMPLE doesn't exist.
  C_GETSET_ENVAR_SAMPLE doesn't exist.
  D_GETSET_ENVAR_SAMPLE doesn't exist.

User:
  A_GETSET_ENVAR_SAMPLE doesn't exist.
  B_GETSET_ENVAR_SAMPLE doesn't exist.
  C_GETSET_ENVAR_SAMPLE doesn't exist.
  D_GETSET_ENVAR_SAMPLE doesn't exist.

Machine:
  A_GETSET_ENVAR_SAMPLE doesn't exist.
  B_GETSET_ENVAR_SAMPLE doesn't exist.
  C_GETSET_ENVAR_SAMPLE doesn't exist.
  D_GETSET_ENVAR_SAMPLE doesn't exist.

Step 4, part 3:
  Check whether the User and Machine environment variables
  were deleted from the Windows operating system registry...

"Environment" key:
  Environment variable doesn't exist.

"System\CurrentControlSet\Control\Session Manager\Environment" key:
  Environment variable doesn't exist.
*/