RegexCompilationInfo Constructeurs

Référence

Définition

Espace de noms:: System.Text.RegularExpressions

Assembly:: System.Text.RegularExpressions.dll

Assembly:: System.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Initialise une nouvelle instance de la classe RegexCompilationInfo.

Surcharges

RegexCompilationInfo(String, RegexOptions, String, String, Boolean)	Initialise une nouvelle instance de la classe RegexCompilationInfo qui contient des informations à propos d'une expression régulière à inclure dans un assembly.
RegexCompilationInfo(String, RegexOptions, String, String, Boolean, TimeSpan)	Initialise une nouvelle instance de la classe RegexCompilationInfo qui contient des informations à propos d'une expression régulière avec une valeur de délai d'attente spécifiée devant être incluse dans un assembly.

RegexCompilationInfo(String, RegexOptions, String, String, Boolean)

Source:: RegexCompilationInfo.cs

Source:: RegexCompilationInfo.cs

Source:: RegexCompilationInfo.cs

Initialise une nouvelle instance de la classe RegexCompilationInfo qui contient des informations à propos d'une expression régulière à inclure dans un assembly.

public:
 RegexCompilationInfo(System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options, System::String ^ name, System::String ^ fullnamespace, bool ispublic);

public RegexCompilationInfo (string pattern, System.Text.RegularExpressions.RegexOptions options, string name, string fullnamespace, bool ispublic);

new System.Text.RegularExpressions.RegexCompilationInfo : string * System.Text.RegularExpressions.RegexOptions * string * string * bool -> System.Text.RegularExpressions.RegexCompilationInfo

Public Sub New (pattern As String, options As RegexOptions, name As String, fullnamespace As String, ispublic As Boolean)

Paramètres

pattern: String

Expression régulière à compiler.

options: RegexOptions

Options de l'expression régulière à utiliser lors de la compilation de l'expression régulière.

name: String

Nom du type qui représente l'expression régulière compilée.

fullnamespace: String

L'espace de noms auquel le nouveau type appartient.

ispublic: Boolean

true pour rendre l'expression régulière compilée visible publiquement ; sinon, false.

Exceptions

ArgumentException

name a la valeur Empty.

ArgumentNullException

pattern a la valeur null.

-ou-

name a la valeur null.

-ou-

fullnamespace a la valeur null.

Exemples

L’exemple suivant crée et utilise une expression régulière compilée en deux étapes.

Dans la première étape, compilez et exécutez l’exemple de code suivant. Le RegexCompilationInfo constructeur dans l’exemple de code définit une expression régulière compilée. Le résultat de l’exécution du code est un assembly nommé FishRegex.dll qui contient un type d’expression régulière compilé nommé FishRegex.

// This code example demonstrates the RegexCompilationInfo constructor
// and the Regex.CompileToAssembly() method.
// compile: csc genFishRegex.cs

namespace MyApp
{
    using System;
    using System.Reflection;
    using System.Text.RegularExpressions;
    class GenFishRegEx
    {
        public static void Main()
        {
// Pattern = Group matches one or more word characters,
//           one or more white space characters,
//           group matches the string "fish".
        string pat = @"(\w+)\s+(fish)";

// Create the compilation information.
// Case-insensitive matching; type name = "FishRegex";
// namespace = "MyApp"; type is public.
        RegexCompilationInfo rci = new RegexCompilationInfo(
                    pat, RegexOptions.IgnoreCase,
                    "FishRegex", "MyApp", true);

// Setup to compile.
        AssemblyName an = new AssemblyName();
        an.Name = "FishRegex";
        RegexCompilationInfo[] rciList = { rci };

// Compile the regular expression.
        Regex.CompileToAssembly(rciList, an);
        }
    }
}

' This code example demonstrates the RegexCompilationInfo constructor
' and the Regex.CompileToAssembly() method.
' compile: csc genFishRegex.cs

Imports System.Reflection
Imports System.Text.RegularExpressions

Class GenFishRegEx
    Public Shared Sub Main() 
        ' Pattern = Group matches one or more word characters, 
        '           one or more white space characters, 
        '           group matches the string "fish".
        Dim pat As String = "(\w+)\s+(fish)"
        
        ' Create the compilation information.
        ' Case-insensitive matching; type name = "FishRegex"; 
        ' namespace = "MyApp"; type is public.
        Dim rci As New RegexCompilationInfo(pat, RegexOptions.IgnoreCase, _
                                            "FishRegex", "MyApp", True)
        
        ' Setup to compile.
        Dim an As New AssemblyName()
        an.Name = "FishRegex"
        Dim rciList As RegexCompilationInfo() = New RegexCompilationInfo() { rci }
        
        ' Compile the regular expression.
        Regex.CompileToAssembly(rciList, an)
    
    End Sub
