1. C#語言基礎

1.1 C#語法概覽

歡迎來到C#的世界！對於剛從Java轉過來的開發者來說，你會發現C#和Java有很多相似之處，但C#也有其獨特的魅力和強大之處。讓我們一起來探索C#的基本語法，並比較一下與Java的異同。

程式結構

C#程式的基本結構與Java非常相似。這裏是一個簡單的C#程式：

using System;
namespaceHelloWorld
{
classProgram
{
staticvoidMain(string[] args)
{
Console.WriteLine("Hello, World!");
}
}
}


對比Java的版本：

public classHelloWorld{
publicstaticvoidmain(String[] args){
System.out.println("Hello, World!");
}
}


你會發現，兩者的結構非常相似。主要的區別在於：

1. C#使用 using 關鍵字匯入名稱空間，而Java使用 import 。

2. C#的 Main 方法是 static void Main(string[] args) ，而Java是 public static void main(String[] args) 。

3. C#使用 Console.WriteLine() 輸出，Java使用 System.out.println() 。

在c# 9的最新語法上還可以更簡潔，是的沒錯，只需要一行程式碼，不需要寫名稱空間，類，方法，直接編寫程式碼，當然這個方式只存在c#9以上的版本。

Console.WriteLine("Hello, World!");


命名約定

C#和Java的命名約定有些許不同：

而Java中：

數據型別

C#和Java的基本數據型別很相似，但也有一些區別：

C#:

int x = 10;
long y = 100L;
float f = 3.14f;
double d = 3.14;
decimal m = 100.50m;
bool isTrue = true;
char c = 'A';
string s = "Hello";


Java:

int x = 10;
long y = 100L;
float f = 3.14f;
double d = 3.14;
boolean isTrue = true;
char c = 'A';
String s = "Hello";


註意C#特有的 decimal 型別，它提供了更高精度的小數計算，特別適合金融相關的套用。

陣列

C#和Java的陣列聲明稍有不同：

C#:

int[] numbers = newint[5];
string[] names = { "Alice", "Bob", "Charlie" };


Java:

int[] numbers = newint[5];
String[] names = { "Alice", "Bob", "Charlie" };


控制結構

C#和Java的控制結構幾乎完全相同：

// if語句
if (condition)
{
// code
}
elseif (anotherCondition)
{
// code
}
else
{
// code
}
// for迴圈
for (int i = 0; i < 10; i++)
{
// code
}
// while迴圈
while (condition)
{
// code
}
// switch語句
switch (variable)
{
case value1:
// code
break;
case value2:
// code
break;
default:
// code
break;
}



這些結構在Java中的寫法完全相同。

例外處理

C#和Java的例外處理也非常相似：

C#:

try
{
// 可能丟擲異常的程式碼
}
catch (SpecificException ex)
{
// 處理特定異常
}
catch (Exception ex)
{
// 處理一般異常
}
finally
{
// 總是要執行的程式碼
}


Java的例外處理結構完全相同。

註釋

C#和Java的註釋方式也是一樣的：

// 這是單行註釋
/*
* 這是多行註釋
*/
///<summary>
/// 這是XML文件註釋，類似於Java的Javadoc
///</summary>


小結

透過這個概覽，你可以看到C#和Java在語法上有很多相似之處。這意味著作為一個Java開發者，你可以相對輕松地過渡到C#。然而，C#也有其獨特的特性和語法糖，使得某些任務更加簡潔和高效。

在接下來的章節中，我們將深入探討C#的各個方面，包括它獨特的特性如內容、事件、委托等。這些概念可能對Java開發者來說比較新，但它們是C#強大功能的關鍵所在。記住，學習一門新的語言不僅是學習語法，更是學習一種新的思維方式。讓我們繼續我們的C#學習之旅吧！

1.2 變量和數據型別

在C#中，變量和數據型別是編程的基礎。對於從Java轉過來的開發者來說，你會發現很多熟悉的概念，但C#也有一些獨特的特性。讓我們深入探討C#的變量和數據型別，並與Java進行比較。

變量聲明

