RegistryValueKind Sabit listesi

Tanım

Ad Alanı:

Microsoft.Win32

Bütünleştirilmiş Kod:

Microsoft.Win32.Registry.dll

Değerleri kayıt defterinde depolarken kullanılacak veri türlerini belirtir veya kayıt defterindeki bir değerin veri türünü tanımlar.

public enum class RegistryValueKind

public enum RegistryValueKind

type RegistryValueKind = 

Public Enum RegistryValueKind

Devralma

Object

ValueType

Enum

RegistryValueKind

Alanlar

Name	Değer	Description
None	-1	Veri türü yok.
Unknown	0	Desteklenmeyen bir kayıt defteri veri türü. Örneğin, Microsoft Windows API kayıt defteri veri türü REG_RESOURCE_LIST desteklenmez. Yöntemin bir ad/değer çifti SetValue(String, Object) depolarken uygun kayıt defteri veri türünü belirlemesi gerektiğini belirtmek için bu değeri kullanın.
String	1	Null olarak sonlandırılan bir dize. Bu değer, Windows API kayıt defteri veri türü REG_SZ eşdeğerdir.
ExpandString	2	Değer alındığında genişletilen %PATH%gibi ortam değişkenlerine açıklanmamış başvurular içeren null olarak sonlandırılan bir dize. Bu değer, Windows API kayıt defteri veri türü REG_EXPAND_SZ eşdeğerdir.
Binary	3	Herhangi bir biçimdeki ikili veriler. Bu değer, Windows API kayıt defteri veri türü REG_BINARY eşdeğerdir.
DWord	4	32 bit ikili sayı. Bu değer, Windows API kayıt defteri veri türü REG_DWORD eşdeğerdir.
MultiString	7	İki null karakterle sonlandırılan, null olarak sonlandırılan dize dizisi. Bu değer, Windows API kayıt defteri veri türü REG_MULTI_SZ eşdeğerdir.
QWord	11	64 bit ikili sayı. Bu değer, Windows API kayıt defteri veri türü REG_QWORD eşdeğerdir.

Örnekler

Aşağıdaki kod örneği bir kayıt defteri anahtarı oluşturur ve kayıt defteri veri türlerini belirtmek için kullanarak RegistryValueKind bu anahtar için çeşitli değerler ayarlar. Daha sonra örnek, değerleri almak ve görüntülemek için kayıt defteri veri türlerini denetlemek için kullanır RegistryKey.GetValueKind .

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;

class RegGetDef
{
    public static void Main()
    {
        // Create a reference to a valid key.  In order for this code to
        // work, the indicated key must have been created previously.
        // The key name is not case-sensitive.
        RegistryKey rk = Registry.LocalMachine.OpenSubKey("Software\\myTestKey", false);
        // Get the value from the specified name/value pair in the key.

        string valueName = "myTestValue";

        Console.WriteLine("Retrieving registry value ...");
        Console.WriteLine();
        object o = rk.GetValue(valueName);
        Console.WriteLine("Object Type = " + o.GetType().FullName);
        Console.WriteLine();
        switch (rk.GetValueKind(valueName))
        {
            case RegistryValueKind.String:
            case RegistryValueKind.ExpandString:
                Console.WriteLine("Value = " + o);
                break;
            case RegistryValueKind.Binary:
                foreach (byte b in (byte[])o)
                {
                    Console.Write("{0:x2} ", b);
                }
                Console.WriteLine();
                break;
            case RegistryValueKind.DWord:
                Console.WriteLine("Value = " + Convert.ToString((int)o));
                break;
            case RegistryValueKind.QWord:
                Console.WriteLine("Value = " + Convert.ToString((Int64)o));
                break;
            case RegistryValueKind.MultiString:
                foreach (string s in (string[])o)
                {
                    Console.Write("[{0:s}], ", s);
                }
                Console.WriteLine();
                break;
            default:
                Console.WriteLine("Value = (Unknown)");
                break;
        }

        // Attempt to retrieve a value that does not exist; the specified
        // default value is returned.
        string def = (string)rk.GetValue("notavalue", "The default to return");
        Console.WriteLine();
        Console.WriteLine(def);

        rk.Close();
    }
}
/*
Output:
Retrieving registry value ...

Object Type = System.String

Value = testData

The default to return
*/

Imports Microsoft.Win32

Public Class RegGetDef
    Public Shared Sub Main()
        ' Create a reference to a valid key.  In order for this code to
        ' work, the indicated key must have been created previously.
        ' The key name is not case-sensitive.
        Dim rk As RegistryKey = Registry.LocalMachine.OpenSubKey("Software\myTestKey", false)

        ' Get the value from the specified name/value pair in the key.
        Dim valueName As String = "myTestValue"

        Console.WriteLine("Retrieving registry value ...")
        Console.WriteLine()
        Dim o As Object = rk.GetValue(valueName)
        Console.WriteLine("Object Type = " + o.GetType().FullName)
        Console.WriteLine()
        Select Case rk.GetValueKind(valueName)
            Case RegistryValueKind.String
            Case RegistryValueKind.ExpandString
                Console.WriteLine("Value = " + o)
            Case RegistryValueKind.Binary
                For Each b As Byte In CType(o,Byte())
                    Console.Write("{0:x2} ", b)
                Next b
                Console.WriteLine()
            Case RegistryValueKind.DWord
                Console.WriteLine("Value = " + Convert.ToString(CType(o,Int32)))
            Case RegistryValueKind.QWord
                Console.WriteLine("Value = " + Convert.ToString(CType(o,Int64)))
            Case RegistryValueKind.MultiString
                For Each s As String In CType(o,String())
                    Console.Write("[{0:s}], ", s)
                Next s
                Console.WriteLine()
            Case Else
                Console.WriteLine("Value = (Unknown)")
        End Select

        ' Attempt to retrieve a value that does not exist; the specified
        ' default value is returned.
        Dim Def As String = rk.GetValue("notavalue", "The default to return")
        Console.WriteLine()
        Console.WriteLine(def)

        rk.Close()
    End Sub
End Class
'
' Output:
' Retrieving registry value ...
'
' Object Type = System.String
'
' Value = testData
'
'The default to return

Açıklamalar

Numaralandırma, RegistryValueKind desteklenen kayıt defteri veri türleri kümesini ve desteklenmeyen türler için kullanılan değeri (Bilinmiyor) tanımlar. .NET Framework 4'te başlayarak None değeriyle bir veri türü kullanmamanızı belirtebilirsiniz.

RegistryKey.GetValueKind Değerini almadan önce kayıt defteri anahtarı değerinin veri türünü belirlemek için yöntemini kullanın. Bir kayıt defteri anahtarı değeri ayarladığınızda SetValue , kayıt defteri veri türünü açıkça belirtmek için yöntemini kullanın.

Ayrıca bkz.

• GetValueKind(String)
• SetValue(String, Object)