Environment.GetEnvironmentVariable Metódus

Definíció

Névtér:
System
Szerelvények:
mscorlib.dll, System.Runtime.Extensions.dll
Szerelvények:
netstandard.dll, System.Runtime.dll
Szerelvény:
System.Runtime.Extensions.dll
Szerelvény:
mscorlib.dll
Szerelvény:
netstandard.dll

Lekéri egy környezeti változó értékét.

Túlterhelések

Name Description
GetEnvironmentVariable(String)

Lekéri egy környezeti változó értékét az aktuális folyamatból.
GetEnvironmentVariable(String, EnvironmentVariableTarget)

Lekéri egy környezeti változó értékét az aktuális folyamatból vagy az aktuális felhasználó vagy helyi gép Windows operációsrendszer-beállításkulcsából.

GetEnvironmentVariable(String)

Forrás:
Environment.cs
Forrás:
Environment.cs
Forrás:
Environment.cs
Forrás:
Environment.cs
Forrás:
Environment.cs

Lekéri egy környezeti változó értékét az aktuális folyamatból.

public:
 static System::String ^ GetEnvironmentVariable(System::String ^ variable);
public static string GetEnvironmentVariable(string variable);
public static string? GetEnvironmentVariable(string variable);
static member GetEnvironmentVariable : string -> string
Public Shared Function GetEnvironmentVariable (variable As String) As String

Paraméterek

variable
String

A környezeti változó neve.

Válaszok

String

A környezeti változó által variablemegadott érték, vagy null ha a környezeti változó nem található.

Kivételek

ArgumentNullException

variable az null.

SecurityException

A hívó nem rendelkezik a művelet végrehajtásához szükséges engedéllyel.

Példák

Az alábbi példa a GetEnvironmentVariable metódust használja a windir környezeti változó lekéréséhez, amely a Windows könyvtár elérési útját tartalmazza.

using System;
using System.IO;

public class Example
{
   public static void Main()
   {
      if (Environment.OSVersion.Platform == PlatformID.Win32NT)
      {
         // Change the directory to %WINDIR%
         Environment.CurrentDirectory = Environment.GetEnvironmentVariable("windir");
         DirectoryInfo info = new DirectoryInfo(".");

         Console.WriteLine("Directory Info:   " + info.FullName);
      }
      else
      {
         Console.WriteLine("This example runs on Windows only.");
      }
   }
}
// The example displays output like the following on a .NET implementation running on Windows:
//        Directory Info:   C:\windows
// The example displays the following output on a .NET implementation on Unix-based systems:
//        This example runs on Windows only.

open System
open System.IO

if Environment.OSVersion.Platform = PlatformID.Win32NT then
    // Change the directory to %WINDIR%
    Environment.CurrentDirectory <- Environment.GetEnvironmentVariable "windir"
    
    let info = DirectoryInfo "."

    printfn $"Directory Info:   {info.FullName}"
else
    printfn "This example runs on Windows only."
// The example displays output like the following on a .NET implementation running on Windows:
//        Directory Info:   C:\windows
// The example displays the following output on a .NET implementation on Unix-based systems:
//        This example runs on Windows only.

Imports System.IO

Module Example
   Public Sub Main()
        If Environment.OSVersion.Platform = PlatformID.Win32NT Then
            ' Change the directory to %WINDIR%
            Environment.CurrentDirectory = Environment.GetEnvironmentVariable("windir")
            Dim info As New DirectoryInfo(".")
            Console.WriteLine("Directory Info:   " + info.FullName)
         Else
            Console.WriteLine("This example runs on Windows only.")
         End If
   End Sub
End Module
' The example displays output like the following on a .NET implementation running on Windows:
'        Directory Info:   C:\windows
' The example displays the following output on a .NET implementation on Unix-based systems:
'        This example runs on Windows only.

Az alábbi példa egy folyamatkörnyezeti blokkból elnevezett Test1 környezeti változó értékét próbálja lekérni. Ha a változó nem létezik, a példa létrehozza és lekéri az értékét. A példa a változó értékét jeleníti meg. Ha a példa létrehozta a változót, meghívja a metódust az GetEnvironmentVariables(EnvironmentVariableTarget) enumerálás minden tagjával EnvironmentVariableTarget annak megállapításához, hogy a változó csak az aktuális folyamatkörnyezeti blokkból kérhető le. Végül, ha a példa létrehozta a változót, törli azt.

