360度看C#编程语言

360度看C#编程语言

A Panorama to C# Programming Language

关于C#编程语言的介绍，CSDN不止一篇，读者对它可能怀有好奇，但又有所敬畏，毕竟，这是软件业巨头Microsoft(微软)的开发工具。本文以不同视角来对C#进行观察，尽量使读者能够从360度全方位了解C#语言及其用途；这样，能为开发者和软件爱好者指明方向、对其引发兴趣，从而加入到开发和交流大军中来。

一、.NET生态系统概述

1.1 .NET家族发展历程

.NET是微软公司为开发应用程序创建的具有革命意义的平台，它提供的功能，不仅仅适用于Windows操作系统；而且，.NET完全开源并支持跨平台运行。这意味着，在.NET编写的应用程序，随时可在Linux,macOS系统运行。

打开Chrome浏览器，访问.NET官网，即可见到"庐山真面目"。

映入眼帘的，是.NET 10.0，这是2025年最新版.NET。

1.1.1 .NET Framwork

.NET Framwork是一种技术，它支持生成和运行Windows应用程序、Web服务等。

.NET Framework包括公共语言运行库(Common Language Running)和.NET Framework类库。公共语言运行库是.NET Framework的基础，可将运行时看作一个执行时用来管理代码的代理，它提供内存管理、线程管理和远程处理等核心服务，并强制实施严格的类型安全，用以提高代码安全性和可靠性。代码管理则是运行时的基本原则。

- .NET Framework (2002-)

• Windows平台的专有框架

• 闭源、仅支持Windows

• 成熟的桌面应用开发(WinForms、WPF)

1.1.2 .NET Core

.NET Core是新的.NET开源框架，可在github上找到。运行库是CoreCLR库，包含集合类的框架、文件系统访问、控制台和XML等，都在Core FX库中。

.NET Core按照模块化设计。该框架分成很多NuGet包，这样一来就不用处理全部包，而实使用元包引用一起工作的小包。Net Core更新更快，即使更新运行库，也不会影响现有的应用程序。
.NET Core (2016-)

• 跨平台、开源、高性能

• 模块化设计，支持微服务

• 云原生应用首选
.NET 5+ (2020-)

• .NET Framework和.NET Core的统一

• 单一平台，支持所有应用类型

• 持续迭代的现代开发平台

官网.NET的场景，可以说明它适用于Web, 移动，桌面，云原生以及人工智能等各种应用程序开发。

1.2 开发工具集

基于Windows系统的开发工具，以微软的Visual Studio为主，同时兼有Visual Studio Code, .NET CLI等；第三方开发工具有JetBrains Rider等。

Visual Studio - 功能完整的IDE

• Community版免费

• 强大的调试和诊断工具

• 丰富的扩展生态

Visual Studio Code - 轻量级跨平台编辑器

• 免费开源

• 丰富的C#扩展

• 适合各种规模的项目

.NET CLI - 命令行工具

可在bash/PowerShell下执行命令，创建及运行C#应用程序。

$ dotnet new console -n MyApp
$ dotnet run

二、C#语言简介

C#编程语言就是用来实现在.NET平台上的强大功能，不但能够开发出功能强劲的应用程序，并且执行效率高。

2.1 C#设计哲学

• 面向对象的现代语言

• 类型安全

• 简洁优雅的语法

• 强大的功能集

三、C# vs C/C++深度对比

3.1 代码简洁性对比

以C++程序为例：

#include <iostream>
#include <vector>
#include <string>

class Person {
private:
    std::string name;
    int age;
public:
    Person(const std::string& n, int a) : name(n), age(a) {}
    
    std::string getName() const { return name; }
    void setName(const std::string& n) { name = n; }
    
    int getAge() const { return age; }
    void setAge(int a) { age = a; }
};

int main() {
    std::vector<Person> people;
    people.push_back(Person("Alice", 25));
    
    for (const auto& person : people) {
        std::cout << person.getName() << ": " << person.getAge() << std::endl;
    }
    return 0;
}

以C#程序为例：

using System;
using System.Collections.Generic;

// 自动属性简化了字段和访问器的定义
public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
    
    public Person(string name, int age)
    {
        Name = name;
        Age = age;
    }
}

class Program
{
    static void Main()
    {
        var people = new List<Person>
        {
            new Person("Alice", 25)
        };
        
        // LINQ使集合操作更简洁
        foreach (var person in people)
        {
            Console.WriteLine($"{person.Name}: {person.Age}");
        }
    }
}