End Class

Dans la deuxième étape, compilez l’exemple de code suivant à l’aide d’une référence à FishRegex.dll, puis exécutez le fichier exécutable résultant. Le fichier exécutable correspond à une chaîne cible à l’aide du FishRegex type et affiche la correspondance, le groupe, le groupe de capture et la position d’index des correspondances dans la chaîne cible.

// This code example demonstrates the RegexCompilationInfo constructor.
// Execute this code example after executing genFishRegex.exe.
// compile: csc /r:FishRegex.dll useFishRegex.cs

namespace MyApp
  {
  using System;
  using System.Reflection;
  using System.Text.RegularExpressions;

  class UseFishRegEx
    {
    public static void Main()
      {
// Match against the following target string.
      string targetString = "One fish two fish red fish blue fish";
      int matchCount = 0;
      FishRegex f = new FishRegex();

// Display the target string.
      Console.WriteLine("\nInput string = \"" + targetString + "\"");

// Display each match, capture group, capture, and match position.
      foreach (Match m in f.Matches(targetString))
    {
    Console.WriteLine("\nMatch(" + (++matchCount) + ")");
    for (int i = 1; i <= 2; i++)
      {
      Group g = m.Groups[i];
      Console.WriteLine("Group(" + i + ") = \"" + g + "\"");
      CaptureCollection cc = g.Captures;
      for (int j = 0; j < cc.Count; j++)
        {
        Capture c = cc[j];
        System.Console.WriteLine(
          "Capture(" + j + ") = \"" + c + "\", Position = " + c.Index);
        }
      }
    }
      }
    }
  }

/*
This code example produces the following results:

Input string = "One fish two fish red fish blue fish"

Match(1)
Group(1) = "One"
Capture(0) = "One", Position = 0
Group(2) = "fish"
Capture(0) = "fish", Position = 4

Match(2)
Group(1) = "two"
Capture(0) = "two", Position = 9
Group(2) = "fish"
Capture(0) = "fish", Position = 13

Match(3)
Group(1) = "red"
Capture(0) = "red", Position = 18
Group(2) = "fish"
Capture(0) = "fish", Position = 22

Match(4)
Group(1) = "blue"
Capture(0) = "blue", Position = 27
Group(2) = "fish"
Capture(0) = "fish", Position = 32

*/

' This code example demonstrates the RegexCompilationInfo constructor.
' Execute this code example after executing genFishRegex.exe.
' compile: vbc /r:FishRegex.dll useFishRegex.vb

Imports System.Reflection
Imports System.Text.RegularExpressions

