RegistryValueKind Enumeration

Definition

Gibt die Datentypen an, die zum Speichern von Werten in der Registrierung verwendet werden, oder bestimmt den Datentyp eines Werts in der Registrierung.Specifies the data types to use when storing values in the registry, or identifies the data type of a value in the registry.

public enum class RegistryValueKind
[System.Runtime.InteropServices.ComVisible(true)]
public enum RegistryValueKind
type RegistryValueKind = 
Public Enum RegistryValueKind
Vererbung
RegistryValueKind
Attribute

Felder

Binary 3

Binärdaten in beliebiger Form.Binary data in any form. Dieser Wert entspricht dem Windows-API-Registrierungsdatentyp REG_BINARY.This value is equivalent to the Windows API registry data type REG_BINARY.

DWord 4

Eine 32-Bit-Binärzahl.A 32-bit binary number. Dieser Wert entspricht dem Windows-API-Registrierungsdatentyp REG_DWORD.This value is equivalent to the Windows API registry data type REG_DWORD.

ExpandString 2

Eine auf NULL endende Zeichenfolge, die nicht erweiterte Verweise auf Umgebungsvariablen (z. B. %PATH%) enthält, die bei Abruf des Werts erweitert werden.A null-terminated string that contains unexpanded references to environment variables, such as %PATH%, that are expanded when the value is retrieved. Dieser Wert entspricht dem Windows-API-Registrierungsdatentyp REG_EXPAND_SZ.This value is equivalent to the Windows API registry data type REG_EXPAND_SZ.

MultiString 7

Ein Array von auf NULL endenden Zeichenfolgen, das auf zwei NULL-Zeichen endet.An array of null-terminated strings, terminated by two null characters. Dieser Wert entspricht dem Windows-API-Registrierungsdatentyp REG_MULTI_SZ.This value is equivalent to the Windows API registry data type REG_MULTI_SZ.

None -1

Kein Datentyp.No data type.

QWord 11

Eine 64-Bit-Binärzahl.A 64-bit binary number. Dieser Wert entspricht dem Windows-API-Registrierungsdatentyp REG_QWORD.This value is equivalent to the Windows API registry data type REG_QWORD.

String 1

Eine auf NULL endende Zeichenfolge.A null-terminated string. Dieser Wert entspricht dem Windows-API-Registrierungsdatentyp REG_SZ.This value is equivalent to the Windows API registry data type REG_SZ.

Unknown 0

Ein nicht unterstützter Registrierungsdatentyp.An unsupported registry data type. Zum Beispiel wird der Microsoft Windows-API-Registrierungsdatentyp REG_RESOURCE_LIST nicht unterstützt.For example, the Microsoft Windows API registry data type REG_RESOURCE_LIST is unsupported. Geben Sie mit diesem Wert an, dass die SetValue(String, Object)-Methode den entsprechenden Registrierungsdatentyp bei der Speicherung eines Name-/Wert-Paares bestimmen soll.Use this value to specify that the SetValue(String, Object) method should determine the appropriate registry data type when storing a name/value pair.

Beispiele

Im folgenden Codebeispiel wird ein Registrierungsschlüssel erstellt, und es werden mehrere Werte für diesen RegistryValueKind Schlüssel festgelegt, wobei zum Angeben der Registrierungs Datentypen verwendet wird.The following code example creates a registry key and sets several values for that key, using RegistryValueKind to specify the registry data types. Im Beispiel wird dann RegistryKey.GetValueKind verwendet, um die Registrierungs Datentypen zu überprüfen, um die Werte abzurufen und anzuzeigen.The example then uses RegistryKey.GetValueKind to check the registry data types, in order to retrieve the values and display them.

