internal RegExpMatch(ArrayPrototype parent, Regex regex, Match match, string input) : base(parent, typeof(RegExpMatch)) { this.hydrated = false; this.regex = regex; this.matches = null; this.match = match; base.SetMemberValue("input", input); base.SetMemberValue("index", match.Index); base.SetMemberValue("lastIndex", (match.Length == 0) ? (match.Index + 1) : (match.Index + match.Length)); string[] groupNames = regex.GetGroupNames(); int num = 0; for (int i = 1; i < groupNames.Length; i++) { string name = groupNames[i]; int num3 = regex.GroupNumberFromName(name); if (name.Equals(num3.ToString(CultureInfo.InvariantCulture))) { if (num3 > num) { num = num3; } } else { Group group = match.Groups[name]; base.SetMemberValue(name, group.Success ? group.ToString() : null); } } this.length = num + 1; }
/// <summary> /// Creates regular expression case /// </summary> /// <param name="regexPattern">Regular expression instance</param> /// <returns>Case expression</returns> public static Expression<Func<string, string>> Rx(Regex regexPattern) { var parameterExpression = Expression.Parameter(typeof (string), "strArg"); var matchExpression = Expression.Variable(typeof (Match), "match"); var retPoint = Expression.Label(typeof (string)); var successProperty = Expression.Property(matchExpression, "Success"); var resultProperty = Expression.Property( regexPattern.GetGroupNames().Length > 1 ? (Expression)Expression.Property(Expression.Property(matchExpression, "Groups"), "Item", Expression.Constant(1)) : matchExpression, "Value"); var block = Expression.Block(new[] { matchExpression}, Expression.Assign(matchExpression, Expression.Call( Expression.Constant(regexPattern, typeof(Regex)), typeof (Regex).GetMethod("Match", new[] {typeof (string)}), parameterExpression)), Expression.IfThenElse( successProperty, Expression.Return(retPoint, resultProperty), Expression.Return(retPoint, Expression.Convert(Expression.Constant(null), typeof(string)))), Expression.Label(retPoint, Expression.Default(typeof(string))) ); return Expression.Lambda<Func<string, string>>(block, parameterExpression); }
public static Dictionary<string, string> Parse(string input, string pattern) { var dict = new Dictionary<string, string>(); try { var regex = new Regex(pattern, RegexOptions.CultureInvariant | RegexOptions.IgnorePatternWhitespace); string[] names = regex.GetGroupNames(); MatchCollection matches = regex.Matches(input); foreach (Match match in matches) { foreach (string name in names) { if (dict.ContainsKey(name)) { dict[name] += Environment.NewLine + match.Groups[name].Value; } else { dict.Add(name, match.Groups[name].Value); } } } } catch (Exception e) { } return dict; }
/// <summary> /// Loads visual studio .sln solution /// </summary> /// <param name="solutionFileName"></param> /// <exception cref="System.IO.FileNotFoundException">The file specified in path was not found.</exception> public Solution(string solutionFileName) { _solutionFileName = solutionFileName; _slnLines = new List<object>(); var slnTxt = File.ReadAllText(solutionFileName); //Match string like: Project("{66666666-7777-8888-9999-AAAAAAAAAAAA}") = "ProjectName", "projectpath.csproj", "{11111111-2222-3333-4444-555555555555}" var projMatcher = new Regex("Project\\(\"(?<ParentProjectGuid>{[A-F0-9-]+})\"\\) = \"(?<ProjectName>.*?)\", \"(?<RelativePath>.*?)\", \"(?<ProjectGuid>{[A-F0-9-]+})"); Regex.Replace(slnTxt, "^(.*?)[\n\r]*$", m => { String line = m.Groups[1].Value; Match m2 = projMatcher.Match(line); if (m2.Groups.Count < 2) { _slnLines.Add(line); return ""; } var s = new SolutionProject(); // "0" - RegEx special kind of group foreach (String g in projMatcher.GetGroupNames().Where(x => x != "0")) s.GetType().GetField(g).SetValue(s, m2.Groups[g].ToString()); _slnLines.Add(s); return ""; }, RegexOptions.Multiline); }
internal ReplaceUsingFunction(Regex regex, ScriptFunction function, string source) { this.function = function; this.cArgs = function.GetNumberOfFormalParameters(); bool flag = (function is Closure) && ((Closure) function).func.hasArgumentsObject; this.groupNumbers = null; this.source = source; if ((this.cArgs > 1) || flag) { string[] groupNames = regex.GetGroupNames(); int num = groupNames.Length - 1; if (flag) { this.cArgs = num + 3; } if (num > 0) { if (num > (this.cArgs - 1)) { num = this.cArgs - 1; } this.groupNumbers = new int[num]; for (int i = 0; i < num; i++) { this.groupNumbers[i] = regex.GroupNumberFromName(groupNames[i + 1]); } } } }
public void Execute(string folder, int days, string dateFormat) { s_log.DebugFormat("Start Vaporizing Folders in {0}", folder); var dir = new DirectoryInfo(folder); foreach (var item in dir.GetDirectories()) { Regex rgx = new Regex(dateFormat); Match m = rgx.Match(item.Name); if (m.Success) { var groupNames = rgx.GetGroupNames(); int hour = groupNames.Contains("hour") ? Convert.ToInt32(m.Groups["hour"].Value) : 0; DateTime d = new DateTime(Convert.ToInt32(m.Groups["year"].Value), Convert.ToInt32(m.Groups["month"].Value), Convert.ToInt32(m.Groups["day"].Value), hour, 0, 0); if (d < DateTime.Now.AddDays(days * -1)) { var name = item.FullName; s_log.DebugFormat("Deleting folder {0}", name); item.Delete(true); s_log.DebugFormat("Finished Deleting folder {0}", name); } } s_log.DebugFormat("Finished Vaporizing Folders in {0}", folder); } }
private void Navigate(string navigationState) { if (navigationState == currentUrl) return; currentUrl = navigationState; string database = Server.DefaultDatabaseName; var databasesMatch = databasesRegEx.Match(currentUrl); if (databasesMatch.Success) { currentUrl = currentUrl.Substring(databasesMatch.Length); database = databasesMatch.Groups[1].Value; } foreach (var route in Routes.OrderBy(x => x.Metadata.Index)) { var regex = new Regex(route.Metadata.Url); var match = regex.Match(navigationState); if (match.Success == false) continue; var parameters = new Dictionary<string, string>(); foreach (var name in regex.GetGroupNames()) { parameters[name] = match.Groups[name].Value; } route.Value.Navigate(database, parameters); return; } }
public static bool Handle(string path) { var viewDispatcher = Mvx.Resolve<Cirrious.MvvmCross.Views.IMvxViewDispatcher>(); var appService = Mvx.Resolve<IApplicationService>(); if (!path.EndsWith("/", StringComparison.Ordinal)) path += "/"; foreach (var route in Routes) { var regex = new Regex(route.Path, RegexOptions.ExplicitCapture | RegexOptions.IgnoreCase); var match = regex.Match(path); var groups = regex.GetGroupNames().Skip(1); if (match.Success) { var rec = new MvxViewModelRequest(); rec.ViewModelType = route.ViewModelType; rec.ParameterValues = new Dictionary<string, string>(); foreach (var group in groups) rec.ParameterValues.Add(group, match.Groups[group].Value); appService.SetUserActivationAction(() => viewDispatcher.ShowViewModel(rec)); return true; } } return false; }
private static void MatchAndPrintResults(Regex regex, string input) { Console.WriteLine("Regex: " + regex); Console.WriteLine("Input: " + input); MatchCollection matches = regex.Matches(input); Console.WriteLine("Match Count: " + matches.Count); int matchCounter = 0; foreach (Match match in matches) { Console.WriteLine(string.Empty.PadRight(50, '=')); Console.WriteLine(" Match {0}:", ++matchCounter); Console.WriteLine(" Value: " + match.Value); Console.WriteLine(string.Empty.PadRight(50, '-')); Console.WriteLine(" Groups:"); Console.WriteLine(string.Empty.PadRight(50, '-')); foreach (string name in regex.GetGroupNames()) { Console.WriteLine(" \"{0}\": {1}", name, match.Groups[name].Value); } Console.WriteLine(string.Empty.PadRight(50, '=')); } Console.WriteLine(); }
public static bool Handle(string path) { if (!path.EndsWith("/", StringComparison.Ordinal)) path += "/"; foreach (var route in Routes) { var regex = new Regex(route.Path, RegexOptions.ExplicitCapture | RegexOptions.IgnoreCase); var match = regex.Match(path); var groups = regex.GetGroupNames().Skip(1).ToList(); if (match.Success) { var vm = IoC.Resolve(route.ViewModelType); foreach (var group in groups) { var property = vm.GetType().GetProperty(group); if (property != null) property.SetValue(vm, match.Groups[group].Value); } //appService.SetUserActivationAction(() => viewDispatcher.ShowViewModel(rec)); return true; } } return false; }
/// <summary> /// Constructeur /// </summary> /// <param name="text">Texte à afficher</param> public Visionneuse(string text) { InitializeComponent(); texte.Text = text; string integers = "\\b(?:[0-9]*\\.)?[0-9]+\\b"; string Strings = "'[^']*"; string all = "\\r|\\n|\\(|\\)|'[^']*'|\\w+|\\[max\\]|\\[min\\]|\\[avg\\]|\\[count\\]|\\|/|\\.|\\{|\\}|\\[|\\]|\\+|:-|:=|<>|[(<=)(>=)^?!,@<>_~%/=:;*'&-]{1}?|\\$|\\?}"; string Comments = @"|/\*(?>(?:(?>[^*]+)|\*(?!/))*)\*/";// matches multiline comments string reg = "--|" + integers + "|" + Strings + "|" + all; Regex rg = new Regex(reg + Comments, RegexOptions.IgnoreCase); MatchCollection mc_ = rg.Matches(texte.Text); string[] a = rg.GetGroupNames(); int j = 0; while (j < mc_.Count) { if (mc_[j].Value == "--") { while (mc_[j].Value != "\r") { texte.SelectionStart = mc_[j].Index; texte.SelectionLength = mc_[j].Length; texte.SelectionFont = new Font("Courrier", 10, FontStyle.Italic); texte.SelectionColor = CommentColor; j++; } } ColorSQLToken(mc_[j]); j++; } }
public bool ProcessRegex(string target, string regexExpression) { if (target == null) { target = string.Empty; } Regex regex = new Regex(regexExpression, RegexOptions.ExplicitCapture); Match match = regex.Match(target); if (!match.Success) { return false; } string[] groupNames = regex.GetGroupNames(); if (groupNames.Length > 0) { if (this._groups == null) { this._groups = new Hashtable(); } for (int i = 0; i < groupNames.Length; i++) { this._groups[groupNames[i]] = match.Groups[i].Value; } } return true; }
public static IEnumerable Match(SqlString pattern, SqlString subject) { var list = new List<MatchContent>(); var regex = new Regex(pattern.Value); var match = regex.Match(subject.Value); var groupNames = regex.GetGroupNames(); var num = 0; while (match.Success) { num++; var array = groupNames; foreach (var text in array) { list.AddRange(match.Groups[text].Captures .Cast<Capture>() .Select(capture => new MatchContent { MatchNumber = num, GroupName = text, CaptureNumber = capture.Index, Value = capture.Value })); } match = match.NextMatch(); } return list; }
public static string regexFun(string target, string expr, object g, regexAct ra, string replStr, int replCnt, int replStart, ref MatchCollection o, int capID) { int gn = g is int ? Int32.Parse(g.ToString()) : 0; if (capID < 0) { capID = 0; } Regex regex = new Regex(expr, RegexOptions.Multiline | RegexOptions.IgnoreCase); try { switch (ra) { case regexAct.Match: var varMatch = regex.Match(target); if (!varMatch.Success) { return null; } else if (g is String && Array.Exists(regex.GetGroupNames(), gpnm => (gpnm == g.ToString()))) { return varMatch.Groups[g.ToString()].Captures[capID].Value; } else if (g is int || Int32.TryParse(g.ToString(), out gn)) { return varMatch.Groups[gn].Captures[capID].Value; } else { return varMatch.Groups[0].Captures[capID].Value; } case regexAct.Replace: return regex.Replace(target, (string)replStr, replCnt, replStart); case regexAct.Matches: var ms = regex.Matches(target); o = ms; return "0"; default: return "err:-1"; } } catch{ return "err:-2"; } }
public static int GetMatchStrength(string regexPattern, string input) { System.Text.RegularExpressions.Regex regex = new System.Text.RegularExpressions.Regex(regexPattern, System.Text.RegularExpressions.RegexOptions.IgnoreCase); if (!regex.IsMatch(input)) { throw new Exception(string.Format("String '{0}' is not a match for Regex '{1}'", input, regexPattern)); } // The idea is that you have a regex like // look at (?<object>.*) // And you have a string like // look at thing // The strength is the length of the "fixed" bit of the string, in this case "look at ". // So we calculate this as the length of the input string, minus the length of the // text that matches the named groups. int lengthOfTextMatchedByGroups = 0; foreach (string groupName in regex.GetGroupNames()) { // exclude group names like "0", we only want the explicitly named groups if (!TextAdventures.Utility.Strings.IsNumeric(groupName)) { string groupMatch = regex.Match(input).Groups[groupName].Value; lengthOfTextMatchedByGroups += groupMatch.Length; } } return(input.Length - lengthOfTextMatchedByGroups); }
/// <summary> /// 根据规则, 过滤出结果 /// /// </summary> /// <param name="rawContent"></param> /// <returns></returns> public override string FilterUsingRule(ref string rawContent) { string filteredContent = string.Empty; Regex reg = new Regex(RegexExp, RegexOptions.Singleline); string[] groupNames = reg.GetGroupNames(); MatchCollection matchs = reg.Matches(rawContent); foreach (Match m in matchs) { //从原始内容中删除已经提取的内容 if (m.Value == string.Empty) continue; rawContent = rawContent.Replace(m.Value, string.Empty); //继续提取精确内容,通过regexgroup for (int i = 0; i < m.Groups.Count; i++) { string groupName = groupNames[i]; int demo; if (!int.TryParse(groupName, out demo)) { Group g = m.Groups[groupNames[i]]; filteredContent += g.Value + "||"; } } filteredContent += "&&"; } return filteredContent; }
public RoutedRequest(IDictionary<string, object> env, Regex regex, string path) : base(env) { var groups = regex.Match(path).Groups; var dic = regex.GetGroupNames().ToDictionary(name => name, name => groups[name].Value); UrlSegments = new DynamicDictionary<string>(dic); }
static int GetGroupNames(IntPtr L) { LuaScriptMgr.CheckArgsCount(L, 1); System.Text.RegularExpressions.Regex obj = (System.Text.RegularExpressions.Regex)LuaScriptMgr.GetNetObjectSelf(L, 1, "System.Text.RegularExpressions.Regex"); string[] o = obj.GetGroupNames(); LuaScriptMgr.PushArray(L, o); return(1); }
public RouterContext(IOwinContext owinContext, Regex regex) { OwinContext = owinContext; var groupNames = regex.GetGroupNames(); if (groupNames.Length > 1) { GetParams(owinContext, regex, groupNames.Skip(1)); } }
private static void Debug(string input, Match match, Regex regex) { Trace.WriteLine("Regex: " + regex); Trace.WriteLine("Input: " + input); foreach(var groupName in regex.GetGroupNames()) { Trace.WriteLine(" -> " + groupName + ": >>" + match.Groups[groupName].Value + "<<"); } }
public SyslogParser(Regex parser) { if (parser == null) { throw new ArgumentNullException("parser"); } this.parser = parser; this.groupNames = parser.GetGroupNames(); }
private static string GetGitHubWikiAuthor(string html) { Regex rex = new Regex("class=\"author\">(.*?)</a> edited this page <time .*>(.*?)</time>"); //var match = rex.Match(html); //return "Last edited by " + match.Groups["name"].Value + " on " + match.Groups["timeStamp"].Value; var match = rex.Match(html); string[] names = rex.GetGroupNames(); string name = names.Length > 0 ? match.Groups[names[1]].Value : "unknown author"; string time = names.Length > 1 ? match.Groups[names[2]].Value : "at unknown time"; name = String.Format("<a href=\"http://github.com/{0}\">{0}</a>", name); return String.Format("Updated {1} by {0}", name, time); }
static public int GetGroupNames(IntPtr l) { try { System.Text.RegularExpressions.Regex self = (System.Text.RegularExpressions.Regex)checkSelf(l); var ret = self.GetGroupNames(); pushValue(l, true); pushValue(l, ret); return(2); } catch (Exception e) { return(error(l, e)); } }
/// <summary> /// Constructs a new instance of <see cref="HttpStatusCodeParser"/> for the specified regular /// expression. /// </summary> /// <param name="pattern"> /// The regular expression pattern to use. /// /// <para><paramref name="pattern"/> should contain the named capturing grounds <c>StatusCode</c> and <c>status</c>.</para> /// </param> /// <exception cref="ArgumentNullException"><paramref name="pattern"/> is <see langword="null"/>.</exception> /// <exception cref="ArgumentException"> /// <paramref name="pattern"/> does not contain a capturing group named <c>StatusCode</c>. /// <para>-or-</para> /// <para><paramref name="pattern"/> does not contain a capturing group named <c>Status</c>.</para> /// </exception> protected HttpStatusCodeParser(string pattern) { if (pattern == null) throw new ArgumentNullException("pattern"); _expression = new Regex(pattern, RegexOptions.Compiled); string[] groupNames = _expression.GetGroupNames(); if (!groupNames.Contains("StatusCode", StringComparer.Ordinal)) throw new ArgumentException("The pattern does not contain a StatusCode named capturing group.", "pattern"); if (!groupNames.Contains("Status", StringComparer.Ordinal)) throw new ArgumentException("The pattern does not contain a Status named capturing group.", "pattern"); }
public static void NameTests() { string pattern = @"\b(?<FirstWord>\w+)\s?((\w+)\s)*(?<LastWord>\w+)?(?<Punctuation>\p{Po})"; string input = "The cow jumped over the moon."; Regex regex = new Regex(pattern); Match match = regex.Match(input); Assert.True(match.Success); string[] names = regex.GetGroupNames(); for (int i = 0; i < names.Length; i++) { Assert.Equal(names[i], match.Groups[i].Name); } }
public IBaseViewModel Handle(string url) { Uri uri; if (!Uri.TryCreate(url, UriKind.Absolute, out uri)) return null; if (_sessionService.Account == null) return null; Uri webDomain; if (!Uri.TryCreate(_sessionService.Account.WebDomain, UriKind.Absolute, out webDomain)) return null; if (uri.Scheme != webDomain.Scheme || uri.Host != webDomain.Host) return null; var relativePath = string.Concat(uri.Segments); if (!relativePath.EndsWith("/", StringComparison.Ordinal)) relativePath += "/"; try { foreach (var route in Routes) { var regex = new Regex(route.Path, RegexOptions.ExplicitCapture | RegexOptions.IgnoreCase); var match = regex.Match(relativePath); var groups = regex.GetGroupNames().Skip(1).ToList(); if (match.Success) { // var vm = Locator.Current.GetService(route.ViewModelType); //// foreach (var group in groups) //// { //// var property = vm.GetType().GetProperty(group); //// if (property != null) //// property.SetValue(vm, match.Groups[group].Value); //// } //// // return vm as IBaseViewModel; } } } catch (Exception e) { System.Diagnostics.Debug.WriteLine("Unable to resolve Url (" + url + "): " + e.Message); } return null; }
public static void PrintAllCapturesToConsole(this Match match, Regex regex) { if (!match.Success) { Console.WriteLine("\t\tNo Match."); return; } var groupNames = regex.GetGroupNames(); foreach (var groupName in groupNames) { var g = match.Groups[groupName]; Console.WriteLine("\tGroup {0}",groupName); g.PrintCaptures(); } }
public static RegMatches MatchGroups(string aInput, string aPattern) { RegMatches ret = new RegMatches(); System.Text.RegularExpressions.Regex regex = new System.Text.RegularExpressions.Regex(aPattern); MatchCollection matchCollection = regex.Matches(aInput); foreach (string groupName in regex.GetGroupNames()) { if (groupName == "0") { continue; } ret.Add(groupName, new List <string>()); } bool isFound = false; if (matchCollection.Count != 0) { foreach (Match match in matchCollection) { foreach (string groupName in ret.Keys) { foreach (Capture cap in match.Groups[groupName].Captures) { string val = cap.Value.Trim(); if (val == "") { continue; } ret[groupName].Add(cap.Value.Trim()); if (!isFound) { isFound = true; } } } } } if (!isFound) { return(null); } return(ret); }
public static string GroupValue(this string text, Regex regex) { var match = regex.Match(text); var names = regex.GetGroupNames(); foreach (var name in names) { if (numericNames.Contains(name)) continue; int unused; if (int.TryParse(name, out unused)) continue; return match.Groups[name].Value; } return match.Groups[0].Value; }
public bool Retrieve(string content) { var regex = new Regex(Expression, RegexOptions.Multiline); var m = regex.Match(content); if (m.Success) { RetrivedData = new Dictionary<string, string>(); foreach (var gName in regex.GetGroupNames()) { RetrivedData[gName] = m.Groups[gName].Value; } return true; } else { return false; } }
internal ReplaceUsingFunction(Regex regex, ScriptFunction function, String source) { this.function = function; this.cArgs = function.GetNumberOfFormalParameters(); bool hasArgumentsObject = (function is Closure) && ((Closure)function).func.hasArgumentsObject; this.groupNumbers = null; this.source = source; if (this.cArgs > 1 || hasArgumentsObject) { String[] groupNames = regex.GetGroupNames(); int cGroupNumbers = groupNames.Length - 1; if (hasArgumentsObject) this.cArgs = cGroupNumbers+3; if (cGroupNumbers > 0) { if (cGroupNumbers > this.cArgs - 1) cGroupNumbers = this.cArgs - 1; this.groupNumbers = new int[cGroupNumbers]; for (int i = 0; i < cGroupNumbers; i++) this.groupNumbers[i] = regex.GroupNumberFromName(groupNames[i+1]); } } }
public static RegMatche2[] Match(string aInput, string aPattern) { var ret = new List <RegMatche2>(); var groupNames = new List <string>(); System.Text.RegularExpressions.Regex regex = new System.Text.RegularExpressions.Regex(aPattern); MatchCollection matchCollection = regex.Matches(aInput); if (matchCollection.Count == 0) { return(null); } // Get group names foreach (string groupName in regex.GetGroupNames()) { if (groupName == "0") { continue; } groupNames.Add(groupName); } foreach (Match match in matchCollection) { foreach (var g in groupNames) { var m = match.Groups[g]; if (m == null || m.Length == 0) { continue; } ret.Add(new RegMatche2() { GroupName = g, Value = match.Value }); } } return(ret.ToArray()); }
public static RegexResult Evaluate(RegexQueryBuilder regexQuery) { RegexResult result = new RegexResult(regexQuery); Regex expression = new Regex(regexQuery.Regex, regexQuery.GetOptions()); result.Regex = regexQuery.Regex; result.Replacement = regexQuery.ReplaceText; int searchPos = 0; List<string> groupNames = expression.GetGroupNames().ToList(); Match m = expression.Match(regexQuery.Target, searchPos); SortedList sl = new SortedList(); while (m.Success) { RegexMatch matchResult = new RegexMatch(); groupNames.ForEach(groupName => { var groupMatch = m.Groups[groupName]; foreach (Capture cap in groupMatch.Captures) { RegexCaptureResult groupResult = new RegexCaptureResult() { Index = cap.Index, MatchText = cap.Value, MatchLength = cap.Length, MatchGroupName = groupName }; matchResult.GroupResults.Add(groupResult); } }); result.Matches.Add(matchResult); sl.Add(m.Index, m.Value); m = m.NextMatch(); } result.MatchSortedList = sl; return result; }
public static QuestDictionary <string> Populate(string regexPattern, string input) { System.Text.RegularExpressions.Regex regex = new System.Text.RegularExpressions.Regex(regexPattern, System.Text.RegularExpressions.RegexOptions.IgnoreCase); if (!regex.IsMatch(input)) { throw new Exception(string.Format("String '{0}' is not a match for Regex '{1}'", input, regexPattern)); } QuestDictionary <string> result = new QuestDictionary <string>(); foreach (string groupName in regex.GetGroupNames()) { if (!TextAdventures.Utility.Strings.IsNumeric(groupName)) { string groupMatch = regex.Match(input).Groups[groupName].Value; result.Add(groupName, groupMatch); } } return(result); }
private void RegexTextBox_OnUserStopTyping(object sender, EventArgs e) { if (this.rtcRegexControl.RegexTextBox.Text.Length != 0) { TextChanged.RaiseEvent(this); } if (!this.rtcRegexControl.RegexTextBox.HasRegexError) { try { Regex regex = new Regex(this.rtcRegexControl.RegexTextBox.Text); EventArgs<List<string>> filesEvent = new EventArgs<List<string>>(); RequestFileList.RaiseEvent(this, filesEvent); UpdateGroups(regex.GetGroupNames()); } catch (Exception) { } } }
public static NameValueCollection GetNamedMatches(Regex regex, Match m) { NameValueCollection dic = new NameValueCollection(); foreach (string groupName in regex.GetGroupNames()) { if (Regex.IsMatch(groupName, @"^\d")) continue; var groupCapture = m.Groups[groupName]; if (groupCapture.Success) { foreach (Capture capture in groupCapture.Captures) { dic.Add(groupName, capture.Value); } } } return dic; }
public string[] GetGroupNames() { return(_regex.GetGroupNames()); }