String.Split Yöntem

Tanım

Bu örnekte belirtilen bir dize veya Unicode karakter dizisinin öğeleriyle ayrılmış alt dizeleri içeren bir dize dizisi döndürür.

Aşırı Yüklemeler

Split(Char, Int32, StringSplitOptions)

Bir dizeyi, belirtilen sınırlandırma karakteri ve isteğe bağlı olarak seçenekler temelinde en fazla sayıda alt dize olarak böler. Bir dizeyi, belirtilen karakter ayırıcısına göre, isteğe bağlı olarak sonuçtan boş alt dizeleri atlayarak en fazla sayıda alt dize olarak böler.

Split(String[], Int32, StringSplitOptions)

Bir dizeyi belirtilen sınırlandırma dizelerine ve isteğe bağlı olarak seçeneklere göre en fazla sayıda alt dizeye böler.

Split(Char[], Int32, StringSplitOptions)

Bir dizeyi, belirtilen sınırlandırma karakterlerine ve isteğe bağlı olarak seçeneklere göre en fazla alt dize sayısına böler.

Split(String[], StringSplitOptions)

Belirtilen sınırlandırma dizesine ve isteğe bağlı olarak seçeneklere göre bir dizeyi alt dizelere böler.

Split(String, Int32, StringSplitOptions)

Bir dizeyi belirtilen sınırlayıcı dizeye ve isteğe bağlı olarak seçeneklere göre en fazla sayıda alt dizeye böler.

Split(Char[], StringSplitOptions)

Belirtilen sınırlandırma karakter ve seçeneklerine göre bir dizeyi alt dizelere böler.

Split(Char[], Int32)

Bir dizeyi, belirtilen sınırlandırma karakterlere göre en fazla sayıda alt dize olarak böler.

Split(Char, StringSplitOptions)

Belirtilen sınırlandırma karakteri ve isteğe bağlı olarak seçenekleri temel alarak bir dizeyi alt dizelere böler.

Split(String, StringSplitOptions)

Bir dizeyi, belirtilen dize ayırıcısını temel alan alt dizelere böler.

Split(Char[])

Belirtilen sınırlandırma karakterlerine göre bir dizeyi alt dizelere böler.

Açıklamalar

Split , ayrılmış bir dizeyi alt dizelere bölmek için kullanılır. Sıfır veya daha fazla sınırlayıcı karakter veya dize belirtmek için bir karakter dizisi ya da dize dizisi kullanabilirsiniz. Sınırlayıcı karakter belirtilmemişse, dize boşluk karakterlerine bölünür.

Yöntemin aşırı yüklemeleri Split , yöntemin (yöntemi) döndürdüğü alt dizelerin sayısını sınırlamanıza izin verir Split(Char[], Int32) , sonuçta boş dizeler ve/veya alt dizeleri ( Split(Char[], StringSplitOptions) ve yöntemleri) dahil edilip edilmeyeceğini belirtebilir (ve yöntemleri) Split(String[], StringSplitOptions) Split(Char[], Int32, StringSplitOptions) Split(String[], Int32, StringSplitOptions) .

İpucu

SplitYöntemi her zaman, ayrılmış bir dizeyi alt dizelere bölmek için en iyi yoldur. Ayrılmış bir dizenin tüm alt dizelerini ayıklamak istemiyorsanız veya bir dizeyi sınırlayıcı karakter kümesi yerine bir düzene göre ayrıştırmak istiyorsanız, normal ifadeleri kullanmayı düşünün veya bir karakterin dizinini yöntemiyle döndüren arama yöntemlerinden birini birleştirin Substring . Daha fazla bilgi için bkz. bir dizeden alt dizeleri ayıklama.

Örnek

Aşağıdaki örneklerde üç farklı aşırı yüklemesi gösterilmektedir String.Split() . İlk örnek, Split(Char[]) aşırı yüklemeyi çağırır ve tek bir sınırlayıcıda geçirir.

string s = "You win some. You lose some.";

string[] subs = s.Split(' ');

foreach (var sub in subs)
{
    Console.WriteLine($"Substring: {sub}");
}

// This example produces the following output:
//
// Substring: You
// Substring: win
// Substring: some.
// Substring: You
// Substring: lose
// Substring: some.

Gördüğünüz gibi, nokta karakterleri ( . ) alt dizelerin iki içine dahil edilir. Süre karakterlerini dışlamak istiyorsanız, Period karakterini ek sınırlandırma karakteri olarak ekleyebilirsiniz. Sonraki örnekte bunun nasıl yapılacağı gösterilmektedir.

string s = "You win some. You lose some.";

string[] subs = s.Split(' ', '.');

foreach (var sub in subs)
{
    Console.WriteLine($"Substring: {sub}");
}

// This example produces the following output:
//
// Substring: You
// Substring: win
// Substring: some
// Substring:
// Substring: You
// Substring: lose
// Substring: some
// Substring:

Dönemler alt dizelerdeki çıktı, ancak artık iki ek boş alt dize eklenmiştir. Bu boş alt dize, bir sözcük ile izleyen nokta arasındaki alt dizeyi temsil eder. Sonuç dizisindeki boş alt dizeleri atlamak için, Split(Char[], StringSplitOptions) aşırı yüklemeyi çağırabilir ve StringSplitOptions.RemoveEmptyEntries parametresi için belirtebilirsiniz options .

string s = "You win some. You lose some.";
char[] separators = new char[] { ' ', '.' };

string[] subs = s.Split(separators, StringSplitOptions.RemoveEmptyEntries);

foreach (var sub in subs)
{
    Console.WriteLine($"Substring: {sub}");
}

// This example produces the following output:
//
// Substring: You
// Substring: win
// Substring: some
// Substring: You
// Substring: lose
// Substring: some

' Nin bireysel aşırı yüklemelerinin bölümleri String.Split() daha fazla örnek içerir.

Split(Char, Int32, StringSplitOptions)

Bir dizeyi, belirtilen sınırlandırma karakteri ve isteğe bağlı olarak seçenekler temelinde en fazla sayıda alt dize olarak böler. Bir dizeyi, belirtilen karakter ayırıcısına göre, isteğe bağlı olarak sonuçtan boş alt dizeleri atlayarak en fazla sayıda alt dize olarak böler.

public string[] Split (char separator, int count, StringSplitOptions options = System.StringSplitOptions.None);
member this.Split : char * int * StringSplitOptions -> string[]
Public Function Split (separator As Char, count As Integer, Optional options As StringSplitOptions = System.StringSplitOptions.None) As String()

Parametreler

separator
Char

Bu örnekteki alt dizeleri sınırlandıran bir karakter.

count
Int32

Dizide beklenen en fazla öğe sayısı.

options
StringSplitOptions

Alt dizelerin kırpılıp kırpılmayacağını ve boş alt dizeleri dahil edilip edilmeyeceğini belirten sabit listesi değerlerinin bit düzeyinde birleşimi.

Döndürülenler

String[]

Bu örnekten ayrılmış en çok alt dizeleri içeren bir dizi count separator .

Açıklamalar

Dize zaten bölünmüş count , ancak dizenin sonuna ulaşılırsa döndürülen dizideki son dize, bu örneğin kalan sonundaki alt dizeyi ve dokunulmadığını içerecektir.

Şunlara uygulanır

Split(String[], Int32, StringSplitOptions)

Bir dizeyi belirtilen sınırlandırma dizelerine ve isteğe bağlı olarak seçeneklere göre en fazla sayıda alt dizeye böler.

public:
 cli::array <System::String ^> ^ Split(cli::array <System::String ^> ^ separator, int count, StringSplitOptions options);
public string[] Split (string[] separator, int count, StringSplitOptions options);
public string[] Split (string[]? separator, int count, StringSplitOptions options);
[System.Runtime.InteropServices.ComVisible(false)]
public string[] Split (string[] separator, int count, StringSplitOptions options);
member this.Split : string[] * int * StringSplitOptions -> string[]
[<System.Runtime.InteropServices.ComVisible(false)>]
member this.Split : string[] * int * StringSplitOptions -> string[]
Public Function Split (separator As String(), count As Integer, options As StringSplitOptions) As String()

Parametreler

separator
String[]

Bu dizede alt dizeleri sınırlandıran dizeler, sınırlayıcı içeren boş bir dizi veya null .

count
Int32

En fazla geri dönüş alt dize sayısı.

options
StringSplitOptions

Alt dizelerin kırpıp kırpılamaymayacaklarını ve boş alt dizeler eklip içermeyip gerek olmadığını belirten numaralama değerlerinin bitwise birleşimi.

Döndürülenler

String[]

Öğeleri bu dizede yer alan ve içinde bir veya daha fazla dizeyle ayrılmış alt dizeleri içeren bir separator dizi. Daha fazla bilgi için Açıklamalar bölümüne bakın.

Öznitelikler

Özel durumlar

count negatiftir.

options , değerlerden biri StringSplitOptions değildir.

Örnekler

Aşağıdaki örnek, yöntemi tarafından oluşturulan alt dizeleri dahil etmek veya hariç StringSplitOptions tutmak için numaralama Split kullanır.