using namespace System;
using namespace Microsoft::Win32;
int main()
{
   
   // Delete and recreate the test key.
   Registry::CurrentUser->DeleteSubKey( "RegistryValueKindExample", false );
   RegistryKey ^ rk = Registry::CurrentUser->CreateSubKey( "RegistryValueKindExample" );
   
   // Create name/value pairs.
   // This overload supports QWord (long) values. 
   rk->SetValue( "QuadWordValue", 42, RegistryValueKind::QWord );
   
   // The following SetValue calls have the same effect as using the
   // SetValue overload that does not specify RegistryValueKind.
   //
   rk->SetValue( "DWordValue", 42, RegistryValueKind::DWord );
   rk->SetValue( "MultipleStringValue", gcnew array<String^>{
      "One","Two","Three"
   }, RegistryValueKind::MultiString );
   rk->SetValue( "BinaryValue", gcnew array<Byte>{
      10,43,44,45,14,255
   }, RegistryValueKind::Binary );
   rk->SetValue( "StringValue", "The path is %PATH%", RegistryValueKind::String );
   
   // This overload supports setting expandable string values. Compare
   // the output from this value with the previous string value.
   rk->SetValue( "ExpandedStringValue", "The path is %PATH%", RegistryValueKind::ExpandString );
   
   // Display all the name/value pairs stored in the test key, with the
   // registry data type in parentheses.
   //
   array<String^>^valueNames = rk->GetValueNames();
   System::Collections::IEnumerator^ myEnum = valueNames->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      String^ s = safe_cast<String^>(myEnum->Current);
      RegistryValueKind rvk = rk->GetValueKind( s );
      switch ( rvk )
      {
         case RegistryValueKind::MultiString:
         {
            array<String^>^values = (array<String^>^)rk->GetValue( s );
            Console::Write( "\r\n {0} ({1}) =", s, rvk );
            for ( int i = 0; i < values->Length; i++ )
            {
               if (i != 0) Console::Write(",");
               Console::Write( " \"{0}\"", values[ i ] );

            }
            Console::WriteLine();
            break;
         }
         case RegistryValueKind::Binary:
         {
            array<Byte>^bytes = (array<Byte>^)rk->GetValue( s );
            Console::Write( "\r\n {0} ({1}) =", s, rvk );
            for ( int i = 0; i < bytes->Length; i++ )
            {
               
               // Display each byte as two hexadecimal digits.
               Console::Write( " {0:X2}", bytes[ i ] );

            }
            Console::WriteLine();
            break;
         }
         default:
            Console::WriteLine( "\r\n {0} ({1}) = {2}", s, rvk, rk->GetValue( s ) );
            break;
      }
   }
}
/*

This code example produces the following output:
 QuadWordValue (QWord) = 42

 DWordValue (DWord) = 42

 MultipleStringValue (MultiString) =, "One", "Two", "Three"

 BinaryValue (Binary) = 0A 2B 2C 2D 0E FF

 StringValue (String) = The path is %PATH%

 ExpandedStringValue (ExpandString) = The path is C:\Program Files\Microsoft.NET\SDK\v2.0\Bin;
 [***The remainder of this output is omitted.***]

*/
using System;
using Microsoft.Win32;

public class Example
{
    public static void Main()
    {
        // Delete and recreate the test key.
        Registry.CurrentUser.DeleteSubKey("RegistryValueKindExample", false);
        RegistryKey rk = Registry.CurrentUser.CreateSubKey("RegistryValueKindExample");

        // Create name/value pairs.

        // This overload supports QWord (long) values. 
        rk.SetValue("QuadWordValue", 42, RegistryValueKind.QWord);

        // The following SetValue calls have the same effect as using the
        // SetValue overload that does not specify RegistryValueKind.
        //
        rk.SetValue("DWordValue", 42, RegistryValueKind.DWord);
        rk.SetValue("MultipleStringValue", new string[] {"One", "Two", "Three"}, RegistryValueKind.MultiString);
        rk.SetValue("BinaryValue", new byte[] {10, 43, 44, 45, 14, 255}, RegistryValueKind.Binary);
        rk.SetValue("StringValue", "The path is %PATH%", RegistryValueKind.String);

        // This overload supports setting expandable string values. Compare
        // the output from this value with the previous string value.
        rk.SetValue("ExpandedStringValue", "The path is %PATH%", RegistryValueKind.ExpandString);


        // Display all name/value pairs stored in the test key, with each
        // registry data type in parentheses.
        //
        string[] valueNames = rk.GetValueNames();
        foreach (string s in valueNames)
        {
            RegistryValueKind rvk = rk.GetValueKind(s);
            switch (rvk)
            {
                case RegistryValueKind.MultiString :
                    string[] values = (string[]) rk.GetValue(s);
                    Console.Write("\r\n {0} ({1}) =", s, rvk);
                    for (int i = 0; i < values.Length; i++)
                    {
                        if (i != 0) Console.Write(",");
                        Console.Write(" \"{0}\"", values[i]);
                    }
                    Console.WriteLine();
                    break;
                
                case RegistryValueKind.Binary :
                    byte[] bytes = (byte[]) rk.GetValue(s);
                    Console.Write("\r\n {0} ({1}) =", s, rvk);
                    for (int i = 0; i < bytes.Length; i++)
                    {
                        // Display each byte as two hexadecimal digits.
                        Console.Write(" {0:X2}", bytes[i]);
                    }
                    Console.WriteLine();
                    break;
                
                default :
                    Console.WriteLine("\r\n {0} ({1}) = {2}", s, rvk, rk.GetValue(s));
                    break;
            }
        }
    }
}
/*

This code example produces the following output:
 QuadWordValue (QWord) = 42

 DWordValue (DWord) = 42

 MultipleStringValue (MultiString) =, "One", "Two", "Three"

 BinaryValue (Binary) = 0A 2B 2C 2D 0E FF

 StringValue (String) = The path is %PATH%

 ExpandedStringValue (ExpandString) = The path is C:\Program Files\Microsoft.NET\SDK\v2.0\Bin;
 [***The remainder of this output is omitted.***]

*/
Imports Microsoft.Win32