二者的区别显而易见。

3.2 内存管理

C++手动内存管理：

// 需要手动管理内存
MyClass* obj = new MyClass();
// ... 使用对象
delete obj; // 必须手动释放

// 内存泄漏风险
void riskyFunction() {
    int* array = new int[1000];
    // 如果这里抛出异常，内存泄漏！
    delete[] array; // 必须确保执行到这里
}

C#自动内存管理：

// 自动内存管理，无需手动释放
var obj = new MyClass();
// 使用对象...
// 当obj不再被引用时，垃圾回收器会自动回收内存

// 使用using语句确保资源释放
using (var resource = new FileStream("file.txt", FileMode.Open))
{
    // 使用资源
    // 即使抛出异常，资源也会被正确释放
}

3.3 流控制和循环

C#更现代的循环语法：

// 传统for循环
for (int i = 0; i < 10; i++)
{
    Console.WriteLine(i);
}

// 更安全的foreach循环
var numbers = new List<int> { 1, 2, 3, 4, 5 };
foreach (var number in numbers)
{
    Console.WriteLine(number);
}

// 使用LINQ进行函数式编程风格的遍历
numbers.Where(n => n % 2 == 0)
       .ToList()
       .ForEach(n => Console.WriteLine(n));

3.4 异常处理

C++异常处理：

try {
    int* arr = new int[1000000000]; // 可能抛出std::bad_alloc
    // 使用数组
    delete[] arr;
} catch (const std::exception& e) {
    std::cerr << "Exception: " << e.what() << std::endl;
}

C#异常处理：

try
{
    // 可能抛出异常的代码
    using var file = File.OpenRead("nonexistent.txt");
}
catch (FileNotFoundException ex)
{
    Console.WriteLine($"文件未找到: {ex.FileName}");
}
catch (UnauthorizedAccessException ex)
{
    Console.WriteLine($"无访问权限: {ex.Message}");
}
catch (Exception ex)
{
    Console.WriteLine($"其他错误: {ex.Message}");
}
finally
{
    // 清理代码，总是执行
    Console.WriteLine("清理完成");
}

四、C# vs Java深度对比

4.1 语法简洁性

Java示例：

import java.util.ArrayList;
import java.util.List;

public class Person {
    private String name;
    private int age;
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public int getAge() {
        return age;
    }
    
    public void setAge(int age) {
        this.age = age;
    }
    
    @Override
    public String toString() {
        return name + ": " + age;
    }
}

public class Main {
    public static void main(String[] args) {
        List<Person> people = new ArrayList<>();
        people.add(new Person("Alice", 25));
        
        for (Person person : people) {
            System.out.println(person);
        }
    }
}

C#更简洁的实现：

using System;
using System.Collections.Generic;

// 记录类型(Record) - C# 9.0+
public record Person(string Name, int Age);

// 或者使用类
public class Person
{
    public string Name { get; init; }  // Init-only属性
    public int Age { get; init; }
    
    // 简化的ToString
    public override string ToString() => $"{Name}: {Age}";
}

class Program
{
    static void Main()
    {
        // 对象初始化器
        var people = new List<Person>
        {
            new Person { Name = "Alice", Age = 25 },
            new() { Name = "Bob", Age = 30 }  // 目标类型new表达式
        };
        
        // 字符串插值
        foreach (var person in people)
        {
            Console.WriteLine($"{person.Name} is {person.Age} years old");
        }
    }
}

4.2 属性和字段

C#属性特性：

public class Product
{
    // 自动属性
    public string Name { get; set; }
    
    // 只读属性
    public DateTime Created { get; } = DateTime.Now;
    
    // 计算属性
    public string DisplayName => $"{Name} - {Created:yyyy-MM-dd}";
    
    // 带验证的属性
    private decimal _price;
    public decimal Price
    {
        get => _price;
        set
        {
            if (value < 0)
                throw new ArgumentException("价格不能为负数");
            _price = value;
        }
    }
}

4.3 委托和事件

C#特有的事件处理机制：

public class Button
{
    // 事件声明
    public event EventHandler? Clicked;
    
    public void Click()
    {
        Clicked?.Invoke(this, EventArgs.Empty);
    }
}

public class Program
{
    static void Main()
    {
        var button = new Button();
        
        // Lambda表达式订阅事件
        button.Clicked += (sender, e) => 
        {
            Console.WriteLine("按钮被点击了！");
        };
        
        // 方法组订阅
        button.Clicked += OnButtonClicked;
        
        button.Click();
    }
    
