===============================string
string str = "this is a string.";
string strCopy = string.Copy(str);//string.Copy此方法拷备的是相同的值
bool testbool = ((object)str == (object)strCopy);//上面拷备相同的值，值比较相等用equals,引用比较用==
//此处值相等，不是引用相等,
Console.WriteLine(testbool);
=============================try_catch====================================
catch//不带参数，捕获任何类型的错误
{}
==========================委托事件====================================
一、委托
委托类似于函数指针，但函数指针只能引用静态方法，而委托既能引用静
态方法，也能引用实例方法。
孔羸:例子:
public class Book
{
string title;
int num;
double price;
public delegate void titleChengHendler();
public event titleChengHendler TitleCheng;//定义事件,事件为委托类型
Main()
{
Book b=new Book();
b.TitleCheng+=new b.titleChengHendler(s);//激发事件 形参:方法名
}
void s()
{
Response.Write("a");
}
}
----------------------------------------------------------------------------------------
委托使用分三步：1、委托声明。2、委托实例化。3、委托调用。
例程一：
using System;
namespace 委托
{
delegate int NumOpe(int a,int b); //委托声明
class Class1
{
static void Main(string[] args)
{
Class1 c1 = new Class1();
NumOpe p1 = new NumOpe(c1.Add); //委托实例化
Console.WriteLine(p1(1,2)); //委托调用
Console.ReadLine();
}
private int Add(int num1,int num2)
{
return(num1+num2);
}
}
}
例中，委托NumOpe引用了方法Add。
委托声明了以后，就可以象类一样进行实例化，实例化时把要引用的方法
（如：Add）做为参数，这样委托和方法就关联了起来，就可以用委托来引
用方法了。
委托和所引用的方法必须保持一致：
1、参数个数、类型、顺序必须完全一致。
2、返回值必须一致。
二、事件
事件有很多，比如说鼠标的事件：MouserMove,MouserDown等，键盘的事
件：KeyUp,KeyDown,KeyPress。
有事件，就会有对事件进行处理的方法，而事件和处理方法之间是怎么联
系起来的呢？委托就是他们中间的桥梁，事件发生时，委托会知道，然后
将事件传递给处理方法，处理方法进行相应处理。
比如在WinForm中最常见的是按钮的Click事件，它是这样委托的：
this.button1.Click += new System.EventHandler(this.button1
_Click);按按钮后就会出发button1_Click方法进行处理。EventHandler就
是系统类库里已经声明的一个委托。
三、自定义事件及其处理
EventHandler以及其它自定义的事件委托都是一类特殊的委托，他们有相
同的形式：
delegate void 事件委托名(object sender,EventArgs e);
object用来传递事件的发生者，比如二中的Button控件就是一个事件发生
者；EventArgs用来传递事件的细节。
例程二：
using System;
namespace 最简单的自定义事件
{
/// <summary>
/// 事件发送类
/// </summary>
class Class1
{
public delegate void UserRequest(object sender,EventArgs e);
//定义委托
public event UserRequest OnUserRequest; //定义一个委托类型的
事件
public void run()
{
while(true)
{
if(Console.ReadLine()=="a")
{
//事件监听
OnUserRequest(this,new EventArgs()); //产生事件
}
}
}
}
/// <summary>
/// 事件接收类
/// </summary>
class Class2
{
static void Main(string[] args)
{
Class1 c1 = new Class1();
c1.OnUserRequest += new Class1.UserRequest(c1
_OnUserRequest); //委托实例化后绑定到事件
c1.run();
}
private static void c1_OnUserRequest(object sender,
EventArgs e)
{//事件处理方法
Console.WriteLine("/t你触发了事件！");
}
}
}
例程三：
using System;
namespace 带事件数据的事件
{
/// <summary>
/// 带事件数据的事件类，从EventArgs继承
/// </summary>
class OnUserRequestEventArgs:EventArgs
{
private string inputText;
public string InputText
{
get
{
return inputText;
}
set
{
inputText = value;
}
}
}
/// <summary>
/// 事件发送类
/// </summary>
class Class1
{
public delegate void UserRequest(object
sender,OnUserRequestEventArgs e);
public event UserRequest OnUserRequest;
public void run()
{
while(true)
{
Console.WriteLine("请输入内容：");
string a=Console.ReadLine();
//if(a=="a")
//{
OnUserRequestEventArgs e1 = new OnUserRequestEventArgs();
e1.InputText = a;
OnUserRequest(this,e1);
//}
}
}
}
/// <summary>
/// 事件接收类
/// </summary>
class Class2
{
[STAThread]
static void Main(string[] args)
{
Class1 c1 = new Class1();
c1.OnUserRequest += new Class1.UserRequest(c1
_OnUserRequest);
c1.run();
}
private static void c1_OnUserRequest(object sender,
OnUserRequestEventArgs e)
{
Console.WriteLine("/t你输入的是："+e.InputText);
}
}
}
=======================i++========================================
200912.4徐国荣thinking:
int i=1;
console.write(i+++1);
thinking:
1 +1=2输出此行结果
i++ +1
i=2
----------------
console.write(i++*--i);
thinking:
1 *(2-1) 1*1=1
i++ *--i
i=2 i=1
-------------------
2 3 4 返回此行结果
++i + ++i + ++i
i=2 i=3 i=4
---------------------
1 2 3 返回此行结果
i++ + i++ + i++
i=2 i=3 i=4
-----------------
Demo:
1 + 1 2 1 返回此行结果，相加
i++ + --i + ++i + --i
i=2 1 i=2 i=1
----------------------
----------------------------------------
i=i+1的过程相当：
temp=i+1; i=temp;
i++的过程相当：
temp=i; i=temp+1; return temp;
++i的过程最简单：
i增1然后return i 的值，一步完成，没有给任何temp变
量赋值：）
i++;是一个右值.而++i是一个左值就行了
简单的说是右值是放在=(赋值运算符)右边的操作数.
而左值是可以放在其左边的操作数.
左值可以取地址,而右值不行.
i++是指在执行该语句后才加1；++i是指加1以后再执行该语
句；
++i 表示 i+1 返回新值。
i++ 表示 i+1 返回旧值。
---------------------------
int x=1,y=2,z=3;
y+=z--/++x-x;//y=1
y=(y+z--/++x-x);
z--先参这、与运算，后自--
运算： z/++x运算完后再下面的z--
z--/++x-x
自身运算 z--
z/++x//3/2=1; 此时z=2 x=2
1-x;//1-2=-1;
x=1,y=6;
while(y--==6)//y==6时循环 y先参与运算比较y==6 之后y再自身－－;y=6时，x输出0
//循环回来，y==5时，不循环，执行输出，此时y自身--y=4
{
x--;
}
console.write(x,y);//x=0 y=4;
=================================================
c# i=0;
i++;
console.write(i);是输出i+1
----
int i=0;
i=i++;
console.write(i);thinking:等同于console.write(i++)是输出temp=i,输出temp
------------------
i=i++*--i;分析：i*--i++ 整个表达式运行完，最后才++,且后++,--运算级别最低
c# i=0;i+=i++;i=0; //i=i+i++ i=0+0++ i=0;
c# i=1;i+=i++;i=2; //i=i+i++ i=1+1++ i=2;
thinking:i++整个右边表达式运算完后赋给左边，再++
2009.12.3日照深度考试部分题
int i = 1;
object o = i;
o = (int)o + 1;
Console.Write(o);
int i = 1;
Console.Write(++i+1);
Console.Write(i++1);//i+1 输出后再i+1
Console.Write(i+++1);//i+1+1输出
--------------------
int x,y,z;
x=y=2;z=3;
y=x++-1;printf("%d/t%d/t",x,y); thinking:遵循右边表达式算完赋给左边后，再++的原则；y=i-1 i++
int x,y,z;
x=y=2;z=3;
y=x--+1;printf("%d/t%d/t",x,y); thinking:y=x+1 之后x--此题跟上面为一题 ，上面x=3,所以这里x=3
--------------------------------------i++终结者
============================c#中抽象类_接口区别======================================
一、抽象类：
抽象类是特殊的类，只是不能被实例化；除此以外，具
有类的其他特性；重要的是抽象类可以包括抽象方法，这是普
通类所不能的。抽象方法只能声明于抽象类中，且不包含任何
实现，派生类必须覆盖它们。另外，抽象类可以派生自一个抽
象类，可以覆盖基类的抽象方法也可以不覆盖，如果不覆盖，
则其派生类必须覆盖它们。
二、接口：
接口是引用类型的，类似于类,和抽象类的相似之处有
三点：
1、不能实例化；
2、包含未实现的方法声明；
3、派生类必须实现未实现的方法，抽象类是抽象方
法，接口则是所有成员（不仅是方法包括其他成员）；
另外，接口有如下特性：
接口除了可以包含方法之外，还可以包含属性、索引器、事
件，而且这些成员都被定义为公有的。除此之外，不能包含任
何其他的成员，例如：常量、域、构造函数、析构函数、静态
成员。一个类可以直接继承多个接口，但只能直接继承一个类
（包括抽象类）。
三、抽象类和接口的区别：
1.类是对对象的抽象，可以把抽象类理解为把类当作对
象，抽象成的类叫做抽象类.而接口只是一个行为的规范或规
定，微软的自定义接口总是后带able字段，证明其是表述一类
类“我能做。。。”.抽象类更多的是定义在一系列紧密相关的
类间，而接口大多数是关系疏松但都实现某一功能的类中.
2.接口基本上不具备继承的任何具体特点,它仅仅承诺
了能够调用的方法;
3.一个类一次可以实现若干个接口,但是只能扩展一个
父类
4.接口可以用于支持回调,而继承并不具备这个特点.
5.抽象类不能被密封。
6.抽象类实现的具体方法默认为虚的，但实现接口的类
中的接口方法却默认为非虚的，当然您也可以声明为虚的.
7.（接口）与非抽象类类似，抽象类也必须为在该类的
基类列表中列出的接口的所有成员提供它自己的实现。但是，
允许抽象类将接口方法映射到抽象方法上。
8.抽象类实现了oop中的一个原则，把可变的与不可变
的分离。抽象类和接口就是定义为不可变的，而把可变的座位
子类去实现。
9.好的接口定义应该是具有专一功能性的，而不是多功
能的，否则造成接口污染。如果一个类只是实现了这个接口的
中一个功能，而不得不去实现接口中的其他方法，就叫接口污
染。
10.尽量避免使用继承来实现组建功能，而是使用黑箱复
用，即对象组合。因为继承的层次增多，造成最直接的后果就
是当你调用这个类群中某一类，就必须把他们全部加载到栈
中！后果可想而知.（结合堆栈原理理解）。同时，有心的朋友
可以留意到微软在构建一个类时，很多时候用到了对象组合的
方法。比如asp.net中，Page类，有Server Request等属性，
但其实他们都是某个类的对象。使用Page类的这个对象来调用
另外的类的方法和属性，这个是非常基本的一个设计原则。
11.如果抽象类实现接口，则可以把接口中方法映射到抽
象类中作为抽象方法而不必实现，而在抽象类的子类中实现接
口中方法.
四、抽象类和接口的使用：
1. 如果预计要创建组件的多个版本，则创建抽象类。
抽象类提供简单的方法来控制组件版本。
2.如果创建的功能将在大范围的全异对象间使用，则使
用接口。如果要设计小而简练的功能块，则使用接口。
3.如果要设计大的功能单元，则使用抽象类.如果要在
组件的所有实现间提供通用的已实现功能，则使用抽象类。
4.抽象类主要用于关系密切的对象；而接口适合为不相
关的类提供通用功能。
以下是我在网上看到的几个形象比喻,真的非常不错,呵呵:
1.飞机会飞，鸟会飞，他们都继承了同一个接口“飞”；但是
F22属于飞机抽象类，鸽子属于鸟抽象类。
2. 就像铁门木门都是门（抽象类），你想要个门我给不了（不
能实例化），但我可以给你个具体的铁门或木门（多态）；而
且只能是门，你不能说它是窗（单继承）；一个门可以有锁
（接口）也可以有门铃（多实现）。 门（抽象类）定义了你是
什么，接口（锁）规定了你能做什么（一个接口最好只能做一
件事，你不能要求锁也能发出声音吧（接口污染））。
============================字段与常量比较====================================
只读readonly
只读字段：常量字段都是一旦赋值，不可更改
只读字段：可任何时候赋值，常量：声明时就直接赋值
只读字段：声明类型时可是对象类型，也可是值类型 常
量：只是值类型如double
==========================throw=======================================
namespace @catch
{
class DataBase
{
public bool opendb()
{
//throw new ArgumentException("打开数据
库文件错误");
return true;
}
public bool login()
{
//throw new IndexOutOfRangeException("登
陆数据库引发错误");
return true;
}
public bool closedb()//只要调用此方法就返回
true
{
//throw new Exception("关闭数据库引发错
误");
return true;
}
}
class Program
{
static void Main(string[] args)
{
Console.WriteLine("处理数据库操作引发的异
常");
DataBase db = new DataBase();
try
{
Console.WriteLine("打开数据库");
if (db.opendb())
{
Console.WriteLine("打开数据库成
功");
Console.WriteLine("登陆数据库");
if (db.login())
{
Console.WriteLine("登陆数据
库成功");
}
}
if (db.closedb())
{
Console.WriteLine("关闭数据库成
功");
}
}
catch (ArgumentException e)
{
Console.WriteLine("引发异常：{0}",
e.Message);
}
catch (IndexOutOfRangeException e)
{
Console.WriteLine("引发异常：{0}",
e.Message);
}
catch (Exception e)
{
Console.WriteLine("引发异常：{0}",
e.Message);
}
}
}
}
上面分析：
class A
{
public static void AA()
{
try
{
throw new Exception();
}
catch(Exception e)
{
throw e;
}
}
}
class Program
{
static void Main(string[] args)
{
try
{
A.AA();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
}
===========================String.Format====================================
(String.Format("Invalid format string: '{0}'.",
format))
==========================Hashtable=====================================
class Program
{
static void Main(string[] args)
{
//创建一个新的hash表.
Hashtable openWith = new Hashtable();
//添加一些元素
openWith.Add("txt", "notepad.exe");
openWith.Add("bmp", "paint.exe");
openWith.Add("dib", "paint.exe");
openWith.Add("rtf", "wordpad.exe");
//如果新添加的元素已经在表中，则抛出异常
try
{
openWith.Add("txt", "winword.exe");
}
catch
{
Console.WriteLine("带有Key是 /"txt/" 的元素已经存
在.");
}
Console.WriteLine("For key = /"rtf/", value = {0}.",
openWith["rtf"]);
openWith["rtf"] = "winword.exe";
Console.WriteLine("For key = /"rtf/", value = {0}.",
openWith["rtf"]);
openWith["doc"] = "winword.exe";
//如果寻找的不在表中，则抛出异常
try
{
Console.WriteLine("For key = /"tif/", value =
{0}.", openWith["tif"]);
}
catch
{
Console.WriteLine("Key = /"tif/" is not found.");
}
// 在插入之前，ContainsKey用来测试keys
if (!openWith.ContainsKey("ht"))
{
openWith.Add("ht", "hypertrm.exe");
Console.WriteLine("Value added for key = /"ht/":
{0}", openWith["ht"]);
}
// foreach枚举hash表的元素
Console.WriteLine();
foreach (DictionaryEntry de in openWith)
{
Console.WriteLine("Key = {0}, Value = {1}",
de.Key, de.Value);
}
// Values属性获取 值：values
ICollection valueColl = openWith.Values;
// ValueCollection的值输出
Console.WriteLine();
foreach (string s in valueColl)
{
Console.WriteLine("Value = {0}", s);
}
//键：keys
ICollection keyColl = openWith.Keys;
// ValueCollection的值输出
Console.WriteLine();
foreach (string s in keyColl)
{
Console.WriteLine("Key = {0}", s);
}
// Remove方法删除key/value.
Console.WriteLine("/nRemove(/"doc/")");
openWith.Remove("doc");
if (!openWith.ContainsKey("doc"))
{
Console.WriteLine("Key /"doc/" is not found.");
}
}
===========================Base======================================
class BaseClass
{
public BaseClass()
{
Console.WriteLine("[BaseClass.BaseClass()] " + "无参
数的调用构造函数");
}
public BaseClass(int foo)
{
Console.WriteLine("[BaseClass.BaseClass(int foo)] " +
"foo = {0}",foo);
}
}
class DerivedClass : BaseClass
{
public DerivedClass(int foo):base(foo)
{
Console.WriteLine("[DerivedClass.DerivedClass] " +
"foo = {0}",foo);
}
}
class Program
{
static void Main(string[] args)
{
Console.WriteLine("[Main]初始化一个 " + "DerivedClass
对象");
DerivedClass derived = new DerivedClass(100);
}
}
=============================is/as======================================
类型安全是.NET设计之初重点考虑的内容之一，对于程序设计
者来说，完全把握系统数据的类型安全，经常是力不从心的问
题。现在，这一切已经在微软大牛们的设计框架中为你解决
了。在.NET中，一切类型都必须集成自System.Object类型，
因此我们可以很容易的获得对象的准确类型，方法是：
GetType()方法。那么.NET中的类型转换，应该考虑的地方有
那些呢？
2. 概念引入
类型转换包括显示转换和隐式转换，在.NET中类型转换的基本
规则如下：
任何类型都可以安全的转换为其基类类型，可以由隐式转换来
完成；
任何类型转换为其派生类型时，必须进行显示转换，转换的规
则是：（类型名）对象名；
使用GetType可以取得任何对象的精确类型；
基本类型可以使用Covert类实现类型转换；
除了string以外的其他类型都有Parse方法，用于将字符串类
型转换为对应的基本类型；
值类型和引用类型的转换机制称为装箱（boxing）和拆箱
（unboxing）。
3. 原理与示例说明
浅谈了类型转换的几个普遍关注的方面，该将主要精力放在
is、as操作符的恩怨情仇上了。类型转换将是个较大的话题，
留于适当的时机讨论。
is/as操作符，是C#中用于类型转换的，提供了对类型兼容性
的判断，从而使得类型转换控制在安全的范畴，提供了灵活的
类型转换控制。
is的规则如下：
检查对象类型的兼容性，并返回结果，true或者false；
不会抛出异常；
如果对象为null，则返回值永远为false。
其典型用法为：
1object o = new object();
2
3class A
4
5{
6
7}
8
9if (o is A) //执行第一次类型兼容检查
10
11{
12
13 A a = (A) o; //执行第二次类型兼容检查
14
15}
16
17
as的规则如下：
检查对象类型的兼容性，并返回结果，如果不兼容就返回
null；
不会抛出异常；
如果结果判断为空，则强制执行类型转换将抛出
NullReferenceException异常。
其典型用法为：
1object o = new object();
2
3class B
4
5{
6
7}
8
9B b = o as B; //执行一次类型兼容检查
10
11if (b != null)
12
13{
14
15 MessageBox.Show("b is B's instance.");
16
17}
18
19
is 是用来判断能不能做转换，结果为False就不执行转换代
码，这样可以保证类型安全。
as 是转换后，转换成功就返回对象，转换失败结果为null，
所以通过判断结果是否为null,可以保证类型安全。
============================函数=======================================
1、DateTime 数字型
System.DateTime currentTime=new System.DateTime();
1.1 取当前年月日时分秒
currentTime=System.DateTime.Now;
1.2 取当前年
int 年=currentTime.Year;
1.3 取当前月
int 月=currentTime.Month;
1.4 取当前日
int 日=currentTime.Day;
1.5 取当前时
int 时=currentTime.Hour;
1.6 取当前分
int 分=currentTime.Minute;
1.7 取当前秒
int 秒=currentTime.Second;
1.8 取当前毫秒
int 毫秒=currentTime.Millisecond;
（变量可用中文）
2、Int32.Parse(变量) Int32.Parse("常量")
字符型转换 转为32位数字型
3、 变量.ToString()
字符型转换 转为字符串
12345.ToString("n"); //生成 12,345.00
12345.ToString("C"); //生成 ￥12,345.00
12345.ToString("e"); //生成 1.234500e+004
12345.ToString("f4"); //生成 12345.0000
12345.ToString("x"); //生成 3039 (16进制)
12345.ToString("p"); //生成 1,234,500.00%
4、变量.Length 数字型
取字串长度：
如： string str="中国";
int Len = str.Length ; //Len是自定义变量， str是求测
的字串的变量名
5、System.Text.Encoding.Default.GetBytes(变量)
字码转换 转为比特码
如：byte[] bytStr =
System.Text.Encoding.Default.GetBytes(str);
然后可得到比特长度：
len = bytStr.Length;
6、System.Text.StringBuilder("")
字符串相加，（+号是不是也一样？）
如：System.Text.StringBuilder sb = new
System.Text.StringBuilder("");
sb.Append("中华");
sb.Append("人民");
sb.Append("共和国");
7、变量.Substring(参数1,参数2);
截取字串的一部分，参数1为左起始位数，参数2为截取几位。
如：string s1 = str.Substring(0,2);
8、String user_IP=Request.ServerVariables
["REMOTE_ADDR"].ToString();
取远程用户IP地址
9、穿过代理服务器取远程用户真实IP地址：
if(Request.ServerVariables["HTTP_VIA"]!=null){
string user_IP=Request.ServerVariables
["HTTP_X_FORWARDED_FOR"].ToString();
}else{
string user_IP=Request.ServerVariables
["REMOTE_ADDR"].ToString();
}
10、 Session["变量"];
存取Session值；
如，赋值： Session["username"]="小布什";
取值： Object objName=Session["username"];
String strName=objName.ToString();
清空： Session.RemoveAll();
11、String str=Request.QueryString["变量"];
用超链接传送变量。
如在任一页中建超链接:<a href=Edit.aspx?fbid=23>点击
</a>
在Edit.aspx页中取值：String str=Request.QueryString
["fdid"];
12、DOC对象.CreateElement("新建节点名");
创建XML文档新节点
13、父节点.AppendChild(子节点)；
将新建的子节点加到XML文档父节点下
14、 父节点.RemoveChild(节点);
删除节点
15、Response
Response.Write("字串")；
Response.Write(变量)；
向页面输出。
Response.Redirect("URL地址"）；
跳转到URL指定的页面
16、char.IsWhiteSpce(字串变量，位数)--逻辑型
查指定位置是否空字符；
如：
string str="中国 人民";
Response.Write(char.IsWhiteSpace(str,2)); //结果为：
True, 第一个字符是0位，2是第三个字符。
17、char.IsPunctuation('字符') --逻辑型
查字符是否是标点符号
如：Response.Write(char.IsPunctuation('A')); //返
回：False
18、(int)'字符'
把字符转为数字，查代码点，注意是单引号。
如：
Response.Write((int)'中'); //结果为中字的代码：20013
19、(char)代码
把数字转为字符，查代码代表的字符。
如：
Response.Write((char)22269); //返回“国”字。
20、 Trim()
清除字串前后空格
21 、字串变量.Replace("子字串","替换为")
字串替换
如：
string str="中国";
str=str.Replace("国","央"); //将国字换为央字
Response.Write(str); //输出结果为“中央”
再如：（这个非常实用）
string str="这是<script>脚本";
str=str.Replace("<","<font><</font>"); //将左尖括号替
换为<font> 与 < 与 </font> （或换为<，但估计经XML存诸
后，再提出仍会还原）
Response.Write(str); //显示为：“这是<script>脚本”
如果不替换，<script>将不显示，如果是一段脚本，将运行；
而替换后，脚本将不运行。
这段代码的价值在于：你可以让一个文本中的所有HTML标签失
效，全部显示出来，保护你的具有交互性的站点。
具体实现：将你的表单提交按钮脚本加上下面代码：
string strSubmit=label1.Text; //label1是你让用户提交
数据的控件ID。
strSubmit=strSubmit.Replace("<","<font><</font>");
然后保存或输出strSubmit。
用此方法还可以简单实现UBB代码。
22、Math.Max(i,j)
取i与j中的最大值
如 int x=Math.Max(5,10); // x将取值 10
23、字串对比一般都用: if(str1==str2){ } , 但还有别的
方法:
(1)、
string str1; str2
//语法: str1.EndsWith(str2); __检测字串str1是否以字串
str2结尾,返回布尔值.如:
if(str1.EndsWith(str2)){ Response.Write("字串str1是
以"+str2+"结束的"); }
(2)、
//语法:str1.Equals(str2); __检测字串str1是否与字串
str2相等,返回布尔值,用法同上.
(3)、
//语法 Equals(str1,str2); __检测字串str1是否与字串
str2相等,返回布尔值,用法同上.
24、IndexOf() 、LastIndexOf()
查找字串中指定字符或字串首次（最后一次）出现的位置,返回
索引值，如：
str1.IndexOf("字")； //查找“字”在str1中的索引值（位
置）
str1.IndexOf("字串")；//查找“字串”的第一个字符在str1
中的索引值（位置）
str1.IndexOf("字串",3,2)；//从str1第4个字符起，查找2
个字符，查找“字串”的第一个字符在str1中的索引值（位
置）
25、Insert()
在字串中指定索引位插入指定字符。如：
str1.Insert(1,"字");在str1的第二个字符处插入“字”，如
果str1="中国"，插入后为“中字国”；
26、PadLeft()、PadRight()
在字串左（或右）加空格或指定char字符，使字串达到指定长
度，如：
<%
string str1="中国人";
str1=str1.PadLeft(10,'1'); //无第二参数为加空格
Response.Write(str1); //结果为“1111111中国人” ， 字
串长为10
%>
27、Remove()
从指定位置开始删除指定数的字符
字串对比一般都用: if(str1==str2){ } , 但还有别的方法:
1、
string str1; str2
//语法: str1.EndsWith(str2); __检测字串str1是否以字串
str2结尾,返回布尔值.如:
if(str1.EndsWith(str2)){ Response.Write("字串str1是
以"+str2+"结束的"); }
2、
//语法:str1.Equals(str2); __检测字串str1是否与字串
str2相等,返回布尔值,用法同上.
3、
//语法 Equals(str1,str2); __检测字串str1是否与字串
str2相等,返回布尔值,用法同上.
IndexOf()
查找字串中指定字符或字串首次出现的位置,返首索引值，如：
str1.IndexOf("字")； //查找“字”在str1中的索引值（位
置）
str1.IndexOf("字串")；//查找“字串”的第一个字符在str1
中的索引值（位置）
str1.IndexOf("字串",3,2)；//从str1第4个字符起，查找2
个字符，查找“字串”的第一个字符在str1中的索引值（位
置）
1.9 取中文日期显示--年月日时分
string strY=currentTime.ToString("f"); //不显示秒
1.10 取中文日期显示_年月
string strYM=currentTime.ToString("y");
1.11 取中文日期显示_月日
string strMD=currentTime.ToString("m");
1.12 取当前年月日，格式为：2003-9-23
string strYMD=currentTime.ToString("d");
1.13 取当前时分，格式为：14：24
string strT=currentTime.ToString("t");
================================c#访问修饰符==================================
C#中类的默认修饰符是internal。类成员和结构成员的默认访
问修饰符是private。
一 类的修饰符：
1 private 只有对包.NET中的应用程序或库才能访问。
2 public 不限制对类的访问。
3 protected 只可以被本类和其继承子类访问；
4 internal 只可以被本集合（Assembly）内所有的类存取。
集合是C#语言中类被组合后的逻辑单位和物理单位，其编译后
的文件扩展名往往是“.DLL”或“.EXE”。 仅为同项目(这里
的项目是只单独的项目,而不是整个解决方案)调用。
5 protected internal 唯一的一种组合限制修饰符，它只可
以被本组合体内所有的类和这些类的继承子类所存取。（注
意：提供的不是internal且protected访问方式）
6 abstract 抽象类，表示该类只能作为父类被用于继承，而
不能进行对象实例化。抽象类可以包含抽象的成员，但这并非
必须。abstract不能和new同时用。
7 sealed 密封类，阻止该类被继承。同时对一个类作
abstract和sealed的修饰是没有意义的，也是被禁止的。
8 new 修饰符只能用于嵌套的类，表示隐藏了由基类继承来
的、与基类中同名的成员和方法。
注：如果不是嵌套的类，命名空间或编译单元内的类只有
public和internal两种修饰。
二 成员访问修饰符
1 private 私有类型成员只能从定义它的类型中访问。类成员
和结构成员缺省时为私有。
2 public 公有类型或类型成员能从程序的任何地方访问。
3 protected 受保护类成员只可以被本类和其继承子类访问。
（？在外部集合是否可以访问？）
4 internal 内部受保护类成员只可以被定义它的所在集合
（Assembly）内所有的类存取。集合是C#语言中类被组合后的
逻辑单位和物理单位，其编译后的文件扩展名往往是“.DLL”
或“.EXE”。仅为同项目调用(这里的项目是指单独的项目,而
不是整个解决方案)。
5 internal protected 唯一的一种组合限制修饰符，它只可
以被本组合体内所有的类和这些类的继承子类所存取。（注
意：提供的不是internal且protected访问方式）
6 override用于成员函数，说明本函数覆盖父类中的同名函
数。调用时系统会在整个继承结构中找到最具体的类并执行此
最具体类中的函数，不管当时的对象是保存在哪一个层次的类
对象中。
7 new 用于成员函数，说明本函数隐藏父类中的同名函数。从
此之后本函数不再处于父类同名函数的继承结构体系中，就如
同在本类中定义了一个全新的不同名函数一样。
8 virtual用于成员函数，说明本函数可以在子类中被改写，
也可以被隐藏，如果子类中没有重定义该函数，那就使用父类
的函数体。一个abstract函数总是一个Virtual函数。除了静
态方法外，非静态属性和非静态索引器也能声明为virtual。
其他的函数成员不能声明为virtual，因而也不能被覆盖。(注
意：一个虚方法不能为私有)
9 Extern 用于成员函数，说明本函数在外部程序，如一个非
操控dll中。
10 const 关键字声明的成员叫常量，在应用程序生命期中保
持不变的域。必须在编译期初赋值，可以默认。缺省时是静态
的(static)。
11 Readonly用于类成员变量，该变量可以在构造函数内被初
始化，从此之后就不可再被修改。
12 static readonly 修饰符声明的成员依然是变量，只不过
具有和常量类似的使用方法：通过类进行访问、初始化后不可
以修改。但与常量不同的是这种变量是在运行期初始化。
13 Static 适用于类成员函数和成员变量，说明本成员是一个
类级别的成员，同所有对象共享，可以通过类名来访问。
14 event事件成员，用以触发某个事件
注意：不管访问修饰符是什么，基类的构造函数和析构函数永
远也不能被派生类继承。
派生类不能继承基类的构造函数，但可以通过派生类构造函数
中的构造函数初始化器调用它们。编译器自动在没有显式定义
构造函数初始化器的派生类的构造函数上附加构造函数初始化
器（调用缺省的基类构造函数）。
附加：
1下面是抽象类用法的伪码：
abstract class A
{
public abstract void F();
}
abstract class B: A
{
public void G() {}
}
class C: B
{
public override void F()
{
//方法F的实现
}
}
抽象类A内含一个抽象方法F()，它不能被实例化。类B继承自
类A，其内包含了一个实例方法G(),但并没有实现抽象方法F
()，所以仍然必须声明为抽象类。类C继承自类B，实现类抽象
方法F()，于是可以进行对象实例化。
2在C#中有一个规定：编译器不允许派生类的可访问性比其基类
更高。也就是说，内部类可以继承于一个公共类，但公共类不
能继承于一个内部类。
合法的：内部类继承公共类
public class MyBase
{
//class members
}
internal class MyClass : MyBase
{
//class members
}
不合法的：公共类继承内部类（编译器会说可访问性不一
致）
internal class MyBase
{
//class members
}
public class MyClass : MyBase
{
//class members
}
===============================索引器==================================
class ListBox_ex
{
//使用ArrayList成员中存储的数据来检验传递的索引值
protected ArrayList data = new ArrayList();
public object this[int idx]
{
get
{
if (idx > -1 && idx < data.Count)
{//返回值："" :data[0];
return (data[idx]);
}
else
{
//抛出异常，这个也可以在索引器外执行
throw new InvalidOperationException
("[ListBox_ex.set_Item]"+"Index out of range");
}
}
set
{
if (idx > -1 && idx < data.Count)
{
data[idx] = value;
}
else if (idx == data.Count)
{
data.Add(value);
}
else
{
throw new InvalidOperationException
("[ListBox_ex.get_Item] Index out of range");
}
}
}
}
class Program
{
static void Main(string[] args)
{
ListBox_ex lbx = new ListBox_ex();
//与使用数组的方法类似，索引器也是按照数组的方式访问
lbx[0] = "这";//索引器set:""
lbx[1] = "是";
lbx[2] = "索引器";
Console.WriteLine("{0} {1} {2}",lbx[0],lbx[1],lbx
[2]);
//索引器get:""
}
}
========================== ==equals=============================
class Program
{
class Person
{
private string name;
public string Name
{
get { return name; }
set { name = value; }
}
public Person(string name)
{
this.name = name;
}
public override bool Equals(object obj)
{
if (!(obj is Person))
{
return false;
}
Person per = (Person)obj;
return this.name == per.name;
}
}
static void Main(string[] args)
{
string a = new string(new char[] { 'h', 'e', 'l', 'l', 'o' });//串比较的是堆中值,串之外的引用比较的是栈中引用对象
string b = new string(new char[] { 'h', 'e', 'l', 'l', 'o' });
Console.WriteLine(a == b);//串比较2 个变量的堆中值true
Console.WriteLine(a.Equals(b));//串比较堆中值true
object g = a;
object h = b;
Console.WriteLine(g == h);//对于string外的引用==比较的是是否引用了同一个对象false
Console.WriteLine(g.Equals(h));//equals继承父类opject true 串比较堆中值
Person p1 = new Person("jia");
Person p2 = new Person("jia");
Console.WriteLine(p1 == p2);//string外的引用==比较是否引用同一个对象false
Console.WriteLine(p1.Equals(p2));//false,没引用同一个对象
Person p3 = new Person("jia");
Person p4 = p3;
Console.WriteLine(p3 == p4);//true,2个对象引用同一个对象p3==p3
Console.WriteLine(p3.Equals(p4));//true都引用同一个对象,2个对象的内容一样
Console.ReadLine();
}
-------------------------------------
== true:条件：值相同，类型相同 类型不同，其长度
不同
equals:true条件：对同一对象的引用
equals与==的区别
对于值类型，如果对象的值相等，则相等运算符 (==) 返回
true，否则返回 false。对于string 以外的引用类型，如果
两个对象引用同一个对象，则 == 返回 true。对于 string
类型，== 比较字符串的值。
==操作比较的是两个变量的值是否相等。
equals（）方法比较的是两个对象的内容是否一
致．equals也就是比较引用类型是否是对同一个对象的引用。
对于值类型的比较，这里就不做描述了，下面讨论引用类
型的比较：
首先我们看一段程序
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ConsoleApplication1
{
class Person
{
private string name;
public string Name
{
get { return name; }
set { name = value; }
}
public Person(string name)
{
this.name = name;
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
string a = new string(new char[] { 'h',
'e', 'l', 'l', 'o' });
string b = new string(new char[] { 'h',
'e', 'l', 'l', 'o' });
Console.WriteLine(a == b);
Console.WriteLine(a.Equals(b));
object g = a;
object h = b;
Console.WriteLine(g == h);
Console.WriteLine(g.Equals(h));
Person p1 = new Person("jia");
Person p2 = new Person("jia");
Console.WriteLine(p1 == p2);
Console.WriteLine(p1.Equals(p2));
Person p3 = new Person("jia");
Person p4 = p3;
Console.WriteLine(p3 == p4);
Console.WriteLine(p3.Equals(p4));
Console.ReadLine();
}
}
}
运行程序，会输出什么呢？
答案是 true，true，false，true，false，false，true，
true。
为什么会出现这个答案呢？因为值类型是存储在内存中的堆栈
（以后简称栈），而引用类型的变量在栈中仅仅是存储引用类
型变量的地址，而其本身则存储在堆中。
==操作比较的是两个变量的值是否相等，对于引用型变量
表示的是两个变量在堆中存储的地址是否相同，即栈中的内容
是否相同。
equals操作表示的两个变量是否是对同一个对象的引用，
即堆中的内容是否相同。
而字符串是一个特殊的引用型类型，在C#语言中，重载了
string 对象的很多方法方法(包括equals()方法)，使string
对象用起来就像是值类型一样。
因此在上面的例子中，字符串a和字符串b的两个比较是相
等的。
对于object g 和object h 时内存中两个不同的对象，所
以在栈中的内容是不相同的，故不相等。而g.equals(h)用的
是sting的equals()方法故相等（多太）。如果将字符串a和b
作这样的修改：
string a="aa";
string b="aa";
则，g和h的两个比较都是相等的。这是因为系统并没有给字符
串b分配内存，只是将"aa"指向了b。所以a和b指向的是同一个
字符串（字符串在这种赋值的情况下做了内存的优化）。
对于p1和p2，也是内存中两个不同的对象，所以在内存中的地
址肯定不相同，故p1==p2会返回false，又因为p1和p2又是对
不同对象的引用，所以p1.equals(p2)将返回false。
对于p3和p4，p4=p3，p3将对对象的引用赋给了p4，p3和p4是
对同一个对象的引用，所以两个比较都返回true。
如果我们对person的equals方法重写：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ConsoleApplication1
{
class Person
{
private string name;
public string Name
{
get { return name; }
set { name = value; }
}
public Person(string name)
{
this.name = name;
}
public override bool Equals(object obj)
{
if (!(obj is Person))
return false;
Person per = (Person)obj;
return this.Name == per.Name;
}
}
}那么p1.equals(p2),就会返回true。
---------------------------------------
//＝＝比较的是栈中内容，equals堆中内容
普通比较：--equals都是比较的引用，栈中内容
string：特殊比较：都是比较值，堆中内容
class Program
{
static void Main(string[] args)
{
string a = new string(new char[] { 'h',
'e', 'l', 'l', 'o' });
string b = new string(new char[] { 'h',
'e', 'l', 'l', 'o' });
object g = a;
object h = b;
Console.WriteLine(g.Equals(h));//true
//string a赋给object，任何对象的基类，此处为equals重
载,string为object的子类，子类继承父类，执行
子类，执行string，比较是值
Person p1 = new Person("jia");
Person p2 = new Person("jia");
Console.WriteLine(p1 == p2);///false
Console.WriteLine(p1.Equals(p2));//false
}
}
class Person
{
private string name;
public string Name
{
get { return name; }
set { name = value; }
}
public Person(string name)
{
this.name = name;
}
}
----------------------------------------
class Program
{
class Person
{
private string name;
public string Name
{
get { return name; }
set { name = value; }
}
public Person(string name)
{
this.name = name;
}
public override bool Equals(object obj)//obj是object类型，所有类的父类，，不能参与具体类型的比较，所以要强转为同一
//一种具体的类型，才能比较，同一种类型下的变量，反过来一种具体类型转为object,则不用强转，为隐式转换，但比较还是要显示为具体类型
{
if (!(obj is Person))
{
return false;
}
Person per = (Person)obj;
return this.name == per.name;
}
}
static void Main(string[] args)
{
string a = new string(new char[] { 'h', 'e', 'l', 'l', 'o' });//串比较的是堆中值,串之外的引用比较的是栈中引用对象
string b = new string(new char[] { 'h', 'e', 'l', 'l', 'o' });
Console.WriteLine(a == b);//串比较2 个变量的堆中值true
Console.WriteLine(a.Equals(b));//串比较堆中值true
object g = a;
object h = b;
Console.WriteLine(g == h);//对于string外的引用==比较的是是否引用了同一个对象false
Console.WriteLine(g.Equals(h));//equals继承父类opject true 串比较堆中值 equals比较的是堆中值，此处string
//是object子类，所以执行子类，又因equals重载string方法，string是特殊的引用类型，比较堆中值，
Person p1 = new Person("jia");
Person p2 = new Person("jia");
Console.WriteLine(p1 == p2);//string外的引用==比较是否引用同一个对象false
Console.WriteLine(p1.Equals(p2));//false,没引用同一个对象
Person p3 = new Person("jia");
Person p4 = p3;
Console.WriteLine(p3 == p4);//true,2个对象引用同一个对象p3==p3
Console.WriteLine(p3.Equals(p4));//true都引用同一个对象,2个对象的内容一样
Console.ReadLine();
}
==============================This===================================
using System;
using System.Collections.Generic;
using System.Text;
namespace ConsoleApplication13
{
public class A
{
private string _name;//private只限本类用,调用可通过属性器
private int _age;
private string[] arr=new string[5];
public string getName
{
get
{
return this._name;
}
}
public int getAge
{
get
{
return this._age;
}
}
public string this[int param]//this:引用本类中的实例this:本类中的当前数组类型为arr //this:a[]
{
get
{
return arr[param];
}
set
{
arr[param] = value;
}
}
public A() { }
public A(string name, int age)
{
this._name = name;//本类中的实例字段_name
this._age=age;
}
public void Print()
{
B.PrintA(this);//this本类中的实例，方法中形参为类类型，所以这里传递的是本类的对象 //this:A a this类对象
}
}
public class B
{
public static void PrintA(A a)//a:this
{
Console.WriteLine(a.getAge+" "+a.getName);
}
}
class Program
{
static void Main(string[] args)
{
A a = new A("Kong", 21);
a[0] = "aa";//a:this
a[1] = "bb";
a[4] = "cc";
a.Print();
for (int i = 0; i < 5; i++)
{
Console.WriteLine(a[i]);//a:表示：this
}
}
}
}
---------------------------------------------
public class A
{
private string _name;//private只限本类用,调用可通过属性器
private int _age;
private string[] arr=new string[5];
public string getName
{
get
{
return this._name;
}
}
public int getAge
{
get
{
return this._age;
}
}
public string this[int param]//this:引用本类中的实例this:
本类中的当前数组类型为arr //this:a[]
{
get
{
return arr[param];
}
set
{
arr[param] = value;
}
}
public A() { }
public A(string name, int age)
{
this._name = name;//本类中的实例字段_name
this._age=age;
}
public void Print()
{
B.PrintA(this);//this本类中的实例，方法中形参为类类
型，所以这里传递的是本类的对象 //this:A a this类对象
}
}
public class B
{
public static void PrintA(A a)//a:this
{
Console.WriteLine(a.getAge+" "+a.getName);
}
}
class Program
{
static void Main(string[] args)
{
A a = new A("Kong", 21);
a[0] = "aa";//a:this
a[1] = "bb";
a[4] = "cc";
a.Print();
for (int i = 0; i < 5; i++)
{
Console.WriteLine(a[i]);//a:表示：this
}
}
}
=============================Interface======================================
using System;
using System.Collections.Generic;
using System.Text;
namespace ConsoleApplication2
{
interface IDrivingLicenceB//执照 //接口继承接口，且接口方法名相同 //接口:做什么
{
void GetLicence();
}
interface IDrivingLicenceA:IDrivingLicenceB//执照
{
new void GetLicence();
}
class Teacher : IDrivingLicenceA//老师考执照
{
void IDrivingLicenceB.GetLicence()//默认为private,对class:private
//对接口:子类中接口方法的实现 ：对接口:publc
{
Console.WriteLine("获得B执照");
}
void IDrivingLicenceA.GetLicence()
{
Console.WriteLine("获得A执照");
}
public void GetLicence()
{
Console.WriteLine("This is not interface Method!");
}
}
class Student : IDrivingLicenceB
{
public void GetLicence()
{
Console.WriteLine("获得B执照");
}
}
class Program
{
static void DriveCar(string nmae, IDrivingLicenceB o)//判断老师是否通过执照
{//判断是否为接口
IDrivingLicenceB dl = o as IDrivingLicenceB;//判断接口是否为空值，即子类是否已实现接口
if (dl!=null)//判断只要不为空，就通过,这里一定不为空，子类不实现接口，报错
{
Console.WriteLine(nmae+"可以开卡车了");
}
else
{
Console.WriteLine(nmae+"未通过执照");
}
}
static void DriveBus(string nmae, IDrivingLicenceB o)//判断老师是否通过执照
{//判断是否为接口
IDrivingLicenceA dl = o as IDrivingLicenceA;//判断接口是否为空值，即子类是否已实现接口
if (dl != null)//判断只要不为空，就通过,这里一定不为空，子类不实现接口，报错
{
Console.WriteLine(nmae + "可以开Bus车了");
}
else
{
Console.WriteLine(nmae + "未通过执照");
}
}
static void Main(string[] args)
{
Teacher t = new Teacher();
((IDrivingLicenceA)t).GetLicence();//显式转换
((IDrivingLicenceB)t).GetLicence();
t.GetLicence();
//DriveCar("Teacher", t);
//DriveBus("Teacher", t);
//Student s = new Student();
//DriveCar("Student", s);
//DriveBus("Student", s);
}
}
}
-------------------------------------
值：存放数据 数据在栈
引用：存放地址，即对象的引用 地址在栈，数据在堆
共同点：都是在栈上创建的，只是存放不同而已
-------------
f11进入方法体
f10不进方法体
C#类和接口、虚方法和抽象方法及值类型和引用类型的区别
1.C#类和接口的区别
接口是负责功能的定义，项目中通过接口来规范类，操作类以及抽象类的概念！
而类是负责功能的具体实现！
在类中也有抽象类的定义，抽象类与接口的区别在于：
抽象类是一个不完全的类，类里面有抽象的方法，属性，也可以有具体的方法和属性，需要进一步
的专业化。
但接口是一个行为的规范，里面的所有东西都是抽象的！
一个类只可以继承一个基类也就是父类，但可以实现多个接口
PS：接口除了规范一个行为之外，在具体项目中的实际作用也是十分重要的，在面向对象的设计原
则以及设计模式的使用中，无不体现作为一个接口的使用好处，最直接的就是设计原则中OCP（开放
封闭原则），我们使用接口，而不需要关心他的具体实现，具体实现的细节变化也无关客户端（使
用接口的类）的使用，对与扩展是开放的，我们可以另写一个接口的实现来扩展当前程序，而不影
响上层的使用，但对修改是封闭的，即我们不能够再去修改接口的定义，当然这个“不能够”是指
在规范原则上不应该这么做！
2.抽象类和接口的区别
答：
抽象类（abstract class）可以包含功能定义和实现，接口（interface）只能包含功能定义
抽象类是从一系列相关对象中抽象出来的概念， 因此反映的是事物的内部共性；接口是为了满足外
部调用而定义的一个功能约定， 因此反映的是事物的外部特性
分析对象，提炼内部共性形成抽象类，用以表示对象本质，即“是什么”
为外部提供调用或功能需要扩充时优先使用接口
3. C#语言中，值类型和引用类型有何不同?
解答
值类型和引用类型的区别在于，值类型的变量直接存放实际的数据，而引用类型的变量存放的
则是数据的地址，即对象的引用。
值类型变量直接把变量的值保存在堆栈中，引用类型的变量把实际数据的地址保存在堆栈中，
而实际数据则保存在堆中。注意，堆和堆栈是两个不同的概念，在内存中的存储位置也不相同，堆
一般用于存储可变长度的数据，如字符串类型;而堆栈则用于存储固定长度的数据，如整型类型的数
据int(每个int变量占用四个字节)。由数据存储的位置可以得知，当把一个值变量赋给另一个值变
量时，会在堆栈中保存两个完全相同的值;而把一个引用变量赋给另一个引用变量，则会在堆栈中保
存对同一个堆位置的两个引用，即在堆栈中保存的是同一个堆的地址。在进行数据操作时，对于值
类型，由于每个变量都有自己的值，因此对一个变量的操作不会影响到其它变量;对于引用类型的变
量，对一个变量的数据进行操作就是对这个变量在堆中的数据进行操作，如果两个引用类型的变量
引用同一个对象，实际含义就是它们在堆栈中保存的堆的地址相同，因此对一个变量的操作就会影
响到引用同一个对象的另一个变量。
4.结构和类的区别
解答
1) 结构是一个值类型，保存在栈上，而类是一个引用类型，保存在受管制的堆上。
2) 对结构中的数据进行操作比对类或对象中的数据进行操作速度要快。
3) 一般用结构存储多种类型的数据，当创建一个很多类或对象共用的小型对象时，使用结构效
率更高。
4.抽象方法和虚方法的区别
抽象方法
使用abstract关键字 public abstract bool Withdraw(…);
抽象方法是必须被派生类覆写的方法。
抽象方法是可以看成是没有实现体的虚方法
如果类中包含抽象方法，那么类就必须定义为抽象类，不论是否还包含其它一般方法
虚方法
使用virtual关键字 public virtual bool Withdraw(…);
调用虚方法，运行时将确定调用对象是什么类的实例，并调用适当的覆写的方法。
虚方法可以有实现体
---------------------------------------------------------------------------------------
------
虚拟方法和抽象方法有什么区别？
抽象方法只有声明没有实现，需要在子类中实现；虚拟方法有声明和实现，并且可以在子类中覆
盖，也可以不覆盖使用父类的默认实现
虚拟方法有实现代码
抽象方法则没有，
并且抽象类不能被实例化，只能实例化实现了全部抽象方法的派生类
抽象方法是虚拟方法的一种
抽象方法没有实现，它的存在只是为派生类统一接口；派生类应该实现这个方法
如果编写一个基类，它永远不会被实现，那么就应该将这个类中的一个或多个方法定义为
抽象方法。
抽象方法只有声明没有实现，需要在子类中实现；虚拟方法有声明和实现，并且可以在子类中覆
盖，也可以不覆盖使用父类的默认实现
补充一点
只允许在抽象类中使用抽象方法声明
学习
其实大家首先要搞清楚，虚方法与多态性关系密切，虚方法允许派生类完全或部分重写该类的方
法，需写方法体。抽象类中可以包含抽象方法与一般的方法，抽象类不可以new,抽象方法只是一个
定义，没有方法体，也就是没有{}，也不要在里面写内容。它们两个相像的一点是都用override重
写
麻雀虽小，五脏俱全，大程序分析时，要分成多个小程序分析，才能理解其思想，一个命令很明白
后，要书面总结写出核心用法，这样思想会很清楚。
return:执行方法中的第一个return,return后面的不执行
谁调用的return方法，就把结果返回谁
continue:循环中遇到continue时，他之后语句的不执行，直接返回循环递增处进行下一次循环，
if elseif:要么执行if 要么执行else if 只执行其中一个
if if 有可能全部执行;一个接一个执行
递归：先回推：执行到函数处重新到函数开始，一直到终止条件为止，
执行递归上面的部分
再递推：从函数递归处开始，到方法尾，循环直到递归开始时的条件止，
执行递归下面的部分
-------------------------------------------
接口：能做什么
抽象类：是什么
as稍微不同，它检查引用对象是否兼容，如果不兼容则返回null，因此需要做null的判断
as要做null判断，as为引用,类型兼容返回非空，否则返回空
//值转换
基本数据类型转换用：covent
字符串类型转换：parse
子类转为父类：隐式转换
父类转子类：显式转
值类型和引用类型的转换采用装箱(boxing)或拆箱(unboxing
GetType可以取得对象的精确类型
引用类型转换
is：检查对象是否与给定类型兼容 返回true false 值
引用 as用于在兼容的引用类型之间执行转换 返回null !null 所以要判断是否为null
protected:基类子类 中用；Main中不能访问基类中的protected成员，子类可访问基类中的成员
Main中不能访问基类子类中的受保护只在基类子类间有权
sizeof()用于值类型获取字节数
struct:值类型 不能继承另外的类或结构，但要继承接口
class：引用 可继承另外的类或构
override: 覆盖了基类虚方法，直接输出子类中方法
new:重写基类中的虚方法，但是new为新建方法，但又继承基类虚方法，只输出基类中的虚方法，并
没对基类方法重写，只是方法名相同
this:引用类的当前实例
类中字段要实例化，所以interface不能有字段
------------------------------------
//构造函数：字段变量为public
私量(属性)访问器:字段变量为private
类：1:先执行static构造函数，且只执行一次
2：再执行默认无参构造函数，
3:再执行有参构造函数，
static构造器作用：对类的static成员初始化
构造器作用：对类的public成员初始化
set作用:对类的private成员初始化赋值
static器,析构器无参：不能被其他调用，为自动调用，为private私有
属性器：无参，private
索引器:有参，private 都是为private字段读写 字段为数组字段
多态实现:方法１：虚方法
方法重载：参数个数不同或参数类型不同
方法重写：方法同名同参，只加 关键字；父类：virtual 派生类：override
多态：不同类对象可调用相同信息
不同的 调用同一个（相同的）
虚方法来重写：前提：类要继承父类
子类有参构造函数继承父类构造函数：是子类形参传给父类形参
c#参数默认为引用类型，不加ref,为值传递，值传递是开辟各自的内存空间，加ref,为引用传递地
址，引用为同一个内存地址，通过地址找到值
ref:传入，传出
out:传出
ref,out只对方法参数用
方法同名同参：重写
方法同名不同参：重载
out适合用在需要retrun多个返回值的地方，而ref则用在需要被调用的方法修改调用者的引用的时
候。
ref ,out 不能同时重载一个方法。
当希望方法返回多个值时，声明 out 方法非常有用
一个类只能继承一个基类，但可以同时继承多个接口
abstract virtual:基类中需要有一个实现的部分时，用virtual,否则用abstract
索引器同属性，有参属性
委托就是一个类，任何类都可声明委托
equals比较的是堆中内容,对同一对象的引用
== 栈中值是否相同
多个catch:只捕捉其中的一个，即只执行一个catch,一次只会发生一种异常，不会同时发生多个异
常
索引器：何时用：set get单个私量赋值，索引器：私量为数组，Hashtable 时，可用，有参赋值
索引器：类中有多个不同类型的字段，可另定义一个类，类中用索引器（多参），对上个类查找，
存取
.抽象类主要用于关系密切的对象；而接口适合为不相关的类提供通用功能
飞机会飞，鸟会飞，他们都继承了同一个接口“飞”；但是F22属于飞机抽象类，鸽子属于鸟抽象
类。
2. 就像铁门木门都是门（抽象类），你想要个门我给不了（不能实例化），但我可以给你个具体的
铁门或木门（多态）；而且只能是门，你不能说它是窗（单继承）；一个门可以有锁（接口）也可
以有门铃（多实现）。 门（抽象类）定义了你是什么，接口（锁）规定了你能做什么（一个接口最
好只能做一件事，你不能要求锁也能发出声音吧（接口污染））。
Interface:Can-do我能开车 能飞
abstract;Is-a我是司机 是飞行员
is:手动抛出异常时用 is不会抛出异常
as:不抛出异常时用
return:没有返回值时：跳出方法体
：return 1表示『函数正常结束』
return 0 表示『函数异常中止，不保证系统状态一致性』
方法对象new时， 方法有构造器，有属性set:先执行构造器中第一个变量，接着对应的set
而且通过set赋值
abstract class表示的是"is a"关系，interface表示的是"like a"关系
abstract:类中可以有抽象方法等，也可以有普通方法（有主体）
抽象方法等必须在抽象类中
子类必须实现父类abstract中的抽象方法等，而子类必须实现接口中的所有成员
接口只能有方法，属性，索引器，事件
抽象类主要用于设计大的功能单元；而接口用于设计小而简练的功能块。
==比较栈，所以值一般==
equals:比较堆中引用对象，一般引用equals
break:跳出最内层循环，return：跳出方法体return只能在方法中
continue:遇到，它下面的不执行，重新挞代
goto少用
符数组转换成字符串:用string的构造方法
继承父类，先执行父类的，再执行子类的构造方法
is as:类型转换操作符is:判断bool值 as:转换 用于引用类型
ado.net:ExecuteScalar()连接的,读取并返回一个值 只返回一个值,效率最高
ExecuteReader() 只读
ExecutenonoQuery() 只写
DataSets() 断开的 读/写
dataset填充之后,连接就关闭
c#编程习惯:接口i开头,exception类用exception结尾 public class MyExeception(){}
有返回值的方法Get开头:GetObject(){}
类{}放在一新行上class a()
{
}
equals():引用指向同一对象 指向同一地址,比较和查询时用此方法
exception:分2类systemexception
applictionexception
自定义异常继承excetion总类就可
try catch finaly如果catch中中断,finaly不执行,因为中断,
----------------------------------------------
数组为引用类型，但new了后，在内存中开辟空间有实值，
class只继承一个class,
-----------------------
class a:o
{}
class b:a
{}
错误
-----------------
class 可继承多个接口
vs中：
类视图：层次结构
解决方案意资源管理器：树结构
服务管理器：连接数据库管理
---------
f5调试
ctrl+f5执行
Show.Dialog():为模态对话框
------------------------------------------
c#8种整数类型：sbyte,byte,short,ushort,int,uint,long,ulong u:为无符号整数，为正整数
否则为正负整数
int默认为int， 实数默认为double
enum每个元素默认为int类型 为enum赋值类型限制为整形
引用定义：引用类型的变量存储地址，通过地址指向存储的值
c#引用类型4种：类，代表(委托delegate)，数组，接口
定义一个类变量，称它为一个类的实例
所有类基类：object 继承基类:base 本类this,数组类型基类:System.Array
装箱：值类型隐式转换成object类型 值到对象，栈到堆
拆箱；将一个对象类型显式转换成值类型，
变量命名规范：开头字母：字母，下划线，或@,后面为字母，下划线，数字
变量必须先定义后使用,给一个定义但未赋值的变量赋值时，必须是在一段可执行的代码中
静态变量的初始值为其类型的默认值，静态变量直到它所属的类运行结束时一直存在
一个类的新实例被 创建，直支类实例不再应用从而所在空间释放为止，非静态变量 一直存在
结构类型中的非静态变量随结构的存在而存在，即：结构类型中的变量存在或结束时，结构类型中
的变量随之存在或结束
数组变量随数组实例的存在而存在，数组元素的默认值 为数组类型的默认值
局部变量不会被自动初始化，也就没有默认值
const类型为任何一种值类型或引用类型
string,bool不能数据类型转换
.net是一个开发平台，c#是一种语言，vs.net是一种开发工具
struct:默认类型：private int默认值(初始值):0 引用类型变量初始值：null
object.ReferenceEquals:是否引用同一处的实例 引用处是否相同，是否是同一处
object.Equals:引用的实例值是否相同
--------------
is 类型判断
as 类型转换
typeof()获取系统类型
sizeof()获取大小，即字节数
----------------------------------
封装：就是把class内部隐藏起来，继承，多态
抽象接口什么时候用，一般用接口
------------------------------------------------------
一个操作数在两个有相同优先级的操作符之间时，从左至右执行
二进制操作符左结合，赋值操作符，条件操作符右结合，x=y=z,(?:)
is判断是否为指定的类型 类型判断
as将一个值显式的转换成引用 类型 类型转换
逻辑与逻辑或为二元操作数，逻辑非一元操作数
自增自减操作符是一个变量，5++非法 后缀境减为整个表达式执行完后再增减
--------------
int i=5;
i=i++;
console.write(i);i=5;
int i=5;
解析为
int n=i++;
console.write(n);n=5;
int i=5;
i=i+++3+4;
console.write(i);i=5;i=12后缀境减为整个表达式执行完后再增减
typeof:获取系统原型对象的类型
移位运算比乘法运算快
两个不同空间调用，要引用-添加项目之后才能用
异常类基类：System.Exception
try{goto a;}
finally{}
a:
结果try,finally,a finally一定执行
c面向过程
c#面向对象 面向对象=对象+类+继承+通信
abstract类不能实例
protected 受保护的，可访问区：基类级基类的派生类
this使用域：构造函数，类方法，类实例
类构造函数中出现this作为一个值类型，表示对正在构造 的对象本身的引用
类方法中出现this作为一个值 类型， 表示对调用该方法的对象的引用
---------
结构构造函数或方法中出现this作为变量类型，表示对正在构造或调用 该方法的结构的引用
this定义为常量this++,this--非法
static成员属于类所有的，非static成员属于类实例-对象
继承：低级的继承高级的
public()
{}
internal():public
{}
默认构造函数：base()
构造函数默认为public,如为private表明类不能实例化，通常 用于含有静态成员的类
c#类是对数据结构的封装与抽象
类实例超出作用域时，析函数释放分配给该实例的任何存储区
return ; 返回void型
static方法只能访问类中static成员
非static方法可访问类中任何成员
不能重载的操作符：= && || ?: new typeof sizeof is
类功能通过类方法完成
int默认为=0
static域实例只初始化一次 不重新初始化，值也不累积
非static每次实例，都重新初始化，初始化后直到未重新初始化前将值累积
const型表达式的值在编译时形成，
static readonly表达式值在运行时形成
系统为每个未初始化的变量提供一个默认值
静态变量，非静态变量的对象变量，数组元素，这些变量自动初始化为本身的默认值，引用类型的
变量，默认为null
---------
值类型变量 的默认值：
sbyte,byte,short ushort,int,uint,long,ulong 默认值0
char /x0000
float 0.0f
double 0.0d
decimal 0.0m
bool false
enum 0
struct类型的变量，默认初始化将对构成该结构的每个值类型初始化为上表中的默认值，对构成的
每个引用类型初始化为null
类中，没有显式的对域初始化，系统将赋予一个默认值，静态域，类在装载时初始化，非静态域，
实例创建时初始化，在默认初始化之前，域的值不可预测
属性体现了对象的封装性
接口只包括：方法，属性，事件，索引器
描述一个类的特性方式：域，属性 域通过public类型的成员变量访问，属性通过访问器访问
面向对象语言特性：继承，多态
多态：同一操作作用于不同对象，有不同解释，产生不同执行结果，
多态通过派生类重载基类中虚方法实现
队了构造函数，析构函数，派生类隐式继承直接基类的所有成员：基类成员：方法，域，属性，事
件，索引器
类基类object 派生类对基类的扩展
构造函数，析构函数不能继承，其他都能继承
base:派生类调用基类
多态：编译时多态：通过重载实现，非虚的成员来说，编译时，根据传递的参数，返回类型决定实
现操作 特点：运行速度快，
运行时多太：系统运行时，根据实际情况决定实现何种操作，运行时多态通过虚成员实现
特点：高度灵活和抽象
virtual override虚方法，在派生类中重写了基类的虚方法，执行时不执行基类中虚方法，因已被
派生类重写，只执行override方法 编译时值为virtual方法 编译时多态 运行时值为
oerride方法，运行时多态
定义有参构造函数时，好习惯为把默认无参构造函数显式写出
-----------------------------------------------
2个类成员；属性：描述状态
方法：定义行为
类在物理上打包在程序集中assembly
try catch finaly正确答案：catch中return中断， finaly照样执行，前面.txt中有说不执行，错
误的
调试时，即时窗口内输入，，回车，如：ds.tables[0].rows.count;=10行
编程：结构+算法
int x;
x=42;
console.Write(x++);//输出42+
调试：跳入方法体 f11
跳出方法体shift+f11
-----------------------------------
不同方式的赋值：int k = new int();
k = 100;
----------
int默认赋值为0 string:null输出时为' '空,空一空格，
------------------------------
virtual 选执行虚方法
override 再执行重载的方法
子类继承基类，可对基类的字段，方法进行操作
----------------------------
=========================return=========================================
麻雀虽小，五脏俱全，大程序分析时，要分成多个小程序分析，才能理解其思想，一个命令很明白后，要书面总结写出核心用法，这样思想会很清楚。
return:执行方法中的第一个return,return后面的不执行
谁调用的return方法，就把结果返回谁
continue:循环中遇到continue时，他之后语句的不执行，直接返回循环递增处进行下一次循环，
if elseif:要么执行if 要么执行else if 只执行其中一个
if if 有可能全部执行;一个接一个执行
递归：先回推：执行到函数处重新到函数开始，一直到终止条件为止，
执行递归上面的部分
再递推：从函数递归处开始，到方法尾，循环直到递归开始时的条件止，
执行递归下面的部分
=============================抽象/虚方法==================================
public abstract class Person
{
public abstract void Hello();//抽象方法，不执行此句
}
class man : Person
{
public override void Hello()
{
//throw new Exception("The method or operation is not implemented.");
}
}
class Program
{
static void Main(string[] args)
{
man manfirst = new man();
manfirst.Hello();
}
}
----------------------------------------------------------------------
public abstract class Person
{
public abstract void Hello();//虚方法，执行此句
}
class man : Person
{
public override void Hello()
{
//throw new Exception("The method or operation is not implemented.");
}
}
class Program
{
static void Main(string[] args)
{
man manfirst = new man();
manfirst.Hello();
}
}
-----------------------------------------Base
class AA
{
public void A(){}
}
class BB:AA
{
base.A();//调用基类方法
}
-------------------------------------------new virtual
class Car
{
public virtual void DescribeCar()
{ }
}
class ConvertibleCar : Car
{
public new virtual void DescribeCar()//new 只执行继承的Car中的DescribeCar(),此处可理解为这是另一个方法，只是名相同而已，此方法不执行
{ base.DescribeCar(); }
}
class Minivan : Car
{
public override void DescribeCar()
{
base.DescribeCar();
}
}
class Program
{
static void Main(string[] args)
{
Car[] cars=new Car[3];
cars[0] = new Car();
cars[1] = new ConvertibleCar();
cars[2] = new Minivan();
foreach (Car var in cars)
{
Console.WriteLine(var.GetType());
var.DescribeCar();
}
}
}
========================string.format======================================
return string.Format("Bank 结余:Transfercount = {0,6:C}",transfercount);//返回一字符串
===============================tab键执行顺序==================================
================================object
object:
struct Point
{
public int x, y;
public Point(int x,int y)
{
this.x = x;
this.y = y;
}
}
static void Main(string[] args)
{
Point p = new Point(10, 10);
object box = p;//p.x=10 p.y=10 p类型 box.x=10 box.y=10 box引用类型
p.x = 20;//p.x=20
Console.Write(((Point)box).x);//?10
}
扫一扫
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
