Exporter (0) Imprimer
Développer tout

DictionaryBase, classe

Mise à jour : novembre 2007

Fournit la classe de base abstract pour une collection fortement typée de paires clé/valeur.

Espace de noms :  System.Collections
Assembly :  mscorlib (dans mscorlib.dll)

[SerializableAttribute]
[ComVisibleAttribute(true)]
public abstract class DictionaryBase : IDictionary, 
	ICollection, IEnumerable
/** @attribute SerializableAttribute */ 
/** @attribute ComVisibleAttribute(true) */
public abstract class DictionaryBase implements IDictionary, 
	ICollection, IEnumerable
public abstract class DictionaryBase implements IDictionary, ICollection, IEnumerable

L'instruction foreach du langage C# (for each en Visual Basic) requiert le type de chaque élément de la collection. Étant donné que chaque élément de DictionaryBase est une paire clé/valeur, le type d'élément n'est pas le type de la clé, ni le type de la valeur. Le type d'élément est plutôt DictionaryEntry. Par exemple :

foreach (DictionaryEntry de in myDictionary) {...}
vb#c#

L'instruction foreach est un wrapper autour de l'énumérateur, qui permet la lecture à partir de la collection, mais non l'écriture dans celle-ci.

Remarque :

Étant donné que les clés peuvent être héritées et leur comportement modifié, leur unicité absolue ne peut pas être garantie par des comparaisons à l'aide de la méthode Equals.

Remarques à l'attention des implémenteurs :

Cette classe de base facilite aux implémenteurs la création d'une collection personnalisée fortement typée. Il est préférable d'étendre cette classe de base plutôt que d'en créer une nouvelle.

Les membres de cette classe de base sont protégés et destinés à être utilisés uniquement par l'intermédiaire d'une classe dérivée.

L'exemple de code suivant implémente la classe DictionaryBase, puis utilise cette implémentation pour créer un dictionnaire de clés et de valeurs String dont le Length ne doit pas dépasser 5 caractères.

using System;
using System.Collections;

public class ShortStringDictionary : DictionaryBase  {

   public String this[ String key ]  {
      get  {
         return( (String) Dictionary[key] );
      }
      set  {
         Dictionary[key] = value;
      }
   }

   public ICollection Keys  {
      get  {
         return( Dictionary.Keys );
      }
   }

   public ICollection Values  {
      get  {
         return( Dictionary.Values );
      }
   }

   public void Add( String key, String value )  {
      Dictionary.Add( key, value );
   }

   public bool Contains( String key )  {
      return( Dictionary.Contains( key ) );
   }

   public void Remove( String key )  {
      Dictionary.Remove( key );
   }

   protected override void OnInsert( Object key, Object value )  {
      if ( key.GetType() != typeof(System.String) )
         throw new ArgumentException( "key must be of type String.", "key" );
      else  {
         String strKey = (String) key;
         if ( strKey.Length > 5 )
            throw new ArgumentException( "key must be no more than 5 characters in length.", "key" );
      }

      if ( value.GetType() != typeof(System.String) )
         throw new ArgumentException( "value must be of type String.", "value" );
      else  {
         String strValue = (String) value;
         if ( strValue.Length > 5 )
            throw new ArgumentException( "value must be no more than 5 characters in length.", "value" );
      }
   }

   protected override void OnRemove( Object key, Object value )  {
      if ( key.GetType() != typeof(System.String) )
         throw new ArgumentException( "key must be of type String.", "key" );
      else  {
         String strKey = (String) key;
         if ( strKey.Length > 5 )
            throw new ArgumentException( "key must be no more than 5 characters in length.", "key" );
      }
   }

