Dieser Artikel wurde maschinell übersetzt. Wenn Sie die englische Version des Artikels anzeigen möchten, aktivieren Sie das Kontrollkästchen Englisch. Sie können den englischen Text auch in einem Popupfenster anzeigen, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch

String.Split-Methode: (String[], StringSplitOptions)

 

Unterteilt eine Zeichenfolge anhand der Zeichenfolgen in einem Array in Teilzeichenfolgen. Sie können angeben, ob die Teilzeichenfolgen auch leere Arrayelemente umfassen.

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

[ComVisibleAttribute(false)]
public string[] Split(
	string[] separator,
	StringSplitOptions options
)

Parameter

separator
Type: System.String[]

Ein Array mit Zeichenfolgen, die die Teilzeichenfolgen in dieser Zeichenfolge trennen, ein leeres Array ohne Trennzeichen oder null.

options
Type: System.StringSplitOptions

StringSplitOptions.RemoveEmptyEntries, wenn leere Arrayelemente aus dem zurückgegebenen Array ausgelassen werden sollen, oder StringSplitOptions.None, wenn leere Arrayelemente in das zurückgegebene Array eingeschlossen werden sollen.

Rückgabewert

Type: System.String[]

Ein Array, dessen Elemente die Teilzeichenfolgen in dieser Zeichenfolge enthält, die durch ein oder mehr Zeichenfolgen aus separator getrennt sind. Weitere Informationen finden Sie im Abschnitt "Hinweise".

Exception Condition
ArgumentException

options entspricht keinem der StringSplitOptions-Werte.

Wenn eine Zeichenfolge von einem bekannten Satz von Zeichenfolgen getrennt ist, können Sie die Split Methode in Teilzeichenfolgen abzugrenzen.

Trennzeichen-Zeichenfolgen werden nicht in den Elementen im zurückgegebenen Array enthalten. Beispielsweise, wenn die separator Array enthält die Zeichenfolge "--" und der Wert der aktuellen Zeichenfolgeninstanz "aa - bb-cc", die Methode gibt ein Array, das drei Elemente enthält: "aa", "bb" und "cc".

Wenn keine der Zeichenfolgen in dieser Instanz enthält separator, das zurückgegebene Array besteht aus einem einzelnen Element, das diese Instanz enthält.

Wenn die options Parameter ist RemoveEmptyEntries und die Länge dieser Instanz ist NULL, wird die Methode ein leeres Array zurück.

Jedes Element der separator definiert ein separates Trennzeichen, die aus einem oder mehreren Zeichen besteht. Wenn die options Argument ist None, und zwei Trennzeichen angrenzen oder am Anfang oder Ende dieser Instanz ein Trennzeichen gefunden wird, enthält das entsprechende Arrayelement String.Empty. Z. B. wenn separator enthält zwei Elemente, die "-" und "_", der Wert der Zeichenfolgeninstanz "- _aa-_" und der Wert der options Argument ist None, die Methode gibt ein Sting-Array mit den folgenden fünf Elementen zurück:

  1. String.Empty, das darstellt, dass der leeren Zeichenfolge, die vor der "-" Teilzeichenfolge am Index 0.

  2. String.Empty, das darstellt, dass der leeren Zeichenfolge zwischen dem "-" Teilzeichenfolge am Index 0 und die Teilzeichenfolge "_" am Index 1.

  3. "aa",

  4. String.Empty, die die leere Zeichenfolge, die die Teilzeichenfolge "_" Index 4 folgt darstellt.

  5. String.Empty, der darstellt, dass der leeren Zeichenfolge, die folgt der "-" Teilzeichenfolge am Index 5.

Wenn keines der Elemente im separator besteht aus mehreren Zeichen, gilt die gesamte Teilzeichenfolge ein Trennzeichen. Angenommen, sofern der Elemente im separator ist "10", bei dem Versuch, teilen die Zeichenfolge "This10is10a10string." Gibt die folgenden vier Elementen Array: {"This", "is", "a", "String". }.

Wenn die separator Parameter ist null oder keine Zeichen enthält Leerzeichen wird angenommen, dass die Trennzeichen. Leerzeichen werden durch die Unicode-standard und return definiert true Wenn es sich bei der Übergabe an die Char.IsWhiteSpace Methode.