    static void OnButtonClicked(object? sender, EventArgs e)
    {
        Console.WriteLine("另一个处理程序");
    }
}

4.4 LINQ - 语言集成查询

C#强大的数据查询能力：

using System;
using System.Collections.Generic;
using System.Linq;

public class Product
{
    public string Name { get; set; } = string.Empty;
    public decimal Price { get; set; }
    public string Category { get; set; } = string.Empty;
}

class Program
{
    static void Main()
    {
        var products = new List<Product>
        {
            new() { Name = "Laptop", Price = 999.99m, Category = "Electronics" },
            new() { Name = "Book", Price = 19.99m, Category = "Education" },
            new() { Name = "Phone", Price = 499.99m, Category = "Electronics" }
        };
        
        // LINQ查询语法
        var expensiveElectronics = 
            from p in products
            where p.Price > 100 && p.Category == "Electronics"
            orderby p.Price descending
            select p;
        
        // LINQ方法语法
        var cheapProducts = products
            .Where(p => p.Price < 50)
            .OrderBy(p => p.Price)
            .Select(p => new { p.Name, p.Price });
        
        // 立即执行查询
        var totalValue = products.Sum(p => p.Price);
        var mostExpensive = products.Max(p => p.Price);
        
        Console.WriteLine($"总价值: {totalValue:C}");
        Console.WriteLine($"最贵商品价格: {mostExpensive:C}");
    }
}

4.5 异步编程

C# async/await模式：

using System;
using System.Net.Http;
using System.Threading.Tasks;

public class ApiService
{
    private readonly HttpClient _httpClient = new();
    
    // 异步方法
    public async Task<string> GetDataAsync(string url)
    {
        try
        {
            // 异步HTTP请求
            var response = await _httpClient.GetAsync(url);
            response.EnsureSuccessStatusCode();
            
            return await response.Content.ReadAsStringAsync();
        }
        catch (HttpRequestException ex)
        {
            Console.WriteLine($"网络请求失败: {ex.Message}");
            return string.Empty;
        }
    }
}

class Program
{
    static async Task Main()  // 异步Main方法
    {
        var service = new ApiService();
        
        // 并行执行多个异步操作
        var task1 = service.GetDataAsync("https://api.example.com/data1");
        var task2 = service.GetDataAsync("https://api.example.com/data2");
        
        // 等待所有任务完成
        var results = await Task.WhenAll(task1, task2);
        
        Console.WriteLine($"获取到 {results.Length} 个结果");
        
        // 使用异步foreach处理流数据
        await foreach (var item in FetchDataStreamAsync())
        {
            Console.WriteLine($"处理: {item}");
        }
    }
    
    static async IAsyncEnumerable<string> FetchDataStreamAsync()
    {
        for (int i = 0; i < 5; i++)
        {
            await Task.Delay(1000); // 模拟异步操作
            yield return $"数据项 {i + 1}";
        }
    }
}

五、C#面向对象特性

5.1 继承和多态

C#面向对象示例：

using System;
using System.Collections.Generic;

// 基类
public abstract class Shape
{
    public string Name { get; set; } = string.Empty;
    
    // 抽象方法
    public abstract double CalculateArea();
    
    // 虚方法
    public virtual void Display()
    {
        Console.WriteLine($"形状: {Name}");
    }
}

// 派生类
public class Circle : Shape
{
    public double Radius { get; set; }
    
    public Circle(double radius)
    {
        Name = "圆形";
        Radius = radius;
    }
    
    public override double CalculateArea()
    {
        return Math.PI * Radius * Radius;
    }
    
    public override void Display()
    {
        base.Display();
        Console.WriteLine($"半径: {Radius}, 面积: {CalculateArea():F2}");
    }
}

public class Rectangle : Shape
{
    public double Width { get; set; }
    public double Height { get; set; }
    
    public Rectangle(double width, double height)
    {
        Name = "矩形";
        Width = width;
        Height = height;
    }
    
    public override double CalculateArea()
    {
        return Width * Height;
    }
}

class Program
{
    static void Main()
    {
        // 多态演示
        var shapes = new List<Shape>
        {
            new Circle(5.0),
            new Rectangle(4.0, 6.0)
        };
        
        foreach (var shape in shapes)
        {
            shape.Display();  // 运行时多态
            Console.WriteLine($"面积: {shape.CalculateArea():F2}");
            Console.WriteLine();
        }
    }
}