using System;

public class Example
{
   public static void Main()
   {
      string value;
      bool toDelete = false;

      // Check whether the environment variable exists.
      value = Environment.GetEnvironmentVariable("Test1");
      // If necessary, create it.
      if (value == null)
      {
         Environment.SetEnvironmentVariable("Test1", "Value1");
         toDelete = true;

         // Now retrieve it.
         value = Environment.GetEnvironmentVariable("Test1");
      }
      // Display the value.
      Console.WriteLine($"Test1: {value}\n");

      // Confirm that the value can only be retrieved from the process
      // environment block if running on a Windows system.
      if (Environment.OSVersion.Platform == PlatformID.Win32NT)
      {
         Console.WriteLine("Attempting to retrieve Test1 from:");
         foreach (EnvironmentVariableTarget enumValue in
                           Enum.GetValues(typeof(EnvironmentVariableTarget))) {
            value = Environment.GetEnvironmentVariable("Test1", enumValue);
            Console.WriteLine($"   {enumValue}: {(value != null ? "found" : "not found")}");
         }
         Console.WriteLine();
      }

      // If we've created it, now delete it.
      if (toDelete) {
         Environment.SetEnvironmentVariable("Test1", null);
         // Confirm the deletion.
         if (Environment.GetEnvironmentVariable("Test1") == null)
            Console.WriteLine("Test1 has been deleted.");
      }
   }
}
// The example displays the following output if run on a Windows system:
//      Test1: Value1
//
//      Attempting to retrieve Test1 from:
//         Process: found
//         User: not found
//         Machine: not found
//
//      Test1 has been deleted.
//
// The example displays the following output if run on a Unix-based system:
//      Test1: Value1
//
//      Test1 has been deleted.

module Example

open System

let mutable toDelete = false

// Check whether the environment variable exists.
let value = 
    let v = Environment.GetEnvironmentVariable "Test1"
    // If necessary, create it.
    if isNull v then
        Environment.SetEnvironmentVariable("Test1", "Value1")
        toDelete <- true
        Environment.GetEnvironmentVariable "Test1"
    else 
        v

// Display the value.
printfn $"Test1: {value}\n"

// Confirm that the value can only be retrieved from the process
// environment block if running on a Windows system.
if Environment.OSVersion.Platform = PlatformID.Win32NT then
    printfn "Attempting to retrieve Test1 from:"
    for enumValue in Enum.GetValues typeof<EnvironmentVariableTarget> do
        let value = Environment.GetEnvironmentVariable("Test1", enumValue :?> EnvironmentVariableTarget)
        printfn $"""   {enumValue}: {if value <> null then "found" else "not found"}"""
    printfn ""

// If we've created it, now delete it.
if toDelete then
    Environment.SetEnvironmentVariable("Test1", null)
    // Confirm the deletion.
    if Environment.GetEnvironmentVariable "Test1" |> isNull then
        printfn "Test1 has been deleted."
// The example displays the following output if run on a Windows system:
//      Test1: Value1
//
//      Attempting to retrieve Test1 from:
//         Process: found
//         User: not found
//         Machine: not found
//
//      Test1 has been deleted.
//
// The example displays the following output if run on a Unix-based system:
//      Test1: Value1
//
//      Test1 has been deleted.

Module Example
   Public Sub Main()
      Dim value As String 
      Dim toDelete As Boolean = False
      
      ' Check whether the environment variable exists.
      value = Environment.GetEnvironmentVariable("Test1")
      ' If necessary, create it.
      If value Is Nothing Then
         Environment.SetEnvironmentVariable("Test1", "Value1")
         toDelete = True
         
         ' Now retrieve it.
         value = Environment.GetEnvironmentVariable("Test1")
      End If
      ' Display the value.
      Console.WriteLine($"Test1: {value}")
      Console.WriteLine()
      
      ' Confirm that the value can only be retrieved from the process
      ' environment block if running on a Windows system.
      If Environment.OSVersion.Platform = PlatformID.Win32NT Then
         Console.WriteLine("Attempting to retrieve Test1 from:")
         For Each enumValue As EnvironmentVariableTarget In 
                           [Enum].GetValues(GetType(EnvironmentVariableTarget))
            value = Environment.GetEnvironmentVariable("Test1", enumValue)
            Console.WriteLine($"   {enumValue}: {If(value IsNot Nothing, "found", "not found")}")
         Next
         Console.WriteLine()
      End If

      ' If we've created it, now delete it.
      If toDelete Then 
         Environment.SetEnvironmentVariable("Test1", Nothing)
         ' Confirm the deletion.
         If Environment.GetEnvironmentVariable("Test1") = Nothing Then
            Console.WriteLine("Test1 has been deleted.")
         End If
      End If         
   End Sub