   protected override void OnSet( Object key, Object oldValue, Object newValue )  {
      if ( key.GetType() != typeof(System.String) )
         throw new ArgumentException( "key must be of type String.", "key" );
      else  {
         String strKey = (String) key;
         if ( strKey.Length > 5 )
            throw new ArgumentException( "key must be no more than 5 characters in length.", "key" );
      }

      if ( newValue.GetType() != typeof(System.String) )
         throw new ArgumentException( "newValue must be of type String.", "newValue" );
      else  {
         String strValue = (String) newValue;
         if ( strValue.Length > 5 )
            throw new ArgumentException( "newValue must be no more than 5 characters in length.", "newValue" );
      }
   }

   protected override void OnValidate( Object key, Object value )  {
      if ( key.GetType() != typeof(System.String) )
         throw new ArgumentException( "key must be of type String.", "key" );
      else  {
         String strKey = (String) key;
         if ( strKey.Length > 5 )
            throw new ArgumentException( "key must be no more than 5 characters in length.", "key" );
      }

      if ( value.GetType() != typeof(System.String) )
         throw new ArgumentException( "value must be of type String.", "value" );
      else  {
         String strValue = (String) value;
         if ( strValue.Length > 5 )
            throw new ArgumentException( "value must be no more than 5 characters in length.", "value" );
      }
   }

}


public class SamplesDictionaryBase  {

   public static void Main()  {

      // Creates and initializes a new DictionaryBase.
      ShortStringDictionary mySSC = new ShortStringDictionary();

      // Adds elements to the collection.
      mySSC.Add( "One", "a" );
      mySSC.Add( "Two", "ab" );
      mySSC.Add( "Three", "abc" );
      mySSC.Add( "Four", "abcd" );
      mySSC.Add( "Five", "abcde" );

      // Display the contents of the collection using foreach. This is the preferred method.
      Console.WriteLine( "Contents of the collection (using foreach):" );
      PrintKeysAndValues1( mySSC );

      // Display the contents of the collection using the enumerator.
      Console.WriteLine( "Contents of the collection (using enumerator):" );
      PrintKeysAndValues2( mySSC );

      // Display the contents of the collection using the Keys property and the Item property.
      Console.WriteLine( "Initial contents of the collection (using Keys and Item):" );
      PrintKeysAndValues3( mySSC );

      // Tries to add a value that is too long.
      try  {
         mySSC.Add( "Ten", "abcdefghij" );
      }
      catch ( ArgumentException e )  {
         Console.WriteLine( e.ToString() );
      }

      // Tries to add a key that is too long.
      try  {
         mySSC.Add( "Eleven", "ijk" );
      }
      catch ( ArgumentException e )  {
         Console.WriteLine( e.ToString() );
      }

      Console.WriteLine();

      // Searches the collection with Contains.
      Console.WriteLine( "Contains \"Three\": {0}", mySSC.Contains( "Three" ) );
      Console.WriteLine( "Contains \"Twelve\": {0}", mySSC.Contains( "Twelve" ) );
      Console.WriteLine();

      // Removes an element from the collection.
      mySSC.Remove( "Two" );

      // Displays the contents of the collection.
      Console.WriteLine( "After removing \"Two\":" );
      PrintKeysAndValues1( mySSC );

   }

   // Uses the foreach statement which hides the complexity of the enumerator.
   // NOTE: The foreach statement is the preferred way of enumerating the contents of a collection.
   public static void PrintKeysAndValues1( ShortStringDictionary myCol )  {
      foreach ( DictionaryEntry myDE in myCol )
         Console.WriteLine( "   {0,-5} : {1}", myDE.Key, myDE.Value );
      Console.WriteLine();
   }

   // Uses the enumerator. 
   // NOTE: The foreach statement is the preferred way of enumerating the contents of a collection.
   public static void PrintKeysAndValues2( ShortStringDictionary myCol )  {
      DictionaryEntry myDE;
      System.Collections.IEnumerator myEnumerator = myCol.GetEnumerator();
      while ( myEnumerator.MoveNext() )
         if ( myEnumerator.Current != null )  {
            myDE = (DictionaryEntry) myEnumerator.Current;
            Console.WriteLine( "   {0,-5} : {1}", myDE.Key, myDE.Value );
         }
      Console.WriteLine();
   }