// This example demonstrates the String.Split(Char[], Boolean) and 
//                               String.Split(Char[], Int32, Boolean) methods
using namespace System;
void Show( array<String^>^entries )
{
   Console::WriteLine( "The return value contains these {0} elements:", entries->Length );
   System::Collections::IEnumerator^ myEnum = entries->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      String^ entry = safe_cast<String^>(myEnum->Current);
      Console::Write( "<{0}>", entry );
   }

   Console::Write( "{0}{0}", Environment::NewLine );
}

int main()
{
   String^ s = ",one,,,two,,,,,three,,";
   array<Char>^sep = gcnew array<Char>{
      ','
   };
   array<String^>^result;
   
   //
   Console::WriteLine( "The original string is \"{0}\".", s );
   Console::WriteLine( "The separation character is '{0}'.", sep[ 0 ] );
   Console::WriteLine();
   
   //
   Console::WriteLine( "Split the string and return all elements:" );
   result = s->Split( sep, StringSplitOptions::None );
   Show( result );
   
   //
   Console::WriteLine( "Split the string and return all non-empty elements:" );
   result = s->Split( sep, StringSplitOptions::RemoveEmptyEntries );
   Show( result );
   
   //
   Console::WriteLine( "Split the string and return 2 elements:" );
   result = s->Split( sep, 2, StringSplitOptions::None );
   Show( result );
   
   //
   Console::WriteLine( "Split the string and return 2 non-empty elements:" );
   result = s->Split( sep, 2, StringSplitOptions::RemoveEmptyEntries );
   Show( result );
}

/*
This example produces the following results:

The original string is ",one,,,two,,,,,three,,".
The separation character is ','.

Split the string and return all elements:
The return value contains these 12 elements:
<><one><><><two><><><><><three><><>

Split the string and return all non-empty elements:
The return value contains these 3 elements:
<one><two><three>

Split the string and return 2 elements:
The return value contains these 2 elements:
<><one,,,two,,,,,three,,>

Split the string and return 2 non-empty elements:
The return value contains these 2 elements:
<one><,,two,,,,,three,,>

*/
// This example demonstrates the String.Split() methods that use
// the StringSplitOptions enumeration.
string s1 = ",ONE,,TWO,,,THREE,,";
string s2 = "[stop]" +
            "ONE[stop][stop]" +
            "TWO[stop][stop][stop]" +
            "THREE[stop][stop]";
char[] charSeparators = new char[] { ',' };
string[] stringSeparators = new string[] { "[stop]" };
string[] result;
// ------------------------------------------------------------------------------
// Split a string delimited by characters.
// ------------------------------------------------------------------------------
Console.WriteLine("1) Split a string delimited by characters:\n");

// Display the original string and delimiter characters.
Console.WriteLine($"1a) The original string is \"{s1}\".");
Console.WriteLine($"The delimiter character is '{charSeparators[0]}'.\n");

// Split a string delimited by characters and return all elements.
Console.WriteLine("1b) Split a string delimited by characters and " +
                  "return all elements:");
result = s1.Split(charSeparators, StringSplitOptions.None);
Show(result);

// Split a string delimited by characters and return all non-empty elements.
Console.WriteLine("1c) Split a string delimited by characters and " +
                  "return all non-empty elements:");
result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// Split the original string into the string and empty string before the
// delimiter and the remainder of the original string after the delimiter.
Console.WriteLine("1d) Split a string delimited by characters and " +
                  "return 2 elements:");
result = s1.Split(charSeparators, 2, StringSplitOptions.None);
Show(result);

// Split the original string into the string after the delimiter and the
// remainder of the original string after the delimiter.
Console.WriteLine("1e) Split a string delimited by characters and " +
                  "return 2 non-empty elements:");
result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// ------------------------------------------------------------------------------
// Split a string delimited by another string.
// ------------------------------------------------------------------------------
Console.WriteLine("2) Split a string delimited by another string:\n");

// Display the original string and delimiter string.
Console.WriteLine($"2a) The original string is \"{s2}\".");
Console.WriteLine($"The delimiter string is \"{stringSeparators[0]}\".\n");

// Split a string delimited by another string and return all elements.
Console.WriteLine("2b) Split a string delimited by another string and " +
                  "return all elements:");
result = s2.Split(stringSeparators, StringSplitOptions.None);
Show(result);

// Split the original string at the delimiter and return all non-empty elements.
Console.WriteLine("2c) Split a string delimited by another string and " +
                  "return all non-empty elements:");
result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// Split the original string into the empty string before the
// delimiter and the remainder of the original string after the delimiter.
Console.WriteLine("2d) Split a string delimited by another string and " +
                  "return 2 elements:");
result = s2.Split(stringSeparators, 2, StringSplitOptions.None);
Show(result);

// Split the original string into the string after the delimiter and the
// remainder of the original string after the delimiter.
Console.WriteLine("2e) Split a string delimited by another string and " +
                  "return 2 non-empty elements:");
result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// Display the array of separated strings using a local function
void Show(string[] entries)
{
    Console.WriteLine($"The return value contains these {entries.Length} elements:");
    foreach (string entry in entries)
    {
        Console.Write($"<{entry}>");
    }
    Console.Write("\n\n");
}

/*
This example produces the following results:

1) Split a string delimited by characters:

1a) The original string is ",ONE,,TWO,,,THREE,,".
The delimiter character is ','.

1b) Split a string delimited by characters and return all elements:
The return value contains these 9 elements:
<><ONE><><TWO><><><THREE><><>

1c) Split a string delimited by characters and return all non-empty elements:
The return value contains these 3 elements:
<ONE><TWO><THREE>

1d) Split a string delimited by characters and return 2 elements:
The return value contains these 2 elements:
<><ONE,,TWO,,,THREE,,>

1e) Split a string delimited by characters and return 2 non-empty elements:
The return value contains these 2 elements:
<ONE><TWO,,,THREE,,>

2) Split a string delimited by another string:

2a) The original string is "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]".
The delimiter string is "[stop]".

2b) Split a string delimited by another string and return all elements:
The return value contains these 9 elements:
<><ONE><><TWO><><><THREE><><>

2c) Split a string delimited by another string and return all non-empty elements:
The return value contains these 3 elements:
<ONE><TWO><THREE>

2d) Split a string delimited by another string and return 2 elements:
The return value contains these 2 elements:
<><ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]>

2e) Split a string delimited by another string and return 2 non-empty elements:
The return value contains these 2 elements:
<ONE><TWO[stop][stop][stop]THREE[stop][stop]>

*/

Açıklamalar

Sınırlayıcı dizeler, döndürülen dizinin öğelerine dahil değildir.

Bu örnek içinde dizelerden birini yoksa veya parametresi 1 ise, döndürülen dizi bu örneği separator count içeren tek bir öğeden oluşur.

Parametre separator karakter null içeriyorsa veya hiç karakter içeriyorsa boşluk karakterleri sınırlayıcı olarak kabul edilir. Boşluk karakterleri Unicode standardı tarafından tanımlanır ve bu Char.IsWhiteSpace karakterlere true geçirilenler yöntemi tarafından geri döner.

parametresi için geçiş yapmak için, gibi bazı diğer aşırı yüklemelerden çağrıyı karartma için null string[] separator türünü belirt null Split(Char[], Int32, StringSplitOptions) gerekir. Aşağıdaki örnekte, bu aşırı yükü belirsiz şekilde tanımlamanın çeşitli yolları gösterilmektedir.

string phrase = "The quick  brown fox";

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

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

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

Parametre count sıfırsa veya parametre ise ve bu örneğin options uzunluğu RemoveEmptyEntries sıfırsa boş bir dizi döndürülür.

öğesinin separator her öğesi, bir veya daha fazla karakterden oluşan ayrı bir sınırlayıcı tanımlar. parametresi ise ve iki sınırlayıcı bitişikse veya bu örneğin başında veya sonunda bir sınırlayıcı bulunursa, karşılık gelen options None dizi öğesi Empty içerir.

Bu örnekte birden fazla alt dize varsa, dönüş değerinin ilk eksi 1 öğesinde ilk eksi 1 alt dize döndürülür ve bu örnekteki kalan karakterler dönüş değerinin son öğesinde count count count döndürülür.

count, alt dize sayısından büyükse kullanılabilir alt dizeler döndürülür ve özel durum olmaz.

Ayırıcı dizi

içinde öğelerden herhangi separator biri birden çok karakterden oluşursa, alt dizenin tamamı sınırlayıcı olarak kabul edilir. Örneğin, içinde öğelerden biri separator "10" ise, "This10is10a10string" dizesini bölmeye çalışıldı. şu dört öğeli diziyi döndürür: { "This", "is", "a", "string." }.

Karşılaştırma ayrıntıları

yöntemi, bu dizede bulunan ve parametresinde bir veya daha fazla dizeyle ayrılmış alt dizeleri ayıklar ve bu alt dizeleri bir dizinin öğeleri Split separator olarak döndürür.

yöntemi, Split büyük/küçük harfe duyarlı sıralama kurallarını kullanarak karşılaştırmalar yaparak sınırlayıcıları aratır. Sözcük, dize ve sıralama sıralamaları hakkında daha fazla bilgi için System.Globalization.CompareOptions bkz. numaralama.

