Regex.Split Yöntem

Tanım

Ad Alanı:

System.Text.RegularExpressions

Bütünleştirilmiş Kod:

System.Text.RegularExpressions.dll

Bir giriş dizesini normal ifade eşleşmesi tarafından tanımlanan konumlarda bir alt dize dizisine böler.

Aşırı Yüklemeler

Split(String, String, RegexOptions, TimeSpan)	Bir giriş dizesini, belirtilen normal ifade deseni tarafından tanımlanan konumlarda bir alt dize dizisine böler. Ek parametreler, eşleşen işlemi değiştiren seçenekleri ve eşleşme bulunamazsa zaman aşımı aralığını belirtir.
Split(String, String, RegexOptions)	Bir giriş dizesini, belirtilen normal ifade deseni tarafından tanımlanan konumlarda bir alt dize dizisine böler. Belirtilen seçenekler eşleşen işlemi değiştirir.
Split(String, Int32, Int32)	Bir giriş dizesini, Regex oluşturucusunda belirtilen normal ifade tarafından tanımlanan konumlarda, bir alt dize dizisine belirtilen en fazla sayıda böler. Normal ifade deseni araması, giriş dizesinde belirtilen karakter konumunda başlar.
Split(String, String)	Bir giriş dizesini normal ifade deseni tarafından tanımlanan konumlarda bir alt dize dizisine böler.
Split(String)	Giriş dizesini, Regex oluşturucusunda belirtilen normal ifade deseni tarafından tanımlanan konumlardaki bir alt dize dizisine böler.
Split(String, Int32)	Bir giriş dizesini, Regex oluşturucusunda belirtilen normal ifade tarafından tanımlanan konumlarda, bir alt dize dizisine belirtilen en fazla sayıda böler.

Split(String, String, RegexOptions, TimeSpan)

Kaynak:

Regex.Split.cs

Bir giriş dizesini, belirtilen normal ifade deseni tarafından tanımlanan konumlarda bir alt dize dizisine böler. Ek parametreler, eşleşen işlemi değiştiren seçenekleri ve eşleşme bulunamazsa zaman aşımı aralığını belirtir.

public:
 static cli::array <System::String ^> ^ Split(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options, TimeSpan matchTimeout);

public static string[] Split (string input, string pattern, System.Text.RegularExpressions.RegexOptions options, TimeSpan matchTimeout);

static member Split : string * string * System.Text.RegularExpressions.RegexOptions * TimeSpan -> string[]

Public Shared Function Split (input As String, pattern As String, options As RegexOptions, matchTimeout As TimeSpan) As String()

Parametreler

input

String

Bölünecek dize.

pattern

String

Eşleşecek normal ifade deseni.

options

RegexOptions

Eşleştirme seçenekleri sağlayan numaralandırma değerlerinin bit düzeyinde birleşimi.

matchTimeout

TimeSpan

Zaman aşımı aralığı veya yöntemin zaman aşımına neden olmaması gerektiğini belirtmek için InfiniteMatchTimeout.

Döndürülenler

String[]

Dize dizisi.

Özel durumlar

ArgumentException

Normal ifade ayrıştırma hatası oluştu.

ArgumentNullException

input veya patternnull.

ArgumentOutOfRangeException

options, RegexOptions değerlerin bit düzeyinde geçerli bir bileşimi değildir.

-veya-

matchTimeout negatif, sıfır veya yaklaşık 24 günden uzundur.

RegexMatchTimeoutException

Zaman aşımı oluştu. Zaman aşımları hakkında daha fazla bilgi için Açıklamalar bölümüne bakın.

Açıklamalar

Regex.Split yöntemleri, String.Split(Char[]) yöntemine benzer, ancak Regex.Split dizeyi bir karakter kümesi yerine normal bir ifade tarafından belirlenen sınırlayıcıda böler. Dize mümkün olduğunca çok kez bölünür. Sınırlayıcı bulunmazsa, dönüş değeri özgün input dizesi olan bir öğe içerir.

pattern parametresi, eşleşecek dizeyi simgesel olarak tanımlayan normal ifade dili öğelerinden oluşur. Normal ifadeler hakkında daha fazla bilgi için bkz. .NET Normal İfadeleri ve Normal İfade Dili - Hızlı Başvuru.

Önemli

Statik Split yöntemlerine yapılan çağrılarda kullanılan derlenmiş normal ifadeler otomatik olarak önbelleğe alınır. Derlenmiş normal ifadelerin ömrünü kendiniz yönetmek için örnek Split yöntemlerini kullanın.

Birden çok eşleşme birbirine bitişikse, diziye boş bir dize eklenir. Örneğin, bir dizeyi tek bir kısa çizgiye bölmek, döndürülen dizinin iki bitişik kısa çizginin bulunduğu konuma boş bir dize eklemesine neden olur.

Giriş dizesinin başında veya sonunda bir eşleşme bulunursa, döndürülen dizinin başına veya sonuna boş bir dize eklenir. Aşağıdaki örnekte, giriş dizesini herhangi bir büyük veya küçük harf alfabetik karakterde bölmek için normal ifade deseni [a-z]+ kullanılır. Dize, eşleşen alfabetik karakterlerle başlayıp sona erdiğinden, döndürülen dizinin ilk ve son öğesinin değeri String.Empty.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "[a-z]+";
      string input = "Abc1234Def5678Ghi9012Jklm";
      string[] result = Regex.Split(input, pattern, 
                                    RegexOptions.IgnoreCase,
                                    TimeSpan.FromMilliseconds(500));
      for (int ctr = 0; ctr < result.Length; ctr++) {
         Console.Write("'{0}'", result[ctr]);
         if (ctr < result.Length - 1) 
            Console.Write(", ");
      }
      Console.WriteLine();
   }
}
// The example displays the following output:
//       '', '1234', '5678', '9012', ''

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "[a-z]+"
      Dim input As String = "Abc1234Def5678Ghi9012Jklm"
      Dim result() As String = Regex.Split(input, pattern, 
                                           RegexOptions.IgnoreCase,
                                           TimeSpan.FromMilliseconds(500))
      For ctr As Integer = 0 To result.Length - 1
         Console.Write("'{0}'", result(ctr))
         If ctr < result.Length - 1 Then Console.Write(", ")
      Next
      Console.WriteLine()
   End Sub               
End Module
' The example displays the following output:
'       '', '1234', '5678', '9012', ''

Yakalama parantezleri bir Regex.Split ifadesinde kullanılıyorsa, yakalanan tüm metinler sonuçta elde edilen dize dizisine eklenir. Örneğin, "plum-pear" dizesini yakalama parantezleri içine yerleştirilmiş bir kısa çizgiye bölerseniz, döndürülen dizi kısa çizgi içeren bir dize öğesi içerir.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "plum-pear";
      string pattern = "(-)";

      string[] substrings = Regex.Split(input, pattern);    // Split on hyphens
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// The example displays the following output:
//    'plum'
//    '-'
//    'pear'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "plum-pear"
      Dim pattern As String = "(-)" 
      
      Dim substrings() As String = Regex.Split(input, pattern)    ' Split on hyphens.
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub
End Module
' The method writes the following to the console:
'    'plum'
'    '-'
'    'pear'

