Advanced  Services

Nichtgenerische Containerklassen

Die Klasse ist seit der Version 3.0 deprecated, es empfiehlt sich die generische Klasse List<T> stattdessen zu verwenden. Hier also nur einige wenige Bemerkungen.

Initialisierung mit dem Defaultkonstruktor, Aufnehmen von Elementen, Ausgabe:

ArrayList al = new ArrayList();
al.Add("Hello");
al.Add("World");
al.Add( new StringBuilder("abc") );
al.Add( new StringBuilder("def") );
al.Add( new StringBuilder("ghi") );
Console.WriteLine(al.Capacity); // 8
Console.WriteLine(al.Count); // 5
foreach (Object ob in al)
   Console.WriteLine(ob);

Initialisierung mit dem Konstruktor der eine ICollection übernimmt, Verwendung von AddRange() und Clear().

ArrayList al2 = new ArrayList(new string[] { "eins", "zweins", "dreins", "vierns", "fünnef", "6", "7" });
al2.Add("8");
al2.Add("9");
Console.WriteLine(al2.Capacity); // 14
Console.WriteLine(al2.Count); // 9
StringBuilder[] sbArr = { new StringBuilder("abc"), new StringBuilder("def"), new StringBuilder("ghi") };
al2.AddRange(sbArr);
al2.AddRange(new int[] { 10,11,12 } );
Console.WriteLine(al2.Capacity); // 28
Console.WriteLine(al2.Count); // 15
foreach (Object ob in al2)
   Console.WriteLine(ob);

al2.Clear();
Console.WriteLine(al2.Capacity); // 28
Console.WriteLine(al2.Count); // 0

Die Klasse BitArray stellt eine Bitfolge als eine Folge von boolschen Werten dar. Es sind die üblichen booleschen Operationen durchführbar. Die ToString()-Methode ist leider nicht überschrieben. Ebenso fehlt eine Methode, die die Instanz als BitfolgeString liefert.

Das folgende Beispiel zeigt Iniotialisaierung und Ausgabe, außerdem die Properties Count und Length. Mit letzerer kann die Länger des BitArrays neui gesetzt werden.

private static void BitArrayBeispiel1()
{
   System.Collections.BitArray bitArray = new BitArray(8, true);
   Console.WriteLine(bitArray.Count); // 8
   Console.WriteLine(bitArray.Length); // 8
   Console.WriteLine(bitArray); // 8
   foreach (bool bit in bitArray)
   {
      Console.Write(bit);
   }
   Console.WriteLine();  // TrueTrueTrueTrueTrueTrueTrueTrue

   foreach (bool bit in bitArray)
   {
      Console.Write(bit ? 1 : 0);
   }
   Console.WriteLine(); // 11111111

   bitArray.Length = 16;
   // setzt eine neue Länge, falls das bestehende Array kleiner ist wird mit false aufgefüllt,
   // ist es größer wird abgeschnitten.
   foreach (bool bit in bitArray)
   {
      Console.Write(bit ? 1 : 0);
   }
   Console.WriteLine();  // 1111111100000000

   bitArray.Length = 5;  //
   foreach (bool bit in bitArray)
   {
      Console.Write(bit ? 1 : 0);
   }
   Console.WriteLine(); // 11111
}

Das nächste Beispiel initialisiert eine 16 bit Folge über ein byteArray der Länge 2 und demonstriert die Operation AND. Für die Ausgabe steht eine statische Methode zur Verfügung, die statt der boolschewn Werte eine Bitfolge ausgibt.

private static void BitArrayBeispiel2()
{
   byte[] bytes = new byte[] { 60, 120 };
   BitArray flags = new BitArray(bytes);
   PrintBitArray(flags); // 0011110000011110
   byte[] bytes2 = new byte[] { 180, 240 };
   BitArray flags2 = new BitArray(bytes2);
   PrintBitArray(flags2); // 0010110100001111

   Console.WriteLine("\n--and------------------------------------");
   // flag2 wird zu flag hinzuaddiert, das alte flag geht verloren
   // flag2 bleibt erhalten
   flags.And(flags2);
   PrintBitArray(flags); // 0010110000001110
}


static void PrintBitArray(BitArray flags)
{
   foreach (bool bit in flags)
   {
      Console.Write(bit ? 1 : 0);
   }
   Console.WriteLine();
}

Das letzte Beispiel initialisiert zwei Instanzen über ein byte- bzw. ein int-Array. Die Klasse wird zudem über eine Extension Method ergänzt, die in der statische Klasse BitArrayUtil realisiert wurde (siehe ).