yöntemi, değeri veya boş dize ("") olan Split herhangi bir öğesini separator null yoksayar.

içinde dizeler ortak karakterlere sahip olduğunda belirsiz sonuçları önlemek için, yöntemi örneğin değerinin başından sonuna kadar ilerler ve örnekteki bir sınırlayıcıya eşit olan ilk öğeyle separator Split separator eşler. Örnekte alt dizelerle karşılaşma sırası, içinde öğelerin sırasına göre separator önceliklidir.

Örneğin değeri "abcdef" olan bir örneği düşünün. içinde ilk öğe "ef" ve ikinci öğe separator "bcde" ise, bölme işlemi "a" ve "f" olur. Bunun nedeni, "bcde" örneğindeki alt dizenin "f" alt dizeyle karşılaşmadan önce içinde bir öğesiyle separator eşleşmesidir.

Ancak, ilk öğesi "bcd" ve ikinci öğe "bc" ise, bölme işlemi separator "a" ve "ef" olur. Bunun nedeni, "bcd"nin örnekteki bir sınırlayıcıyla separator eşleşen ilk sınırlayıcı olduğudır. Ayırıcıların sırası tersine çevrilse, ilk öğe "bc" ve ikinci öğe "bcd" ise sonuç "a" ve "def" olur.

Performansla ilgili önemli noktalar

Yöntemler, Split döndürülen dizi nesnesi için bellek ve her dizi öğesi için bir nesne String ayırır. Uygulamanız en iyi performans gerektiriyorsa veya bellek ayırmayı yönetmek uygulamanıza kritik önem taşıyorsa, bir dize içinde bir alt dize bulmak için veya yöntemini ve isteğe bağlı olarak IndexOf yöntemini kullanmayı göz önünde IndexOfAny Compare bulundurabilirsiniz.

Bir dizeyi ayırıcı karakterde bölüyorsanız, dizedeki ayırıcı IndexOf karakteri bulmak için veya yöntemini IndexOfAny kullanın. Bir dizeyi ayırıcı dizede bölüyorsanız, ayırıcı dizenin ilk karakterini bulmak IndexOf IndexOfAny için veya yöntemini kullanın. Ardından, bu ilk karakterden sonra gelen karakterlerin ayırıcı dizenin kalan karakterlerine eşit Compare olup olmadığını belirlemek için yöntemini kullanın.

Ayrıca, birden çok yöntem çağrısında dizeleri bölmek için aynı karakter kümesi kullanılıyorsa, tek bir dizi oluşturmayı ve her yöntem çağrısında buna Split başvuruyu göz önünde bulundurarak bunu göz önünde bulundurarak. Bu, her yöntem çağrısının ek yükünü önemli ölçüde azaltır.

Arayanlara Notlar

.NET Framework 3.5 ve önceki sürümlerde yöntemine karakter içeren veya karakter içeren bir geçirilse yöntem, dizeyi bölmek için yöntemin dizeyi kırpmasına göre biraz farklı bir boşluk karakteri kümesi Split(Char[]) separator null Trim(Char[]) kullanır. 4. .NET Framework başlayarak her iki yöntem de aynı Unicode boşluk karakterleri kümesi kullanır.

Şunlara uygulanır

Split(Char[], Int32, StringSplitOptions)

Bir dizeyi, belirtilen sınırlandırma karakterlerine ve isteğe bağlı olarak seçeneklere göre en fazla alt dize sayısına böler.

public:
 cli::array <System::String ^> ^ Split(cli::array <char> ^ separator, int count, StringSplitOptions options);
public string[] Split (char[] separator, int count, StringSplitOptions options);
public string[] Split (char[]? separator, int count, StringSplitOptions options);
[System.Runtime.InteropServices.ComVisible(false)]
public string[] Split (char[] separator, int count, StringSplitOptions options);
member this.Split : char[] * int * StringSplitOptions -> string[]
[<System.Runtime.InteropServices.ComVisible(false)>]
member this.Split : char[] * int * StringSplitOptions -> string[]
Public Function Split (separator As Char(), count As Integer, options As StringSplitOptions) As String()

Parametreler

separator
Char[]

Bu dizedeki alt dizeleri sınırlandıran bir karakter dizisi, sınırlayıcılar içeren boş bir dizi veya null .

count
Int32

Döndürülecek en fazla alt dize sayısı.

options
StringSplitOptions

Alt dizelerin kırpılıp kırpılmayacağını ve boş alt dizeleri dahil edilip edilmeyeceğini belirten sabit listesi değerlerinin bit düzeyinde birleşimi.

Döndürülenler

String[]

Bu dizedeki, içindeki bir veya daha fazla karakterle ayrılmış alt dizeleri içeren bir dizi separator . Daha fazla bilgi için, açıklamalar bölümüne bakın.

Öznitelikler

Özel durumlar

count negatiftir.

options , değerlerden biri StringSplitOptions değildir.

Örnekler

Aşağıdaki örnek, yöntemi tarafından oluşturulan alt dizeleri dahil etmek veya hariç StringSplitOptions tutmak için numaralama Split kullanır.

// This example demonstrates the String.Split(Char[], Boolean) and 
//                               String.Split(Char[], Int32, Boolean) methods
using namespace System;
void Show( array<String^>^entries )
{
   Console::WriteLine( "The return value contains these {0} elements:", entries->Length );
   System::Collections::IEnumerator^ myEnum = entries->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      String^ entry = safe_cast<String^>(myEnum->Current);
      Console::Write( "<{0}>", entry );
   }

   Console::Write( "{0}{0}", Environment::NewLine );
}

int main()
{
   String^ s = ",one,,,two,,,,,three,,";
   array<Char>^sep = gcnew array<Char>{
      ','
   };
   array<String^>^result;
   
   //
   Console::WriteLine( "The original string is \"{0}\".", s );
   Console::WriteLine( "The separation character is '{0}'.", sep[ 0 ] );
   Console::WriteLine();
   
   //
   Console::WriteLine( "Split the string and return all elements:" );
   result = s->Split( sep, StringSplitOptions::None );
   Show( result );
   
   //
   Console::WriteLine( "Split the string and return all non-empty elements:" );
   result = s->Split( sep, StringSplitOptions::RemoveEmptyEntries );
   Show( result );
   
   //
   Console::WriteLine( "Split the string and return 2 elements:" );
   result = s->Split( sep, 2, StringSplitOptions::None );
   Show( result );
   
   //
   Console::WriteLine( "Split the string and return 2 non-empty elements:" );
   result = s->Split( sep, 2, StringSplitOptions::RemoveEmptyEntries );
   Show( result );
}

/*
This example produces the following results:

The original string is ",one,,,two,,,,,three,,".
The separation character is ','.

Split the string and return all elements:
The return value contains these 12 elements:
<><one><><><two><><><><><three><><>

Split the string and return all non-empty elements:
The return value contains these 3 elements:
<one><two><three>

Split the string and return 2 elements:
The return value contains these 2 elements:
<><one,,,two,,,,,three,,>

Split the string and return 2 non-empty elements:
The return value contains these 2 elements:
<one><,,two,,,,,three,,>

*/
// This example demonstrates the String.Split() methods that use
// the StringSplitOptions enumeration.
string s1 = ",ONE,,TWO,,,THREE,,";
string s2 = "[stop]" +
            "ONE[stop][stop]" +
            "TWO[stop][stop][stop]" +
            "THREE[stop][stop]";
char[] charSeparators = new char[] { ',' };
string[] stringSeparators = new string[] { "[stop]" };
string[] result;
// ------------------------------------------------------------------------------
// Split a string delimited by characters.
// ------------------------------------------------------------------------------
Console.WriteLine("1) Split a string delimited by characters:\n");

// Display the original string and delimiter characters.
Console.WriteLine($"1a) The original string is \"{s1}\".");
Console.WriteLine($"The delimiter character is '{charSeparators[0]}'.\n");

// Split a string delimited by characters and return all elements.
Console.WriteLine("1b) Split a string delimited by characters and " +
                  "return all elements:");
result = s1.Split(charSeparators, StringSplitOptions.None);
Show(result);

// Split a string delimited by characters and return all non-empty elements.
Console.WriteLine("1c) Split a string delimited by characters and " +
                  "return all non-empty elements:");
result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// Split the original string into the string and empty string before the
// delimiter and the remainder of the original string after the delimiter.
Console.WriteLine("1d) Split a string delimited by characters and " +
                  "return 2 elements:");
result = s1.Split(charSeparators, 2, StringSplitOptions.None);
Show(result);

// Split the original string into the string after the delimiter and the
// remainder of the original string after the delimiter.
Console.WriteLine("1e) Split a string delimited by characters and " +
                  "return 2 non-empty elements:");
result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// ------------------------------------------------------------------------------
// Split a string delimited by another string.
// ------------------------------------------------------------------------------
Console.WriteLine("2) Split a string delimited by another string:\n");

// Display the original string and delimiter string.
Console.WriteLine($"2a) The original string is \"{s2}\".");
Console.WriteLine($"The delimiter string is \"{stringSeparators[0]}\".\n");