Ancak, normal ifade deseni birden çok yakalama parantezi kümesi içerdiğinde, bu yöntemin davranışı .NET Framework sürümüne bağlıdır. .NET Framework 1.0 ve 1.1'de, ilk yakalama parantezleri kümesinde eşleşme bulunmazsa, ek yakalama parantezlerinden yakalanan metin döndürülen diziye dahil edilmez. .NET Framework 2.0'dan başlayarak, yakalanan tüm metinler de döndürülen diziye eklenir. Örneğin, aşağıdaki kod bir tarih dizesinden tarih sınırlayıcıları da dahil olmak üzere bir tarihin öğelerini ayıklamak için iki yakalama parantezi kümesi kullanır. İlk yakalama parantez kümesi kısa çizgiyi, ikinci küme ise eğik çizgiyi yakalar. Örnek kod derlenir ve .NET Framework 1.0 veya 1.1 altında çalıştırılırsa, eğik çizgi karakterleri hariç tutulur; derlenir ve .NET Framework 2.0 veya sonraki sürümleri altında çalıştırılırsa, bunları içerir.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = @"07/14/2007";   
      string pattern = @"(-)|(/)";

      foreach (string result in Regex.Split(input, pattern)) 
      {
         Console.WriteLine("'{0}'", result);
      }
   }
}
// In .NET 1.0 and 1.1, the method returns an array of
// 3 elements, as follows:
//    '07'
//    '14'
//    '2007'
//
// In .NET 2.0 and later, the method returns an array of
// 5 elements, as follows:
//    '07'
//    '/'
//    '14'
//    '/'
//    '2007'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "07/14/2007"   
      Dim pattern As String = "(-)|(/)"
      For Each result As String In Regex.Split(input, pattern) 
         Console.WriteLine("'{0}'", result)
      Next
   End Sub
End Module
' In .NET 1.0 and 1.1, the method returns an array of
' 3 elements, as follows:
'    '07'
'    '14'
'    '2007'
'
' In .NET 2.0 and later, the method returns an array of
' 5 elements, as follows:
'    '07'
'    '/'
'    '14'
'    '/'
'    '2007'

Normal ifade boş dizeyle eşleşebiliyorsa, boş dize sınırlayıcısı her konumda bulunabildiğinden Split dizeyi tek karakterli dize dizisine böler.

matchTimeout parametresi, bir desen eşleştirme yönteminin zaman aşımına uğramadan önce eşleşmeyi ne kadar süreyle bulmaya çalışması gerektiğini belirtir. Zaman aşımı aralığı ayarlamak, aşırı geri izleme kullanan normal ifadelerin, yakın eşleşmeler içeren girişleri işlerken yanıt vermeyi durdurmak için görünmesini engeller. Daha fazla bilgi için bkz. Normal İfadeler ve Geri İzlemeiçin En İyi Yöntemler. Bu zaman aralığında eşleşme bulunmazsa, yöntem bir RegexMatchTimeoutException özel durumu oluşturur. matchTimeout, yöntemin yürütüldiği uygulama etki alanı için tanımlanan varsayılan zaman aşımı değerlerini geçersiz kılar.

Arayanlara Notlar

matchTimeout parametresini iki saniye gibi uygun bir değere ayarlamanızı öneririz. InfiniteMatchTimeoutbelirterek zaman aşımlarını devre dışı bırakırsanız, normal ifade altyapısı biraz daha iyi performans sunar. Ancak, zaman aşımlarını yalnızca aşağıdaki koşullar altında devre dışı bırakmalısınız:

• Normal bir ifade tarafından işlenen giriş bilinen ve güvenilen bir kaynaktan türetildiğinde veya statik metinden oluştuğunda. Bu, kullanıcılar tarafından dinamik olarak giriş yapılan metinleri dışlar.

• Normal ifade deseni, eşleşmeleri, eşleşme olmayanları ve yakın eşleşmeleri verimli bir şekilde işlediğinden emin olmak için kapsamlı bir şekilde test edildiğinde.

• Normal ifade deseni, yakın bir eşleşmeyi işlerken aşırı geri dönüşe neden olduğu bilinen bir dil öğesi içermediğinde.

Ayrıca bkz.

• Normal İfade Dili Öğeleri

Split(String, String, RegexOptions)

Kaynak:

Regex.Split.cs

Bir giriş dizesini, belirtilen normal ifade deseni tarafından tanımlanan konumlarda bir alt dize dizisine böler. Belirtilen seçenekler eşleşen işlemi değiştirir.

public:
 static cli::array <System::String ^> ^ Split(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options);

public static string[] Split (string input, string pattern, System.Text.RegularExpressions.RegexOptions options);

static member Split : string * string * System.Text.RegularExpressions.RegexOptions -> string[]

Public Shared Function Split (input As String, pattern As String, options As RegexOptions) As String()

Parametreler

input

String

Bölünecek dize.

pattern

String

Eşleşecek normal ifade deseni.

options

RegexOptions

Eşleştirme seçenekleri sağlayan numaralandırma değerlerinin bit düzeyinde birleşimi.

Döndürülenler

String[]

Dize dizisi.

Özel durumlar

ArgumentException

Normal ifade ayrıştırma hatası oluştu.

ArgumentNullException

input veya patternnull.

ArgumentOutOfRangeException

options, RegexOptions değerlerin bit düzeyinde geçerli bir bileşimi değildir.

RegexMatchTimeoutException

Zaman aşımı oluştu. Zaman aşımları hakkında daha fazla bilgi için Açıklamalar bölümüne bakın.

Açıklamalar

Regex.Split yöntemleri, String.Split(Char[]) yöntemine benzer, ancak Regex.Split dizeyi bir karakter kümesi yerine normal bir ifade tarafından belirlenen sınırlayıcıda böler. Dize mümkün olduğunca çok kez bölünür. Sınırlayıcı bulunmazsa, dönüş değeri özgün input dizesi olan bir öğe içerir.

pattern parametresi, eşleşecek dizeyi simgesel olarak tanımlayan normal ifade dili öğelerinden oluşur. Normal ifadeler hakkında daha fazla bilgi için bkz. .NET Normal İfadeleri ve Normal İfade Dili - Hızlı Başvuru.

Önemli

Statik Split yöntemlerine yapılan çağrılarda kullanılan derlenmiş normal ifadeler otomatik olarak önbelleğe alınır. Derlenmiş normal ifadelerin ömrünü kendiniz yönetmek için örnek Split yöntemlerini kullanın.

Birden çok eşleşme birbirine bitişikse, diziye boş bir dize eklenir. Örneğin, bir dizeyi tek bir kısa çizgiye bölmek, döndürülen dizinin iki bitişik kısa çizginin bulunduğu konuma boş bir dize eklemesine neden olur.

