(0) exportieren Drucken
Alle erweitern

CollectionBase.OnInsert-Methode

Aktualisiert: November 2007

Führt zusätzliche benutzerdefinierte Prozesse vor dem Einfügen eines neuen Elements in die CollectionBase-Instanz aus.

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

protected virtual void OnInsert(
	int index,
	Object value
)
protected void OnInsert(
	int index,
	Object value
)
protected function OnInsert(
	index : int, 
	value : Object
)

Parameter

index
Typ: System.Int32
Der nullbasierte Index, an dem value eingefügt werden soll.
value
Typ: System.Object
Der neue Wert des Elements an index.

Überschreiben Sie die Standardimplementierung dieser Methode durch eine abgeleitete Klasse, wenn vor dem Einfügen des angegebenen Elements zusätzliche Aktionen ausgeführt werden sollen.

Die On*-Methoden werden lediglich für die von der List-Eigenschaft zurückgegebene Instanz aufgerufen, jedoch nicht für die von der InnerList-Eigenschaft zurückgegebene Instanz.

Wenn der Prozess nicht ausgeführt werden kann, wird der vorherige Zustand der Auflistung wiederhergestellt.

Die Standardimplementierung dieser Methode ist ein O(1)-Vorgang.

Hinweise zur Implementierung:

Mithilfe der Methode können während der Implementierung Prozesse definiert werden, die vor dem Einfügen des Elements in die zugrunde liegende System.Collections.ArrayList ausgeführt werden müssen. Durch eine Definition dieser Methode kann der Funktionsumfang vererbter Methoden bei der Implementierung erweitert werden, ohne alle anderen Methoden überschreiben zu müssen.

OnInsert wird vor dem Standardverhalten von Insert aufgerufen, OnInsertComplete hingegen nach dem Standardverhalten von Insert.

Beispielsweise kann die Zahl der Objekttypen eingeschränkt werden, die in System.Collections.ArrayList eingefügt werden dürfen.

OnValidate wird vor dieser Methode aufgerufen.

Im folgenden Codebeispiel wird die CollectionBase-Klasse implementiert und diese Implementierung zum Erstellen einer Auflistung von Int16-Objekten verwendet.

using System;
using System.Collections;

public class Int16Collection : CollectionBase  {

   public Int16 this[ int index ]  {
      get  {
         return( (Int16) List[index] );
      }
      set  {
         List[index] = value;
      }
   }

   public int Add( Int16 value )  {
      return( List.Add( value ) );
   }

   public int IndexOf( Int16 value )  {
      return( List.IndexOf( value ) );
   }

   public void Insert( int index, Int16 value )  {
      List.Insert( index, value );
   }

   public void Remove( Int16 value )  {
      List.Remove( value );
   }

   public bool Contains( Int16 value )  {
      // If value is not of type Int16, this will return false.
      return( List.Contains( value ) );
   }

   protected override void OnInsert( int index, Object value )  {
      // Insert additional code to be run only when inserting values.
   }

   protected override void OnRemove( int index, Object value )  {
      // Insert additional code to be run only when removing values.
   }

   protected override void OnSet( int index, Object oldValue, Object newValue )  {
      // Insert additional code to be run only when setting values.
   }

   protected override void OnValidate( Object value )  {
      if ( value.GetType() != typeof(System.Int16) )
         throw new ArgumentException( "value must be of type Int16.", "value" );
   }

}


public class SamplesCollectionBase  {

   public static void Main()  {

      // Create and initialize a new CollectionBase.
      Int16Collection myI16 = new Int16Collection();

      // Add elements to the collection.
      myI16.Add( (Int16) 1 );
      myI16.Add( (Int16) 2 );
      myI16.Add( (Int16) 3 );
      myI16.Add( (Int16) 5 );
      myI16.Add( (Int16) 7 );

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

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

      // Display the contents of the collection using the Count property and the Item property.
      Console.WriteLine( "Initial contents of the collection (using Count and Item):" );
      PrintIndexAndValues( myI16 );

      // Search the collection with Contains and IndexOf.
      Console.WriteLine( "Contains 3: {0}", myI16.Contains( 3 ) );
      Console.WriteLine( "2 is at index {0}.", myI16.IndexOf( 2 ) );
      Console.WriteLine();

      // Insert an element into the collection at index 3.
      myI16.Insert( 3, (Int16) 13 );
      Console.WriteLine( "Contents of the collection after inserting at index 3:" );
      PrintIndexAndValues( myI16 );

      // Get and set an element using the index.
      myI16[4] = 123;
      Console.WriteLine( "Contents of the collection after setting the element at index 4 to 123:" );
      PrintIndexAndValues( myI16 );

      // Remove an element from the collection.
      myI16.Remove( (Int16) 2 );

      // Display the contents of the collection using the Count property and the Item property.
      Console.WriteLine( "Contents of the collection after removing the element 2:" );
      PrintIndexAndValues( myI16 );

   }