End Module
' The example displays the following output if run on a Windows system:
'      Test1: Value1
'
'      Attempting to retrieve Test1 from:
'         Process: found
'         User: not found
'         Machine: not found
'
'      Test1 has been deleted.
'
' The example displays the following output if run on a Unix-based system:
'      Test1: Value1
'
'      Test1 has been deleted.

Megjegyzések

A GetEnvironmentVariable metódus lekéri egy környezeti változó értékét az aktuális folyamatból.

A környezeti változók neve a Unix-szerű rendszereken megkülönbözteti a kis- és nagybetűket, Windows rendszeren azonban nincs különbség a kis- és nagybetűk között.

Megjegyzés:

A natív kódtárak által végrehajtott folyamatban lévő környezetmódosításokat a felügyelt hívók nem látják. Ezzel szemben a felügyelt hívók által végrehajtott ilyen módosításokat nem látják a natív kódtárak.

GetEnvironmentVariable(String) módszer

A GetEnvironmentVariable(String) metódus csak az aktuális folyamat környezeti blokkjából kér le egy környezeti változót. Ez egyenértékű azzal, hogy a GetEnvironmentVariable(String, EnvironmentVariableTarget) metódust target a következő értékkel EnvironmentVariableTarget.Processhívja meg: .

Ha az összes környezeti változót és azok értékeit szeretné lekérni, hívja meg a metódust GetEnvironmentVariables .

Windows rendszereken

Windows rendszereken az aktuális folyamat környezeti blokkja a következőket tartalmazza:

  • Minden környezeti változó, amelyet az azt létrehozó szülőfolyamat biztosít neki. Egy konzolablakból indított .NET-alkalmazás például örökli a konzolablak összes környezeti változóját.

    Ha nincs szülőfolyamat, a rendszer inkább gépenkénti és felhasználónkénti környezeti változókat használ. Egy új konzolablakban például minden gépenkénti és felhasználónkénti környezeti változó meg van határozva az indításkor.

  • Amikor a folyamat fut, a folyamatblokkhoz hozzáadott változók a SetEnvironmentVariable(String, String) vagy a SetEnvironmentVariable(String, String, EnvironmentVariableTarget) metódusok meghívásával történnek, ahol a target értéke a EnvironmentVariableTarget.Process. Ezek a környezeti változók mindaddig megmaradnak, amíg a .NET-alkalmazás le nem áll.

Ha a környezeti változók a folyamat elindítása után jönnek létre, ezzel a metódussal csak azokat a változókat kérdezheti le, amelyek a SetEnvironmentVariable(String, String) metódus vagy a SetEnvironmentVariable(String, String, EnvironmentVariableTarget) metódus .targetértékű meghívásával EnvironmentVariableTarget.Process lettek létrehozva.

Unix-szerű rendszereken

Unix-szerű rendszereken az aktuális folyamat környezeti blokkja a következő környezeti változókat tartalmazza:

A Unix-szerű rendszereken a .NET nem támogatja a gépenkénti vagy felhasználónkénti környezeti változókat.

GetEnvironmentVariable(String, EnvironmentVariableTarget) módszer

Ha az összes környezeti változót és azok értékeit szeretné lekérni, hívja meg a metódust GetEnvironmentVariables .

Windows rendszereken

Windows rendszeren a target paraméter azt határozza meg, hogy a környezeti változó az aktuális folyamatból vagy az aktuális felhasználó vagy helyi gép Windows operációsrendszer-beállításkulcsából van-e lekérve. A rendszer automatikusan átmásolja az összes felhasználónkénti és gépenkénti környezeti változót az aktuális folyamat környezeti blokkjába, ahogyan a .NET-folyamatot létrehozó szülőfolyamat számára elérhető egyéb környezeti változók is. A környezeti változók azonban csak akkor adhatók hozzá az aktuális folyamat környezeti blokkjához, ha a SetEnvironmentVariable(String, String) vagy a SetEnvironmentVariable(String, String, EnvironmentVariableTarget) metódust hívják meg a target értékkel EnvironmentVariableTarget.Process. Ezek a változók csak a folyamat időtartama alatt maradnak meg.

