C#高级编程四十六天----正则表达式

正则表达式

1.定义一个Regex类的实例

Regex regex=new Regex(“”);

这里初始化参数就是一个正则表达式,”\d”表示配置数字

2.判断是否匹配

判断一个字符串,是否匹配一个正则表达式,在Regex对象中,可以使用Regex.IsMatch(string )方法.

Regex regex = new Regex(@"\d");

bool b1=regex.IsMatch("abc"); //返回值为false，字符串中未包含数字

bool b2 = regex.IsMatch("abc3abc"); //返回值为true，因为字符串中包含了数字

3.获取匹配次数

使用Regex.Matches(string)方法得到一个Matched集合,再使用这个集合的Count属性.

int count=regex.Matches(“abc123abc”).Count;

count的值为3,因为匹配了三次数字

4.获取匹配内容

使用regex.Match(string)方法进行匹配

Regex regex = new Regex(@"\d");

string str=regex.Match("abc123abc").Value;

Console.WriteLine(str);

返回值为1,表示第一个匹配到的值

5.捕获

正则表达式中可以使用括号对部分值进行捕获,想要获取捕获的值,可以使用Regex.Match(string).Groups[int].Value来获取.

Regex regex = new Regex(@"\w2(\d*)"); //匹配两个字母间的数字串

string str=regex.Match("abc123abc").Groups[0].Value; //返回值为“123”

Console.WriteLine(str);

一.C#正则表达式符号模式

