Regex.Escape(String) Metod

public:
 static System::String ^ Escape(System::String ^ str);

public static string Escape(string str);

static member Escape : string -> string

Public Shared Function Escape (str As String) As String

Parametrar

Returer

En sträng med tecken med metakarakterare konverterade till deras undantagna form.

Undantag

Exempel

I följande exempel extraheras kommentarer från text. Det förutsätter att kommentarerna avgränsas av en startkommentarsymbol och en slutkommentarsymbol som väljs av användaren. Eftersom kommentarssymbolerna ska tolkas bokstavligen skickas de till Escape metoden för att säkerställa att de inte kan feltolkas som metakarakterare. Dessutom kontrollerar exemplet uttryckligen om slutkommentarsymbolen som användaren har angett är en avslutande hakparentes (]) eller klammerparentes (}). I så fall läggs ett omvänt snedstreck (\) till inom hakparentesen eller klammerparentesen så att det tolkas bokstavligen. Observera att exemplet också använder Match.Groups samlingen för att endast visa kommentaren, i stället för kommentaren tillsammans med dess inledande och avslutande kommentarssymboler.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      ConsoleKeyInfo keyEntered;
      char beginComment, endComment;
      Console.Write("Enter begin comment symbol: ");
      keyEntered = Console.ReadKey();
      beginComment = keyEntered.KeyChar;
      Console.WriteLine();
      
      Console.Write("Enter end comment symbol: ");
      keyEntered = Console.ReadKey();
      endComment = keyEntered.KeyChar;
      Console.WriteLine();
      
      string input = "Text [comment comment comment] more text [comment]";
      string pattern;
      pattern = Regex.Escape(beginComment.ToString()) + @"(.*?)";
      string endPattern = Regex.Escape(endComment.ToString());
      if (endComment == ']' || endComment == '}') endPattern = @"\" + endPattern;
      pattern += endPattern;
      MatchCollection matches = Regex.Matches(input, pattern);
      Console.WriteLine(pattern);
      int commentNumber = 0;
      foreach (Match match in matches)
         Console.WriteLine("{0}: {1}", ++commentNumber, match.Groups[1].Value);
   }
}
// The example shows possible output from the example:
//       Enter begin comment symbol: [
//       Enter end comment symbol: ]
//       \[(.*?)\]
//       1: comment comment comment
//       2: comment

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim keyEntered As ConsoleKeyInfo
      Dim beginComment, endComment As Char
      Console.Write("Enter begin comment symbol: ")
      keyEntered = Console.ReadKey()
      beginComment = keyEntered.KeyChar
      Console.WriteLine()
      
      Console.Write("Enter end comment symbol: ")
      keyEntered = Console.ReadKey()
      endComment = keyEntered.KeyChar
      Console.WriteLine()
      
      Dim input As String = "Text [comment comment comment] more text [comment]"
      Dim pattern As String = Regex.Escape(beginComment.ToString()) + "(.*?)"
      Dim endPattern As String = Regex.Escape(endComment.ToString())
      If endComment = "]"c OrElse endComment = "}"c Then endPattern = "\" + endPattern
      pattern += endPattern
      
      Dim matches As MatchCollection = Regex.Matches(input, pattern)
      Console.WriteLine(pattern)
      Dim commentNumber As Integer = 0
      For Each match As Match In matches
         commentNumber += 1
         Console.WriteLine("{0}: {1}", commentNumber, match.Groups(1).Value)
      Next         
   End Sub
End Module
' The example shows possible output from the example:
'       Enter begin comment symbol: [
'       Enter end comment symbol: ]
'       \[(.*?)\]
'       1: comment comment comment
'       2: comment

Kommentarer

Escape konverterar en sträng så att motorn för reguljära uttryck tolkar alla metakarakterare som den kan innehålla som teckenliteraler. Tänk dig till exempel ett reguljärt uttryck som är utformat för att extrahera kommentarer som avgränsas av raka inledande och avslutande hakparenteser ([ och ]) från text. I följande exempel tolkas det reguljära uttrycket "[(.*?)]" som en teckenklass. I stället för att matcha kommentarer som är inbäddade i indatatexten matchar det reguljära uttrycket varje inledande eller avslutande parentes, punkt, asterisk eller frågetecken.