C#和Java的變量聲明方式非常相似：

C#:

int age = 25;
string name = "Alice";
bool isStudent = true;


Java:

int age = 25;
String name = "Alice";
boolean isStudent = true;


主要區別在於：

1. C#使用 string （小寫），而Java使用 String （大寫）。

2. C#使用 bool ，而Java使用 boolean 。

基本數據型別

C#和Java都有類似的基本數據型別，但C#提供了更多的選擇：

註意C#提供了無符號整數型別（ byte , ushort , uint , ulong ）和 decimal 型別，這些在Java中是沒有的。

值型別和參照型別

C#和Java都區分值型別和參照型別，但C#的處理更加靈活：

1. 值型別（Value Types）：

C#獨特之處：

可空型別

C#引入了可空型別的概念，這在Java中是沒有的：

int? nullableInt = null;
bool? nullableBool = null;


可空型別允許值型別也可以賦值為 null ，這在處理資料庫或使用者輸入時非常有用。

var關鍵字

C#提供了 var 關鍵字用於隱式型別聲明：

var x = 10; // 編譯器推斷x為int型別
var name = "Alice"; // 編譯器推斷name為string型別


Java從Java 10開始引入了類似的 var 關鍵字，但使用範圍更受限制。

常量

C#使用 const 關鍵字聲明常量：

constint MaxValue = 100;
conststring AppName = "MyApp";


Java使用 final 關鍵字：

finalint MAX_VALUE = 100;
final String APP_NAME = "MyApp";


列舉

C#和Java都支持列舉，但C#的列舉更加靈活：

C#:

enum Days
{
Monday,
Tuesday,
Wednesday,
Thursday,
Friday,
Saturday,
Sunday
}
// 可以指定底層型別和值
enum Status : byte
{
Active = 1,
Inactive = 0,Suspended = 2
}

Java:

enum Days {
MONDAY,
TUESDAY,
WEDNESDAY,
THURSDAY,
FRIDAY,
SATURDAY,
SUNDAY
}


C#的列舉可以指定底層型別，而Java的列舉實際上是特殊的類。

型別轉換

C#提供了多種型別轉換方法：

1. 隱式轉換：

   int x = 10;
long y = x; // 隱式轉換，不需要顯式轉換


2. 顯式轉換（強制型別轉換）：

   doubled = 3.14;
int i = (int)d; // 顯式轉換，可能會損失精度


3. 使用Convert類：

   string s = "123";
int i = Convert.ToInt32(s);


4. 使用Parse方法：

   string s = "3.14";
double d = double.Parse(s);


5. TryParse方法（安全轉換）：

   string s = "123";
int result;
if (int.TryParse(s, out result))
{
Console.WriteLine($"Converted value: {result}");
}
else
{
Console.WriteLine("Conversion failed");
}


Java的型別轉換相對簡單一些，主要依賴於強制型別轉換和包裝類的方法。

小結

雖然C#和Java在變量和數據型別方面有很多相似之處，但C#提供了更多的選擇和靈活性。C#的可空型別、更豐富的基本數據型別、更靈活的列舉和方便的型別轉換方法，都為開發者提供了更多的工具來處理各種數據場景。

作為一個從Java轉向C#的開發者，你會發現這些額外的特性可以讓你的程式碼更加簡潔和表達力更強。在實際編程中，合理利用這些特性可以提高程式碼的可讀性和效能。

在接下來的學習中，我們將深入探討C#的更多高級特性，如內容、索引器、泛型等。這些概念將進一步展示C#相對於Java的獨特優勢。繼續保持學習的熱情，你會發現C#是一個功能豐富、富有表現力的語言！

1.3 運算子和運算式

C#的運算子和運算式與Java有很多相似之處，但也有一些獨特的特性。讓我們深入了解C#的運算子和運算式，並與Java進行比較。

算術運算子

C#和Java的算術運算子基本相同：

範例：

int a = 10, b = 3;
int sum = a + b; // 13
int difference = a - b; // 7
int product = a * b; // 30
int quotient = a / b; // 3 (整數除法)
int remainder = a % b; // 1


