由C++轉向C#：我們需要注意哪些方面的變化？

2024-07-21 02:17:08

字體：大中小

來源：轉載

供稿：網友

每隔10年左右，編程人員就需要花費大量的時間和精力去學習新的編程技術。在80年代是unix和c，90年代是windows和c++，現在又輪到了微軟的.netframework和c#。盡管需要學習新的技術，但由此帶來的好處卻遠高于付出的勞動。幸運的是，使用c#和.net進行的大多數工程的分析和設計與在c++和windows中沒有本質的變化。在本篇文章中，我將介紹如何實現由c++到c#的飛躍。

已經有許多文章介紹過c#對c++的改進，在這里我就不再重復這些問題了。在這里，我將重點討論由c++轉向c#時最大的變化：由不可管理的環境向可管理的環境的變化。此外，我還會提出一些c#編程人員容易犯的錯誤供大家參考，此外，還將說明一些c#語言的能夠影響編程的新功能。

轉向可管理的環境

c++的設計目標是低級的、與平臺無關的面向對象編程語言，c#則是一種高級的面向組件的編程語言。向可管理環境的轉變意味著你編程方式思考的重大轉變，c#不再處理細微的控制，而是讓架構幫助你處理這些重要的問題。例如，在c++中，我們就可以使用new在棧中、堆中、甚至是內存中的某一特定位置創建一個對象。

在.net的可管理環境中，我們再不用進行那樣細微的控制了。在選擇了要創建的類型后，它的位置就是固定的了。簡單類型（ints、double和long）的對象總是被創建在棧中（除非它們是被包含在其他的對象中），類總是被創建在堆中。我們無法控制對象是創建在堆中哪個位置的，也沒有辦法得到這個地址，不能將對象放置在內存中的某一特定位置。（當然也有突破這些限制的方法，但那是很另類的方法。）我們再也不能控制對象的生存周期，c#沒有destructor。碎片收集程序會將對象所占用的內存進行回收，但這是非顯性地進行的。

正是c#的這種結構反映了其基礎架構，其中沒有多重繼承和模板，因為在一個可管理的碎片收集環境中，多重繼承是很難高效地實現的。

c#中的簡單類型僅僅是對通用語言運行庫（clr）中類型的簡單映射，例如，c#中的int是對system.int32的映射。c#中的數據類型不是由語言本身決定的，而是由clr決定的。事實上，如果仍然想在c#中使用在visualbasic中創建的對象，就必須使自己的編程習慣更符合clr的規定。

另一方面，可管理的環境和clr也給我們帶來了好處。除了碎片收集和所有.net語言中統一的數據類型外，它還提供給我們一個功能強大的面向組件的編程語言，無須對后期綁定提供特別的支持，類型發現和后期綁定都是被內置在語言中的。屬性是c#語言中的第一類的成員，事件和代理也是。

可管理環境最主要的優點是.netframework。盡管在所有的.net語文中都可以使用這種框架，但c#可以更好地使用.net框架中豐富的類、接口和對象。

traps

c#看起來與c++非常相似，這使得我們在由c++轉向c#時比較輕松，但其中也有一些容易出錯的地方。在c++中編寫得非常漂亮的代碼，在c#中會不能通過編譯，甚至會出現意想不到的結果。c#與c++之間在語法上的變化并不大，編譯器能夠發現這二者之間大部分的差異，我在這里就不再多費筆墨了，在這里我介紹幾個容易出問題的比較重要的變化：

引用類型和值類型

在c#中，值類型和引用類型數據是有區別的。簡單類型（int、long、double等）和結構屬于值類型數據，類和對象屬于引用類型數據。除非是包含在引用類型的變量中，與在c++中一樣，值類型變量的值存儲在棧中。引用類型的變量也存儲在棧中，但它的值是一個存儲在堆中的對象的地址，這一點也與c++類似。值類型變量是將自己的值傳遞給方法，而引用類型變量則將自己的指針傳遞給方法。

結構

c#中的結構與c++中有非常明顯的區別。在c++中，結構更象是類，除了缺省的繼承外，其缺省的訪問權限是public而不是private。在c#中，結構與類截然不同，它是用來封裝輕型對象的，是值類型的數據類型，在傳遞時傳送的是變量的值，而不是其地址。此外，它們也有一些不適用于類的限制，例如，它是不能繼承的，也沒有除system.valuetype之外的基本類。結構還不能定義一個缺省的constructor。

另一方面，由于結構比類的效率要高，因此它非常適合于創建輕型對象。因此，如果它的缺點對你的軟件沒有影響，使用結構比使用類效率要高得多，尤其是對于小對象而言。

所有的一切都是對象

在c#中，所有的東西都是由繼承object得到的，包括創建的類和int、structs等值類型的變量。object類提供了一些有用的方法，例如tostring，使用tostring的一個例子是與system.console.writeline一起使用，它可以接受一個字符串和許多對象。與使用printf語句不同，要使用writeline，需要提供代換變量。假設myemployee是用戶定義的employee類的一個實例，mycounter是用戶定義的counter類的一個實例：