Unix-szerű rendszereken

Unix-szerű rendszereken a GetEnvironmentVariable(String, EnvironmentVariableTarget) metódus csak egy target értéket EnvironmentVariableTarget.Process támogat. Olyan hívások, ahol a target értéke EnvironmentVariableTarget.Machine vagy EnvironmentVariableTarget.User, nem támogatottak, és null értékkel térnek vissza.

Folyamatonkénti környezeti változók a következők:

Lásd még

A következőre érvényes:

GetEnvironmentVariable(String, EnvironmentVariableTarget)

Forrás:
Environment.cs
Forrás:
Environment.cs
Forrás:
Environment.cs
Forrás:
Environment.cs
Forrás:
Environment.cs

Lekéri egy környezeti változó értékét az aktuális folyamatból vagy az aktuális felhasználó vagy helyi gép Windows operációsrendszer-beállításkulcsából.

public:
 static System::String ^ GetEnvironmentVariable(System::String ^ variable, EnvironmentVariableTarget target);
public static string? GetEnvironmentVariable(string variable, EnvironmentVariableTarget target);
public static string GetEnvironmentVariable(string variable, EnvironmentVariableTarget target);
static member GetEnvironmentVariable : string * EnvironmentVariableTarget -> string
Public Shared Function GetEnvironmentVariable (variable As String, target As EnvironmentVariableTarget) As String

Paraméterek

variable
String

Egy környezeti változó neve.

target
EnvironmentVariableTarget

Az egyik EnvironmentVariableTarget érték. Unix-szerű rendszereken futó .NET csak Process támogatott.

Válaszok

String

A környezeti változó és a variabletarget paraméterek által megadott érték, vagy null ha a környezeti változó nem található.

Kivételek

ArgumentNullException

variable az null.

ArgumentException

target érvénytelen EnvironmentVariableTarget érték.

SecurityException

A hívó nem rendelkezik a művelet végrehajtásához szükséges engedéllyel.

Példák

Az alábbi példa környezeti változókat hoz létre a EnvironmentVariableTarget.Process, EnvironmentVariableTarget.Userés Machine a célok számára, ellenőrzi, hogy az operációsrendszer-beállításjegyzék tartalmazza-e a felhasználói és a gép környezeti változóit, majd törli a környezeti változókat. Mivel a Unix-szerű rendszerek .NET nem támogatják a felhasználónkénti és a gépenkénti környezeti változókat, csak SetEnvironmentVariable(String, String) és SetEnvironmentVariable(String, String, EnvironmentVariableTarget)EnvironmentVariableTarget.Process sikeresen tárol egy környezeti változót a folyamatkörnyezeti blokkban.

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