// Split a string delimited by another string and return all elements.
Console.WriteLine("2b) Split a string delimited by another string and " +
                  "return all elements:");
result = s2.Split(stringSeparators, StringSplitOptions.None);
Show(result);

// Split the original string at the delimiter and return all non-empty elements.
Console.WriteLine("2c) Split a string delimited by another string and " +
                  "return all non-empty elements:");
result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// Split the original string into the empty string before the
// delimiter and the remainder of the original string after the delimiter.
Console.WriteLine("2d) Split a string delimited by another string and " +
                  "return 2 elements:");
result = s2.Split(stringSeparators, 2, StringSplitOptions.None);
Show(result);

// Split the original string into the string after the delimiter and the
// remainder of the original string after the delimiter.
Console.WriteLine("2e) Split a string delimited by another string and " +
                  "return 2 non-empty elements:");
result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// Display the array of separated strings using a local function
void Show(string[] entries)
{
    Console.WriteLine($"The return value contains these {entries.Length} elements:");
    foreach (string entry in entries)
    {
        Console.Write($"<{entry}>");
    }
    Console.Write("\n\n");
}

/*
This example produces the following results:

1) Split a string delimited by characters:

1a) The original string is ",ONE,,TWO,,,THREE,,".
The delimiter character is ','.

1b) Split a string delimited by characters and return all elements:
The return value contains these 9 elements:
<><ONE><><TWO><><><THREE><><>

1c) Split a string delimited by characters and return all non-empty elements:
The return value contains these 3 elements:
<ONE><TWO><THREE>

1d) Split a string delimited by characters and return 2 elements:
The return value contains these 2 elements:
<><ONE,,TWO,,,THREE,,>

1e) Split a string delimited by characters and return 2 non-empty elements:
The return value contains these 2 elements:
<ONE><TWO,,,THREE,,>

2) Split a string delimited by another string:

2a) The original string is "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]".
The delimiter string is "[stop]".

2b) Split a string delimited by another string and return all elements:
The return value contains these 9 elements:
<><ONE><><TWO><><><THREE><><>

2c) Split a string delimited by another string and return all non-empty elements:
The return value contains these 3 elements:
<ONE><TWO><THREE>

2d) Split a string delimited by another string and return 2 elements:
The return value contains these 2 elements:
<><ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]>

2e) Split a string delimited by another string and return 2 non-empty elements:
The return value contains these 2 elements:
<ONE><TWO[stop][stop][stop]THREE[stop][stop]>

*/

Açıklamalar

Sınırlayıcı karakterler döndürülen dizinin öğelerine dahil edilmez.

Bu örnek içindeki karakterlerden hiçbirini içermiyorsa separator veya count parametresi 1 ise, döndürülen dizi bu örneği içeren tek bir öğeden oluşur.

Parametre yoksa separator null veya karakter içermiyorsa, boşluk karakterlerinin sınırlayıcı olduğu varsayılır. Boşluk karakterleri Unicode standardı tarafından tanımlanır ve Char.IsWhiteSpace yöntemi true kendisine geçirildiklerinde döndürülür.

Parametresi için geçiş yapmak üzere null char[] separator öğesinin türünü, null başka bir aşırı yükten (gibi) çağrının belirsizliğini ortadan kaldırmak için belirtmeniz gerekir Split(String[], Int32, StringSplitOptions) . Aşağıdaki örnekte, bu aşırı yükü belirsiz şekilde tanımlamanın çeşitli yolları gösterilmektedir.

string phrase = "The quick  brown fox";

_ = phrase.Split(default(char[]), 3, StringSplitOptions.RemoveEmptyEntries);

_ = phrase.Split((char[])null, 3, StringSplitOptions.RemoveEmptyEntries);

_ = phrase.Split(null as char[], 3, StringSplitOptions.RemoveEmptyEntries);

countParametre sıfırsa veya options parametresi ise RemoveEmptyEntries ve bu örneğin uzunluğu sıfır ise, boş bir dizi döndürülür.

Her öğesi separator ayrı bir sınırlayıcı karakter tanımlar. Parametresi ise options None ve iki sınırlayıcı bitişik ise veya bu örneğin başında veya sonunda bir sınırlayıcı bulunursa, karşılık gelen dizi öğesi içerir Empty .

Bu örnekte birden fazla alt dize varsa, dönüş değerinin ilk eksi 1 öğesinde ilk eksi 1 alt dize döndürülür ve bu örnekteki kalan karakterler dönüş değerinin son öğesinde count count count döndürülür.

count, alt dize sayısından büyükse kullanılabilir alt dizeler döndürülür ve özel durum olmaz.

Performansla ilgili önemli noktalar

Yöntemler, Split döndürülen dizi nesnesi için bellek ve her dizi öğesi için bir nesne String ayırır. Uygulamanız en iyi performans gerektiriyorsa veya bellek ayırmayı yönetmek uygulamanıza kritik önem taşıyorsa, bir dize içinde bir alt dize bulmak için veya yöntemini ve isteğe bağlı olarak IndexOf yöntemini kullanmayı göz önünde IndexOfAny Compare bulundurabilirsiniz.

Bir dizeyi ayırıcı karakterde bölüyorsanız, dizedeki ayırıcı IndexOf karakteri bulmak için veya yöntemini IndexOfAny kullanın. Bir dizeyi ayırıcı dizede bölüyorsanız, ayırıcı dizenin ilk karakterini bulmak IndexOf IndexOfAny için veya yöntemini kullanın. Ardından, bu ilk karakterden sonra gelen karakterlerin ayırıcı dizenin kalan karakterlerine eşit Compare olup olmadığını belirlemek için yöntemini kullanın.

Ayrıca, birden çok yöntem çağrısında dizeleri bölmek için aynı karakter kümesi kullanılıyorsa, tek bir dizi oluşturmayı ve her yöntem çağrısında buna Split başvuruyu göz önünde bulundurarak bunu göz önünde bulundurarak. Bu, her yöntem çağrısının ek yükünü önemli ölçüde azaltır.

Arayanlara Notlar

.NET Framework 3.5 ve önceki sürümlerde yöntemine karakter içeren veya karakter içeren bir geçirilse yöntem, dizeyi bölmek için yöntemin dizeyi kırpmasına göre biraz farklı bir boşluk karakteri kümesi Split(Char[]) separator null Trim(Char[]) kullanır. 4. .NET Framework başlayarak her iki yöntem de aynı Unicode boşluk karakterleri kümesi kullanır.

Şunlara uygulanır

Split(String[], StringSplitOptions)

Belirtilen sınırlandırma dizesine ve isteğe bağlı olarak seçeneklere göre bir dizeyi alt dizelere böler.

public:
 cli::array <System::String ^> ^ Split(cli::array <System::String ^> ^ separator, StringSplitOptions options);
public string[] Split (string[] separator, StringSplitOptions options);
public string[] Split (string[]? separator, StringSplitOptions options);
[System.Runtime.InteropServices.ComVisible(false)]
public string[] Split (string[] separator, StringSplitOptions options);
member this.Split : string[] * StringSplitOptions -> string[]
[<System.Runtime.InteropServices.ComVisible(false)>]
member this.Split : string[] * StringSplitOptions -> string[]
Public Function Split (separator As String(), options As StringSplitOptions) As String()

Parametreler

separator
String[]

Bu dizedeki alt dizeleri sınırlandıran dizelerin dizisi, sınırlayıcı içermeyen boş bir dizi null .

options
StringSplitOptions

Alt dizelerin kırpılıp kırpılmayacağını ve boş alt dizeleri dahil edilip edilmeyeceğini belirten sabit listesi değerlerinin bit düzeyinde birleşimi.

Döndürülenler

String[]

Öğeleri bu dizedeki bir veya daha fazla dize tarafından ayrılmış olan alt dizeleri içeren bir dizi separator . Daha fazla bilgi için, açıklamalar bölümüne bakın.

Öznitelikler

Özel durumlar

options değerlerden biri değil StringSplitOptions .

Örnekler

Aşağıdaki örnek, String.Split(String[], StringSplitOptions) ve parametresi ile eşit olan bir dizenin metodunu çağırarak döndürülen dizilerdeki farkı gösterir options StringSplitOptions.None StringSplitOptions.RemoveEmptyEntries .

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   \"{source}\".");
Console.WriteLine();
Console.WriteLine($"Using the delimiter string:\n   \"{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 ({result.Length} elements):");
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 ({result.Length} elements):");
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'

Aşağıdaki örnek, noktalama ve boşluk karakterlerini içeren bir ayırıcı dizisini tanımlar. Bu diziyi yöntemi ile birlikte geçirmek, StringSplitOptions.RemoveEmptyEntries Split(String[], StringSplitOptions) dizeden tek sözcüklerden oluşan bir dizi döndürür.

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

Yönteminin options olarak ayarlanan bağımsız değişkenle çağrıldığını unutmayın StringSplitOptions.RemoveEmptyEntries . Bu, döndürülen dizinin String.Empty noktalama işaretleri ve boşluk karakterleri arasındaki boş alt dize eşleşmelerini temsil eden değerleri eklemesini önler.