Wenn die separator Parameter im Aufruf der Überladung dieser Methode ist null, Compiler überladungsauflösung ein Fehler auftritt. Um die aufgerufene Methode eindeutig identifizieren zu können, muss Ihr Code geben den Typ der der null. Das folgende Beispiel zeigt mehrere Möglichkeiten, diese Überladung eindeutig zu identifizieren.

string phrase = "The quick  brown fox";
string[] words;

words = phrase.Split(default(string[]), StringSplitOptions.RemoveEmptyEntries);

words = phrase.Split((string[]) null, StringSplitOptions.RemoveEmptyEntries);

words = phrase.Split(null as string[], StringSplitOptions.RemoveEmptyEntries);

Die Split Methode extrahiert die Teilzeichenfolgen in dieser Zeichenfolge, die durch mindestens eine der Zeichenfolgen in begrenzt werden die separator Parameter, und gibt diese Teilzeichenfolgen als Elemente eines Arrays zurück.

Die Split Methode sucht nach Trennzeichen, durch das Durchführen von Vergleichen mit Ordinalsortierung Groß-/Kleinschreibung beachtet. Weitere Informationen zu Word, Zeichenfolgen- und ordinal sortiert, finden Sie unter der System.Globalization.CompareOptions Enumeration.

Die Split Methode ignoriert alle Elemente von separator , dessen Wert null oder eine leere Zeichenfolge ("").

Um mehrdeutige Ergebnisse zu vermeiden bei Zeichenfolgen im separator haben Zeichen gemeinsam, die Split Vorgang vom Anfang bis zum Ende des Werts der Instanz wird fortgesetzt, und entspricht dem ersten Element in separator , gleich einem Trennzeichen in der Instanz ist. Die Reihenfolge, in der Teilzeichenfolgen in der Instanz, hat Vorrang vor der Reihenfolge der Elemente im separator.

Betrachten Sie beispielsweise eine Instanz, deren Wert "Abcdef". Wenn das erste Element im separator "Ef" und das zweite Element "bcde", ist das Ergebnis des Split-Vorgangs wäre ein Zeichenfolgenarray, das zwei Elemente enthält "a" und "f". Grund hierfür ist die Teilzeichenfolge in der Instanz "bcde" überein, festgestellt wird, und entspricht einem Element im separator vor dem Auftreten der Teilzeichenfolge "f".

Jedoch, wenn das erste Element des separator "bcd" und das zweite Element wurde "bc", ist das Ergebnis des Split-Vorgangs wäre ein Zeichenfolgenarray, das zwei Elemente enthält "a" und "Ef". Dies liegt daran "bcd" das erste Trennzeichen in separator , ein Trennzeichen in der Instanz entspricht. Wenn die Reihenfolge der Trennzeichen umgekehrt wird, sodass das erste Element "bc" wurde und das zweite Element wurde "bcd", das Ergebnis wäre ein Zeichenfolgenarray, das zwei Elemente enthält "a" und "Def".

Die Split Methoden von Arbeitsspeicher für das zurückgegebene Array-Objekt und ein String -Objekt für jedes Arrayelement. Wenn Ihre Anwendung eine optimale Leistung erfordert oder Verwalten von speicherbelegung in Ihrer Anwendung wichtig ist, sollten Sie mithilfe der IndexOf oder IndexOfAny -Methode, und optional die Compare Methode, um eine Teilzeichenfolge innerhalb einer Zeichenfolge zu suchen.

Wenn Sie eine Zeichenfolge an einem Trennzeichen teilen, verwenden Sie die IndexOf oder IndexOfAny Methode zum Suchen eines Trennzeichens in der Zeichenfolge. Wenn Sie eine Zeichenfolge an einem Trennzeichen teilen, verwenden Sie die IndexOf oder IndexOfAny Methode zum Suchen des ersten Zeichens der Zeichenfolge als Trennzeichen. Verwenden Sie dann die Compare Methode, um zu bestimmen, ob die Zeichen nach dem ersten Zeichen der verbleibenden Zeichen der Zeichenfolge als Trennzeichen gleich sind.