Giriş dizesinin başında veya sonunda bir eşleşme bulunursa, döndürülen dizinin başına veya sonuna boş bir dize eklenir. Aşağıdaki örnekte, giriş dizesini herhangi bir büyük veya küçük harf alfabetik karakterde bölmek için normal ifade deseni [a-z]+ kullanılır. Dize, eşleşen alfabetik karakterlerle başlayıp sona erdiğinden, döndürülen dizinin ilk ve son öğesinin değeri String.Empty.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "[a-z]+";
      string input = "Abc1234Def5678Ghi9012Jklm";
      string[] result = Regex.Split(input, pattern, 
                                    RegexOptions.IgnoreCase);
      for (int ctr = 0; ctr < result.Length; ctr++) {
         Console.Write("'{0}'", result[ctr]);
         if (ctr < result.Length - 1) 
            Console.Write(", ");
      }
      Console.WriteLine();
   }
}
// The example displays the following output:
//       '', '1234', '5678', '9012', ''

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "[a-z]+"
      Dim input As String = "Abc1234Def5678Ghi9012Jklm"
      Dim result() As String = Regex.Split(input, pattern, 
                                           RegexOptions.IgnoreCase)
      For ctr As Integer = 0 To result.Length - 1
         Console.Write("'{0}'", result(ctr))
         If ctr < result.Length - 1 Then Console.Write(", ")
      Next
      Console.WriteLine()
   End Sub               
End Module
' The example displays the following output:
'       '', '1234', '5678', '9012', ''

Yakalama parantezleri bir Regex.Split ifadesinde kullanılıyorsa, yakalanan tüm metinler sonuçta elde edilen dize dizisine eklenir. Örneğin, "plum-pear" dizesini yakalama parantezleri içine yerleştirilmiş bir kısa çizgiye bölerseniz, döndürülen dizi kısa çizgi içeren bir dize öğesi içerir.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "plum-pear";
      string pattern = "(-)";

      string[] substrings = Regex.Split(input, pattern);    // Split on hyphens
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// The example displays the following output:
//    'plum'
//    '-'
//    'pear'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "plum-pear"
      Dim pattern As String = "(-)" 
      
      Dim substrings() As String = Regex.Split(input, pattern)    ' Split on hyphens.
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub
End Module
' The method writes the following to the console:
'    'plum'
'    '-'
'    'pear'

Ancak, normal ifade deseni birden çok yakalama parantezi kümesi içerdiğinde, bu yöntemin davranışı .NET Framework sürümüne bağlıdır. .NET Framework 1.0 ve 1.1'de, ilk yakalama parantezleri kümesinde eşleşme bulunmazsa, ek yakalama parantezlerinden yakalanan metin döndürülen diziye dahil edilmez. .NET Framework 2.0'dan başlayarak, yakalanan tüm metinler de döndürülen diziye eklenir. Örneğin, aşağıdaki kod bir tarih dizesinden tarih sınırlayıcıları da dahil olmak üzere bir tarihin öğelerini ayıklamak için iki yakalama parantezi kümesi kullanır. İlk yakalama parantez kümesi kısa çizgiyi, ikinci küme ise eğik çizgiyi yakalar. Örnek kod derlenir ve .NET Framework 1.0 veya 1.1 altında çalıştırılırsa, eğik çizgi karakterleri hariç tutulur; derlenir ve .NET Framework 2.0 veya sonraki sürümleri altında çalıştırılırsa, bunları içerir.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = @"07/14/2007";   
      string pattern = @"(-)|(/)";

      foreach (string result in Regex.Split(input, pattern)) 
      {
         Console.WriteLine("'{0}'", result);
      }
   }
}
// In .NET 1.0 and 1.1, the method returns an array of
// 3 elements, as follows:
//    '07'
//    '14'
//    '2007'
//
// In .NET 2.0 and later, the method returns an array of
// 5 elements, as follows:
//    '07'
//    '/'
//    '14'
//    '/'
//    '2007'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "07/14/2007"   
      Dim pattern As String = "(-)|(/)"
      For Each result As String In Regex.Split(input, pattern) 
         Console.WriteLine("'{0}'", result)
      Next
   End Sub
End Module
' In .NET 1.0 and 1.1, the method returns an array of
' 3 elements, as follows:
'    '07'
'    '14'
'    '2007'
'
' In .NET 2.0 and later, the method returns an array of
' 5 elements, as follows:
'    '07'
'    '/'
'    '14'
'    '/'
'    '2007'

Normal ifade boş dizeyle eşleşebiliyorsa, boş dize sınırlayıcısı her konumda bulunabildiğinden Split dizeyi tek karakterli dize dizisine böler.

Bölme işleminin yürütme süresi yöntemin çağrıldığı uygulama etki alanı için belirtilen zaman aşımı aralığını aşarsa RegexMatchTimeoutException özel durumu oluşturulur. Uygulama etki alanının özelliklerinde zaman aşımı tanımlanmamışsa veya zaman aşımı değeri Regex.InfiniteMatchTimeoutise özel durum oluşturmaz.

Arayanlara Notlar

Bu yöntem, yönteminin çağrıldığı uygulama etki alanının varsayılan zaman aşımı değerine eşit bir aralıktan sonra zaman aşımına uğradı. Uygulama etki alanı için zaman aşımı değeri tanımlanmamışsa, yönteminin zaman aşımına girmesini engelleyen InfiniteMatchTimeoutdeğeri kullanılır. Desen eşleşmesinde metni bölmek için önerilen statik yöntem, zaman aşımı aralığını ayarlamanıza olanak tanıyan Split(String, String, RegexOptions, TimeSpan)yöntemidir.

Ayrıca bkz.

• Normal İfade Dili Öğeleri

Split(String, Int32, Int32)

Kaynak:

Regex.Split.cs

Bir giriş dizesini, Regex oluşturucusunda belirtilen normal ifade tarafından tanımlanan konumlarda, bir alt dize dizisine belirtilen en fazla sayıda böler. Normal ifade deseni araması, giriş dizesinde belirtilen karakter konumunda başlar.

public:
 cli::array <System::String ^> ^ Split(System::String ^ input, int count, int startat);

public string[] Split (string input, int count, int startat);

member this.Split : string * int * int -> string[]

Public Function Split (input As String, count As Integer, startat As Integer) As String()

Parametreler

input

String

Bölünecek dize.

count

Int32

Bölmenin en fazla kaç kez gerçekleşebileceği.

startat

Int32

Aramanın başlayacağı giriş dizesindeki karakter konumu.

Döndürülenler

String[]

Dize dizisi.

Özel durumlar

ArgumentNullException

input null.

ArgumentOutOfRangeException

startat sıfırdan küçük veya inputuzunluğundan büyük.

RegexMatchTimeoutException

Zaman aşımı oluştu. Zaman aşımları hakkında daha fazla bilgi için Açıklamalar bölümüne bakın.

Açıklamalar

Regex.Split yöntemleri, String.Split yöntemine benzer, ancak Regex.Split dizeyi bir karakter kümesi yerine normal bir ifade tarafından belirlenen sınırlayıcıda böler. count parametresi, input dizesinin bölündüğü en fazla alt dize sayısını belirtir; son dize, dizenin ayrıştırılmamış kalan kısmını içerir. sıfır count değeri, mümkün olduğunca çok kez bölmenin varsayılan davranışını sağlar. startat parametresi, ilk sınırlayıcı için aramanın başladığı noktayı tanımlar (bu, baştaki boşluğu atlamak için kullanılabilir).

