StringCollection Třída

Definice

Představuje kolekci řetězců.Represents a collection of strings.

public ref class StringCollection : System::Collections::IList
public class StringCollection : System.Collections.IList
[System.Serializable]
public class StringCollection : System.Collections.IList
type StringCollection = class
    interface ICollection
    interface IEnumerable
    interface IList
[<System.Serializable>]
type StringCollection = class
    interface IList
    interface ICollection
    interface IEnumerable
Public Class StringCollection
Implements IList
Dědičnost
StringCollection
Odvozené
Atributy
Implementuje

Příklady

Následující příklad kódu ukazuje několik vlastností a metod pro StringCollection .The following code example demonstrates several of the properties and methods of StringCollection.

#using <System.dll>

using namespace System;
using namespace System::Collections;
using namespace System::Collections::Specialized;

void PrintValues1( StringCollection^ myCol );
void PrintValues2( StringCollection^ myCol );
void PrintValues3( StringCollection^ myCol );

int main()
{
   
   // Create and initializes a new StringCollection.
   StringCollection^ myCol = gcnew StringCollection;
   
   // Add a range of elements from an array to the end of the StringCollection.
   array<String^>^myArr = {"RED","orange","yellow","RED","green","blue","RED","indigo","violet","RED"};
   myCol->AddRange( myArr );
   
   // Display the contents of the collection using for each. This is the preferred method.
   Console::WriteLine( "Displays the elements using for each:" );
   PrintValues1( myCol );

   // Display the contents of the collection using the enumerator.
   Console::WriteLine( "Displays the elements using the IEnumerator:" );
   PrintValues2( myCol );
   
   // Display the contents of the collection using the Count and Item properties.
   Console::WriteLine( "Displays the elements using the Count and Item properties:" );
   PrintValues3( myCol );
   
   // Add one element to the end of the StringCollection and insert another at index 3.
   myCol->Add( "* white" );
   myCol->Insert( 3, "* gray" );
   Console::WriteLine( "After adding \"* white\" to the end and inserting \"* gray\" at index 3:" );
   PrintValues1( myCol );
   
   // Remove one element from the StringCollection.
   myCol->Remove( "yellow" );
   Console::WriteLine( "After removing \"yellow\":" );
   PrintValues1( myCol );
   
   // Remove all occurrences of a value from the StringCollection.
   int i = myCol->IndexOf( "RED" );
   while ( i > -1 )
   {
      myCol->RemoveAt( i );
      i = myCol->IndexOf( "RED" );
   }

   
   // Verify that all occurrences of "RED" are gone.
   if ( myCol->Contains( "RED" ) )
      Console::WriteLine( "*** The collection still contains \"RED\"." );

   Console::WriteLine( "After removing all occurrences of \"RED\":" );
   PrintValues1( myCol );
   
   // Copy the collection to a new array starting at index 0.
   array<String^>^myArr2 = gcnew array<String^>(myCol->Count);
   myCol->CopyTo( myArr2, 0 );
   Console::WriteLine( "The new array contains:" );
   for ( i = 0; i < myArr2->Length; i++ )
   {
      Console::WriteLine( "   [{0}] {1}", i, myArr2[ i ] );

   }
   Console::WriteLine();
   
   // Clears the entire collection.
   myCol->Clear();
   Console::WriteLine( "After clearing the collection:" );
   PrintValues1( myCol );
}


// Uses the for each statement which hides the complexity of the enumerator.
// NOTE: The for each statement is the preferred way of enumerating the contents of a collection.
void PrintValues1( StringCollection^ myCol )  {
   for each ( Object^ obj in myCol )
      Console::WriteLine( "   {0}", obj );
   Console::WriteLine();
}

// Uses the enumerator. 
void PrintValues2( StringCollection^ myCol )
{
   StringEnumerator^ myEnumerator = myCol->GetEnumerator();
   while ( myEnumerator->MoveNext() )
      Console::WriteLine( "   {0}", myEnumerator->Current );

   Console::WriteLine();
}


// Uses the Count and Item properties.
void PrintValues3( StringCollection^ myCol )
{
   for ( int i = 0; i < myCol->Count; i++ )
      Console::WriteLine( "   {0}", myCol[ i ] );
   Console::WriteLine();
}