   // Uses the Count property and the Item property.
   public static void PrintIndexAndValues( Int16Collection myCol )  {
      for ( int i = 0; i < myCol.Count; i++ )
         Console.WriteLine( "   [{0}]:   {1}", i, myCol[i] );
      Console.WriteLine();
   }

   // 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 PrintValues1( Int16Collection myCol )  {
      foreach ( Int16 i16 in myCol )
         Console.WriteLine( "   {0}", i16 );
      Console.WriteLine();
   }

   // Uses the enumerator. 
   // NOTE: The foreach statement is the preferred way of enumerating the contents of a collection.
   public static void PrintValues2( Int16Collection myCol )  {
      System.Collections.IEnumerator myEnumerator = myCol.GetEnumerator();
      while ( myEnumerator.MoveNext() )
         Console.WriteLine( "   {0}", myEnumerator.Current );
      Console.WriteLine();
   }
}


/* 
This code produces the following output.

Contents of the collection (using foreach):
   1
   2
   3
   5
   7

Contents of the collection (using enumerator):
   1
   2
   3
   5
   7

Initial contents of the collection (using Count and Item):
   [0]:   1
   [1]:   2
   [2]:   3
   [3]:   5
   [4]:   7

Contains 3: True
2 is at index 1.

Contents of the collection after inserting at index 3:
   [0]:   1
   [1]:   2
   [2]:   3
   [3]:   13
   [4]:   5
   [5]:   7

Contents of the collection after setting the element at index 4 to 123:
   [0]:   1
   [1]:   2
   [2]:   3
   [3]:   13
   [4]:   123
   [5]:   7

Contents of the collection after removing the element 2:
   [0]:   1
   [1]:   3
   [2]:   13
   [3]:   123
   [4]:   7

*/



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

public class Int16Collection extends CollectionBase
{
    /** @property 
     */
    public short get_Value(int index)
    {
        short s = System.Convert.ToInt16(get_List().get_Item(index));
        return(s) ; 
    } //get_Value

    /** @property 
     */
    public void set_Value(int index,short value)
    {
        get_List().set_Item(index, (Int16)value);
    } //set_Value

    public int Add(short value) 
    {
        return get_List().Add((Int16)value);
    } //Add

    public int IndexOf(short value)
    {
        return get_List().IndexOf((Int16)value);
    } //IndexOf

    public void Insert(int index, short value) 
    {
        get_List().Insert(index, (Int16)value);
    } //Insert

    public void Remove(short value) 
    {
        get_List().Remove((Int16)value);
    } //Remove

    public boolean Contains(short value) 
    {
        // If value is not of type Int16, this will return false.
        return get_List().Contains((Int16)value);
    } //Contains

    protected   void OnInsert(int index, Object value) 
    {
        // Insert additional code to be run only when inserting values.
    } //OnInsert

       protected   void OnRemove(int index, Object value) 
    {
        // Insert additional code to be run only when removing values.
    } //OnRemove

       protected   void OnSet(int index, Object oldValue, Object newValue) 
    {
        // Insert additional code to be run only when setting values.
    } //OnSet

    protected   void OnValidate(Object value) 
    {
        if ( value.GetType() != Type.GetType("System.Int16")  ) {
            throw new ArgumentException("value must be of type Int16.", 
                "value");
        }
    } //OnValidate
} //Int16Collection

