第一篇：總結(jié)C#獲取當(dāng)前路徑的7種方法
總結(jié)C#獲取當(dāng)前路徑的7種方法
C#獲取當(dāng)前路徑的方法如下：
1.System.Diagnostics.Process.GetCurrentProcess().MainModule.FileName －獲取模塊的完整路徑。
2.System.Environment.CurrentDirectory －獲取和設(shè)置當(dāng)前目錄(該進程從中啟動的目錄)的完全限定目錄。3.System.IO.Directory.GetCurrentDirectory()－獲取應(yīng)用程序的當(dāng)前工作目錄。這個不一定是程序從中啟動的目錄啊，有可能程序放在C:004km.cnLOCALS~1Temp
System.Environment.GetEnvironmentVariable(“TEMP”)=C:DOCUME~1zhoufoxcnLOCALS~1Temp
System.Environment.GetEnvironmentVariable(“Path”)=C:WINDOWSsystem32;C:WINDOWS;C:WINDOWSSystem32Wbem;C:jdk1.5.0bin;C:MySQLServer5.0bin;C:Program FilesSymantecpcAnywhere;C:Program FilesMicrosoft SQL Server80ToolsBINN
C# 相對路徑 系統(tǒng)路徑 2007-12-22 09:53 //獲取啟動了應(yīng)用程序的可執(zhí)行文件的路徑，不包括可執(zhí)行文件的名稱。
string
str5=Application.StartupPath;//可獲得當(dāng)前執(zhí)行的exe的文件名。
string
str1
=Process.GetCurrentProcess().MainModule.FileName;//獲取和設(shè)置當(dāng)前目錄（即該進程從中啟動的目錄）的完全限定路徑。備注
按照定義，如果該進程在本地或網(wǎng)絡(luò)驅(qū)動器的根目錄中啟動，則此屬性的值為驅(qū)動器名稱后跟一個尾部反斜杠（如“C:”）。如果該進程在子目錄中啟動，則此屬性的值為不帶尾部反斜杠的驅(qū)動器和子目錄路徑（如“C:mySubDirectory”）。
string
str2=Environment.CurrentDirectory;//獲取應(yīng)用程序的當(dāng)前工作目錄。
string
str3=Directory.GetCurrentDirectory();//獲取基目錄，它由程序集沖突解決程序用來探測程序集。
string
str4=AppDomain.CurrentDomain.BaseDirectory;//獲取啟動了應(yīng)用程序的可執(zhí)行文件的路徑，不包括可執(zhí)行文件的名稱。
string
str5=Application.StartupPath;//獲取啟動了應(yīng)用程序的可執(zhí)行文件的路徑，包括可執(zhí)行文件的名稱。
string
str6=Application.ExecutablePath;//獲取或設(shè)置包含該應(yīng)用程序的目錄的名稱。
string
str7=AppDomain.CurrentDomain.SetupInformation.ApplicationBase;//例子
Application.StartupPath;//可以得到F:learningc#TrainingwinwinbinDebug //注意自己補兩個 Application.StartupPath+“3.jpg”;
FilesMicrosoft Visual
在c#中，相對路徑是用“.”和“..”表示，“.”代表當(dāng)前目錄，“..”代表上一級錄。
例如 假設(shè)我用vs2005在D:My DocumentsVisual Studio 2005Projects目錄里創(chuàng)建了一個名叫controls的項目，即在Projects文件夾里有一個controls文件夾，controls文件夾里有三個文件：controls.sln
controls文件夾
GulfOfStLawrence文件夾。
D:My DocumentsVisual Studio 2005ProjectsControlsControlsbinDebug是這個簡單項目能夠運行的可執(zhí)行文件Controls.exe
現(xiàn)在我想要 D:My DocumentsVisual Studio 2005ProjectsControlsGulfOfStLawrence文件夾下的Gulf_of_St._Lawrence.mxd（arcgis desktop）工程文件路徑。
那么相對路徑應(yīng)該就是“......GulfOfStLawrenceGulf_of_St._Lawrence.mxd” 即string filename = @“......GulfOfStLawrenceGulf_of_St._Lawrence.mxd”;
心得：1.用相對路徑能增加項目的可移植性。使一個工程在移植過程中變得簡單，節(jié)省了大量布置與工程相關(guān)的文件的時間。（如果設(shè)置的是絕對路徑）。
2.使用相對路徑也使程序代碼變得簡單
3.但有一點必須注意：（只能在同一個驅(qū)動器里（如：都在D:里）使用相對路徑）。
第二篇：C#總結(jié)
引用類型是類型安全的指針，它們的內(nèi)存是分配在堆（保存指針地址）上的。String、數(shù)組、類、接口和委托都是引用類型。
強制類型轉(zhuǎn)換與as類型轉(zhuǎn)換的區(qū)別：當(dāng)類型轉(zhuǎn)換非法時，強制類型轉(zhuǎn)換將拋出一System.InvalidCastException異常，而as不會拋出異常，它返回一個null值。用using創(chuàng)建別名：using console = System.Console;訪問限定符：
public 該成員可以被其他任何類訪問 protected 該成員只能被其派生類訪問
private 該成員只能被本類的其他成員訪問 internal 該成員只能在當(dāng)前編譯單元的其他成員訪問 帶參數(shù)列表和返回值的Main方法： class Test {
public static int Main(string[] args)
{
foreach(string arg in args)
{
...}
} } 構(gòu)造函數(shù)（constructor）包括實例構(gòu)造函數(shù)和靜態(tài)構(gòu)造函數(shù)。構(gòu)造函數(shù)與類名相同，且不能有返回值。例：
class TestClass {
TestClass()//實例構(gòu)造函數(shù)：可以訪問靜態(tài)成員和實例成員，用于初始化實例成員
{
...}
static TestClass()//靜態(tài)構(gòu)造函數(shù)：只能訪問靜態(tài)成員，用于初始化靜態(tài)成員
{
...} } 類的靜態(tài)成員屬于類所有，不必生成實例就可以訪問，它是在載入包含類的應(yīng)用程序時創(chuàng)建的，但靜態(tài)方法不能訪問類的實例變量和方法。通常，靜態(tài)變量是在定義時就賦初始值的。類的實例成員屬于類的實例所有，不創(chuàng)建實例對象就無法對其進行訪問，實例成員可以訪問類的
靜態(tài)成員和其它實例成員。調(diào)用基類的析構(gòu)函數(shù)： class A {
public A()
{
...} } class B {
public B(): base()//調(diào)用基類的析構(gòu)函數(shù)
{
...} } 常量：其值是在編譯時設(shè)定的，必須是數(shù)值文字。默認狀態(tài)下常量是靜態(tài)的。例： class A {
public const double pi = 3.1415;} 常量是編譯時就確定的值，只讀字段是在運行才能確定的值。比如運行時才能確定的屏幕分辨率。
只讀字段只能在類的析構(gòu)函數(shù)中賦值。靜態(tài)只讀字段： class A {
public static readonly int ScreenWidth;//靜態(tài)只讀字段
static A()
//靜態(tài)析構(gòu)函數(shù)
{
ScreenWidth = 1024;//在靜態(tài)析構(gòu)函數(shù)中初始化
} } 在類的繼承中，類的析構(gòu)函數(shù)是不會被繼承的。一個派生類只能從一個基類繼承，不能同時從多個基類繼承，但可以通過繼承多個接口來達到相同目的。實現(xiàn)多繼承的唯一方法就是使用接口。例：
class MyFancyGrid: Control, ISerializable, IDataBound {...} 密封類是不能繼承的類，抽象類不能被定義為密封類，且密封類的私有成員不能用protected修飾，只能用private。例： sealed class A {...} 關(guān)鍵字ref和out用于指定用引用方式傳遞方法的參數(shù)。
它們的區(qū)別是：ref參數(shù)必須初始化，而out參數(shù)不需要初始化。所以在方法處理代碼依賴參數(shù)的初始化值時使用ref，不依賴初始化值時使用out。對out參數(shù)即使在傳遞前對其進行了初始化，其值也不會傳遞到方法處理函數(shù)內(nèi)部。傳遞時系統(tǒng)會將其設(shè)為未初始化。所以在方法內(nèi)部必須對out參數(shù)進行初始化。
方法重載時，必須參數(shù)數(shù)目和參數(shù)類型其中之一不同，返回值不同不能作為重載。C#不支持方法的默認值，只能通過方法重載來實現(xiàn)。例： class A {
int Method(int a)
{
...}
void Method(int a, int b)//參數(shù)數(shù)目不同
{
//返回值不同不能作為重載
...} } params參數(shù)用于一個不定數(shù)目參數(shù)的方法，一般后面跟一個數(shù)組。例： class A {
public void Method(params int[] i)
{
...} } 方法的覆蓋：指派生類覆蓋基類的同名方法，有二種方法
1）第一種是在派生類要覆蓋的方法前面加new修飾，而基類不需要作任何改動。這種方法的缺點是不能實現(xiàn)多態(tài)。例： class A {
public void Method()//無需任何修飾
{
...} } class B: A
//從基類繼承
{
new public void Method()//覆蓋基類的同名方法
{
...} } class TestClass {
A Instance = new B();
Instance.Method();//這時將調(diào)用類A的Method方法，而不是類B的Method方法 } 2）第二種是在派生類要覆蓋的方法前面加override修飾，而基類的同名方法前面加virtual修飾。這樣就能實現(xiàn)多態(tài)，例： class A {
virtual public void Method()
//基類定義虛方法
{
//虛擬方法不能定義為private，因為private成員對派生類是無法訪問的...} }
class B: A
//從基類繼承 {
override public void Method()
//派生類覆蓋基類的同名虛方法
{
...} } class TestClass {
protected void Test()
{
A Instance = new B();
//定義一個實例，類型為基類，從派生類創(chuàng)建
//派生類總是能夠向上轉(zhuǎn)換為其基類
Instance.Method();
//將調(diào)用派生類B的Method方法，而不是基類的，這就是多態(tài)
} } 說明：new修飾的方法覆蓋不能實現(xiàn)多態(tài)的原因，是因為使用new時編譯器只會實現(xiàn)早期綁定（early binding）。即調(diào)用的方法在編譯時就決定了：編譯器看到Instance.Method()而Instance的類是A，就會調(diào)用類A的Method()方法。
override修飾的方法覆蓋可以實現(xiàn)多態(tài)的原因，是因為實現(xiàn)了后期綁定（late binding）。使用override時強制編譯器在運行時根據(jù)類的真正類型正確調(diào)用相應(yīng)的方法，而不是在編譯時。
而基類的同名方法必須加virtual修飾。
類的靜態(tài)方法可能通過 類名.靜態(tài)方法名 這種格式來調(diào)用，不能使用 實例名.靜態(tài)方法名 這種方法調(diào)用。
因為類的靜態(tài)方法為類所有（是屬于類本身的），而非實例所有（不是屬于類的實例的）。類的靜態(tài)方法可以訪問類的任何靜態(tài)成員，但不能訪問類的實例成員。C#中類的變量稱為字段。類的public變量稱為類的公共字段。
類的屬性由一個protected（也可以是private）字段和getter和setter方法構(gòu)成： class Address {
protected string zipCode;//protected字段，注意大小寫
public string ZipCode
{
get
//getter方法
{
return zipCode;
}
set
//setter方法
{
zipCode = value;//被傳遞的值自動被在這個value變量中
}
};} 只讀屬性是指省略setter方法的屬性，只讀屬性只能讀取，不能設(shè)置。
屬性也可以用限定符virtual，override和abstract修飾，功能同其他類的方法。
屬性有一個用處稱為懶惰的初始化（lazy initialization）。即在需要類成員時才對它們進行初始化。如果類中包含了很少被引用的成員，而這些成員的初始化又會花費大量的時候和系統(tǒng)資源的話，懶惰的初始化就很有用了。C#中數(shù)組對象共同的基類是System.Array。將數(shù)組聲明為類的一個成員時，聲明數(shù)組與實例化數(shù)組必須分開，這是因為只能在運行時創(chuàng)建了類的實例對象之后，才能實例化數(shù)組元素值。聲明：
int[] intArray;//一維數(shù)組 int[，] int3Array;//三維數(shù)組 初始化：
intArray = new int[3] {1,2,3};int[,] int2Array = new int[2,3] {{1,2,3},{4,5,6}};//聲明時可以初始化 遍歷：
1）一維數(shù)組
for(int i = 0;i < intArray.Length;i++);//Array.Length返回數(shù)組所有元素的個數(shù) foreach(int i in intArray);for(int i = 0;i < intArray.GetLength(0);i++);//Array.GetLength(0)返回數(shù)組第一維的個數(shù) 2）多維數(shù)組
for(int i = 0;i < int3Array.GetLength(0);i++)//遍歷三維數(shù)組
for(int j = 0;j < int3Array.GetLength(1);j++)
for(int k = 0;k < int3Array.GetLength(2);k++)
{
...} 數(shù)組的維數(shù)就是該數(shù)組的秩（Rank）。Array.Rank可以返回數(shù)據(jù)的秩。鋸齒數(shù)組（jagged Array）是元素為數(shù)組的數(shù)組，例：
int[][] jaggedArray = new int[2][];//包含二個元素，每個元素是個數(shù)組 jaggedArray[0] = new int[2];//每個元素必須初始化 jaggedArray[1] = new int[3];for(int i = 0;i < jaggedArray.Length;i++)//遍歷鋸齒數(shù)組
for(int j = 0;j < jaggedArray[i].Length;j++)
{
...} 類的屬性稱為智能字段，類的索引器稱為智能數(shù)組。由于類本身作數(shù)組使用，所以用this作索引器的名稱，索引器有索引參數(shù)值。例： using System;using System.Collections;class MyListBox {
protected ArrayList data = new ArrayList();
public object this[int idx] //this作索引器名稱，idx是索引參數(shù)
{
get
{
if(idx >-1 && idx < data.Count)
{
return data[idx];
}
else
{
return null;
}
}
set
{
if(idx >-1 && idx < data.Count)
{
data[idx] = value;
}
else if(idx = data.Count)
{
data.Add(value);
}
else
{
//拋出一個異常
}
}
} } 接口是二段不同代碼之間約定，通過約定實現(xiàn)彼此之間的相互訪問。C#并不支持多繼承，但通過接口可實現(xiàn)相同功能。當(dāng)在接口中指定了實現(xiàn)這個接口的類時，我們就稱這個類“實現(xiàn)了該接口”或“從接口繼承”。一個接口基本上就是一個抽象類，這個抽象類中除了聲明C#類的其他成員類型——例如屬性、事件和索引器之外，只聲明了純虛擬方法。接口中可以包含方法、屬性、索引器和事件——其中任何一種都不是在接口自身中來實現(xiàn)的。例：
interface IExampleInterface {
//property declaration
int testProperty { get;}
//event declaration
event testEvevnt Changed;
//mothed declaration
function void testMothed();
//indexer declaration
string this[int index] { get;set;} } 說明：定義接口時，在方法、屬性、事件和索引器所有這些接口成員都不能用public之類的訪問限定符，因為所有接口成員都是public類型的。因為接口定義了一個約定，任何實現(xiàn)一個接口的類都必須定義那個接口中每一個成員，否則將編譯失敗。例： using System;public class FancyControl {
protected string data;
public string Data
{
get {return this.data;}
set {data = value;}
} } interface IValidate {
bool Validate();//接口方法
} public class MyControl: FancyControl, IValidate {
public MyControl()
{
data = “my control data”;
}
public bool Validate()//實現(xiàn)接口
{
if(data == “my control data”)
return true;
else
return false;
} } class InterfaceApp {
MyControl myControl = new MyControl();
IValidate val =(IValidate)myControl;//可以將一個實現(xiàn)某接口的類，轉(zhuǎn)換成該接口
bool success = val.Validate();//然后可調(diào)用該接口的方法 } 也可以用：bool success = myControl.Validate();這種方法來調(diào)用Validate方法，因為Validate在類MyControl中是被定義成public的，如果去除public，Validate方法被隱藏，就不能用這種方法調(diào)用了，這樣隱藏接口方法稱為名字隱藏（name hiding）。可以用：類實例 is 接口名 來判斷某個類是否實現(xiàn)了某接口，例： myControl is IValidate //MyControl類的實例myControl是否實現(xiàn)了IValidate接口
當(dāng)然，也可用as來作轉(zhuǎn)換，根據(jù)轉(zhuǎn)換結(jié)果是否為null來判斷某個類是否實現(xiàn)了某接口，例： IValidate val = myControl as IValidate;if(null == val){...//沒有實現(xiàn)IValidate接口 } else {...//實現(xiàn)了IValidate接口
}
如果一個類從多個接口繼承，而這些接口中如果定義的同名的方法，則實現(xiàn)接口的方法時，必須加接口名來區(qū)別，寫成 接口名.方法名。假設(shè)Test類從IDataStore和ISerializable二個接口繼承，而這二個接口都有SaveData()方法，實現(xiàn)SaveData()方法時必須寫成： class Test: ISerializable, IDataStore {
void ISerializable.SaveData()
{
...}
void IDataStore.SaveData()
{
...} } 如果一個類從多個接口繼承，為了方便可以定義一個新的接口，這個接口繼續(xù)多個接口，然后類直接從這個接口繼承就可以了，這個叫合并接口。例： interface ISaveData: ISerializable, IDataStore { //不需要定義任何方法或成員，只是用作合并 } class Test: ISaveData //只要繼承ISaveData就可以了 {...} C# 操作符優(yōu)先級（從高到低）
初級操作符()x.y f(x)a[x] x++ x--new typeof sizeof checked unchecked 一元操作符 +位移操作符 << >> 關(guān)系操作符 < > <= >= is 等于操作符 == 邏輯與
& 邏輯異或 ^ 邏輯或
| 條件與
&& 條件或
|| 條件操作符 ?: 賦值操作符 = *= /= %= +=-= <<= >>= &= ^= |= 所有的二元操作符除賦值符外都是左聯(lián)合的，即從左到右計算。
typeof()運算符可以從一個類名得到一個System.Type對象，而從System.Object對象繼承來的GetType()方法則可從一個類實例來得到一個System.Type對象。例： Type t1 = typeof(Apple);//Apple是一個類名
Apple apple = new Apple();//apple是Apple類的一個實例 Type t2 = apple.GetType();//t1與t2是相同的 通過反射得到一個類的所有成員和方法： Type t = typeof(Apple);string className = t.ToString();//得到類名
MethodInfo[] methods = t.GetMethods();//得到所有方法 foreach(MethodInfo method in methods){ //用method.ToString()得到方法名 } MemberInfo[] members = t.GetMembers();//得到所有成員 foreach(MemberInfo member in members){ //用member.ToString()得到成員名 } sizeof()操作符用來計算值類型變量在內(nèi)存中占用的字節(jié)數(shù)（Bytes），并且它只能在unsafe（非安全）
代碼中使用。例：
static unsafe public void ShowSizes(){
int i, j;
j = sizeof(short);
j = sizeof(i);} 盡可能使用復(fù)合賦值操作符，它比不用復(fù)合賦值操作符的效率高。for語句的語法為：
for(initialization;Boolean-expression;step)
embedded-statement 在initialization和step部份還可以使用逗號操作符，例： for(int i = '0', j = 1;i <= 'xFF';i++, j++)for(int i = 1, j = 1;i < 1000;i += j, j = i!~ ++--true false 二元：+32)/ 9)* 5;
} } 代表的(delegate)目的與C++中的函數(shù)指針相同，代表不是在編譯時被定義的，而是在運行時被定義的。
代表主要有二個用途：回調(diào)(Callback)和事件處理(event)回調(diào)通常用于異步處理和自定義處理。例： class DBManager {
static DBConnection[] activeConnections;
//聲明回調(diào)函數(shù)
public void delegate EnumConnectionCallback(DBConnection connection);
public static void EnumConnections(EnumConnectionCallback callback)
{
foreach(DBConnection connection in activeConnections)
{
callback(connection);//執(zhí)行回調(diào)函數(shù)
}
} } //調(diào)用
class DelegateApp {
public static void ActiveConncetionCallback(DBConnection connection)//處理函數(shù)
{
...}
public void main()
{
//創(chuàng)建指向具體處理函數(shù)的代表實例（新建一個代表，讓它指向具體的處理函數(shù)）
DBManager.EmnuConnectionCallback myCallback = new DBManager.EmnuConnectionCallback(ActiveConncetionCallback);
DBManager.EnumConnections(myCallback);
} } //使用靜態(tài)代表，上面的調(diào)用改為 class DelegateApp {
//創(chuàng)建一個指向處理函數(shù)的靜態(tài)代表
public static DBManager.EmnuConnectionCallback myCallback
= new DBManager.EmnuConnectionCallback(ActiveConncetionCallback);
public static void ActiveConncetionCallback(DBConnection connection)
{...} public void main()
{
DBManager.EnumConnections(myCallback);
} } //在需要時才創(chuàng)建代表，上面的調(diào)用改為
class DelegateApp {
//將創(chuàng)建代表放在屬性的getter方法中
public static DBManager.EmnuConnectionCallback myCallback
{
get
{
retun new DBManager.EmnuConnectionCallback(ActiveConncetionCallback);
}
}
public static void ActiveConncetionCallback(DBConnection connection)
{...} public void main()
{
DelegateApp app = new DelegateApp();//創(chuàng)建應(yīng)用程序
DBManager.EnumConnections(myCallback);
} } 可以將多個代表整合成單個代表，例： class CompositeDelegateApp {
public static void LogEvent(Part part)
{
...}
public static void EmailPurchasingMgr(Part part)
{
...}
public static void Main()
{
//定義二個代表
InventoryManager.OutOfStockExceptionMethod LogEventCallback
= new InventoryManager.OutOfStockExceptionMethod(LogEvent);
InventoryManager.OutOfStockExceptionMethod EmailPurchasingMgrCallback
= new InventoryManager.OutOfStockExceptionMethod(EmailPurchasingMgr);
//整合為一個代表，注意后加的代表先執(zhí)行（這里是先執(zhí)行LogEventCallback）
InventoryManager.OutOfStockExceptionMethod onHandExceptionEventsCallback
= EmailPurchasingMgrCallback + LogEventCallback;
//調(diào)用代表
InventoryManager mgr = new InventoryManager();
mgr.ProcessInventory(onHandExceptionEventsCallback);
//InventoryManager類的ProcessInventory方法的原型為：
//public void ProcessInventory(OutOfStockExceptionMethod exception);
} } 可以根據(jù)需要將多個代表自由地組合成單個代表，例： class CompositeDelegateApp {
//代表指向的處理函數(shù)（三個代表三個函數(shù)）
public static void LogEvent(Part part)
{
...} public static void EmailPurchasingMgr(Part part){...}
public static void EmailStoreMgr(Part part)
{
...}
public static void Main()
{
//通過數(shù)組定義三個代表
InventoryManager.OutOfStockExceptionMethod[] exceptionMethods
= new InventoryManager.OutOfStockExceptionMethod[3];
exceptionMethods[0] = new InventoryManager.OutOfStockExceptionMethod(LogEvent);
exceptionMethods[1] = new InventoryManager.OutOfStockExceptionMethod(EmailPurchasingMgr);
exceptionMethods[2] = new InventoryManager.OutOfStockExceptionMethod(EmailStoreMgr);
int location = 1;
//再定義一個代表（用于組合成單代表）
InventoryManager.OutOfStockExceptionMethod compositeDelegate;
//根據(jù)需要組合
if(location = 2)
{
compositeDelegate = exceptionMethods[0] + exceptionMethods[1];
}
else
{
compositeDelegate = exceptionMethods[0] + exceptionMethods[2];
}
//調(diào)用代表
InventoryManager mgr = new InventoryManager();
mgr.ProcessInventory(compositeDelegate);
} } C#的事件遵循“發(fā)布——預(yù)訂”的設(shè)計模式。在這種模式中，一個類公布能夠出現(xiàn)的所有事件，然后任何的類都可以預(yù)訂這些事件。一旦事件產(chǎn)生，運行環(huán)境就負責(zé)通知每個訂戶事件已經(jīng)發(fā)生了。
當(dāng)代表作為事件的處理結(jié)果時（或者說定義具有代表的事件），定義的代表必須指向二個參數(shù)的方法：一個參數(shù)是引發(fā)事件的對象（發(fā)布者），另一個是事件信息對象（這個對象必須從EventArgs類中派生）。例： using System;
class InventoryChangeEventArgs: EventArgs //事件信息對象，從EventArgs類派生 {...//假設(shè)定義二個public屬性string Sku和int Change } class InventoryManager
//事件的發(fā)布者 {
//聲明代表
public delegate void InventoryChangeEventHander(object source, InventoryChangeEventArgs e);
//發(fā)布事件，event關(guān)鍵字可將一個代表指向多個處理函數(shù)
public event InventoryChangeEventHandler onInventoryChangeHander;
public void UpdateInventory(string sku, int change)
{
if(change == 0)
return;
InventoryChangeEventArgs e = new InventoryChangeEventArgs(sku, change);
//觸發(fā)事件
if(onInventoryChangeHandler!= null)//如果有預(yù)訂者就觸發(fā)
onInventoryChangeHandler(this, e);//執(zhí)行代表指向的處理函數(shù)
} } class InventoryWatcher
//事件的預(yù)訂者 {
public InventoryWatcher(InventoryManager mgr)//mgr參數(shù)用于聯(lián)結(jié)發(fā)布者
{
this.inventoryManager = mgr;
//預(yù)訂事件，用 += 調(diào)用多個處理函數(shù)
mgr.onInventroyChangeHandler += new InventoryManager.InventoryChangeEventHandler(onInventoryChange);
//事件處理函數(shù)
void onInventroyChange(object source, InventroyChangeEventArgs e)
{
...}
InventoryManager inventoryManager;
} } class EventsApp
//主程序 {
public static void Main()
{
InventoryManager inventoryManager = new InventoryManager();
InventoryWatcher inventoryWatcher = new InventoryWatcher(inventoryManager);
inventoryManager.UpdateInventory(“111 006 116”,-2);
inventoryManager.UpdateInventory(“111 006 116”, 5);
} } Microsoft Windows NT和IBM OS/2等操作系統(tǒng)都支持占先型多任務(wù)。在占先型多任務(wù)執(zhí)行中，處理器負責(zé)
給每個線程分配一定量的運行時間——一個時間片(timeslice)。處理器接著在不同的線程之間進行切換，執(zhí)行相應(yīng)的處理。在單處理器的計算機上，并不能真正實現(xiàn)多個線程的同時運行，除非運行在多個處理器 的計算機上。操作系統(tǒng)調(diào)度的多線程只是根據(jù)分配給每個線程時間片進行切換執(zhí)行，感覺上就像同時執(zhí)行。
上下文切換(context switching)是線程運行的一部分，處理器使用一個硬件時間來判斷一個指定線程的時間片何時結(jié)束。當(dāng)這個硬件計時器給出中斷信號時，處理器把當(dāng)前運行的線程所用的所有寄存器(registers)數(shù)據(jù)存儲到堆棧中。然后，處理器把堆棧里那些相同的寄存器信息存放到一種被稱為“上下文結(jié)構(gòu)”的數(shù)據(jù)結(jié)構(gòu)中。當(dāng)處理器要切換回原來執(zhí)行的線程時，它反向執(zhí)行這個過程，利用與該線程相關(guān)的上下文結(jié)構(gòu)，在寄存器里重新恢復(fù)與這一線程相關(guān)的信息。這樣的一個完整過程稱為“上下文切換”。多線程允許應(yīng)用程序把任務(wù)分割為多個線程，它們彼此之間可以獨立地工作，最大限度地利用了處理器時間。using System;using System.Threading;class SimpleThreadApp {
public static void WorkerThreadMethod()//線程的執(zhí)行體
{
...//執(zhí)行一些操作
}
public static void Main()
{
//創(chuàng)建一個線程代表指向線程的執(zhí)行體，ThreadStart是創(chuàng)建新線程必須用到的代表
ThreadStart worker = new ThreadStart(WorkerThreadMethod);
Thread t = new Thread(worker);//用線程代表創(chuàng)建線程
t.Start();
//執(zhí)行線程
} } 可以通過兩種方式來得到一個Thread對象：一種是通過創(chuàng)建一個新線程來得到，如上例；另一種在正在執(zhí)行的線程調(diào)用靜態(tài)的Thread.CurrentThread方法。
靜態(tài)方法Thread.Sleep(int ms)可以讓當(dāng)前線程（它自動調(diào)用Thread.CurrentThread）暫停指定毫秒的時間。
如果使用Thread.Sleep(0)那么當(dāng)前線程將一直處于等待中，直到另一個線程調(diào)用這個線程的實例方法Thread.Interrupt方法，等待才會結(jié)束。使用Thread.Suspend方法也能掛起線程，Thread.Suspend方法可以被當(dāng)前線程或其他線程調(diào)用，而Thread.Sleep(0)只能由當(dāng)前線程在執(zhí)行體中調(diào)用。當(dāng)線程用Thread.Suspend掛起時，必須用Thread.Resume方法恢復(fù)。不論Thread.Suspend方法調(diào)用了多少次，只要調(diào)用Thread.Resume方法一次就可以線程恢復(fù)執(zhí)行。用Thread.Suspend方法并不會阻塞線程，調(diào)用立即返回。而Thread.Sleep(0)則會阻塞線程。所以確切地說Thread.Sleep(0)暫停線程，而不是掛起線程。
使用Thread.Abort方法可以終止正在執(zhí)行的線程。當(dāng)Thread.Abort方法被調(diào)用時，線程不會立即終止執(zhí)行。運行環(huán)境將會等待，直到線程到達文檔中所描述的“安全點”。如果要確保線程已經(jīng)完全停止，可以使用Thread.Join方法。這是一個同步調(diào)用，同步調(diào)用意味著直到線程完全停止，調(diào)用才會返回。
Thread.Priority屬性用于設(shè)置的線程的優(yōu)先級。其值是Thread.ThreadPriority枚舉值，可以設(shè)為Highest, AboveNormal,Normal, BelowNormal, Lowest。缺省值是Thread.ThreadPriority.Normal。
線程的同步是為了解決多個線程同時使用同一對象產(chǎn)生的一些問題。通過同步，可以指定代碼的臨界區(qū)(critical section)，一次只有一個線程可以進入臨界區(qū)。使用System.Monitor類（鎖定與信號量）進行線程同步： using System;using System.Threading;public void SaveData(string text)//線程執(zhí)行函數(shù)或線程執(zhí)行函數(shù)調(diào)用的對象的方法 {
...//執(zhí)行其他一些不需要同步的處理
Monitor.Enter(this);//獲取對象的Monitor鎖
...//執(zhí)行需要同步的處理
Monitor.Exit(this);//釋放對象的Monitor鎖
...//執(zhí)行其他一些不需要同步的處理
} 說明：當(dāng)執(zhí)行Monitor.Enter方法時。這個方法會試圖獲取對象上的Monitor鎖，如果另一個線程已經(jīng)擁有了這個鎖，這個方法將會阻塞(block)，直到這個鎖被釋放。
也可用C#的lock語句來獲得和釋放一個Monitor鎖。上面同步寫成：public void SaveData(string text)//線程執(zhí)行函數(shù)或線程執(zhí)行函數(shù)調(diào)用的對象的方法 {
...//執(zhí)行其他一些不需要同步的處理
lock(this)//獲取對象的Monitor鎖，代碼塊執(zhí)行完成后釋放Monitor鎖
{
...//執(zhí)行需要同步的處理
}
...//執(zhí)行其他一些不需要同步的處理 } 也可以使用System.Threading名稱空間的Mutex類（互斥類）進行線程同步。與Monitor鎖一樣，一次只有一個線程能獲得一個給定的互斥。但Mutex要慢得多，但它增加了靈活性。例：
using System;using System.Threading;class Database {
Mutex mutex = new Mutex(false);//創(chuàng)建一個互斥，但不立即獲得它
//注意：創(chuàng)建互斥在需要同步的方法之外，實際上它只要創(chuàng)建一個實例
public void SaveData(string text)//需要同步的方法
{
mutex.WaitOne();//等待獲得互斥
...//需要同步的處理
mntex.Close();//釋放互斥
} } Mutex類重載了三個構(gòu)造函數(shù)：
Mutex()
//創(chuàng)建并使創(chuàng)建類立即獲得互斥
Mutex(bool initiallyOwned)
//創(chuàng)建時可指定是否要立即獲得互斥 Mutex(bool initiallyOwned, string muterName)//還可以指定互斥的名稱 Mutex.WaitOne方法也重載了三次： Mutex.WaitOne()
//一直等待
Mutex.WaitOne(TimeSpan time, bool exitContext)//等待TimeSpan指定的時間 Mutex.WaitOne(int milliseconds, bool exitContext)//等待指定的毫秒 線程的用法：
1)并發(fā)操作：比如一個程序監(jiān)視多個COM口，當(dāng)每個COM接到信息時執(zhí)行一段處理時。2)復(fù)雜長時間操作：一個長時間的復(fù)雜操作可能會使界面停滯，停止用戶響應(yīng)，如果還允許用戶停止它，或者顯示進度條、顯示操作執(zhí)行進程信息時。
反射(Reflection)就是能夠在運行時查找類型信息，這是因為.NET編譯的可執(zhí)行(PE)文件中包括MSIL和元數(shù)據(jù)(metadata)。
反射的中心是類System.Type。System.Type是一個抽象類，代表公用類型系統(tǒng)(Common Type System, CTS)中的一種類型。
using System;using System.Reflection;//反射命名空間，必須引用 public static void Main(string[] args){
int i = 6;
Type t = i.GetType();
//根據(jù)實例得到類型
t = Type.GetType(“System.Int32”);//根據(jù)類型的字符名稱得到類型
} 通過Assembly類可以得到已經(jīng)編譯.NET Framework程序的中所有類型，例： using System;using System.Diagnostics;//為了使用Process類 using System.Reflection;//為了使用Assembly類 class GetTypesApp {
protected static string GetAssemblyName(string[] args)
{
string assemblyName;
if(0 == args.Length)//如果參數(shù)為空，取當(dāng)前進程的名稱
{
Process p = Process.GetCurrentProcess();
assemblyName = p.ProcessName + “.exe”;
}
else
assemblyName = args[0];//取第一個參數(shù)，即當(dāng)前運行程序名
return assemblyName;
}
public static void Main(string[] args)
{
string assemblyName = GetAssemblyName(args);
Assembly a = Assembly.LoadFrom(assemblyName);//調(diào)用編譯程序集
Type[] types = a.GetTypes();
//得到多個類型
foreach(Type t in types)
//遍歷類型數(shù)組
{
...//取得t.FullName,t.BaseType.FullName等類型信息
}
} } 一個應(yīng)用程序可以包括多個代碼模塊。若要將一個cs文件編譯一個模塊，只要執(zhí)行下面的命令：
csc /target:module 要編譯的模塊.cs //csc是C Sharp Compiler(C#編譯器)然后在應(yīng)用程序中using編譯的模塊.cs中的NameSpace即可應(yīng)用了。要反射應(yīng)用程序中所有代碼模塊(Module)，只要：
Assembly a = Assembly.LoadFrom(assemblyName);//應(yīng)用程序的物理文件名 Module[] modules = a.GetModules();foreach(Module m in modules){...//顯示m.Name等
} 后期綁定(latebinding),例：
string[] fileNames = Directory.GetFiles(Environment.CurrentDirectory, “*.dll”);foreach(string fileName in fileNames){
Assembly a = Assembly.LoadFrom(fileName);
Type[] types = a.GetTypes();
foreach(Type t in types)
{
if(t.IsSubclassOf(typeof(CommProtocol)))//判斷是否有CommProtocol的派生類
{
object o = Activator.CreateInstance(t);//生成實例
MethodInfo mi = t.GetMethod(“DisplayName”);
mi.Invoke(o, null);
//調(diào)用方法
}
} } //帶參數(shù)的例子
namespace Programming_CSharp {
using System;
using System.Reflection;
public class Tester
{
public static void Main()
{
Type t = Type.GetType(“System.Math”);
Object o = Activator.CreateInstance(t);
// 定義參數(shù)類型
Type[] paramTypes = new Type[1];
paramTypes[0]= Type.GetType(“System.Double”);
MethodInfo CosineInfo = t.GetMethod(“Cos”, paramTypes);
//設(shè)置參數(shù)數(shù)據(jù)
Object[] parameters = new Object[1];
parameters[0] = 45;
//執(zhí)行方法
Object returnVal = CosineInfo.Invoke(o, parameters);
Console.WriteLine(“The cosine of a 45 degree angle {0}”, returnVal);
}
} } 動態(tài)生成代碼和動態(tài)調(diào)用的完整例子： //動態(tài)生成代碼的部分 using System;using System.Reflection;using System.Reflection.Emit;//動態(tài)生成代碼必須引用 namespace ILGenServer {
public class CodeGenerator
{
public CodeGenerator()
{
currentDomain = AppDomain.CurrentDomain;//得到當(dāng)前域
assemblyName = new AssemblyName();//從域創(chuàng)建一個程序集
assemblyName.Name = “TempAssembly”;
//得到一個動態(tài)編譯生成器，AssemblyBuilerAccess.Run表示只在內(nèi)存中運行，不能保存
assemblyBuilder = currentDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilerAccess.Run);
//從編譯生成器得到一個模塊生成器
moduleBuilder = assemblyBuilder.DefineDynamicModule(“TempModule”);
//模塊生成器得到類生成器
typeBuilder = moduleBuilder.DefineType(“TempClass”, TypeAttributes.Public);
//為類添加一個方法
methodBuilder = typeBuilder.DefineMethod(“HelloWord”, MethodAttributes.Public, null, null);
//為方法寫入代碼，生成代碼必須使用到IL生成器
msil = methodBuilder.GetILGenerator();
msil.EmitWriteLine(“Hello World”);msil.Emit(OpCodes.Ret);//最后還需要編譯(build)一下類 t = typeBuilder.CreateType();
}
AppDomain currentDomain;
AssemblyName assemblyName;
AssemblyBuilder assemblyBuilder;
ModuleBuilder moduleBuilder;
TypeBuilder typeBuilder;
MethodBuilder methodBuilder;
ILGenerator msil;
object o;
Type t;
public Type T
{
get
{
return this.t;
}
}
} } //動態(tài)調(diào)用的部分
using System;using System.Reflection;using ILGenServer;//引用動態(tài)生成代碼的類 public class ILGenClientApp {
public static void Main（{
CodeGenerator gen = new CodeGenerator();//創(chuàng)建動態(tài)生成類
Type t = gen.T;
if(null!= t)
{
object o = Activator.CreateInstance(t);
MethodInfo helloWorld = t.GetMethod(“HelloWorld”);//為調(diào)用方法創(chuàng)建一個MethodInfo
if(null!= helloWorld)
{
helloWorld.Invoke(o, null);//調(diào)用方法
}
}
} } 調(diào)用DLL using System;using System.Runtime.InteropServices;//為了使用DLLImport特性
class PInvokeApp {
[DllImport(“user32.dll”, CharSet=CharSet.Ansi)] //CharSet.Ansi指定Ansi版本的函數(shù)(MessageBoxA),CharSet.Unicode指定Unicode版本的函數(shù)(MessageBoxW)
static extern int MessageBox(int hWnd, string msg, string caption, int type);//聲明DLL中的函數(shù)
//[DllImport(“user32.dll”, EntryPoint=“MessageBoxA”)] //用這種方法使用不同的函數(shù)名
//static extern int MsgBox(int hWnd, string msg, string caption, int type);
//[DllImport(“user32.dll”, CharSet=CharSet.Unicode)] //調(diào)用Unicode版的DLL函數(shù)
//static extern int MessageBox(int hWnd, [MarshalAs(UnmanagedType.LPWStr)]string msg，// [MarshalAs(UnmanagedType.LPWStr)]string caption, int type);//將LPWStr翻譯為string型，缺省情況系統(tǒng)只將LPStr翻譯成string
public static void Main()
{
MessageBox(0, “Hello, World!”, “CaptionString”, 0);//調(diào)用DLL中的函數(shù)
} } 例2，使用回調(diào)： class CallbackApp {
[DllImport(“user32.dll”)]
static extern int GetWindowText(int hWnd, StringBuilder text, int count);
delegate bool CallbackDef(int hWnd, int lParam);
[DllImport(“user32.dll”)]
static extern int EnumWindows(CallbackDef callback, int lParam);
static bool PrintWindow(int hWnd, int lParam)
{
StringBuilder text = new StringBuilder(255);
GetWindowText(hWnd, text, 255);
Console.WriteLine(“Window Caption: {0}”, text);
return true;
}
static void Main()
{
CallbackDef callback = new CallbackDef(PrintWindow);
EnumWindows(callback, 0);
} } 關(guān)鍵字unsafe指定標(biāo)記塊在非控環(huán)境中運行。該關(guān)鍵字可以用于所有的方法，包括構(gòu)造函數(shù)和屬性，甚至還有方法中的代碼塊。關(guān)鍵字fixed負責(zé)受控對象的固定(pinning)。Pinning是一種動作，向垃圾收集(Garbage Collector, GC)指定一些不能被移動的對象。為了不在內(nèi)存中產(chǎn)生碎片，.NET運行環(huán)境把對象四處移動，以便于最有效地利用內(nèi)存。使用fixed后指定對象將不會被移動，所以就可以用指針來訪問它。
C#中只能得到值類型、數(shù)組和字符串的指針。在數(shù)組的情況下，第一個元素必須是值類型，因為C#實際上是返回一個指向數(shù)組第一個元素的指針，而不是返回數(shù)組自身。& 取一個變量的內(nèi)存地址（即指向該變量的指針）* 取指針?biāo)缸兞康闹?> 取成員
例：using System;class UnsafeApp {
public static unsafe void GetValues(int* x, int* y)
{
*x = 6;
*y = 42;
}
public static unsafe void Main()
{
int a = 1;
int b = 2;
GetValues(&a, &b);
} } fixed語法為：fixed(type* ptr = expression)statements其中type也可以為非控類型，也可是void；expression是任何產(chǎn)生一個type指針的表達式；statements是應(yīng)用的代碼塊。例： fixed(int* f = &foo.x)//foo是Foo類的一個實例，x是Foo類的一個int屬性 {
SetFooValue(f);//SetFooValue方法的定義為unsafe static void SetFooValue(int* x)} 傳統(tǒng)的COM組件可以通過互操作層(COM Interop)與.NET運行環(huán)境交互?；ゲ僮鲗犹幚碓谕泄苓\行環(huán)境和非托管區(qū)域中的COM組件操作之間傳遞所有的消息。
要使COM組件能在.NET環(huán)境中使用,必須為COM組件生成元數(shù)據(jù)。.NET運行環(huán)境用元數(shù)據(jù)層業(yè)判斷類型信息。在運行時刻使用類型信息，以便生成RCW(Runtime Callable Wrapper,運行時可調(diào)用包裝)。當(dāng).NET應(yīng)用程序與COM對象交互時，RCW處理對COM對象的裝載和調(diào)用。RCW還完成許多其他的工作，如管理對象標(biāo)識、對象生存周期以及接口緩沖區(qū)。對象生存周期管理十分關(guān)鍵，因為.NET GC把對象到處移動，并且當(dāng)對象不再使用時，自動處理這些對象。RCW服務(wù)告訴.NET，應(yīng)用程序正與托管.NET組件交互，同時又使非托管COM組件“覺得”COM對象是被傳統(tǒng)的COM客戶端調(diào)用的。
為了為COM組件生成元數(shù)據(jù)包裝，必須使用tlbimp.exe(TypeLib Importer)工具： tlbimp some_COM.tlb /out:som_COM.dll
第三篇：獲取工作經(jīng)驗的八種方法
對于初次找工作或者準(zhǔn)備跳槽的人來說，進入一個新的工作領(lǐng)域是件非常困難的事。你理想中的招聘廣告是這樣的：
“新成立公司招聘職員，要求對工作充滿熱情，高薪，高福利，無需工作經(jīng)驗，我們將提供培訓(xùn)”
然而現(xiàn)實通常是這樣的：
“招聘某某部經(jīng)理，1到2年工作經(jīng)驗，需要工作證明”
也許你逃避了大學(xué)實習(xí)，也許你從未找到過適合你的工作，也許你正經(jīng)歷一場中年事業(yè)危機，想要嘗試一些新的東西，不管出于何種原因，你發(fā)現(xiàn)你自己沒有也不可能獲得相關(guān)工作經(jīng)驗。
幸運的是，在信息時代，那些“沒有工作經(jīng)驗”的接口已經(jīng)越來越?jīng)]有市場了，通過各種各樣的非傳統(tǒng)途徑來獲取工作經(jīng)驗，即使你還沒有得到夢想中的工作，你已經(jīng)離它不遠了。
義務(wù)工作：
登錄或者之類的網(wǎng)站來尋找相關(guān)的工組機會，你會看到很多像“網(wǎng)上義工”之類的廣告，它們對你的居住地沒有任何要求。但因為這是沒有薪水的，通過它們獲取的經(jīng)驗（從時間和經(jīng)驗層面上）總是比同等的帶薪工作要少。
●涉及領(lǐng)域：大部分工作，你可以為千里之外的慈善協(xié)會寫文案，接送癌癥病人接受治療（心理咨詢或者什么的）或者為當(dāng)?shù)毓娼M織拉贊助。
●優(yōu)點：可以以此來建立人際關(guān)系網(wǎng)，增加工作經(jīng)驗，有利于將來找工作，還能增強你的自信心，同時這些工作對時間要求通常會很寬松。
自由職業(yè)工作網(wǎng)站：
在像, 和 網(wǎng)站上，你可以競標(biāo)到很多工作，從一天的短工到長期的專業(yè)工作應(yīng)有盡有，假如你有什么特長，你應(yīng)該去看看那里是否有你適合的工作。
因為這些網(wǎng)站采用客戶反饋系統(tǒng)開評價你的工作，一開始你必須做些樣品并且報酬要得低一些，一旦你得到了足夠多的好評，那么你將通過你的努力掙很多錢。
●相關(guān)領(lǐng)域：程序設(shè)計，圖式設(shè)計，市場營銷，寫作，銷售，行政管理，等等 ●優(yōu)點：培養(yǎng)獨立工作能力，拓展人脈，獲取大量工作經(jīng)驗，當(dāng)然還有賺錢
●缺點：接到第一筆業(yè)務(wù)可能比較困難，而且在有些網(wǎng)站你必須付費成為會員后才能接業(yè)務(wù)。
考證
在某些領(lǐng)域，比別人多一張證會使你鶴立雞群，如果你想打入一流的房地產(chǎn)公司，考一張房產(chǎn)經(jīng)營證是值得的，在你還沒有完成商科學(xué)業(yè)前，你可以用它來找份兼職，如果你是位運動或者營養(yǎng)品企業(yè)，你可以去考張私人教練證或者去你所在地的青年基督教會做義工。
●相關(guān)領(lǐng)域：心理咨詢，運動健身，房地產(chǎn)，信息技術(shù)，財金保險，新世紀(jì)產(chǎn)業(yè)，保安，餐飲業(yè)，醫(yī)療等，去圖書館查查各個領(lǐng)域的資質(zhì)證書和相關(guān)細節(jié)會對你有所幫助。
讓你的愛好成為職業(yè)
如果你對你的職業(yè)生涯是非常認真的，那么好一個與你的愛好關(guān)系緊密的工作是再好不過的了，想想看你的愛好是什么，怎么讓它成為你的工作。
你必須要有創(chuàng)造性，但當(dāng)你在游戲中帶領(lǐng)一群人戰(zhàn)斗或者在虛擬世界中做買賣時，你正在學(xué)習(xí)很多有用的技能，我就在我簡歷的工作經(jīng)驗上寫了這么一條：我在《無盡的任務(wù)》中的勝率是100%。
●相關(guān)領(lǐng)域：很明顯，假如你夢想成為消防員，你不可能把放火滅火當(dāng)成興趣，所以這一條是有一定限制的，但是每個領(lǐng)域都有錄像，書籍，圖表，或者其他什么替代品來讓你了解。
●優(yōu)點：有趣
●缺點：也許沒有人付你工資
當(dāng)學(xué)徒
根據(jù)你喜歡的領(lǐng)域，你很可能會找到很多需要額外幫手的工作人員，你甚至可能根據(jù)你的工作時間為此安排一個寬松的時間表，你可以試著去問問看，被拒絕也沒關(guān)系。
●相關(guān)領(lǐng)域：幾乎所有，幸運的話你可以碰到個個體戶或者自由職業(yè)者，你可能會去給醫(yī)生接電話，為面包房洗盤子，為一個自由撰稿人校對稿子甚至幫魔術(shù)師打雜。
●優(yōu)點：你可以交到在這個領(lǐng)域工作的朋友，獲得相關(guān)的經(jīng)驗。
●缺點：沒有報酬，而且有些人會想方設(shè)法瞞著你一些東西，因為他們害怕培養(yǎng)了未來的競爭對手。
傳統(tǒng)自由撰稿人
即使寫作不是你最大的職業(yè)理想，但這會是你邁向目標(biāo)的好方法，一開始你可以向你目標(biāo)領(lǐng)域的貿(mào)易出版物提供一些簡單的東西，比如公司簡介什么的，也許你需要提供一些未公布的樣本來證明你有刺探情報的能力，但大多數(shù)貿(mào)易出版物愿意接受新人。
●相關(guān)領(lǐng)域：任何有其雜志的領(lǐng)域，像和這樣的網(wǎng)站。
●優(yōu)點：工作時間寬松，威望高后薪水相當(dāng)可觀。
●缺點：可能競爭非常激烈，取決于不同領(lǐng)域。
自己創(chuàng)業(yè)
想想看，時間并不會因為困難太多而等你，盡管你會面臨合法性或者資格問題，但這些并不妨礙你開自己的公司。
●相關(guān)領(lǐng)域：盡管你不可能自己開一家整形診所，但你可以從事廣告，餐飲或者銷售之類的行業(yè)，最好的選擇是最資質(zhì)要求和啟動資金少的行業(yè)。
●優(yōu)點：你自己當(dāng)自己的老板，獲取經(jīng)驗，還有可能賺很多錢，你甚至?xí)凵线@個行業(yè)而放棄原先的理想。
●缺點：自己當(dāng)老板后再去給別人打工時十分痛苦的，而且若你選擇開資本密集型公司虧損的可能性是非常大的。
開網(wǎng)店
信不信由你，在易趣網(wǎng)買古舊紀(jì)念版T恤和舊貨是很有意義的，盡管你把這當(dāng)成興趣，但在這過程中你會學(xué)到很多，你必須找到貨源，考慮怎么做廣告，拍照，應(yīng)對客戶或者做些網(wǎng)頁設(shè)計什么的，你不必對這些事樣樣精通，但如果真那樣的也值得你炫耀了。
●相關(guān)領(lǐng)域：市場營銷（特別是網(wǎng)絡(luò)營銷），界面設(shè)計，攝影，客戶服務(wù)，銷售，網(wǎng)頁設(shè)計（你可以在易趣網(wǎng)店里采用自定義風(fēng)格），采購，以及可以想象的任何消費品。
●優(yōu)點：時間寬松，可能非常有利可圖
●缺點：在郵局排隊，處理很多問題，一個人處理大小事務(wù)，除非你認識供貨商不然你不會對行情很了解。
那么現(xiàn)在準(zhǔn)備好提升你的經(jīng)驗值想著理想前進了嗎？還有什么能阻止你呢？
第四篇：總結(jié)一下java獲取路徑幾種途徑
總結(jié)一下java獲取路徑幾種途徑--
在寫java程序時不可避免要獲取文件的路徑...總結(jié)一下,遺漏的隨時補上
1.可以在servlet的init方法里
String path = getServletContext().getRealPath(“/”);這將獲取web項目的全路徑
例如 :E:eclipseM9workspacetree tree是我web項目的根目錄
2.你也可以隨時在任意的class里調(diào)用
this.getClass().getClassLoader().getResource(“/”).getPath();這將獲取 到classes目錄的全路徑
例如 : E:eclipseM9/workspace/tree/WEB-INF/classes/
這個方法也可以不在web環(huán)境里確定路徑,比較好用
3.request.getContextPath();獲得web根的上下文環(huán)境 如 /tree tree是我的web項目的root context
獲取web項目的全路徑
Java路徑問題最終解決方案
—可定位所有資源的相對路徑尋址
前言
Java的路徑問題，非常難搞。最近的工作涉及到創(chuàng)建和讀取文件的工作，這里我就給大家徹底得解決Java路徑問題。
我編寫了一個方法，比ClassLoader.getResource(String 相對路徑)方法的能力更強。它可以接受“../”這樣的參數(shù)，允許我們用相對路徑來定位classpath外面的資源。這樣，我們就可以使用相對于classpath的路徑，定位所有位置的資源！
Java路徑
Java中使用的路徑，分為兩種：絕對路徑和相對路徑。具體而言，又分為四種：
一、URI形式的絕對資源路徑
如：file:/D:/java/eclipse32/workspace/jbpmtest3/bin/aaa.b URL是URI的特例。URL的前綴/協(xié)議，必須是Java認識的。URL可以打開資源，而URI則不行。URL和URI對象可以互相轉(zhuǎn)換，使用各自的toURI(),toURL()方法即可！
二、本地系統(tǒng)的絕對路徑
D:/java/eclipse32/workspace/jbpmtest3/bin/aaa.b Java.io包中的類，需要使用這種形式的參數(shù)。
但是，它們一般也提供了URI類型的參數(shù)，而URI類型的參數(shù)，接受的是URI樣式的String。因此，通過URI轉(zhuǎn)換，還是可以把URI樣式的絕對路徑用在java.io包中的類中。
三、相對于classpath的相對路徑
如：相對于
file:/D:/java/eclipse32/workspace/jbpmtest3/bin/這個路徑的相對路徑。其中，bin是本項目的classpath。所有的Java源文件編譯后的.class文件復(fù)制到這個目錄中。
四、相對于當(dāng)前用戶目錄的相對路徑
就是相對于System.getProperty(“user.dir”)返回的路徑。
對于一般項目，這是項目的根路徑。對于JavaEE服務(wù)器，這可能是服務(wù)器的某個路徑。這個并沒有統(tǒng)一的規(guī)范！
所以，絕對不要使用“相對于當(dāng)前用戶目錄的相對路徑”。然而：
默認情況下，java.io 包中的類總是根據(jù)當(dāng)前用戶目錄來分析相對路徑名。此目錄由系統(tǒng)屬性 user.dir 指定，通常是 Java 虛擬機的調(diào)用目錄。
這就是說，在使用java.io包中的類時，最好不要使用相對路徑。否則，雖然在J2SE應(yīng)用程序中可能還算正常，但是到了J2EE程序中，一定會出問題！而且這個路徑，在不同的服務(wù)器中都是不同的！
相對路徑最佳實踐
推薦使用相對于當(dāng)前classpath的相對路徑
因此，我們在使用相對路徑時，應(yīng)當(dāng)使用相對于當(dāng)前classpath的相對路徑。
ClassLoader類的getResource(String name),getResourceAsStream(String name)等方法，使用相對于當(dāng)前項目的classpath的相對路徑來查找資源。
讀取屬性文件常用到的ResourceBundle類的getBundle(String path)也是如此。
通過查看ClassLoader類及其相關(guān)類的源代碼，我發(fā)現(xiàn)，它實際上還是使用了URI形式的絕對路徑。通過得到當(dāng)前classpath的URI形式的絕對路徑，構(gòu)建了相對路徑的URI形式的絕對路徑。（這個實際上是猜想，因為JDK內(nèi)部調(diào)用了SUN的源代碼，而這些代碼不屬于JDK，不是開源的。）
相對路徑本質(zhì)上還是絕對路徑
因此，歸根結(jié)底，Java本質(zhì)上只能使用絕對路徑來尋找資源。所有的相對路徑尋找資源的方法，都不過是一些便利方法。不過是API在底層幫助我們構(gòu)建了絕對路徑，從而找到資源的！
得到classpath和當(dāng)前類的絕對路徑的一些方法
下面是一些得到classpath和當(dāng)前類的絕對路徑的一些方法。你可能需要使用其中的一些方法來得到你需要的資源的絕對路徑。
1，F(xiàn)ileTest.class.getResource(“")
得到的是當(dāng)前類FileTest.class文件的URI目錄。不包括自己！如：file:/D:/java/eclipse32/workspace/jbpmtest3/bin/com/test/ 2，F(xiàn)ileTest.class.getResource(”/“)
得到的是當(dāng)前的classpath的絕對URI路徑。
如：file:/D:/java/eclipse32/workspace/jbpmtest3/bin/
3，Thread.currentThread().getContextClassLoader().getResource(”“)
得到的也是當(dāng)前ClassPath的絕對URI路徑。
如：file:/D:/java/eclipse32/workspace/jbpmtest3/bin/
4，F(xiàn)ileTest.class.getClassLoader().getResource(”“)
得到的也是當(dāng)前ClassPath的絕對URI路徑。
如：file:/D:/java/eclipse32/workspace/jbpmtest3/bin/ 5，ClassLoader.getSystemResource(”“)
得到的也是當(dāng)前ClassPath的絕對URI路徑。
如：file:/D:/java/eclipse32/workspace/jbpmtest3/bin/
我推薦使用Thread.currentThread().getContextClassLoader().getResource(”“)來得到當(dāng)前的classpath的絕對路徑的URI表示法。
Web應(yīng)用程序中資源的尋址
上文中說過，當(dāng)前用戶目錄，即相對于System.getProperty(”user.dir“)返回的路徑。
對于JavaEE服務(wù)器，這可能是服務(wù)器的某個路徑，這個并沒有統(tǒng)一的規(guī)范！而不是我們發(fā)布的Web應(yīng)用程序的根目錄！
這樣，在Web應(yīng)用程序中，我們絕對不能使用相對于當(dāng)前用戶目錄的相對路徑。
在Web應(yīng)用程序中，我們一般通過ServletContext.getRealPath(”/“)方法得到Web應(yīng)用程序的根目錄的絕對路徑。這樣，我們只需要提供相對于Web應(yīng)用程序根目錄的路徑，就可以構(gòu)建出定位資源的絕對路徑。這是我們開發(fā)Web應(yīng)用程序時一般所采取的策略。
通用的相對路徑解決辦法容易的解決相對路徑問題。
Java中各種相對路徑非常多，不容易使用，非常容易出錯。因此，我編寫了一個便利方法，幫助更Web應(yīng)用程序中使用JavaSE運行的資源尋址問題
在JavaSE程序中，我們一般使用classpath來作為存放資源的目的地。但是，在Web應(yīng)用程序中，我們一般使用classpath外面的WEB-INF及其子目錄作為資源文件的存放地。
在Web應(yīng)用程序中，我們一般通過ServletContext.getRealPath(”/“)方法得到Web應(yīng)用程序的根目錄的絕對路徑。這樣，我們只需要提供相對于Web應(yīng)用程序根目錄的路徑，就可以構(gòu)建出定位資源的絕對路徑。
Web應(yīng)用程序，可以作為Web應(yīng)用程序進行發(fā)布和運行。但是，我們也常常會以JavaSE的方式來運行Web應(yīng)用程序的某個類的main方法?；蛘撸褂肑Unit測試。這都需要使用JavaSE的方式來運行。
這樣，我們就無法使用ServletContext.getRealPath(”/“)方法得到Web應(yīng)用程序的根目錄的絕對路徑。而JDK提供的ClassLoader類，它的getResource(String name),getResourceAsStream(String name)等方法，使用相對于當(dāng)前項目的classpath的相對路徑來查找資源。
讀取屬性文件常用到的ResourceBundle類的getBundle(String path)也是如此。
它們都只能使用相對路徑來讀取classpath下的資源，無法定位到classpath外面的資源。
Classpath外配置文件讀取問題
如，我們使用測試驅(qū)動開發(fā)的方法，開發(fā)Spring、Hibernate、iBatis等使用配置文件的Web應(yīng)用程序，就會遇到問題。
盡管Spring自己提供了FileSystem（也就是相對于user,dir目錄）來讀取Web配置文件的方法，但是終究不是很方便。而且與Web程序中的代碼使用方式不一致！
至于Hibernate，iBatis就更麻煩了！只有把配置文件移到classpath下，否則根本不可能使用測試驅(qū)動開發(fā)！
這怎么辦？
通用的相對路徑解決辦法”)方法來定位資源。
面對這個問題，我決定編寫一個助手類ClassLoaderUtil，提供一個便利方法[public static URL getExtendResource(String relativePath)]。在Web應(yīng)用程序等一切Java程序中，需要定位classpath外的資源時，都使用這個助手類的便利方法，而不使用Web應(yīng)用程序特有的ServletContext.getRealPath(“/利用classpath的絕對路徑，定位所有資源 這個便利方法的實現(xiàn)原理，就是“利用classpath的絕對路徑，定位所有資源”。
ClassLoader類的getResource(”“)方法能夠得到當(dāng)前classpath的絕對路徑，這是所有Java程序都擁有的能力，具有最大的適應(yīng)性！
而目前的JDK提供的ClassLoader類的getResource(String 相對路徑)方法，只能接受一般的相對路徑。這樣，使用ClassLoader類的getResource(String 相對路徑)方法就只能定位到classpath下的資源。
如果，它能夠接受“../”這樣的參數(shù)，允許我們用相對路徑來定位classpath外面的資源，那么我們就可以定位位置的資源！
當(dāng)然，我無法修改ClassLoader類的這個方法，于是，我編寫了一個助手類ClassLoaderUtil類，提供了[public static URL getExtendResource(String relativePath)]這個方法。它能夠接受帶有“../”符號的相對路徑，實現(xiàn)了自由尋找資源的功能。
通過相對classpath路徑實現(xiàn)自由尋找資源的助手類的源代碼：
import java.io.IOException;import java.io.InputStream;
import java.net.MalformedURLException;import java.net.URL;import java.util.Properties;
import org.apache.commons.logging.Log;import org.apache.commons.logging.LogFactory;
/**
*@author沈東良shendl_s@hotmail.com
*Nov29,2006 10:34:34AM
*用來加載類，ｃｌａｓｓｐａｔｈ下的資源文件，屬性文件等。
*getExtendResource(StringrelativePath)方法，可以使用../符號來加載classpath外部的資源。
*/
publicclass ClassLoaderUtil {
privatestatic Log log=LogFactory.getLog(ClassLoaderUtil.class);
/**
*Thread.currentThread().getContextClassLoader().getResource(”“)
*/
/**
*加載Java類。使用全限定類名
*@paramclassName
*@return
*/
publicstatic Class loadClass(String className){
try {
return getClassLoader().loadClass(className);
} catch(ClassNotFoundException e){
thrownew RuntimeException(”class not found '“+className+”'“, e);
}
}
/**
*得到類加載器
*@return
*/
publicstatic ClassLoader getClassLoader(){
return ClassLoaderUtil.class.getClassLoader();
}
/**
*提供相對于classpath的資源路徑，返回文件的輸入流
*@paramrelativePath必須傳遞資源的相對路徑。是相對于classpath的路徑。如果需要查找classpath外部的資源，需要使用../來查找
*@return 文件輸入流
*@throwsIOException
*@throwsMalformedURLException
*/
publicstatic InputStream getStream(String relativePath)throws MalformedURLException, IOException {
if(!relativePath.contains(”../“)){
return getClassLoader().getResourceAsStream(relativePath);
}else{
return ClassLoaderUtil.getStreamByExtendResource(relativePath);
}
}
/**
*
*@paramurl
*@return
*@throwsIOException
*/
publicstatic InputStream getStream(URL url)throws IOException{
if(url!=null){
return url.openStream();
}else{
returnnull;
}
}
/**
*
*@paramrelativePath必須傳遞資源的相對路徑。是相對于classpath的路徑。如果需要查找classpath外部的資源，需要使用../來查找
*@return
*@throwsMalformedURLException
*@throwsIOException
*/
publicstatic InputStream getStreamByExtendResource(String relativePath)throws MalformedURLException, IOException{
return ClassLoaderUtil.getStream(ClassLoaderUtil.getExtendResource(relativePath));
}
/**
*提供相對于classpath的資源路徑，返回屬性對象，它是一個散列表
*@paramresource
*@return
*/
publicstatic Properties getProperties(String resource){
Properties properties = new Properties();
try {
properties.load(getStream(resource));
} catch(IOException e){
thrownew RuntimeException(”couldn't load properties file '“+resource+”'“, e);
}
return properties;
}
/**
*得到本Class所在的ClassLoader的Classpat的絕對路徑。
*URL形式的 *@return
*/
publicstatic String getAbsolutePathOfClassLoaderClassPath(){
ClassLoaderUtil.log.info(ClassLoaderUtil.getClassLoader().getResource(”“).toString());
return ClassLoaderUtil.getClassLoader().getResource(”“).toString();
}
/**
*
*@paramrelativePath 必須傳遞資源的相對路徑。是相對于classpath的路徑。如果需要查找classpath外部的資源，需要使用../來查找
*@return資源的絕對URL
*@throwsMalformedURLException
*/
publicstatic URL getExtendResource(String relativePath)throws MalformedURLException{
ClassLoaderUtil.log.info(”傳入的相對路徑：“+relativePath);
//ClassLoaderUtil.log.info(Integer.valueOf(relativePath.indexOf(”../“)));
if(!relativePath.contains(”../“)){
return ClassLoaderUtil.getResource(relativePath);
}
String classPathAbsolutePath=ClassLoaderUtil.getAbsolutePathOfClassLoaderClassPath();
if(relativePath.substring(0, 1).equals(”/“)){
relativePath=relativePath.substring(1);
}
ClassLoaderUtil.log.info(Integer.valueOf(relativePath.lastIndexOf(”../“)));
String wildcardString=relativePath.substring(0,relativePath.lastIndexOf(”../“)+3);
relativePath=relativePath.substring(relativePath.lastIndexOf(”../“)+3);
int containSum=ClassLoaderUtil.containSum(wildcardString, ”../“);
classPathAbsolutePath= ClassLoaderUtil.cutLastString(classPathAbsolutePath, ”/“, containSum);
String resourceAbsolutePath=classPathAbsolutePath+relativePath;
ClassLoaderUtil.log.info(”絕對路徑：“+resourceAbsolutePath);
URL resourceAbsoluteURL=new URL(resourceAbsolutePath);
return resourceAbsoluteURL;
}
/**
*
*@paramsource
*@paramdest
*@return
*/
privatestaticint containSum(String source,String dest){
int containSum=0;
int destLength=dest.length();
while(source.contains(dest)){
containSum=containSum+1;
source=source.substring(destLength);
}
return containSum;
}
/**
*
*@paramsource
*@paramdest
*@paramnum
*@return
*/
privatestatic String cutLastString(String source,String dest,int num){
// String cutSource=null;
for(int i=0;i
source=source.substring(0, source.lastIndexOf(dest, source.length()-2)+1);
}
return source;
}
/**
*
*@paramresource
*@return
*/
publicstatic URL getResource(String resource){
ClassLoaderUtil.log.info(”傳入的相對于classpath的路徑：“+resource);
return ClassLoaderUtil.getClassLoader().getResource(resource);
}
/**
*@paramargs
*@throwsMalformedURLException
*/
publicstaticvoid main(String[] args)throws MalformedURLException {
//ClassLoaderUtil.getExtendResource(”../spring/dao.xml“);
//ClassLoaderUtil.getExtendResource(”../../../src/log4j.properties“);
ClassLoaderUtil.getExtendResource(”log4j.properties“);
System.out.println(ClassLoaderUtil.getClassLoader().getResource(”log4j.properties").toString());
}
}
第五篇：C#實習(xí)總結(jié)
現(xiàn)在的社會日新月異，科技飛速發(fā)展，但是隨之而來的環(huán)境問題也日益嚴(yán)重，當(dāng)然這也有很多其他諸如人口、能源等因素，不過這些讓人們越來越重視綠色產(chǎn)業(yè)，而軟件就是首當(dāng)其沖的一個。我積極參加了學(xué)校組織的軟件實習(xí)，主要是對.Net方面的實訓(xùn)和實戰(zhàn)，一方面想要繼續(xù)深造之前在大學(xué)里面學(xué)習(xí)的軟件方面的知識，另一方面，也是為了自己的職業(yè)規(guī)劃，說直接點，就是以后找份好工作。雖然實訓(xùn)中時間安排有點緊，但很充實，學(xué)到了很多之前在大學(xué)課堂上沒有學(xué)到的知識，可以說我從這次實訓(xùn)中的收獲很大。
對于計算機編程，我可以說從高中就開始接觸，大學(xué)從?？崎_始一直學(xué)習(xí)的都是軟件開發(fā)的專業(yè)，學(xué)過C#、Java，學(xué)過開發(fā)，也學(xué)過測試。但是這次實訓(xùn)讓我體會了和之前完全不同的學(xué)習(xí)感受，不僅是時間安排、或者說效率還是教學(xué)授課的方式上，都是和大學(xué)課堂完全不同的，不是一節(jié)課講一點，也不是一點一點教給你，這個實訓(xùn)中更多的是培養(yǎng)我們獨立動手解決實際問題的能力，分析考慮問題的方法思路，讓我們真正成長起來。
學(xué)校為我們提供了良好的學(xué)習(xí)的平臺，提供了好工作的面試機會。我們覺得我們更應(yīng)該充分利用資源，珍惜機會，努力學(xué)習(xí)，不斷地給自己“充電”，這樣才能不斷的開拓進取，勇于創(chuàng)新，才不至于被社會淘汰。
這次實習(xí)中，我們主要有S0、S1、S2三個階段，S0階段主要是自學(xué)C#基礎(chǔ)知識，S1階段是在老師的指導(dǎo)下學(xué)習(xí)C#基礎(chǔ)編程、C#桌面應(yīng)用開發(fā)、C#數(shù)據(jù)庫應(yīng)用開發(fā)、C#網(wǎng)絡(luò)應(yīng)用開發(fā)、軟件測試和軟件工程幾個方面的技術(shù)方面的課程，S2階段則是進入項目實戰(zhàn)，做實際項目來進行鞏固和總結(jié)。整個過程中，還有穿插了職業(yè)素養(yǎng)課和英語口語課，學(xué)技術(shù)的同時，我們也注重職業(yè)素養(yǎng)的培養(yǎng)和英語口語的鍛煉。
到目前為止，我們實習(xí)的主要成果有（按時間順序）：Point24(24點游戲求解小程序)、HandsUp（舉手游戲模擬小程序）、SimpleCalculator（簡單計算器）、GottaU（捕捉鼠標(biāo)小游戲）、TypeGame（打字小游戲）、WebBrowser（簡易網(wǎng)絡(luò)瀏覽器）、Checker（單機對戰(zhàn)跳棋小游戲）、MDITextEditor（多文檔界面文本編輯器）、FileManager（文件管理器）、SimpleMediaPlayer（簡單媒體播放器）等，這些小程序或是項目，雖然和市面的那些軟件比起來，在功能強大、界面美觀、Bug稀少等方面都有欠缺，但是都是實打?qū)嵉?，我們自己動腦、動手做出來的，當(dāng)然在做的過程中遇到了不少困難、挫折，但是正因為這些困難和挫折，我們才真正學(xué)到了知識和技術(shù)。更值得注意的則是，在老師帶領(lǐng)我們做項目的過程中，我們從老師的言傳身教中學(xué)到了很多很多編程思想、解決問題的方法思路等各種“無形”的知識。
眾多收獲之中，讓我感觸頗深的，則是老師給我們介紹的“10-90”原則和“Quality-Client-Cost”原則?！?0-90”原則的意思是，我們通常都是花10%的代價就可以完成一件事或者一個項目的90%，而剩下的10%，卻需要我們花費90%的金錢、精力等各種代價，能不能做到這最后的10%，往往是衡量一個人或者一家公司很重要的一個原則。而且這個原則還是可以嵌套的，最后10%的部分中，也可以再分成90%和10%，同樣是開始的90%需要10%的代價，最后的10%需要90%的代價。這個原則不僅適用于做軟件、做項目、做公司，其實人生中做人也是如此，很多時候最后的10%是很重要的一把標(biāo)尺。雖然不能說這個原則放之四海而皆準(zhǔn)，但是確實是適用于很多地方、很多方面，讓我獲益良多。“Quality-Client-Cost”原則講的則是做軟件或是做軟件公司的一個原則，就是質(zhì)量一定要放在第一位，客戶在第二位。我自己原本心目中對這三項的排序是Client-Quality-Cost”，但是老師的講解點醒了我，最具有說服力的例子，就是像微軟這樣的大公司，都是Quality第一的，他們寧可花費多一些，價格貴一些，但是一定把產(chǎn)品盡善盡美。這個原則同樣可以用在人生中，Quality就是人品、品德、素質(zhì)，Client是朋友、客戶、親人，我們當(dāng)然應(yīng)該把個人的品格放在第一位。這些都屬于這次實習(xí)中，我在技術(shù)以外的收獲。
另外在實習(xí)還有職業(yè)素養(yǎng)課中，也學(xué)到了很多其他在今后的工作中，要注意的東西，首先要有團隊合作精神，現(xiàn)金的大中型軟件的編寫，分工越來越細，這樣在開發(fā)、測試的過程中，團隊的合作、成員間的交流就變得尤為重要，是決定效率的重要因素；要學(xué)會獨立解決問題，工作不比在學(xué)校學(xué)習(xí)，遇到的各種實際問題不會有老師專門幫助解決，自己獨立分析、解決問題的能力就變得極其重要；要有創(chuàng)新精神，在工作和學(xué)習(xí)中，如果只是一味的模仿、學(xué)習(xí)，那就永遠不會真正得學(xué)得得心應(yīng)手、融會貫通，必須自己去實踐，在實踐中創(chuàng)新，這樣才能把學(xué)來的，變成自己的；要有耐心，學(xué)會自我規(guī)劃和管控，耐心自是不必多說，有耐心才能把事情仔細做好，而公司的管理制度和學(xué)校根本上的不同，使得自我規(guī)劃和管控就成了能否按時圓滿完成任務(wù)的很重要的條件。
通過這次實習(xí)，我在個人素質(zhì)方面有較大的提高，不僅是在C#的技術(shù)方面，還包括面對、分析和處理問題的思路、能力，思維的創(chuàng)造性和全面性，交流和溝通能力，英語口語水平，同時也克服了一些自己的缺點，獲得很大進步。
總的來說，這次實習(xí)對我有很大意義，不僅鞏固和實踐了之前在大學(xué)課堂上學(xué)到的各種知識，擴充了自己對軟件技術(shù)方面的知識儲備，同時也給了我很大的成就感，增強了我的自信。并不是說因為我做成的很難的程序，或者做出來的軟件很強很完善，但都是自己認真完成的，過程中有遇到各種困難和挫折，但是經(jīng)
過網(wǎng)上查資料、小組討論、向老師請教等幾種途徑，最終都克服了，當(dāng)最終自己完成時，總會有一些成就感。
此外，我還人知到在以后的工作和學(xué)習(xí)中，不僅要努力學(xué)習(xí)和鍛煉專業(yè)技能知識，包括C#技術(shù)、算法技巧、MVC模式框架的開發(fā)、中間技術(shù)等等，而且也要注意讓自己興趣廣泛起來，拓寬自己的知識面，多積累各種知識，這不僅對以后的軟件開發(fā)工作有一定好處，對自身的個人修養(yǎng)的提升也是大有裨益。
社會的競爭是激烈的，我想我們應(yīng)該好好把握住大學(xué)學(xué)習(xí)的時間，充實、完善自我，掌握更多的專業(yè)知識，加強實踐和設(shè)計能力，同時也注意全面發(fā)展，這樣更有利于將來的發(fā)展，在自己的專業(yè)領(lǐng)域有所作為。
點擊咨詢 