class Sample
{
    public static void Main()
    {
        // Environment variable names for default, process, user, and machine targets.
        string defaultEnvVar = nameof(defaultEnvVar);
        string processEnvVar = nameof(processEnvVar);
        string userEnvVar = nameof(userEnvVar);
        string machineEnvVar = nameof(machineEnvVar);

        string dft = nameof(dft);
        string process = nameof(process);
        string user = nameof(user);
        string machine = nameof(machine);

        // Set the environment variable for each target.
        Console.WriteLine("Setting environment variables for each target...\n");
        // The default target (the current process).
        Environment.SetEnvironmentVariable(defaultEnvVar, dft);
        // The current process.
        Environment.SetEnvironmentVariable(processEnvVar, process,
                                           EnvironmentVariableTarget.Process);
        // The current user.
        Environment.SetEnvironmentVariable(userEnvVar, user,
                                           EnvironmentVariableTarget.User);
        // The local machine.
        Environment.SetEnvironmentVariable(machineEnvVar, machine,
                                           EnvironmentVariableTarget.Machine);

        // Define an array of environment variables.
        string[] envVars = { defaultEnvVar,processEnvVar, userEnvVar, machineEnvVar };

        // Try to get the environment variables from each target.
        // The default (no specified target).
        Console.WriteLine("Retrieving environment variables from the default target:");
        foreach (var envVar in envVars)
        {
          var value = Environment.GetEnvironmentVariable(envVar) ?? "(none)";
          Console.WriteLine($"   {envVar}: {value}");
        }
        // The process block.
        Console.WriteLine("\nRetrieving environment variables from the Process target:");
        foreach (var envVar in envVars)
        {
          var value = Environment.GetEnvironmentVariable(envVar, EnvironmentVariableTarget.Process) ?? "(none)";
          Console.WriteLine($"   {envVar}: {value}");
        }
        // The user block.
        Console.WriteLine("\nRetrieving environment variables from the User target:");
        foreach (var envVar in envVars)
        {
          var value = Environment.GetEnvironmentVariable(envVar, EnvironmentVariableTarget.User) ?? "(none)";
          Console.WriteLine($"   {envVar}: {value}");
        }
        // The machine block.
        Console.WriteLine("\nRetrieving environment variables from the Machine target:");
        foreach (var envVar in envVars)
        {
          var value = Environment.GetEnvironmentVariable(envVar, EnvironmentVariableTarget.Machine) ?? "(none)";
          Console.WriteLine($"   {envVar}: {value}");
        }

        // Delete the environment variable for each target.
        Console.WriteLine("\nDeleting environment variables for each target...\n");
        // The default target (the current process).
        Environment.SetEnvironmentVariable(defaultEnvVar, null);
        // The current process.
        Environment.SetEnvironmentVariable(processEnvVar, null,
                                           EnvironmentVariableTarget.Process);
        // The current user.
        Environment.SetEnvironmentVariable(userEnvVar, null,
                                           EnvironmentVariableTarget.User);
        // The local machine.
        Environment.SetEnvironmentVariable(machineEnvVar, null,
                                           EnvironmentVariableTarget.Machine);
    }
}
// The example displays the following output if run on a Windows system:
//      Setting environment variables for each target...
//
//      Retrieving environment variables from the default target:
//        defaultEnvVar: dft
//        processEnvVar: process
//        userEnvVar: user
//        machineEnvVar: (none)
//
//      Retrieving environment variables from the Process target:
//        defaultEnvVar: dft
//        processEnvVar: process
//        userEnvVar: user
//        machineEnvVar: (none)
//
//      Retrieving environment variables from the User target:
//        defaultEnvVar: (none)
//        processEnvVar: (none)
//        userEnvVar: user
//        machineEnvVar: (none)
//
//      Retrieving environment variables from the Machine target:
//        defaultEnvVar: (none)
//        processEnvVar: (none)
//        userEnvVar: (none)
//        machineEnvVar: machine
//
//      Deleting environment variables for each target...
//
// The example displays the following output if run on a Unix-based system:
//
//      Setting environment variables for each target...
//
//      Retrieving environment variables from the default target:
//        defaultEnvVar: dft
//        processEnvVar: process
//        userEnvVar: (none)
//        machineEnvVar: (none)
//
//      Retrieving environment variables from the Process target:
//        defaultEnvVar: dft
//        processEnvVar: process
//        userEnvVar: (none)
//        machineEnvVar: (none)
//
//      Retrieving environment variables from the User target:
//        defaultEnvVar: (none)
//        processEnvVar: (none)
//        userEnvVar: (none)
//        machineEnvVar: (none)
//
//      Retrieving environment variables from the Machine target:
//        defaultEnvVar: (none)
//        processEnvVar: (none)
//        userEnvVar: (none)
//        machineEnvVar: (none)
//
//      Deleting environment variables for each target...

module Sample

open System

// Environment variable names for default, process, user, and machine targets.
let rec defaultEnvVar = nameof defaultEnvVar
let rec processEnvVar = nameof processEnvVar
let rec userEnvVar = nameof userEnvVar
let rec machineEnvVar = nameof machineEnvVar

let rec dft = nameof dft
let rec proc = nameof proc
let rec user = nameof user
let rec machine = nameof machine

// Set the environment variable for each target.
printfn "Setting environment variables for each target...\n"
// The default target (the current process).
Environment.SetEnvironmentVariable(defaultEnvVar, dft)
// The current process.
Environment.SetEnvironmentVariable(processEnvVar, proc, EnvironmentVariableTarget.Process)
// The current user.
Environment.SetEnvironmentVariable(userEnvVar, user, EnvironmentVariableTarget.User)
// The local machine.
Environment.SetEnvironmentVariable(machineEnvVar, machine, EnvironmentVariableTarget.Machine)

