Unity3D中的C#程式設計初級

一、前言

這篇文章主要是給零基礎想要Unity入門的關於C#程式設計的一些意見

二、參考文章

unity中的C#程式設計-零基礎（Unity2017）

三、正文

1、支援Unity3D的程式語言
2、程式設計工具（IDE）
3、建立C#程式碼
4、場景的儲存和指令碼的儲存
5、關於日誌輸出（指控制輸出，其中Log有三類：正常、警告、錯誤輸出）
6、變數與常量
7、方法的定義和呼叫
8、方法中的引數，返回值
9、類的定義
10、列舉型別：
11、元件的建立與使用

1、支援Unity3D的程式語言

C#、JavaScript、UnityScript
先說C#與JavaScript，因為JavaScript是動態的，肯定不如編譯的C#好，但是JavaScript更快捷一點， JavaScript適合個人開發，敏捷快速。c#適合公司開發，規範嚴謹。
然後說說這個C#和Unity內建的UnityScript
UnityScript脫胎於.Net平臺的第三方語言Boo，差距可能是全方位，立體式的。社群支援，程式碼維護，甚至是編譯出來的CIL程式碼質量都可能有很大的差距。另外從Unity5.0版本開始就會停止對Boo的文件支援。同時消失的還有從選單建立Boo指令碼的選項“Create Boo Script”。從U3D團隊對Boo的態度，也可以窺見和Boo聯絡密切的UnityScript未來的走勢。
2、程式設計工具（IDE）

Visual Studio 全系列
Visual Studio Code
Xamarin Studio
這個主要是在Mac上使用的IDE，因為在Mac上不能使用VS，MonoDevelop也不能輸入中文，就挺難受的，就可以使用XamarinStudio，關於這個IDE使用可以參考這篇文章。http://www.xuanyusong.com/archives/3545
MonoDevelop
Unity3D內建的編輯器，操作感覺一般，但是勝在方便，在安裝Unity3D的時候就可以一起安裝了，不用另外安裝IDE了
JetBrains Rider
一款強大的強大的跨平臺C#編輯器，官網https://www.jetbrains.com/zh/dotnet/promo/unity/
3、建立C#程式碼

在工程目錄下右鍵點選，選擇Create->C# Script

在任意物件上，點選Add Component->New Script

這個是建立成功後的初始指令碼的樣子

4、場景的儲存和指令碼的儲存

快捷鍵F2 點選場景名或者指令碼名字可以重新命名
快捷鍵Ctrl+S 快速儲存場景或者儲存指令碼
狀態列中顯示“*”號的都是未儲存的

編輯器意外奔潰，場景未來得及儲存？
這時可以開啟工程目錄，找到/Temp/_Backupscenes/資料夾，可以看到有字尾名為.backup的檔案，將該檔案的字尾名改為.unity拖拽到專案檢視，即可還原編輯器崩潰前的場景。

5、關於日誌輸出（指控制輸出，其中Log有三類：正常、警告、錯誤輸出）

print
是MonoBehaviour的一個成員，必須繼承MonoBehaviour才能使用，通過反編譯可以看到print的方法為
public static void print(object message)
{
Debug.Log(message);
}
說明print方法還是通過Debug.Log實現的，print就是Debug.Log的一個簡單封裝。

Debug.Log
輸出log資訊，可以在執行的時候檢視關鍵資料的變化

Debug.LogWarning
輸出警告資訊

Debug.LogError
輸出錯誤資訊

6、變數與常量

因為兩個比較相似，就放一塊說

變數
一個變數只不過是一個供程式操作的儲存區的名字。在 C# 中，每個變數都有一個特定的型別，型別決定了變數的記憶體大小和佈局。範圍內的值可以儲存在記憶體中，可以對變數進行一系列操作。

常量
常量是固定值，程式執行期間不會改變。常量可以是任何基本資料型別，比如整數常量、浮點常量、字元常量或者字串常量，還有列舉常量。
常量可以被當作常規的變數，只是它們的值在定義後不能被修改。

變數的型別

型別   舉例
整數型別   sbyte、byte、short、ushort、int、uint、long、ulong 和 char
浮點型   float 和 double
十進位制型別   decimal
布林型別   true 或 false 值，指定的值
空型別   可為空值的資料型別
其他變數型別   列舉enum，引用型別變數class，結構體型別struct
變數的定義
int i, j, k;
char c, ch;
float f, salary;
double d;