startathakkında daha fazla ayrıntı için Match(String, Int32)'nin Açıklamalar bölümüne bakın.

Dizedeki count+1 konumundan eşleşme bulunmazsa, yöntem input dizesini içeren tek öğeli bir dizi döndürür. Bir veya daha fazla eşleşme bulunursa, döndürülen dizinin ilk öğesi, ilk karakterden eşleşmeden önce bir karaktere kadar olan dizenin ilk bölümünü içerir.

Birden çok eşleşme birbirine bitişikse ve bulunan eşleşme sayısı en az iki countise, diziye boş bir dize eklenir. Benzer şekilde, dizedeki ilk karakter olan startatiçinde bir eşleşme bulunursa, döndürülen dizinin ilk öğesi boş bir dizedir. Başka bir ifadeyle, eşleşen alt dize sayısının counteşit olup olmadığı belirlenirken bitişik eşleşmelerden kaynaklanan boş dizeler sayılır. Aşağıdaki örnekte, normal ifade \d+ bir dizedeki ilk sayısal karakterlerin başlangıç konumunu bulmak ve ardından dizeyi bu konumdan başlayarak en fazla üç kez bölmek için kullanılır. Normal ifade deseni giriş dizesinin başlangıcıyla eşleştiğinden, döndürülen dize dizisi boş bir dizeden, beş karakterli bir alfabetik dizeden ve dizenin geri kalanından oluşur.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\d+";
      Regex rgx = new Regex(pattern);
      string input = "123ABCDE456FGHIJ789KLMNO012PQRST";
      Match m = rgx.Match(input);
      if (m.Success) { 
         int startAt = m.Index;
         string[] result = rgx.Split(input, 3, startAt);
         for (int ctr = 0; ctr < result.Length; ctr++) {
            Console.Write("'{0}'", result[ctr]);
            if (ctr < result.Length - 1)
               Console.Write(", ");
         }
         Console.WriteLine();
      }
   }
}
// The example displays the following output:
//       '', 'ABCDE', 'FGHIJKL789MNOPQ012'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\d+"
      Dim rgx As New Regex(pattern)
      Dim input As String = "123ABCDE456FGHIJ789KLMNO012PQRST"
      Dim m As Match = rgx.Match(input)
      If m.Success Then 
         Dim startAt As Integer = m.Index
         Dim result() As String = rgx.Split(input, 3, startAt)
         For ctr As Integer = 0 To result.Length - 1
            Console.Write("'{0}'", result(ctr))
            If ctr < result.Length - 1 Then Console.Write(", ")
         Next
         Console.WriteLine()
      End If
   End Sub               
End Module
' The example displays the following output:
'       '', 'ABCDE', 'FGHIJKL789MNOPQ012'

Yakalama parantezleri normal bir ifadede kullanılıyorsa, yakalanan tüm metinler bölünmüş dize dizisine eklenir. Ancak, yakalanan metin içeren dizi öğeleri, eşleşme sayısının countulaşıp ulaşmadığını belirlerken sayılmaz. Örneğin, '"apple-apricot-plum-pear-pomegranate-pineapple-peach" dizesini dizedeki 15 karakterinden başlayarak en fazla dört alt dizeye bölmek, aşağıdaki kodda gösterildiği gibi yedi öğeli bir diziyle sonuçlanıyor.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "(-)";
      string input = "apple-apricot-plum-pear-pomegranate-pineapple-peach";

      // Split on hyphens from 15th character on
      Regex regex = new Regex(pattern);    
      // Split on hyphens from 15th character on
      string[] substrings = regex.Split(input, 4, 15);
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// The method writes the following to the console:
//    'apple-apricot-plum'
//    '-'
//    'pear'
//    '-'
//    'pomegranate'
//    '-'
//    'pineapple-peach'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(-)"
      Dim input As String = "apple-apricot-plum-pear-pomegranate-pineapple-peach"

      Dim regex As Regex = New Regex(pattern)    
      ' Split on hyphens from 15th character on
      Dim substrings() As String = regex.Split(input, 4, 15)
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub  
End Module
' The example displays the following output:
'    'apple-apricot-plum'
'    '-'
'    'pear'
'    '-'
'    'pomegranate'
'    '-'
'    'pineapple-peach'

Ancak, normal ifade deseni birden çok yakalama parantezi kümesi içerdiğinde, bu yöntemin davranışı .NET Framework sürümüne bağlıdır. .NET Framework 1.0 ve 1.1'de, ilk yakalama parantezleri kümesinde eşleşme bulunmazsa, ek yakalama parantezlerinden yakalanan metin döndürülen diziye dahil edilmez. .NET Framework 2.0'dan başlayarak, yakalanan tüm metinler de döndürülen diziye eklenir. Örneğin, aşağıdaki kod dizedeki tek tek sözcükleri ayıklamak için iki yakalama parantezi kümesi kullanır. İlk yakalama parantez kümesi kısa çizgiyi, ikinci küme ise dikey çubuğu yakalar. Örnek kod derlenir ve .NET Framework 1.0 veya 1.1 altında çalıştırılırsa, dikey çubuk karakterleri dışlar; derlenir ve .NET Framework 2.0 veya sonraki sürümleri altında çalıştırılırsa, bunları içerir.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "(-)|([|])";     // possible delimiters found in string
      string input = "apple|apricot|plum|pear|pomegranate|pineapple|peach";

      Regex regex = new Regex(pattern);    
      // Split on delimiters from 15th character on
      string[] substrings = regex.Split(input, 4, 15);
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// In .NET 2.0 and later, the method returns an array of
// 7 elements, as follows:
//    apple|apricot|plum'
//    '|'
//    'pear'
//    '|'
//    'pomegranate'
//    '|'
//    'pineapple|peach'
// In .NET 1.0 and 1.1, the method returns an array of
// 4 elements, as follows:
//    'apple|apricot|plum'
//    'pear'
//    'pomegranate'
//    'pineapple|peach'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(-)|([|])"   ' possible delimiters found in string
      Dim input As String = "apple|apricot|plum|pear|pomegranate|pineapple|peach"

      Dim regex As Regex = New Regex(pattern)    
      ' Split on delimiters from 15th character on
      Dim substrings() As String = regex.Split(input, 4, 15)
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub
End Module
' In .NET 2.0, the method returns an array of
' 7 elements, as follows:
'    apple|apricot|plum'
'    '|'
'    'pear'
'    '|'
'    'pomegranate'
'    '|'
'    'pineapple|peach'
' In .NET 1.0 and 1.1, the method returns an array of
' 4 elements, as follows:
'    'apple|apricot|plum'
'    'pear'
'    'pomegranate'
'    'pineapple|peach'