/*
This code produces the following output.

Displays the elements using the IEnumerator:
   RED
   orange
   yellow
   RED
   green
   blue
   RED
   indigo
   violet
   RED

Displays the elements using the Count and Item properties:
   RED
   orange
   yellow
   RED
   green
   blue
   RED
   indigo
   violet
   RED

After adding "* white" to the end and inserting "* gray" at index 3:
   RED
   orange
   yellow
   * gray
   RED
   green
   blue
   RED
   indigo
   violet
   RED
   * white

After removing "yellow":
   RED
   orange
   * gray
   RED
   green
   blue
   RED
   indigo
   violet
   RED
   * white

After removing all occurrences of "RED":
   orange
   * gray
   green
   blue
   indigo
   violet
   * white

The new array contains:
   [0] orange
   [1] * gray
   [2] green
   [3] blue
   [4] indigo
   [5] violet
   [6] * white

After clearing the collection:

*/
using System;
using System.Collections;
using System.Collections.Specialized;

public class SamplesStringCollection  {

   public static void Main()  {

      // Create and initializes a new StringCollection.
      StringCollection myCol = new StringCollection();

      // Add a range of elements from an array to the end of the StringCollection.
      String[] myArr = new String[] { "RED", "orange", "yellow", "RED", "green", "blue", "RED", "indigo", "violet", "RED" };
      myCol.AddRange( myArr );

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

      // Display the contents of the collection using the enumerator.
      Console.WriteLine( "Displays the elements using the IEnumerator:" );
      PrintValues2( myCol );

      // Display the contents of the collection using the Count and Item properties.
      Console.WriteLine( "Displays the elements using the Count and Item properties:" );
      PrintValues3( myCol );

      // Add one element to the end of the StringCollection and insert another at index 3.
      myCol.Add( "* white" );
      myCol.Insert( 3, "* gray" );

      Console.WriteLine( "After adding \"* white\" to the end and inserting \"* gray\" at index 3:" );
      PrintValues1( myCol );

      // Remove one element from the StringCollection.
      myCol.Remove( "yellow" );

      Console.WriteLine( "After removing \"yellow\":" );
      PrintValues1( myCol );

      // Remove all occurrences of a value from the StringCollection.
      int i = myCol.IndexOf( "RED" );
      while ( i > -1 )  {
         myCol.RemoveAt( i );
         i = myCol.IndexOf( "RED" );
      }

      // Verify that all occurrences of "RED" are gone.
      if ( myCol.Contains( "RED" ) )
         Console.WriteLine( "*** The collection still contains \"RED\"." );

      Console.WriteLine( "After removing all occurrences of \"RED\":" );
      PrintValues1( myCol );

      // Copy the collection to a new array starting at index 0.
      String[] myArr2 = new String[myCol.Count];
      myCol.CopyTo( myArr2, 0 );

      Console.WriteLine( "The new array contains:" );
      for ( i = 0; i < myArr2.Length; i++ )  {
         Console.WriteLine( "   [{0}] {1}", i, myArr2[i] );
      }
      Console.WriteLine();

      // Clears the entire collection.
      myCol.Clear();

      Console.WriteLine( "After clearing the collection:" );
      PrintValues1( myCol );
   }

   // 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( StringCollection myCol )  {
      foreach ( Object obj in myCol )
         Console.WriteLine( "   {0}", obj );
      Console.WriteLine();
   }

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

   // Uses the Count and Item properties.
   public static void PrintValues3( StringCollection myCol )  {
      for ( int i = 0; i < myCol.Count; i++ )
         Console.WriteLine( "   {0}", myCol[i] );
      Console.WriteLine();
   }
}

/*
This code produces the following output.

Displays the elements using foreach:
   RED
   orange
   yellow
   RED
   green
   blue
   RED
   indigo
   violet
   RED

Displays the elements using the IEnumerator:
   RED
   orange
   yellow
   RED
   green
   blue
   RED
   indigo
   violet
   RED

Displays the elements using the Count and Item properties:
   RED
   orange
   yellow
   RED
   green
   blue
   RED
   indigo
   violet
   RED

After adding "* white" to the end and inserting "* gray" at index 3:
   RED
   orange
   yellow
   * gray
   RED
   green
   blue
   RED
   indigo
   violet
   RED
   * white

After removing "yellow":
   RED
   orange
   * gray
   RED
   green
   blue
   RED
   indigo
   violet
   RED
   * white

After removing all occurrences of "RED":
   orange
   * gray
   green
   blue
   indigo
   violet
   * white

The new array contains:
   [0] orange
   [1] * gray
   [2] green
   [3] blue
   [4] indigo
   [5] violet
   [6] * white

After clearing the collection:

*/
Imports System.Collections
Imports System.Collections.Specialized

Public Class SamplesStringCollection

   Public Shared Sub Main()

      ' Create and initializes a new StringCollection.
      Dim myCol As New StringCollection()

      ' Add a range of elements from an array to the end of the StringCollection.
      Dim myArr() As String = {"RED", "orange", "yellow", "RED", "green", "blue", "RED", "indigo", "violet", "RED"}
      myCol.AddRange(myArr)

      ' Display the contents of the collection using foreach. This is the preferred method.
      Console.WriteLine("Displays the elements using foreach:")
      PrintValues1(myCol)

      ' Display the contents of the collection using the enumerator.
      Console.WriteLine("Displays the elements using the IEnumerator:")
      PrintValues2(myCol)

      ' Display the contents of the collection using the Count and Item properties.
      Console.WriteLine("Displays the elements using the Count and Item properties:")
      PrintValues3(myCol)

      ' Add one element to the end of the StringCollection and insert another at index 3.
      myCol.Add("* white")
      myCol.Insert(3, "* gray")

      Console.WriteLine("After adding ""* white"" to the end and inserting ""* gray"" at index 3:")
      PrintValues1(myCol)

      ' Remove one element from the StringCollection.
      myCol.Remove("yellow")

      Console.WriteLine("After removing ""yellow"":")
      PrintValues1(myCol)

      ' Remove all occurrences of a value from the StringCollection.
      Dim i As Integer = myCol.IndexOf("RED")
      While i > - 1
         myCol.RemoveAt(i)
         i = myCol.IndexOf("RED")
      End While

      ' Verify that all occurrences of "RED" are gone.
      If myCol.Contains("RED") Then
         Console.WriteLine("*** The collection still contains ""RED"".")
      End If 
      Console.WriteLine("After removing all occurrences of ""RED"":")
      PrintValues1(myCol)

      ' Copy the collection to a new array starting at index 0.
      Dim myArr2(myCol.Count) As String
      myCol.CopyTo(myArr2, 0)

      Console.WriteLine("The new array contains:")
      For i = 0 To myArr2.Length - 1
         Console.WriteLine("   [{0}] {1}", i, myArr2(i))
      Next i
      Console.WriteLine()

      ' Clears the entire collection.
      myCol.Clear()

      Console.WriteLine("After clearing the collection:")
      PrintValues1(myCol)
   End Sub


   ' 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 Shared Sub PrintValues1(myCol As StringCollection)
      Dim obj As [Object]
      For Each obj In  myCol
         Console.WriteLine("   {0}", obj)
      Next obj
      Console.WriteLine()
   End Sub


   ' Uses the enumerator. 
   ' NOTE: The foreach statement is the preferred way of enumerating the contents of a collection.
   Public Shared Sub PrintValues2(myCol As StringCollection)
      Dim myEnumerator As StringEnumerator = myCol.GetEnumerator()
      While myEnumerator.MoveNext()
         Console.WriteLine("   {0}", myEnumerator.Current)
      End While
      Console.WriteLine()
   End Sub


   ' Uses the Count and Item properties.
   Public Shared Sub PrintValues3(myCol As StringCollection)
      Dim i As Integer
      For i = 0 To myCol.Count - 1
         Console.WriteLine("   {0}", myCol(i))
      Next i
      Console.WriteLine()
   End Sub

End Class


'This code produces the following output.
'
'Displays the elements using foreach:
'   RED
'   orange
'   yellow
'   RED
'   green
'   blue
'   RED
'   indigo
'   violet
'   RED
'
'Displays the elements using the IEnumerator:
'   RED
'   orange
'   yellow
'   RED
'   green
'   blue
'   RED
'   indigo
'   violet
'   RED
'
'Displays the elements using the Count and Item properties:
'   RED
'   orange
'   yellow
'   RED
'   green
'   blue
'   RED
'   indigo
'   violet
'   RED
'
'After adding "* white" to the end and inserting "* gray" at index 3:
'   RED
'   orange
'   yellow
'   * gray
'   RED
'   green
'   blue
'   RED
'   indigo
'   violet
'   RED
'   * white
'
'After removing "yellow":
'   RED
'   orange
'   * gray
'   RED
'   green
'   blue
'   RED
'   indigo
'   violet
'   RED
'   * white
'
'After removing all occurrences of "RED":
'   orange
'   * gray
'   green
'   blue
'   indigo
'   violet
'   * white
'
'The new array contains:
'   [0] orange
'   [1] * gray
'   [2] green
'   [3] blue
'   [4] indigo
'   [5] violet
'   [6] * white
'
'After clearing the collection:
'

Poznámky

StringCollection přijímá null jako platnou hodnotu a povoluje duplicitní prvky.StringCollection accepts null as a valid value and allows duplicate elements.

Při porovnávání řetězců se rozlišují malá a velká písmena.String comparisons are case-sensitive.

K prvkům v této kolekci lze přistupovat pomocí celočíselného indexu.Elements in this collection can be accessed using an integer index. Indexy v této kolekci jsou založené na nule.Indexes in this collection are zero-based.

Konstruktory

StringCollection()

Inicializuje novou instanci StringCollection třídy.Initializes a new instance of the StringCollection class.

Vlastnosti

Count

Získá počet řetězců obsažených v StringCollection .Gets the number of strings contained in the StringCollection.

IsReadOnly

Získá hodnotu, která určuje, zda je StringCollection určena jen pro čtení.Gets a value indicating whether the StringCollection is read-only.

IsSynchronized

Načte hodnotu, která označuje, jestli se má synchronizovat přístup k aplikaci (bezpečné pro přístup z StringCollection více vláken).Gets a value indicating whether access to the StringCollection is synchronized (thread safe).

Item[Int32]

Získá nebo nastaví prvek u zadaného indexu.Gets or sets the element at the specified index.

SyncRoot

Získává objekt, který lze použít k synchronizaci přístupu k StringCollection .Gets an object that can be used to synchronize access to the StringCollection.

Metody

Add(String)

Přidá řetězec na konec StringCollection .Adds a string to the end of the StringCollection.

AddRange(String[])

Zkopíruje prvky pole řetězců na konec StringCollection .Copies the elements of a string array to the end of the StringCollection.

Clear()

Odebere všechny řetězce z StringCollection .Removes all the strings from the StringCollection.

Contains(String)

Určuje, zda je zadaný řetězec v StringCollection .Determines whether the specified string is in the StringCollection.

CopyTo(String[], Int32)

Zkopíruje celé StringCollection hodnoty do jednorozměrného pole řetězců, počínaje zadaným indexem cílového pole.Copies the entire StringCollection values to a one-dimensional array of strings, starting at the specified index of the target array.

Equals(Object)

Určí, zda se zadaný objekt rovná aktuálnímu objektu.Determines whether the specified object is equal to the current object.

(Zděděno od Object)
GetEnumerator()

Vrátí objekt StringEnumerator , který projde StringCollection .Returns a StringEnumerator that iterates through the StringCollection.

GetHashCode()

Slouží jako výchozí funkce hash.Serves as the default hash function.

(Zděděno od Object)
GetType()

Získá Type aktuální instanci.Gets the Type of the current instance.

(Zděděno od Object)
IndexOf(String)

Vyhledá zadaný řetězec a vrátí index založený na nule prvního výskytu v rámci StringCollection .Searches for the specified string and returns the zero-based index of the first occurrence within the StringCollection.

Insert(Int32, String)

Vloží řetězec do v StringCollection zadaném indexu.Inserts a string into the StringCollection at the specified index.

MemberwiseClone()

Vytvoří kopii aktuálního seznamu Object .Creates a shallow copy of the current Object.

(Zděděno od Object)
Remove(String)

Odebere první výskyt konkrétního řetězce z StringCollection .Removes the first occurrence of a specific string from the StringCollection.

RemoveAt(Int32)

Odebere řetězec v zadaném indexu StringCollection .Removes the string at the specified index of the StringCollection.

ToString()

Vrátí řetězec, který představuje aktuální objekt.Returns a string that represents the current object.

(Zděděno od Object)

Explicitní implementace rozhraní

ICollection.CopyTo(Array, Int32)

Zkopíruje celý StringCollection na kompatibilní jednorozměrné Array , počínaje zadaným indexem cílového pole.Copies the entire StringCollection to a compatible one-dimensional Array, starting at the specified index of the target array.

IEnumerable.GetEnumerator()

Vrátí objekt IEnumerator , který projde StringCollection .Returns a IEnumerator that iterates through the StringCollection.

IList.Add(Object)

Přidá objekt na konec StringCollection .Adds an object to the end of the StringCollection.

IList.Contains(Object)

Určuje, zda je element v StringCollection .Determines whether an element is in the StringCollection.

IList.IndexOf(Object)

Vyhledá zadanou hodnotu Object a vrátí index prvního výskytu prvního výskytu v rámci celého StringCollection .Searches for the specified Object and returns the zero-based index of the first occurrence within the entire StringCollection.

IList.Insert(Int32, Object)

Vloží element do v StringCollection zadaném indexu.Inserts an element into the StringCollection at the specified index.

IList.IsFixedSize

Načte hodnotu, která označuje, zda StringCollection má objekt pevnou velikost.Gets a value indicating whether the StringCollection object has a fixed size.

IList.IsReadOnly

Načte hodnotu, která označuje, zda StringCollection je objekt určen jen pro čtení.Gets a value indicating whether the StringCollection object is read-only.

IList.Item[Int32]

Získá nebo nastaví prvek u zadaného indexu.Gets or sets the element at the specified index.

IList.Remove(Object)

Odebere první výskyt konkrétního objektu z StringCollection .Removes the first occurrence of a specific object from the StringCollection.

Metody rozšíření

Cast<TResult>(IEnumerable)

Přetypování prvky IEnumerable na zadaný typ.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable)

Filtruje prvky IEnumerable založené na zadaném typu.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable)

Povoluje paralelní zpracování dotazu.Enables parallelization of a query.

AsQueryable(IEnumerable)

Převede IEnumerable na IQueryable .Converts an IEnumerable to an IQueryable.

Platí pro

Bezpečný přístup z více vláken

Veřejné statické ( Shared v Visual Basic) členy tohoto typu jsou bezpečné pro přístup z více vláken.Public static (Shared in Visual Basic) members of this type are thread safe. U členů instancí není zaručena bezpečnost pro přístup z více vláken.Any instance members are not guaranteed to be thread safe.

Tato implementace neposkytuje synchronizovanou obálku (bezpečný přístup z více vláken) pro StringCollection , ale odvozené třídy mohou vytvořit své vlastní synchronizované verze StringCollection pomocí SyncRoot Vlastnosti.This implementation does not provide a synchronized (thread safe) wrapper for a StringCollection, but derived classes can create their own synchronized versions of the StringCollection using the SyncRoot property.

Výčet prostřednictvím kolekce je vnitřně nebezpečným postupem pro přístup z více vláken.Enumerating through a collection is intrinsically not a thread safe procedure. I v případě, že jde o synchronizovanou kolekci, mohou úpravy provádět i ostatní vlákna, což způsobuje vyvolání výjimky enumerátorem.Even when a collection is synchronized, other threads can still modify the collection, which causes the enumerator to throw an exception. K zaručení bezpečnosti přístupu z více vláken můžete buďto zamknout kolekci na celou dobu práce s výčtem, nebo zachycovat výjimky vzniklé v důsledku změn prováděných ostatními vlákny.To guarantee thread safety during enumeration, you can either lock the collection during the entire enumeration or catch the exceptions resulting from changes made by other threads.