Queue.CopyTo, méthode (System.Collections)

Bibliothèque de classes .NET Framework

Queue.CopyTo, méthode

Copie les éléments Queue dans un Array existant à une dimension commençant au niveau de l'index de tableau spécifié.

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

Syntaxe

Visual Basic (Déclaration)

Public Overridable Sub CopyTo ( _
    array As Array, _
    index As Integer _
)

Visual Basic (Utilisation)

Dim instance As Queue
Dim array As Array
Dim index As Integer

instance.CopyTo(array, index)

public virtual void CopyTo (
    Array array,
    int index
)

C++

public:
virtual void CopyTo (
    Array^ array, 
    int index
)

public void CopyTo (
    Array array, 
    int index
)

JScript

public function CopyTo (
    array : Array, 
    index : int
)

Paramètres

array: Array unidimensionnel qui constitue la destination des éléments copiés à partir de Queue. Array doit avoir une indexation de base zéro.

index: Index de base zéro dans array au niveau duquel commencer la copie.

Exceptions

Type d'exception	Condition
ArgumentNullException	array est référence Null (Nothing en Visual Basic).
ArgumentOutOfRangeException	index est inférieur à zéro.
ArgumentException	array est multidimensionnel. - ou - index est supérieur ou égal à la longueur de array. - ou - Le nombre d'éléments dans le Queue source est supérieur à la quantité d'espace disponible entre index et la fin du array de destination.
ArrayTypeMismatchException	Le cast automatique du type du Queue source en type du array de destination est impossible.

Notes

Les éléments sont copiés dans Array dans l'ordre dans lequel l'énumérateur parcourt Queue.

Cette méthode est une opération O(n), où n est égal à Count.

Exemple

L'exemple suivant montre comment copier Queue dans un tableau unidimensionnel.

Visual Basic

Imports System
Imports System.Collections
Imports Microsoft.VisualBasic

Public Class SamplesQueue    

    Public Shared Sub Main()

        ' Creates and initializes the source Queue.
        Dim mySourceQ As New Queue()
        mySourceQ.Enqueue("three")
        mySourceQ.Enqueue("napping")
        mySourceQ.Enqueue("cats")
        mySourceQ.Enqueue("in")
        mySourceQ.Enqueue("the")
        mySourceQ.Enqueue("barn")

        ' Creates and initializes the one-dimensional target Array.
        Dim myTargetArray As Array = Array.CreateInstance(GetType(String), 15)
        myTargetArray.SetValue("The", 0)
        myTargetArray.SetValue("quick", 1)
        myTargetArray.SetValue("brown", 2)
        myTargetArray.SetValue("fox", 3)
        myTargetArray.SetValue("jumped", 4)
        myTargetArray.SetValue("over", 5)
        myTargetArray.SetValue("the", 6)
        myTargetArray.SetValue("lazy", 7)
        myTargetArray.SetValue("dog", 8)

        ' Displays the values of the target Array.
        Console.WriteLine("The target Array contains the " & _
           "following (before and after copying):")
        PrintValues(myTargetArray, " "c)

        ' Copies the entire source Queue to the target Array, starting
        ' at index 6.
        mySourceQ.CopyTo(myTargetArray, 6)

        ' Displays the values of the target Array.
        PrintValues(myTargetArray, " "c)

        ' Copies the entire source Queue to a new standard array.
        Dim myStandardArray As Object() = mySourceQ.ToArray()

        ' Displays the values of the new standard array.
        Console.WriteLine("The new standard array contains the following:")
        PrintValues(myStandardArray, " "c)

    End Sub

    Public Shared Sub PrintValues(myArr As Array, mySeparator As Char)
        Dim myObj As [Object]
        For Each myObj In  myArr
            Console.Write("{0}{1}", mySeparator, myObj)
        Next myObj
        Console.WriteLine()
    End Sub 'PrintValues

End Class 'SamplesQueue


' This code produces the following output.
' 
' The target Array contains the following (before and after copying):
'  The quick brown fox jumped over the lazy dog
'  The quick brown fox jumped over three napping cats in the barn
' The new standard array contains the following:
'  three napping cats in the barn

using System;
using System.Collections;
public class SamplesQueue  {

   public static void Main()  {

      // Creates and initializes the source Queue.
      Queue mySourceQ = new Queue();
      mySourceQ.Enqueue( "three" );
      mySourceQ.Enqueue( "napping" );
      mySourceQ.Enqueue( "cats" );
      mySourceQ.Enqueue( "in" );
      mySourceQ.Enqueue( "the" );
      mySourceQ.Enqueue( "barn" );

      // Creates and initializes the one-dimensional target Array.
      Array myTargetArray=Array.CreateInstance( typeof(String), 15 );
      myTargetArray.SetValue( "The", 0 );
      myTargetArray.SetValue( "quick", 1 );
      myTargetArray.SetValue( "brown", 2 );
      myTargetArray.SetValue( "fox", 3 );
      myTargetArray.SetValue( "jumped", 4 );
      myTargetArray.SetValue( "over", 5 );
      myTargetArray.SetValue( "the", 6 );
      myTargetArray.SetValue( "lazy", 7 );
      myTargetArray.SetValue( "dog", 8 );

      // Displays the values of the target Array.
      Console.WriteLine( "The target Array contains the following (before and after copying):" );
      PrintValues( myTargetArray, ' ' );

      // Copies the entire source Queue to the target Array, starting at index 6.
      mySourceQ.CopyTo( myTargetArray, 6 );

      // Displays the values of the target Array.
      PrintValues( myTargetArray, ' ' );

      // Copies the entire source Queue to a new standard array.
      Object[] myStandardArray = mySourceQ.ToArray();

      // Displays the values of the new standard array.
      Console.WriteLine( "The new standard array contains the following:" );
      PrintValues( myStandardArray, ' ' );
   }