Normal ifade boş dizeyle eşleşebiliyorsa, boş dize sınırlayıcısı her konumda bulunabildiğinden Split dizeyi tek karakterli dize dizisine böler. Aşağıdaki örnek, "a" karakterinden başlayarak "characters" dizesini giriş dizesinin içerdiği sayıda öğeye böler. Null dize giriş dizesinin sonuyla eşleştiğinden, döndürülen dizinin sonuna bir null dize eklenir.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "characters";
      Regex regex = new Regex("");
      string[] substrings = regex.Split(input, input.Length, input.IndexOf("a"));
      Console.Write("{");
      for(int ctr = 0; ctr < substrings.Length; ctr++)
      {
         Console.Write(substrings[ctr]);
         if (ctr < substrings.Length - 1)
            Console.Write(", ");
      }
      Console.WriteLine("}");
   }
}
// The example displays the following output:   
//    {, c, h, a, r, a, c, t, e, rs}

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "characters"
      Dim regex As New Regex("")
      Dim substrings() As String = regex.Split(input, input.Length, _
                                               input.IndexOf("a"))
      Console.Write("{")
      For ctr As Integer = 0 to substrings.Length - 1
         Console.Write(substrings(ctr))
         If ctr < substrings.Length - 1 Then Console.Write(", ")
      Next
      Console.WriteLine("}")
   End Sub
End Module
' The example produces the following output:   
'    {, c, h, a, r, a, c, t, e, rs}

Bölme işleminin yürütme süresi Regex.Regex(String, RegexOptions, TimeSpan) oluşturucu tarafından belirtilen zaman aşımı aralığını aşarsa RegexMatchTimeoutException özel durumu oluşturulur. Oluşturucuyu çağırdığınızda zaman aşımı aralığı ayarlamazsanız, işlem Regex nesnesinin oluşturulduğu uygulama etki alanı için belirlenen zaman aşımı değerini aşarsa özel durum oluşturulur. Regex oluşturucu çağrısında veya uygulama etki alanının özelliklerinde zaman aşımı tanımlanmadıysa veya zaman aşımı değeri Regex.InfiniteMatchTimeoutise, özel durum oluşturmaz

Ayrıca bkz.

• Normal İfade Dilini - Hızlı Başvuru

Split(String, String)

Kaynak:

Regex.Split.cs

Bir giriş dizesini normal ifade deseni tarafından tanımlanan konumlarda bir alt dize dizisine böler.

public:
 static cli::array <System::String ^> ^ Split(System::String ^ input, System::String ^ pattern);

public static string[] Split (string input, string pattern);

static member Split : string * string -> string[]

Public Shared Function Split (input As String, pattern As String) As String()

Parametreler

input

String

Bölünecek dize.

pattern

String

Eşleşecek normal ifade deseni.

Döndürülenler

String[]

Dize dizisi.

Özel durumlar

ArgumentException

Normal ifade ayrıştırma hatası oluştu.

ArgumentNullException

input veya patternnull.

RegexMatchTimeoutException

Zaman aşımı oluştu. Zaman aşımları hakkında daha fazla bilgi için Açıklamalar bölümüne bakın.

Açıklamalar

Regex.Split yöntemleri, String.Split yöntemine benzer, ancak Regex.Split dizeyi bir karakter kümesi yerine normal bir ifade tarafından belirlenen sınırlayıcıda böler. input dizesi mümkün olduğunca çok kez bölünür. input dizesinde pattern bulunamazsa, dönüş değeri özgün input dizesi olan bir öğe içerir.

pattern parametresi, eşleşecek dizeyi simgesel olarak tanımlayan normal ifade dili öğelerinden oluşur. Normal ifadeler hakkında daha fazla bilgi için bkz. .NET Normal İfadeleri ve Normal İfade Dili - Hızlı Başvuru.

Önemli

Statik Split yöntemlerine yapılan çağrılarda kullanılan derlenmiş normal ifadeler otomatik olarak önbelleğe alınır. Derlenmiş normal ifadelerin ömrünü kendiniz yönetmek için örnek Split yöntemlerini kullanın.

Birden çok eşleşme birbirine bitişikse, diziye boş bir dize eklenir. Örneğin, bir dizeyi tek bir kısa çizgiye bölmek, döndürülen dizinin aşağıdaki kodda gösterildiği gibi iki bitişik kısa çizginin bulunduğu konuma boş bir dize eklemesine neden olur.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "plum--pear";
      string pattern = "-";            // Split on hyphens
      
      string[] substrings = Regex.Split(input, pattern);
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// The method displays the following output:
//    'plum'
//    ''
//    'pear'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "plum--pear"
      Dim pattern As String = "-"          ' Split on hyphens
      
      Dim substrings() As String = Regex.Split(input, pattern)
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub  
End Module
' The example displays the following output:
'    'plum'
'    ''
'    'pear'

Giriş dizesinin başında veya sonunda bir eşleşme bulunursa, döndürülen dizinin başına veya sonuna boş bir dize eklenir. Aşağıdaki örnek, bir giriş dizesini sayısal karakterlere bölmek için normal ifade deseni \d+ kullanır. Dize eşleşen sayısal karakterlerle başlayıp sona erdiğinden, döndürülen dizinin ilk ve son öğesinin değeri String.Empty.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\d+";
      string input = "123ABCDE456FGHIJKL789MNOPQ012";
      string[] result = Regex.Split(input, pattern);
      for (int ctr = 0; ctr < result.Length; ctr++) {
         Console.Write("'{0}'", result[ctr]);
         if (ctr < result.Length - 1) 
            Console.Write(", ");
      }
      Console.WriteLine();
   }
}
// The example displays the following output:
//       '', 'ABCDE', 'FGHIJKL', 'MNOPQ', ''

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\d+"
      Dim input As String = "123ABCDE456FGHIJKL789MNOPQ012"
      Dim result() As String = Regex.Split(input, pattern)
      For ctr As Integer = 0 To result.Length - 1
         Console.Write("'{0}'", result(ctr))
         If ctr < result.Length - 1 Then Console.Write(", ")
      Next
      Console.WriteLine()
   End Sub               
End Module
' The example displays the following output:
'       '', 'ABCDE', 'FGHIJKL', 'MNOPQ', ''

Yakalama parantezleri bir Regex.Split ifadesinde kullanılıyorsa, yakalanan tüm metinler sonuçta elde edilen dize dizisine eklenir. Örneğin, "plum-pear" dizesini yakalama parantezleri içine yerleştirilmiş bir kısa çizgiye bölerseniz, döndürülen dizi kısa çizgi içeren bir dize öğesi içerir.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "plum-pear";
      string pattern = "(-)";

      string[] substrings = Regex.Split(input, pattern);    // Split on hyphens
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// The example displays the following output:
//    'plum'
//    '-'
//    'pear'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "plum-pear"
      Dim pattern As String = "(-)" 
      
      Dim substrings() As String = Regex.Split(input, pattern)    ' Split on hyphens.
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub
End Module
' The method writes the following to the console:
'    'plum'
'    '-'
'    'pear'

