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)	Bir giriş dizesini, oluşturucuda belirtilen normal ifade deseni tarafından tanımlanan konumlardaki bir alt dize dizisine Regex böler.
Split(String, Int32)	Bir giriş dizesini, oluşturucuda belirtilen normal bir ifade tarafından tanımlanan konumlarda bir alt dize dizisine Regex belirtilen en fazla sayıda böler.
Split(String, String)	Bir giriş dizesini normal ifade deseni tarafından tanımlanan konumlarda bir alt dize dizisine böler.
Split(String, Int32, Int32)	Bir giriş dizesini, oluşturucuda belirtilen normal bir ifade tarafından tanımlanan konumlarda bir alt dize dizisine Regex belirtilen en fazla sayıda böler. Normal ifade deseni araması, giriş dizesinde belirtilen karakter konumunda başlar.
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, 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)

Source:

Regex.Split.cs

Bir giriş dizesini, oluşturucuda belirtilen normal ifade deseni tarafından tanımlanan konumlardaki bir alt dize dizisine Regex 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 değeridir.

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 yöntemine String.Split(Char[]) benzer, ancak Regex.Split dizeyi bir karakter kümesi yerine normal bir ifade tarafından belirlenen sınırlayıcıya 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 çizgide 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 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 desenini \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 olur 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', ''

Bir ifadede Regex.Split yakalama parantezleri kullanılıyorsa, yakalanan tüm metinler sonuçta elde edilen dize dizisine eklenir. Örneğin, "plum-pear" dizesini yakalama parantezlerine yerleştirilen 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, yakalama parantezlerinin ilk kümesinde eşleşme bulunmazsa, ek yakalama parantezlerinden yakalanan metin döndürülen diziye dahil değildir. .NET Framework 2.0'dan başlayarak, yakalanan tüm metin de döndürülen diziye eklenir. Örneğin, aşağıdaki kod 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 parantez yakalama kümesi kısa çizgiyi, ikinci küme ise eğik çizgiyi yakalar. Örnek kod derlenip .NET Framework 1.0 veya 1.1 altında çalıştırılırsa, eğik çizgi karakterlerini dışlar; derlenip .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, Split(String) boş dize sınırlayıcısı her konumda bulunabileceğinden dizeyi tek karakterli dize dizisine böler. Örnek:

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 RegexMatchTimeoutException işleminin yürütme süresi oluşturucu tarafından Regex.Regex(String, RegexOptions, TimeSpan) belirtilen zaman aşımı aralığını aşarsa özel durum oluşturulur. Oluşturucuyu çağırdığınızda zaman aşımı aralığı ayarlamazsanız, işlem nesnenin oluşturulduğu uygulama etki alanı Regex için belirlenen zaman aşımı değerini aşarsa özel durum oluşturulur. Oluşturucu çağrısında Regex veya uygulama etki alanının özelliklerinde zaman aşımı tanımlanmadıysa veya zaman aşımı değeri ise Regex.InfiniteMatchTimeout, özel durum oluşturmaz

Ayrıca bkz.

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

Split(String, Int32)

Source:

Regex.Split.cs

Bir giriş dizesini, oluşturucuda belirtilen normal bir ifade tarafından tanımlanan konumlarda bir alt dize dizisine Regex 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 değeridir.

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