變數的初始化
int d = 3, f = 5; /* 初始化 d 和 f. */
byte z = 22; /* 初始化 z. */
double pi = 3.14159; /* 宣告 pi 的近似值 */
char x = 'x'; /* 變數 x 的值為 'x' */

例項

namespace VariableDefinition
{
class Program
{
static void Main(string[] args)
{
short a;
int b ;
double c; /* 實際初始化 */
a = 10;
b = 20;
c = a + b;
Console.WriteLine("a = {0}, b = {1}, c = {2}", a, b, c);
Console.ReadLine();
}
}
}

編譯執行結果：

a = 10, b = 20, c = 30
1
常量的定義
const double pi = 3.14159; // 常量宣告
1
常量的型別
整數常量

整數常量可以是十進位制、八進位制或十六進位制的常量。字首指定基數：0x 或 0X 表示十六進位制，0 表示八進位制，沒有字首則表示十進位制。

整數常量也可以有字尾，可以是 U 和 L 的組合，其中，U 和 L 分別表示 unsigned 和 long。字尾可以是大寫或者小寫，多個字尾以任意順序進行組合。

212 /* 合法 */
215u /* 合法 */
0xFeeL /* 合法 */
078 /* 非法：8 不是一個八進位制數字 */
032UU /* 非法：不能重複字尾 */
85 /* 十進位制 */
0213 /* 八進位制 */
0x4b /* 十六進位制 */
30 /* int */
30u /* 無符號 int */
30l /* long */
30ul /* 無符號 long */

浮點常量

一個浮點常量是由整數部分、小數點、小數部分和指數部分組成。您可以使用小數形式或者指數形式來表示浮點常量。
這裡有一些浮點常量的例項：

3.14159 /* 合法 */
314159E-5L /* 合法 */
510E /* 非法：不完全指數 */
210f /* 非法：沒有小數或指數 */
.e55 /* 非法：缺少整數或小數 */

使用小數形式表示時，必須包含小數點、指數或同時包含兩者。使用指數形式表示時，必須包含整數部分、小數部分或同時包含兩者。有符號的指數是用 e 或 E 表示的。

字元常量

字元常量是括在單引號裡，例如，’x’，且可儲存在一個簡單的字元型別變數中。一個字元常量可以是一個普通字元（例如 ‘x’）、一個轉義序列（例如 ‘\t’）或者一個通用字元（例如 ‘\u02C0’）。

在 C# 中有一些特定的字元，當它們的前面帶有反斜槓時有特殊的意義，可用於表示換行符（\n）或製表符 tab（\t）。在這裡，列出一些轉義序列碼：

轉義序列   含義
\\   \ 字元
\’   ’ 字元
\”   ” 字元
\?   ? 字元
\a   Alert 或 bell
\b   退格鍵（Backspace）
\f   換頁符（Form feed）
\n   換行符（Newline）
\r   回車
\t   水平製表符 tab
\v   垂直製表符 tab
\ooo   一到三位的八進位制數
\xhh …   一個或多個數字的十六進位制數
例項：

namespace EscapeChar
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Hello\tWorld\n\n");
Console.ReadLine();
}
}
}

編譯執行結果：

Hello World
1
字串常量

字串常量是括在雙引號 “” 裡，或者是括在 @”” 裡。字串常量包含的字元與字元常量相似，可以是：普通字元、轉義序列和通用字元

使用字串常量時，可以把一個很長的行拆成多個行，可以使用空格分隔各個部分。

這裡是一些字串常量的例項。下面所列的各種形式表示相同的字串。

string a = "hello, world"; // hello, world
string b = @"hello, world"; // hello, world
string c = "hello \t world"; // hello world
string d = @"hello \t world"; // hello \t world
string e = "Joe said \"Hello\" to me"; // Joe said "Hello" to me
string f = @"Joe said ""Hello"" to me"; // Joe said "Hello" to me
string g = "\\\\server\\share\\file.txt"; // \\server\share\file.txt
string h = @"\\server\share\file.txt"; // \\server\share\file.txt
string i = "one\r\ntwo\r\nthree";
string j = @"one
two
three";

