C# Match.Result方法代码示例

 private ProjectItem CreateProjectItem(Match match)
 {
     var projectTitle = match.Result("${Title}");
     var projectPath = match.Result("${Location}");
     var projectItem = new ProjectItem {Name = projectTitle, Path = projectPath};
     return projectItem;
 }

        public static int SheifTopicDataInt(ref string errText, ref TCG.ResourcesService.Resources topic, Match match, string datarole)
        {
            if (string.IsNullOrEmpty(datarole))
            {
                return -1;
            }

            string splitstr = datarole.IndexOf("\r\n")>-1 ? "\r\n" : "\n";
            string[] datas = datarole.Split(new string[] { splitstr }, StringSplitOptions.None);
            if (datas.Length == 0)
            {
                return -2;
            }

            PropertyInfo[] tproperty = topic.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance);

            for (int i = 0; i < datas.Length; i++)
            {
                if (!string.IsNullOrEmpty(datas[i]))
                {
                    string[] keyvalue = datas[i].Split(',');
                    int rtn = SheifTopicSheValue(ref errText, ref topic, tproperty, match.Result(keyvalue[0]), keyvalue[1]);
                }
            }
            return 1;
        }

 internal override String Evaluate(Match match) {
   this.lastMatch = match;
   Object[] args = new Object[this.cArgs];
   if (this.cArgs > 0) {
     args[0] = match.ToString();
     if (this.cArgs > 1) {
       int i = 1;
       if (this.groupNumbers != null)
         for (; i <= this.groupNumbers.Length; i++) {
           Group group = match.Groups[this.groupNumbers[i-1]];
           args[i] = group.Success ? group.ToString() : null;
         }
       if (i < this.cArgs) {
         args[i++] = match.Index;
         if (i < this.cArgs) {
           args[i++] = this.source;
           for (; i < this.cArgs; i++)
             args[i] = null;
         }
       }
     }
   }
   Object result = this.function.Call(args, null);
   return match.Result(result is Empty ? "" : Convert.ToString(result));
 }

            private static string Evaluate(Match match)
            {
                var prop = match.Groups[1].Value;
                if (!themeColors.ContainsKey(prop))
                    themeColors[prop] = themeColors["background-color"].Replace("background-color", prop);

                return match.Result(".theme-color-$1(");
            }

 /// <summary>
 /// Replace the URL placeholder {p:PropertyName} with the value of the corresponding
 /// property of the parent data object.
 /// </summary>
 /// <param name="m">The regex match that contains property name.</param>
 /// <returns>The property value to use.</returns>
 protected string GetPropertyValue(Match m)
 {
     string prop = m.Result("$1");
     DataObject parent = this.property.GetParent();
     if (parent != null && parent.HasProperty(prop))
         return parent[prop].EditStringValue;
     return m.Value;
 }

 protected virtual string GetMatch(Match m, ViewDataDictionary viewDataDictionary)
 {
     if (m.Success) {
         string key = m.Result("$1");
         if (viewDataDictionary.ContainsKey(key)) {
             return viewDataDictionary[key].ToString();
         }
     }
     return string.Empty;
 }

 protected MatchViewModel(Match model)
 {
     Model = model;
     var groups = model.Groups;
     var capture = model.Captures;// Capture has Index, Length, Value
     var index = model.Index;
     var length = model.Length;
     var next = model.NextMatch();
     var result = model.Result(stringg);
     var x = model.Success;
     var y = model.Value;
     groups[0].

 protected virtual string GetMatch(Match m, ViewDataDictionary viewData)
 {
     if (m.Success)
     {
         // 获取匹配后的结果，即 ViewData 中的 key 值，并根据这个 key 值返回 ViewData 中对应的 value
         string key = m.Result("$1");
         if (viewData.ContainsKey(key))
         {
             return viewData[key].ToString();
         }
     }
     return string.Empty;
 }

 internal override string Evaluate(Match match)
 {
     base.lastMatch = match;
     object[] args = new object[this.cArgs];
     if (this.cArgs > 0)
     {
         args[0] = match.ToString();
         if (this.cArgs > 1)
         {
             int index = 1;
             if (this.groupNumbers != null)
             {
                 while (index <= this.groupNumbers.Length)
                 {
                     Group group = match.Groups[this.groupNumbers[index - 1]];
                     args[index] = group.Success ? group.ToString() : null;
                     index++;
                 }
             }
             if (index < this.cArgs)
             {
                 args[index++] = match.Index;
                 if (index < this.cArgs)
                 {
                     args[index++] = this.source;
                     while (index < this.cArgs)
                     {
                         args[index] = null;
                         index++;
                     }
                 }
             }
         }
     }
     object obj2 = this.function.Call(args, null);
     return match.Result((obj2 is Microsoft.JScript.Empty) ? "" : Microsoft.JScript.Convert.ToString(obj2));
 }

        private string _ParseANSI(Match m)
        {
            string[] ansicode = m.Result( "$1" ).Split( new char[] { ';' } ); //取出所需結果，並切割成字串陣列
            StringBuilder ret = new StringBuilder(); //要回傳的字串

            foreach ( string s in ansicode )
            {
                if ( s == "" | s == "0" )
                {
                    //重置所有控制碼
                    brightness = "f0";
                    forecolor = "7";
                    backcolor = "b0";
                    blink = false;
                    underline = false;
                }
                else if ( s == "1" )
                {
                    //明暗
                    brightness = "f1";
                }
                else if ( s == "4" )
                {
                    //底線
                    underline = true;
                }
                else if ( s == "5" )
                {
                    //閃爍
                    blink = true;
                }
                else if ( s == "7" )
                {
                    //交換顏色
                    string tmp = forecolor;
                    forecolor = backcolor[1].ToString();
                    backcolor = "b" + tmp;
                }
                else if ( s[0].ToString() == "3" )
                {
                    //前景色
                    forecolor = s[1].ToString();
                }
                else if ( s[0].ToString() == "4" )
                {
                    //背景色
                    backcolor = "b" + s[1].ToString();
                }
            }

            ret.Append( opened == true ? "</span>" : "" ); //如果前面有未關閉的標籤，先關閉之

            if ( brightness == "f0" && forecolor == "7" && backcolor == "b0" && blink == false && underline == false )
            {
                /* TODO: 如果標籤跟上一個完全一樣，也不要寫入 */
                //目前控制碼完全跟預設值一樣，所以不寫入新的標籤
                opened = false; //沒有寫新的標籤，所以目前狀態為已關閉
            }
            else
            {
                //寫入新的標籤
                ret.Append( "<span class=\"" + brightness + forecolor + " " + backcolor ); //亮度及前景色、背景色
                ret.Append( blink == true ? " db" : "" ); //閃爍
                ret.Append( underline == true ? " du" : "" ); //底線
                ret.Append( "\">" );
                opened = true; //寫入了新的標籤，所以目前狀態為未關閉
            }

            return ret.ToString();
        }

        private static string ToUpperChar(Match context, string options, Func<char, char> processingFunction)
        {
            string result = string.Empty;
            Match match = charConversionOptionsParser.Match(context.Result(options));
            if (match.Success)
            {
                // Convert to char array:
                char[] charArray = context.Groups[match.Groups["GroupName"].Value].Value.ToCharArray();

                // Check for specified indices:
                Group indexGroup = match.Groups["Index"];
                if (indexGroup.Success)
                {
                    // Process indices:
                    foreach (Capture capture in indexGroup.Captures)
                    {
                        if (capture.Length > 0)
                        {
                            // Split options into range:
                            string[] range = capture.Value.Split('-');

                            // Parse "from" index:
                            int from;
                            if (!Int32.TryParse(range[0], out from))
                                from = 0;
                            int to = from;

                            // Parse "to" index:
                            if (range.Length > 1)
                            {
                                if (!Int32.TryParse(range[1], out to))
                                    to = charArray.Length - 1;
                            }

                            // Ensure valid range:
                            if (from < 0)
                                from = 0;
                            if (to >= charArray.Length)
                                to = charArray.Length - 1;

                            // Apply processing:
                            for (int i = from; i <= to; i++)
                                charArray[i] = processingFunction(charArray[i]);
                        }
                    }
                }
                // No indices specified. Fallback to default - process the first char (if possible):
                else if (charArray.Length > 0)
                {
                    charArray[0] = processingFunction(charArray[0]);
                }

                result = new string(charArray);
            }
            return result;
        }

 private string Evaluator(Match match)
 {
     string id = match.Result("$1");
     return _resolvings[id];
 }

        private string VersionChanger(Match match)
        {
            // assembly version would be in the format yyyy.dd.mm and assembly file version would be in the format yyyy.dd.mm.revsion
            // first find the type of assembly version
            string versionType = match.Groups[1].Value;

            // get the yyyy.mm.dd
            int yyyy = int.Parse(match.Groups[2].Value);
            int mm = int.Parse(match.Groups[3].Value);
            int dd = int.Parse(match.Groups[4].Value);

            var currentDate = DateTime.UtcNow;

            bool hasRevision = false; // we have the revision number only when change the assembly file version
            int revisionNumber = 1;

            if (!string.IsNullOrEmpty(match.Groups[5].Value))
            {
                hasRevision = true;
                revisionNumber = int.Parse(match.Groups[5].Value.Replace(".", string.Empty));

                // increment revision if same date
                if (yyyy == currentDate.Year && mm == currentDate.Month && dd == currentDate.Day)
                    ++revisionNumber;
                else
                    revisionNumber = 1;
            }

            var dateVersion = currentDate.ToString("yyyy.MM.dd");

            return string.Format(match.Result("[assembly: Assembly{0}Version(\"{1}{2}\")]"),
                versionType, dateVersion, ( hasRevision ? string.Format(".{0}",revisionNumber) : string.Empty));
        }

 private void PrintCanvas(Match match)
 {
     //this ugliness is just to visualize the solution.
     Console.WriteLine("Visualized:");
     Console.WriteLine();
     var solutionChars = match.Groups["SolutionChar"].GetCaptures();
     var canvas = Regex.Match(match.Result("$_"), @"~[~\s]+\Z").Value;
     var ordered = match.Groups["Filled"].GetCaptures()
         .Zip(solutionChars, (filled, c) => new {Char = c.Value, Order = filled.Length})
         .OrderBy(c => c.Order).Select(c => c.Char).ToArray();
     int index = 0;
     var solution = Regex.Replace(canvas, @"~", m => ordered[index++]);
     Console.WriteLine(solution);
 }

		private string replaceAllEvaluator(Match m)
		{
			//	So this method is called for every match

			//	We make a replacement in the range based upon
			//	the match range.
			string replacement = m.Result(_lastReplaceAllReplaceString);
			int start = _lastReplaceAllRangeToSearch.Start + m.Index + _lastReplaceAllOffset;
			int end = start + m.Length;

			Range r = new Range(start, end, Scintilla);
			_lastReplaceAllMatches.Add(r);
			r.Text = replacement;

			//	But because we've modified the document, the RegEx
			//	match ranges are going to be different from the
			//	document ranges. We need to compensate
			_lastReplaceAllOffset += replacement.Length - m.Value.Length;
			return replacement;
		}