Birden çok eşleşme birbirine bitişikse veya başında veya sonunda inputbir eşleşme bulunursa ve bulunan eşleşme sayısı en az iki küçükse count, diziye boş bir dize eklenir. Başka bir ifadeyle, eşleşen alt dizelerin sayısının eşit countolup olmadığını belirlemek için bitişik eşleşmelerden veya giriş dizesinin başında veya sonundaki eşleşmelerden kaynaklanan boş dizeler sayılır. Aşağıdaki örnekte normal ifade /d+ , bir veya daha fazla ondalık basamak içeren bir giriş dizesini en fazla üç alt dizeye bölmek için kullanılır. Giriş dizesinin başlangıcı normal ifade deseni ile eşleştiğinden, ilk dizi öğesi öğesini içerir String.Empty, 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 dahil edilir. Ancak, yakalanan metin içeren dizi öğeleri, eşleşme sayısının ulaşıp ulaşmadığını countbelirlerken 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 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-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 dizelerin sayısının eşit countolup olmadığını belirlerken sayılmaz. Örneğin, aşağıdaki kodda normal ifade, bir tarih dizesindeki bir tarihin öğelerini ayıklamak için iki yakalama parantezi kümesi kullanır. İlk parantez yakalama kümesi kısa çizgiyi, ikinci küme ise eğik çizgiyi yakalar. Yöntemine yapılan Split(String, Int32) çağrı daha sonra döndürülen dizide en fazla iki öğe belirtir. Örnek kod derlenip .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. Derlenip .NET Framework 2.0 veya sonraki sürümleri altında çalıştırılırsa, yöntem üç öğeli bir 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, Split(String, Int32) boş dize sınırlayıcısı her konumda bulunabileceğinden 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 RegexMatchTimeoutException işleminin yürütme süresi oluşturucu tarafından Regex.Regex(String, RegexOptions, TimeSpan) belirtilen zaman aşımı aralığını aşarsa özel durum oluşturulur. Oluşturucuyu çağırdığınızda zaman aşımı aralığı ayarlamazsanız, işlem nesnenin oluşturulduğu uygulama etki alanı Regex için belirlenen zaman aşımı değerini aşarsa özel durum oluşturulur. Oluşturucu çağrısında Regex veya uygulama etki alanının özelliklerinde zaman aşımı tanımlanmadıysa veya zaman aşımı değeri ise Regex.InfiniteMatchTimeout, özel durum oluşturmaz

Ayrıca bkz.

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

Split(String, String)

Source:

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ştirecek normal ifade deseni.

Döndürülenler

String[]

Dize dizisi.

Özel durumlar

ArgumentException

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

ArgumentNullException

input veya pattern şeklindedir 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 yöntemine String.Split benzer, ancak Regex.Split dizeyi bir karakter kümesi yerine normal bir ifade tarafından belirlenen sınırlayıcıya böler. Dize input mümkün olduğunca çok kez bölünür. Dizede input bulunmazsapattern, dönüş değeri özgün input dize olan bir öğe içerir.

parametresi, pattern eşleşecek dizeyi sembolik 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öntemlere 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 birbirinin yanındaysa, 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 desenini \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 olur 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', ''

Bir ifadede Regex.Split yakalama parantezleri kullanılıyorsa, yakalanan tüm metinler sonuçta elde edilen dize dizisine dahil edilir. Örneğin, "erik-armut" dizesini yakalama parantezlerine yerleştirilen 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 değildir. .NET Framework 2.0'dan başlayarak, yakalanan tüm metin döndürülen diziye de eklenir. Örneğin, aşağıdaki kod 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 derlenip .NET Framework 1.0 veya 1.1 altında çalıştırılırsa, eğik çizgi karakterlerini dışlar; derlenip .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, Split boş dize sınırlayıcısı her konumda bulunabildiğinden dizeyi tek karakterli dize dizisine böler. Örnek:

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.

RegexMatchTimeoutException 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 özel durum oluşturulur. Uygulama etki alanının özelliklerinde zaman aşımı tanımlanmamışsa veya zaman aşımı değeri ise Regex.InfiniteMatchTimeoutö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 bir zaman aşımı değeri tanımlanmamışsa, yönteminin zaman aşımına geçmesini engelleyen değeri InfiniteMatchTimeoutkullanı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 yöntemidir Split(String, String, RegexOptions, TimeSpan).

Ayrıca bkz.

• Normal İfade Dili Öğeleri

Split(String, Int32, Int32)

Source:

Regex.Split.cs

Bir giriş dizesini, oluşturucuda belirtilen normal ifade tarafından tanımlanan konumlarda, belirtilen en fazla sayıda alt dize dizisine Regex böler. Normal ifade deseni için arama, 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

Giriş dizesinde aramanın başlayacağı karakter konumu.