Ancak, normal ifade deseni birden çok yakalama parantezi kümesi içerdiğinde, bu yöntemin davranışı .NET Framework sürümüne bağlıdır. .NET Framework 1.0 ve 1.1'de, ilk yakalama parantezleri kümesinde eşleşme bulunmazsa, ek yakalama parantezlerinden yakalanan metin döndürülen diziye dahil edilmez. .NET Framework 2.0'dan başlayarak, yakalanan tüm metinler de döndürülen diziye eklenir. Örneğin, aşağıdaki kod bir tarih dizesinden tarih sınırlayıcıları da dahil olmak üzere bir tarihin öğelerini ayıklamak için iki yakalama parantezi kümesi kullanır. İlk yakalama parantez kümesi kısa çizgiyi, ikinci küme ise eğik çizgiyi yakalar. Örnek kod derlenir ve .NET Framework 1.0 veya 1.1 altında çalıştırılırsa, eğik çizgi karakterleri hariç tutulur; derlenir ve .NET Framework 2.0 veya sonraki sürümleri altında çalıştırılırsa, bunları içerir.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = @"07/14/2007";   
      string pattern = @"(-)|(/)";

      foreach (string result in Regex.Split(input, pattern)) 
      {
         Console.WriteLine("'{0}'", result);
      }
   }
}
// In .NET 1.0 and 1.1, the method returns an array of
// 3 elements, as follows:
//    '07'
//    '14'
//    '2007'
//
// In .NET 2.0 and later, the method returns an array of
// 5 elements, as follows:
//    '07'
//    '/'
//    '14'
//    '/'
//    '2007'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "07/14/2007"   
      Dim pattern As String = "(-)|(/)"
      For Each result As String In Regex.Split(input, pattern) 
         Console.WriteLine("'{0}'", result)
      Next
   End Sub
End Module
' In .NET 1.0 and 1.1, the method returns an array of
' 3 elements, as follows:
'    '07'
'    '14'
'    '2007'
'
' In .NET 2.0 and later, the method returns an array of
' 5 elements, as follows:
'    '07'
'    '/'
'    '14'
'    '/'
'    '2007'

Normal ifade boş dizeyle eşleşebiliyorsa, boş dize sınırlayıcısı her konumda bulunabildiğinden Split dizeyi tek karakterli dize dizisine böler. Mesela:

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "characters";
      string[] substrings = Regex.Split(input, "");
      Console.Write("{");
      for(int ctr = 0; ctr < substrings.Length; ctr++)
      {
         Console.Write("'{0}'", substrings[ctr]);
         if (ctr < substrings.Length - 1)
            Console.Write(", ");
      }
      Console.WriteLine("}");
   }
}
// The example produces the following output:   
//    {'', 'c', 'h', 'a', 'r', 'a', 'c', 't', 'e', 'r', 's', ''}

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "characters"
      Dim substrings() As String = Regex.Split(input, "")
      Console.Write("{")
      For ctr As Integer = 0 to substrings.Length - 1
         Console.Write("'{0}'", substrings(ctr))
         If ctr < substrings.Length - 1 Then Console.Write(", ")
      Next
      Console.WriteLine("}")
   End Sub
End Module
' The example produces the following output:   
'    {'', 'c', 'h', 'a', 'r', 'a', 'c', 't', 'e', 'r', 's', ''}

Döndürülen dizinin dizinin başında ve sonunda boş bir dize de içerdiğini unutmayın.

Bölme işleminin yürütme süresi yöntemin çağrıldığı uygulama etki alanı için belirtilen zaman aşımı aralığını aşarsa RegexMatchTimeoutException özel durumu oluşturulur. Uygulama etki alanının özelliklerinde zaman aşımı tanımlanmamışsa veya zaman aşımı değeri Regex.InfiniteMatchTimeoutise özel durum oluşturmaz.

Arayanlara Notlar

Bu yöntem, yönteminin çağrıldığı uygulama etki alanının varsayılan zaman aşımı değerine eşit bir aralıktan sonra zaman aşımına uğradı. Uygulama etki alanı için zaman aşımı değeri tanımlanmamışsa, yönteminin zaman aşımına girmesini engelleyen InfiniteMatchTimeoutdeğeri kullanılır. Desen eşleşmesinde metni bölmek için önerilen statik yöntem, zaman aşımı aralığını ayarlamanıza olanak tanıyan Split(String, String, RegexOptions, TimeSpan)yöntemidir.

Ayrıca bkz.

• Normal İfade Dili Öğeleri

Split(String)

Kaynak:

Regex.Split.cs

Giriş dizesini, Regex oluşturucusunda belirtilen normal ifade deseni tarafından tanımlanan konumlardaki bir alt dize dizisine böler.

public:
 cli::array <System::String ^> ^ Split(System::String ^ input);

public string[] Split (string input);

member this.Split : string -> string[]

Public Function Split (input As String) As String()

Parametreler

input

String

Bölünecek dize.

Döndürülenler

String[]

Dize dizisi.

Özel durumlar

ArgumentNullException

input null.

RegexMatchTimeoutException

Zaman aşımı oluştu. Zaman aşımları hakkında daha fazla bilgi için Açıklamalar bölümüne bakın.

Açıklamalar

Regex.Split yöntemleri, String.Split(Char[]) yöntemine benzer, ancak Regex.Split dizeyi bir karakter kümesi yerine normal bir ifade tarafından belirlenen sınırlayıcıda böler. Dize mümkün olduğunca çok kez bölünür. Sınırlayıcı bulunmazsa, dönüş değeri özgün giriş dizesi olan bir öğe içerir.

Birden çok eşleşme birbirine bitişikse, diziye boş bir dize eklenir. Örneğin, bir dizeyi tek bir kısa çizgiye bölmek, döndürülen dizinin aşağıdaki kodda gösterildiği gibi iki bitişik kısa çizginin bulunduğu konuma boş bir dize eklemesine neden olur.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      Regex regex = new Regex("-");         // Split on hyphens.
      string[] substrings = regex.Split("plum--pear");
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// The example displays the following output:
//    'plum'
//    ''
//    'pear'

Imports System.Text.RegularExpressions

Module RegexSplit
   Public Sub Main()
      Dim regex As Regex = New Regex("-")         ' Split on hyphens.
      Dim substrings() As String = regex.Split("plum--pear")
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub
End Module
' The example displays the following output:
'    'plum'
'    ''
'    'pear'

Giriş dizesinin başında veya sonunda bir eşleşme bulunursa, döndürülen dizinin başına veya sonuna boş bir dize eklenir. Aşağıdaki örnek, bir giriş dizesini sayısal karakterlere bölmek için normal ifade deseni \d+ kullanır. Dize eşleşen sayısal karakterlerle başlayıp sona erdiğinden, döndürülen dizinin ilk ve son öğesinin değeri String.Empty.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\d+";
      Regex rgx = new Regex(pattern);
      string input = "123ABCDE456FGHIJKL789MNOPQ012";
      
      string[] result = rgx.Split(input);
      for (int ctr = 0; ctr < result.Length; ctr++) {
         Console.Write("'{0}'", result[ctr]);
         if (ctr < result.Length - 1) 
            Console.Write(", ");
      }
      Console.WriteLine();
   }
}
// The example displays the following output:
//       '', 'ABCDE', 'FGHIJKL', 'MNOPQ', ''

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\d+"
      Dim rgx As New Regex(pattern)
      Dim input As String = "123ABCDE456FGHIJKL789MNOPQ012"
      
      Dim result() As String = rgx.Split(input)
      For ctr As Integer = 0 To result.Length - 1
         Console.Write("'{0}'", result(ctr))
         If ctr < result.Length - 1 Then Console.Write(", ")
      Next
      Console.WriteLine()
   End Sub               