Açıklamalar

Bir dize, bilinen bir dizeler kümesiyle sınırlandırılırdı, Split yöntemini alt dizelerde ayırmak için kullanabilirsiniz.

Sınırlayıcı dizeler döndürülen dizinin öğelerine dahil edilmez. Örneğin, separator dizi "--" dizesini içeriyorsa ve geçerli dize örneğinin değeri "aa--bb--cc" ise, yöntem üç öğe içeren bir dizi döndürür: "AA", "BB" ve "CC".

Bu örnek içindeki dizelerin hiçbirini içermiyorsa separator , döndürülen dizi bu örneği içeren tek bir öğeden oluşur.

optionsParametresi ise RemoveEmptyEntries ve bu örneğin uzunluğu sıfırsa, yöntem boş bir dizi döndürür.

Her öğesi separator bir veya daha fazla karakterden oluşan ayrı bir sınırlayıcı tanımlar. optionsBağımsız değişken ise None ve iki sınırlayıcı bitişik ise veya bu örneğin başında veya sonunda bir sınırlayıcı bulunursa, karşılık gelen dizi öğesi içerir String.Empty . Örneğin, separator "-" ve "" olmak üzere iki öğe içeriyorsa _ , dize örneğinin değeri "- _ AA- _ " ve options bağımsız değişkeninin değeri ise None , yöntemi aşağıdaki beş öğeye sahip bir dize dizisi döndürür:

  1. String.Empty, 0 dizinindeki "-" alt dizeden önce gelen boş dizeyi temsil eder.

  2. String.Empty, 0 dizinindeki "-" alt dizesi ile dizin 1 ' deki "_" alt dizesinde boş dizeyi temsil eden.

  3. "AA".

  4. String.Empty, dizin 4 ' te "-" alt dizesini izleyen boş dizeyi temsil eden.

  5. String.Empty, Dizin 5 ' te "_" alt dizesini izleyen boş dizeyi temsil eder.

Ayırıcı dizisi

İçindeki öğelerinden herhangi biri separator birden fazla karakterden oluşuyorsa, tüm alt dize bir sınırlayıcı olarak kabul edilir. Örneğin, içindeki öğelerden biri separator "10" ise, "This10is10a10string" dizesini bölmeye çalışılıyor. Şu dört öğeli diziyi döndürür: {"This", "dir", "a", "String." }.

separatorParametre null boş olmayan dizeler içeriyorsa veya içermiyorsa, boşluk karakterlerinin sınırlayıcı olduğu varsayılır. Boşluk karakterleri Unicode standardı tarafından tanımlanır ve Char.IsWhiteSpace yöntemi true kendisine geçirildiklerinde döndürülür.

Parametresi için geçiş yapmak üzere null string[] separator öğesinin türünü, null başka bir aşırı yükten (gibi) çağrının belirsizliğini ortadan kaldırmak için belirtmeniz gerekir Split(Char[], StringSplitOptions) . Aşağıdaki örnekte, bu aşırı yükü belirsiz şekilde tanımlamanın çeşitli yolları gösterilmektedir.

string phrase = "The quick  brown fox";

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

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

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

Karşılaştırma ayrıntıları

SplitYöntemi, bu dizedeki, parametresindeki bir veya daha fazla dizeden ayrılmış olan alt dizeleri ayıklar separator ve bu alt dizeleri bir dizinin öğeleri olarak döndürür.

SplitYöntemi, büyük/küçük harfe duyarlı sıra sıralama kuralları kullanarak karşılaştırmalar gerçekleştirerek sınırlayıcıları arar. Sözcük, dize ve sıralı sıralamalar hakkında daha fazla bilgi için bkz System.Globalization.CompareOptions . sabit listesi.

SplitYöntemi, separator değeri null veya boş dize ("") olan herhangi bir öğeyi yoksayar.

İçindeki dizelerin ortak olarak karakterleri olduğunda belirsiz sonuçlara engel olmak için, separator Split işlem başlangıçtan örnek değerinin sonuna kadar ilerler ve içindeki ilk öğesiyle eşleşir ve separator Bu, örnekteki sınırlayıcıyla eşittir. Örnekte alt dizelerin karşılaştığı sıra, içindeki öğelerin sırasına göre önceliklidir separator .

Örneğin, değeri "abcdef" olan bir örnek düşünün. İçindeki ilk öğe separator "ef" ve ikinci öğe ise "bcde" ise, bölme işleminin sonucu iki öğe içeren bir dize dizisi olur, "a" ve "f". Bunun nedeni, "bcde" örneğindeki alt dizenin ve separator "f" alt dizesi ile karşılaşılmadan önce içindeki bir öğesiyle eşleşmesi nedeniyle oluşur.

Ancak, ilk öğesi separator "bcd" ve ikinci öğe "BC" ise, bölme işleminin sonucu iki öğe içeren bir dize dizisi olur, "a" ve "ef". Bunun nedeni, "bcd" öğesinde separator örnekteki sınırlayıcıyla eşleşen ilk sınırlayıcıdır. Ayırıcıların sırası tersine çevrilirse ilk öğe "BC", ikinci öğe ise "bcd" ise, sonuç iki öğe içeren bir dize dizisi olur, "a" ve "def".

Performansla ilgili önemli noktalar

SplitYöntemler döndürülen dizi nesnesi için bellek ayırır ve String her dizi öğesi için bir nesnesi. Uygulamanız en iyi performansı gerektiriyorsa veya uygulamanızda bellek ayırmayı yönetmek önemliyse, IndexOf IndexOfAny Compare bir dize içinde bir alt dizeyi bulmak için veya yöntemini ve isteğe bağlı olarak yöntemini kullanmayı düşünün.

Bir dizeyi bir ayırıcı karakterde böyor, IndexOf IndexOfAny dizedeki bir ayırıcı karakter bulmak için veya metodunu kullanın. Bir dizeyi bir ayırıcı dizesinde böyor, IndexOf IndexOfAny ayırıcı dizesinin ilk karakterini bulmak için veya yöntemini kullanın. Sonra Compare Bu ilk karakterden sonraki karakterlerin ayırıcı dizesinin kalan karakterlerine eşit olup olmadığını anlamak için yöntemini kullanın.

Ayrıca, birden çok yöntem çağrısında dizeleri ayırmak için aynı karakter kümesi kullanılıyorsa Split , tek bir dizi oluşturmayı ve her yöntem çağrısında buna başvurmayı düşünün. Bu, her yöntem çağrısının ek yükünü önemli ölçüde azaltır.

Arayanlara Notlar

.NET Framework 3,5 ve önceki sürümlerde, Split(Char[]) yöntemi bir separator karakter içeren veya olmayan bir değer geçirtiyse, yöntem dizeyi kırpmak için yöntemden farklı bir null boşluk karakter kümesi kullanır Trim(Char[]) . .NET Framework 4 ' te başlayarak her iki yöntem de özdeş bir Unicode boşluk karakterleri kümesi kullanır.

Şunlara uygulanır

Split(String, Int32, StringSplitOptions)

Bir dizeyi belirtilen sınırlayıcı dizeye ve isteğe bağlı olarak seçeneklere göre en fazla sayıda alt dizeye böler.

public string[] Split (string? separator, int count, StringSplitOptions options = System.StringSplitOptions.None);
public string[] Split (string separator, int count, StringSplitOptions options = System.StringSplitOptions.None);
member this.Split : string * int * StringSplitOptions -> string[]
Public Function Split (separator As String, count As Integer, Optional options As StringSplitOptions = System.StringSplitOptions.None) As String()

Parametreler

separator
String

Bu örnekteki alt dizeleri sınırlandıran bir dize.

count
Int32

Dizide beklenen en fazla öğe sayısı.

options
StringSplitOptions

Alt dizelerin kırpıp kırpılamaymayacaklarını ve boş alt dizeler eklip içermeyip gerek olmadığını belirten numaralama değerlerinin bitwise birleşimi.

Döndürülenler

String[]

Bu örnekten en count çok alt dize içeren ve ile sınırlandırılmış bir separator dizi.

Açıklamalar

Dize zaten bölünmüşse ( 1 kez) ama dizenin sonuna ulaşıldı ise, döndürülen dizide son dize bu örneğin kalan sonda kalan alt dizesini (dokunulmamış) count içerir.

Şunlara uygulanır

Split(Char[], StringSplitOptions)

Belirtilen sınırlandırma karakter ve seçeneklerine göre bir dizeyi alt dizelere böler.

public:
 cli::array <System::String ^> ^ Split(cli::array <char> ^ separator, StringSplitOptions options);
public string[] Split (char[] separator, StringSplitOptions options);
public string[] Split (char[]? separator, StringSplitOptions options);
[System.Runtime.InteropServices.ComVisible(false)]
public string[] Split (char[] separator, StringSplitOptions options);
member this.Split : char[] * StringSplitOptions -> string[]
[<System.Runtime.InteropServices.ComVisible(false)>]
member this.Split : char[] * StringSplitOptions -> string[]
Public Function Split (separator As Char(), options As StringSplitOptions) As String()