string pattern = "[(.*?)]"; 
string input = "The animal [what kind?] was visible [by whom?] from the window.";

MatchCollection matches = Regex.Matches(input, pattern);
int commentNumber = 0;
Console.WriteLine("{0} produces the following matches:", pattern);
foreach (Match match in matches)
   Console.WriteLine("   {0}: {1}", ++commentNumber, match.Value);  

// This example displays the following output:
//       [(.*?)] produces the following matches:
//          1: ?
//          2: ?
//          3: .

Dim pattern As String = "[(.*?)]" 
Dim input As String = "The animal [what kind?] was visible [by whom?] from the window."

Dim matches As MatchCollection = Regex.Matches(input, pattern)
Dim commentNumber As Integer = 0
Console.WriteLine("{0} produces the following matches:", pattern)
For Each match As Match In matches
   commentNumber += 1
   Console.WriteLine("{0}: {1}", commentNumber, match.Value)       
Next      
' This example displays the following output:
'       1: ?
'       2: ?
'       3: .

Men om den inledande hakparentesen är undantagen Escape genom att skicka den till metoden lyckas det reguljära uttrycket matcha kommentarer som är inbäddade i indatasträngen. I följande exempel visas detta.

string pattern = Regex.Escape("[") + "(.*?)]"; 
string input = "The animal [what kind?] was visible [by whom?] from the window.";

MatchCollection matches = Regex.Matches(input, pattern);
int commentNumber = 0;
Console.WriteLine("{0} produces the following matches:", pattern);
foreach (Match match in matches)
   Console.WriteLine("   {0}: {1}", ++commentNumber, match.Value);  

// This example displays the following output:
//       \[(.*?)] produces the following matches:
//          1: [what kind?]
//          2: [by whom?]

Dim pattern As String = Regex.Escape("[") + "(.*?)]" 
Dim input As String = "The animal [what kind?] was visible [by whom?] from the window."

Dim matches As MatchCollection = Regex.Matches(input, pattern)
Dim commentNumber As Integer = 0
Console.WriteLine("{0} produces the following matches:", pattern)
For Each match As Match In matches
   commentNumber += 1
   Console.WriteLine("   {0}: {1}", commentNumber, match.Value)  
Next
' This example displays the following output:
'       \[(.*?)] produces the following matches:
'          1: [what kind?]
'          2: [by whom?]

I ett reguljärt uttryck som definieras med hjälp av statisk text kan tecken som ska tolkas bokstavligen snarare än som metakarakterare kringgås genom att föregå dem med en omvänt snedstreckssymbol (\) samt genom att anropa Escape metoden. I ett reguljärt uttryck som definieras dynamiskt med hjälp av tecken som inte är kända vid designtillfället är det särskilt viktigt att anropa Escape metoden för att säkerställa att motorn för reguljära uttryck tolkar enskilda tecken som literaler snarare än som metakarakterare.

Escape Även om metoden undflyr den raka inledande hakparentesen ([) och inledande klammerparenteser ({) kommer de inte undan motsvarande avslutande tecken (] och }). I de flesta fall är det inte nödvändigt att fly från dessa. Om en avslutande hakparentes eller klammerparentes inte föregås av motsvarande öppningstecken tolkar motorn för reguljära uttryck den bokstavligen. Om en inledande hakparentes eller klammerparentes tolkas som ett metadiagram tolkar motorn för reguljära uttryck det första motsvarande avslutande tecknet som ett metadiagram. Om detta inte är det önskade beteendet bör den avslutande hakparentesen eller klammerparentesen vara undantagen genom att uttryckligen föreläsa omvänt snedstreck (\). En bild finns i avsnittet Exempel.

Se även

• Unescape(String)
• Språk för reguljärt uttryck – snabbreferens
• Tecken rymningar i reguljära uttryck