5.2 接口和实现

C# 接口实现：

using System;
using System.Collections.Generic;

// 接口定义
public interface IRepository<T>
{
    void Add(T item);
    void Remove(T item);
    T GetById(int id);
    IEnumerable<T> GetAll();
}

public interface ILoggable
{
    void Log(string message);
}

// 具体实现
public class ProductRepository : IRepository<Product>, ILoggable
{
    private readonly List<Product> _products = new();
    
    public void Add(Product item)
    {
        _products.Add(item);
        Log($"添加产品: {item.Name}");
    }
    
    public void Remove(Product item)
    {
        _products.Remove(item);
        Log($"移除产品: {item.Name}");
    }
    
    public Product GetById(int id)
    {
        return _products.Find(p => p.GetHashCode() == id) 
               ?? throw new KeyNotFoundException("产品未找到");
    }
    
    public IEnumerable<Product> GetAll()
    {
        return _products.AsReadOnly();
    }
    
    public void Log(string message)
    {
        Console.WriteLine($"[LOG] {DateTime.Now:yyyy-MM-dd HH:mm:ss}: {message}");
    }
}

六、C#并发编程

6.1 多线程和任务并行

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

public class ParallelProcessor
{
    // 使用Parallel类进行数据并行处理
    public void ProcessDataParallel(List<int> data)
    {
        var results = new List<double>();
        var lockObject = new object();
        
        Parallel.ForEach(data, number =>
        {
            // 模拟CPU密集型计算
            double result = Math.Sqrt(number) * Math.Pow(number, 2);
            
            lock (lockObject)  // 线程安全地添加结果
            {
                results.Add(result);
            }
        });
        
        Console.WriteLine($"并行处理了 {results.Count} 个数据项");
    }
    
    // 使用Task进行任务并行
    public async Task<string[]> DownloadMultipleFilesAsync(string[] urls)
    {
        var downloadTasks = new List<Task<string>>();
        
        foreach (var url in urls)
        {
            downloadTasks.Add(DownloadFileAsync(url));
        }
        
        // 等待所有下载任务完成
        string[] contents = await Task.WhenAll(downloadTasks);
        return contents;
    }
    
    private async Task<string> DownloadFileAsync(string url)
    {
        using var httpClient = new HttpClient();
        return await httpClient.GetStringAsync(url);
    }
    
    // 使用CancellationToken支持取消操作
    public async Task ProcessWithCancellationAsync(CancellationToken cancellationToken = default)
    {
        for (int i = 0; i < 100; i++)
        {
            // 检查取消请求
            cancellationToken.ThrowIfCancellationRequested();
            
            await Task.Delay(100, cancellationToken);
            Console.WriteLine($"处理进度: {i + 1}%");
        }
    }
}

class Program
{
    static async Task Main()
    {
        var processor = new ParallelProcessor();
        var data = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
        
        // 并行处理
        processor.ProcessDataParallel(data);
        
        // 使用CancellationTokenSource管理取消
        using var cts = new CancellationTokenSource();
        
        // 5秒后取消
        cts.CancelAfter(TimeSpan.FromSeconds(5));
        
        try
        {
            await processor.ProcessWithCancellationAsync(cts.Token);
        }
        catch (OperationCanceledException)
        {
            Console.WriteLine("操作被取消");
        }
    }
}

七、总结：C#的核心优势

7.1 对比总结

7.2 C#适用场景

推荐使用C#的场景：

• Windows桌面应用(WinForms、WPF)

• Unity游戏开发

• ASP.NET Core Web应用

• 微服务和云原生应用

• 企业级应用开发

• 跨平台移动应用(MAUI)

C#的核心竞争力：

1. 现代化语法特性 - 持续演进的语言设计
2. 强大的工具支持 - Visual Studio生态
3. 出色的生产力 - LINQ、async/await等特性
4. 良好的性能 - 接近原生代码的执行效率
5. 丰富的生态系统 - NuGet包管理器
6. 微软强力支持 - 长期的技术投入和更新

.NET开发技术文章陆续推出。

---

敬请关注、收藏和点赞！👍

您的认可，我的动力！😃

推荐阅读：

1. 用Visual Studio Code最新版开发C#应用程序
2. 用JetBrains Rider开发C#应用程序指南
3. 在macOS上搭建C#集成开发环境指南
4. 2025最新版Python 3.14.0安装使用指南
5. 2025最新版Eclipse for Java安装使用指南