例項：

using System;

namespace DeclaringConstants
{
class Program
{
static void Main(string[] args)
{
const double pi = 3.14159; // 常量宣告
double r;
Console.WriteLine("Enter Radius: ");
r = Convert.ToDouble(Console.ReadLine());
double areaCircle = pi * r * r;
Console.WriteLine("Radius: {0}, Area: {1}", r, areaCircle);
Console.ReadLine();
}
}
}

編譯執行結果：

Enter Radius:

Radius: 3, Area: 28.27431

7、方法的定義和呼叫

方法的定義
語法如下：
<Access Specifier> <Return Type> <Method Name>(Parameter List)
{
Method Body
}

下面是方法的各個元素：

Access Specifier：訪問修飾符，這個決定了變數或方法對於另一個類的可見性。
Return type：返回型別，一個方法可以返回一個值。返回型別是方法返回的值的資料型別。如果方法不返回任何值，則返回型別為 void。
Method name：方法名稱，是一個唯一的識別符號，且是大小寫敏感的。它不能與類中宣告的其他識別符號相同。
Parameter list：引數列表，使用圓括號括起來，該引數是用來傳遞和接收方法的資料。引數列表是指方法的引數型別、順序和數量。引數是可選的，也就是說，一個方法可能不包含引數。
Method body：方法主體，包含了完成任務所需的指令集。
例項：
下面的程式碼片段顯示一個函式 FindMax，它接受兩個整數值，並返回兩個中的較大值。它有 public 訪問修飾符，所以它可以使用類的例項從類的外部進行訪問。

class NumberManipulator
{
public int FindMax(int num1, int num2)
{
/* 區域性變數宣告 */
int result;

if (num1 > num2)
result = num1;
else
result = num2;

return result;
}
...
}

方法的呼叫
using System;

namespace CalculatorApplication
{
class NumberManipulator
{
public int FindMax(int num1, int num2)
{
/* 區域性變數宣告 */
int result;

if (num1 > num2)
result = num1;
else
result = num2;

return result;
}
static void Main(string[] args)
{
/* 區域性變數定義 */
int a = 100;
int b = 200;
int ret;
NumberManipulator n = new NumberManipulator();

//呼叫 FindMax 方法
ret = n.FindMax(a, b);
Console.WriteLine("最大值是： {0}", ret );
Console.ReadLine();
}
}
}

編譯執行後的結果：

最大值是： 200
1
您也可以使用類的例項從另一個類中呼叫其他類的公有方法。例如，方法 FindMax 屬於 NumberManipulator 類，您可以從另一個類 Test 中呼叫它。

using System;

namespace CalculatorApplication
{
class NumberManipulator
{
public int FindMax(int num1, int num2)
{
/* 區域性變數宣告 */
int result;

if (num1 > num2)
result = num1;
else
result = num2;

return result;
}
}
class Test
{
static void Main(string[] args)
{
/* 區域性變數定義 */
int a = 100;
int b = 200;
int ret;
NumberManipulator n = new NumberManipulator();
//呼叫 FindMax 方法
ret = n.FindMax(a, b);
Console.WriteLine("最大值是： {0}", ret );
Console.ReadLine();

}
}
}

編譯執行的結果：

最大值是： 200
1
遞迴方法的呼叫
一個方法可以自我呼叫。這就是所謂的遞迴。下面的例項使用遞迴函式計算一個數的階乘：
using System;

namespace CalculatorApplication
{
class NumberManipulator
{
public int factorial(int num)
{
/* 區域性變數定義 */
int result;

if (num == 1)
{
return 1;
}
else
{
result = factorial(num - 1) * num;
return result;
}
}

static void Main(string[] args)
{
NumberManipulator n = new NumberManipulator();
//呼叫 factorial 方法
Console.WriteLine("6 的階乘是： {0}", n.factorial(6));
Console.WriteLine("7 的階乘是： {0}", n.factorial(7));
Console.WriteLine("8 的階乘是： {0}", n.factorial(8));
Console.ReadLine();

}
}
}

編譯執行後的結果：

6 的階乘是： 720
7 的階乘是： 5040
8 的階乘是： 40320