End Module
' The example displays the following output:
'       '', 'ABCDE', 'FGHIJKL', 'MNOPQ', ''

Yakalama parantezleri bir Regex.Split ifadesinde kullanılıyorsa, yakalanan tüm metinler sonuçta elde edilen dize dizisine eklenir. Örneğin, "plum-pear" dizesini yakalama parantezleri içine yerleştirilmiş bir kısa çizgiye bölerseniz, döndürülen dizi kısa çizgi içeren bir dize öğesi içerir.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      Regex regex = new Regex("(-)");         // Split on hyphens.
      string[] substrings = regex.Split("plum-pear");
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// The example displays the following output:
//    'plum'
//    '-'
//    'pear'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim regex As Regex = New Regex("(-)")          ' Split on hyphens.
      Dim substrings() As String = regex.Split("plum-pear")
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub
End Module
' The example displays the following output:
'    'plum'
'    '-'
'    'pear'

Ancak, normal ifade deseni birden çok yakalama parantezi kümesi içerdiğinde, bu yöntemin davranışı .NET Framework sürümüne bağlıdır. .NET Framework 1.0 ve 1.1'de, ilk yakalama parantezleri kümesinde eşleşme bulunmazsa, ek yakalama parantezlerinden yakalanan metin döndürülen diziye dahil edilmez. .NET Framework 2.0'dan başlayarak, yakalanan tüm metinler de döndürülen diziye eklenir. Örneğin, aşağıdaki kod bir tarih dizesinden tarih sınırlayıcıları da dahil olmak üzere bir tarihin öğelerini ayıklamak için iki yakalama parantezi kümesi kullanır. İlk yakalama parantez kümesi kısa çizgiyi, ikinci küme ise eğik çizgiyi yakalar. Örnek kod derlenir ve .NET Framework 1.0 veya 1.1 altında çalıştırılırsa, eğik çizgi karakterleri hariç tutulur; derlenir ve .NET Framework 2.0 veya sonraki sürümleri altında çalıştırılırsa, bunları içerir.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = @"07/14/2007";   
      string pattern = @"(-)|(/)";
      Regex regex = new Regex(pattern);
      foreach (string result in regex.Split(input)) 
      {
         Console.WriteLine("'{0}'", result);
      }
   }
}
// Under .NET 1.0 and 1.1, the method returns an array of
// 3 elements, as follows:
//    '07'
//    '14'
//    '2007'
//
// Under .NET 2.0 and later, the method returns an array of
// 5 elements, as follows:
//    '07'
//    '/'
//    '14'
//    '/'
//    '2007'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "07/14/2007"   
      Dim pattern As String = "(-)|(/)"
      Dim regex As Regex = New Regex(pattern)
      For Each result As String In regex.Split(input) 
         Console.WriteLine("'{0}'", result)
      Next
   End Sub
End Module
' In .NET 1.0 and 1.1, the method returns an array of
' 3 elements, as follows:
'    '07'
'    '14'
'    '2007'
'
' In .NET 2.0 and later, the method returns an array of
' 5 elements, as follows:
'    '07'
'    '/'
'    '14'
'    '/'
'    '2007'

Normal ifade boş dizeyle eşleşebiliyorsa, boş dize sınırlayıcısı her konumda bulunabildiğinden Split(String) dizeyi tek karakterli dize dizisine böler. Mesela:

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "characters";
      Regex regex = new Regex("");
      string[] substrings = regex.Split(input);
      Console.Write("{");
      for(int ctr = 0; ctr < substrings.Length; ctr++)
      {
         Console.Write(substrings[ctr]);
         if (ctr < substrings.Length - 1)
            Console.Write(", ");
      }
      Console.WriteLine("}");
   }
}
// The example displays the following output:   
//    {, c, h, a, r, a, c, t, e, r, s, }

Imports System.Text.RegularExpressions

Module Main
   Public Sub Main()
      Dim input As String = "characters"
      Dim regex As New Regex("")
      Dim substrings() As String = regex.Split(input)
      Console.Write("{")
      For ctr As Integer = 0 to substrings.Length - 1
         Console.Write(substrings(ctr))
         If ctr < substrings.Length - 1 Then Console.Write(", ")
      Next
      Console.WriteLine("}")
   End Sub
End Module
' The example produces the following output:   
'    {, c, h, a, r, a, c, t, e, r, s, }

Döndürülen dizinin dizinin başında ve sonunda boş bir dize de içerdiğini unutmayın.

Bölme işleminin yürütme süresi Regex.Regex(String, RegexOptions, TimeSpan) oluşturucu tarafından belirtilen zaman aşımı aralığını aşarsa RegexMatchTimeoutException özel durumu oluşturulur. Oluşturucuyu çağırdığınızda zaman aşımı aralığı ayarlamazsanız, işlem Regex nesnesinin oluşturulduğu uygulama etki alanı için belirlenen zaman aşımı değerini aşarsa özel durum oluşturulur. Regex oluşturucu çağrısında veya uygulama etki alanının özelliklerinde zaman aşımı tanımlanmadıysa veya zaman aşımı değeri Regex.InfiniteMatchTimeoutise, özel durum oluşturmaz

Ayrıca bkz.

• Normal İfade Dilini - Hızlı Başvuru

Split(String, Int32)

Kaynak:

Regex.Split.cs

Bir giriş dizesini, Regex oluşturucusunda belirtilen normal ifade tarafından tanımlanan konumlarda, bir alt dize dizisine belirtilen en fazla sayıda böler.

public:
 cli::array <System::String ^> ^ Split(System::String ^ input, int count);

public string[] Split (string input, int count);

member this.Split : string * int -> string[]

Public Function Split (input As String, count As Integer) As String()

Parametreler

input

String

Bölünecek dize.

count

Int32

Bölmenin en fazla kaç kez gerçekleşebileceği.

Döndürülenler

String[]

Dize dizisi.

Özel durumlar

ArgumentNullException

input null.

RegexMatchTimeoutException

Zaman aşımı oluştu. Zaman aşımları hakkında daha fazla bilgi için Açıklamalar bölümüne bakın.

Açıklamalar

Regex.Split yöntemleri, String.Split yöntemine benzer, ancak Regex.Split dizeyi bir karakter kümesi yerine normal bir ifade tarafından belirlenen sınırlayıcıda böler. count parametresi, input dizesinin bölünebileceği en fazla alt dize sayısını belirtir; son dize, dizenin ayrıştırılmamış kalan kısmını içerir. sıfır count değeri, mümkün olduğunca çok kez bölmenin varsayılan davranışını sağlar.

