Exportar (0) Imprimir
Expandir Tudo
Este artigo foi traduzido por máquina. Coloque o ponteiro do mouse sobre as frases do artigo para ver o texto original. Mais informações.
Tradução
Original

DictionaryBase Classe

Provides the abstract base class for a strongly typed collection of key/value pairs.

Namespace:  System.Collections
Assembly:  mscorlib (em mscorlib. dll)

[SerializableAttribute]
[ComVisibleAttribute(true)]
public abstract class DictionaryBase : IDictionary, 
	ICollection, IEnumerable

A instrução do C# foreach Idioma (for each na Visual Basic) requer o tipo de cada elemento na coleção.Since each element of the DictionaryBase is a key/value pair, the element type is not the type of the key or the type of the value.Em vez disso, o tipo de elemento é DictionaryEntry. Por exemplo:

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

The foreach statement is a wrapper around the enumerator, which only allows reading from, not writing to, the collection.

ObservaçãoObservação:

Because keys can be inherited and their behavior changed, their absolute uniqueness cannot be guaranteed by comparisons using the Equals method.

OBSERVAÇÕES PARA Implementers:

This classe base is provided to make it easier for Implementers to Criar a personalizado fortemente tipado coleção.Implementadores são incentivados a estender essa classe base, em vez de criar seus próprios.

Members of this classe base are Protected and are intended to be used Através a classe derivada only.

The following code example implements the DictionaryBase class and uses that implementation to create a dictionary of String keys and values that have a Length of 5 characters or less.

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

*/



Public static (Shared in Visual Basic) members of this type are thread safe. Os membros da instâncianão estãogarantias de serem thread safe.

This implementation does not provide a synchronized (thread-safe) wrapper for a DictionaryBase, but derived classes can create their own synchronized versions of the DictionaryBase using the SyncRoot property.

Enumerando através de um conjunto é intrinsically não um procedimento isenta de segmentos.Mesmo quando uma coleção é sincronizada, outros Threads poderá ainda modificar a coleção, que faz com que o enumerador para gerar uma exceção.Para garantir segurança de segmentos durante enumeração, você pode bloquear a coleção durante a enumeração inteira ou pegar as exceções resultantes de alterações feitas por outros segmentos.

Contribuições da comunidade

ADICIONAR
Mostrar:
© 2014 Microsoft