C#语言学习之旅(7)字符串和正则表达式

本章节将讲述关于字符串方面的处理问题。

 7.1 创建字符串

如果多次修改一个字符串的话，处理效率会变得效率低下。对于这种情况下，应该使用C#专门处理较长字符串的一个类:system.text.bulider，该类是专门用来处理上述问题的。

下面给出使用代码：

using System;

using System.Collections.Generic;

using System.Text;



namespace Wrox.ProCSharp.StringEncoder

{

   class MainEntryPoint

   {

      static void Main(string[] args)

      {

         StringBuilder greetingBuilder =

            new StringBuilder("Hello from all the guys at Wrox Press. ", 150);

         greetingBuilder.Append("We do hope you enjoy this book as much as we enjoyed writing it");



         for(int i = (int)'z'; i>=(int)'a' ; i--)

         {

            char Old = (char)i;

            char New = (char)(i+1);

            greetingBuilder = greetingBuilder.Replace(Old, New);

         }



         for(int i = (int)'Z'; i>=(int)'A' ; i--)

         {

            char Old = (char)i;

            char New = (char)(i+1);

            greetingBuilder = greetingBuilder.Replace(Old, New);

         }

         Console.WriteLine("Encoded:\n" + greetingBuilder.ToString());

                    

      }

   }

}

 说明：使用该类并不是总能提高性能的，只有基于处理多个字符串时使用。但如果只是处理连接连个字符串的话，最好还是使用string类比较好。

7.2 格式化字符串

 格式化字符串就是能够以各种方法显示变量的内容，.net运行库中定义了一种标准方法：使用接口IFormatetable。

下面给出字符串格式表

字符	说明	示例	输出
C 或 c	货币	Console.Write("{0:C}", 2.5); Console.Write("{0:C}", -2.5);	$2.50 ($2.50)
D 或 d	十进制	Console.Write("{0:D5}", 25);	00025
E 或 e	科学型	Console.Write("{0:E}", 250000);	2.500000E+005
F 或 f	固定点	Console.Write("{0:F2}", 25); Console.Write("{0:F0}", 25);	25.00 25
G 或 g	常规	Console.Write("{0:G}", 2.5);	2.5
N 或 n	数字	Console.Write("{0:N}", 2500000);	2,500,000.00
X 或 x	十六进制	Console.Write("{0:X}", 250); Console.Write("{0:X}", 0xffff);	FA FFFF

 下面是IFormattable的定义

interface IFormattable

{

string ToString(string formate,IFormateProvider formateProvider)；

}

接着来实现字符串格式化：

using System;

using System.Collections.Generic;

using System.Text;





namespace Wrox.ProCSharp.FormattableVector

{

    class MainEntryPoint

    {

        static void Main()

        {

            Vector v1 = new Vector(1, 32, 5);

            Vector v2 = new Vector(845.4, 54.3, -7.8);

            Console.WriteLine("\nIn IJK format,\nv1 is {0,30:IJK}\nv2 is {1,30:IJK}", v1, v2);

            Console.WriteLine("\nIn default format,\nv1 is {0,30}\nv2 is {1,30}", v1, v2);

            Console.WriteLine("\nIn VE format\nv1 is {0,30:VE}\nv2 is {1,30:VE}", v1, v2);

            Console.WriteLine("\nNorms are:\nv1 is {0,20:N}\nv2 is {1,20:N}", v1, v2);

        }

    }



    struct Vector : IFormattable

    {

        public double x, y, z;



        public Vector(double x, double y, double z)

        {

            this.x = x;

            this.y = y;

            this.z = z;

        }



        public string ToString(string format, IFormatProvider formatProvider)

        {

            if (format == null)

                return ToString();

            string formatUpper = format.ToUpper();

            switch (formatUpper)

            {

                case "N":

                    return "|| " + Norm().ToString() + " ||";

                case "VE":

                    return String.Format("( {0:E}, {1:E}, {2:E} )", x, y, z);

                case "IJK":

                    StringBuilder sb = new StringBuilder(x.ToString(), 30);

                    sb.Append(" i + ");

                    sb.Append(y.ToString());

                    sb.Append(" j + ");

                    sb.Append(z.ToString());

                    sb.Append(" k");

                    return sb.ToString();

                default:

                    return ToString();

            }

        }



        public Vector(Vector rhs)

        {

            x = rhs.x;

            y = rhs.y;

            z = rhs.z;

        }



        public override string ToString()

        {

            return "( " + x + " , " + y + " , " + z + " )";

        }



        public double this[uint i]