   // Uses the Keys property and the Item property.
   public static void PrintKeysAndValues3( ShortStringDictionary myCol )  {
      ICollection myKeys = myCol.Keys;
      foreach ( String k in myKeys )
         Console.WriteLine( "   {0,-5} : {1}", k, myCol[k] );
      Console.WriteLine();
   }

}


/* 
This code produces the following output.

Contents of the collection (using foreach):
   Three : abc
   Five  : abcde
   Two   : ab
   One   : a
   Four  : abcd

Contents of the collection (using enumerator):
   Three : abc
   Five  : abcde
   Two   : ab
   One   : a
   Four  : abcd

Initial contents of the collection (using Keys and Item):
   Three : abc
   Five  : abcde
   Two   : ab
   One   : a
   Four  : abcd

System.ArgumentException: value must be no more than 5 characters in length.
Parameter name: value
   at ShortStringDictionary.OnValidate(Object key, Object value)
   at System.Collections.DictionaryBase.System.Collections.IDictionary.Add(Object key, Object value)
   at SamplesDictionaryBase.Main()
System.ArgumentException: key must be no more than 5 characters in length.
Parameter name: key
   at ShortStringDictionary.OnValidate(Object key, Object value)
   at System.Collections.DictionaryBase.System.Collections.IDictionary.Add(Object key, Object value)
   at SamplesDictionaryBase.Main()

Contains "Three": True
Contains "Twelve": False

After removing "Two":
   Three : abc
   Five  : abcde
   One   : a
   Four  : abcd

*/



import System.*;
import System.Collections.*;

public class ShortStringDictionary extends DictionaryBase
{
    /** @property 
     */
    public String get_Value(String key)
    {
        return((String)(get_Dictionary().get_Item(key)));
    } //get_Value

    /** @property 
     */
    public void set_Value(String key,String value)
    {
        get_Dictionary().set_Item(key, value);
    } //set_Value


    /** @property 
     */
    public ICollection get_Keys()
    {
        return get_Dictionary().get_Keys();
    } //get_Keys

    /** @property 
     */
    public ICollection get_Values()
    {
        return get_Dictionary().get_Values();
    } //get_Values

    public void Add(String key, String value) 
    {
        get_Dictionary().Add(key, value);
    } //Add

    public boolean Contains(String key) 
    {
        return get_Dictionary().Contains(key);
    } //Contains

    public void Remove(String key) 
    {
        get_Dictionary().Remove(key);
    } //Remove

    protected void OnInsert(Object key, Object value) 
    {
        if (!key.GetType().Equals(Type.GetType("System.String"))) {
            throw new ArgumentException("key must be of type String.", "key");
        }
        else {
            String strKey = ((String)(key));
            if (strKey.length() > 5) {
                throw new ArgumentException("key must be no more than "
                    + "5 characters in length.", "key");
            }
        }  
        if (!value.GetType().Equals(Type.GetType("System.String"))) {
            throw new ArgumentException("value must be of type String.", 
                "value");
        }
        else {
            String strValue = (String)value;
            if (strValue.length() > 5) {
                throw new ArgumentException("value must be no more than "
                    + "5 characters in length.", "value");
            }
        }
    } //OnInsert

    protected void OnRemove(Object key, Object value) 
    {
        if (!key.GetType().Equals(Type.GetType("System.String"))) {
            throw new ArgumentException("key must be of type String.", "key");
        }
        else {
            String strKey = ((String)(key));
            if (strKey.length() > 5) {
                throw new ArgumentException("key must be no more than "
                    + "5 characters in length.", "key");
            }
        }
    } //OnRemove

