C# 字符串操作学习总结

最新推荐文章于 2024-05-01 14:22:29 发布
最新推荐文章于 2024-05-01 14:22:29 发布
阅读量2.3k 收藏 10
点赞数
分类专栏： .Net 文章标签： c# string

C#中字符串操作总结

http://blog.csdn.net/beyondqd/article/details/6999030

在实际的开发过程中，对字符串的操作是经常遇到的，其中涉及到字符串拼接、拆分、比较、替换等操作。C#提供了string类型，String和StringBuilder两种类来对字符串进行处理。那么string，String，StringBuilder对字符串进行处理有何异同，在实际编程中，对于不同的字符串操作应该采用哪种方式来提高程序的效率呢?本文将对string，String，StringBuilder进行详细的解释和比较，最后在编程过程中遇到的常用的字符串处理进行了总结。
　　首先理解string，String，StringBuilder的概念和区别：

　　string

　　string，msdn给出的解释就是，string 是C#中的关键字，并且是引用类型， string 类型表示零或更多 Unicode 字符组成的序列。string 是 .NET Framework 中 String 的别名。但定义相等运算符(== 和 !=)是为了比较 string 对象(而不是引用)的值(后面给出示例解释这点)。

　　String：

　　String是类，表示文本，即一系列 Unicode 字符。String 对象是不可改变的。每次使用 System.String 类中的方法之一时，都要在内存中创建一个新的字符串对象，这就需要为该新对象分配新的空间。如：当我们实例化一个String的对象后，在内存中为此对象分配一个空间。如下：String str = “hello”;当我们修改str的值的时候，如：str = “hello world”;此时，系统会为str重新分配一个空间。这样原来的内存空间就被浪费掉了，只能等待垃圾回收器回收。在需要对字符串执行重复修改的情况下，与创建新的 String对象相关的系统开销可能会非常昂贵。

　　String与string的区别：

　　string 是 .NET Framework 中 String 的别名，string是C#基元类型(primitive)，简单来说就是编译器直接支持的数据类型。基元类型要直接映射到Framework类库(FCL)中的类型，例如，C#中一个基元类型int直接映射到System.Int32类型，这里int是基元类型，System.Int32是FCL类型。而String是FCL类型的，所以在C#的编译时，会自动的把string转化为System.String。所以string与String实质上没什么区别，只是在使用string要做一次转换，转换为String。因此，在编码时我们推荐使用String。

　　string虽然为引用类型，但是(== 和 !=)是为了比较 string 对象(而不是引用)的值。

　　如： 

    　string a = "hello";
　　string b = "hel";
　　b = b + "lo";
　　string c = "hello";
　　Response.Write(a==b); //True
　　Response.Write((object)a == (object)b); //False
　　Response.Write((object)a == (object)c); //True

　　　a==b比较的是值而非引用。所以a==b为True。当创建多个字符串内容相同的对象时，都只会指向同一个引用; a和c都指向同一个a的引用,并不会为c重新分配内存;这样即可保证内存有效利用;所以上面的(object)a == (object)c比较的是a与c的引用，结果为True。这里面b由于进行了累加操作(b = b + "lo";)b又重新分配了内存，所以(object)a == (object)b比较的是引用，所以为False。

　　接下来我们再通过几个例子来理解下String(string)

　    String str1 = "abc";
　　String str2 = str1;
　　str1 = "123";

　　Response.Write(str2);//abc


　　输出结果是abc，首先给str赋值为"abc"，接着执行str2 = str1，使str2和str1指向同一引用，即内存地址。当执行str1 = "123"后，String对象是不可改变的，实质上str1 = "123"是str1=new string("123")的简写，它的每一次赋值都会抛掉原来的对象而生成一个新的字符串对象，分配新的内存空间，str1 = "123"语句编译器私底下创建了一个新的字符串对象来保存新的字符序列"123"，也就是此str1已非彼str1了。因此str1的值的改变也就不能影响先前str1指向地址的值了，当然str2的值也就不会改变了。因此string是不可改变的。

　　通过上面的例子，如果我们执行下面这些语句：

String sql = “Select * From T_Test ”;
　　sql += “Where id=888 ”;
        sql += “And type=3 ”;

　　sql += “Order By Desc”;


　　实际上这样是十分浪费内存空间的。如果是频繁的这样做的话，建议是使用StringBuilder对象，或者这样写：String sql = “Select * From T_Test” + “Where id=888 ” + “And type=3” + “Order By Desc ” ;

　　StringBuilder:

　　出于性能方面的考虑，大量的串联或所涉及其他字符串操作应通过StringBuilder类来执行。StringBuilder表示可变字符字符串, 它允许我们有效的对字符串的字符执行动态操作，有效的缩减字符串的大小或者更改字符串中的字符。如果字符串变大，超过已经分配的字符的大小，StringBuilder就会自动的分配一个全新的、更大的数组，并开始使用新的数组，虽然 StringBuilder 对象是动态对象，允许扩充它所封装的字符串中字符的数量，但是您可以为它可容纳的最大字符数指定一个值。此值称为该对象的容量，不应将它与当前 StringBuilder 对象容纳的字符串长度混淆在一起。例如，可以创建 StringBuilder 类的带有字符串“Hello”(长度为 5)的一个新实例，同时可以指定该对象的最大容量为 25。当修改 StringBuilder 时，在达到容量之前，它不会为其自己重新分配空间。当达到容量时，将自动分配新的空间且容量翻倍。可以使用重载的构造函数之一来指定 StringBuilder 类的容量。

　　String 或 StringBuilder 对象的串联操作的性能取决于内存分配的发生频率。String 串联操作每次都分配内存，而 StringBuilder 串联操作仅当 StringBuilder 对象缓冲区太小而无法容纳新数据时才分配内存。因此，如果串联固定数量的 String 对象，则 String 类更适合串联操作。这种情况下，编译器甚至会将各个串联操作组合到一个操作中。如果串联任意数量的字符串，则 StringBuilder 对象更适合串联操作;例如，某个循环对用户输入的任意数量的字符串进行串联。

C#中判断空字符串

　　首先明确””，null和string.Empty的区别：

　　string.Empty：不分配存储空间。

　　""：分配一个长度为空的存储空间 ，""和String.Empty，这两个都是表示空字符串，空字符串是一个特殊的字符串，只不过这个字符串的值为空，在内存中是有准确的指向的。

　　string.Empty就相当于""，一般用于字符串的初始化。比如： string a = string.Empty;在进行为空的比较时。string.Empty和""是一样的。即如果string test1 = "";则可以使用if(test1=="") 或者if(test1==string.Empty) 进行判断。上面两句是一样的效果。

　　Null：null 关键字是表示不引用任何对象的空引用的文字值。null 是引用类型变量的默认值。那么也只有引用型的变量可以为NULL，如果 int i=null,的话，是不可以的，因为Int是值类型的。