引數傳遞
當呼叫帶有引數的方法時，您需要向方法傳遞引數。在 C# 中，有三種向方法傳遞引數的方式：
方式   描述
值引數   這種方式複製引數的實際值給函式的形式引數，實參和形參使用的是兩個不同記憶體中的值。在這種情況下，當形參的值發生改變時，不會影響實參的值，從而保證了實引數據的安全。
引用引數   這種方式複製引數的記憶體位置的引用給形式引數。這意味著，當形參的值發生改變時，同時也改變實參的值。
輸出引數   這種方式可以返回多個值。
按值引數傳遞
這是引數傳遞的預設方式。在這種方式下，當呼叫一個方法時，會為每個值引數建立一個新的儲存位置。
實際引數的值會複製給形參，實參和形參使用的是兩個不同記憶體中的值。所以，當形參的值發生改變時，不會影響實參的值，從而保證了實引數據的安全。下面的例項演示了這個概念：

using System;
namespace CalculatorApplication
{
class NumberManipulator
{
public void swap(int x, int y)
{
int temp;

temp = x; /* 儲存 x 的值 */
x = y; /* 把 y 賦值給 x */
y = temp; /* 把 temp 賦值給 y */
}

static void Main(string[] args)
{
NumberManipulator n = new NumberManipulator();
/* 區域性變數定義 */
int a = 100;
int b = 200;

Console.WriteLine("在交換之前，a 的值： {0}", a);
Console.WriteLine("在交換之前，b 的值： {0}", b);

/* 呼叫函式來交換值 */
n.swap(a, b);

Console.WriteLine("在交換之後，a 的值： {0}", a);
Console.WriteLine("在交換之後，b 的值： {0}", b);

Console.ReadLine();
}
}
}

編譯執行後的結果：

在交換之前，a 的值：100
在交換之前，b 的值：200
在交換之後，a 的值：200
在交換之後，b 的值：100

結果表明，swap 函式內的值改變了，且這個改變可以在 Main 函式中反映出來。

按輸出傳遞引數
return 語句可用於只從函式中返回一個值。但是，可以使用輸出引數來從函式中返回兩個值。輸出引數會把方法輸出的資料賦給自己，其他方面與引用引數相似。

下面的例項演示了這點：

using System;

namespace CalculatorApplication
{
class NumberManipulator
{
public void getValue(out int x )
{
int temp = 5;
x = temp;
}

static void Main(string[] args)
{
NumberManipulator n = new NumberManipulator();
/* 區域性變數定義 */
int a = 100;

Console.WriteLine("在方法呼叫之前，a 的值： {0}", a);

/* 呼叫函式來獲取值 */
n.getValue(out a);

Console.WriteLine("在方法呼叫之後，a 的值： {0}", a);
Console.ReadLine();

}
}
}

編譯執行後的結果：

在方法呼叫之前，a 的值： 100
在方法呼叫之後，a 的值： 5
1
2
提供給輸出引數的變數不需要賦值。當需要從一個引數沒有指定初始值的方法中返回值時，輸出引數特別有用。請看下面的例項，來理解這一點

using System;

namespace CalculatorApplication
{
class NumberManipulator
{
public void getValues(out int x, out int y )
{
Console.WriteLine("請輸入第一個值： ");
x = Convert.ToInt32(Console.ReadLine());
Console.WriteLine("請輸入第二個值： ");
y = Convert.ToInt32(Console.ReadLine());
}

static void Main(string[] args)
{
NumberManipulator n = new NumberManipulator();
/* 區域性變數定義 */
int a , b;

/* 呼叫函式來獲取值 */
n.getValues(out a, out b);

Console.WriteLine("在方法呼叫之後，a 的值： {0}", a);
Console.WriteLine("在方法呼叫之後，b 的值： {0}", b);
Console.ReadLine();
}
}
}

編譯執行後的結果：

請輸入第一個值：
7
請輸入第二個值：
8
在方法呼叫之後，a 的值： 7
在方法呼叫之後，b 的值： 8

8、方法中的引數，返回值

方法中引數的型別有三種
in型引數

int 型引數通過值傳遞的方式將數值傳入方法中，即我們在Java中常見的方法。

ref型引數

該種型別的引數傳遞變數地址給方法（引用傳遞），傳遞前變數必須初始化。

該型別與out型的區別在與：

1）.ref 型傳遞變數前，變數必須初始化，否則編譯器會報錯, 而 out 型則不需要初始化
2）.ref 型傳遞變數，數值可以傳入方法中，而 out 型無法將資料傳入方法中。換而言之，ref 型有進有出，out 型只出不進。

out 型引數

與 ref 型類似，僅用於傳回結果。

注意：

1). out型資料在方法中必須要賦值，否則編譯器會報錯。

eg:如下圖若將程式碼中的sum1方法的方法體

改為 a+=b; 則編譯器會報錯。原因：out 型只出不進，在沒給 a 賦值前是不能使用的

改為 b+=b+2; 編譯器也會報錯。原因：out 型資料在方法中必須要賦值。

2). 過載方法時若兩個方法的區別僅限於一個引數型別為ref 另一個方法中為out，編譯器會報錯

eg：若將下面的程式碼中將方法名 vsum1 改為 sum（或者將方法名 sum 改為 sum1），編譯器會報錯。

Error 1 Cannot define overloaded method ‘sum’ because it differs from another method only on ref and out

原因：引數型別區別僅限於為 ref 與為 out 時，若過載對編譯器而言兩者的後設資料表示完全相同。

class C
{
//1. in型引數
public void sum(int a, int b) {
a += b;
}
//2. ref型引數
public void sum(ref int a, int b)
{
a += b;
}
//3. out型引數
public void sum1(out int a, int b)
{
a = b+2;
}
public static void Main(string[] args)
{
C c = new C();
int a = 1, b = 2;
c.sum(a,b);
Console.WriteLine("a:{0}", a);
a = 1; b = 2;
c.sum(ref a, b);
Console.WriteLine("ref a:{0}", a);
a = 1; b = 2;
c.sum1(out a, b);
Console.WriteLine("out a:{0}", a);
}
}

輸出結果：

從程式碼也可以看出，int 型引數為值傳遞，所以當將變數 a 傳入方法時，變數 a 的值並不會發生變化。而 ref 型引數，由於是引用傳遞，將變數的值和地址都傳入方法中故變數值改變。out 型無法將變數的值傳入。但可以將變數的地址傳入併為該地址上的變數賦值。

按值傳遞引數的問題：
為什麼即使在函式內改變了值，值也沒有發生任何的變化呢？

在交換之前，a 的值：100
在交換之前，b 的值：200
在交換之後，a 的值：100
在交換之後，b 的值：200
1
2
3
4
解析：

呼叫一個方法時相當於複製一個物件到新分配的記憶體中，方法完畢物件也就del了，兩個變數是不同的兩個地址，a只不過是棧裡的臨時變數而已，和主函式裡的變數沒有關係，因此不會改變b的值。

而指標和引用直接訪問記憶體地址，故直接修改所指向的物件，兩者指向同一變數。

9、類的定義

定義一個類的時候相當於定義了一個資料型別的藍圖，本身沒有定義任何資料，但是它定義了類的名稱意味著什麼，就是說可以在這個類由什麼物件組成，以及在這個物件上可以執行什麼操作

累的定義
關鍵字 class 後跟類的名稱，類的主體包含在一段花括號中{}，下面是類的一般形式
<access specifier> class class_name
{
// member variables
<access specifier> <data type> variable1;
<access specifier> <data type> variable2;
...
<access specifier> <data type> variableN;
// member methods
<access specifier> <return type> method1(parameter_list)
{
// method body
}
<access specifier> <return type> method2(parameter_list)
{
// method body
}
...
<access specifier> <return type> methodN(parameter_list)
{
// method body
}
}

請注意：

訪問識別符號 <access specifier> 指定了對類及其成員的訪問規則。如果沒有指定，則使用預設的訪問識別符號。類的預設訪問識別符號是 internal，成員的預設訪問識別符號是 private。
資料型別 <data type> 指定了變數的型別，返回型別 <return type> 指定了返回的方法返回的資料型別。
如果要訪問類的成員，你要使用點（.）運算子。
點運算子連結了物件的名稱和成員的名稱。
下面的例項說明了目前為止所討論的概念：