Parametreler

separator
Char[]

Bu dizedeki alt dizeleri sınırlandıran bir karakter dizisi, sınırlayıcılar içeren boş bir dizi veya null .

options
StringSplitOptions

Alt dizelerin kırpılıp kırpılmayacağını ve boş alt dizeleri dahil edilip edilmeyeceğini belirten sabit listesi değerlerinin bit düzeyinde birleşimi.

Döndürülenler

String[]

Öğeleri bu dizedeki bir veya daha fazla karakterle ayrılmış alt dizeleri içeren bir dizi separator . Daha fazla bilgi için, açıklamalar bölümüne bakın.

Öznitelikler

Özel durumlar

options değerlerden biri değil StringSplitOptions .

Örnekler

Aşağıdaki örnek, StringSplitOptions yöntemi tarafından oluşturulan alt dizeleri dahil etmek veya hariç tutmak için sabit listesini kullanır Split .

// This example demonstrates the String.Split(Char[], Boolean) and 
//                               String.Split(Char[], Int32, Boolean) methods
using namespace System;
void Show( array<String^>^entries )
{
   Console::WriteLine( "The return value contains these {0} elements:", entries->Length );
   System::Collections::IEnumerator^ myEnum = entries->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      String^ entry = safe_cast<String^>(myEnum->Current);
      Console::Write( "<{0}>", entry );
   }

   Console::Write( "{0}{0}", Environment::NewLine );
}

int main()
{
   String^ s = ",one,,,two,,,,,three,,";
   array<Char>^sep = gcnew array<Char>{
      ','
   };
   array<String^>^result;
   
   //
   Console::WriteLine( "The original string is \"{0}\".", s );
   Console::WriteLine( "The separation character is '{0}'.", sep[ 0 ] );
   Console::WriteLine();
   
   //
   Console::WriteLine( "Split the string and return all elements:" );
   result = s->Split( sep, StringSplitOptions::None );
   Show( result );
   
   //
   Console::WriteLine( "Split the string and return all non-empty elements:" );
   result = s->Split( sep, StringSplitOptions::RemoveEmptyEntries );
   Show( result );
   
   //
   Console::WriteLine( "Split the string and return 2 elements:" );
   result = s->Split( sep, 2, StringSplitOptions::None );
   Show( result );
   
   //
   Console::WriteLine( "Split the string and return 2 non-empty elements:" );
   result = s->Split( sep, 2, StringSplitOptions::RemoveEmptyEntries );
   Show( result );
}

/*
This example produces the following results:

The original string is ",one,,,two,,,,,three,,".
The separation character is ','.

Split the string and return all elements:
The return value contains these 12 elements:
<><one><><><two><><><><><three><><>

Split the string and return all non-empty elements:
The return value contains these 3 elements:
<one><two><three>

Split the string and return 2 elements:
The return value contains these 2 elements:
<><one,,,two,,,,,three,,>

Split the string and return 2 non-empty elements:
The return value contains these 2 elements:
<one><,,two,,,,,three,,>

*/
// This example demonstrates the String.Split() methods that use
// the StringSplitOptions enumeration.
string s1 = ",ONE,,TWO,,,THREE,,";
string s2 = "[stop]" +
            "ONE[stop][stop]" +
            "TWO[stop][stop][stop]" +
            "THREE[stop][stop]";
char[] charSeparators = new char[] { ',' };
string[] stringSeparators = new string[] { "[stop]" };
string[] result;
// ------------------------------------------------------------------------------
// Split a string delimited by characters.
// ------------------------------------------------------------------------------
Console.WriteLine("1) Split a string delimited by characters:\n");

// Display the original string and delimiter characters.
Console.WriteLine($"1a) The original string is \"{s1}\".");
Console.WriteLine($"The delimiter character is '{charSeparators[0]}'.\n");

// Split a string delimited by characters and return all elements.
Console.WriteLine("1b) Split a string delimited by characters and " +
                  "return all elements:");
result = s1.Split(charSeparators, StringSplitOptions.None);
Show(result);

// Split a string delimited by characters and return all non-empty elements.
Console.WriteLine("1c) Split a string delimited by characters and " +
                  "return all non-empty elements:");