// Define a list of environment variables.
let envVars = [ defaultEnvVar; processEnvVar; userEnvVar; machineEnvVar ]

// Try to get the environment variables from each target.
// The default (no specified target).
printfn "Retrieving environment variables from the default target:"
for envVar in envVars do
    let value = 
        match Environment.GetEnvironmentVariable envVar with
        | null -> "(none)"
        | v -> v
    printfn $"   {envVar}: {value}"

// The process block.
printfn "\nRetrieving environment variables from the Process target:"
for envVar in envVars do
    let value = 
        match Environment.GetEnvironmentVariable(envVar, EnvironmentVariableTarget.Process) with
        | null -> "(none)"
        | v -> v
    printfn $"   {envVar}: {value}"

// The user block.
printfn "\nRetrieving environment variables from the User target:"
for envVar in envVars do
    let value = 
        match Environment.GetEnvironmentVariable(envVar, EnvironmentVariableTarget.User) with
        | null -> "(none)"
        | v -> v
    printfn $"   {envVar}: {value}"

// The machine block.
printfn "\nRetrieving environment variables from the Machine target:"
for envVar in envVars do
    let value = 
        match Environment.GetEnvironmentVariable(envVar, EnvironmentVariableTarget.Machine) with
        | null -> "(none)"
        | v -> v
    printfn $"   {envVar}: {value}"

// Delete the environment variable for each target.
printfn "\nDeleting environment variables for each target...\n"
// The default target (the current process).
Environment.SetEnvironmentVariable(defaultEnvVar, null)
// The current process.
Environment.SetEnvironmentVariable(processEnvVar, null, EnvironmentVariableTarget.Process)
// The current user.
Environment.SetEnvironmentVariable(userEnvVar, null, EnvironmentVariableTarget.User)
// The local machine.
Environment.SetEnvironmentVariable(machineEnvVar, null, EnvironmentVariableTarget.Machine)

// The example displays the following output if run on a Windows system:
//      Setting environment variables for each target...
//
//      Retrieving environment variables from the default target:
//        defaultEnvVar: dft
//        processEnvVar: process
//        userEnvVar: user
//        machineEnvVar: (none)
//
//      Retrieving environment variables from the Process target:
//        defaultEnvVar: dft
//        processEnvVar: process
//        userEnvVar: user
//        machineEnvVar: (none)
//
//      Retrieving environment variables from the User target:
//        defaultEnvVar: (none)
//        processEnvVar: (none)
//        userEnvVar: user
//        machineEnvVar: (none)
//
//      Retrieving environment variables from the Machine target:
//        defaultEnvVar: (none)
//        processEnvVar: (none)
//        userEnvVar: (none)
//        machineEnvVar: machine
//
//      Deleting environment variables for each target...
//
// The example displays the following output if run on a Unix-based system:
//
//      Setting environment variables for each target...
//
//      Retrieving environment variables from the default target:
//        defaultEnvVar: dft
//        processEnvVar: process
//        userEnvVar: (none)
//        machineEnvVar: (none)
//
//      Retrieving environment variables from the Process target:
//        defaultEnvVar: dft
//        processEnvVar: process
//        userEnvVar: (none)
//        machineEnvVar: (none)
//
//      Retrieving environment variables from the User target:
//        defaultEnvVar: (none)
//        processEnvVar: (none)
//        userEnvVar: (none)
//        machineEnvVar: (none)
//
//      Retrieving environment variables from the Machine target:
//        defaultEnvVar: (none)
//        processEnvVar: (none)
//        userEnvVar: (none)
//        machineEnvVar: (none)
//
//      Deleting environment variables for each target...

Imports System.Collections
Imports Microsoft.Win32

