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/