Birden çok eşleşme birbiriyle bitişikse veya inputbaşında veya sonunda bir eşleşme bulunursa ve bulunan eşleşme sayısı counten az iki ise, diziye boş bir dize eklenir. Diğer bir ifadeyle, bitişik eşleşmelerden veya giriş dizesinin başında veya sonundaki eşleşmelerden kaynaklanan boş dizeler, eşleşen alt dize sayısının counteşit olup olmadığını belirlerken sayılır. Aşağıdaki örnekte, bir veya daha fazla ondalık basamak içeren bir giriş dizesini en fazla üç alt dizeye bölmek için normal ifade /d+ kullanılır. Giriş dizesinin başlangıcı normal ifade deseni ile eşleştiğinden, ilk dizi öğesi String.Emptyiçerir, ikincisi giriş dizesindeki ilk alfabetik karakter kümesini, üçüncüsü ise üçüncü eşleşmeyi izleyen dizenin geri kalanını içerir.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\d+";
      Regex rgx = new Regex(pattern);
      string input = "123ABCDE456FGHIJKL789MNOPQ012";
      
      string[] result = rgx.Split(input, 3);
      for (int ctr = 0; ctr < result.Length; ctr++) {
         Console.Write("'{0}'", result[ctr]);
         if (ctr < result.Length - 1) 
            Console.Write(", ");
      }
      Console.WriteLine();
   }
}
// The example displays the following output:
//       '', 'ABCDE', 'FGHIJKL789MNOPQ012'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\d+"
      Dim rgx As New Regex(pattern)
      Dim input As String = "123ABCDE456FGHIJKL789MNOPQ012"
      
      Dim result() As String = rgx.Split(input, 3)
      For ctr As Integer = 0 To result.Length - 1
         Console.Write("'{0}'", result(ctr))
         If ctr < result.Length - 1 Then Console.Write(", ")
      Next
      Console.WriteLine()
   End Sub               
End Module
' The example displays the following output:
'       '', 'ABCDE', 'FGHIJKL789MNOPQ012'

Yakalama parantezleri normal bir ifadede kullanılıyorsa, yakalanan tüm metinler bölünmüş dize dizisine eklenir. Ancak, yakalanan metin içeren dizi öğeleri, eşleşme sayısının countulaşıp ulaşmadığını belirlerken sayılmaz. Örneğin, "apple-apricot-plum-pear-banana" dizesini en fazla dört alt dizeye bölmek, aşağıdaki kodda gösterildiği gibi yedi öğeli bir diziye neden olur.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "(-)";
      string input = "apple-apricot-plum-pear-banana";
      Regex regex = new Regex(pattern);         // Split on hyphens.
      string[] substrings = regex.Split(input, 4);
      foreach (string match in substrings)
      {
         Console.WriteLine("'{0}'", match);
      }
   }
}
// The example displays the following output:
//       'apple'
//       '-'
//       'apricot'
//       '-'
//       'plum'
//       '-'
//       'pear-banana'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "(-)"
      Dim input As String = "apple-apricot-plum-pear-banana"
      Dim regex As Regex = New Regex(pattern)         ' Split on hyphens.
      Dim substrings() As String = regex.Split(input, 4)
      For Each match As String In substrings
         Console.WriteLine("'{0}'", match)
      Next
   End Sub
End Module
' The example displays the following output:
'    'apple'
'    '-'
'    'apricot'
'    '-'
'    'plum'
'    '-'
'    'pear-banana'

Ancak, normal ifade deseni birden çok yakalama parantezi kümesi içerdiğinde, bu yöntemin davranışı .NET Framework sürümüne bağlıdır. .NET Framework 1.0 ve 1.1'de, döndürülen diziye yalnızca ilk yakalama parantezleri kümesinden yakalanan metin eklenir. .NET Framework 2.0'dan başlayarak, yakalanan tüm metin döndürülen diziye eklenir. Ancak, döndürülen dizide yakalanan metin içeren öğeler, eşleşen alt dize sayısının counteşit olup olmadığı belirlenirken sayılmaz. Örneğin, aşağıdaki kodda normal ifade, tarih dizesindeki bir tarihin öğelerini ayıklamak için iki yakalama parantezi kümesi kullanır. İlk yakalama parantez kümesi kısa çizgiyi, ikinci küme ise eğik çizgiyi yakalar. daha sonra Split(String, Int32) yöntemine yapılan çağrı, döndürülen dizide en fazla iki öğe belirtir. Örnek kod derlenir ve .NET Framework 1.0 veya 1.1 altında çalıştırılırsa, yöntem iki öğeli bir dize dizisi döndürür. Derlenir ve .NET Framework 2.0 veya sonraki sürümleri altında çalıştırılırsa, yöntem üç öğeli dize dizisi döndürür.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = @"07/14/2007";   
      string pattern = @"(-)|(/)";
      Regex regex = new Regex(pattern);
      foreach (string result in regex.Split(input, 2)) 
      {
         Console.WriteLine("'{0}'", result);
      }
   }
}
// Under .NET 1.0 and 1.1, the method returns an array of
// 2 elements, as follows:
//    '07'
//    '14/2007'
//
// Under .NET 2.0 and later, the method returns an array of
// 3 elements, as follows:
//    '07'
//    '/'
//    '14/2007'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "07/14/2007"   
      Dim pattern As String = "(-)|(/)"
      Dim regex As Regex = New Regex(pattern)
      For Each result As String In regex.Split(input, 2) 
         Console.WriteLine("'{0}'", result)
      Next
   End Sub
End Module
' In .NET 1.0 and 1.1, the method returns an array of
' 2 elements, as follows:
'    '07'
'    '14/2007'
'
' In .NET 2.0 and later, the method returns an array of
' 3 elements, as follows:
'    '07'
'    '/'
'    '14/2007'

Normal ifade boş dizeyle eşleşebiliyorsa, boş dize sınırlayıcısı her konumda bulunabildiğinden Split(String, Int32) dizeyi tek karakterli dize dizisine böler. Aşağıdaki örnek, "characters" dizesini giriş dizesinde olduğu kadar çok öğeye böler. Null dize giriş dizesinin başlangıcıyla eşleştiğinden, döndürülen dizinin başına bir null dize eklenir. Bu, onuncu öğenin giriş dizesinin sonundaki iki karakterden oluşmasına neden olur.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "characters"
      Dim regex As New Regex("")
      Dim substrings() As String = regex.Split(input, input.Length)
      Console.Write("{")
      For ctr As Integer = 0 to substrings.Length - 1
         Console.Write(substrings(ctr))
         if ctr < substrings.Length - 1 Then Console.Write(", ")
      Next
      Console.WriteLine("}")
   End Sub
End Module
' The example displays the following output:   
'    {, c, h, a, r, a, c, t, e, rs}

Bölme işleminin yürütme süresi Regex.Regex(String, RegexOptions, TimeSpan) oluşturucu tarafından belirtilen zaman aşımı aralığını aşarsa RegexMatchTimeoutException özel durumu oluşturulur. Oluşturucuyu çağırdığınızda zaman aşımı aralığı ayarlamazsanız, işlem Regex nesnesinin oluşturulduğu uygulama etki alanı için belirlenen zaman aşımı değerini aşarsa özel durum oluşturulur. Regex oluşturucu çağrısında veya uygulama etki alanının özelliklerinde zaman aşımı tanımlanmadıysa veya zaman aşımı değeri Regex.InfiniteMatchTimeoutise, özel durum oluşturmaz

Ayrıca bkz.

• Normal İfade Dilini - Hızlı Başvuru