Darüber hinaus, wenn der gleiche Satz von Zeichen wird verwendet, um Zeichenfolgen in mehreren Teilen Split Methodenaufrufe, sollten Sie ein einzelnes Array erstellen und in jedem Methodenaufruf darauf verweisen. Dies verringert erheblich den Mehraufwand von jedem Methodenaufruf.

Hinweise für Aufrufer:

In der .NET Framework 3.5 und frühere Versionen, wenn die Split -Methode übergeben eine separator also null oder keine Zeichen enthält, die Methode verwendet einen etwas anderen Satz von Zeichen der Zeichenfolge als der Trim Methode hat, um die Zeichenfolge abzuschneiden. In der .NET Framework 4, beide Methoden verwenden einen identischen Satz von Unicode-Leerzeichen.

Das folgende Beispiel veranschaulicht den Unterschied zwischen den Arrays zurückgegeben, indem einer Zeichenfolge String.Split(String[], StringSplitOptions) Methode mit seiner options Parameter gleich StringSplitOptions.None und StringSplitOptions.RemoveEmptyEntries.

using System;

class Example 
{
   public static void Main() 
   {
      string source = "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]";
      string[] stringSeparators = new string[] {"[stop]"};
      string[] result;

      // Display the original string and delimiter string.
      Console.WriteLine("Splitting the string:\n   \"{0}\".", source);
      Console.WriteLine();
      Console.WriteLine("Using the delimiter string:\n   \"{0}\"", 
                        stringSeparators[0]);
      Console.WriteLine();                           

      // Split a string delimited by another string and return all elements.
      result = source.Split(stringSeparators, StringSplitOptions.None);
      Console.WriteLine("Result including all elements ({0} elements):", 
                        result.Length);
      Console.Write("   ");
      foreach (string s in result)
      {
         Console.Write("'{0}' ", String.IsNullOrEmpty(s) ? "<>" : s);                   
      }
      Console.WriteLine();
      Console.WriteLine();

      // Split delimited by another string and return all non-empty elements.
      result = source.Split(stringSeparators, 
                            StringSplitOptions.RemoveEmptyEntries);
      Console.WriteLine("Result including non-empty elements ({0} elements):", 
                        result.Length);
      Console.Write("   ");
      foreach (string s in result)
      {
         Console.Write("'{0}' ", String.IsNullOrEmpty(s) ? "<>" : s);                   
      }
      Console.WriteLine();
   }
}
// The example displays the following output:
//    Splitting the string:
//       "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]".
//    
//    Using the delimiter string:
//       "[stop]"
//    
//    Result including all elements (9 elements):
//       '<>' 'ONE' '<>' 'TWO' '<>' '<>' 'THREE' '<>' '<>'
//    
//    Result including non-empty elements (3 elements):
//       'ONE' 'TWO' 'THREE'

Das folgende Beispiel definiert ein Array von Trennzeichen, die Interpunktion und Leerzeichen enthalten. Übergibt dieses Array zusammen mit einem Wert von StringSplitOptions.RemoveEmptyEntries auf die Split(String[], StringSplitOptions) -Methode gibt ein Array, aus denen die einzelne Wörter aus der Zeichenfolge besteht.

using System;

public class Example
{
   public static void Main()
   {
      string[] separators = {",", ".", "!", "?", ";", ":", " "};
      string value = "The handsome, energetic, young dog was playing with his smaller, more lethargic litter mate.";
      string[] words = value.Split(separators, StringSplitOptions.RemoveEmptyEntries);
      foreach (var word in words)
         Console.WriteLine(word);
   }
}
// The example displays the following output:
//       The
//       handsome
//       energetic
//       young
//       dog
//       was
//       playing
//       with
//       his
//       smaller
//       more
//       lethargic
//       litter
//       mate

Note that the method is called with the options argument set to F:System.StringSplitOptions.RemoveEmptyEntries. This prevents the returned array from includingF:System.String.Empty values that represent empty substring matches between punctuation marks and white-space characters.

Universelle Windows-Plattform
Verfügbar seit 8
.NET Framework
Verfügbar seit 2.0
Portierbare Klassenbibliothek
Unterstützt in: portierbare .NET-Plattformen
Silverlight
Verfügbar seit 2.0
Windows Phone Silverlight
Verfügbar seit 7.0
Windows Phone
Verfügbar seit 8.1
Zurück zum Anfang
Anzeigen: