NameObjectCollectionBase-Klasse
Stellt die abstract-Basisklasse für eine Auflistung zugeordneter String-Schlüssel und Object-Werte bereit, auf die entweder über den Schlüssel oder über den Index zugegriffen werden kann.
Namespace: System.Collections.Specialized
Assembly: System (in system.dll)
Syntax
'Declaration
<SerializableAttribute> _
Public MustInherit Class NameObjectCollectionBase
Implements ICollection, IEnumerable, ISerializable, IDeserializationCallback
'Usage
Dim instance As NameObjectCollectionBase
[SerializableAttribute]
public abstract class NameObjectCollectionBase : ICollection, IEnumerable, ISerializable,
IDeserializationCallback
[SerializableAttribute]
public ref class NameObjectCollectionBase abstract : ICollection, IEnumerable, ISerializable,
IDeserializationCallback
/** @attribute SerializableAttribute() */
public abstract class NameObjectCollectionBase implements ICollection, IEnumerable,
ISerializable, IDeserializationCallback
SerializableAttribute
public abstract class NameObjectCollectionBase implements ICollection, IEnumerable,
ISerializable, IDeserializationCallback
Hinweise
Diese Klasse verwendet eine Hashtabelle als zugrunde liegende Struktur.
Jedes Element ist ein Schlüssel-Wert-Paar.
Bei der Kapazität einer NameObjectCollectionBase handelt es sich um die Anzahl der Elemente, die die NameObjectCollectionBase enthalten kann. Die anfängliche Standardkapazität für eine NameObjectCollectionBase ist 0 (null). Beim Hinzufügen von Elementen zu einer NameObjectCollectionBase wird die Kapazität nach Bedarf automatisch durch Neureservierung erhöht.
Der Hashcodeanbieter verteilt Hashcodes für Schlüssel in der NameObjectCollectionBase-Instanz. Der Hashcode-Standardanbieter ist CaseInsensitiveHashCodeProvider.
Der Comparer ermittelt, ob zwei Schlüssel gleich sind. Der Standardcomparer ist CaseInsensitiveComparer.
In .NET Framework, Version 1.0, verwendet diese Klasse kulturabhängige Zeichenfolgenvergleiche. In .NET Framework, Version 1.1 und höher, verwendet diese Klasse jedoch CultureInfo.InvariantCulture bei Zeichenfolgenvergleichen. Weitere Informationen über den Einfluss der Kultur auf Vergleiche und die Sortierung finden Sie unter Vergleichen und Sortieren von Daten für eine bestimmte KulturVergleichen und Sortieren von Daten für eine bestimmte Kultur und Durchführen kulturunabhängiger Zeichenfolgenoperationen.
NULL (Nothing in Visual Basic) ist als Schlüssel oder Wert zulässig.
Warnung
Die BaseGet-Methode unterscheidet nicht zwischen einem Wert NULL (Nothing in Visual Basic), der zurückgegeben wird, weil der angegebene Schlüssel nicht gefunden wurde, und einem Wert NULL (Nothing in Visual Basic), der zurückgegeben wird, weil der dem Schlüssel zugeordnete Wert NULL (Nothing in Visual Basic) ist.
Beispiel
Das folgende Codebeispiel stellt das Implementieren und Verwenden der NameObjectCollectionBase-Klasse dar.
Imports System
Imports System.Collections
Imports System.Collections.Specialized
Public Class MyCollection
Inherits NameObjectCollectionBase
' Creates an empty collection.
Public Sub New()
End Sub 'New
' Adds elements from an IDictionary into the new collection.
Public Sub New(d As IDictionary, bReadOnly As Boolean)
Dim de As DictionaryEntry
For Each de In d
Me.BaseAdd(CType(de.Key, String), de.Value)
Next de
Me.IsReadOnly = bReadOnly
End Sub 'New
' Gets a key-and-value pair (DictionaryEntry) using an index.
Default Public ReadOnly Property Item(index As Integer) As DictionaryEntry
Get
return new DictionaryEntry( _
me.BaseGetKey(index), me.BaseGet(index) )
End Get
End Property
' Gets or sets the value associated with the specified key.
Default Public Property Item(key As String) As Object
Get
Return Me.BaseGet(key)
End Get
Set
Me.BaseSet(key, value)
End Set
End Property
' Gets a String array that contains all the keys in the collection.
Public ReadOnly Property AllKeys() As String()
Get
Return Me.BaseGetAllKeys()
End Get
End Property
' Gets an Object array that contains all the values in the collection.
Public ReadOnly Property AllValues() As Array
Get
Return Me.BaseGetAllValues()
End Get
End Property
' Gets a String array that contains all the values in the collection.
Public ReadOnly Property AllStringValues() As String()
Get
Return CType(Me.BaseGetAllValues(GetType(String)), String())
End Get
End Property
' Gets a value indicating if the collection contains keys that are not null.
Public ReadOnly Property HasKeys() As Boolean
Get
Return Me.BaseHasKeys()
End Get
End Property
' Adds an entry to the collection.
Public Sub Add(key As String, value As Object)
Me.BaseAdd(key, value)
End Sub 'Add
' Removes an entry with the specified key from the collection.
Overloads Public Sub Remove(key As String)
Me.BaseRemove(key)
End Sub 'Remove
' Removes an entry in the specified index from the collection.
Overloads Public Sub Remove(index As Integer)
Me.BaseRemoveAt(index)
End Sub 'Remove
' Clears all the elements in the collection.
Public Sub Clear()
Me.BaseClear()
End Sub 'Clear
End Class 'MyCollection
Public Class SamplesNameObjectCollectionBase
Public Shared Sub Main()
' Creates and initializes a new MyCollection that is read-only.
Dim d As New ListDictionary()
d.Add("red", "apple")
d.Add("yellow", "banana")
d.Add("green", "pear")
Dim myROCol As New MyCollection(d, True)
' Tries to add a new item.
Try
myROCol.Add("blue", "sky")
Catch e As NotSupportedException
Console.WriteLine(e.ToString())
End Try
' Displays the keys and values of the MyCollection.
Console.WriteLine("Read-Only Collection:")
PrintKeysAndValues(myROCol)
' Creates and initializes an empty MyCollection that is writable.
Dim myRWCol As New MyCollection()
' Adds new items to the collection.
myRWCol.Add("purple", "grape")
myRWCol.Add("orange", "tangerine")
myRWCol.Add("black", "berries")
Console.WriteLine("Writable Collection (after adding values):")
PrintKeysAndValues(myRWCol)
' Changes the value of one element.
myRWCol("orange") = "grapefruit"
Console.WriteLine("Writable Collection (after changing one value):")
PrintKeysAndValues(myRWCol)
' Removes one item from the collection.
myRWCol.Remove("black")
Console.WriteLine("Writable Collection (after removing one value):")
PrintKeysAndValues(myRWCol)
' Removes all elements from the collection.
myRWCol.Clear()
Console.WriteLine("Writable Collection (after clearing the collection):")
PrintKeysAndValues(myRWCol)
End Sub 'Main
' Prints the indexes, keys, and values.
Public Shared Sub PrintKeysAndValues(myCol As MyCollection)
Dim i As Integer
For i = 0 To myCol.Count - 1
Console.WriteLine("[{0}] : {1}, {2}", i, myCol(i).Key, myCol(i).Value)
Next i
End Sub 'PrintKeysAndValues
' Prints the keys and values using AllKeys.
Public Shared Sub PrintKeysAndValues2(myCol As MyCollection)
Dim s As String
For Each s In myCol.AllKeys
Console.WriteLine("{0}, {1}", s, myCol(s))
Next s
End Sub 'PrintKeysAndValues2
End Class 'SamplesNameObjectCollectionBase
'This code produces the following output.
'
'System.NotSupportedException: Collection is read-only.
' at System.Collections.Specialized.NameObjectCollectionBase.BaseAdd(String name, Object value)
' at SamplesNameObjectCollectionBase.Main()
'Read-Only Collection:
'[0] : red, apple
'[1] : yellow, banana
'[2] : green, pear
'Writable Collection (after adding values):
'[0] : purple, grape
'[1] : orange, tangerine
'[2] : black, berries
'Writable Collection (after changing one value):
'[0] : purple, grape
'[1] : orange, grapefruit
'[2] : black, berries
'Writable Collection (after removing one value):
'[0] : purple, grape
'[1] : orange, grapefruit
'Writable Collection (after clearing the collection):
using System;
using System.Collections;
using System.Collections.Specialized;
public class MyCollection : NameObjectCollectionBase
{
// Creates an empty collection.
public MyCollection() {
}
// Adds elements from an IDictionary into the new collection.
public MyCollection( IDictionary d, Boolean bReadOnly ) {
foreach ( DictionaryEntry de in d ) {
this.BaseAdd( (String) de.Key, de.Value );
}
this.IsReadOnly = bReadOnly;
}
// Gets a key-and-value pair (DictionaryEntry) using an index.
public DictionaryEntry this[ int index ] {
get {
return ( new DictionaryEntry(
this.BaseGetKey(index), this.BaseGet(index) ) );
}
}
// Gets or sets the value associated with the specified key.
public Object this[ String key ] {
get {
return( this.BaseGet( key ) );
}
set {
this.BaseSet( key, value );
}
}
// Gets a String array that contains all the keys in the collection.
public String[] AllKeys {
get {
return( this.BaseGetAllKeys() );
}
}
// Gets an Object array that contains all the values in the collection.
public Array AllValues {
get {
return( this.BaseGetAllValues() );
}
}
// Gets a String array that contains all the values in the collection.
public String[] AllStringValues {
get {
return( (String[]) this.BaseGetAllValues( typeof( string ) ));
}
}
// Gets a value indicating if the collection contains keys that are not null.
public Boolean HasKeys {
get {
return( this.BaseHasKeys() );
}
}
// Adds an entry to the collection.
public void Add( String key, Object value ) {
this.BaseAdd( key, value );
}
// Removes an entry with the specified key from the collection.
public void Remove( String key ) {
this.BaseRemove( key );
}
// Removes an entry in the specified index from the collection.
public void Remove( int index ) {
this.BaseRemoveAt( index );
}
// Clears all the elements in the collection.
public void Clear() {
this.BaseClear();
}
}
public class SamplesNameObjectCollectionBase {
public static void Main() {
// Creates and initializes a new MyCollection that is read-only.
IDictionary d = new ListDictionary();
d.Add( "red", "apple" );
d.Add( "yellow", "banana" );
d.Add( "green", "pear" );
MyCollection myROCol = new MyCollection( d, true );
// Tries to add a new item.
try {
myROCol.Add( "blue", "sky" );
}
catch ( NotSupportedException e ) {
Console.WriteLine( e.ToString() );
}
// Displays the keys and values of the MyCollection.
Console.WriteLine( "Read-Only Collection:" );
PrintKeysAndValues( myROCol );
// Creates and initializes an empty MyCollection that is writable.
MyCollection myRWCol = new MyCollection();
// Adds new items to the collection.
myRWCol.Add( "purple", "grape" );
myRWCol.Add( "orange", "tangerine" );
myRWCol.Add( "black", "berries" );
Console.WriteLine( "Writable Collection (after adding values):" );
PrintKeysAndValues( myRWCol );
// Changes the value of one element.
myRWCol["orange"] = "grapefruit";
Console.WriteLine( "Writable Collection (after changing one value):" );
PrintKeysAndValues( myRWCol );
// Removes one item from the collection.
myRWCol.Remove( "black" );
Console.WriteLine( "Writable Collection (after removing one value):" );
PrintKeysAndValues( myRWCol );
// Removes all elements from the collection.
myRWCol.Clear();
Console.WriteLine( "Writable Collection (after clearing the collection):" );
PrintKeysAndValues( myRWCol );
}
// Prints the indexes, keys, and values.
public static void PrintKeysAndValues( MyCollection myCol ) {
for ( int i = 0; i < myCol.Count; i++ ) {
Console.WriteLine( "[{0}] : {1}, {2}", i, myCol[i].Key, myCol[i].Value );
}
}
// Prints the keys and values using AllKeys.
public static void PrintKeysAndValues2( MyCollection myCol ) {
foreach ( String s in myCol.AllKeys ) {
Console.WriteLine( "{0}, {1}", s, myCol[s] );
}
}
}
/*
This code produces the following output.
System.NotSupportedException: Collection is read-only.
at System.Collections.Specialized.NameObjectCollectionBase.BaseAdd(String name, Object value)
at SamplesNameObjectCollectionBase.Main()
Read-Only Collection:
[0] : red, apple
[1] : yellow, banana
[2] : green, pear
Writable Collection (after adding values):
[0] : purple, grape
[1] : orange, tangerine
[2] : black, berries
Writable Collection (after changing one value):
[0] : purple, grape
[1] : orange, grapefruit
[2] : black, berries
Writable Collection (after removing one value):
[0] : purple, grape
[1] : orange, grapefruit
Writable Collection (after clearing the collection):
*/
#using <System.dll>
using namespace System;
using namespace System::Collections;
using namespace System::Collections::Specialized;
public ref class MyCollection : public NameObjectCollectionBase {
private:
DictionaryEntry^ _de;
// Creates an empty collection.
public:
MyCollection() {
_de = gcnew DictionaryEntry();
}
// Adds elements from an IDictionary into the new collection.
MyCollection( IDictionary^ d, Boolean bReadOnly ) {
_de = gcnew DictionaryEntry();
for each ( DictionaryEntry^ de in d ) {
this->BaseAdd( (String^) de->Key, de->Value );
}
this->IsReadOnly = bReadOnly;
}
// Gets a key-and-value pair (DictionaryEntry) using an index.
property DictionaryEntry^ default[ int ] {
DictionaryEntry^ get(int index) {
_de->Key = this->BaseGetKey(index);
_de->Value = this->BaseGet(index);
return( _de );
}
}
// Gets or sets the value associated with the specified key.
property Object^ default[ String^ ] {
Object^ get(String^ key) {
return( this->BaseGet( key ) );
}
void set( String^ key, Object^ value ) {
this->BaseSet( key, value );
}
}
// Gets a String array that contains all the keys in the collection.
property array<String^>^ AllKeys {
array<String^>^ get() {
return( (array<String^>^)this->BaseGetAllKeys() );
}
}
// Gets an Object array that contains all the values in the collection.
property Array^ AllValues {
Array^ get() {
return( this->BaseGetAllValues() );
}
}
// Gets a String array that contains all the values in the collection.
property array<String^>^ AllStringValues {
array<String^>^ get() {
return( (array<String^>^) this->BaseGetAllValues( String ::typeid ));
}
}
// Gets a value indicating if the collection contains keys that are not null.
property Boolean HasKeys {
Boolean get() {
return( this->BaseHasKeys() );
}
}
// Adds an entry to the collection.
void Add( String^ key, Object^ value ) {
this->BaseAdd( key, value );
}
// Removes an entry with the specified key from the collection.
void Remove( String^ key ) {
this->BaseRemove( key );
}
// Removes an entry in the specified index from the collection.
void Remove( int index ) {
this->BaseRemoveAt( index );
}
// Clears all the elements in the collection.
void Clear() {
this->BaseClear();
}
};
public ref class SamplesNameObjectCollectionBase {
public:
static void Main() {
// Creates and initializes a new MyCollection that is read-only.
IDictionary^ d = gcnew ListDictionary();
d->Add( "red", "apple" );
d->Add( "yellow", "banana" );
d->Add( "green", "pear" );
MyCollection^ myROCol = gcnew MyCollection( d, true );
// Tries to add a new item.
try {
myROCol->Add( "blue", "sky" );
}
catch ( NotSupportedException^ e ) {
Console::WriteLine( e->ToString() );
}
// Displays the keys and values of the MyCollection.
Console::WriteLine( "Read-Only Collection:" );
PrintKeysAndValues( myROCol );
// Creates and initializes an empty MyCollection that is writable.
MyCollection^ myRWCol = gcnew MyCollection();
// Adds new items to the collection.
myRWCol->Add( "purple", "grape" );
myRWCol->Add( "orange", "tangerine" );
myRWCol->Add( "black", "berries" );
Console::WriteLine( "Writable Collection (after adding values):" );
PrintKeysAndValues( myRWCol );
// Changes the value of one element.
myRWCol["orange"] = "grapefruit";
Console::WriteLine( "Writable Collection (after changing one value):" );
PrintKeysAndValues( myRWCol );
// Removes one item from the collection.
myRWCol->Remove( "black" );
Console::WriteLine( "Writable Collection (after removing one value):" );
PrintKeysAndValues( myRWCol );
// Removes all elements from the collection.
myRWCol->Clear();
Console::WriteLine( "Writable Collection (after clearing the collection):" );
PrintKeysAndValues( myRWCol );
}
// Prints the indexes, keys, and values.
static void PrintKeysAndValues( MyCollection^ myCol ) {
for ( int i = 0; i < myCol->Count; i++ ) {
Console::WriteLine( "[{0}] : {1}, {2}", i, myCol[i]->Key, myCol[i]->Value );
}
}
// Prints the keys and values using AllKeys.
static void PrintKeysAndValues2( MyCollection^ myCol ) {
for each ( String^ s in myCol->AllKeys ) {
Console::WriteLine( "{0}, {1}", s, myCol[s] );
}
}
};
int main()
{
SamplesNameObjectCollectionBase::Main();
}
/*
This code produces the following output.
System.NotSupportedException: Collection is read-only.
at System.Collections.Specialized.NameObjectCollectionBase.BaseAdd(String name, Object value)
at SamplesNameObjectCollectionBase.Main()
Read-Only Collection:
[0] : red, apple
[1] : yellow, banana
[2] : green, pear
Writable Collection (after adding values):
[0] : purple, grape
[1] : orange, tangerine
[2] : black, berries
Writable Collection (after changing one value):
[0] : purple, grape
[1] : orange, grapefruit
[2] : black, berries
Writable Collection (after removing one value):
[0] : purple, grape
[1] : orange, grapefruit
Writable Collection (after clearing the collection):
*/
import System.* ;
import System.Collections.* ;
import System.Collections.Specialized.* ;
public class MyCollection extends NameObjectCollectionBase
{
private DictionaryEntry _de = new DictionaryEntry();
// Creates an empty collection.
public MyCollection()
{
} //MyCollection
// Adds elements from an IDictionary into the new collection.
public MyCollection(IDictionary d, boolean bReadOnly)
{
IDictionaryEnumerator objEnum = d.GetEnumerator();
while (objEnum.MoveNext()) {
DictionaryEntry de = (DictionaryEntry)objEnum.get_Current();
this.BaseAdd(((String)(de.get_Key())), de.get_Value());
}
this.set_IsReadOnly(bReadOnly);
} //MyCollection
// Gets a key-and-value pair (DictionaryEntry) using an index.
/** @property
*/
public DictionaryEntry get_Item(int index)
{
_de.set_Key(this.BaseGetKey(index));
_de.set_Value(this.BaseGet(index));
return _de ;
} //get_Item
// Gets or sets the value associated with the specified key.
/** @property
*/
public Object get_Item(String key)
{
return this.BaseGet(key) ;
} //get_Item
/** @property
*/
public void set_Item(String key, Object value)
{
this.BaseSet(key, value);
} //set_Item
// Gets a String array that contains all the keys in the collection.
/** @property
*/
public String[] get_AllKeys()
{
return this.BaseGetAllKeys() ;
} //get_AllKeys
// Gets an Object array that contains all the values in the collection.
/** @property
*/
public Array get_AllValues()
{
return this.BaseGetAllValues() ;
} //get_AllValues
// Gets a String array that contains all the values in the collection.
/** @property
*/
public String[] get_AllStringValues()
{
return((String[])(this.BaseGetAllValues(Type.GetType("String")))) ;
} //get_AllStringValues
// Gets a value indicating if the collection contains keys that are not null
/** @property
*/
public Boolean get_HasKeys()
{
return new Boolean(this.BaseHasKeys()) ;
} //get_HasKeys
// Adds an entry to the collection.
public void Add(String key, Object value)
{
this.BaseAdd(key, value);
} //Add
// Removes an entry with the specified key from the collection.
public void Remove(String key)
{
this.BaseRemove(key);
} //Remove
// Removes an entry in the specified index from the collection.
public void Remove(int index)
{
this.BaseRemoveAt(index);
} //Remove
// Clears all the elements in the collection.
public void Clear()
{
this.BaseClear();
} //Clear
} //MyCollection
public class SamplesNameObjectCollectionBase
{
public static void main(String[] args)
{
// Creates and initializes a new MyCollection that is read-only.
IDictionary d = new ListDictionary();
d.Add("red", "apple");
d.Add("yellow", "banana");
d.Add("green", "pear");
MyCollection myROCol = new MyCollection(d, true);
// Tries to add a new item.
try {
myROCol.Add("blue", "sky");
}
catch (NotSupportedException e) {
Console.WriteLine(e.ToString());
}
// Displays the keys and values of the MyCollection.
Console.WriteLine("Read-Only Collection:");
PrintKeysAndValues(myROCol);
// Creates and initializes an empty MyCollection that is writable.
MyCollection myRWCol = new MyCollection();
// Adds new items to the collection.
myRWCol.Add("purple", "grape");
myRWCol.Add("orange", "tangerine");
myRWCol.Add("black", "berries");
Console.WriteLine("Writable Collection (after adding values):");
PrintKeysAndValues(myRWCol);
// Changes the value of one element.
myRWCol.set_Item( "orange" , "grapefruit" );
Console.WriteLine("Writable Collection (after changing one value):");
PrintKeysAndValues(myRWCol);
// Removes one item from the collection.
myRWCol.Remove("black");
Console.WriteLine("Writable Collection (after removing one value):");
PrintKeysAndValues(myRWCol);
// Removes all elements from the collection.
myRWCol.Clear();
Console.WriteLine("Writable Collection (after clearing the"
+ " collection):");
PrintKeysAndValues(myRWCol);
} //main
// Prints the indexes, keys, and values.
public static void PrintKeysAndValues(MyCollection myCol)
{
for (int i=0; i < myCol.get_Count(); i++) {
Console.WriteLine("[{0}] : {1}, {2}",System.Convert.ToString(i),
myCol.get_Item(i).get_Key(), myCol.get_Item(i).get_Value());
}
} //PrintKeysAndValues
// Prints the keys and values using AllKeys.
public static void PrintKeysAndValues2(MyCollection myCol)
{
String str = new String();
for (int iCtr = 0; iCtr < myCol.get_Count(); iCtr++) {
str = myCol.get_AllKeys()[iCtr];
Console.WriteLine("{0} , {1}", str,
(myCol.get_Item(str)).ToString());
}
} //PrintKeysAndValues2
} //SamplesNameObjectCollectionBase
/*
This code produces the following output.
System.NotSupportedException: Collection is read-only.
at System.Collections.Specialized.NameObjectCollectionBase.BaseAdd(String name, Object value)
at SamplesNameObjectCollectionBase.main(String[] args)
Read-Only Collection:
[0] : red, apple
[1] : yellow, banana
[2] : green, pear
Writable Collection (after adding values):
[0] : purple, grape
[1] : orange, tangerine
[2] : black, berries
Writable Collection (after changing one value):
[0] : purple, grape
[1] : orange, grapefruit
[2] : black, berries
Writable Collection (after removing one value):
[0] : purple, grape
[1] : orange, grapefruit
Writable Collection (after clearing the collection):
*/
Vererbungshierarchie
System.Object
System.Collections.Specialized.NameObjectCollectionBase
Abgeleitete Klassen
Threadsicherheit
Öffentliche statische (Shared in Visual Basic) Member dieses Typs sind threadsicher. Bei Instanzmembern ist die Threadsicherheit nicht gewährleistet.
Diese Implementierung stellt keinen synchronisierten (threadsicheren) Wrapper für die NameObjectCollectionBase bereit, abgeleitete Klassen können jedoch mithilfe der SyncRoot-Eigenschaft eigene synchronisierte Versionen der NameObjectCollectionBase erstellen.
Die Enumeration einer Auflistung ist systemintern keine threadsichere Prozedur. Selbst wenn eine Auflistung synchronisiert wird, besteht die Möglichkeit, dass andere Threads sie ändern. Dies führt dazu, dass der Enumerator eine Ausnahme auslöst. Sie können während der Enumeration Threadsicherheit gewährleisten, indem Sie entweder die Auflistung während der gesamten Enumeration sperren oder die Ausnahmen abfangen, die durch Änderungen ausgelöst werden, die von anderen Threads vorgenommen werden.
Plattformen
Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile für Pocket PC, Windows Mobile für Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition
.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.
Versionsinformationen
.NET Framework
Unterstützt in: 2.0, 1.1, 1.0
.NET Compact Framework
Unterstützt in: 2.0, 1.0
Siehe auch
Referenz
NameObjectCollectionBase-Member
System.Collections.Specialized-Namespace
Hashtable-Klasse
NameValueCollection
String-Klasse