Döndürülenler

String[]

Dize dizisi.

Özel durumlar

ArgumentNullException

input, null değeridir.

ArgumentOutOfRangeException

startatsıfırdan küçük veya uzunluğundan büyük.input

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 yöntemine String.Split benzer, ancak Regex.Split dizeyi bir karakter kümesi yerine normal bir ifade tarafından belirlenen bir sınırlayıcıya böler. parametresi, count dizenin bölündüğü input en fazla alt dize sayısını belirtir; son dize dizenin kesintisiz kalan kısmını içerir. count Sıfır değeri, mümkün olduğunca çok kez bölmenin varsayılan davranışını sağlar. parametresi, startat 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).

hakkında startatdaha fazla ayrıntı için öğesinin Açıklamalar bölümüne Match(String, Int32)bakın.

Dizedeki count+1 konumundan eşleşme bulunmazsa, yöntem dizeyi içeren tek öğeli input 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 küçükse count, diziye boş bir dize eklenir. Benzer şekilde, dizedeki ilk karakter olan konumunda bir eşleşme bulunursa startat, döndürülen dizinin ilk öğesi boş bir dizedir. Başka bir ifadeyle, eşleşen alt dize sayısının eşit countolup olmadığı belirlenirken bitişik eşleşmelerden kaynaklanan boş dizeler sayılır. Aşağıdaki örnekte, normal ifade \d+ bir dizedeki sayısal karakterlerin ilk alt dizesinin başlangıç konumunu bulmak ve ardından bu konumdan başlayarak dizeyi 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 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 dahil edilir. Ancak, yakalanan metin içeren dizi öğeleri eşleşme sayısının ulaşıp ulaşmadığı countbelirlenirken 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, yakalama parantezlerinin ilk kümesinde eşleşme bulunamazsa, ek yakalama parantezlerinden yakalanan metin döndürülen diziye dahil değildir. .NET Framework 2.0'dan başlayarak, yakalanan tüm metin döndürülen diziye de 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 parantezi kümesi kısa çizgiyi, ikinci küme ise dikey çubuğu yakalar. Örnek kod derlenip .NET Framework 1.0 veya 1.1 altında çalıştırılırsa, dikey çubuk karakterleri hariç tutar; derlenip .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, Split boş dize sınırlayıcısı her konumda bulunabildiğinden 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}

RegexMatchTimeoutException Bölme işleminin yürütme süresi oluşturucu tarafından Regex.Regex(String, RegexOptions, TimeSpan) belirtilen zaman aşımı aralığını aşarsa özel durum oluşturulur. Oluşturucuyu çağırdığınızda zaman aşımı aralığı ayarlamazsanız, işlem nesnenin oluşturulduğu uygulama etki alanı Regex için oluşturulan herhangi bir zaman aşımı değerini aşarsa özel durum oluşturulur. Oluşturucu çağrısında veya uygulama etki alanının özelliklerinde Regex hiçbir zaman aşımı tanımlanmamışsa veya zaman aşımı değeri ise Regex.InfiniteMatchTimeoutözel durum oluşturmaz

Ayrıca bkz.

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

Split(String, String, RegexOptions)

Source:

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ştirecek 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 pattern şeklindedir null.

ArgumentOutOfRangeException

options , değerlerin RegexOptions 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 yöntemine String.Split(Char[]) benzer, ancak Regex.Split dizeyi bir karakter kümesi yerine normal bir ifade tarafından belirlenen bir sınırlayıcıya 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 dize olan bir öğe içerir.

parametresi, pattern eşleşecek dizeyi sembolik 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öntemlere 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 birbirinin yanındaysa, 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, herhangi bir büyük veya küçük harf karakterdeki bir giriş dizesini 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 olur 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', ''