Module Sample 
    Public Sub Main() 
        ' Environment variable names for default, process, user, and machine targets.
        Dim defaultEnvVar As String = NameOf(defaultEnvVar)
        Dim processEnvVar As String = NameOf(processEnvVar)
        Dim userEnvVar As String = NameOf(userEnvVar)
        Dim machineEnvVar As String = NameOf(machineEnvVar)

        Dim dft As String = NameOf(dft)
        Dim process As String = NameOf(process)
        Dim user As String = NameOf(user)
        Dim machine As String = NameOf(machine)

        ' Set the environment variable for each target.
        Console.WriteLine("Setting environment variables for each target...")
        ' The default target (the current process).
        Environment.SetEnvironmentVariable(defaultEnvVar, dft)
        ' The current process.
        Environment.SetEnvironmentVariable(processEnvVar, process, 
                                           EnvironmentVariableTarget.Process)
        ' The current user.
        Environment.SetEnvironmentVariable(userEnvVar, user, 
                                           EnvironmentVariableTarget.User)
        ' The local machine.
        Environment.SetEnvironmentVariable(machineEnvVar, machine, 
                                           EnvironmentVariableTarget.Machine)
        Console.WriteLine()

        ' Define an array of environment variables.
        Dim envVars As String() = { defaultEnvVar, processEnvVar, userEnvVar, machineEnvVar }
        
        ' Try to get the environment variables from each target.
        ' The default (no specified target).
        Console.WriteLine("Retrieving environment variables from the default target:")
        For Each envVar in envVars
          Dim value = Environment.GetEnvironmentVariable(envVar)
          Console.WriteLine($"   {envVar}: {If(value IsNot Nothing, value, "(none)")}")
        Next
        Console.WriteLine()
        ' The process block.
        Console.WriteLine("Retrieving environment variables from the Process target:")
        For Each envVar in envVars
          Dim value = Environment.GetEnvironmentVariable(envVar, EnvironmentVariableTarget.Process)
          Console.WriteLine($"   {envVar}: {If(value IsNot Nothing, value, "(none)")}")
        Next
        Console.WriteLine()
        ' The user block.
        Console.WriteLine("Retrieving environment variables from the User target:")
        For Each envVar in envVars
          Dim value = Environment.GetEnvironmentVariable(envVar, EnvironmentVariableTarget.User)
          Console.WriteLine($"   {envVar}: {value}")
        Next
        Console.WriteLine()
        ' The machine block.
        Console.WriteLine("Retrieving environment variables from the Machine target:")
        For Each envVar in envVars
          Dim value = Environment.GetEnvironmentVariable(envVar, EnvironmentVariableTarget.Machine)
          Console.WriteLine($"   {envVar}: {value}")
        Next
        Console.WriteLine()

        ' Delete the environment variable for each target.
        Console.WriteLine("Deleting environment variables for each target...")
        ' The default target (the current process).
        Environment.SetEnvironmentVariable(defaultEnvVar, Nothing)
        ' The current process.
        Environment.SetEnvironmentVariable(processEnvVar, Nothing, 
                                           EnvironmentVariableTarget.Process)
        ' The current user.
        Environment.SetEnvironmentVariable(userEnvVar, Nothing, 
                                           EnvironmentVariableTarget.User)
        ' The local machine.
        Environment.SetEnvironmentVariable(machineEnvVar, Nothing, 
                                           EnvironmentVariableTarget.Machine)
    End Sub
End Module
' The example displays the following output if run on a Windows system:
'      Setting environment variables for each target...
'
'      Retrieving environment variables from the default target:
'        defaultEnvVar: dft
'        processEnvVar: process
'        userEnvVar: user
'        machineEnvVar: (none)
'
'      Retrieving environment variables from the Process target:
'        defaultEnvVar: dft
'        processEnvVar: process
'        userEnvVar: user
'        machineEnvVar: (none)
'
'      Retrieving environment variables from the User target:
'        defaultEnvVar: (none)
'        processEnvVar: (none)
'        userEnvVar: user
'        machineEnvVar: (none)
'
'      Retrieving environment variables from the Machine target:
'        defaultEnvVar: (none)
'        processEnvVar: (none)
'        userEnvVar: (none)
'        machineEnvVar: machine
'
'      Deleting environment variables for each target...
'
' The example displays the following output if run on a Unix-based system:
'
'      Setting environment variables for each target...
'
'      Retrieving environment variables from the default target:
'        defaultEnvVar: dft
'        processEnvVar: process
'        userEnvVar: (none)
'        machineEnvVar: (none)
'
'      Retrieving environment variables from the Process target:
'        defaultEnvVar: dft
'        processEnvVar: process
'        userEnvVar: (none)
'        machineEnvVar: (none)
'
'      Retrieving environment variables from the User target:
'        defaultEnvVar: (none)
'        processEnvVar: (none)
'        userEnvVar: (none)
'        machineEnvVar: (none)
'
'      Retrieving environment variables from the Machine target:
'        defaultEnvVar: (none)
'        processEnvVar: (none)
'        userEnvVar: (none)
'        machineEnvVar: (none)
'
'      Deleting environment variables for each target...