说明:由于在正则表达式中“ \ ”、“ ? ”、“ * ”、“ ^ ”、“ $ ”、“ + ”、“（”、“）”、“ | ”、“ { ”、“ [ ”等字符已经具有一定特殊意义,如果需要用他们的原始意义,则应该对它进行转义,例如希望在字符串中至少有一个”\”,那么正则表达式应该这么说:\\+.

一.在C#中,要使用正则表达式,请在源文件开头处添加以下语句:

using System.Text.RegularExpressions

二.Regex类常用的方法

1.静态的Match方法

使用静态Match方,可以得到源中第一个匹配模式的连续子串.

静态的Match方法有两个重载,分别是:

Regex.Match(string input,string pattren);

Regex.Match(string input,string pattren ,RegexOptions options);

第一种重载的参数表示:输入,模式

第二种重载的参数表示:输入,模式,RegexOptions枚举的”按位或”组合.

RegexOptions枚举的有效值是：

Complied表示编译此模式

CultureInvariant表示不考虑文化背景

ECMAScript表示符合ECMAScript，这个值只能和IgnoreCase、Multiline、Complied连用

ExplicitCapture表示只保存显式命名的组

IgnoreCase表示不区分输入的大小写

IgnorePatternWhitespace表示去掉模式中的非转义空白，并启用由#标记的注释

Multiline表示多行模式，改变元字符^和$的含义，它们可以匹配行的开头和结尾

None表示无设置，此枚举项没有意义

RightToLeft表示从右向左扫描、匹配，这时，静态的Match方法返回从右向左的第一个匹配

Singleline表示单行模式，改变元字符.的意义，它可以匹配换行符

注意：Multiline在没有ECMAScript的情况下，可以和Singleline连用。Singleline和Multiline不互斥，但是和ECMAScript互斥

2.静态的Matches方法

这个方法的重载形式同静态的Match方法,返回一个MatchCollection,表示输入中,匹配模式的匹配的集合.

3.静态的IsMatch()方法

此方法返回一个bool,重载形式同静态的Matches,若输入中匹配模式,返回true,否则返回false.可以理解为:IsMatch方法,返回Matches方法返回的集合是否为空.

四.Regex类的实例

1.字符串替换

例如我想把如下格式记录中的NAME值修改为WANG

string line="ADDR=1234;NAME=ZHANG;PHONE=123456";

Regex reg=new Regex("NAME=(.+);");

string modified=reg.Replace(line,"NAME=WANG;");

Console.WriteLine(modified);

分析:修改后的字符串为ADDR=1234;NAME=WANG;PHONE=123456

2.字符串匹配

例如我想提取刚才那条记录中的NAME值.

string line="ADDR=1234;NAME=ZHANG;PHONE=123456";

Regex reg=new Regex("NAME=(.+);");

Match match = reg.Match(line);

string value = match.Groups[1].Value;

Console.WriteLine(value);

3.Match实例:文本中含有"speed=30.2mph",需要提取该速度值，但是速度的单位可能是公制也可能是英制，mph,km/h,m/s都有可能；另外前后可能有空格。

string line = "lane=1;speed=30.3mph;acceleration=2.5mph/s";

Regex reg = new Regex(@"speed\s*=\s*([\d\.]+)\s*(mph|km/h|m/s)*");

Match match = reg.Match(line);

string value = match.Groups[1].Value;//数值

Console.WriteLine(value);

Console.WriteLine(match.Groups[2].Value);//单位

4.案例:解码gps的GPRMC字符串

Regex reg = new Regex(@"^\$GPRMC,[\d\.]*,[A|V],(-?[0-9]*\.?[0-9]+),([NS]*),(-?[0-9]*\.?[0-9]+),([EW]*),.*");

分析:以前需要几十行代码的工作,现在一行就完成了.

五.System.Text.RegularExpressions命名空间的说明

该命名空间包括8个类,1个枚举,1以委托.他们分别是:

Capture: 包含一次匹配的结果；

CaptureCollection: Capture的序列；

Group: 一次组记录的结果，由Capture继承而来；

GroupCollection：表示捕获组的集合

Match: 一次表达式的匹配结果，由Group继承而来；

MatchCollection: Match的一个序列；

MatchEvaluator: 执行替换操作时使用的委托；

Regex：编译后的表达式的实例。

RegexCompilationInfo：提供编译器用于将正则表达式编译为独立程序集的信息

RegexOptions 提供用于设置正则表达式的枚举值

Regex类中还包含一些静态的方法：

Escape: 对字符串中的regex中的转义符进行转义；

IsMatch: 如果表达式在字符串中匹配，该方法返回一个布尔值；

Match: 返回Match的实例；

Matches: 返回一系列的Match的方法；

Replace: 用替换字符串替换匹配的表达式；

Split: 返回一系列由表达式决定的字符串；

Unescape:不对字符串中的转义字符转义。

(1)”@”符号

“@”符号表示,跟在它后面的字符串是个”逐字字符串”,举例,一下两个声明是等效的:

string x=”c:\\syx\\haha”

string [email protected]”c:\syx\haha”

事实上如果按照如下声明:

string y=”c:\syx\haha”,C#会报错,因为”\”在C#中用于实现转移,如”\n”表示换行.

(2)基本的语法字符


字符
含义

\d
0-9的数字

\D
\d的补集(以所有字符为全集,下同),即所有的非数字的字符

\w
单词字符,指大小写字母,0-9的数字,下划线

\W
\w的补集

\s
空白字符,包括换行符\n,回车符\r,制表符\t,垂直制表符\v,换页符\f

\S
\s的补集

[...]
匹配[]内所列出的所有字符

[^...]
匹配非[]内所列出的所有字符

.
除换行符\n以外的任意字符

案例:

string i = "\n";

string m = "3";

Regex r = new Regex(@"\D");//同Regex r = new Regex("\\D");

Console.WriteLine(r.IsMatch(i));//输出true

Console.WriteLine(r.IsMatch(m));//输出false

案例:

string i = "%";

string m = "3";

//匹配小写字母或数字字符

Regex r = new Regex("[a-z0-9]");

Console.WriteLine(r.IsMatch(i));//输出false

Console.WriteLine(r.IsMatch(m));//输出true

(3)定位字符:

“定位字符”所代表的是一个虚的字符,它代表一个位置,你可以直观的认为”定位字符”所代表的hi某个字符与自附件的那个微小间隙.


定位字符
含义

^
表示其后的字符必须位于字符串的开始处

$
表示其前面的字符必须位于字符串的结尾处

\b
匹配一个单词的边界

\B
匹配一个非单词的边界

\A
前面的字符必须位于字符处的开始出

\z
前面的字符必须位于字符串的结尾处

\Z
前面的字符必须位于字符串的结尾处,或者位于换行符前

案例:

string i = "Live for nothing,die for something";

Regex r1 = new Regex("^Live for nothing,die for something$");

//r1.IsMatch(i) true

Regex r2 = new Regex("^Live for nothing,die for some$");

//r2.IsMatch(i) false

Regex r3 = new Regex("^Live for nothing,die for some");

//r3.IsMatch(i) true

案例:

string i = @"Live for nothing,

die for something";//多行

Regex r1 = new Regex("^Live for nothing,die for something$");

Console.WriteLine("r1 match count:" + r1.Matches(i).Count);//0

Regex r2 = new Regex("^Live for nothing,die for something$", RegexOptions.Multiline);

Console.WriteLine("r2 match count:" + r2.Matches(i).Count);//0

Regex r3 = new Regex("^Live for nothing,\r\ndie for something$");

Console.WriteLine("r3 match count:" + r3.Matches(i).Count);//1

Regex r4 = new Regex("^Live for nothing,$");

Console.WriteLine("r4 match count:" + r4.Matches(i).Count);//0

Regex r5 = new Regex("^Live for nothing,$", RegexOptions.Multiline);

Console.WriteLine("r5 match count:" + r5.Matches(i).Count);//0

Regex r6 = new Regex("^Live for nothing,\r\n$");

Console.WriteLine("r6 match count:" + r6.Matches(i).Count);//0

Regex r7 = new Regex("^Live for nothing,\r\n$", RegexOptions.Multiline);

Console.WriteLine("r7 match count:" + r7.Matches(i).Count);//0

Regex r8 = new Regex("^Live for nothing,\r$");

Console.WriteLine("r8 match count:" + r8.Matches(i).Count);//0

Regex r9 = new Regex("^Live for nothing,\r$", RegexOptions.Multiline);

Console.WriteLine("r9 match count:" + r9.Matches(i).Count);//1

Regex r10 = new Regex("^die for something$");

Console.WriteLine("r10 match count:" + r10.Matches(i).Count);//0

Regex r11 = new Regex("^die for something$", RegexOptions.Multiline);

Console.WriteLine("r11 match count:" + r11.Matches(i).Count);//1

Regex r12 = new Regex("^");

Console.WriteLine("r12 match count:" + r12.Matches(i).Count);//1

Regex r13 = new Regex("$");

Console.WriteLine("r13 match count:" + r13.Matches(i).Count);//1

Regex r14 = new Regex("^", RegexOptions.Multiline);

Console.WriteLine("r14 match count:" + r14.Matches(i).Count);//2

Regex r15 = new Regex("$", RegexOptions.Multiline);

Console.WriteLine("r15 match count:" + r15.Matches(i).Count);//2

Regex r16 = new Regex("^Live for nothing,\r$\n^die for something$", RegexOptions.Multiline);

Console.WriteLine("r16 match count:" + r16.Matches(i).Count);//1

对于一个多行字符串,在设置了Multiline选项之后,^和$将出现多次匹配.

案例:

string i = "Live for nothing,die for something";

string m = "Live for nothing,die for some thing";

Regex r1 = new Regex(@"\bthing\b");

Console.WriteLine("r1 match count:" + r1.Matches(i).Count);//0

Regex r2 = new Regex(@"thing\b");

Console.WriteLine("r2 match count:" + r2.Matches(i).Count);//2

Regex r3 = new Regex(@"\bthing\b");

Console.WriteLine("r3 match count:" + r3.Matches(m).Count);//1

Regex r4 = new Regex(@"\bfor something\b");

Console.WriteLine("r4 match count:" + r4.Matches(i).Count);//1

\b通常用于约束一个完整的单词

(4)重复描述符

“重复描述符”是体现C#正则表达式”很好很强大”的地方之一


重复描述符
含义

{n}
匹配前面的字符n次

{n,}
匹配前面的字符n次或多余n次

{n,m}
匹配前面的字符n到m次

?
匹配前面的字符0或者1次

+
匹配前面的字符1次或多于1次

*
匹配前面的字符0次或多于0次

案例:匹配1000到9999的整数

string x = "1024";

string y = "+1024";

string z = "1,024";

string a = "1";

string b = "-1024";

string c = "10000";

Regex r = new Regex(@"^\+?[1-9],?\d{3}$");

Console.WriteLine("x match count:" + r.Matches(x).Count);//1

Console.WriteLine("y match count:" + r.Matches(y).Count);//1

Console.WriteLine("z match count:" + r.Matches(z).Count);//1

Console.WriteLine("a match count:" + r.Matches(a).Count);//0

Console.WriteLine("b match count:" + r.Matches(b).Count);//0

Console.WriteLine("c match count:" + r.Matches(c).Count);//0

(5)择一匹配

C#正则表达式中的(|)符号似乎没有一个专门的称为,姑且称之为”择一匹配”吧.事实上,像[a-z]也是一种择一匹配,只不过它只能匹配单个字符,而(|)则提供了更大的范围,(ab|xy)表示匹配ab或匹配xy.注意”|”与”()”在此是一个整体.

案例:匹配0到100的整数.最外层的括号包含两部分”(100(.0+)*)” , “([1-9]?[0-9])(\.\d+)*”,这两部分是”OR”的关系,即正则表达式引擎会现场时匹配100,如果失败,则尝试匹配后一个表达式(表示[0,100)范围中的数字)

string x = "0";

string y = "0.23";

string z = "100";

string a = "100.01";

string b = "9.9";

string c = "99.9";

string d = "99.";

string e = "00.1";

Regex r = new Regex(@"^\+?((100(.0+)*)|([1-9]?[0-9])(\.\d+)*)$");

Console.WriteLine("x match count:" + r.Matches(x).Count);//1

Console.WriteLine("y match count:" + r.Matches(y).Count);//1

Console.WriteLine("z match count:" + r.Matches(z).Count);//1

Console.WriteLine("a match count:" + r.Matches(a).Count);//0

Console.WriteLine("b match count:" + r.Matches(b).Count);//1

Console.WriteLine("c match count:" + r.Matches(c).Count);//1

Console.WriteLine("d match count:" + r.Matches(d).Count);//0

Console.WriteLine("e match count:" + r.Matches(e).Count);//0

(6)特殊字符的匹配

案例:匹配“\”

string x = "\\";

Regex r1 = new Regex("^\\\\$");

Console.WriteLine("r1 match count:" + r1.Matches(x).Count);//1

Regex r2 = new Regex(@"^\\$");

Console.WriteLine("r2 match count:" + r2.Matches(x).Count);//1

Regex r3 = new Regex("^\\$");

Console.WriteLine("r3 match count:" + r3.Matches(x).Count);//0

案例:匹配双引号

string x = "\"";

Regex r1 = new Regex("^\"$");

Console.WriteLine("r1 match count:" + r1.Matches(x).Count);//1

Regex r2 = new Regex(@"^""$");

Console.WriteLine("r2 match count:" + r2.Matches(x).Count);//1

(7)组与非捕获组

案例:

//正则表达式引擎会记忆“()”中匹配到的内容，作为一个“组”，并且可以通过索引的方式进行引用。表达式中的“\1”，用于反向引用表达式中出现的第一个组，即粗体标识的第一个括号内容，“\2”则依此类推。

string x = "Live for nothing,die for something";

string y = "Live for nothing,die for somebody";

Regex r = new Regex(@"^Live ([a-z]{3}) no([a-z]{5}),die \1 some\2$");

Console.WriteLine("x match count:" + r.Matches(x).Count);//1

Console.WriteLine("y match count:" + r.Matches(y).Count);//0

案例:            //获取组中的内容。注意，此处是Groups[1]，因为Groups[0]是整个匹配的字符串，即整个变量x的内容。

string x = "Live for nothing,die for something";

Regex r = new Regex(@"^Live for no([a-z]{5}),die for some\1$");

if (r.IsMatch(x))

{

Console.WriteLine("group1 value:" + r.Match(x).Groups[1].Value);//输出：thing

}

案例:            //可根据组名进行索引。使用以下格式为标识一个组的名称(?<groupname>…)。

string x = "Live for nothing,die for something";

Regex r = new Regex(@"^Live for no(?<g1>[a-z]{5}),die for some\1$");

if (r.IsMatch(x))

{

Console.WriteLine("group1 value:" + r.Match(x).Groups["g1"].Value);//输出：thing

}

案例:            //删除原字符串中重复出现的“nothing”。在表达式之外，使用“$1”来引用第一个组，下面则是通过组名来引用：

string x = "Live for nothing nothing";

Regex r = new Regex(@"([a-z]+) \1");

if (r.IsMatch(x))

{

x = r.Replace(x, "$1");

Console.WriteLine("var x:" + x);//输出：Live for nothing

}

案例://在组前加上“?:”表示这是个“非捕获组”，即引擎将不保存该组的内容。

string x = "Live for nothing nothing";

Regex r = new Regex(@"(?<g1>[a-z]+) \1");

if (r.IsMatch(x))

{

x = r.Replace(x, "${g1}");

Console.WriteLine("var x:" + x);//输出：Live for nothing

}

string x = "Live for nothing";

Regex r = new Regex(@"^Live for no(?:[a-z]{5})$");

if (r.IsMatch(x))

{

Console.WriteLine("group1 value:" + r.Match(x).Groups[1].Value);//输出：(空)

}

(8)贪婪与非贪婪

正则的引擎是贪婪,只要模式允许,它将匹配尽可能多的字符.通过在”重复描述符”(+,*)后面添加”?”,可以将匹配模式改成非贪婪.实例:

string x = "Live for nothing,die for something";

Regex r1 = new Regex(@".*thing");

if (r1.IsMatch(x))

{

Console.WriteLine("match:" + r1.Match(x).Value);//输出：Live for nothing,die for something

}

Regex r2 = new Regex(@".*?thing");

if (r2.IsMatch(x))

{

Console.WriteLine("match:" + r2.Match(x).Value);//输出：Live for nothing

}

(9)回溯与非回溯

使用”(?>...)”方式进行非回溯声明.由于正则表达式引擎的贪婪特性,导致他在某些情况下,将进行回溯以获得匹配,实例:

//在r1中，“.*”由于其贪婪特性，将一直匹配到字符串的最后，随后匹配“thing”，但在匹配“,”时失败，此时引擎将回溯，并在“thing,”处匹配成功。

string x = "Live for nothing,die for something";

Regex r1 = new Regex(@".*thing,");

if (r1.IsMatch(x))

{

Console.WriteLine("match:" + r1.Match(x).Value);//输出：Live for nothing,

}

Regex r2 = new Regex(@"(?>.*)thing,");

if (r2.IsMatch(x))//不匹配

{

Console.WriteLine("match:" + r2.Match(x).Value);

}

分析:由于强制非回溯,所以整个表达式匹配失败.

(10)正向预搜索,反向预搜索

正向预搜索声明格式:正声明”(?=...)”,负声明”(?!...)”,声明本身不作为最终匹配结果的一部分,示例如下:

//r1中的正声明表示必须保证在四位数字的后面必须紧跟着“ used”，r2中的负声明表示四位数字之后不能跟有“ used”。

string x = "1024 used 2048 free";

Regex r1 = new Regex(@"\d{4}(?= used)");

if (r1.Matches(x).Count == 1)

{

Console.WriteLine("r1 match:" + r1.Match(x).Value);//输出：1024

}

Regex r2 = new Regex(@"\d{4}(?! used)");

if (r2.Matches(x).Count == 1)

{

Console.WriteLine("r2 match:" + r2.Match(x).Value); //输出：2048

}

反向预搜索声明格式：正声明“(?<=)”，负声明“(?<!)”，声明本身不作为最终匹配结果的一部分，请看下面的示例：

//r1中的反向正声明表示在4位数字之前必须紧跟着“used:”，r2中的反向负声明表示在4位数字之前必须紧跟着除“used:”之外的字符串。

string x = "used:1024 free:2048";

Regex r1 = new Regex(@"(?<=used:)\d{4}");

if (r1.Matches(x).Count == 1)

{

Console.WriteLine("r1 match:" + r1.Match(x).Value);//输出：1024

}

Regex r2 = new Regex(@"(?<!used:)\d{4}");

if (r2.Matches(x).Count == 1)

{

Console.WriteLine("r2 match:" + r2.Match(x).Value);//输出：2048

}

(11)十六进制字符范围

正则表达式中，可以使用 "\xXX" 和 "\uXXXX" 表示一个字符（"X" 表示一个十六进制数）形式字符范围：

\xXX       编号在 0到255 范围的字符，比如：空格可以使用 "\x20" 表示。

\uXXXX   任何字符可以使用 "\u" 再加上其编号的4位十六进制数表示，比如：汉字可以使用“[\u4e00-\u9fa5]”表示。

(12)对[0,100]的比较完备的匹配

案例:

下面是一个比较综合的示例，对于匹配[0,100]，需要特殊考虑的地方包括

*00合法，00.合法，00.00合法，001.100合法

*空字符串不合法，仅小数点不合法，大于100不合法

*数值是可带后缀的，如“1.07f”表示该值为一个float类型（未考虑）

Regex r = new Regex(@"^\+?0*(?:100(\.0*)?|(\d{0,2}(?=\.\d)|\d{1,2}(?=($|\.$)))(\.\d*)?)$");

string x = "";

while (true)

{

x = Console.ReadLine();

if (x != "exit")

{

if (r.IsMatch(x))

{

Console.WriteLine(x + " succeed!");

}

else

{

Console.WriteLine(x + " failed!");

}

}

else

{

break;

}

}

（13）精确匹配有时候是困难的

有些需求要做到精确匹配比较困难，例如：日期、Url、Email地址等，其中一些你甚至需要研究一些专门的文档写出精确完备的表达式，对于这种情况，只能退而求其次，保证比较精确的匹配。例如对于日期，可以基于应用系统的实际情况考虑一段较短的时间，或者对于像Email的匹配，可以只考虑最常见的形式。

版权声明：本文为博主原创文章，未经博主允许不得转载。

时间： 2024-10-13 01:03:15

C#高级编程四十六天----正则表达式的相关文章

C#高级编程五十六天----可观察的集合ObservableCollection

可观察的集合 如果需要集合中的元素核实删除或添加的信息,就可以使用ObservableCollection<T>类. ObservableCollection<T>类表示一个动态数据集合,在添加项,移除项或刷新整个列表时,刺激和将提供通知. 命名空间:System.Collections.ObjectModle 语法:public class ObservableCollection<T>:Collection<T>,INotifyCollectionCha

C#高级编程六十六天----表达式树总结

表达式树总结 基础 表达式树提供了一个将可执行代码转换成数据的方法.如果你要在执行代码之前修改或转换此代码,那么它是很有用的.有其是当你要将C#代码----如LINQ查询表达式转换成其他代码在另一个程序----如SQL数据库里操作它. 表达式树的语法: 考虑下面简单的Lambda表达式: Func<int,int,int>function=(a,b)=>a+b; 这个语法包含三个部分: 1.一个声明 : Func<int,int,int>function 2.一个等号 : =

C#高级编程六十六天----表达式树总结【转】

https://blog.csdn.net/shanyongxu/article/details/47257139 表达式树总结 基础 表达式树提供了一个将可执行代码转换成数据的方法.如果你要在执行代码之前修改或转换此代码,那么它是很有用的.有其是当你要将C#代码----如LINQ查询表达式转换成其他代码在另一个程序----如SQL数据库里操作它. 表达式树的语法: 考虑下面简单的Lambda表达式: Func<int,int,int>function=(a,b)=>a+b; 这个语法包

C#高级编程四十九天----队列

队列 1.Queue定义 System.Collections.Queue类表示对象的先进先出集合,存储在Queue(队列)中的对象在一端插入,从还有一端移除. 2.长处 (1).能对集合进行顺序处理(先进先出) (2)能接受null值,而且同意反复的元素 3.Queue的构造器 构造器函数 凝视 Queue() 初始化Queue类的新实例,该实例为空,具有默认初始容量(32)并使用默认增长因子(2.0) Queue(ICollection) 初始化Queue类的新实例,该实例包括从指定集合复制

C#高级编程四十天----运算符重载

运算符重载 所谓的运算符重载是指允许用户使用用户定义的类型编写表达式的能力. 例如,通常需要编写类似与以下内容的代码,入江两个数字相加,很明显,sum是两个数字之和. int i=5,j=4; int sum = i+j; 如果可以使用代表附属的用户定义的类型来编写相同类型的表达式,那当然是最好不过的了: Complex i=5; Complex sum=i+j; 运算符重载允许为用户定义的类型重载(即指明明确的含义)诸如"+"这样的运算符.如果不进行重载,则用户需要编写以下代码: C

C#高级编程四十四天-----string和stringbuilder

System.String类 首先string类是静态的,System.String是最常用的字符串操作类,可以帮助开发者完成绝大部分的字符串操作功能,使用方便. 1.比较字符串 比较字符串是指按照字典排序规则,判定两个字符的相对大小.按照点点规则,在一本英文字典中,出现在前面的单词小于出现在后面的单词.在string类中,常用的比较字符串的方法包括Compare,CompareTo,CompareOrdinal以及Equals,下面进行详细的介绍. Compare()方法是string类的静态

C#高级编程五十四天----Lookup类和有序字典

Lookup类 Dictionary<Tkey,TValue>只为每个键支持一个值.新类Lookup<Tkey,TValue>是.NET3.5中新增的,它类似与Dictionary<Tkey,TElement>,但把键映射带一个值集上.这个类在程序及System.Core中实现,用System,Linq命名空间定义. Lookup<Tkey,TElement>的方法和属性如下表: 属性名或者方法名 说明 Count 属性Count返回集合中的元素个数 Ite

【读书笔记】C#高级编程 第二十四章 文件和注册表操作

(一)文件和注册表 对于文件系统操作,相关的类几乎都在System.IO名称空间中,而注册表操作由System.Win32名称空间中的类来处理. (二)管理文件系统 System.MarshalByRefObject--这是.NET类中用于远程操作的基对象类,它允许在应用程序域之间编组数据. FileSystemInfo--这是表示任何文件系统对象的基类. FileInfo和File--这些类表示文件系统上的文件. DirectoryInfo和Directory--这些类表示文件系统上的文件夹.

【读书笔记】C#高级编程 第十四章 内存管理和指针

(一)后台内存管理 1.值数据类型 Windows使用一个虚拟寻址系统,该系统把程序可用的内存地址映射到硬件内存中的实际地址,该任务由Windows在后台管理(32位每个进程可使用4GB虚拟内存,64位更多,这个内存包括可执行代码和加载的DLL,以及程序运行时使用的变量内容). 在处理器的虚拟内存中,有一个区域称为栈.栈存储不是对象成员的值数据类型. 释放变量时,其顺序总是与它们分配内存的顺序相反,这就是栈的工作方式. 程序第一次运行时,栈指针指向为栈保留的内存块末尾.栈实际上是向下填充的,即从