Regex Konstruktorer

Definition

Namnområde:: System.Text.RegularExpressions

Sammansättningar:: System.dll, System.Text.RegularExpressions.dll

Sammansättningar:: netstandard.dll, System.Text.RegularExpressions.dll

Sammansättning:: System.Text.RegularExpressions.dll

Sammansättning:: System.dll

Sammansättning:: netstandard.dll

Viktigt

En del information gäller för förhandsversionen av en produkt och kan komma att ändras avsevärt innan produkten blir allmänt tillgänglig. Microsoft lämnar inga garantier, uttryckliga eller underförstådda, avseende informationen som visas här.

Initierar en ny instans av Regex klassen.

Överlagringar

Name	Description
Regex()	Initierar en ny instans av Regex klassen.
Regex(String)	Initierar en ny instans av Regex klassen för det angivna reguljära uttrycket.
Regex(SerializationInfo, StreamingContext)	Föråldrad. Initierar en ny instans av Regex klassen med hjälp av serialiserade data.
Regex(String, RegexOptions)	Initierar en ny instans av Regex klassen för det angivna reguljära uttrycket, med alternativ som ändrar mönstret.
Regex(String, RegexOptions, TimeSpan)	Initierar en ny instans av Regex klassen för det angivna reguljära uttrycket, med alternativ som ändrar mönstret och ett värde som anger hur länge en mönstermatchningsmetod ska försöka matcha innan tidsgränsen uppnås.

Regex()

Källa:: Regex.cs

Källa:: Regex.cs

Källa:: Regex.cs

Källa:: Regex.cs

Källa:: Regex.cs

Initierar en ny instans av Regex klassen.

protected:
 Regex();

protected Regex();

Protected Sub New ()

Kommentarer

Observera att konstruktorn är skyddad. Det kan bara anropas av klasser som härletts Regex från klassen.

Gäller för

Regex(String)

Källa:: Regex.cs

Källa:: Regex.cs

Källa:: Regex.cs

Källa:: Regex.cs

Källa:: Regex.cs

Initierar en ny instans av Regex klassen för det angivna reguljära uttrycket.

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)

Parametrar

pattern: String

Det reguljära uttrycksmönster som ska matchas.

Undantag

ArgumentException

Ett fel uppstod vid parsning av reguljära uttryck.

ArgumentNullException

pattern är null.

Exempel

I följande exempel visas hur du använder den här konstruktorn för att instansiera ett reguljärt uttryck som matchar alla ord som börjar med bokstäverna "a" eller "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

Observera att mönstret för reguljära uttryck inte kan matcha ordet "The" i början av texten, eftersom jämförelser är skiftlägeskänsliga som standard. Ett exempel på skiftlägesokänslig jämförelse finns i Regex(String, RegexOptions) konstruktorn.

Kommentarer

Varning

När du använder System.Text.RegularExpressions för att bearbeta ej betrodda indata skickar du ett timeout-värde för att förhindra att skadliga användare orsakar en överbelastningsattack. Ett timeout-värde anger hur länge en mönstermatchningsmetod ska försöka hitta en matchning innan tidsgränsen uppnås.

Parametern pattern består av reguljära uttrycksspråkelement som symboliskt beskriver strängen som ska matchas. Mer information om reguljära uttryck finns i avsnitten .NET Regular Expressions och Regular Expression Language – Quick Reference.

Regex(String) Att anropa konstruktorn motsvarar att anropa Regex(String, RegexOptions) konstruktorn med värdet None för för options argumentet.

Ett Regex objekt är oföränderligt, vilket innebär att det endast kan användas för det matchningsmönster som du definierar när du skapar det. Den kan dock användas valfritt antal gånger utan att omkompileras.

Den här konstruktorn instansierar ett reguljärt uttrycksobjekt som försöker matcha skiftlägeskänsligt med alla alfabetiska tecken som definierats i pattern. Använd konstruktorn för en skiftlägeskänslig matchning Regex.Regex(String, RegexOptions) .

Anteckningar till anropare

Den här konstruktorn skapar ett Regex objekt som använder standardvärdet för tidsgränsen för programdomänen där det skapas. Om ett timeout-värde inte har definierats för programdomänen Regex använder objektet värdet InfiniteMatchTimeout, vilket förhindrar att åtgärden överskrider tidsgränsen. Den rekommenderade konstruktorn för att skapa ett Regex objekt är Regex(String, RegexOptions, TimeSpan), vilket gör att du kan ange tidsgränsintervallet.

Se även

Språkelement för reguljära uttryck

Gäller för

Regex(SerializationInfo, StreamingContext)

Källa:: Regex.cs

Källa:: Regex.cs

Källa:: Regex.cs

Källa:: Regex.cs

Källa:: Regex.cs

Varning

This API supports obsolete formatter-based serialization. It should not be called or extended by application code.

Initierar en ny instans av Regex klassen med hjälp av serialiserade data.

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)

Parametrar

info: SerializationInfo

Objektet som innehåller ett serialiserat mönster och RegexOptions information.

context: StreamingContext

Målet för den här serialiseringen. (Den här parametern används inte. Ange null.)

Attribut: ObsoleteAttribute

Undantag

ArgumentException

Ett fel uppstod vid parsning av reguljära uttryck.

ArgumentNullException

Mönstret som info innehåller är null.

ArgumentOutOfRangeException

info innehåller en ogiltig RegexOptions flagga.

PlatformNotSupportedException

Serialisering av Regex objekt stöds inte.

Gäller för

Regex(String, RegexOptions)

Källa:: Regex.cs

Källa:: Regex.cs

Källa:: Regex.cs

Källa:: Regex.cs

Källa:: Regex.cs

Initierar en ny instans av Regex klassen för det angivna reguljära uttrycket, med alternativ som ändrar mönstret.

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)

Parametrar

pattern: String

Det reguljära uttrycksmönster som ska matchas.

options: RegexOptions

En bitvis kombination av uppräkningsvärdena som ändrar det reguljära uttrycket.

Undantag

ArgumentException

Ett fel uppstod vid parsning av reguljära uttryck.

ArgumentNullException

pattern är null.

ArgumentOutOfRangeException

options är inte ett giltigt RegexOptions värde.

Exempel

I följande exempel visas hur du använder den här konstruktorn för att instansiera ett reguljärt uttryck som matchar alla ord som börjar med bokstäverna "a" eller "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

Observera att matchningssamlingen innehåller ordet "The" som börjar texten eftersom parametern options har definierat skiftlägesokänsliga jämförelser.

Kommentarer

Varning

Ett Regex objekt är oföränderligt, vilket innebär att det bara kan användas för de matchningsparametrar som du definierar när du skapar det. Den kan dock användas valfritt antal gånger utan att omkompileras.

Anteckningar till anropare

Se även

Språkelement för reguljära uttryck

Gäller för

Regex(String, RegexOptions, TimeSpan)

Källa:: Regex.cs

Källa:: Regex.cs

Källa:: Regex.cs

Källa:: Regex.cs

Källa:: Regex.cs

Initierar en ny instans av Regex klassen för det angivna reguljära uttrycket, med alternativ som ändrar mönstret och ett värde som anger hur länge en mönstermatchningsmetod ska försöka matcha innan tidsgränsen uppnås.

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)

Parametrar

pattern: String

Det reguljära uttrycksmönster som ska matchas.

options: RegexOptions

En bitvis kombination av uppräkningsvärdena som ändrar det reguljära uttrycket.

matchTimeout: TimeSpan

Ett tidsgränsintervall, eller InfiniteMatchTimeout för att indikera att metoden inte bör överskrida tidsgränsen.

Undantag

ArgumentException

Ett fel uppstod vid parsning av reguljära uttryck.

ArgumentNullException

pattern är null.

ArgumentOutOfRangeException

options är inte ett giltigt RegexOptions värde, eller matchTimeout är negativt, noll eller större än cirka 24 dagar.

Exempel

I följande exempel anropas Regex(String, RegexOptions, TimeSpan) konstruktorn för att instansiera ett Regex objekt med ett timeout-värde på en sekund. Det reguljära uttrycksmönstret (a+)+$, som matchar en eller flera sekvenser med ett eller flera "a"-tecken i slutet av en rad, är föremål för överdriven bakåtspårning. Om en RegexMatchTimeoutException genereras ökar exemplet timeout-värdet upp till det maximala värdet på tre sekunder. Annars avbryts försöket att matcha mönstret.

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.

Kommentarer

Ett Regex objekt är oföränderligt, vilket innebär att det bara kan användas för det matchningsmönster som du definierar när du skapar det. Den kan dock användas valfritt antal gånger utan att omkompileras.

Parametern matchTimeout anger hur länge en mönstermatchningsmetod ska försöka hitta en matchning innan tidsgränsen uppnås. Om ingen matchning hittas i det tidsintervallet genererar metoden mönstermatchning ett RegexMatchTimeoutException undantag. matchTimeout åsidosätter alla standardvärden för tidsgränser som definierats för programdomänen Regex där objektet skapas. De metoder för mönstermatchning av instanser som observerar matchTimeout tidsgränsintervallet omfattar följande:

Om du anger ett tidsgränsintervall förhindras reguljära uttryck som förlitar sig på överdriven bakåtspårning från att verka sluta svara när de bearbetar indata som innehåller nära matchningar. Mer information finns i Metodtips för reguljära uttryck och bakåtspårning. Tänk på följande faktorer för att ange ett rimligt tidsgränsintervall:

Längden och komplexiteten i det reguljära uttrycksmönstret. Längre och mer komplexa reguljära uttryck kräver mer tid än kortare och enklare uttryck.
Den förväntade datorbelastningen. Bearbetningen tar längre tid på system som har hög processor- och minnesanvändning.

Anteckningar till anropare

Vi rekommenderar att du anger parametern matchTimeout till ett lämpligt värde, till exempel två sekunder. Om du inaktiverar tidsgränser genom att ange ger motorn för reguljära InfiniteMatchTimeoututtryck något bättre prestanda. Du bör dock inaktivera tidsgränser endast under följande villkor:

När indata som bearbetas av ett reguljärt uttryck härleds från en känd och betrodd källa eller består av statisk text. Detta exkluderar text som har matats in dynamiskt av användare.
När mönstret för reguljära uttryck har testats noggrant för att säkerställa att det effektivt hanterar matchningar, icke-matchningar och nära matchningar.
När det reguljära uttrycksmönstret inte innehåller några språkelement som är kända för att orsaka överdriven bakåtspårning vid bearbetning av en nära matchning.

Se även

Gäller för

Feedback

Var den här sidan till hjälp?