註意：C#和Java在整數除法時都會舍去小數部份，如果要得到精確結果，至少有一個運算元應該是浮點數。

設定運算子

C#和Java的設定運算子也基本相同：

C#特有的復合設定運算子：

範例：

int x = 5;
x += 3; // 等同於 x = x + 3
x -= 2; // 等同於 x = x - 2
string name = null;
name ??= "John"; // 如果name為null，賦值為"John"

比較運算子

C#和Java的比較運算子完全相同：

範例：

int a = 5, b = 7;
bool isEqual = (a == b);// false
bool isNotEqual = (a !=b); // true
bool isGreater = (a > b);// false
bool isLess = (a < b); // true
bool isGreaterOrEqual = (a >= b); // false
bool isLessOrEqual = (a <= b);// true


邏輯運算子

C#和Java的邏輯運算子也是相同的：

範例：

bool a = true, b = false;
bool andResult = a && b; // false
bool orResult = a || b; // true
bool notResult = !a; // false


位運算子

C#和Java的位運算子也基本相同：

C#特有的位運算子：

範例：

int a = 60;// 二進制: 0011 1100
int b = 13; // 二進制: 0000 1101
int c = a & b; // 12(二進制: 0000 1100)
int d = a | b; // 61 (二進制: 0011 1101)
int e = a ^ b; // 49 (二進制: 0011 0001)
int f = ~a; // -61 (二進制: 1100 0011, 補碼表示)
int g = a << 2; // 240 (二進制: 1111 0000)
int h = a >> 2; // 15 (二進制: 0000 1111)

條件運算子

C#和Java都有三元條件運算子：

int a = 10, b = 20;
int max = (a > b) ? a : b; // 20


C#特有的條件運算子：

範例：

string name = null;
string displayName = name ?? "Guest"; // "Guest"
classPerson
{
publicstring Name { get; set; }
}
Person person = null;
int? nameLength = person?.Name?.Length; // null


型別測試運算子

C#提供了一些Java中沒有的型別測試運算子：

範例：

object obj = "Hello";
if (obj isstring)
{
Console.WriteLine("obj is a string");
}
string str = obj asstring;
if (str != null)
{
Console.WriteLine($"The string is: {str}");
}

Lambda 運算式

C#和Java都支持Lambda運算式，但語法略有不同：

C#:

Func<int, int> square = x => x * x;
int result = square(5); // 25


Java:

Function<Integer, Integer> square = x -> x * x;
int result = square.apply(5); // 25


空合並運算子(??)

C#特有的空合並運算子可以簡化處理可能為null的情況：

string name = null;
string displayName = name ?? "Guest"; // "Guest"


在Java中，你可能需要這樣寫：

String name = null;
String displayName = (name != null) ? name : "Guest";


運算式體成員 (Expression-bodied members)

C#允許使用更簡潔的語法來定義內容和方法：

public classCircle
{
publicdouble Radius { get; set; }
publicdouble Diameter => Radius * 2;
publicdoubleCalculateArea() => Math.PI * Radius * Radius;
}


這種語法在Java中是不存在的。

字串插值

C#提供了非常方便的字串插值語法：

string name = "Alice";
int age = 30;
string message = $"My name is {name} and I am {age} years old.";


Java在較新的版本中也引入了類似的功能，但語法不同：

String name = "Alice";
int age = 30;
String message = String.format("My name is %s and I am %d years old.", name, age);


小結

雖然C#和Java在運算子和運算式方面有很多相似之處，但C#提供了一些額外的特性，如空合並運算子、空條件運算子、運算式體成員等，這些可以讓程式碼更加簡潔和表達力更強。

作為一個從Java轉向C#的開發者，你會發現這些額外的特性可以讓你的程式碼更加優雅和易讀。在實際編程中，合理利用這些特性可以提高程式碼品質和開發效率。

在接下來的學習中，我們將深入探討C#的更多高級特性，如LINQ、異步編程等。這些概念將進一步展示C#相對於Java的獨特優勢。繼續保持學習的熱情，你會發現C#是一個功能豐富、表達力強的語言！