   public static void PrintValues( Array myArr, char mySeparator )  {
      foreach ( Object myObj in myArr )  {
         Console.Write( "{0}{1}", mySeparator, myObj );
      }
      Console.WriteLine();
   }
}
/* 
This code produces the following output.

The target Array contains the following (before and after copying):
 The quick brown fox jumped over the lazy dog
 The quick brown fox jumped over three napping cats in the barn
The new standard array contains the following:
 three napping cats in the barn

*/

C++

using namespace System;
using namespace System::Collections;
void PrintValues( Array^ myArr, char mySeparator );
int main()
{
   // Creates and initializes the source Queue.
   Queue^ mySourceQ = gcnew Queue;
   mySourceQ->Enqueue( "three" );
   mySourceQ->Enqueue( "napping" );
   mySourceQ->Enqueue( "cats" );
   mySourceQ->Enqueue( "in" );
   mySourceQ->Enqueue( "the" );
   mySourceQ->Enqueue( "barn" );

   // Creates and initializes the one-dimensional target Array.
   Array^ myTargetArray = Array::CreateInstance( String::typeid, 15 );
   myTargetArray->SetValue( "The", 0 );
   myTargetArray->SetValue( "quick", 1 );
   myTargetArray->SetValue( "brown", 2 );
   myTargetArray->SetValue( "fox", 3 );
   myTargetArray->SetValue( "jumped", 4 );
   myTargetArray->SetValue( "over", 5 );
   myTargetArray->SetValue( "the", 6 );
   myTargetArray->SetValue( "lazy", 7 );
   myTargetArray->SetValue( "dog", 8 );

   // Displays the values of the target Array.
   Console::WriteLine( "The target Array contains the following (before and after copying):" );
   PrintValues( myTargetArray, ' ' );

   // Copies the entire source Queue to the target Array, starting at index 6.
   mySourceQ->CopyTo( myTargetArray, 6 );

   // Displays the values of the target Array.
   PrintValues( myTargetArray, ' ' );

   // Copies the entire source Queue to a new standard array.
   array<Object^>^myStandardArray = mySourceQ->ToArray();

   // Displays the values of the new standard array.
   Console::WriteLine( "The new standard array contains the following:" );
   PrintValues( myStandardArray, ' ' );
}

void PrintValues( Array^ myArr, char mySeparator )
{
   IEnumerator^ myEnum = myArr->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      Object^ myObj = safe_cast<Object^>(myEnum->Current);
      Console::Write( "{0}{1}", mySeparator, myObj );
   }

   Console::WriteLine();
}

/* 
 This code produces the following output.
 
 The target Array contains the following (before and after copying):
  The quick brown fox jumped over the lazy dog
  The quick brown fox jumped over three napping cats in the barn
 The new standard array contains the following:
  three napping cats in the barn

 */

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

public class SamplesQueue
{
    public static void main(String[] args)
    {
        // Creates and initializes the source Queue.
        Queue mySourceQ =  new Queue();
        mySourceQ.Enqueue("three");
        mySourceQ.Enqueue("napping");
        mySourceQ.Enqueue("cats");
        mySourceQ.Enqueue("in");
        mySourceQ.Enqueue("the");
        mySourceQ.Enqueue("barn");

        // Creates and initializes the one-dimensional target Array.
        Array myTargetArray = Array.CreateInstance(String.class.ToType(), 15);
        myTargetArray.SetValue("The", 0);
        myTargetArray.SetValue("quick", 1);
        myTargetArray.SetValue("brown", 2);
        myTargetArray.SetValue("fox", 3);
        myTargetArray.SetValue("jumped", 4);
        myTargetArray.SetValue("over", 5);
        myTargetArray.SetValue("the", 6);
        myTargetArray.SetValue("lazy", 7);
        myTargetArray.SetValue("dog", 8);

        // Displays the values of the target Array.
        Console.WriteLine("The target Array contains the following" 
            + " (before and after copying):");
        PrintValues(myTargetArray, ' ');

        // Copies the entire source Queue to the target Array,
        // starting at index 6.
        mySourceQ.CopyTo(myTargetArray, 6);

        // Displays the values of the target Array.
        PrintValues(myTargetArray, ' ');

        // Copies the entire source Queue to a new standard array.
        Object myStandardArray[] = mySourceQ.ToArray();

        // Displays the values of the new standard array.
        Console.WriteLine("The new standard array contains the following:");
        PrintValues(myStandardArray, ' ');
    } //main

    public static void PrintValues(Array myArr, char mySeparator)
    {
        IEnumerator e = myArr.GetEnumerator();
        while(e.MoveNext()) {
            Object myObj = e.get_Current(); 
            Console.Write("{0}{1}", System.Convert.ToString(mySeparator),
                System.Convert.ToString( myObj));
        }
        Console.WriteLine();
    } //PrintValues
} //SamplesQueue

/* 
 This code produces the following output.
 
 The target Array contains the following (before and after copying):
  The quick brown fox jumped over the lazy dog
  The quick brown fox jumped over three napping cats in the barn
 The new standard array contains the following:
  three napping cats in the barn
 */

Plates-formes

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile pour Pocket PC, Windows Mobile pour Smartphone, Windows Server 2003, Windows XP Édition Media Center, Windows XP Professionnel Édition x64, Windows XP SP2, Windows XP Starter Edition

Le .NET Framework ne prend pas en charge toutes les versions de chaque plate-forme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise.

Informations de version

.NET Framework

Prise en charge dans : 2.0, 1.1, 1.0

.NET Compact Framework

Prise en charge dans : 2.0, 1.0

Voir aussi

Référence

Queue, classe
Membres Queue
System.Collections, espace de noms