Megjegyzések

A GetEnvironmentVariable metódus lekéri egy környezeti változó értékét az aktuális folyamatból.

A környezeti változók neve a Unix-szerű rendszereken megkülönbözteti a kis- és nagybetűket, Windows rendszeren azonban nincs különbség a kis- és nagybetűk között.

Megjegyzés:

A natív kódtárak által végrehajtott folyamatban lévő környezetmódosításokat a felügyelt hívók nem látják. Ezzel szemben a felügyelt hívók által végrehajtott ilyen módosításokat nem látják a natív kódtárak.

GetEnvironmentVariable(String) módszer

A GetEnvironmentVariable(String) metódus csak az aktuális folyamat környezeti blokkjából kér le egy környezeti változót. Ez egyenértékű azzal, hogy a GetEnvironmentVariable(String, EnvironmentVariableTarget) metódust target a következő értékkel EnvironmentVariableTarget.Processhívja meg: .

Ha az összes környezeti változót és azok értékeit szeretné lekérni, hívja meg a metódust GetEnvironmentVariables .

Windows rendszereken

Windows rendszereken az aktuális folyamat környezeti blokkja a következőket tartalmazza:

  • Minden környezeti változó, amelyet az azt létrehozó szülőfolyamat biztosít neki. Egy konzolablakból indított .NET-alkalmazás például örökli a konzolablak összes környezeti változóját.

    Ha nincs szülőfolyamat, a rendszer inkább gépenkénti és felhasználónkénti környezeti változókat használ. Egy új konzolablakban például minden gépenkénti és felhasználónkénti környezeti változó meg van határozva az indításkor.

  • Amikor a folyamat fut, a folyamatblokkhoz hozzáadott változók a SetEnvironmentVariable(String, String) vagy a SetEnvironmentVariable(String, String, EnvironmentVariableTarget) metódusok meghívásával történnek, ahol a target értéke a EnvironmentVariableTarget.Process. Ezek a környezeti változók mindaddig megmaradnak, amíg a .NET-alkalmazás le nem áll.

Ha a környezeti változók a folyamat elindítása után jönnek létre, ezzel a metódussal csak azokat a változókat kérdezheti le, amelyek a SetEnvironmentVariable(String, String) metódus vagy a SetEnvironmentVariable(String, String, EnvironmentVariableTarget) metódus .targetértékű meghívásával EnvironmentVariableTarget.Process lettek létrehozva.

Unix-szerű rendszereken

Unix-szerű rendszereken az aktuális folyamat környezeti blokkja a következő környezeti változókat tartalmazza:

A Unix-szerű rendszereken a .NET nem támogatja a gépenkénti vagy felhasználónkénti környezeti változókat.

GetEnvironmentVariable(String, EnvironmentVariableTarget) módszer

Ha az összes környezeti változót és azok értékeit szeretné lekérni, hívja meg a metódust GetEnvironmentVariables .

Windows rendszereken

Windows rendszeren a target paraméter azt határozza meg, hogy a környezeti változó az aktuális folyamatból vagy az aktuális felhasználó vagy helyi gép Windows operációsrendszer-beállításkulcsából van-e lekérve. A rendszer automatikusan átmásolja az összes felhasználónkénti és gépenkénti környezeti változót az aktuális folyamat környezeti blokkjába, ahogyan a .NET-folyamatot létrehozó szülőfolyamat számára elérhető egyéb környezeti változók is. A környezeti változók azonban csak akkor adhatók hozzá az aktuális folyamat környezeti blokkjához, ha a SetEnvironmentVariable(String, String) vagy a SetEnvironmentVariable(String, String, EnvironmentVariableTarget) metódust hívják meg a target értékkel EnvironmentVariableTarget.Process. Ezek a változók csak a folyamat időtartama alatt maradnak meg.

Unix-szerű rendszereken

Unix-szerű rendszereken a GetEnvironmentVariable(String, EnvironmentVariableTarget) metódus csak egy target értéket EnvironmentVariableTarget.Process támogat. Olyan hívások, ahol a target értéke EnvironmentVariableTarget.Machine vagy EnvironmentVariableTarget.User, nem támogatottak, és null értékkel térnek vissza.

Folyamatonkénti környezeti változók a következők:

Lásd még

A következőre érvényes: