StringCollection Osztály

Definíció

Névtér:: System.Collections.Specialized

Szerelvények:: System.dll, System.Collections.Specialized.dll

Szerelvény:: System.dll

Szerelvény:: netstandard.dll

Fontos

Egyes információk olyan, kiadás előtti termékekre vonatkoznak, amelyek a kiadásig még jelentősen módosulhatnak. A Microsoft nem vállal kifejezett vagy törvényi garanciát az itt megjelenő információért.

Sztringek gyűjteményét jelöli.

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

Öröklődés: Object
StringCollection

Származtatott: System.Configuration.CommaDelimitedStringCollection

Attribútumok: SerializableAttribute

Megvalósítás: ICollection IEnumerable IList

Példák

Az alábbi példakód a számos tulajdonságát és metódusát StringCollectionmutatja be.

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:
'

Megjegyzések

StringCollection null érvényes értékként fogadja el, és lehetővé teszi az ismétlődő elemek használatát.

A sztring-összehasonlítások megkülönböztetik a kis- és nagybetűket.

A gyűjtemény elemei egész számindex használatával érhetők el. A gyűjtemény indexei nulla alapúak.

Konstruktorok

Name	Description
StringCollection()	Inicializálja a StringCollection osztály új példányát.

Tulajdonságok

Name	Description
Count	A sztringek számának lekérdezése a StringCollection.
IsReadOnly	Beolvas egy értéket, amely jelzi, hogy az StringCollection írásvédett-e.
IsSynchronized	Beolvas egy értéket, amely jelzi, hogy a StringCollection hozzáférés szinkronizálva van-e (a szál biztonságos).
Item[Int32]	Lekéri vagy beállítja az elemet a megadott indexen.
SyncRoot	Lekéri az objektumot, amely a hozzáférés szinkronizálására használható.StringCollection

Metódusok

Name	Description
Add(String)	Sztringet ad hozzá a StringCollectionvégéhez.
AddRange(String[])	Egy sztringtömb elemeinek másolása a StringCollectionsor végére.
Clear()	Eltávolítja az összes sztringet a StringCollection.
Contains(String)	Meghatározza, hogy a megadott sztring szerepel-e a StringCollection.
CopyTo(String[], Int32)	A teljes StringCollection értékeket egy egydimenziós sztringtömbbe másolja, a céltömb megadott indexétől kezdve.
Equals(Object)	Meghatározza, hogy a megadott objektum egyenlő-e az aktuális objektummal. (Öröklődés forrása Object)
GetEnumerator()	Egy olyan értéket StringEnumerator ad vissza, amely a StringCollection.
GetHashCode()	Ez az alapértelmezett kivonatoló függvény. (Öröklődés forrása Object)
GetType()	Lekéri az Type aktuális példányt. (Öröklődés forrása Object)
IndexOf(String)	Megkeresi a megadott sztringet, és az első előfordulás nulla alapú indexét adja vissza a StringCollection.
Insert(Int32, String)	Sztring beszúrása a StringCollection megadott indexbe.
MemberwiseClone()	Az aktuális Objectpéldány sekély másolatát hozza létre. (Öröklődés forrása Object)
Remove(String)	Eltávolítja egy adott sztring első előfordulását a StringCollection.
RemoveAt(Int32)	Eltávolítja a sztringet a megadott indexben.StringCollection
ToString()	Az aktuális objektumot jelképező sztringet ad vissza. (Öröklődés forrása Object)

Explicit interfész-implementációk

Name	Description
ICollection.CopyTo(Array, Int32)	A teljes StringCollection példányt egy kompatibilis egydimenziósra Arraymásolja a céltömb megadott indexétől kezdve.
IEnumerable.GetEnumerator()	Egy olyan értéket IEnumerator ad vissza, amely a StringCollection.
IList.Add(Object)	Objektumot ad hozzá a StringCollectionvégéhez.
IList.Contains(Object)	Meghatározza, hogy egy elem szerepel-e a StringCollection.
IList.IndexOf(Object)	Megkeresi a megadott Object értéket, és a teljes első StringCollectionelőfordulás nulla alapú indexét adja vissza.
IList.Insert(Int32, Object)	Elemet szúr be a StringCollection megadott indexbe.
IList.IsFixedSize	Beolvas egy értéket, amely jelzi, hogy az StringCollection objektum rögzített méretű-e.
IList.IsReadOnly	Beolvas egy értéket, amely jelzi, hogy az StringCollection objektum írásvédett-e.
IList.Item[Int32]	Lekéri vagy beállítja az elemet a megadott indexen.
IList.Remove(Object)	Eltávolítja egy adott objektum első előfordulását a StringCollection.

Bővítő metódusok

Name	Description
AsParallel(IEnumerable)	Lehetővé teszi a lekérdezés párhuzamosítását.
AsQueryable(IEnumerable)	Átalakítja az egyiket IEnumerable IQueryable.
Cast<TResult>(IEnumerable)	Egy elem elemeit IEnumerable a megadott típusra veti.
OfType<TResult>(IEnumerable)	Egy adott típus alapján szűri IEnumerable egy adott elem elemeit.

A következőre érvényes:

Szálbiztonság

A nyilvános statikus (Shared Visual Basic) ilyen típusú tagjai szálbiztosak. A példánytagok nem garantáltan szálbiztosak.

Ez az implementáció nem biztosít szinkronizált (szálbiztos) burkolót egy StringCollection, de a származtatott osztályok létrehozhatják a saját szinkronizált verzióikat a StringCollection SyncRoot tulajdonság használatával.

A gyűjteményen keresztüli számbavétel alapvetően nem szálbiztos eljárás. A gyűjtemény szinkronizálása esetén is más szálak módosíthatják a gyűjteményt, ami miatt az enumerátor kivételt okoz. Az enumerálás során a szálbiztonság garantálása érdekében zárolhatja a gyűjteményt a teljes enumerálás során, vagy elkaphatja a más szálak által végrehajtott módosításokból eredő kivételeket.

Lásd még

Culture-Insensitive sztringműveletek végrehajtása

Visszajelzés

Hasznosnak találta ezt az oldalt?