===============================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
}