    protected void OnSet(Object key, Object oldValue, Object newValue) 
    {
        if (!key.GetType().Equals(Type.GetType("System.String"))) {
            throw new ArgumentException("key must be of type String.", "key");
        }
        else {
            String strKey = (String)key;
            if (strKey.length() > 5) {
                throw new ArgumentException("key must be no more than "
                    + "5 characters in length.", "key") ;
            }
        }
        if (!newValue.GetType().Equals(Type.GetType("System.String"))) {
            throw new ArgumentException("newValue must be of type String.",
                "newValue") ;
        }
        else {
            String strValue = ((String)(newValue));
            if (strValue.length() > 5) {
                throw new ArgumentException("newValue must be no more than "
                    + "5 characters in length.", "newValue") ;
            }
        }
    } //OnSet

    protected void OnValidate(Object key, Object value) 
    {
        if (!key.GetType().Equals(Type.GetType("System.String"))) {
            throw new ArgumentException("key must be of type String.", "key");
        }
        else {
            String strKey = ((String)(key));
            if (strKey.length() > 5) {
                throw new ArgumentException("key must be no more than "
                    + "5 characters in length.", "key") ;
            }
        }   
        if (!value.GetType().Equals(Type.GetType("System.String"))) {
            throw new ArgumentException("value must be of type String.", 
                "value");
        }
        else {
            String strValue = ((String)(value));
            if (strValue.length() > 5) {
                throw new ArgumentException("value must be no more than "
                    + "5 characters in length.", "value") ;
            }
        }
    } //OnValidate
} //ShortStringDictionary

public class SamplesDictionaryBase
{
    public static void main(String[] args)
    {
        // Creates and initializes a new DictionaryBase.
        ShortStringDictionary mySSC =  new ShortStringDictionary();

        // Adds elements to the collection.
        mySSC.Add("One", "a");
        mySSC.Add("Two", "ab");
        mySSC.Add("Three", "abc");
        mySSC.Add("Four", "abcd");
        mySSC.Add("Five", "abcde");

        // Display the contents of the collection using while. This is the
        // preferred method.
        Console.WriteLine("Contents of the collection (using for):");
        PrintKeysAndValues1(mySSC);

        // Display the contents of the collection using the enumerator.
        Console.WriteLine("Contents of the collection (using enumerator):");
        PrintKeysAndValues2(mySSC);

        // Display the contents of the collection using the Keys property and
        // the Item property.
        Console.WriteLine("Initial contents of the collection (using Keys"
            + " and Item):");
        PrintKeysAndValues3(mySSC);

        // Tries to add a value that is too long.
        try {
            mySSC.Add("Ten", "abcdefghij");
        }
        catch(ArgumentException e) {
            Console.WriteLine(e.ToString());
        }

        // Tries to add a key that is too long.
        try {
            mySSC.Add("Eleven", "ijk");
        }
        catch(ArgumentException e) {
            Console.WriteLine(e.ToString());
        }
        Console.WriteLine();

        // Searches the collection with Contains.
        boolean b = mySSC.Contains("Three");
        Console.Write("Contains \"Three\": ");
        Console.WriteLine(b);
        b = mySSC.Contains("Twelve");
        Console.Write("Contains \"Twelve\": ");
        Console.WriteLine(b);
        Console.WriteLine();

        // Removes an element from the collection.
        mySSC.Remove("Two");

        // Displays the contents of the collection.
        Console.WriteLine("After removing \"Two\":");
        PrintKeysAndValues1(mySSC);
    }//main

    // Uses the for statement which hides the complexity of the enumerator.
    // NOTE: The for statement is the preferred way of enumerating the 
    // contents of a collection.
    public static void PrintKeysAndValues1(ShortStringDictionary myCol) 
    {
        String strValue;
        String strKeys[] = new String[myCol.get_Count()];
        myCol.get_Keys().CopyTo(strKeys,0);

        for (int iCtr = 0; iCtr < myCol.get_Count(); iCtr++){
            strValue = myCol.get_Value(strKeys[iCtr]);
            Console.WriteLine("   {0,-5} : {1}", strKeys[iCtr], strValue);
        }
        Console.WriteLine();
    } //PrintKeysAndValues1