console.writeline("theemployee:{0},thecountervalue:{1}",
myemployee,mycounter);

其中的writeline會調用每個對象的object.tostring方法，替換作為參數返回的變量。如果employee類不覆蓋tostring，就會調用缺省的實現（由system.object繼承得到的），它將把類的名字作為一個字符串返回。counter會覆蓋tostring，返回一個整型的變量，因此，上面代碼的輸出為：

theemployee:employee,thecountervalue:12

如果向writeline傳遞一個整型變量會發生什么情況呢？由于不能對整型變量調用tostring，編譯器將自動將整型變量封裝在一個對象的實例中。當writeline調用tostring時，對象就會返回表示整型變量值的字符串。下面的代碼就說明了這個問題：

類的使用

usingsystem;
//不覆蓋tostring的類
publicclassemployee
{
}
//覆蓋了tostring的類
publicclasscounter
{
privateinttheval;
publiccounter(inttheval)
{
this.theval=theval;
}
publicoverridestringtostring()
{
console.writeline("callingcounter.tostring()");
returntheval.tostring();
}
}
publicclasstester
{
publicstaticvoidmain()
{
//創建類的實例
testert=newtester();
//調用非靜態成員
//(mustbethroughaninstance)
t.run();
}
//演示調用tostring的非靜態方法
publicvoidrun()
{
employeemyemployee=newemployee();
countermycounter=newcounter(12);
console.writeline("theemployee:{0},thecountervalue:{1}",
myemployee,mycounter);
intmyint=5;
console.writeline("herearetwointegers:{0}and{1}",17,myint);
}
}

引用型參數和輸出型參數

與c++中相同，c#中的方法也只能有一個返回值。在c++中，我們通過將指針或索引作為參數而克服了這個限制，被調用的方法改變其中的參數，調用方法就可以得到新的值了。

向方法中傳遞一個索引作為參數時，只能嚴格地按傳遞索引或指針所能夠提供的方式訪問原來的對象。對于值類型變量而言，就不能采用這種方法了。如果要通過引用型參數傳遞值型變量，就需要在其前面加上ref關健字。如下所示：

publicvoidgetstats(refintage,refintid,refintyearsserved)

需要注意的是，既需要在方法的定義中使用ref關健字，也需要在對方法的實際調用中使用ref關健字。

fred.getstats(refage,refid,refyearsserved);

現在，我們可以在調用方法中定義age、id和yearsserved變量，并將它們傳遞給getstats，得到改變后的值。

c#要求明確的賦值，也就是說，在調用getstats方法之前，必須對age、id和yearsserved這三個局部變量進行初始化，這一工作似乎有點多余，因為我們僅僅使用它們從getstats中得到新的變量的值。為了解決這一問題，c#提供了out關健字，表示我們可以向方法中傳遞沒有被初始化的變量，這些變量將通過引用變量的方式進行傳遞：

publicvoidgetstats(outintage,outintid,outintyearsserved)

當然了，調用方法也必須作出相應的變化：

fred.getstats(outage,outid,outyearsserved);

new的調用

在c++中，new關健字可以在堆上生成一個對象。在c#中卻不是這樣。對于引用類型變量而言，new關健字在堆上生成一個對象；對于結構等值類型變量而言，new關健字在棧中生成一個對象，并需要調用constructor。

事實上，我們可以不使用new關健字而在棧上生成一個結構類型的變量，但這時需要注意的是，new關健字能夠初始化對象。如果不使用new，則在使用前必須手工地對結構中的所有成員進行初始化，否則在編譯時會出錯。

對象的初始化

usingsystem;//有二個成員變量和一個構造器的簡單結構
publicstructpoint
{
publicpoint(intx,inty)
{
this.x=x;
this.y=y;
}

publicintx;
publicinty;
}

publicclasstester
{
publicstaticvoidmain()
{
testert=newtester();
t.run();
}

publicvoidrun()
{
pointp1=newpoint(5,12);
somemethod(p1);//fine

pointp2;//不調用new而直接創建

//編譯器編譯到這里時會出錯，因為p2的成員變量沒有被初始化
//somemethod(p2);

//手工對它們進行初始化
p2.x=1;
p2.y=2;

somemethod(p2);

}

//一個可以接受point作為參數的方法
privatevoidsomemethod(pointp)
{
console.writeline("pointat{0}x{1}",
p.x,p.y);
}
}

屬性

大多數的c++編程人員都希望使成員變量的屬性為private，這種隱藏數據的想法促進了數據封裝概念的出現，使我們能夠在不改變用戶依賴的接口的情況下而改變類的實現。通常情況下，我們只希望客戶獲取或設置這些成員變量的值。因此，c++編程人員開發出了用來存取private成員變量的存取器。

在c#中，屬性是類的第一級成員。對于客戶而言，屬性看起來象一個成員變量。對于類的實現者而言，它看起來更象是方法。這種設計很巧妙，既可以實現數據的隱藏和封裝，又可以使客戶很方便地訪問成員變量。

我們可以在employee類中添加一個age屬性，使客戶可以很方便地獲取和設置員工年齡這個類的成員：

publicintage
{
get
{
returnage;
}
set
{
age=value;
}
}

關健字value可以被屬性隱性地使用。如果編寫如下的代碼：

fred.age=17;

編譯器將會把值17傳遞給value。

通過只采用get而不采用set，我們可以為yearsserved創建一個只讀的屬性：

publicintyearsserved
{
get
{
returnyearsserved;
}
}accessors的使用
privatevoidrun()
{
employeefred=newemployee(25,101,7);
console.writeline("fred'sage:{0}",
fred.age);
fred.age=55;
console.writeline("fred'sage:{0}",
fred.age);

console.writeline("fred'sservice:{0}",
fred.yearsserved);
//fred.yearsserved=12;//是不被允許的

}

我們可以通過屬性獲取fred的年齡，也可以使用這一屬性設置年齡。我們雖然可以訪問yearsserved屬性獲得它的值，但不能設置值。如果沒有注釋掉最后一行的代碼，在編譯時就會出錯。

如果以后決定從數據庫中獲取employee的年齡，我們就只需要改變存取器的實現，而客戶不會受到任何影響。

數組

c#提供了一個數組類，它比c/c++中傳統的數組更智能化。例如，在c#中寫數組時不會超出邊界。此外，數組還有一個更智能的伙伴—arraylist，可以動態地增長，管理對數組大小不斷變化的需求。

c#中的數組有三種形式：一維數組、多維均勻數組（象c++中傳統的數組那樣）、非均勻數組（數組的數組）。我們可以通過下面的代碼創建一維數組：

int[]myintarray=newint[5];

另外，還可以以如下的方式對它進行初始化：

int[]myintarray={2,4,6,8,10};

我們可以通過如下方式創建一個4×3的均勻數組：

int[,]myrectangulararray=newint[rows,columns];

我們可以按如下方式對該數組進行初始化：

int[,]myrectangulararray=
{
{0,1,2},{3,4,5},{6,7,8},{9,10,11}
};

由于非均勻數組是數組的數組，因此，我們只能創建一維非均勻數組：

int[][]myjaggedarray=newint[4][];

然后再創建內部的每個數組：

myjaggedarray[0]=newint[5];
myjaggedarray[1]=newint[2];
myjaggedarray[2]=newint[3];
myjaggedarray[3]=newint[5];

由于數組是由繼承system.array對象而得到的，因此，它們帶有許多包括sort、reverse在內的許多有用的方法。

索引器

我們可以創建象數組一樣的對象。例如，我們可以創建一個顯示一系列字符串的列表框，可以把列表框當作一個數組，使用一個索引就可以很方便地訪問列表框中的內容。

stringthefirststring=mylistbox[0];
stringthelaststring=mylistbox[length-1];

這是通過索引器完成的。索引器在很大程度上象一個屬性，但支持索引操作的語法。圖4顯示了一個后面跟著索引操作符的屬性，圖5顯示如何完成一個很簡單的listbox類并對它進行索引：

界面

軟件界面是二種對象之間如何進行交互的契約。如果一個對象發布了一個界面，就等于向所有可能的客戶聲明：我支持下面的方法、屬性、事件和索引器。

c#是一種面向對象的語言，因此這些契約被封裝在一個被稱作界面的實體中，界面定義了封裝著契約的引用型類型的對象。從概念上來講，界面與抽象類非常相似，二者的區別是抽象類可以作為一系列衍生類的基礎類，界面則是與其他繼承樹結合在一起的。

ienumerable界面

再回到上面的例子中。象在普通的數組中那樣，使用foreach-loop循環結構就能夠很好地打印listboxtest類中的字符串，通過在類中實現ienumerable界面就能實現，這是由foreach-loop循環結構隱性地完成的。在任何支持枚舉和foreach-loop循環的類中都可以實現ienumerable界面。

ienumerable界面只有一個方法getenumerator，其任務是返回一個特別的ienumerator的實現。從語法的角度來看，enumerable類能夠提供一個ienumerator。

figure5listboxclass
usingsystem;
//簡化的listbox控制
publicclasslistboxtest
{
//用字符串初始化該listbox
publiclistboxtest(paramsstring[]initialstrings)
{
//為字符串分配空間
mystrings=newstring[256];
//把字符串拷貝到構造器中
foreach(stringsininitialstrings)
{
mystrings[myctr++]=s;
}
}
//在listbox的末尾添加一個字符串
publicvoidadd(stringthestring)
{
mystrings[myctr++]=thestring;
}
publicstringthis[intindex]
{
get
{
if(index<0||index>=mystrings.length)
{
//處理有問題的索引
}
returnmystrings[index];
}
set
{
mystrings[index]=value;
}
}
//返回有多少個字符串
publicintgetnumentries()
{
returnmyctr;
}
privatestring[]mystrings;
privateintmyctr=0;
}
publicclasstester
{
staticvoidmain()
{
//創建一個新的列表并初始化
listboxtestlbt=newlistboxtest("hello","world");
//添加一些新字符串
lbt.add("who");
lbt.add("is");
lbt.add("john");
lbt.add("galt");
stringsubst="universe";
lbt[1]=subst;
//訪問所有的字符串
for(inti=0;i{
console.writeline("lbt[{0}]:{1}",i,lbt[i]);
}
}
}

enumerator必須實現ienumerator方法，這可以直接通過一個容器類或一個獨立的類實現，后一種方法經常被選用，因為它可以將這一任務封裝在enumerator類中，而不會使容器類顯得很混亂。我們將在上面代碼中的listboxtest中添加enumerator類，由于enumerator類是針對我們的容器類的（因為listboxenumerator必須清楚listboxtest的許多情況），我們將使它在listboxtest中成為不公開的。在本例中，listboxtest被定義來完成ienumerable界面，ienumerable界面必須返回一個enumerator。

publicienumeratorgetenumerator()
{
return(ienumerator)newlistboxenumerator(this);
}

注意，方法將當前的listboxtest對象（this）傳遞給enumerator，這將使enumerator枚舉這一指定的listboxtest對象中的元素。

實現這一類的enumerator在這里被實現為listboxenumerator，它在listboxtest中被定義成一個私有類，這一工作是相當簡單的。

被枚舉的listboxtest作為一個參數被傳遞給constructor，listboxtest被賦給變量mylbt，構造器還會將成員變量index設置為-1，表明對象的枚舉還沒有開始。

publiclistboxenumerator(listboxtestthelb)
{
mylbt=thelb;
index=-1;
}

movenext方法對index進行加1的操作，然后確保沒有超過枚舉的對象的邊界。如果超過邊界了，就會返回false值，否則返回true值。

publicboolmovenext()
{
index++;
if(index>=mylbt.mystrings.length)
returnfalse;
else
returntrue;
}

reset的作用僅僅是將index的值設置為-1。

current返回最近添加的字符串，這是一個任意的設定，在其他類中，current可以有設計人員確定的意義。無論是如何設計的，每個進行枚舉的方法必須能夠返回當前的成員。

publicobjectcurrent
{
get
{
return(mylbt[index]);
}
}

對foreach循環結構的調用能夠獲取枚舉的方法，并用它處理數組中的每個成員。由于foreach循環結構將顯示每一個字符串，而無論我們是否添加了一個有意義的值，我們將mystrings的初始化改為8個條目，以保證顯示的易于處理。

mystrings=newstring[8];

使用基本類庫

為了更好地理解c#與c++的區別和解決問題方式的變化，我們先來看一個比較簡單的例子。我們將創建一個讀取文本文件的類，并在屏幕上顯示其內容。我將把它做成多線程程序，以便在從磁盤上讀取數據時還可以做其他的工作。

在c++中，我們可能會創建一個讀文件的線程和另一個做其他工作的線程，這二個線程將各自獨立地運行，但可能會需要對它們進行同步。在c#中，我們也可以完成同樣的工作，由于.net框架提供了功能強大的異步i/o機制，在編寫線程時，我們會節省不少的時間。

異步i/o支持是內置在clr中的，而且幾乎與使用正常的i/o流類一樣簡單。在程序的開始，我們首先通知編譯器，我們將在程序中使用許多名字空間中的對象：

usingsystem;
usingsystem.io;
usingsystem.text;

在程序中包含system，并不會自動地包含其所有的子名字空間，必須使用using關健字明確地包含每個子名字空間。我們在例子中會用到i/o流類，因此需要包含system.io名字空間，我們還需要system.text名字空間支持字節流的ascii編碼。

由于.net架構為完成了大部分的工作，編寫這一程序所需的步驟相當簡單。我們將用到stream類的beginread方法，它提供異步i/o功能，將數據讀入到一個緩沖區中，當緩沖區可以處理時調用相應的處理程序。

我們需要使用一個字節數組作為緩沖區和回叫方法的代理，并將這二者定義為驅動程序類的private成員變量。

publicclassasynchiotester
{
privatestreaminputstream;
privatebyte[]buffer;
privateasynccallbackmycallback;

inputstream是一個stream類型的變量，我們將對它調用beginread方法。代理與成員函數的指針非常相似。代理是c#的第一類元素。

當緩沖區被磁盤上的文件填滿時，.net將調用被代理的方法對數據進行處理。在等待讀取數據期間，我們可以讓計算機完成其他的工作。（在本例中是將1個整型變量由1增加到50000，但在實際的應用程序中，我們可以讓計算機與用戶進行交互或作其他有意義的工作。）

本例中的代理被定義為asynccallback類型的過程，這是stream的beginread方法所需要的。system空間中asynccallback類型代理的定義如下所示：

publicdelegatevoidasynccallback(iasyncresultar);

這一代理可以是與任何返回void類型值、將iasyncresult界面作為參數的方法相關聯的。在該方法被調用時，clr可以在運行時傳遞iasyncresult界面對象作為參數。我們需要如下所示的形式定義該方法：

voidoncompletedread(iasyncresultasyncresult)

然后在構造器中與代理連接起來：

asynchiotester()
{
???
mycallback=newasynccallback(this.oncompletedread);
}

上面的代碼將代理的實例賦給成員變量mycallback。下面是全部程序的詳細工作原理。在main函數中，創建了一個類的實例，并讓它開始運行：

publicstaticvoidmain()
{
asynchiotestertheapp=newasynchiotester();
theapp.run();
}

new關健字能夠啟動構造器。在構造器中我們打開一個文件，并得到一個stream對象。然后在緩沖中分配空間并與回調機制聯結起來。

asynchiotester()
{
inputstream=file.openread(@"c:/msdn/fromcpptocs.txt");
buffer=newbyte[buffer_size];
mycallback=newasynccallback(this.oncompletedread);
}

在run方法中，我們調用了beginread，它將以異步的方式讀取文件。

inputstream.beginread(
buffer,//存放結果
0,//偏移量
buffer.length,//緩沖區中有多少字節
mycallback,//回調代理
null);//本地對象

這時，我們可以完成其他的工作。

for(longi=0;i<50000;i++)
{
if(i%1000==0)
{
console.writeline("i:{0}",i);
}
}

文件讀取操作結束后，clr將調用回調方法。

voidoncompletedread(iasyncresultasyncresult)
{

在oncompletedread中要做的第一件事就是通過調用stream對象的endread方法找出讀取了多少字節：

intbytesread=inputstream.endread(asyncresult);

對endread的調用將返回讀取的字節數。如果返回的數字比0大，則將緩沖區轉換為一個字符串，然后將它寫到控制臺上，然后再次調用beginread，開始另一次異步讀的過程。

if(bytesread>0)
{
strings=encoding.ascii.getstring(buffer,0,bytesread);
console.writeline(s);
inputstream.beginread(buffer,0,buffer.length,
mycallback,null);
}

現在，在讀取文件的過程中就可以作別的工作了（在本例中是從1數到50000），但我們可以在每次緩沖區滿了時對讀取的數據進行處理（在本例中是向控制臺輸出緩沖區中的數據）。有興趣的讀者可以點擊此處下載完整的源代碼。

異步i/o的管理完全是由clr提供的，這樣，在網絡上讀取文件時，會更好些。

在網絡上讀取文件

在c++中，在網絡上讀取文件需要有相當的編程技巧，.net對此提供了廣泛的支持。事實上，在網絡上讀取文件僅僅是基礎類庫中stream類的另一種應用。

首先，為了對tcp/ip端口（在本例中是65000）進行監聽，我們需要創建一個tcplistener類的實例。

tcplistenertcplistener=newtcplistener(65000);

一旦創建后，就讓它開始進行監聽。

tcplistener.start();

現在就要等待客戶連接的要求了。

socketsocketforclient=tcplistener.accept();

tcplistener對象的accept方法返回一個socket對象，accept是一個同步的方法，除非接收到一個連接請求它才會返回。如果連接成功，就可以開始向客戶發送文件了。

if(socketforclient.connected)
{
???

接下來，我們需要創建一個networkstream類，將報路傳遞給constructor：

networkstreamnetworkstream=newnetworkstream(socketforclient);

然后創建一個streamwriter對象，只是這次不是在文件上而是在剛才創建的networkstream類上創建該對象：

system.io.streamwriterstreamwriter=
newsystem.io.streamwriter(networkstream);

當向該流寫內容時，流就通過網絡被傳輸給客戶端。

客戶端的創建

客戶端軟件就是一個tcpclient類的具體例子，tcpclient類代表連向主機的一個tcp/ip連接。

tcpclientsocketforserver;
socketforserver=newtcpclient("localhost",65000);

有了tcpclient對象后，我們就可以創建networkstream對象了，然后在其上創建streamreader類：

networkstreamnetworkstream=socketforserver.getstream();
system.io.streamreaderstreamreader=
newsystem.io.streamreader(networkstream);

現在，只要其中有數據就讀取該流，并將結果輸出到控制臺上。

do
{
outputstring=streamreader.readline();

if(outputstring!=null)
{
console.writeline(outputstring);
}
}
while(outputstring!=null);

為了對這一段代碼進行測試，可以創建如下一個測試用的文件：

thisislineone
thisislinetwo
thisislinethree
thisislinefour

這是來自服務器的輸出：

output(server)
clientconnected
sendingthisislineone
sendingthisislinetwo
sendingthisislinethree
sendingthisislinefour
disconnectingfromclient...
exiting...

下面是來自客戶端的輸出：

thisislineone
thisislinetwo
thisislinethree
thisislinefour

屬性和元數據

c#和c++之間一個顯著的區別是它提供了對元數據的支持：有關類、對象、方法等其他實體的數據。屬性可以分為二類：一類以clr的一部分的形式出現，另一種是我們自己創建的屬性，clr屬性用來支持串行化、排列和com協同性等。一些屬性是針對一個組合體的，有些屬性則是針對類或界面，它們也被稱作是屬性目標。

將屬性放在屬性目標前的方括號內，屬性就可以作用于它們的屬性目標。

[assembly:assemblydelaysign(false)]
[assembly:assemblykeyfile(".//keyfile.snk")]

或用逗號將各個屬性分開：

[assembly:assemblydelaysign(false),
assembly:assemblykeyfile(".//keyfile.snk")]

自定義的屬性

我們可以任意創建自定義屬性，并在認為合適的時候使用它們。假設我們需要跟蹤bug的修復情況，就需要建立一個包含bug的數據庫，但需要將bug報告與專門的修正情況綁定在一塊兒，則可能在代碼中添加如下所示的注釋：

//bug323fixedbyjesseliberty1/1/2005.

這樣，在源代碼中就可以一目了然地了解bug的修正情況，但如果如果把相關的資料保存在數據庫中可能會更好，這樣就更方便我們的查詢工作了。如果所有的bug報告都使用相同的語法那就更好了，但這時我們就需要一個定制的屬性了。我們可能使用下面的內容代替代碼中的注釋：

[bugfix(323,"jesseliberty","1/1/2005")comment="offbyoneerror"]

與c#中的其他元素一樣，屬性也是類。定制化的屬性類需要繼承system.attribute：

publicclassbugfixattribute:system.attribute

我們需要讓編譯器知道這個屬性可以跟什么類型的元素，我們可以通過如下的方式來指定該類型的元素：

[attributeusage(attributetargets.classmembers,allowmultiple=true)]

attributeusage是一個作用于屬性的屬性━━元屬性，它提供的是元數據的元數據，也即有關元數據的數據。在這種情況下，我們需要傳遞二個參數，第一個是目標（在本例中是類成員。），第二個是表示一個給定的元素是否可以接受多于一個屬性的標記。allowmultiple的值被設置為true，意味著類成員可以有多于一個bugfixattribute屬性。如果要聯合二個屬性目標，可以使用or操作符連接它們。

[attributeusage(attributetargets.class|attributetargets.interface,allowmultiple=true)]

上面的代碼將使一個屬性隸屬于一個類或一個界面。

新的自定義屬性被命名為bugfixattribute。命名的規則是在屬性名之后添加attribute。在將屬性指派給一個元素后，編譯器允許我們使用精簡的屬性名調用這一屬性。因此，下面的代碼是合法的：

[bugfix(123,"jesseliberty","01/01/05",comment="offbyone")]

編譯器將首先查找名字為bugfix的屬性，如果沒有發現，則查找bugfixattribute。

每個屬性必須至少有一個構造器。屬性可以接受二種類型的參數：環境參數和命名參數。在前面的例子中，bugid、編程人員的名字和日期是環境參數，注釋是命名參數。環境參數被傳遞到構造器中的，而且必須按在構造器中定義的順序傳遞。

publicbugfixattribute(intbugid,stringprogrammer,stringdate)
{
this.bugid=bugid;
this.programmer=programmer;
this.date=date;
}

namedparametersareimplementedasproperties.

屬性的使用

為了對屬性進行測試，我們創建一個名字為mymath的簡單類，并給它添加二個函數，然后給它指定bugfix屬性。

[bugfixattribute(121,"jesseliberty","01/03/05")]

[bugfixattribute(107,"jesseliberty","01/04/05",
comment="fixedoffbyoneerrors")]
publicclassmymath

這些數據將與元數據存儲在一起。下面是完整的源代碼及其輸出：

自定義屬性

usingsystem;
//創建被指派給類成員的自定義屬性
[attributeusage(attributetargets.class,
allowmultiple=true)]
publicclassbugfixattribute:system.attribute
{
//位置參數的自定義屬性構造器
publicbugfixattribute
(intbugid,
stringprogrammer,
stringdate)
{
this.bugid=bugid;
this.programmer=programmer;
this.date=date;
}
publicintbugid
{
get
{
returnbugid;
}
}

//命名參數的屬性
publicstringcomment
{
get
{
returncomment;
}
set
{
comment=value;
}
}

publicstringdate
{
get
{
returndate;
}
}

publicstringprogrammer
{
get
{
returnprogrammer;
}
}

//專有成員數據
privateintbugid;
privatestringcomment;
privatestringdate;
privatestringprogrammer;
}

//把屬性指派給類

[bugfixattribute(121,"jesseliberty","01/03/05")]
[bugfixattribute(107,"jesseliberty","01/04/05",
comment="fixedoffbyoneerrors")]
publicclassmymath
{

publicdoubledofunc1(doubleparam1)
{
returnparam1+dofunc2(param1);
}

publicdoubledofunc2(doubleparam1)
{
returnparam1/3;
}

}

publicclasstester
{
publicstaticvoidmain()
{
mymathmm=newmymath();
console.writeline("callingdofunc(7).result:{0}",
mm.dofunc1(7));
}
}

輸出：

callingdofunc(7).result:9.3333333333333339

象我們看到的那樣，屬性對輸出絕對沒有影響，創建屬性也不會影響代碼的性能。到目前為止，讀者也只是在聽我論述有關屬性的問題，使用ildasm瀏覽元數據，就會發現屬性確實是存在的。

映射

在許多情況下，我們需要一種方法，能夠從元數據中訪問屬性，c#提供了對映射的支持以訪問元數據。通過初始化memberinfo類型對象，system.reflection名字空間中的這個對象可以用來發現成員的屬性，對元數據進行訪問。

system.reflection.memberinfoinf=typeof(mymath);

對mymath類型調用typeof操作符，它返回一個由繼承memberinfo而生成的type類型的變量。

下一步是對memberinfo對象調用getcustomattributes，并將希望得到的屬性的類型作為一個參數傳遞給getcustomattributes。我們將得到一個對象數組，數組的每個成員的類型都是bugfixattribute。

object[]attributes;
attributes=attribute.getcustomattributes(inf,typeof(bugfixattribute));

我們就可以遍歷這個數組了，打印bugfixattribute對象的數組，代碼下所示：

屬性的打印

publicstaticvoidmain()
{
mymathmm=newmymath();
console.writeline("callingdofunc(7).result:{0}",
mm.dofunc1(7));

//獲取成員信息并使用它訪問自定義的屬性
system.reflection.memberinfoinf=typeof(mymath);
object[]attributes;
attributes=
attribute.getcustomattributes(inf,typeof(bugfixattribute));

//遍歷所有的屬性
foreach(objectattributeinattributes)
{
bugfixattributebfa=(bugfixattribute)attribute;
console.writeline("/nbugid:{0}",bfa.bugid);
console.writeline("programmer:{0}",bfa.programmer);
console.writeline("date:{0}",bfa.date);
console.writeline("comment:{0}",bfa.comment);
}
}

類型發現

我們可以通過映象的方法來研究一個組合實體的內容，如果要建立需要顯示組合體內部信息的工具或動態地調用組合體中的途徑，這一方法是非常有用的。

通過映象的方法，我們可以知道一個模塊、方法、域、屬性的類型，以及該類型的每個方法的信號、該類支持的界面和該類的超級類。我們可以通過如下的形式，用assembly.load靜態方法動態地加載一個組合體：

publicstaticassembly.load(assemblyname)

然后，可以將它傳遞到核心庫中。

assemblya=assembly.load("mscorlib.dll");

一旦加載了組合體，我們可以通過調用gettypes返回一個type對象數組。type對象是映射的核心，它表示類、界面、數組、值和枚舉等的類型定義。

type[]types=a.gettypes();

組合休會返回一個類型的數組，我們可以使用foreach-loop結構顯示該數組，其輸出將有好幾頁文檔之多，下面我們從中找一小段：

typeissystem.typecode
typeissystem.security.util.stringexpressionset
typeissystem.text.utf7encoding$encoder
typeissystem.argiterator
typeissystem.runtime.remoting.jitlookuptable
1205typesfound

我們得到了一個內容為核心庫中類型的數組，可以將它們都打印出來，該數組將有1205個項。

對一種類型映射我們也可以對組合體中一種類型進行映射。為此，我們可以使用gettype方法從組合體中解析出一個類型：

publicclasstester
{
publicstaticvoidmain()
{
//檢查一個對象
typethetype=type.gettype("system.reflection.assembly");
console.writeline("/nsingletypeis{0}/n",thetype);
}
}

輸出如下所示：

singletypeissystem.reflection.assembly

發現成員

我們還可以得到所有成員的類型，顯示所有的方法、屬性、域，下面的代碼演示了實現上述目標的代碼。

figure9gettingallmembers
publicclasstester
{
publicstaticvoidmain()
{
//檢查一個單一的對象
typethetype=type.gettype("system.reflection.assembly");
console.writeline("/nsingletypeis{0}/n",thetype);

//獲取所有的成員
memberinfo[]mbrinfoarray=
thetype.getmembers(bindingflags.lookupall);
foreach(memberinfombrinfoinmbrinfoarray)
{
console.writeline("{0}isa{1}",
mbrinfo,mbrinfo.membertype.format());
}
}
}

盡管得到的輸出還非常長，但在輸出中我們可以得到如下面的不甘落后民示的域、方法、構造器和屬性：

system.strings_localfileprefixisafield
booleanisdefined(system.type)isamethod
void.ctor()isaconstructor
system.stringcodebaseisaproperty
system.stringcopiedcodebaseisaproperty

只發現方法

我們可能會只關心方法，而不關心域、屬性等，為此，我們需要刪除如下的對getmembers的調用：

memberinfo[]mbrinfoarray=
thetype.getmembers(bindingflags.lookupall);

然后添加調用getmethods的語句：

mbrinfoarray=thetype.getmethods();

現在，輸出中就只剩下方法了。

output(excerpt)
booleanequals(system.object)isamethod
system.stringtostring()isamethod
system.stringcreatequalifiedname(system.string,system.string)
isamethod
system.reflection.methodinfoget_entrypoint()isamethod

發現特定的成員

最后，為了進一步地縮小范圍，我們可以使用findmembers方法來發現某一類型的特定的方法。例如，在下面的代碼中，我們可以只搜索以“get”開頭的方法。

publicclasstester
{
publicstaticvoidmain()
{
//檢查一個單一的對象
typethetype=type.gettype("system.reflection.assembly");
//只獲取以get開頭的成員
memberinfo[]mbrinfoarray
thetype.findmembers(membertypes.method,
bindingflags.default,
type.filtername,"get*");
foreach(memberinfombrinfoinmbrinfoarray)
{
console.writeline("{0}isa{1}",
mbrinfo,mbrinfo.membertype.format());
}
}
}

其輸出的一部分如下所示：

system.type[]gettypes()isamethod
system.type[]getexportedtypes()isamethod
system.typegettype(system.string,boolean)isamethod
system.typegettype(system.string)isamethod
system.reflection.assemblynamegetname(boolean)isamethod
system.reflection.assemblynamegetname()isamethod
int32gethashcode()isamethod
system.reflection.assemblygetassembly(system.type)isamethod
system.typegettype(system.string,boolean,boolean)isamethod

動態調用

一旦發現一個方法，可以使用映射的方法調用它。例如，我們可能需要調用system.math中的cos方法（返回一個角的余弦值）。為此，我們需要獲得system.math類的類型信息，如下所示：

typethemathtype=type.gettype("system.math");

有了類型信息，我們就可以動態地加載一個類的實例：

objecttheobj=activator.createinstance(themathtype);

createinstance是activator類的一個靜態方法，可以用來對對象進行初始化。

有了system.math類的實例后，我們就可以調用cos方法了。我們還需要準備好一個定義參數類型的數組，因為cos只需要一個參數（需要求余弦值的角度），因此數組中只需要有一個成員。我們將在數組中賦予一個system.double類型的type對象，也就是cos方法需要的參數的類型：

type[]paramtypes=newtype[1];
paramtypes[0]=type.gettype("system.double");

現在我們就可以傳遞方法的名字了，這個數組定義了type對象中getmethod方法的參數的類型：

methodinfocosineinfo=
themathtype.getmethod("cos",paramtypes);

我們現在得到了methodinfo類型的對象，我們可以在其上調用相應的方法。為此，我們需要再次在數組中傳入參數的實際值：

object[]parameters=newobject[1];
parameters[0]=45;
objectreturnval=cosineinfo.invoke(theobj,parameters);

需要注意的是，我創建了二個數組，第一個名字為paramtypes的數組存儲著參數的類型，第二個名字為parameters的數組保存實際的參數值。如果方法需要二個參數，我們就需要使這二個數組每個保持二個參數。如果方法不需要參數，我們仍然需要創建這二個數組，只是無需在里面存儲數據即可。

type[]paramtypes=newtype[0];

盡管看起來有點奇怪，但它是正確的。下面是完整的代碼：

映射方法的使用

usingsystem;
usingsystem.reflection;publicclasstester
{
publicstaticvoidmain()
{
typethemathtype=type.gettype("system.math");
objecttheobj=activator.createinstance(themathtype);

//只有一個成員的數組
type[]paramtypes=newtype[1];
paramtypes[0]=type.gettype("system.double");

//獲得cos()方法的信息
methodinfocosineinfo=
themathtype.getmethod("cos",paramtypes);

//將實際的參數填寫在一個數組中
object[]parameters=newobject[1];
parameters[0]=45;
objectreturnval=cosineinfo.invoke(theobj,parameters);
console.writeline(
"thecosineofa45degreeangle{0}",returnval);

}
}

結論

盡管有許多小錯誤等著c++編程人員去犯，但c#的語法與c++并沒有太大的不同，向新語言的轉換是相當容易的。使用c#的有趣的部分是使用通用語言運行庫，這篇文章只能涉及幾個重點問題。clr和.netframework提供了對線程、集合、互聯網應用開發、基于windows的應用開發等方面提供了更多的支持。語言功能和clr功能之間的區分是非常模糊的，但組合在一起就是一種功能非常強大的開發工具了。

收集最實用的網頁特效代碼！

上一篇：Remoting編程知識一

下一篇：&#091;GDI+&#093; ColorMatrix 彩色矩陣