　　String.Empty和Null，这两个都是表示空字符串，string str1= String.Empty，这样定义后，str1是一个空字符串，空字符串是一个特殊的字符串，只不过这个字符串的值为空，在内存中是有准确的指向的 ，string str2=null,这样定义后，只是定义了一个string 类的引用，str2并没有指向任何地方，在使用前如果不实例化的话，都将报错。所以下面代码中执行test3.Length == 0就是错误的。

　　判断空字符串：　 

　  string test1 = "";
　　string test2 = string.Empty;
　　string test3 = null;
　　Response.Write("test1 = \"\"" +" ");
　　Response.Write("test2 = string.Empty"  "</br>");
　　Response.Write("test3 = null" + "</br>");
　　if (test1 == "")
　　Response.Write("(test1 == \"\") is :True"+"</br>");
　　if(test2 == string.Empty)
　　Response.Write("(test2 == string.Empty) is:True" + "</br>");

　　if(test1 == string.Empty)
　　Response.Write("(test1 == string.Empty) is: True" + "</br>");
　　if(test2 == "")
　　Response.Write("(test2 == \"\") is: True" + "</br>");

　　if(test1 == test2)
　　Response.Write("(test1 == test2) is: True" + "</br>");

　　if(test3 == null)
　　Response.Write("(test3 == null) is: True" + "</br>");

　　if (test1 != null)
　　Response.Write("(test1 != null) is : True" + "</br>");

　　if (test2 != null)
　　Response.Write("(test2 != null) is : True" + "</br>");

　　if(test1.Length ==0)
　　Response.Write("(test1.Length ==0) is: True" + "</br>");

　　if(test2.Length==0)
　　Response.Write("(test2.Length==0) is : True" + "</br>");
　　//if(test3.Length == 0)//Error,null不能用Length来进行判断为空
　　if(string.IsNullOrEmpty(test1))

　　Response.Write("(string.IsNullOrEmpty(test1)) is :True" + "</br>");
　　if (string.IsNullOrEmpty(test2))

　　Response.Write("(string.IsNullOrEmpty(test2)) is :True" + "</br>");
　　if (string.IsNullOrEmpty(test3))

　　Response.Write("(string.IsNullOrEmpty(test3)) is :True" + "</br>");

　　输出：


　　test1 = ""
　　test2 = string.Empty
　　test3 = null
　　(test1 == "") is :True
　　(test2 == string.Empty) is:True
　　(test1 == string.Empty) is: True
　  (test2 == "") is: True
　　(test1 == test2) is: True
　　(test3 == null) is: True
　　(test1 != null) is : True
　　(test2 != null) is : True
　　(test1.Length ==0) is: True
　　(test2.Length==0) is : True
　　(string.IsNullOrEmpty(test1)) is :True
　　(string.IsNullOrEmpty(test2)) is :True
　　(string.IsNullOrEmpty(test3)) is :True

　　因此，判断字符串为空最通用的方法就是IsNullOrEmpty()无论是"", string.Empty还是null。如果字符串初始化为null，则不能使用test3.Length == 0进行判断。对于"",和string.Empty 使用s.Length == 0，s == string.Empty 和s == ""都可以，这里面不讨论性能问题。

比较字符串相等
　　Equals() 和运算符 ==

　　C# 中有两种不同的相等：引用相等和值相等。值相等是大家普遍理解的意义上的相等：它意味着两个对象包含相同的值。例如，两个值为 2 的整数具有值相等性。引用相等意味着要比较的不是两个对象，而是两个对象引用，且两者引用的是同一个对象。这可以通过简单的赋值来实现，如下面的示例所示：

　　System.Object a = new System.Object();

　　System.Object b = a;

　　System.Object.ReferenceEquals(a, b); //returns true

　　在上面的代码中，只存在一个对象，但存在对该对象的多个引用：a 和 b。由于它们引用的是同一个对象，因此具有引用相等性。如果两个对象具有引用相等性，则它们也具有值相等性，但是值相等性不能保证引用相等性。

　　若要检查引用相等性，应使用 ReferenceEquals。若要检查值相等性，请使用 Equals。

　　运算符 ==

　　对于预定义的值类型，如果操作数的值相等，则相等运算符 (==) 返回 true，否则返回false。对于string以外的引用类型，如果两个操作数引用同一个对象，则==返回true。对于string类型，==比较字符串的值

　　对于内置值类型，==判断的是两个对象的代数值是否相等。它会根据需要自动进行必要的类型转换，并根据两个对象的值是否相等返回true或者false。例如：

　　int x = 100;

　　Double y = 100;

　　if (x == y)

　　Response.Write("x==y!"); //x==y

　　而对于用户定义的值类型，如果没有重载==操作符，==将是不能够使用的。例如：

　　Struct Userstruct1;

　　Userstruct1 a;

　　Userstruct1 b;

　　If(a == b)

　　Console.WriteLine(“can == reach this far?”)

　　上面的这段代码是不能够通过编译的。可以通过重载使==作用于用户定义的值类型。

　　对于引用类型，== 默认的行为与ReferenceEquals的行为相同，仅有两个对象指向同一个Reference的时候才返回true。

　　Equals()：

　　Equals方法对于值类型和引用类型的定义不同，对于值类型，类型相同，并且数值相同(对于struct的每个成员都必须相同)，则Equals返回true,否则返回false。而对于引用类型，默认的行为与ReferenceEquals的行为相同，仅有两个对象指向同一个Reference的时候才返回true。可以根据需要对Equals进行重载，例如String类的Equals用于判断两个字符串的内容是否相等。

　　StringBuilder a = new StringBuilder();

　　a.Append("the test a");

　　String s1 = a.ToString();

　　String s2 = "the test a";

　　if (s2 == s1) //为真，因为S2,S1内容相等。String类的==与Equals的行为相同，判断两个字符串的内容是否相等

　　Response.Write("== returns true");

　　if (Object.Equals(s2, s1)) //为真，String类重载了Equals，用于判断两个字符串的内容是否相等
　　{
　　Response.Write("equals returns true");
　　}

　　if (Object.ReferenceEquals(s2, s1)) //为假，因为s2,s1并不是指向同一个对象
　　{
　　Response.Write("ReferenceEquals returns true");
　　}

　　注：对于String类，直接声明s1 = “the test a”的话，输出结果将包含 "ReferenceEquals returns true"，因为默认的，String对于声明的相同的字符串在堆上只保留一个Copy，所以s1与s2将会指向相同的Reference。


　　分割字符串

　　Split 方法将字符串分隔后返回字符串数组。

　　Split使用方法一：

　　string str = "abcdefghigkceofuecto";

　　string[] sArray = str.Split('c');

　　foreach (string i in sArray)

　　Response.Write(i.ToString()+"</br>");

　　输出下面的结果：

　　ab

　　defghigk

　　eofue

　　to

　　Split使用方法二：

　　我们看到了结果是以一个指定的字符进行的分割。使用另一种构造方法对多个字符进行分割:

　　string str = "abcdefghigkceofuecto";

　　string[] sArray = str.Split(new char[3] { 'h', 'i', 'g' });

　　foreach (string i in sArray)

　　Response.Write(i.ToString()+"</br>");

　　输出：

　　abcdef


　　kceofuecto

　　使用正则表达式：

　　使用正则表达式，可以过滤掉一些不是很规则的字符。

　　string str = "everybody***************Welcome*****to***china*!";

　　string[] sArray = System.Text.RegularExpressions.Regex.Split(str, @"[*]+");

　　foreach (string i in sArray)

　　Response.Write(i.ToString()+"</br>");

　　输出：


　　everybody


　　Welcome


　　to


　　china


　　!


　　字符串截取


　　string myString = "Hello Word!";


　　//Substring()在C#中有两个重载函数


　　//分别如下示例


　　string subString1 = myString.Substring(0);


　　//如果传入参数为一个长整, 且大于等于0,


　　//则以这个长整的位置为起始,


　　//截取之后余下所有作为字串.


　　//如若传入值小于0,


　　//系统会抛出ArgumentOutOfRange异常


　　//表明参数范围出界


　　string subString2 = myString.Substring(0, 5);


　　//如果传入了两个长整参数,


　　//前一个为参数子串在原串的起始位置


　　//后一个参数为子串的长度


　　//如不合条件同样出现上述异常


　　Response.Write(subString1);//Hello Word!


　　Response.Write(subString2);//Hello


格式化字符串
　　格式化数字


　　格式字符 说明和关联属性


　　________________________________________


　　c、C 货币格式。

　　d、D 十进制格式。

　　e、E 科学计数(指数)格式。

　　f、F 固定点格式。

　　g、G 常规格式。

　　n、N 数字格式。

　　P、P 百分比

　　r、R 往返格式，确保将已转换成字符串的数字转换回数字时具有与原数字相同的值。

　　x、X 十六进制格式。

　　________________________________________


　　double val=Math.PI;


　　Console.WriteLine(val.ToString( )); //displays 3.14159265358979


　　Console.WriteLine(val.ToString("E"));//displays 3.141593E+000