Public Class Example
    Public Shared Sub Main()
        ' Delete and recreate the test key.
        Registry.CurrentUser.DeleteSubKey("RegistryValueKindExample", False)
        Dim rk As RegistryKey = Registry.CurrentUser.CreateSubKey("RegistryValueKindExample")
        
        ' Create name/value pairs.
        ' This overload supports QWord (long) values. 
        rk.SetValue("QuadWordValue", 42, RegistryValueKind.QWord)
        
        ' The following SetValue calls have the same effect as using the
        ' SetValue overload that does not specify RegistryValueKind.
        '
        rk.SetValue("DWordValue", 42, RegistryValueKind.DWord)
        rk.SetValue("MultipleStringValue", New String() {"One", "Two", "Three"}, RegistryValueKind.MultiString)
        rk.SetValue("BinaryValue", New Byte() {10, 43, 44, 45, 14, 255}, RegistryValueKind.Binary)
        rk.SetValue("StringValue", "The path is %PATH%", RegistryValueKind.String) 
        
        ' This overload supports setting expandable string values. Compare
        ' the output from this value with the previous string value.
        rk.SetValue("ExpandedStringValue", "The path is %PATH%", RegistryValueKind.ExpandString)
        
        
        ' Display all name/value pairs stored in the test key, with each
        ' registry data type in parentheses.
        '
        Dim valueNames As String() = rk.GetValueNames()
        Dim s As String
        For Each s In  valueNames
            Dim rvk As RegistryValueKind = rk.GetValueKind(s)
            Select Case rvk
                Case RegistryValueKind.MultiString
                    Dim values As String() = CType(rk.GetValue(s), String())
                    Console.Write(vbCrLf & " {0} ({1}) =", s, rvk)
                    For i As Integer = 0 To values.Length - 1
                        If i <> 0 Then Console.Write(",")
                        Console.Write(" ""{0}""", values(i))
                    Next i
                    Console.WriteLine()
                
                Case RegistryValueKind.Binary
                    Dim bytes As Byte() = CType(rk.GetValue(s), Byte())
                    Console.Write(vbCrLf & " {0} ({1}) =", s, rvk)
                    For i As Integer = 0 To bytes.Length - 1
                        ' Display each byte as two hexadecimal digits.
                        Console.Write(" {0:X2}", bytes(i))
                    Next i
                    Console.WriteLine()
                
                Case Else
                    Console.WriteLine(vbCrLf & " {0} ({1}) = {2}", s, rvk, rk.GetValue(s))
            End Select
        Next s
    End Sub
End Class

'
'This code example produces the following output (some output is omitted):
'
' QuadWordValue (QWord) = 42
'
' DWordValue (DWord) = 42
'
' MultipleStringValue (MultiString) = "One", "Two", "Three"
'
' BinaryValue (Binary) = 0A 2B 2C 2D 0E FF
'
' StringValue (String) = The path is %PATH%
'
' ExpandedStringValue (ExpandString) = The path is C:\Program Files\Microsoft.NET\SDK\v2.0\Bin;
' [***The remainder of this output is omitted.***]

Hinweise

Die RegistryValueKind -Enumeration definiert den Satz unterstützter Registrierungs Datentypen und den Wert, der für nicht unterstützte Typen (unbekannt) verwendet wird.The RegistryValueKind enumeration defines the set of supported registry data types and the value that is used for unsupported types (Unknown). Beginnend mit können Sie angeben ,dasskein-DatentypmitdemWertNoneverwendetwerdensoll..NET Framework 4.NET Framework 4Starting in the .NET Framework 4.NET Framework 4, you can specify not to use a data type with the None value.

Verwenden Sie RegistryKey.GetValueKind die-Methode, um den Datentyp eines Registrierungsschlüssel Werts zu bestimmen, bevor Sie den-Wert abrufen.Use the RegistryKey.GetValueKind method to determine the data type of a registry key value before retrieving the value. Wenn Sie einen Registrierungsschlüssel Wert festlegen, verwenden Sie SetValue die-Methode, um den Registrierungs Datentyp explizit anzugeben.When you set a registry key value, use the SetValue method to specify the registry data type explicitly.

Gilt für:

Siehe auch