private static void BitArrayBeispiel3()
{
   byte[] bytes = new byte[] { 84, 168 };  // ergibt 16 bit in einer Instanz
   BitArray flags = new BitArray(bytes);
   PrintBitArray(flags); // 0010101000010101
   int[] arr = new int[] { 100, 200 };  // ergibt 2*4*8 bits = 64 bits
   BitArray flags2 = new BitArray(arr);
   Console.WriteLine(flags2.Count);  // 64
   Console.WriteLine(flags2.Length);  // 64
   Console.WriteLine(flags2.ToBitString());  // Extensionmethod
   // 0010011000000000000000000000000000010011000000000000000000000000

   byte[] bytes2 = new byte[] { 250 };  // ergibt 8 bit in einer Instanz
   BitArray flags3 = new BitArray(bytes2); // 01011111
   Console.WriteLine(flags3.ToBitString());  // Extensionmethod
}

///////////////////// Extension class /////////////////////
static class BitArrayUtil
{
   // Extension Method // Extension method must be defined in a non-generic static class
   public static string ToBitString(this BitArray flags)
   {
      StringBuilder sb = new StringBuilder();
      foreach (bool bit in flags)
      {
         sb.Append(bit ? '1' : '0');
      }
      return sb.ToString();
   }
} // end class BitArrayUtil

Queue realisiert eine FIFO-Liste. Das folgende Beispiel demonstriert einige wichtige Methoden

static void Main(string[] args)
{
   Queue queue = new Queue();

   queue.Enqueue("eins");
   queue.Enqueue("2");
   queue.Enqueue("drei");

   foreach (var elem in queue)
      Console.WriteLine(elem);

   Console.WriteLine(queue.Peek());  // liefert das erste Element ohne es zu entfernen
   Console.WriteLine(queue.Dequeue());  // liefert das erste Element und entfernt es
   Console.WriteLine(queue.Peek());   // liefert das neue erste Element "2"

   Console.WriteLine(queue.AsString());  // da ToString() nicht den Inhalt ausgibt.
}

Die ToString()-Methode liefert lediglich den Klassennamen, deswegen gibt es eine Methode AsString() die als Extensionmethode angelegt ist.

static class QueueExtension
{
   public static string AsString(this Queue qu)
   {
      StringBuilder sb = new StringBuilder("[");
      foreach (var elem in qu)
         sb.Append(elem + ",");
      sb.Replace(',', ']', sb.Length - 1, 1);
      return sb.ToString();
   }
}

Stack realisiert eine LIFO-Liste. Das folgende Beispiel demonstriert einige wichtige Methoden

static void Main(string[] args)
{
   Stack stack = new Stack();

   // Aufnehmen
   stack.Push("erstes");
   stack.Push("zweites");
   stack.Push("drittes");

   foreach (var elem in stack)
      Console.WriteLine(elem);
   // gibt das letzte zuerst aus

   Console.WriteLine(stack.Peek());   // drittes, no remove
   Console.WriteLine(stack.Pop());    // removes the last
   Console.WriteLine(stack.Peek());   // zweites

   Console.WriteLine(stack.AsString());  // da ToString() nicht den Inhalt ausgibt.
}

Die ToString()-Methode liefert lediglich den Klassennamen, deswegen gibt es eine Methode AsString() die als Extensionmethode angelegt ist.

static class StackExtension
{
   public static string AsString(this Stack qu)
   {
      StringBuilder sb = new StringBuilder("[");
      foreach (var elem in qu)
         sb.Append(elem + ",");
      sb.Replace(',', ']', sb.Length - 1, 1);
      return sb.ToString();
   }
}

Aus der API

The objects used as keys by a Hashtable are required to override the Object.GetHashCode method (or the IHashCodeProvider interface) and the Object.Equals method (or the IComparer interface). The implementation of both methods and interfaces must handle case sensitivity the same way; otherwise, the Hashtable might behave incorrectly. For example, when creating a Hashtable, you must use the CaseInsensitiveHashCodeProvider class (or any case-insensitive IHashCodeProvider implementation) with the CaseInsensitiveComparer class (or any case-insensitive IComparer implementation).

Furthermore, these methods must produce the same results when called with the same parameters while the key exists in the Hashtable. An alternative is to use a Hashtable constructor with an IEqualityComparer parameter. If key equality were simply reference equality, the inherited implementation of Object.GetHashCode and Object.Equals would suffice.

Key objects must be immutable as long as they are used as keys in the Hashtable.

When an element is added to the Hashtable, the element is placed into a bucket based on the hash code of the key. Subsequent lookups of the key use the hash code of the key to search in only one particular bucket, thus substantially reducing the number of key comparisons required to find an element.

Quelle: http://msdn.microsoft.com/en-us/library/system.collections.hashtable%28v=vs.80%29.aspx