        {

            get

            {

                switch (i)

                {

                    case 0:

                        return x;

                    case 1:

                        return y;

                    case 2:

                        return z;

                    default:

                        throw new IndexOutOfRangeException(

                           "Attempt to retrieve Vector element" + i);

                }

            }

            set

            {

                switch (i)

                {

                    case 0:

                        x = value;

                        break;

                    case 1:

                        y = value;

                        break;

                    case 2:

                        z = value;

                        break;

                    default:

                        throw new IndexOutOfRangeException(

                           "Attempt to set Vector element" + i);

                }

            }

        }



        /* public static bool operator == (Vector lhs, Vector rhs)

           {

              if (lhs.x == rhs.x && lhs.y == rhs.y && lhs.z == rhs.z)

                 return true;

              else

                 return false;

           }*/



        private const double Epsilon = 0.0000001;



        //以下都是重载运算

        public static bool operator ==(Vector lhs, Vector rhs)

        {

            if (System.Math.Abs(lhs.x - rhs.x) < Epsilon &&

               System.Math.Abs(lhs.y - rhs.y) < Epsilon &&

               System.Math.Abs(lhs.z - rhs.z) < Epsilon)

                return true;

            else

                return false;

        }



        public static bool operator !=(Vector lhs, Vector rhs)

        {

            return !(lhs == rhs);

        }



        public static Vector operator +(Vector lhs, Vector rhs)

        {

            Vector Result = new Vector(lhs);

            Result.x += rhs.x;

            Result.y += rhs.y;

            Result.z += rhs.z;

            return Result;

        }



        public static Vector operator *(double lhs, Vector rhs)

        {

            return new Vector(lhs * rhs.x, lhs * rhs.y, lhs * rhs.z);

        }



        public static Vector operator *(Vector lhs, double rhs)

        {

            return rhs * lhs;

        }



        public static double operator *(Vector lhs, Vector rhs)

        {

            return lhs.x * rhs.x + lhs.y + rhs.y + lhs.z * rhs.z;

        }



        public double Norm()

        {

            return x * x + y * y + z * z;

        }

    }

}

 7.3 正则表达式

正则表达式主要是用来处理字符串的语言，这个在js上面用的很多。

下面给出简单使用示例：

using System;

using System.Collections.Generic;

using System.Text;

using System.Text.RegularExpressions;



namespace Wrox.ProCSharp.RegularExpressionPlayaround

{

    class MainEntryPoint

    {

        static void Main()

        {

            Find1();

            Console.ReadLine();

        }



        static void Find1()

        {

            string text = @"XML has made a major impact in almost every aspect of 

            software development. Designed as an open, extensible, self-describing 

            language, it has become the standard for data and document delivery on 

            the web. The panoply of XML-related technologies continues to develop 

            at breakneck speed, to enable validation, navigation, transformation, 

            linking, querying, description, and messaging of data.";

            string pattern = @"\bn\S*ion\b";

            MatchCollection matches = Regex.Matches(text, pattern,

               RegexOptions.IgnoreCase | RegexOptions.IgnorePatternWhitespace |

               RegexOptions.ExplicitCapture);

            WriteMatches(text, matches);

        }



        static void Find2()

        {

            string text = @"XML has made a major impact in almost every aspect of 

            software development. Designed as an open, extensible, self-describing 

            language, it has become the standard for data and document delivery on 

            the web. The panoply of XML-related technologies continues to develop 

            at breakneck speed, to enable validation, navigation, transformation, 

            linking, querying, description, and messaging of data.";

            string pattern = @"\bn";

            MatchCollection matches = Regex.Matches(text, pattern,

              RegexOptions.IgnoreCase);

            WriteMatches(text, matches);

        }



        static void WriteMatches(string text, MatchCollection matches)

        {

            Console.WriteLine("Original text was: \n\n" + text + "\n");

            Console.WriteLine("No. of matches: " + matches.Count);

            foreach (Match nextMatch in matches)

            {

                int Index = nextMatch.Index;

                string result = nextMatch.ToString();

                int charsBefore = (Index < 5) ? Index : 5;

                int fromEnd = text.Length - Index - result.Length;

                int charsAfter = (fromEnd < 5) ? fromEnd : 5;

                int charsToDisplay = charsBefore + charsAfter + result.Length;



                Console.WriteLine("Index: {0}, \tString: {1}, \t{2}",

                   Index, result,

                   text.Substring(Index - charsBefore, charsToDisplay));



            }

        }

    }

}

小结：这一章节写的比较少，主要讲了如何字符串各种方法。下一章节将讲泛型