1.4 控制流語句

控制流語句是程式語言的基本構建塊，用於控制程式的執行路徑。C#和Java在這方面非常相似，但C#也有一些獨特的特性。讓我們深入了解C#的控制流語句，並與Java進行比較。

if-else 語句

C#和Java的if-else語句幾乎完全相同：

int x = 10;
if (x > 5)
{
Console.WriteLine("x is greater than 5");
}
elseif (x < 5)
{
Console.WriteLine("x is less than 5");
}
else
{
Console.WriteLine("x is equal to 5");
}


C#特有的特性：

1. 可空型別的使用：

int? x = null;
if (x.HasValue)
{
Console.WriteLine($"x has a value: {x.Value}");
}
else
{
Console.WriteLine("x is null");
}


2. 模式匹配（C# 7.0+）：

object obj = "Hello";
if (obj isstring s)
{
Console.WriteLine($"The string is: {s}");
}


switch 語句

C#的switch語句比Java的更加靈活：

int day = 3;
switch (day)
{
case1:
Console.WriteLine("Monday");
break;
case2:
Console.WriteLine("Tuesday");
break;
case3:
case4:
case5:
Console.WriteLine("Midweek");
break;
default:
Console.WriteLine("Weekend");
break;
}


C#特有的特性：

1. 模式匹配（C# 7.0+）：

object obj = 123;
switch (obj)
{
caseint i when i > 100:
Console.WriteLine($"Large integer: {i}");
break;
casestring s:
Console.WriteLine($"String value: {s}");
break;
casenull:
Console.WriteLine("Null value");
break;
default:
Console.WriteLine("Unknown type");
break;
}


2. switch 運算式（C# 8.0+）：

stringGetDayType(int day) => day switch
{
1 => "Monday",
2 => "Tuesday",
3 or 4 or 5 => "Midweek",
_ => "Weekend"
};


迴圈語句

C#和Java的迴圈語句非常相似：

1. for迴圈：

for (int i = 0; i < 5; i++)
{
Console.WriteLine(i);
}


2. while 迴圈：

int i = 0;
while (i < 5)
{
Console.WriteLine(i);
i++;
}


3. do-while 迴圈：

int i = 0;
do
{
Console.WriteLine(i);
i++;
} while (i < 5);


4. foreach 迴圈：

string[] fruits = { "apple", "banana", "cherry" };
foreach (string fruit in fruits)
{
Console.WriteLine(fruit);
}


C#特有的特性：

1. LINQ與foreach的結合：

List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
foreach (var num in numbers.Where(n => n % 2 == 0))
{
Console.WriteLine(num);
}


跳轉語句

C#和Java都支持以下跳轉語句：

1. break：跳出當前迴圈或switch語句

2. continue：跳過當前迴圈的剩余部份，開始下一次叠代

3. return：從方法中返回，並可選擇返回一個值

C#特有的跳轉語句：

1. goto：雖然不推薦使用，但C#保留了goto語句

int i = 0;
start:
if (i < 5)
{
Console.WriteLine(i);
i++;
goto start;
}


例外處理

C#和Java的例外處理機制非常相似：

try
{
int result = 10 / 0;
}
catch (DivideByZeroException ex)
{
Console.WriteLine($"Division by zero error: {ex.Message}");
}
catch (Exception ex)
{
Console.WriteLine($"An error occurred: {ex.Message}");
}
finally
{
Console.WriteLine("This always executes");
}


C#特有的特性：

1. 異常過濾器（C# 6.0+）：

try
{
// 可能丟擲異常的程式碼
}
catch (Exception ex) when (ex.InnerException != null)
{
Console.WriteLine($"Inner exception: {ex.InnerException.Message}");
}


2. using 語句（簡化資源管理）：

using (var file = new System.IO.StreamReader("file.txt"))
{
string content = file.ReadToEnd();
Console.WriteLine(content);
}
// file自動關閉


3. using 聲明（C# 8.0+）：

usingvar file = new System.IO.StreamReader("file.txt");
string content = file.ReadToEnd();
Console.WriteLine(content);
// file 在作用域結束時自動關閉


小結

雖然C#和Java在控制流語句方面有很多相似之處，但C#提供了一些額外的特性，如模式匹配、switch運算式、異常過濾器等，這些可以讓程式碼更加簡潔和表達力更強。

作為一個從Java轉向C#的開發者，你會發現這些額外的特性可以讓你的程式碼更加優雅和易讀。特別是模式匹配和switch運算式，它們可以大大簡化復雜的條件邏輯。

在實際編程中，合理利用這些特性可以提高程式碼品質和開發效率。例如，使用模式匹配可以使型別檢查和轉換更加簡潔，使用switch運算式可以使復雜的條件判斷更加清晰。

在接下來的學習中，我們將深入探討C#的更多高級特性，如LINQ、異步編程等。這些概念將進一步展示C#相對於Java的獨特優勢。繼續保持學習的熱情，你會發現C#是一個功能豐富、表達力強的語言！

1.5 方法和參數

方法（在Java中稱為函式）是編程中最基本的程式碼組織單元。C#和Java在方法定義和使用上有很多相似之處，但C#提供了一些額外的特性，使得方法定義和呼叫更加靈活。讓我們深入探討C#的方法和參數，並與Java進行比較。

方法定義

C#和Java的基本方法定義非常相似：

publicintAdd(int a, int b)
{
return a + b;
}


Java中的等效程式碼：

publicintadd(int a, int b){
return a + b;
}


主要區別：

1. C#方法名通常使用PascalCase，而Java使用camelCase。

2. C#支持方法多載，Java也支持。

參數傳遞

C#和Java都支持值傳遞和參照傳遞，但C#提供了更多選項：

1. 值參數（預設）：

publicvoidIncrementValue(int x)
{
x++; // 不影響原始值
}


2. 參照參數（ref 關鍵字）：

publicvoidIncrementRef(refint x)
{
x++; // 修改原始值
}
// 呼叫
int num = 5;
IncrementRef(ref num);
Console.WriteLine(num); // 輸出 6

Java沒有直接等效的參照參數，但可以透過包裝類或陣列實作類似效果。

3. 輸出參數（out 關鍵字）：

publicboolTryParse(string s, outint result)
{
returnint.TryParse(s, out result);
}
// 呼叫
if (TryParse("123", outint number))
{
Console.WriteLine($"Parsed number: {number}");
}

Java沒有直接等效的輸出參數。

4. 參數陣列（params 關鍵字）：

publicintSum(paramsint[] numbers)
{
return numbers.Sum();
}
// 呼叫
int total = Sum(1, 2, 3, 4, 5);

Java使用可變參數（varargs）實作類似功能：

publicintsum(int... numbers){
return Arrays.stream(numbers).sum();
}


方法多載

C#和Java都支持方法多載，允許在同一個類中定義多個同名但參數列不同的方法：

public classCalculator
{
publicintAdd(int a, int b)
{
return a + b;
}
publicdoubleAdd(double a, double b)
{
return a + b;
}
}

Java的方法多載與C#基本相同。

可選參數

C#支持可選參數，這在Java中直到最近才引入：

publicvoidGreet(string name, string greeting = "Hello")
{
Console.WriteLine($"{greeting}, {name}!");
}
// 呼叫
Greet("Alice"); // 輸出: Hello, Alice!
Greet("Bob", "Hi"); // 輸出: Hi, Bob!

在Java中，你通常需要使用方法多載來實作類似功能：

publicvoidgreet(String name){
greet(name, "Hello");
}
publicvoidgreet(String name, String greeting){
System.out.println(greeting + ", " + name + "!");
}

命名參數

C#支持命名參數，可以提高程式碼的可讀性：

publicvoidCreateUser(string name, int age, bool isAdmin = false)
{
//方法實作
}
// 呼叫
CreateUser(name: "Alice", age: 30, isAdmin: true);
CreateUser(age: 25, name: "Bob"); // 可以改變參數順序

Java不支持命名參數，但可以使用建造者模式來實作類似的效果。

運算式體方法

C# 6.0引入了運算式體方法，可以使簡單方法的定義更加簡潔：

publicintAdd(int a, int b) => a + b;
publicstringGetFullName(string firstName, string lastName) => $"{firstName}{lastName}";

Java不支持這種語法糖。

本地函式

C# 7.0引入了本地函式，允許在方法內定義函式：

publicintFactorial(int n)
{
intLocalFactorial(int x)
{
return x <= 1 ? 1 : x * LocalFactorial(x - 1);
}
return LocalFactorial(n);
}

Java不直接支持本地函式，但可以使用匿名內部類或lambda運算式來實作類似功能。

異步方法

C#對異步編程的支持非常強大，使用async和await關鍵字：

publicasync Task<string> FetchDataAsync(string url)
{
usingvar client = new HttpClient();
returnawait client.GetStringAsync(url);
}
// 呼叫
string data = await FetchDataAsync("https://api.example.com");

Java也支持異步編程，但語法和使用方式與C#不同，通常使用CompletableFuture：

public CompletableFuture<String> fetchDataAsync(String url){
return CompletableFuture.supplyAsync(() -> {
// 使用HttpClient獲取數據
return"data";
});
}
// 呼叫
String data = fetchDataAsync("https://api.example.com").join();

擴充套件方法

C#允許你為現有型別添加新方法，而不需要修改原始型別的定義：

publicstatic classStringExtensions
{
publicstaticboolIsNullOrEmpty(thisstring str)
{
returnstring.IsNullOrEmpty(str);
}
}
// 使用
string name = "Alice";
bool isEmpty = name.IsNullOrEmpty();

Java不支持擴充套件方法，但可以使用靜態工具類來實作類似功能。

泛型方法

C#和Java都支持泛型方法，允許你編寫可以處理多種型別的方法：

public T Max<T>(T a, T b) where T : IComparable<T>
{
return a.CompareTo(b) > 0 ? a : b;
}
// 使用
int maxInt = Max(5, 10);
string maxString = Max("apple", "banana");

Java的泛型方法語法略有不同：

public <T extends Comparable<T>> T max(T a, T b){
return a.compareTo(b) > 0 ? a : b;
}


方法組合與函數語言程式設計

C#對函數語言程式設計有很好的支持，可以輕松組合和傳遞方法：

Func<int, int> square = x => x * x;
Func<int, int> addOne = x => x + 1;
Func<int, int> squareThenAddOne = x => addOne(square(x));
int result = squareThenAddOne(5); // 26


Java也支持函數語言程式設計，但語法略有不同：

Function<Integer, Integer> square = x -> x * x;
Function<Integer, Integer> addOne = x -> x + 1;
Function<Integer, Integer> squareThenAddOne = square.andThen(addOne);
int result = squareThenAddOne.apply(5); // 26


小結

雖然C#和Java在方法和參數的基本概念上很相似，但C#提供了更多的特性和靈活性。C#的參照參數、輸出參數、命名參數、可選參數等特性可以讓方法定義和呼叫更加靈活和清晰。此外，C#的異步方法、擴充套件方法和運算式體方法等特性可以讓程式碼更加簡潔和易讀。

作為一個從Java轉向C#的開發者，你會發現這些額外的特性可以大大提高你的編程效率和程式碼品質。例如，命名參數和可選參數可以減少方法多載的需求，擴充套件方法可以讓你更容易地擴充套件現有型別的功能，而async/await則可以大大簡化異步編程的復雜性。

在實際編程中，合理利用這些特性可以讓你的程式碼更加清晰、簡潔和易於維護。例如，使用命名參數可以提高程式碼的可讀性，使用擴充套件方法可以使你的程式碼更加模組化，而使用異步方法可以提高應用程式的響應性。

隨著你對C#的深入學習，你會發現更多強大的特性和用法。保持學習和實踐的熱情，你將能夠充分利用C#的強大功能，成為一個高效的.NET開發者！

Java失業者轉.NET開發交流群：157210263

部落格詳細文章站點 http://token-ai.cn/