using System;
namespace BoxApplication
{
class Box
{
public double length; // 長度
public double breadth; // 寬度
public double height; // 高度
}
class Boxtester
{
static void Main(string[] args)
{
Box Box1 = new Box(); // 宣告 Box1，型別為 Box
Box Box2 = new Box(); // 宣告 Box2，型別為 Box
double volume = 0.0; // 體積

// Box1 詳述
Box1.height = 5.0;
Box1.length = 6.0;
Box1.breadth = 7.0;

// Box2 詳述
Box2.height = 10.0;
Box2.length = 12.0;
Box2.breadth = 13.0;

// Box1 的體積
volume = Box1.height * Box1.length * Box1.breadth;
Console.WriteLine("Box1 的體積： {0}", volume);

// Box2 的體積
volume = Box2.height * Box2.length * Box2.breadth;
Console.WriteLine("Box2 的體積： {0}", volume);
Console.ReadKey();
}
}
}

編譯執行後的結果：

Box1 的體積： 210
Box2 的體積： 1560
1
2
成員函式和封裝
類的成員函式是一個在類定義中有它的定義或原型的函式，就像其他變數一樣。作為類的一個成員，它能在類的任何物件上操作，且能訪問該物件的類的所有成員。
成員變數是物件的屬性（從設計角度），且它們保持私有來實現封裝。這些變數只能使用公共成員函式來訪問。

讓我們使用上面的概念來設定和獲取一個類中不同的類成員的值：

using System;
namespace BoxApplication
{
class Box
{
private double length; // 長度
private double breadth; // 寬度
private double height; // 高度
public void setLength( double len )
{
length = len;
}

public void setBreadth( double bre )
{
breadth = bre;
}

public void setHeight( double hei )
{
height = hei;
}
public double getVolume()
{
return length * breadth * height;
}
}
class Boxtester
{
static void Main(string[] args)
{
Box Box1 = new Box(); // 宣告 Box1，型別為 Box
Box Box2 = new Box(); // 宣告 Box2，型別為 Box
double volume; // 體積

// Box1 詳述
Box1.setLength(6.0);
Box1.setBreadth(7.0);
Box1.setHeight(5.0);

// Box2 詳述
Box2.setLength(12.0);
Box2.setBreadth(13.0);
Box2.setHeight(10.0);

// Box1 的體積
volume = Box1.getVolume();
Console.WriteLine("Box1 的體積： {0}" ,volume);

// Box2 的體積
volume = Box2.getVolume();
Console.WriteLine("Box2 的體積： {0}", volume);

Console.ReadKey();
}
}
}

編譯執行後的結果：

Box1 的體積： 210
Box2 的體積： 1560
1
2
C# 中的建構函式
類的建構函式是類的一個特殊的成員函式，當建立類的新物件時執行。
建構函式的名稱與類的名稱完全相同，它沒有任何返回型別。

下面的例項說明了建構函式的概念：

using System;
namespace LineApplication
{
class Line
{
private double length; // 線條的長度
public Line()
{
Console.WriteLine("物件已建立");
}

public void setLength( double len )
{
length = len;
}
public double getLength()
{
return length;
}

static void Main(string[] args)
{
Line line = new Line();
// 設定線條長度
line.setLength(6.0);
Console.WriteLine("線條的長度： {0}", line.getLength());
Console.ReadKey();
}
}
}

編譯執行後的結果：

物件已建立
線條的長度： 6
1
2
預設的建構函式沒有任何引數。但是如果你需要一個帶有引數的建構函式可以有引數，這種建構函式叫做引數化建構函式。這種技術可以幫助你在建立物件的同時給物件賦初始值，具體請看下面例項：

using System;
namespace LineApplication
{
class Line
{
private double length; // 線條的長度
public Line(double len) // 引數化建構函式
{
Console.WriteLine("物件已建立，length = {0}", len);
length = len;
}

public void setLength( double len )
{
length = len;
}
public double getLength()
{
return length;
}

static void Main(string[] args)
{
Line line = new Line(10.0);
Console.WriteLine("線條的長度： {0}", line.getLength());
// 設定線條長度
line.setLength(6.0);
Console.WriteLine("線條的長度： {0}", line.getLength());
Console.ReadKey();
}
}
}

當上面的程式碼被編譯和執行時，它會產生下列結果：

物件已建立，length = 10
線條的長度： 10
線條的長度： 6
1
2
3
C# 中的解構函式
類的解構函式是類的一個特殊的成員函式，當類的物件超出範圍時執行。
解構函式的名稱是在類的名稱前加上一個波浪形（~）作為字首，它不返回值，也不帶任何引數。

