Regex Constructors

Bron:

Regex.cs

Bron:

Regex.cs

Bron:

Regex.cs

Bron:

Regex.cs

Bron:

Regex.cs

protected:
 Regex();

protected Regex();

Protected Sub New ()

Opmerkingen

Houd er rekening mee dat deze constructor is beveiligd; het kan alleen worden aangeroepen door klassen die zijn afgeleid van de Regex klasse.

Bron:

Regex.cs

Bron:

Regex.cs

Bron:

Regex.cs

Bron:

Regex.cs

Bron:

Regex.cs

public:
 Regex(System::String ^ pattern);

public Regex(string pattern);

new System.Text.RegularExpressions.Regex : string -> System.Text.RegularExpressions.Regex

Public Sub New (pattern As String)

Parameters

Uitzonderingen

Voorbeelden

In het volgende voorbeeld ziet u hoe u deze constructor gebruikt om een reguliere expressie te instantiëren die overeenkomt met een woord dat begint met de letters 'a' of 't'.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b[at]\w+";
      string text = "The threaded application ate up the thread pool as it executed.";
      MatchCollection matches;

      Regex defaultRegex = new Regex(pattern);
      // Get matches of pattern in text
      matches = defaultRegex.Matches(text);
      Console.WriteLine("Parsing '{0}'", text);
      // Iterate matches
      for (int ctr = 0; ctr < matches.Count; ctr++)
         Console.WriteLine("{0}. {1}", ctr, matches[ctr].Value);
   }
}
// The example displays the following output:
//       Parsing 'The threaded application ate up the thread pool as it executed.'
//       0. threaded
//       1. application
//       2. ate
//       3. the
//       4. thread
//       5. as

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b[at]\w+"
      Dim text As String = "The threaded application ate up the thread pool as it executed."
      Dim matches As MatchCollection

      Dim defaultRegex As New Regex(pattern)
      ' Get matches of pattern in text
      matches = defaultRegex.Matches(text)
      Console.WriteLine("Parsing '{0}'", text)
      ' Iterate matches
      For ctr As Integer = 0 to matches.Count - 1
         Console.WriteLine("{0}. {1}", ctr, matches(ctr).Value)
      Next
   End Sub
End Module
' The example displays the following output:
'       Parsing 'The threaded application ate up the thread pool as it executed.'
'       0. threaded
'       1. application
'       2. ate
'       3. the
'       4. thread
'       5. as

Houd er rekening mee dat het reguliere expressiepatroon niet overeenkomt met het woord 'The' aan het begin van de tekst, omdat vergelijkingen standaard hoofdlettergevoelig zijn. Zie de Regex(String, RegexOptions) constructor voor een voorbeeld van een niet-hoofdlettergevoelige vergelijking.

Opmerkingen

De pattern parameter bestaat uit reguliere expressietaalelementen die de tekenreeks symbolisch beschrijven die overeenkomen. Zie de onderwerpen .NET Reguliere expressies en Regular Expression Language - Quick Reference voor meer informatie over reguliere expressies.

Het aanroepen van de Regex(String) constructor is gelijk aan het aanroepen van de Regex(String, RegexOptions) constructor met een waarde voor None het options argument.

Een Regex object is onveranderbaar, wat betekent dat het alleen kan worden gebruikt voor het overeenkomstpatroon dat u definieert wanneer u het maakt. Het kan echter een willekeurig aantal keren worden gebruikt zonder opnieuw te worden gecompileerd.

Met deze constructor wordt een reguliere expressieobject geïnstitueerd waarmee een hoofdlettergevoelige overeenkomst wordt geprobeerd van alfabetische tekens die zijn gedefinieerd in pattern. Gebruik de Regex.Regex(String, RegexOptions) constructor voor een niet-hoofdlettergevoelige overeenkomst.

Notities voor bellers