　　Console.WriteLine(val.ToString("F3");//displays 3.142


　　int val=65535;

　　Console.WriteLine(val.ToString("x")); //displays ffff


　　Console.WriteLine(val.ToString("X")); //displays FFFF


　　Single val=0.123F;


　　Console.WriteLine(val.ToString("p")); //displays 12.30 %


　　Console.WriteLine(val.ToString("p1")); //displays 12.3 %


　　格式化日期


　　d 短日期模式


　　表示由当前 ShortDatePattern 属性定义的自定义 DateTime 格式字符串。


　　例如，用于固定区域性的自定义格式字符串为“MM/dd/yyyy”。


　　G 常规日期/时间模式(短时间)


　　表示短日期 (d) 和短时间 (t) 模式的组合，由空格分隔。


　　G 常规日期/时间模式(长时间)


　　表示短日期 (d) 和长时间 (T) 模式的组合，由空格分隔。


　　M 或 m 月日模式


　　表示由当前 MonthDayPattern 属性定义的自定义 DateTime 格式字符串。


　　例如，用于固定区域性的自定义格式字符串为“MMMM dd”。


　　R 或 r RFC1123 模式


　　表示由当前 RFC1123Pattern 属性定义的自定义 DateTime 格式字符串。该模式是定义的标准，并且属性是只读的。因此，无论所使用的区域性或所提供的格式提供程序是什么，它总是相同的。


　　定义格式字符串为“ddd, dd MMM yyyy HH':'mm':'ss 'GMT'”。


　　格式化不会修改正在格式化的 DateTime 对象的值。因此，应用程序在使用此格式说明符之前必须将该值转换为协调世界时 (UTC)。


　　T 长时间模式


　　表示由当前 LongTimePattern 属性定义的自定义 DateTime 格式字符串。


　　例如，用于固定区域性的自定义格式字符串为“HH:mm:ss”。


　　U 通用的可排序日期/时间模式


　　表示由当前 UniversalSortableDateTimePattern 属性定义的自定义 DateTime 格式字符串。此模式是定义的标准，并且属性是只读的。因此，无论所使用的区域性或所提供的格式提供程序是什么，它总是相同的。


　　自定义格式字符串为“yyyy'-'MM'-'dd HH':'mm':'ss'Z'”。


　　格式化日期和时间时不进行时区转换。因此，应用程序在使用此格式说明符之前必须将本地日期和时间转换为协调世界时 (UTC)。


DateTime dt = DateTime.Now;
　　String date;
　　date = dt.ToString("d",DateTimeFormatInfo.InvariantInfo);


　　Response.Write(date + "</br>");//07/22/2009


　　date = dt.ToString("G", DateTimeFormatInfo.InvariantInfo);


　　Response.Write(date + "</br>");//07/22/2009 14:54:37


　　date = dt.ToString("r", DateTimeFormatInfo.InvariantInfo);
　　Response.Write(date + "</br>");//Wed, 22 Jul 2009 14:54:37 GMT


　　date = dt.ToString("T", DateTimeFormatInfo.InvariantInfo);
　　Response.Write(date + "</br>");//14:54:37


　　date = dt.ToString("u", DateTimeFormatInfo.InvariantInfo);
　　Response.Write(date + "</br>");//2009-07-22 14:54:37Z


　　date = dt.ToString("dd-MM-yyyy", DateTimeFormatInfo.InvariantInfo);
　　Response.Write(date + "</br>");//22-07-2009


　　
　　其他函数


　　Endswith 末尾是否匹配指定string


　　Indexof 索引指向int start开始的第一个string


　　Insert 插入string


　　Length 长度,数组为大小


　　Remove 从string中删除,数组为删除一个string


　　Replace 替换

　　StartsWith 开始是否与指定string匹配

　　Tolower 小写

　　Toupper 大写

　　Trim 两头去除空格

　　TrimEnd "右面"去空格

　　TrimStart "左面"去空格


   String str = "Hello,Welcome to China!";
　　String temp;
　　if (str.EndsWith("!"))


　　Response.Write("str is endwith !" + "</br>" );//str is endwith !
　　int i= str.IndexOf('W');
　　Response.Write("The first place of W is:" + i +  "</br>");//The first place of W is:6


　　temp = str.Insert(5, " everyone");
　　Response.Write("temp Insert:" + temp + "</br>");//temp Insert:Hello everyone,Welcome to China!


　　temp = str.Remove(5, 9);
　　Response.Write("temp Remove:" + temp + "</br>");//temp Remove:Helloto China!


　　Response.Write("The length of str is:" + str.Length + "</br>");//The length of str is:23


　　temp = str.Replace('!','$');
　　Response.Write("temp Replace:" + temp + "</br>");//temp Replace:Hello,Welcome to China$


　　temp = str.ToLower();
　　Response.Write("temp ToLower:" + temp + "</br>");//temp ToLower:hello,welcome to china!


　　temp = str.ToUpper();
　　Response.Write("temp ToUpper:" + temp + "</br>");//temp ToUpper:HELLO,WELCOME TO CHINA!
========

 C#字符串操作大全

http://blog.csdn.net/lllljz/article/details/7461228




===============================字符串基本操作================================
　　一、C#中字符串的建立过程
　　　　例如定义变量


　　　　strT="Welcome to ";
　　　　strT+="www.cuit.edu.cn";
　　　　程序首先创建一个System.String 类型的对象并初始化为“Welcome to”。此时编译程度会分配足够的内存来保存这个文本串。并用变量strT来表示这个实例。当执行strT+="www.cuit.edu.cn"时，系统会创建一个新的实例，并分配足够的内存来保存复合后的文本。然后用变量strT来表示这个新的字符串，旧的字符串被撤消。


　　二、字符串处理

　　　　1、从字符串中提取子串 
　　　　StringBuilder 类没有支持子串的方法，因此必须用String类来提取。（关于StringBuilder 类，文末会提到）
　　　　string mystring="My name is ynn."; 
　　　　//Displays "name is ynn." 
　　　　Console.WriteLine(mystring.Substring( 3 )); 
　　　　//Displays "ynn" 
　　　　Console.WriteLine(mystring.Substring( 11,3 ));


　　　　2、比较字符串 
　　　　String 类有四种方法：Compare( )、CompareTo( )、CompareOrdinal( )、Equals( )。 
　　　　Compare( )方法是CompareTo( )方法的静态版本。只要使用“＝”运算符，就会调用Equals( )方法，的以Equals( )方法与“＝”是等价的。CompareOrdinal( )方法对两个字符串比较不考本地语言与文件。 
　　　　示例： 
　　　　int result; 
　　　　bool bresult; 
　　　　s1="aaaa"; 
　　　　s2="bbbb"; 
　　　　//Compare( )method 
　　　　//result值为“0”表示等，小于零表示 s1 < s2，大于零表示 s1 > s2 
　　　　result=String.Compare(s1,s2); 
　　　　result=s1.CompareTo( s2 ); 
　　　　result=String.CompareOrdinal(s1,s2);

　　　　3.插入子串
　　　　字符串.Insert(插入位置，插入子串) ;
　　　　s.Insert(2,"ab");
　　　　4.移出子串
　　　　字符串.Remove（起始位置，移出数）;
　　　　s.Remove(3,2);
　　　　5.替换子串
　　　　字符串.Replace（源子串，替换为）;
　　　　s.Replace("-"," ");将-替换为空格
　　　　6.截取子串
　　　　字符串.Substring（截取起始位置，截取个数）;
　　　　"abcdef".Substring(2,3);结果为cde


　　　　7.去空格
　　　　　　myString.Trim(); //同时删除字符串前后的空格
　　　　string userResponse = Console.ReadLine();
　　　　userResponse = userResponse.Trim();//用该命令处理后产生新地变量再赋给此变量：
　　　　if (userResponse.ToLower() == “yes”)
　　　　　　　　Console.WriteLine(”OK!”);
　　　　else
　　　　　　　　Console .WriteLine (”NO!”);
　　　　myString = myString.Trim(trimChars); //删除所有指定字符
　　　　myString = myString.TrimEnd(); //删除字符串后的空格
　　　　myString = myString.TrimStart(); //删除字符串前的空格


　　　　8.转换大小写
　　　　str.ToLower()转化成小写字母
　　　　str.ToUpper()转化成大写字母
　　　　Char.IsUpper(str,3)//判断一个字符串中的第n个字符是否是大写


　　　　9.拆分字符串
　　　　例1：string[] Strs = myString.Split(' ',3);


            //按照空格进行拆分，并且返回前三个字符串，结果在字符串数组里


　　　　例2：Split命令作用是用指定的分隔符分隔字符串，成为子字符串，子字符串赋给数组，作为元素输出


　　　string myStr = "this is a test.";
            char[] separator ={ ' ' };//'a' a为分隔符，此例为空格分隔符定义一个分隔符数组
            string[] mywords;
            mywords = myStr.Split(separator);
            foreach (string word in mywords)
            {
                Console.WriteLine("{0}", word);
            }
            Console.ReadLine();

　
　　　　10.使字串达到指定长度
　　　　PadLeft()、PadRight() ，如：
　　　　例1：string str1="00";
　　　　str1=str1.PadLeft(3,'1'); //无第二参数为加空格，结果为"100"
　　　　　　//为字符串添加空格，都是从左向右数字符串的长度进行添加 空格
　　　　例2：

　　　　char[] trimChars ={ ' ', 'e', 's' };//命名一个要被删除的字符的数组
                //Console.WriteLine("{0},{1},{2}", trimChars[0],trimChars[1],trimChars[2]);
                string userResponse = Console.ReadLine();
                userResponse = userResponse.ToLower();
                userResponse = userResponse.Trim(trimChars);
                if (userResponse == "y")
                {
                    Console.WriteLine(".Trim()命令可以删除字符"yes"删除es后变为：{0}", userResponse);
                }
                Console.ReadLine();


　　　　11.得到字符串长度
　　　　  len=str.Length;
　　　　12.查找子串
　　　　字符串.IndexOf(子串，查找起始位置) ;
　　　　字符串.LastIndexOf(子串) ;最后一次出现的位置
　　　　str.IndexOf("ab",0);
　　　　13.字符串遍历
　　　　string myString = "This is a test!";
　　　　foreach (char myChar in myString)
　　　　{
　　　　　　　　Console.Write("{0}",myChar);
　　　　}


==============================string类&char类==================================
 

 　　　　//string类型变量可以看作char变量的只读数组的使用
　　　　string myString = “A string”;


　　　　//使用数组变量的ToCharArray()命令将string变量myString变量的字符串值赋给
　　　　//char类型的数组myChar为元素
　　　　char[] myChars = myString.ToCharArray();
　　　　//ToCharArray()命令把字符串值转换成char数组元素
　　　　foreach (char myChar in myChars)//读取数组元素
　　　　{
　　　　　　　　Console.WriteLine(”{0}”,myChar);//或(myChar)
　　　　}




　　　　//string类型变量可以看作char变量的只读数组的使用
　　　　Console.WriteLine(”请输入要转换的字符串，把其转换为char数组元素”);
　　　　string myString = Console.ReadLine();//从屏幕得到字符串
　　　　Console.WriteLine(”你输入的字符串长度为：{0}”,myString .Length );//获取字符串的长度
　　　　//使用数组变量的ToCharArray()命令将string变量myString变量的字符串值赋给
　　　　//char类型的数组myChar为元素
　　　　char[] myChars = myString.ToCharArray();//ToCharArray()命令把字符串值转换成char数组元素
　　　　foreach (char myChar in myChars)//读取数组元素
　　　　{
　　　　　　　　Console.WriteLine(”{0}”,myChar);//或(myChar)
　　　　}


 ===============================字符串格式化================================ 


　　3.1 格式化数字


　　　　----------------------------------------------------------------------------
　　　　格式字符    说明和关联属性 
　　　　c、C       货币格式。 
　　　　d、D       十进制格式。 
　　　　e、E       科学计数（指数）格式。 
　　　　f、F       固定点格式。 
　　　　g、G       常规格式。 
　　　　n、N       数字格式。 
　　　　r、R       往返格式，确保将已转换成字符串的数字转换回数字时具有与原数字相同的值。 
　　　　x、X       十六进制格式。

　　　　----------------------------------------------------------------------------

　　　　double val=Math.PI; 
　　　　Console.WriteLine(val.ToString( ));  //displays 3.14159265358979 
　　　　Console.WriteLine(val.ToString("E"));//displays 3.141593E+000 
　　　　Console.WriteLine(val.ToString("F3");//displays 3.142

　　　　int val=65535; 
　　　　Console.WriteLine(val.ToString("x"));  //displays ffff 
　　　　Console.WriteLine(val.ToString("X"));  //displays FFFF 

　　　　Single val=0.123F; 
　　　　Console.WriteLine(val.ToString("p"));  //displays 12.30 % 
　　　　Console.WriteLine(val.ToString("p1"));  //displays 12.3 % 


　　默认格式化会在数字和百分号之间放入一个空格。定制方法如下： 
　　其中NumberFormatInfo类是System.Globalization命名空间的一个成员，因此该命名空间必须导入到程序中。 
　　　　Single val=0.123F; 
　　　　object myobj=NumberFormatInfo.CurrentInfo.Clone( ) as NumberFormatInfo; 
　　　　NumberFormatInfo myformat=myobj as NumberFormatInfo; 
　　　　myformat.PercentPositivePattern=1; 
　　　　Console.WriteLine(val.ToString("p",myformat)); //displays 12.30%; 
　　　　Console.WriteLine(val.ToString("p1",myformat)); //displays 12.3%;




　　格式化具有很大的灵活性。下面的例子演示一个没有意义的货币结构： 
　　　　double val=1234567.89; 
　　　　int [] groupsize={2,1,3}; 
　　　　object myobj=NumberFormatInfo.CurrentInfo.Clone( ); 
　　　　NumberFormatInfo mycurrency=myobj as NumberFormatInfo; 
　　　　mycurrency.CurrencySymbol="#"; //符号 
　　　　mycurrency.CurrencyDecimalSeparator=":"; //小数点 
　　　　mycurrency.CurrencyGroupSeparator="_";  //分隔符 
　　　　mycurrency.CurrencyGroupSizes=groupsize; 
　　　　// 输出　#1_234_5_67:89 
　　　　Console.WriteLine(val.ToString("C",mycurrency));


　　3.2 格式化日期 
　　输出形式取决于用户计算机的文化设置。 
　　　　using System; 
　　　　using System.Globalization; 
　　　　public class MainClass 
　　　　{ 
　　　　　　　　public static void Main(string[] args)  
　　　　　　　　{ 
　　　　　　　　　　　　DateTime dt = DateTime.Now; 
　　　　　　　　　　　　String[] format = {"d","D","f","F","g","G","m","r","s","t", "T","u", "U","y","dddd, MMMM dd yyyy","ddd, MMM d ""'""yy","dddd, MMMM dd","M/yy","dd-MM-yy",}; 
　　　　　　　　　　　　String date; 
　　　　　　　　　　　　for (int i = 0; i < format.Length; i++) 
 　　　　     　　　　　　　　{ 
 　　　　        　　　　　　　　date = dt.ToString(format[i], DateTimeFormatInfo.InvariantInfo); 
　　　　         　　　　　　　　Console.WriteLine(String.Concat(format[i], " :" , date)); 
 　　　　     　　　　　　　　} 
　　　　     　　　} 
　　　　}




　　
　　　　d :07/11/2004    <=======输出 
　　　　D :Sunday, 11 July 2004 
　　　　f :Sunday, 11 July 2004 10:52 
　　　　F :Sunday, 11 July 2004 10:52:36 
　　　　g :07/11/2004 10:52 
　　　　G :07/11/2004 10:52:36 
　　　　m :July 11 
　　　　r :Sun, 11 Jul 2004 10:52:36 GMT 
　　　　s :2004-07-11T10:52:36 
　　　　t :10:52 
　　　　T :10:52:36 
　　　　u :2004-07-11 10:52:36Z 
　　　　U :Sunday, 11 July 2004 02:52:36 
　　　　y :2004 July 
　　　　dddd, MMMM dd yyyy :Sunday, July 11 2004 
　　　　ddd, MMM d "'"yy :Sun, Jul 11 '04 
　　　　dddd, MMMM dd :Sunday, July 11 
　　　　M/yy :7/04 
　　　　dd-MM-yy :11-07-04




　　3.3 格式化枚举 
　　　　enum classmen 
　　　　{ 
　　　　  ynn=1, 
　　　　  yly=2, 
 　　　　 css=3, 
 　　　　 C++=4 
　　　　} 


　　获取枚举字符串信息如下： 
　　　　classmen myclassmen=classmen.yly; 
　　　　Console.WriteLine(myclassmen.ToString( ));   //displays yly 
　　　　Console.WriteLine(myclassmen.ToString("d")); //displays 2 



　　从系统枚举中获取文本人信息如下： 
　　　　DayOfWeek day=DayOfWeek.Friday; 
　　　　//displays "Day is Friday" 
　　　　Console.WriteLine(String.Format("Day is {0:G}",day)); 
　　　　格式化字符串“ G ”把枚举显示为一个字符串。 
　　


===============================StringBuilder类=================================
 
　　当要进行大规模的字符替换与调整操作时，使用字符串来操作将严重影响性能。在这中情况下就可以用System.Text.StringBuilder类。


　　StringBuilder类并没有String 类的功能强大，只提供基本的替换和添加和删除字符串中的文本，但它的工作效率非常高，当定义StringBuilder对象时可以指定内存的内存容量，如果不指定系统就会根据对象初始化时的字符串长度来确定。它有两个主要参数Length和Capacity分别表示字符串的实际长度和字符串占据的内存空间长度。对字符串的修改就是在这个内存中进行的，大大提高了添加和替换的的效率。
如定义：




　　StringBuilder sb=new StringBuilder(”Hello,Welcome”,100);//初始化对象并设置初始容量为100
       sb.Append(” to www.sinory.com”);
       sb.Replace(old,new);//将old替换为new,作用与String.Replace()一样只是不需要在过程中复制字符。




　　StringBuilder的成员：
     　　StringBuilder sb=new StringBuilder(”www.google.com”);//定义初值为www.google.com的对象。
     　　StringBuilder sb=new StringBuilder(20);//初始化容量为20的空对象。
　　另外StringBuilder还有MaxCapacity属性用来限定对象可以使用的最大容量。默认大约是int.MaxValue（20亿）
     可以在使用过程中定义sb.MaxCapacity=value;
     sb.Append()——给当前字符串追加字符串。
     sb.AppendFormat()——添加特定格式的字符串
     sb.Insert()——插入一个子字符串
     sb.Remove()——从当前字符串删除字符
     sb.Replace()——替换字符串中指定的字符
     sb.ToString()——将sb转化为String 对象
========

总结的5个C#字符串操作方法分享

http://www.jb51.net/article/66634.htm
这篇文章主要介绍了总结的5个C#字符串操作方法分享,本文讲解了把字符串按照分隔符转换成 List、把字符串转 按照, 分割 换为数据、得到数组列表以逗号分隔的字符串、得到字符串长度等方法,需要的朋友可以参考下
..字符串操作是C#中最基本的、最常见的、也是用的最多的，以下我总结了几种常见的方法:


1.把字符串按照分隔符转换成 List  


?1234567891011121314151617181920212223 /// <summary>      /// 把字符串按照分隔符转换成 List      /// </summary>      /// <param name="str">源字符串</param>      /// <param name="speater">分隔符</param>      /// <param name="toLower">是否转换为小写</param>      /// <returns></returns>      public static List<string> GetStrArray(string str, char speater, bool toLower)     {       var list = new List<string>();       var ss = str.Split(speater);       foreach (var s in ss)       {         if (string.IsNullOrWhiteSpace(s) || s == speater.ToString(CultureInfo.InvariantCulture)) continue;         var strVal = s;         if (toLower)         {           strVal = s.ToLower();         }         list.Add(strVal);       }       return list;     } 
2.把字符串转 按照, 分割 换为数据  


?123456789 /// <summary>      /// 把字符串转 按照, 分割 换为数据      /// </summary>      /// <param name="str"></param>      /// <returns></returns>      public static string[] GetStrArray(string str)     {       return str.Split(new[] { ',', '，' });     } 
3.得到数组列表以逗号分隔的字符串


?1234567891011121314151617181920212223 /// <summary>     /// 得到数组列表以逗号分隔的字符串     /// </summary>     /// <param name="list"></param>     /// <param name="speater"></param>     /// <returns></returns>     public static string GetArrayStr(List<string> list, string speater)     {       var sb = new StringBuilder();       for (var i = 0; i < list.Count; i++)       {         if (i == list.Count - 1)         {           sb.Append(list[i]);         }         else        {           sb.Append(list[i]);           sb.Append(speater);         }       }       return sb.ToString();     } 
4.得到字符串长度


?1234567891011 /// <summary>     /// 得到字符串长度     /// </summary>     /// <param name="inputStr"></param>     /// <returns></returns>     public static int StrLength(string inputStr)     {       var asc = new ASCIIEncoding();       var s = asc.GetBytes(inputStr);       return s.Sum(t => t == 63 ? 2 : 1);     } 
5.截取指定长度字符串


?123456789101112131415161718192021222324252627282930313233343536373839 /// <summary>     /// 截取指定长度字符串     /// </summary>     /// <param name="inputString"></param>     /// <param name="len"></param>     /// <returns></returns>     public static string CutStr(string inputString, int len)     {       var isShowFix = false;       if (len % 2 == 1)       {         isShowFix = true;         len--;       }       var ascii = new ASCIIEncoding();       var tempLen = 0;       var tempString = "";       var s = ascii.GetBytes(inputString);       for (var i = 0; i < s.Length; i++)       {         tempLen += s[i] == 63 ? 2 : 1;         try        {           tempString += inputString.Substring(i, 1);         }         catch        {           break;         }           if (tempLen > len)           break;       }         var mybyte = Encoding.Default.GetBytes(inputString);       if (isShowFix && mybyte.Length > len)         tempString += "…";       return tempString;      } 


暂时就这五种方法了。
========

C#自定义的字符串操作增强类


这个C#类在C#自由的字符串操作类的基础上进行的大幅度增强，把我们平时可能用到的字符串操作都做进去了，字符串的处理我想大部分编程都不可避免，有了这个类，可以节省你很多时间，同时可以根据自己的需要对这个C#字符串类进行扩展。 
using System;
using System.Collections.Generic;
using System.Text;
using System.Text.RegularExpressions;

namespace DotNet.Utilities
{
    /// <summary>
    /// 字符串操作类
    /// 1、GetStrArray(string str, char speater, bool toLower)  把字符串按照分隔符转换成 List
    /// 2、GetStrArray(string str) 把字符串转 按照, 分割 换为数据
    /// 3、GetArrayStr(List list, string speater) 把 List 按照分隔符组装成 string
    /// 4、GetArrayStr(List list)  得到数组列表以逗号分隔的字符串
    /// 5、GetArrayValueStr(Dictionary<int, int> list)得到数组列表以逗号分隔的字符串
    /// 6、DelLastComma(string str)删除最后结尾的一个逗号
    /// 7、DelLastChar(string str, string strchar)删除最后结尾的指定字符后的字符
    /// 8、ToSBC(string input)转全角的函数(SBC case)
    /// 9、ToDBC(string input)转半角的函数(SBC case)
    /// 10、GetSubStringList(string o_str, char sepeater)把字符串按照指定分隔符装成 List 去除重复
    /// 11、GetCleanStyle(string StrList, string SplitString)将字符串样式转换为纯字符串
    /// 12、GetNewStyle(string StrList, string NewStyle, string SplitString, out string Error)将字符串转换为新样式
    /// 13、SplitMulti(string str, string splitstr)分割字符串
    /// 14、SqlSafeString(string String, bool IsDel)
    /// </summary>
    public class StringPlus
    {
        /// <summary>
        /// 把字符串按照分隔符转换成 List
        /// </summary>
        /// <param name="str">源字符串</param>
        /// <param name="speater">分隔符</param>
        /// <param name="toLower">是否转换为小写</param>
        /// <returns></returns>
        public static List<string> GetStrArray(string str, char speater, bool toLower)
        {
            List<string> list = new List<string>();
            string[] ss = str.Split(speater);
            foreach (string s in ss)
            {
                if (!string.IsNullOrEmpty(s) && s != speater.ToString())
                {
                    string strVal = s;
                    if (toLower)
                    {
                        strVal = s.ToLower();
                    }
                    list.Add(strVal);
                }
            }
            return list;
        }
        /// <summary>
        /// 把字符串转 按照, 分割 换为数据
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static string[] GetStrArray(string str)
        {
            return str.Split(new Char[] { ',' });
        }
        /// <summary>
        /// 把 List<string> 按照分隔符组装成 string
        /// </summary>
        /// <param name="list"></param>
        /// <param name="speater"></param>
        /// <returns></returns>
        public static string GetArrayStr(List<string> list, string speater)
        {
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < list.Count; i++)
            {
                if (i == list.Count - 1)
                {
                    sb.Append(list[i]);
                }
                else
                {
                    sb.Append(list[i]);
                    sb.Append(speater);
                }
            }
            return sb.ToString();
        }
        /// <summary>
        /// 得到数组列表以逗号分隔的字符串
        /// </summary>
        /// <param name="list"></param>
        /// <returns></returns>
        public static string GetArrayStr(List<int> list)
        {
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < list.Count; i++)
            {
                if (i == list.Count - 1)
                {
                    sb.Append(list[i].ToString());
                }
                else
                {
                    sb.Append(list[i]);
                    sb.Append(",");
                }
            }
            return sb.ToString();
        }
        /// <summary>
        /// 得到数组列表以逗号分隔的字符串
        /// </summary>
        /// <param name="list"></param>
        /// <returns></returns>
        public static string GetArrayValueStr(Dictionary<int, int> list)
        {
            StringBuilder sb = new StringBuilder();
            foreach (KeyValuePair<int, int> kvp in list)
            {
                sb.Append(kvp.Value + ",");
            }
            if (list.Count > 0)
            {
                return DelLastComma(sb.ToString());
            }
            else
            {
                return "";
            }
        }

        #region 删除最后一个字符之后的字符

        /// <summary>
        /// 删除最后结尾的一个逗号
        /// </summary>
        public static string DelLastComma(string str)
        {
            return str.Substring(0, str.LastIndexOf(","));
        }

        /// <summary>
        /// 删除最后结尾的指定字符后的字符
        /// </summary>
        public static string DelLastChar(string str, string strchar)
        {
            return str.Substring(0, str.LastIndexOf(strchar));
        }

        #endregion

        /// <summary>
        /// 转全角的函数(SBC case)
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public static string ToSBC(string input)
        {
            //半角转全角：
            char[] c = input.ToCharArray();
            for (int i = 0; i < c.Length; i++)
            {
                if (c[i] == 32)
                {
                    c[i] = (char)12288;
                    continue;
                }
                if (c[i] < 127)
                    c[i] = (char)(c[i] + 65248);
            }
            return new string(c);
        }

        /// <summary>
        ///  转半角的函数(SBC case)
        /// </summary>
        /// <param name="input">输入</param>
        /// <returns></returns>
        public static string ToDBC(string input)
        {
            char[] c = input.ToCharArray();
            for (int i = 0; i < c.Length; i++)
            {
                if (c[i] == 12288)
                {
                    c[i] = (char)32;
                    continue;
                }
                if (c[i] > 65280 && c[i] < 65375)
                    c[i] = (char)(c[i] - 65248);
            }
            return new string(c);
        }

        /// <summary>
        /// 把字符串按照指定分隔符装成 List 去除重复
        /// </summary>
        /// <param name="o_str"></param>
        /// <param name="sepeater"></param>
        /// <returns></returns>
        public static List<string> GetSubStringList(string o_str, char sepeater)
        {
            List<string> list = new List<string>();
            string[] ss = o_str.Split(sepeater);
            foreach (string s in ss)
            {
                if (!string.IsNullOrEmpty(s) && s != sepeater.ToString())
                {
                    list.Add(s);
                }
            }
            return list;
        }

        #region 将字符串样式转换为纯字符串
        /// <summary>
        ///  将字符串样式转换为纯字符串
        /// </summary>
        /// <param name="StrList"></param>
        /// <param name="SplitString"></param>
        /// <returns></returns>
        public static string GetCleanStyle(string StrList, string SplitString)
        {
            string RetrunValue = "";
            //如果为空，返回空值
            if (StrList == null)
            {
                RetrunValue = "";
            }
            else
            {
                //返回去掉分隔符
                string NewString = "";
                NewString = StrList.Replace(SplitString, "");
                RetrunValue = NewString;
            }
            return RetrunValue;
        }
        #endregion

        #region 将字符串转换为新样式
        /// <summary>
        /// 将字符串转换为新样式
        /// </summary>
        /// <param name="StrList"></param>
        /// <param name="NewStyle"></param>
        /// <param name="SplitString"></param>
        /// <param name="Error"></param>
        /// <returns></returns>
        public static string GetNewStyle(string StrList, string NewStyle, string SplitString, out string Error)
        {
            string ReturnValue = "";
            //如果输入空值，返回空，并给出错误提示
            if (StrList == null)
            {
                ReturnValue = "";
                Error = "请输入需要划分格式的字符串";
            }
            else
            {
                //检查传入的字符串长度和样式是否匹配,如果不匹配，则说明使用错误。给出错误信息并返回空值
                int strListLength = StrList.Length;
                int NewStyleLength = GetCleanStyle(NewStyle, SplitString).Length;
                if (strListLength != NewStyleLength)
                {
                    ReturnValue = "";
                    Error = "样式格式的长度与输入的字符长度不符，请重新输入";
                }
                else
                {
                    //检查新样式中分隔符的位置
                    string Lengstr = "";
                    for (int i = 0; i < NewStyle.Length; i++)
                    {
                        if (NewStyle.Substring(i, 1) == SplitString)
                        {
                            Lengstr = Lengstr + "," + i;
                        }
                    }
                    if (Lengstr != "")
                    {
                        Lengstr = Lengstr.Substring(1);
                    }
                    //将分隔符放在新样式中的位置
                    string[] str = Lengstr.Split(',');
                    foreach (string bb in str)
                    {
                        StrList = StrList.Insert(int.Parse(bb), SplitString);
                    }
                    //给出最后的结果
                    ReturnValue = StrList;
                    //因为是正常的输出，没有错误
                    Error = "";
                }
            }
            return ReturnValue;
        }
        #endregion

        /// <summary>
        /// 分割字符串
        /// </summary>
        /// <param name="str"></param>
        /// <param name="splitstr"></param>
        /// <returns></returns>
        public static string[] SplitMulti(string str, string splitstr)
        {
            string[] strArray = null;
            if ((str != null) && (str != ""))
            {
                strArray = new Regex(splitstr).Split(str);
            }
            return strArray;
        }
        public static string SqlSafeString(string String, bool IsDel)
        {
            if (IsDel)
            {
                String = String.Replace("'", "");
                String = String.Replace("\"", "");
                return String;
            }
            String = String.Replace("'", "'");
            String = String.Replace("\"", """);
            return String;
        }

        #region 获取正确的Id，如果不是正整数，返回0
        /// <summary>
        /// 获取正确的Id，如果不是正整数，返回0
        /// </summary>
        /// <param name="_value"></param>
        /// <returns>返回正确的整数ID，失败返回0</returns>
        public static int StrToId(string _value)
        {
            if (IsNumberId(_value))
                return int.Parse(_value);
            else
                return 0;
        }
        #endregion
        #region 检查一个字符串是否是纯数字构成的，一般用于查询字符串参数的有效性验证。
        /// <summary>
        /// 检查一个字符串是否是纯数字构成的，一般用于查询字符串参数的有效性验证。(0除外)
        /// </summary>
        /// <param name="_value">需验证的字符串。。</param>
        /// <returns>是否合法的bool值。</returns>
        public static bool IsNumberId(string _value)
        {
            return QuickValidate("^[1-9]*[0-9]*$", _value);
        }
        #endregion
        #region 快速验证一个字符串是否符合指定的正则表达式。
        /// <summary>
        /// 快速验证一个字符串是否符合指定的正则表达式。
        /// </summary>
        /// <param name="_express">正则表达式的内容。</param>
        /// <param name="_value">需验证的字符串。</param>
        /// <returns>是否合法的bool值。</returns>
        public static bool QuickValidate(string _express, string _value)
        {
            if (_value == null) return false;
            Regex myRegex = new Regex(_express);
            if (_value.Length == 0)
            {
                return false;
            }
            return myRegex.IsMatch(_value);
        }
        #endregion
    }
}


========
bcbobo21cn
关注
  • 0
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C#关于字符串的操作
12-11
在C#编程语言中，字符串是经常被使用的数据类型，特别是在处理文本...通过实践和练习，你可以更好地理解和运用这些字符串操作，从而提升编程技能。在学习过程中，不要忘了使用如`StringDemo`这样的示例代码来加深理解。
C#字符串加密解密方法实例
09-03
总结起来，这个C#字符串加密解密实例展示了如何使用基本的DES加密算法对字符串进行操作。然而，在现实世界的应用中，应选择更为安全的加密算法，并遵循最佳安全实践，以确保数据的安全性。了解这些基础对于理解和...
C# 后台js重定向Response.Write
weixin_45062076的博客
09-15 437
Response.Write(string.Format(“”，pkey)); //Card是你的网址 key是传的参数
在C#中使用Response.write返回的内容不要HTML
简单编程
07-27 5060
Response.Clear(); Response.Write(""); Response.Flush(); Response.End();
深入解析C#特殊字符：概念、分类与使用方法
最新发布
qq_35320456的博客
05-01 1180
C#是一种强类型、面向对象的编程语言，广泛应用于软件开发领域。在C#编程中，特殊字符发挥着至关重要的作用，它们构成了C#语言的基础语法和结构。本文将深入解析C#特殊字符的概念、分类、使用方法及其在程序中的作用，并提供一些技巧和方法，帮助读者更好地掌握和使用这些特殊字符。特殊字符是指在C#编程语言中具有特定意义和功能的字符。它们用于表示语言的结构、语法或操作，是编写C#程序的基础。特殊字符可以分为多种类型，如转义字符、格式字符、逻辑运算符等。C# 中的特殊字符是构建和理解代码的关键。
后台代码里执行弹出脚本方法！(Response.Write)
yiye2017zhangmu的博客
09-30 3396
在winform后台，我们通过MessageBox.show(“消息")的方式来返回后台信息，在webform后台，我们通过Response.write(”消息")来返回后台消息，但这样需要将消息值以字符串形式显示到前台页面，是否有类似于MessageBox.show("消息")的方式弹出信息呢。我们会很快想到javascript的alert方法。通过在后台调用js来实现alert的调用。...
Response对象的write方法
推荐系统-机器学习-数据挖掘的专栏
04-14 1万+
除了最简单的用response.write方法向浏览器端输出信息， 1.用HTML语法方式向浏览器发送字符串。使用write方法输出的字符串被浏览器按HTML语法进行解释，因此可以用write方法直接输出HTML代码，实现网页元素及格式的定制，在以下页面以表格布局方式显示查询数据库的记录。 xuehaoname
C# ASP.NET Response.Write的alert弹窗换行问题（弹窗如何显示多行字符串）
ba_wang_mao的专栏
06-24 2308
一、我想在Response.Write() 的alert弹窗中显示多行字符串，参见下图： 二、网上说用 ： Response.write("内容1<br/>内容2") Response.write("内容1内容2")运行结果如下图所示， 显然没有达到我的要求（我需要的是在Alert弹窗中显示多行字符串）。 三、可以用\\r\\n转义符解决Response.Write() 的alert弹窗中显示多行字符串。 程序代码如下： string str = "第一行：= ..
C#实现char字符数组与字符串相互转换的方法
08-31
- 《C#字符串操作技巧总结》：了解字符串的各种操作，包括格式化、替换、比较等。 - 《C#数组操作技巧总结》：学习数组的创建、初始化、遍历以及各种操作方法。 - 《C#中XML文件操作技巧汇总》：掌握读写XML文件的...
C＃字符串与通配符匹配
04-06
总结，C#中的字符串与通配符匹配可以通过自定义函数或利用正则表达式实现。理解并熟练掌握这些技术，将有助于提升C#编程的效率和代码质量。同时，对正则表达式的深入学习，将使你在处理复杂文本匹配问题时游刃有余。
总结C#删除字符串数组中空字符串的几种方法
12-31
但C#3.0新增的lambda表达式就可以很方便实现这个功能，下面一起看看为大家整理的几种清除数组中的空字符串的方法，有需要的可以参考学习。 方式一：使用lambda表达式筛选过滤掉数组中空字符串 /// /// 使用...
C#中Response.Write常见问题汇总
09-04
主要介绍了C#中Response.Write常见问题汇总,总结了C#中Response.Write的常用技巧,非常实用,需要的朋友可以参考下
C# ASP.NET Response.Write()显示字符串的问题
ba_wang_mao的专栏
06-24 492
我想弹出一个窗口显示字符串str中的值到弹窗体中，如何实现? str = "设备MAC地址：=12-13-14-15-16-17" 程序代码如下： string str = "设备MAC地址：=12-13-14-15-16-17"; Response.Write("<Script language='javascript'>alert('" + str + "')</Script>"); ...
用response.write方法 输出 <img src="upload/1.jpg">
热门推荐
得已
06-11 1万+
response.write("&lt;img src='upload/1.jpg'&gt;")
c#中Response.Write输出双引号方法
weixin_30457465的博客
07-27 520
呵呵,就这么简单,折腾了我半天, Response.Write("\"");Response.Write("<td align=center><a href='#' onClick=\"return OpenW('Edit.aspx?TBNAME=" + name + "&ID=" + dr[0] + "');\">修改</a> <a hre...
C# ASP response.write()弹出提示框后页面布局被打乱
weixin_34204722的博客
11-07 518
发现在使用了response.write后样式发生了变化，位置和字体都不正确。Response.Write("<script>alert(')</script>")这种用法也是这样，2003中没有这种情况，很不明白，恰巧看到了csdn上的一个帖子也是讨论这个问题的，其中提到原因有： ASP.NET 2.0里默认使用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值