解構函式用於在結束程式（比如關閉檔案、釋放記憶體等）之前釋放資源。解構函式不能繼承或過載。

下面的例項說明了解構函式的概念：

using System;
namespace LineApplication
{
class Line
{
private double length; // 線條的長度
public Line() // 建構函式
{
Console.WriteLine("物件已建立");
}
~Line() //解構函式
{
Console.WriteLine("物件已刪除");
}

public void setLength( double len )
{
length = len;
}
public double getLength()
{
return length;
}

static void Main(string[] args)
{
Line line = new Line();
// 設定線條長度
line.setLength(6.0);
Console.WriteLine("線條的長度： {0}", line.getLength());
}
}
}

當上面的程式碼被編譯和執行時，它會產生下列結果：

物件已建立
線條的長度： 6
物件已刪除
C# 類的靜態成員
我們可以使用 static 關鍵字把類成員定義為靜態的。當我們宣告一個類成員為靜態時，意味著無論有多少個類的物件被建立，只會有一個該靜態成員的副本。
關鍵字 static 意味著類中只有一個該成員的例項。靜態變數用於定義常量，因為它們的值可以通過直接呼叫類而不需要建立類的例項來獲取。靜態變數可在成員函式或類的定義外部進行初始化。你也可以在類的定義內部初始化靜態變數。

下面的例項演示了靜態變數的用法：

using System;
namespace StaticVarApplication
{
class StaticVar
{
public static int num;
public void count()
{
num++;
}
public int getNum()
{
return num;
}
}
class StaticTester
{
static void Main(string[] args)
{
StaticVar s1 = new StaticVar();
StaticVar s2 = new StaticVar();
s1.count();
s1.count();
s1.count();
s2.count();
s2.count();
s2.count();
Console.WriteLine("s1 的變數 num： {0}", s1.getNum());
Console.WriteLine("s2 的變數 num： {0}", s2.getNum());
Console.ReadKey();
}
}
}

編譯執行後的結果：

s1 的變數 num： 6
s2 的變數 num： 6
你也可以把一個成員函式宣告為 static。這樣的函式只能訪問靜態變數。靜態函式在物件被建立之前就已經存在。下面的例項演示了靜態函式的用法：

using System;
namespace StaticVarApplication
{
class StaticVar
{
public static int num;
public void count()
{
num++;
}
public static int getNum()
{
return num;
}
}
class StaticTester
{
static void Main(string[] args)
{
StaticVar s = new StaticVar();
s.count();
s.count();
s.count();
Console.WriteLine("變數 num： {0}", StaticVar.getNum());
Console.ReadKey();
}
}
}

編譯執行後的結果：

變數 num： 3
10、列舉型別：

列舉是一組命名整型常量。列舉型別是使用 enum 關鍵字宣告的。

C# 列舉是值型別。換句話說，列舉包含自己的值，且不能繼承或傳遞繼承。
- 宣告
語法

enum <enum_name>
{
enumeration list
};
1
2
3
4
enum RoleType{ //關鍵字+命名
apple, //物件，以逗號分隔
pen,
erase
}
RoleType rt = RoleType.apple; //使用列舉

其中，

enum_name 指定列舉的型別名稱。
enumeration list 是一個用逗號分隔的識別符號列表。
列舉列表中的每個符號代表一個整數值，一個比它前面的符號大的整數值。預設情況下，第一個列舉符號的值是 0.例如：

enum Days { Sun, Mon, tue, Wed, thu, Fri, Sat };
例項：
下面的例項演示了列舉變數的用法：

using System;
namespace EnumApplication
{
class EnumProgram
{
enum Days { Sun, Mon, tue, Wed, thu, Fri, Sat };

static void Main(string[] args)
{
int WeekdayStart = (int)Days.Mon;
int WeekdayEnd = (int)Days.Fri;
Console.WriteLine("Monday: {0}", WeekdayStart);
Console.WriteLine("Friday: {0}", WeekdayEnd);
Console.ReadKey();
}
}
}

編譯執行後的結果：

Monday: 1
Friday: 5

Unity3D中的C#程式設計初級

相關文章