Bir ifadede Regex.Split yakalama parantezleri kullanılıyorsa, yakalanan tüm metinler sonuçta elde edilen dize dizisine dahil edilir. Örneğin, "erik-armut" dizesini yakalama parantezlerine yerleştirilen 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 değildir. .NET Framework 2.0'dan başlayarak, yakalanan tüm metin döndürülen diziye de eklenir. Örneğin, aşağıdaki kod 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 derlenip .NET Framework 1.0 veya 1.1 altında çalıştırılırsa, eğik çizgi karakterlerini dışlar; derlenip .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, Split boş dize sınırlayıcısı her konumda bulunabildiğinden dizeyi tek karakterli dize dizisine böler.

RegexMatchTimeoutException 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 özel durum oluşturulur. Uygulama etki alanının özelliklerinde zaman aşımı tanımlanmamışsa veya zaman aşımı değeri ise Regex.InfiniteMatchTimeoutö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 bir zaman aşımı değeri tanımlanmamışsa, yöntemin zaman aşımına girmesini engelleyen değeri InfiniteMatchTimeoutkullanı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 yöntemidir Split(String, String, RegexOptions, TimeSpan).

Ayrıca bkz.

• Normal İfade Dili Öğeleri

Split(String, String, RegexOptions, TimeSpan)

Source:

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ştirecek 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 InfiniteMatchTimeout yöntemin zaman aşımına neden olmaması gerektiğini belirtmek için.

Döndürülenler

String[]

Bir dize dizisi.

Özel durumlar

ArgumentException

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

ArgumentNullException

input veya pattern şeklindedir null.

ArgumentOutOfRangeException

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

-veya-

matchTimeout negatif, sıfır veya yaklaşık 24 günden 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 yöntemine String.Split(Char[]) benzer, ancak Regex.Split dizeyi bir karakter kümesi yerine normal bir ifade tarafından belirlenen sınırlayıcıya 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 dize olan bir öğe içerir.

parametresi, pattern eşleşecek dizeyi sembolik 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öntemlere 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 eşleşme bulunursa, döndürülen dizinin başına veya sonuna boş bir dize eklenir. Aşağıdaki örnek, herhangi bir büyük veya küçük harf alfabetik karakterde bir giriş dizesini bölmek için normal ifade desenini [a-z]+ kullanır. Dize eşleşen alfabetik karakterlerle başlayıp sona erdiğinden, döndürülen dizinin ilk ve son öğesinin değeri olur 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', ''

Bir ifadede Regex.Split yakalama parantezleri kullanılıyorsa, yakalanan tüm metinler sonuçta elde edilen dize dizisine eklenir. Örneğin, "plum-pear" dizesini yakalama parantezlerine yerleştirilen 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, yakalama parantezlerinin ilk kümesinde eşleşme bulunmazsa, ek yakalama parantezlerinden yakalanan metin döndürülen diziye dahil değildir. .NET Framework 2.0'dan başlayarak, yakalanan tüm metin de döndürülen diziye eklenir. Örneğin, aşağıdaki kod 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 parantez yakalama kümesi kısa çizgiyi, ikinci küme ise eğik çizgiyi yakalar. Örnek kod derlenip .NET Framework 1.0 veya 1.1 altında çalıştırılırsa, eğik çizgi karakterlerini dışlar; derlenip .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, Split boş dize sınırlayıcısı her konumda bulunabileceğinden dizeyi tek karakterli dize dizisine böler.

parametresi, matchTimeout desen eşleştirme yönteminin zaman aşımına uğramadan önce eşleşmeyi ne kadar süreyle bulmaya çalışılması gerektiğini belirtir. Zaman aşımı aralığı ayarlamak, aşırı geri izlemeyi kullanan normal ifadelerin, yakın eşleşmeler içeren girişi işlerken yanıt vermeyi durduracak şekilde görünmesini önler. 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 durum 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

parametresini matchTimeout iki saniye gibi uygun bir değere ayarlamanızı öneririz. belirterek InfiniteMatchTimeoutzaman 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şullarda devre dışı bırakmanız gerekir:

• 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şmeleri 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şme işlenirken aşırı geri izlenmeye neden olduğu bilinen bir dil öğesi içermediğinde.

Ayrıca bkz.

• Normal İfade Dili Öğeleri