result = s1.Split(charSeparators, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// Split the original string into the string and empty string before the
// delimiter and the remainder of the original string after the delimiter.
Console.WriteLine("1d) Split a string delimited by characters and " +
                  "return 2 elements:");
result = s1.Split(charSeparators, 2, StringSplitOptions.None);
Show(result);

// Split the original string into the string after the delimiter and the
// remainder of the original string after the delimiter.
Console.WriteLine("1e) Split a string delimited by characters and " +
                  "return 2 non-empty elements:");
result = s1.Split(charSeparators, 2, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// ------------------------------------------------------------------------------
// Split a string delimited by another string.
// ------------------------------------------------------------------------------
Console.WriteLine("2) Split a string delimited by another string:\n");

// Display the original string and delimiter string.
Console.WriteLine($"2a) The original string is \"{s2}\".");
Console.WriteLine($"The delimiter string is \"{stringSeparators[0]}\".\n");

// Split a string delimited by another string and return all elements.
Console.WriteLine("2b) Split a string delimited by another string and " +
                  "return all elements:");
result = s2.Split(stringSeparators, StringSplitOptions.None);
Show(result);

// Split the original string at the delimiter and return all non-empty elements.
Console.WriteLine("2c) Split a string delimited by another string and " +
                  "return all non-empty elements:");
result = s2.Split(stringSeparators, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// Split the original string into the empty string before the
// delimiter and the remainder of the original string after the delimiter.
Console.WriteLine("2d) Split a string delimited by another string and " +
                  "return 2 elements:");
result = s2.Split(stringSeparators, 2, StringSplitOptions.None);
Show(result);

// Split the original string into the string after the delimiter and the
// remainder of the original string after the delimiter.
Console.WriteLine("2e) Split a string delimited by another string and " +
                  "return 2 non-empty elements:");
result = s2.Split(stringSeparators, 2, StringSplitOptions.RemoveEmptyEntries);
Show(result);

// Display the array of separated strings using a local function
void Show(string[] entries)
{
    Console.WriteLine($"The return value contains these {entries.Length} elements:");
    foreach (string entry in entries)
    {
        Console.Write($"<{entry}>");
    }
    Console.Write("\n\n");
}

/*
This example produces the following results:

1) Split a string delimited by characters:

1a) The original string is ",ONE,,TWO,,,THREE,,".
The delimiter character is ','.

1b) Split a string delimited by characters and return all elements:
The return value contains these 9 elements:
<><ONE><><TWO><><><THREE><><>

1c) Split a string delimited by characters and return all non-empty elements:
The return value contains these 3 elements:
<ONE><TWO><THREE>

1d) Split a string delimited by characters and return 2 elements:
The return value contains these 2 elements:
<><ONE,,TWO,,,THREE,,>

1e) Split a string delimited by characters and return 2 non-empty elements:
The return value contains these 2 elements:
<ONE><TWO,,,THREE,,>

2) Split a string delimited by another string:

2a) The original string is "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]".
The delimiter string is "[stop]".

2b) Split a string delimited by another string and return all elements:
The return value contains these 9 elements:
<><ONE><><TWO><><><THREE><><>

2c) Split a string delimited by another string and return all non-empty elements:
The return value contains these 3 elements:
<ONE><TWO><THREE>

2d) Split a string delimited by another string and return 2 elements:
The return value contains these 2 elements:
<><ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]>

2e) Split a string delimited by another string and return 2 non-empty elements:
The return value contains these 2 elements:
<ONE><TWO[stop][stop][stop]THREE[stop][stop]>

*/

Açıklamalar

Sınırlayıcı karakterler ( separator dizideki karakterler) döndürülen dizinin öğelerine dahil edilmez. Örneğin, separator dizi "-" karakterini içeriyorsa ve geçerli dize örneğinin değeri "aa-bb-cc" ise, yöntem üç öğe içeren bir dizi döndürür: "AA", "BB" ve "CC".

Bu örnek içindeki karakterlerden hiçbirini içermiyorsa separator , döndürülen dizi bu örneği içeren tek bir öğeden oluşur.

optionsParametresi ise RemoveEmptyEntries ve bu örneğin uzunluğu sıfırsa, yöntem boş bir dizi döndürür.

Her öğesi, separator tek bir karakterden oluşan ayrı bir sınırlayıcı tanımlar. optionsBağımsız değişken ise None ve iki sınırlayıcı bitişik ise veya bu örneğin başında veya sonunda bir sınırlayıcı bulunursa, karşılık gelen dizi öğesi içerir String.Empty . Örneğin, separator iki öğe içeriyorsa '-' ve '_' dize örneğinin değeri "- _ AA- _ " ise ve bağımsız değişkenin değeri ise, options None yöntemi aşağıdaki beş öğeye sahip bir dize dizisi döndürür:

  1. String.Empty, 0 dizinindeki "-" karakterinden önce gelen boş dizeyi temsil eder.

  2. String.Empty, 0 dizinindeki "-" karakteri ile dizin 1 ' deki "_" karakteri arasındaki boş dizeyi temsil eder.

  3. "AA".

  4. String.Empty, dizin 4 ' te "-" karakterini izleyen boş dizeyi temsil eden.

  5. String.Empty, Dizin 5 ' te "_" karakteri izleyen boş dizeyi temsil eder.

Ayırıcı dizisi

Parametre yoksa separator null veya karakter içermiyorsa, boşluk karakterlerinin sınırlayıcı olduğu varsayılır. Boşluk karakterleri Unicode standardı tarafından tanımlanır ve Char.IsWhiteSpace yöntemi true kendisine geçirildiklerinde döndürülür.

Parametresi için geçiş yapmak üzere null char[] separator öğesinin türünü, null başka bir aşırı yükten (gibi) çağrının belirsizliğini ortadan kaldırmak için belirtmeniz gerekir Split(String[], StringSplitOptions) . Aşağıdaki örnekte, bu aşırı yükü belirsiz şekilde tanımlamanın çeşitli yolları gösterilmektedir.

string phrase = "The quick  brown fox";

_ = phrase.Split(default(char[]), StringSplitOptions.RemoveEmptyEntries);

_ = phrase.Split((char[])null, StringSplitOptions.RemoveEmptyEntries);

_ = phrase.Split(null as char[], StringSplitOptions.RemoveEmptyEntries);

Karşılaştırma ayrıntıları

SplitYöntemi bu dizedeki, parametresindeki bir veya daha fazla karakterle ayrılmış olan alt dizeleri ayıklar separator ve bu alt dizeleri bir dizinin öğeleri olarak döndürür.

SplitYöntemi, büyük/küçük harfe duyarlı sıra sıralama kuralları kullanarak karşılaştırmalar gerçekleştirerek sınırlayıcıları arar. Sözcük, dize ve sıralı sıralamalar hakkında daha fazla bilgi için bkz System.Globalization.CompareOptions . sabit listesi.

Performansla ilgili önemli noktalar

SplitYöntemler döndürülen dizi nesnesi için bellek ayırır ve String her dizi öğesi için bir nesnesi. Uygulamanız en iyi performansı gerektiriyorsa veya uygulamanızda bellek ayırmayı yönetmek önemliyse, IndexOf IndexOfAny Compare bir dize içinde bir alt dizeyi bulmak için veya yöntemini ve isteğe bağlı olarak yöntemini kullanmayı düşünün.

Bir dizeyi bir ayırıcı karakterde böyor, IndexOf IndexOfAny dizedeki bir ayırıcı karakter bulmak için veya metodunu kullanın. Bir dizeyi bir ayırıcı dizesinde böyor, IndexOf IndexOfAny ayırıcı dizesinin ilk karakterini bulmak için veya yöntemini kullanın. Sonra Compare Bu ilk karakterden sonraki karakterlerin ayırıcı dizesinin kalan karakterlerine eşit olup olmadığını anlamak için yöntemini kullanın.

Ayrıca, birden çok yöntem çağrısında dizeleri ayırmak için aynı karakter kümesi kullanılıyorsa Split , tek bir dizi oluşturmayı ve her yöntem çağrısında buna başvurmayı düşünün. Bu, her yöntem çağrısının ek yükünü önemli ölçüde azaltır.

Arayanlara Notlar

.NET Framework 3,5 ve önceki sürümlerde, Split(Char[]) yöntemi bir separator karakter içeren veya olmayan bir değer geçirtiyse, yöntem dizeyi kırpmak için yöntemden farklı bir null boşluk karakter kümesi kullanır Trim(Char[]) . .NET Framework 4 ' te başlayarak her iki yöntem de özdeş bir Unicode boşluk karakterleri kümesi kullanır.

Şunlara uygulanır

Split(Char[], Int32)

Bir dizeyi, belirtilen sınırlandırma karakterlere göre en fazla sayıda alt dize olarak böler.

public:
 cli::array <System::String ^> ^ Split(cli::array <char> ^ separator, int count);
public string[] Split (char[] separator, int count);
public string[] Split (char[]? separator, int count);
member this.Split : char[] * int -> string[]
Public Function Split (separator As Char(), count As Integer) As String()

Parametreler

separator
Char[]

Bu dizedeki alt dizeleri sınırlandıran bir karakter dizisi, sınırlayıcılar içeren boş bir dizi veya null .

count
Int32

Döndürülecek en fazla alt dize sayısı.

Döndürülenler

String[]

Öğeleri içindeki bir veya daha fazla karakterle ayrılmış bu örnekteki alt dizeleri içeren bir dizi separator . Daha fazla bilgi için, açıklamalar bölümüne bakın.

Özel durumlar

count negatiftir.

Örnekler

Aşağıdaki örnek, count tarafından döndürülen dizelerin sayısını sınırlamak için nasıl kullanılabileceğini gösterir Split .

string name = "Alex Johnson III";

string[] subs = name.Split(null, 2);

string firstName = subs[0];
string lastName;
if (subs.Length > 1)
{
    lastName = subs[1];
}

// firstName = "Alex"
// lastName = "Johnson III"

Açıklamalar

Sınırlayıcı karakterler döndürülen dizinin öğelerine dahil edilmez.

Bu örnek içindeki karakterlerden hiçbirini içermiyorsa separator , döndürülen dizi bu örneği içeren tek bir öğeden oluşur. countSıfırsa boş bir dizi döndürülür.

Parametre yoksa separator null veya karakter içermiyorsa, boşluk karakterlerinin sınırlayıcı olduğu varsayılır. Boşluk karakterleri Unicode standardı tarafından tanımlanır ve Char.IsWhiteSpace yöntemi true kendisine geçirildiklerinde döndürülür.

Her öğesi separator ayrı bir sınırlayıcı karakter tanımlar. İki sınırlayıcı bitişik ise veya bu örneğin başlangıcında veya sonunda bir sınırlayıcı bulunursa, karşılık gelen dizi öğesi içerir Empty .

countBu örnekte alt dizeler varsa, ilk alt count - 1 dizeler döndürülen count - 1 değerin ilk öğelerinde döndürülür ve bu örnekteki geri kalan karakterler döndürülen değerin son öğesinde döndürülür.

Alt count dizeler sayısından büyükse, kullanılabilir alt dizeler döndürülür ve hiçbir özel durum oluşturulmaz.

Aşağıdaki tabloda bazı örnekler gösterilmektedir.

Dil Dize değeri Ayırıcı Döndürülen dizi
C# "42, 12, 19" Yeni Char [] {', ', ' '} {"42", "", "12", "", "19"}
Visual Basic "42, 12, 19" Char () = {"," c "," c}) {"42", "", "12", "", "19"}
C# "42.. 12.. 19." Yeni Char [] {'. '} {"42", "", "12", "", "19", ""}
Visual Basic "42.. 12.. 19." Char () = {"." , {"42", "", "12", "", "19", ""}
C# Muz Yeni Char [] {'. '} {"Banana"}
Visual Basic Muz Char () = {"." , {"Banana"}
C# "Darb\nSmarba" Yeni Char [] {} {"Darb", "Smarba"}
Visual Basic "Darb" & vbLf & "Smarba" Char () = {} {"Darb", "Smarba"}
C# "Darb\nSmarba" null {"Darb", "Smarba"}
Visual Basic "Darb" & vbLf & "Smarba" Nothing {"Darb", "Smarba"}

Performansla ilgili önemli noktalar

SplitYöntemler döndürülen dizi nesnesi için bellek ayırır ve String her dizi öğesi için bir nesnesi. Uygulamanız en iyi performansı gerektiriyorsa veya uygulamanızda bellek ayırmayı yönetmek önemliyse, IndexOf IndexOfAny Compare bir dize içinde bir alt dizeyi bulmak için veya yöntemini ve isteğe bağlı olarak yöntemini kullanmayı düşünün.

Bir dizeyi bir ayırıcı karakterde böyor, IndexOf IndexOfAny dizedeki bir ayırıcı karakter bulmak için veya metodunu kullanın. Bir dizeyi bir ayırıcı dizesinde böyor, IndexOf IndexOfAny ayırıcı dizesinin ilk karakterini bulmak için veya yöntemini kullanın. Sonra Compare Bu ilk karakterden sonraki karakterlerin ayırıcı dizesinin kalan karakterlerine eşit olup olmadığını anlamak için yöntemini kullanın.

Ayrıca, birden çok yöntem çağrısında dizeleri ayırmak için aynı karakter kümesi kullanılıyorsa Split , tek bir dizi oluşturmayı ve her yöntem çağrısında buna başvurmayı düşünün. Bu, her yöntem çağrısının ek yükünü önemli ölçüde azaltır.

Arayanlara Notlar

.NET Framework 3,5 ve önceki sürümlerde, Split(Char[]) yöntemi bir separator karakter içeren veya olmayan bir değer geçirtiyse, yöntem dizeyi kırpmak için yöntemden farklı bir null boşluk karakter kümesi kullanır Trim(Char[]) . .NET Framework 4 ' te başlayarak her iki yöntem de özdeş bir Unicode boşluk karakterleri kümesi kullanır.

Ayrıca bkz.

Şunlara uygulanır

Split(Char, StringSplitOptions)

Belirtilen sınırlandırma karakteri ve isteğe bağlı olarak seçenekleri temel alarak bir dizeyi alt dizelere böler.

public string[] Split (char separator, StringSplitOptions options = System.StringSplitOptions.None);
member this.Split : char * StringSplitOptions -> string[]
Public Function Split (separator As Char, Optional options As StringSplitOptions = System.StringSplitOptions.None) As String()

Parametreler

separator
Char

Bu dizedeki alt dizeleri sınırlandıran bir karakter.

options
StringSplitOptions

Alt dizelerin kırpılıp kırpılmayacağını ve boş alt dizeleri dahil edilip edilmeyeceğini belirten sabit listesi değerlerinin bit düzeyinde birleşimi.

Döndürülenler

String[]

Öğeleri tarafından ayrılmış bu örnekten alt dizeleri içeren bir dizi separator .

Şunlara uygulanır

Split(String, StringSplitOptions)

Bir dizeyi, belirtilen dize ayırıcısını temel alan alt dizelere böler.

public string[] Split (string? separator, StringSplitOptions options = System.StringSplitOptions.None);
public string[] Split (string separator, StringSplitOptions options = System.StringSplitOptions.None);
member this.Split : string * StringSplitOptions -> string[]
Public Function Split (separator As String, Optional options As StringSplitOptions = System.StringSplitOptions.None) As String()

Parametreler

separator
String

Bu dizedeki alt dizeleri sınırlandıran bir dize.

options
StringSplitOptions

Alt dizelerin kırpılıp kırpılmayacağını ve boş alt dizeleri dahil edilip edilmeyeceğini belirten sabit listesi değerlerinin bit düzeyinde birleşimi.

Döndürülenler

String[]

Öğeleri tarafından ayrılmış bu örnekten alt dizeleri içeren bir dizi separator .

Şunlara uygulanır

Split(Char[])

Belirtilen sınırlandırma karakterlerine göre bir dizeyi alt dizelere böler.

public:
 cli::array <System::String ^> ^ Split(... cli::array <char> ^ separator);
public string[] Split (params char[] separator);
public string[] Split (params char[]? separator);
member this.Split : char[] -> string[]
Public Function Split (ParamArray separator As Char()) As String()

Parametreler

separator
Char[]

Sınırlayıcı karakterlerden oluşan dizi, sınırlayıcı içermeyen boş bir dizi null .

Döndürülenler

String[]

Öğeleri bu örnekten gelen ve içindeki bir veya daha fazla karakterle ayrılmış alt dizeleri içeren bir dizi separator . Daha fazla bilgi için, açıklamalar bölümüne bakın.

Örnekler

Aşağıdaki örnek, boşluk karakteri ( ) ve sekme karakteri () ile sınırlayıcı olarak davranarak bir metin bloğundan bağımsız sözcüklerin nasıl ayıklanacağını göstermektedir \t . Bölünen dize, bu karakterlerin her ikisini de içerir.

string s = "Today\tI'm going to school";
string[] subs = s.Split(' ', '\t');

foreach (var sub in subs)
{
    Console.WriteLine($"Substring: {sub}");
}

// This example produces the following output:
//
// Substring: Today
// Substring: I'm
// Substring: going
// Substring: to
// Substring: school

Açıklamalar

Bir dize, bilinen bir karakter kümesiyle sınırlandırılırdı, Split(Char[]) yöntemini alt dizelerdeki ayırmak için kullanabilirsiniz.

Sınırlayıcı karakterler döndürülen dizinin öğelerine dahil edilmez. Örneğin, ayırıcı dizi "-" karakterini içeriyorsa ve geçerli dize örneğinin değeri "aa-bb-cc" ise, yöntem üç öğe içeren bir dizi döndürür: "AA", "BB" ve "CC".

Bu örnek içindeki karakterlerden hiçbirini içermiyorsa separator , döndürülen dizi bu örneği içeren tek bir öğeden oluşur.

Her öğesi separator ayrı bir sınırlayıcı karakter tanımlar. İki sınırlayıcı bitişik ise veya bu örneğin başlangıcında veya sonunda bir sınırlayıcı bulunursa, döndürülen dizide karşılık gelen öğesi içerir Empty .

Aşağıdaki tabloda bazı örnekler gösterilmektedir.

Dil Dize değeri Ayırıcı Döndürülen dizi
C# "42, 12, 19" Yeni Char [] {', ', ' '} {"42", "", "12", "", "19"}
Visual Basic "42, 12, 19" Char () = {"," c "," c}) {"42", "", "12", "", "19"}
C# "42.. 12.. 19." Yeni Char [] {'. '} {"42", "", "12", "", "19", ""}
Visual Basic "42.. 12.. 19." Char () = {"." , {"42", "", "12", "", "19", ""}
C# Muz Yeni Char [] {'. '} {"Banana"}
Visual Basic Muz Char () = {"." , {"Banana"}
C# "Darb\nSmarba" Yeni Char [] {} {"Darb", "Smarba"}
Visual Basic "Darb" & vbLf & "Smarba" Char () = {} {"Darb", "Smarba"}
C# "Darb\nSmarba" null {"Darb", "Smarba"}
Visual Basic "Darb" & vbLf & "Smarba" Nothing {"Darb", "Smarba"}

Ayırıcı dizisi

Her ayırıcı öğesi, tek bir karakterden oluşan ayrı bir sınırlayıcı tanımlar.

separatorBağımsız değişken karakter içermiyorsa null veya içermiyorsa, yöntem boşluk karakterlerini sınırlayıcılar olarak değerlendirir. Boşluk karakterleri Unicode standardı tarafından tanımlanır ve Char.IsWhiteSpace yöntemi true bir boşluk karakteri geçirilse döndürülür.

String. Split (Char []) ve derleyici aşırı yükleme çözünürlüğü

Bu aşırı yüklemesi için tek parametre String.Split bir karakter dizisi olsa da, aşağıdaki örnekte gösterildiği gibi tek bir karakterle çağırabilirsiniz.

string value = "This is a short string.";
char delimiter = 's';
string[] substrings = value.Split(delimiter);
foreach (var substring in substrings)
    Console.WriteLine(substring);

// The example displays the following output:
//     Thi
//      i
//      a
//     hort
//     tring.

separatorParametresi özniteliği ile donatılmış olduğundan ParamArrayAttribute , derleyiciler tek bir karakteri tek öğeli karakter dizisi olarak yorumlayacak. Bu bir parametre içeren diğer aşırı yüklemeler için bu durum değildir String.Split separator ; Bu aşırı yüklemeleri bağımsız değişken olarak bir karakter dizisi olarak açıkça geçirmeniz gerekir separator .

Karşılaştırma ayrıntıları

Split(Char[])Yöntemi, bu dizedeki, dizideki bir veya daha fazla karakterle ayrılmış olan alt dizeleri ayıklar separator ve bu alt dizeleri bir dizinin öğeleri olarak döndürür.

Split(Char[])Yöntemi, büyük/küçük harfe duyarlı sıra sıralama kuralları kullanarak karşılaştırmalar gerçekleştirerek sınırlayıcıları arar. Sözcük, dize ve sıralı sıralamalar hakkında daha fazla bilgi için bkz System.Globalization.CompareOptions . sabit listesi.

Performansla ilgili önemli noktalar

SplitYöntemler döndürülen dizi nesnesi için bellek ayırır ve String her dizi öğesi için bir nesnesi. Uygulamanız en iyi performansı gerektiriyorsa veya uygulamanızda bellek ayırmayı yönetmek kritik öneme sahip ise, IndexOf veya yöntemini kullanmayı düşünün IndexOfAny . Ayrıca, Compare bir dize içinde bir alt dizeyi bulmak için yöntemini kullanma seçeneğiniz de vardır.

Bir dizeyi bir ayırıcı karakterde ayırmak için, IndexOf veya IndexOfAny yöntemini kullanarak dizedeki bir ayırıcı karakter bulun. Bir dizeyi bir ayırıcı dizesinde ayırmak için, IndexOf veya IndexOfAny yöntemini kullanarak ayırıcı dizesinin ilk karakterini bulun. Sonra Compare Bu ilk karakterden sonraki karakterlerin ayırıcı dizesinin kalan karakterlerine eşit olup olmadığını anlamak için yöntemini kullanın.

Ayrıca, birden çok yöntem çağrısında dizeleri ayırmak için aynı karakter kümesi kullanılıyorsa Split , tek bir dizi oluşturmayı ve her yöntem çağrısında buna başvurmayı düşünün. Bu, her yöntem çağrısının ek yükünü önemli ölçüde azaltır.

Arayanlara Notlar

.NET Framework 3,5 ve önceki sürümlerde, Split(Char[]) yöntemi bir separator karakter içeren veya olmayan bir değer geçirtiyse, yöntem dizeyi kırpmak için yöntemden farklı bir null boşluk karakter kümesi kullanır Trim(Char[]) . .NET Framework 4 ' te başlayarak her iki yöntem de özdeş bir Unicode boşluk karakterleri kümesi kullanır.

Ayrıca bkz.

Şunlara uygulanır