Met deze constructor maakt u een Regex object dat gebruikmaakt van de standaardtime-outwaarde van het toepassingsdomein waarin het wordt gemaakt. Als er geen time-outwaarde is gedefinieerd voor het toepassingsdomein, gebruikt het Regex object de waarde InfiniteMatchTimeout, waardoor er geen time-out optreedt voor de bewerking. De aanbevolen constructor voor het maken van een Regex object is Regex(String, RegexOptions, TimeSpan), waarmee u het time-outinterval kunt instellen.

Zie ook

• Taalelementen voor reguliere expressies

Bron:

Regex.cs

Bron:

Regex.cs

Bron:

Regex.cs

Bron:

Regex.cs

Bron:

Regex.cs

protected:
 Regex(System::Runtime::Serialization::SerializationInfo ^ info, System::Runtime::Serialization::StreamingContext context);

[System.Obsolete("This API supports obsolete formatter-based serialization. It should not be called or extended by application code.", DiagnosticId="SYSLIB0051", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
protected Regex(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context);

protected Regex(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context);

[<System.Obsolete("This API supports obsolete formatter-based serialization. It should not be called or extended by application code.", DiagnosticId="SYSLIB0051", UrlFormat="https://aka.ms/dotnet-warnings/{0}")>]
new System.Text.RegularExpressions.Regex : System.Runtime.Serialization.SerializationInfo * System.Runtime.Serialization.StreamingContext -> System.Text.RegularExpressions.Regex

new System.Text.RegularExpressions.Regex : System.Runtime.Serialization.SerializationInfo * System.Runtime.Serialization.StreamingContext -> System.Text.RegularExpressions.Regex

Protected Sub New (info As SerializationInfo, context As StreamingContext)

Parameters

Kenmerken

ObsoleteAttribute

Uitzonderingen

Bron:

Regex.cs

Bron:

Regex.cs

Bron:

Regex.cs

Bron:

Regex.cs

Bron:

Regex.cs

public:
 Regex(System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options);

public Regex(string pattern, System.Text.RegularExpressions.RegexOptions options);

new System.Text.RegularExpressions.Regex : string * System.Text.RegularExpressions.RegexOptions -> System.Text.RegularExpressions.Regex

Public Sub New (pattern As String, options As RegexOptions)

Parameters

Uitzonderingen

Voorbeelden

In het volgende voorbeeld ziet u hoe u deze constructor gebruikt om een reguliere expressie te instantiëren die overeenkomt met een woord dat begint met de letters 'a' of 't'.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b[at]\w+";
      RegexOptions options = RegexOptions.IgnoreCase | RegexOptions.Compiled;
      string text = "The threaded application ate up the thread pool as it executed.";
      MatchCollection matches;

      Regex optionRegex = new Regex(pattern, options);
      Console.WriteLine("Parsing '{0}' with options {1}:", text, options.ToString());
      // Get matches of pattern in text
      matches = optionRegex.Matches(text);
      // Iterate matches
      for (int ctr = 0; ctr < matches.Count; ctr++)
         Console.WriteLine("{0}. {1}", ctr, matches[ctr].Value);
   }
}
// The example displays the following output:
//    Parsing 'The threaded application ate up the thread pool as it executed.'
//        with options IgnoreCase, Compiled:
//    0. The
//    1. threaded
//    2. application
//    3. ate
//    4. the
//    5. thread
//    6. as

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String = "\b[at]\w+"
      Dim options As RegexOptions = RegexOptions.IgnoreCase Or RegexOptions.Compiled
      Dim text As String = "The threaded application ate up the thread pool as it executed."
      Dim matches As MatchCollection

      Dim optionRegex As New Regex(pattern, options)
      Console.WriteLine("Parsing '{0}' with options {1}:", text, options.ToString())
      ' Get matches of pattern in text
      matches = optionRegex.Matches(text)
      ' Iterate matches   
      For ctr As Integer = 0 to matches.Count - 1
         Console.WriteLine("{0}. {1}", ctr, matches(ctr).Value)
      Next
   End Sub
End Module
' The example displays the following output:
'    Parsing 'The threaded application ate up the thread pool as it executed.'
'       with options IgnoreCase, Compiled:
'    0. The
'    1. threaded
'    2. application
'    3. ate
'    4. the
'    5. thread
'    6. as

Houd er rekening mee dat de overeenkomstverzameling het woord 'The' bevat dat de tekst begint, omdat de options parameter hoofdlettergevoelige vergelijkingen heeft gedefinieerd.

Opmerkingen

De pattern parameter bestaat uit reguliere expressietaalelementen die de tekenreeks symbolisch beschrijven die overeenkomen. Zie de onderwerpen .NET Reguliere expressies en Regular Expression Language - Quick Reference voor meer informatie over reguliere expressies.

Een Regex object is onveranderbaar, wat betekent dat het alleen kan worden gebruikt voor de overeenkomende parameters die u definieert wanneer u het maakt. Het kan echter een willekeurig aantal keren worden gebruikt zonder opnieuw te worden gecompileerd.

Notities voor bellers

Met deze constructor maakt u een Regex object dat gebruikmaakt van de standaardtime-outwaarde van het toepassingsdomein waarin het wordt gemaakt. Als er geen time-outwaarde is gedefinieerd voor het toepassingsdomein, gebruikt het Regex object de waarde InfiniteMatchTimeout, waardoor er geen time-out optreedt voor de bewerking. De aanbevolen constructor voor het maken van een Regex object is Regex(String, RegexOptions, TimeSpan), waarmee u het time-outinterval kunt instellen.

Zie ook

• Taalelementen voor reguliere expressies

Bron:

Regex.cs

Bron:

Regex.cs

Bron:

Regex.cs

Bron:

Regex.cs

Bron:

Regex.cs

public:
 Regex(System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options, TimeSpan matchTimeout);

public Regex(string pattern, System.Text.RegularExpressions.RegexOptions options, TimeSpan matchTimeout);

new System.Text.RegularExpressions.Regex : string * System.Text.RegularExpressions.RegexOptions * TimeSpan -> System.Text.RegularExpressions.Regex

Public Sub New (pattern As String, options As RegexOptions, matchTimeout As TimeSpan)

Parameters

Uitzonderingen

Voorbeelden

In het volgende voorbeeld wordt de Regex(String, RegexOptions, TimeSpan) constructor aangeroepen om een Regex object te instantiëren met een time-outwaarde van één seconde. Het reguliere expressiepatroon (a+)+$, dat overeenkomt met een of meer reeksen van een of meer a-tekens aan het einde van een regel, is onderhevig aan overmatige backtracking. Als er een RegexMatchTimeoutException optreedt, wordt in het voorbeeld de time-outwaarde verhoogd tot de maximumwaarde van drie seconden. Anders wordt de poging om overeen te komen met het patroon afgelaten.

using System;
using System.ComponentModel;
using System.Diagnostics;
using System.Security;
using System.Text.RegularExpressions;
using System.Threading; 

public class Example
{
   const int MaxTimeoutInSeconds = 3;

   public static void Main()
   {
      string pattern = @"(a+)+$";    // DO NOT REUSE THIS PATTERN.
      Regex rgx = new Regex(pattern, RegexOptions.IgnoreCase, TimeSpan.FromSeconds(1));       
      Stopwatch sw = null;
      
      string[] inputs= { "aa", "aaaa>", 
                         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
                         "aaaaaaaaaaaaaaaaaaaaaa>",
                         "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>" };
                                 
      foreach (var inputValue in inputs) {
         Console.WriteLine("Processing {0}", inputValue);
         bool timedOut = false;
         do { 
            try {
               sw = Stopwatch.StartNew();
               // Display the result.
               if (rgx.IsMatch(inputValue)) {
                  sw.Stop();
                  Console.WriteLine(@"Valid: '{0}' ({1:ss\.fffffff} seconds)", 
                                    inputValue, sw.Elapsed); 
               }
               else {
                  sw.Stop();
                  Console.WriteLine(@"'{0}' is not a valid string. ({1:ss\.fffff} seconds)", 
                                    inputValue, sw.Elapsed);
               }
            }
            catch (RegexMatchTimeoutException e) {   
               sw.Stop();
               // Display the elapsed time until the exception.
               Console.WriteLine(@"Timeout with '{0}' after {1:ss\.fffff}", 
                                 inputValue, sw.Elapsed);
               Thread.Sleep(1500);       // Pause for 1.5 seconds.

               // Increase the timeout interval and retry.
               TimeSpan timeout = e.MatchTimeout.Add(TimeSpan.FromSeconds(1));
               if (timeout.TotalSeconds > MaxTimeoutInSeconds) {
                  Console.WriteLine("Maximum timeout interval of {0} seconds exceeded.",
                                    MaxTimeoutInSeconds);
                  timedOut = false;
               }
               else {               
                  Console.WriteLine("Changing the timeout interval to {0}", 
                                    timeout); 
                  rgx = new Regex(pattern, RegexOptions.IgnoreCase, timeout);
                  timedOut = true;
               }
            }
         } while (timedOut);
         Console.WriteLine();
      }   
   }
}
// The example displays output like the following :
//    Processing aa
//    Valid: 'aa' (00.0000779 seconds)
//    
//    Processing aaaa>
//    'aaaa>' is not a valid string. (00.00005 seconds)
//    
//    Processing aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
//    Valid: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' (00.0000043 seconds)
//    
//    Processing aaaaaaaaaaaaaaaaaaaaaa>
//    Timeout with 'aaaaaaaaaaaaaaaaaaaaaa>' after 01.00469
//    Changing the timeout interval to 00:00:02
//    Timeout with 'aaaaaaaaaaaaaaaaaaaaaa>' after 02.01202
//    Changing the timeout interval to 00:00:03
//    Timeout with 'aaaaaaaaaaaaaaaaaaaaaa>' after 03.01043
//    Maximum timeout interval of 3 seconds exceeded.
//    
//    Processing aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>
//    Timeout with 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>' after 03.01018
//    Maximum timeout interval of 3 seconds exceeded.

Imports System.ComponentModel
Imports System.Diagnostics
Imports System.Security
Imports System.Text.RegularExpressions
Imports System.Threading 

Module Example
   Const MaxTimeoutInSeconds As Integer = 3
   
   Public Sub Main()
      Dim pattern As String = "(a+)+$"    ' DO NOT REUSE THIS PATTERN.
      Dim rgx As New Regex(pattern, RegexOptions.IgnoreCase, TimeSpan.FromSeconds(1))       
      Dim sw As Stopwatch = Nothing
      
      Dim inputs() As String = { "aa", "aaaa>", 
                                 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
                                 "aaaaaaaaaaaaaaaaaaaaaa>",
                                 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>" }
                                 
      For Each inputValue In inputs
         Console.WriteLine("Processing {0}", inputValue)
         Dim timedOut As Boolean = False
         Do 
            Try
               sw = Stopwatch.StartNew()
               ' Display the result.
               If rgx.IsMatch(inputValue) Then
                  sw.Stop()
                  Console.WriteLine("Valid: '{0}' ({1:ss\.fffffff} seconds)", 
                                    inputValue, sw.Elapsed) 
               Else
                  sw.Stop()
                  Console.WriteLine("'{0}' is not a valid string. ({1:ss\.fffff} seconds)", 
                                    inputValue, sw.Elapsed)
               End If
            Catch e As RegexMatchTimeoutException   
               sw.Stop()
               ' Display the elapsed time until the exception.
               Console.WriteLine("Timeout with '{0}' after {1:ss\.fffff}", 
                                 inputValue, sw.Elapsed)
               Thread.Sleep(1500)       ' Pause for 1.5 seconds.

               ' Increase the timeout interval and retry.
               Dim timeout As TimeSpan = e.MatchTimeout.Add(TimeSpan.FromSeconds(1))
               If timeout.TotalSeconds > MaxTimeoutInSeconds Then
                  Console.WriteLine("Maximum timeout interval of {0} seconds exceeded.",
                                    MaxTimeoutInSeconds)
                  timedOut = False
               Else                
                  Console.WriteLine("Changing the timeout interval to {0}", 
                                    timeout) 
                  rgx = New Regex(pattern, RegexOptions.IgnoreCase, timeout)
                  timedOut = True
               End If
            End Try
         Loop While timedOut
         Console.WriteLine()
      Next   
   End Sub 
End Module
' The example displays output like the following:
'    Processing aa
'    Valid: 'aa' (00.0000779 seconds)
'    
'    Processing aaaa>
'    'aaaa>' is not a valid string. (00.00005 seconds)
'    
'    Processing aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
'    Valid: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' (00.0000043 seconds)
'    
'    Processing aaaaaaaaaaaaaaaaaaaaaa>
'    Timeout with 'aaaaaaaaaaaaaaaaaaaaaa>' after 01.00469
'    Changing the timeout interval to 00:00:02
'    Timeout with 'aaaaaaaaaaaaaaaaaaaaaa>' after 02.01202
'    Changing the timeout interval to 00:00:03
'    Timeout with 'aaaaaaaaaaaaaaaaaaaaaa>' after 03.01043
'    Maximum timeout interval of 3 seconds exceeded.
'    
'    Processing aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>
'    Timeout with 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>' after 03.01018
'    Maximum timeout interval of 3 seconds exceeded.

Opmerkingen

De pattern parameter bestaat uit reguliere expressietaalelementen die de tekenreeks symbolisch beschrijven die overeenkomen. Zie de onderwerpen .NET Reguliere expressies en Regular Expression Language - Quick Reference voor meer informatie over reguliere expressies.

Een Regex object is onveranderbaar, wat betekent dat het alleen kan worden gebruikt voor het overeenkomstpatroon dat u definieert wanneer u het maakt. Het kan echter een willekeurig aantal keren worden gebruikt zonder opnieuw te worden gecompileerd.

De matchTimeout parameter geeft aan hoe lang een patroonkoppelingsmethode moet proberen een overeenkomst te vinden voordat er een time-out optreedt. Als er in dat tijdsinterval geen overeenkomst wordt gevonden, genereert de patroonkoppelingsmethode een RegexMatchTimeoutException uitzondering. matchTimeout overschrijft een standaardtime-outwaarde die is gedefinieerd voor het toepassingsdomein waarin het Regex object wordt gemaakt. De patroonkoppelingsmethoden van het exemplaar die het matchTimeout time-outinterval observeren, omvatten het volgende:

• IsMatch

• Match

• Matches

• Replace

• Split

• Match.NextMatch

Als u een time-outinterval instelt, voorkomt u dat reguliere expressies die afhankelijk zijn van overmatige backtracking niet meer reageren wanneer ze invoer verwerken die bijna overeenkomsten bevat. Zie Aanbevolen procedures voor reguliere expressies en backtracking voor meer informatie. Als u een redelijk time-outinterval wilt instellen, moet u rekening houden met de volgende factoren:

• De lengte en complexiteit van het reguliere expressiepatroon. Langere en complexere reguliere expressies vereisen meer tijd dan kortere en eenvoudigere expressies.

• De verwachte computerbelasting. Verwerking kost meer tijd op systemen met een hoog CPU- en geheugengebruik.

Notities voor bellers

U wordt aangeraden de matchTimeout parameter in te stellen op een geschikte waarde, zoals twee seconden. Als u time-outs uitschakelt door op te InfiniteMatchTimeoutgeven, biedt de reguliere expressie-engine iets betere prestaties. Schakel echter alleen time-outs uit onder de volgende voorwaarden:

• Wanneer de invoer die door een reguliere expressie wordt verwerkt, wordt afgeleid van een bekende en vertrouwde bron of bestaat uit statische tekst. Dit sluit tekst uit die dynamisch door gebruikers is ingevoerd.

• Wanneer het reguliere expressiepatroon grondig is getest om ervoor te zorgen dat er efficiënt overeenkomsten, niet-overeenkomsten en bijna-overeenkomsten worden verwerkt.

• Wanneer het reguliere expressiepatroon geen taalelementen bevat die bekend zijn dat ze overmatige backtracking veroorzaken bij het verwerken van een bijna-overeenkomst.

Zie ook

• Backtracking in reguliere expressies
• Taalelementen voor reguliere expressies