Class UseFishRegEx
    Public Shared Sub Main() 
        ' Match against the following target string.
        Dim targetString As String = "One fish two fish red fish blue fish"
        Dim matchCount As Integer = 0
        Dim f As New MyApp.FishRegex()
        
        ' Display the target string.
        Console.WriteLine(vbLf & "Input string = """ & targetString & """")
        
        ' Display each match, capture group, capture, and match position.
        Dim m As Match
        For Each m In f.Matches(targetString)
            matchCount = matchCount + 1
            Console.WriteLine(vbLf & "Match(" & matchCount & ")")

            Dim i As Integer
            For i = 1 to 2
                Dim g As Group = m.Groups(i)
                Console.WriteLine("Group(" & i & ") = """ & g.ToString() & """")
                Dim cc As CaptureCollection = g.Captures
                Dim j As Integer
                For j = 0 To cc.Count-1
                    Dim c As Capture = cc(j)
                    System.Console.WriteLine("Capture(" & j & ") = """ & c.ToString() & _
                                             """, Position = " & c.Index)
                Next j
            Next i
        Next m
    End Sub
End Class

'
'This code example produces the following results:
'
'Input string = "One fish two fish red fish blue fish"
'
'Match(1)
'Group(1) = "One"
'Capture(0) = "One", Position = 0
'Group(2) = "fish"
'Capture(0) = "fish", Position = 4
'
'Match(2)
'Group(1) = "two"
'Capture(0) = "two", Position = 9
'Group(2) = "fish"
'Capture(0) = "fish", Position = 13
'
'Match(3)
'Group(1) = "red"
'Capture(0) = "red", Position = 18
'Group(2) = "fish"
'Capture(0) = "fish", Position = 22
'
'Match(4)
'Group(1) = "blue"
'Capture(0) = "blue", Position = 27
'Group(2) = "fish"
'Capture(0) = "fish", Position = 32
'

Remarques

Chaque paramètre du RegexCompilationInfo(String, RegexOptions, String, String, Boolean) constructeur correspond directement à une propriété de la RegexCompilationInfo classe . Étant donné que toutes les propriétés sont en lecture/écriture, leurs valeurs peuvent également être affectées directement.

La CompileToAssembly méthode génère un assembly qui contient des expressions régulières compilées. Par conséquent, vous ne devez pas spécifier Compiled comme l’une des valeurs de options.

Si ispublic est true, la classe d’expression régulière compilée est accessible au public. Autrement dit, il peut être instancié à partir du code qui s’exécute dans n’importe quel assembly. Si ispublic est false, la classe d’expression régulière compilée est donnée internal (en C#) ou Friend (en Visual Basic) accessibilité. Autrement dit, il ne peut être instancié qu’à partir du code qui s’exécute dans le même assembly que la classe d’expression régulière.

Notes pour les appelants

Ce constructeur crée une expression régulière compilée qui utilise la valeur de délai d’attente par défaut du domaine d’application dans lequel elle est créée. Si une valeur de délai d’attente est définie pour le domaine d’application, l’expression régulière compilée utilise la valeur InfiniteMatchTimeout, ce qui empêche une opération de mise en correspondance de modèle d’expirer. Le constructeur recommandé pour créer une expression régulière compilée est RegexCompilationInfo(String, RegexOptions, String, String, Boolean, TimeSpan), ce qui vous permet de définir l’intervalle de délai d’attente.

S’applique à

RegexCompilationInfo(String, RegexOptions, String, String, Boolean, TimeSpan)

Source:: RegexCompilationInfo.cs

Source:: RegexCompilationInfo.cs

Source:: RegexCompilationInfo.cs

Initialise une nouvelle instance de la classe RegexCompilationInfo qui contient des informations à propos d'une expression régulière avec une valeur de délai d'attente spécifiée devant être incluse dans un assembly.

public:
 RegexCompilationInfo(System::String ^ pattern, System::Text::RegularExpressions::RegexOptions options, System::String ^ name, System::String ^ fullnamespace, bool ispublic, TimeSpan matchTimeout);

public RegexCompilationInfo (string pattern, System.Text.RegularExpressions.RegexOptions options, string name, string fullnamespace, bool ispublic, TimeSpan matchTimeout);

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

Public Sub New (pattern As String, options As RegexOptions, name As String, fullnamespace As String, ispublic As Boolean, matchTimeout As TimeSpan)

Paramètres

pattern: String

Expression régulière à compiler.

options: RegexOptions

Options de l'expression régulière à utiliser lors de la compilation de l'expression régulière.

name: String

Nom du type qui représente l'expression régulière compilée.

fullnamespace: String

L'espace de noms auquel le nouveau type appartient.

ispublic: Boolean

true pour rendre l'expression régulière compilée visible publiquement ; sinon, false.

matchTimeout: TimeSpan

Délai d'attente par défaut pour l'expression régulière.

Exceptions

ArgumentException

name a la valeur Empty.

ArgumentNullException

pattern a la valeur null.

-ou-

name a la valeur null.

-ou-

fullnamespace a la valeur null.

ArgumentOutOfRangeException

matchTimeout a une valeur négative, nulle ou supérieure à environ 24 jours.

Exemples

L’exemple suivant définit une seule expression régulière compilée nommée DuplicateChars qui identifie au moins deux occurrences du même caractère dans une chaîne d’entrée. L’expression régulière compilée a un délai d’expiration par défaut de 2 secondes. Lorsque vous exécutez l’exemple, il crée une bibliothèque de classes nommée RegexLib.dll qui contient l’expression régulière compilée.

using System;
using System.Reflection;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
        // Match two or more occurrences of the same character.
        string pattern = @"(\w)\1+";
        
        // Use case-insensitive matching. 
        var rci = new RegexCompilationInfo(pattern, RegexOptions.IgnoreCase,
                                           "DuplicateChars", "CustomRegexes", 
                                           true, TimeSpan.FromSeconds(2));

        // Define an assembly to contain the compiled regular expression.
        var an = new AssemblyName();
        an.Name = "RegexLib";
        RegexCompilationInfo[] rciList = { rci };

        // Compile the regular expression and create the assembly.
        Regex.CompileToAssembly(rciList, an);
   }
}

Imports System.Reflection
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
        ' Match two or more occurrences of the same character.
        Dim pattern As String = "(\w)\1+"
        
        ' Use case-insensitive matching. 
        Dim rci As New RegexCompilationInfo(pattern, RegexOptions.IgnoreCase,
                                            "DuplicateChars", "CustomRegexes", 
                                            True, TimeSpan.FromSeconds(2))

        ' Define an assembly to contain the compiled regular expression.
        Dim an As New AssemblyName()
        an.Name = "RegexLib"
        Dim rciList As RegexCompilationInfo() = New RegexCompilationInfo() { rci }

        ' Compile the regular expression and create the assembly.
        Regex.CompileToAssembly(rciList, an)
   End Sub
End Module

Le modèle d'expression régulière (\w)\1+ est défini comme indiqué dans le tableau suivant.

Modèle	Description
`(\w)`	Faites correspondre n’importe quel caractère de mot et affectez-le au premier groupe de capture.
`\1+`	Faire correspondre une ou plusieurs occurrences de la valeur du premier groupe capturé.

L’exemple suivant utilise l’expression DuplicatedChars régulière pour identifier les caractères en double dans un tableau de chaînes. Lorsqu’il appelle le DuplicatedChars constructeur, il modifie l’intervalle de délai d’attente en .5 secondes.

using CustomRegexes;
using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      var rgx = new DuplicateChars(TimeSpan.FromSeconds(.5));
      
      string[] values = { "Greeeeeat", "seed", "deed", "beam", 
                          "loop", "Aardvark" };
      // Display regex information.
      Console.WriteLine("Regular Expression Pattern: {0}", rgx);
      Console.WriteLine("Regex timeout value: {0} seconds\n", 
                        rgx.MatchTimeout.TotalSeconds);
      
      // Display matching information.
      foreach (var value in values) {
         Match m = rgx.Match(value);
         if (m.Success)
            Console.WriteLine("'{0}' found in '{1}' at positions {2}-{3}",
                              m.Value, value, m.Index, m.Index + m.Length - 1);
         else
            Console.WriteLine("No match found in '{0}'", value);
      }                                                         
   }
}
// The example displays the following output:
//       Regular Expression Pattern: (\w)\1+
//       Regex timeout value: 0.5 seconds
//       
//       //eeeee// found in //Greeeeeat// at positions 2-6
//       //ee// found in //seed// at positions 1-2
//       //ee// found in //deed// at positions 1-2
//       No match found in //beam//
//       //oo// found in //loop// at positions 1-2
//       //Aa// found in //Aardvark// at positions 0-1

Imports CustomRegexes
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim rgx As New DuplicateChars(TimeSpan.FromSeconds(.5))
      
      Dim values() As String = { "Greeeeeat", "seed", "deed", "beam", 
                                 "loop", "Aardvark" }
      ' Display regex information.
      Console.WriteLine("Regular Expression Pattern: {0}", rgx)
      Console.WriteLine("Regex timeout value: {0} seconds", 
                        rgx.MatchTimeout.TotalSeconds)
      Console.WriteLine()
      
      ' Display matching information.
      For Each value In values
         Dim m As Match = rgx.Match(value)
         If m.Success Then
            Console.WriteLine("'{0}' found in '{1}' at positions {2}-{3}",
                              m.Value, value, m.Index, m.Index + m.Length - 1)
         Else
            Console.WriteLine("No match found in '{0}'", value)
         End If   
      Next                                                         
   End Sub
End Module
' The example displays the following output:
'       Regular Expression Pattern: (\w)\1+
'       Regex timeout value: 0.5 seconds
'       
'       'eeeee' found in 'Greeeeeat' at positions 2-6
'       'ee' found in 'seed' at positions 1-2
'       'ee' found in 'deed' at positions 1-2
'       No match found in 'beam'
'       'oo' found in 'loop' at positions 1-2
'       'Aa' found in 'Aardvark' at positions 0-1

Remarques

La CompileToAssembly méthode génère un assembly qui contient des expressions régulières compilées. Par conséquent, vous ne devez pas spécifier Compiled comme l’une des valeurs de options.

Le matchTimeout paramètre définit l’intervalle de délai d’attente par défaut pour l’expression régulière compilée. Cette valeur représente la durée approximative pendant laquelle un objet d’expression régulière compilée exécute une seule opération de correspondance avant que l’opération expire et que le moteur d’expression régulière lève une RegexMatchTimeoutException exception lors de son case activée de minutage suivant. Pour plus d’informations sur la valeur du délai d’attente, consultez la MatchTimeout propriété .

Important

Nous vous recommandons de toujours définir une valeur de délai d’attente par défaut pour une expression régulière compilée. Les consommateurs de votre bibliothèque d’expressions régulières peuvent remplacer cette valeur de délai d’attente en transmettant une TimeSpan valeur qui représente le nouvel intervalle de délai d’attente à cette surcharge de constructeur.

Voir aussi

MatchTimeout

S’applique à

RegexCompilationInfo Constructeurs

Définition

Surcharges

RegexCompilationInfo(String, RegexOptions, String, String, Boolean)

Paramètres

Exceptions

Exemples

Remarques

Notes pour les appelants

S’applique à

RegexCompilationInfo(String, RegexOptions, String, String, Boolean, TimeSpan)

Paramètres

Exceptions

Exemples

Remarques

Voir aussi

S’applique à

Commentaires

Ressources supplémentaires