C# RegularExpressions.Group类代码示例

 void ReplaceUrlWithAbsoluteUrl(StringBuilder builder, Group matchedUrlGroup, string currentDirectory)
 {
     var relativeUrl = matchedUrlGroup.Value.Trim('"', '\'');
     var absoluteUrl = CreateAbsoluteUrl(relativeUrl, currentDirectory);
     builder.Remove(matchedUrlGroup.Index, matchedUrlGroup.Length);
     builder.Insert(matchedUrlGroup.Index, absoluteUrl);
 }

 private string GetPathThroughLastSlash(SourceText text, int position, Group quotedPathGroup)
 {
     return PathCompletionUtilities.GetPathThroughLastSlash(
         quotedPath: quotedPathGroup.Value,
         quotedPathStart: GetQuotedPathStart(text, position, quotedPathGroup),
         position: position);
 }

 private IEnumerable<Frame> CreateFrames(
     Group framesGroup)
 {
     return 
         from Capture capture in framesGroup.Captures
         select CreateFrame(capture.Value);
 }

 private TextSpan GetTextChangeSpan(SourceText text, int position, Group quotedPathGroup)
 {
     return PathCompletionUtilities.GetTextChangeSpan(
         quotedPath: quotedPathGroup.Value,
         quotedPathStart: GetQuotedPathStart(text, position, quotedPathGroup),
         position: position);
 }

    public static Group Synchronized(Group inner)
    {
      Contract.Ensures(Contract.Result<System.Text.RegularExpressions.Group>() != null);
      Contract.Ensures(Contract.Result<System.Text.RegularExpressions.Group>() == inner);

      return default(Group);
    }

 /// <summary>
 /// Concatenates the captures of <paramref name="group" /> to a string.
 /// </summary>
 /// <param name="group"><see cref="Group" /> containing the captures.</param>
 /// <returns>
 /// <see cref="string" /> containg the concatenated captures.
 /// </returns>
 /// <remarks>
 /// A named-group can captured multiple times, when the regular
 /// expression has a quantifier, e.g. (// (?'Text'.*) )* will match
 /// multiline comments with group <i>Text</i> having a capture for
 /// every line.
 /// </remarks>
 private string ConcatenateCaptures(Group group) {
     StringBuilder sb = new StringBuilder();
     foreach (Capture capture in group.Captures) {
         sb.Append(capture.Value);
     }
     return sb.ToString();
 }

    public static Group Synchronized(Group inner)
    {
      Contract.Requires(inner != null);
      Contract.Ensures(Contract.Result<Group>() != null);

      return default(Group);
    }

        private void AddSubNode(int parentNodeIndex, string caption, Group captureGroup, int groupIndex)
        {
            TreeNode newNode = makeCaptureNode(caption);

            Nodes[parentNodeIndex].Nodes.Add(newNode);
            Nodes[parentNodeIndex].Nodes[groupIndex - 1].Tag = captureGroup;
            Nodes[parentNodeIndex].Expand();
        }

        private static void DisplayCaptures(Group group, TreeNode groupRoot)
        {
            foreach (Capture capture in group.Captures)
            {
                TreeNode captureRoot = new TreeNode(capture.Value);
                groupRoot.Nodes.Add(captureRoot);

            }
        }

        public static double ParseDouble(Group @group)
        {
            if (@group.Captures.Count != 1)
            {
                throw new ArgumentException("Expected single capture");
            }

            return ParseDouble(@group.Value);
        }

 private static int GroupToInt(Group g)
 {
     int value;
     if (int.TryParse(g.ToString(), out value))
     {
         return value;
     }
     return -1;
 }

        public EditUserForm()
        {
            InitializeComponent();

            _userName = string.Empty;
            _password = string.Empty;
            GroupId = -1;
            Groups = new Group[0];
        }

        private static IReadOnlyList<UriParameter> ParseParameterGroup(Group group)
        {
            if (!group.Success)
                return new UriParameter[] { };

            var parameters = group.Value;
            var splitByAmpersand = parameters.Split('&');
            return splitByAmpersand.Select(ParseParameterPart).ToArray();
        }

 string GetImageFilename(Group matchedUrlGroup, string currentDirectory)
 {
     var originalUrl = matchedUrlGroup.Value.Trim('"', '\'');
     if (originalUrl.StartsWith("/"))
     {
         return PathUtilities.NormalizePath("~" + originalUrl);
     }
     return PathUtilities.NormalizePath(PathUtilities.CombineWithForwardSlashes(currentDirectory, originalUrl));
 }

 private static string GetDistinctCount(string @select, Group g, string @from)
 {
     var columns = g.ToString().Trim();
     if(columns == "DISTINCT")
     {
         throw new ArgumentException("Malformed SQL; DISTINCT queries must specify at least one column");
     }
     var distinct = string.Concat(@select, "COUNT(", columns,  ") ", @from);
     return distinct;
 }