public class SamplesCollectionBase
{
    public static void main(String[] args)
    {
        // Create and initialize a new CollectionBase.
        Int16Collection myI16 =  new Int16Collection();

        // Add elements to the collection.
        myI16.Add((Int16)1);
        myI16.Add((Int16)2);
        myI16.Add((Int16)3);
        myI16.Add((Int16)5);
        myI16.Add((Int16)7);

        // Display the contents of the collection using for.
        Console.WriteLine("Contents of the collection (using for):");
        PrintValues1(myI16);

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

        // Display the contents of the collection using the Count property and 
        // the Item property.
        Console.WriteLine("Initial contents of the collection "
            + "(using Count and Item):");
        PrintIndexAndValues(myI16);

        // Search the collection with Contains and IndexOf.
        Console.WriteLine("Contains 3: {0}", 
            (System.Boolean)myI16.Contains((Int16)3));
        Console.WriteLine("2 is at index {0}.", 
            (Int16)myI16.IndexOf((Int16)2));
        Console.WriteLine();

        // Insert an element into the collection at index 3.
        myI16.Insert(3, (Int16)13);
        Console.WriteLine("Contents of the collection after inserting at"
            + " index 3:");
        PrintIndexAndValues(myI16);

        // Get and set an element using the index.
        myI16 .set_Item( 4 ,(Int16)123 );
        Console.WriteLine("Contents of the collection after setting the"
            + " element at index 4 to 123:");
        PrintIndexAndValues(myI16);

        // Remove an element from the collection.
        myI16.Remove((Int16)2);

        // Display the contents of the collection using the Count property and
        // the Item property.
        Console.WriteLine("Contents of the collection after removing the"
            + " element 2:");
        PrintIndexAndValues(myI16);
   } //main

   // Uses the Count property and the Item property.
    public static void PrintIndexAndValues(Int16Collection myCol) 
    {
        for(int i = 0; i < myCol.get_Count(); i++) {
            Console.WriteLine("   [{0}]:   {1}", (Int32)i, 
                myCol.get_Item(i));
        } 
        Console.WriteLine();
    } //PrintIndexAndValues

    // 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 PrintValues1(Int16Collection myCol) 
    {
        for (int iCtr = 0; iCtr < myCol.get_Count(); iCtr++) {
            Console.WriteLine("   {0}", myCol.get_Item(iCtr));
        }
        Console.WriteLine();
    } //PrintValues1

    // Uses the enumerator. 
    // NOTE: The for statement is the preferred way of enumerating the contents 
    // of a collection.
    public static void PrintValues2(Int16Collection myCol) 
    {
        System.Collections.IEnumerator myEnumerator = myCol.GetEnumerator();
        while(myEnumerator.MoveNext()) {
            Console.WriteLine("   {0}", myEnumerator.get_Current());
        }
        Console.WriteLine();
    } //PrintValues2
} //SamplesCollectionBase

/* 
Contents of the collection (using for):
   1
   2
   3
   5
   7

Contents of the collection (using enumerator):
   1
   2
   3
   5
   7

Initial contents of the collection (using Count and Item):
   [0]:   1
   [1]:   2
   [2]:   3
   [3]:   5
   [4]:   7

Contains 3: True
2 is at index 1.

Contents of the collection after inserting at index 3:
   [0]:   1
   [1]:   2
   [2]:   3
   [3]:   13
   [4]:   5
   [5]:   7

Contents of the collection after setting the element at index 4 to 123:
   [0]:   1
   [1]:   2
   [2]:   3
   [3]:   13
   [4]:   123
   [5]:   7

Contents of the collection after removing the element 2:
   [0]:   1
   [1]:   3
   [2]:   13
   [3]:   123
   [4]:   7

*/



Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP Starter Edition, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98, Windows CE, Windows Mobile für Smartphone, Windows Mobile für Pocket PC, Xbox 360

.NET Framework und .NET Compact Framework unterstützen nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen für .NET Framework.

.NET Framework

Unterstützt in: 3.5, 3.0, 2.0, 1.1, 1.0

.NET Compact Framework

Unterstützt in: 3.5, 2.0, 1.0

XNA Framework

Unterstützt in: 2.0, 1.0

Community-Beiträge

HINZUFÜGEN
Anzeigen:
© 2014 Microsoft