    // Uses the enumerator. 
    // NOTE: The for statement is the preferred way of enumerating the 
    // contents of a collection.
    public static void PrintKeysAndValues2(ShortStringDictionary myCol) 
    {
        DictionaryEntry myDE;
        System.Collections.IEnumerator myEnumerator = myCol.GetEnumerator();
        while(myEnumerator.MoveNext()) {
            if ( myEnumerator.get_Current()  != null  ) {
                myDE =((DictionaryEntry)(myEnumerator.get_Current()));
                Console.WriteLine("   {0,-5} : {1}", myDE.get_Key(), 
                myDE.get_Value());
            }
        }
        Console.WriteLine();
    } //PrintKeysAndValues2

    // Uses the Keys property and the Value property.
    public static void PrintKeysAndValues3(ShortStringDictionary myCol) 
    {
        ICollection myKeys = myCol.get_Keys();
        IEnumerator myEnumerator = myKeys.GetEnumerator();
        while (myEnumerator.MoveNext()) {
            String k = myEnumerator.get_Current().ToString();
            Console.WriteLine("   {0,-5} : {1}", k, myCol.get_Item(k));
        }
        Console.WriteLine();
    } //PrintKeysAndValues3
} //SamplesDictionaryBase

/* 
This code produces the following output.

Contents of the collection (using while):
   Three : abc
   Five  : abcde
   Two   : ab
   One   : a
   Four  : abcd

Contents of the collection (using enumerator):
   Three : abc
   Five  : abcde
   Two   : ab
   One   : a
   Four  : abcd

Initial contents of the collection (using Keys and Item):
   Three : abc
   Five  : abcde
   Two   : ab
   One   : a
   Four  : abcd

System.ArgumentException: value must be no more than 5 characters in length.
Parameter name: value
   at ShortStringDictionary.OnValidate(Object key, Object value)
   at System.Collections.DictionaryBase.System.Collections.IDictionary.Add(
Object key, Object value)
   at SamplesDictionaryBase.Main()
System.ArgumentException: key must be no more than 5 characters in length.
Parameter name: key
   at ShortStringDictionary.OnValidate(Object key, Object value)
   at System.Collections.DictionaryBase.System.Collections.IDictionary.Add(
Object key, Object value)
   at SamplesDictionaryBase.Main()

Contains "Three": True
Contains "Twelve": False

After removing "Two":
   Three : abc
   Five  : abcde
   One   : a
   Four  : abcd

*/



Les membres statiques publics (Shared en Visual Basic) de ce type sont thread-safe. Il n'est pas garanti que les membres d'instance soient thread-safe.

Cette implémentation ne fournit pas un wrapper synchronisé (thread-safe) pour DictionaryBase, mais des classes dérivées peuvent créer leurs propres versions synchronisées de DictionaryBase à l'aide de la propriété SyncRoot.

L'énumération d'une collection n'est intrinsèquement pas une procédure thread-safe. Même lorsqu'une collection est synchronisée, les autres threads peuvent toujours modifier la collection, ce qui entraîne la levée d'une exception par l'énumérateur. Pour garantir la sécurité des threads au cours de l'énumération, vous pouvez soit verrouiller la collection pendant l'ensemble de l'énumération, soit intercepter les exceptions résultant des modifications apportées par les autres threads.

Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professionnel Édition x64, Windows XP Starter Edition, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98

Le .NET Framework et le .NET Compact Framework ne prennent pas en charge toutes les versions de chaque plateforme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise du .NET Framework.

.NET Framework

Pris en charge dans : 3.5, 3.0, 2.0, 1.1, 1.0

Ajouts de la communauté

AJOUTER
Microsoft réalise une enquête en ligne pour recueillir votre opinion sur le site Web de MSDN. Si vous choisissez d’y participer, cette enquête en ligne vous sera présentée lorsque vous quitterez le site Web de MSDN.

Si vous souhaitez y participer,
Afficher:
© 2014 Microsoft