编程语言基础

难度等级：⭐⭐⭐ 前置知识：无 后续衔接：Web 后端开发、架构设计

学习路径

一、C# 与 .NET 生态

1.1 C# 语言基础

委托与事件

概念解释

委托（Delegate）是 C# 中类型安全的方法引用，类似于 C/C++ 的函数指针，但具有类型安全和面向对象特性。委托定义了方法的签名（参数类型和返回值类型），可以将方法作为参数传递、存储和调用。事件（Event）是基于委托的发布-订阅机制，用于实现对象间的松耦合通信。

核心要点

代码示例

// 委托定义
public delegate void MessageHandler(string message);

// 使用 Action 和 Func
Action<string> print = Console.WriteLine;
Func<int, int, int> add = (a, b) => a + b;

// 事件示例
public class Publisher
{
    public event EventHandler<string> OnMessage;
    
    public void SendMessage(string msg)
    {
        OnMessage?.Invoke(this, msg);
    }
}

public class Subscriber
{
    public void HandleMessage(object sender, string msg)
    {
        Console.WriteLine($"Received: {msg}");
    }
}

// 使用
var pub = new Publisher();
var sub = new Subscriber();
pub.OnMessage += sub.HandleMessage;
pub.SendMessage("Hello");

实际应用场景

LINQ（Language Integrated Query）

概念解释

LINQ 是 C# 3.0 引入的语言集成查询功能，允许使用类似 SQL 的语法对任何实现了 IEnumerable<T> 的集合进行查询操作。它将查询能力直接集成到语言中，提供编译时类型检查和 IntelliSense 支持。

核心要点

代码示例

var people = new List<Person>
{
    new Person { Name = "Alice", Age = 25, City = "Beijing" },
    new Person { Name = "Bob", Age = 30, City = "Shanghai" },
    new Person { Name = "Charlie", Age = 25, City = "Beijing" }
};

// 查询语法
var query = from p in people
            where p.Age > 20 && p.City == "Beijing"
            orderby p.Name
            select p.Name;

// 方法语法（等价）
var methodQuery = people
    .Where(p => p.Age > 20 && p.City == "Beijing")
    .OrderBy(p => p.Name)
    .Select(p => p.Name);

// 分组查询
var grouped = people.GroupBy(p => p.City)
                    .Select(g => new { City = g.Key, Count = g.Count() });

实际应用场景

async/await 异步编程

概念解释

async/await 是 C# 5.0 引入的异步编程模型，基于 Task 和 Task<T> 类型，使异步代码的编写和阅读体验接近同步代码。编译器会将 async/await 转换为状态机实现，避免了传统的回调地狱问题。

核心要点

代码示例

public async Task<string> DownloadAndProcessAsync(string url)
{
    using var client = new HttpClient();
    // 异步下载，不阻塞线程
    var content = await client.GetStringAsync(url);
    
    // 异步处理
    var result = await Task.Run(() => ProcessContent(content));
    return result;
}

// 并行执行多个异步操作
public async Task ProcessMultipleAsync()
{
    var task1 = DownloadAsync("url1");
    var task2 = DownloadAsync("url2");
    var task3 = DownloadAsync("url3");
    
    await Task.WhenAll(task1, task2, task3);
    
    var results = await Task.WhenAll(task1, task2, task3);
}

// 异步流（C# 8.0+）
public async IAsyncEnumerable<int> GenerateNumbersAsync()
{
    for (int i = 0; i < 10; i++)
    {
        await Task.Delay(100);
        yield return i;
    }
}

实际应用场景

泛型与反射

概念解释

泛型（Generics）允许定义类型安全的模板类和方法，在编译时或运行时用具体类型替换。反射（Reflection）使程序能够在运行时检查类型信息、动态创建对象、调用方法。

核心要点

代码示例

// 泛型类
public class Repository<T> where T : class, new()
{
    private readonly List<T> _items = new();
    
    public void Add(T item) => _items.Add(item);
    public T GetById(int id) => _items.FirstOrDefault();
}

// 泛型方法
public T Clone<T>(T source) where T : ICloneable
{
    return (T)source.Clone();
}

// 反射示例
public void InspectType(object obj)
{
    var type = obj.GetType();
    Console.WriteLine($"Type: {type.Name}");
    
    foreach (var prop in type.GetProperties())
    {
        Console.WriteLine($"  {prop.Name}: {prop.PropertyType.Name}");
    }
    
    // 动态创建实例
    var instance = Activator.CreateInstance(type);
    
    // 动态调用方法
    var method = type.GetMethod("ToString");
    var result = method.Invoke(instance, null);
}

实际应用场景

1.2 .NET 平台演进

概念解释

.NET 平台经历了从 .NET Framework（Windows 专用）到 .NET Core（跨平台）再到统一平台 .NET 5/6/7/8+ 的演进过程。理解各版本差异对于技术选型和迁移至关重要。

核心要点

版本对比 | 特性 | .NET Framework 4.8 | .NET Core 3.1 | .NET 6 (LTS) | .NET 8 (LTS) | |——|——————-|—————|————–|————–| | 跨平台 | 否 | 是 | 是 | 是 | | 性能 | 基准 | 2-5x 提升 | 进一步优化 | 再提升 20%+ | | 部署方式 | 全局安装 | 自包含/框架依赖 | 单文件发布 | Native AOT | | Web 框架 | ASP.NET MVC | MVC/Razor Pages | 最小 API | 最小 API + 源生成器 |

实际应用场景

1.3 CLR 运行时

概念解释

CLR（Common Language Runtime）是 .NET 的执行引擎，负责管理代码执行，提供内存管理、类型安全、异常处理、垃圾回收等服务。理解 CLR 原理对于性能调优和问题排查至关重要。

核心要点

GC 调优要点

// 查看 GC 信息
var gcInfo = GC.GetGCMemoryInfo();
Console.WriteLine($"Gen 0 collections: {gcInfo.GenerationInfo[0].Collections}");

// 强制回收（通常不推荐，仅用于特定场景）
GC.Collect();
GC.WaitForPendingFinalizers();

// 大对象分配优化
// 使用 ArrayPool<T> 避免频繁分配大数组
var pool = ArrayPool<byte>.Shared;
var buffer = pool.Rent(1024 * 1024);
try
{
    // 使用 buffer
}
finally
{
    pool.Return(buffer);
}

实际应用场景

二、Java 生态

2.1 Java 语言基础

集合框架

概念解释

Java 集合框架（Collections Framework）提供了一组接口和实现类，用于存储和操作对象组。核心接口包括 List、Set、Map、Queue，每种接口有多个实现类，适用于不同场景。

核心要点

代码示例

// List 使用
List<String> list = new ArrayList<>();
list.add("Java");
list.add("Python");
list.removeIf(s -> s.startsWith("P"));

// Map 使用
Map<Integer, String> map = new HashMap<>();
map.put(1, "One");
map.computeIfAbsent(2, k -> "Two");
map.merge(1, "Updated", (old, newVal) -> old + " " + newVal);

// Stream 与集合结合
List<String> result = list.stream()
    .filter(s -> s.length() > 3)
    .map(String::toUpperCase)
    .collect(Collectors.toList());

// ConcurrentHashMap
ConcurrentHashMap<String, Integer> concurrentMap = new ConcurrentHashMap<>();
concurrentMap.putIfAbsent("key", 1);
concurrentMap.compute("key", (k, v) -> v == null ? 1 : v + 1);

实际应用场景

反射与注解

概念解释

反射（Reflection）允许程序在运行时检查类、方法、字段信息并动态调用。注解（Annotation）是元数据机制，为代码添加标记，可被编译器或运行时读取。

核心要点

代码示例

// 自定义注解
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Retry {
    int maxAttempts() default 3;
    long delayMs() default 1000;
}

// 使用注解
public class Service {
    @Retry(maxAttempts = 5, delayMs = 2000)
    public void callExternalApi() {
        // 可能失败的操作
    }
}

// 反射读取注解
public void processAnnotations(Object obj) throws Exception {
    Class<?> clazz = obj.getClass();
    for (Method method : clazz.getDeclaredMethods()) {
        if (method.isAnnotationPresent(Retry.class)) {
            Retry retry = method.getAnnotation(Retry.class);
            System.out.println("Retry: " + retry.maxAttempts() + " times");
            // 实现重试逻辑
        }
    }
}

实际应用场景

IO 与 NIO

概念解释

Java IO 是基于流的阻塞式 I/O 模型，NIO（New IO）是基于缓冲区和通道的非阻塞 I/O 模型。NIO.2（Java 7）进一步提供了异步 I/O 和文件系统 API。

核心要点

代码示例

// 传统 IO
try (BufferedReader reader = new BufferedReader(
        new FileReader("input.txt"))) {
    String line;
    while ((line = reader.readLine()) != null) {
        process(line);
    }
}

// NIO.2 文件操作
Path path = Paths.get("data.txt");
List<String> lines = Files.readAllLines(path, StandardCharsets.UTF_8);
Files.walk(Paths.get("/tmp"))
     .filter(Files::isRegularFile)
     .forEach(System.out::println);

// 零拷贝文件传输
try (FileChannel source = new FileInputStream("source.dat").getChannel();
     FileChannel dest = new FileOutputStream("dest.dat").getChannel()) {
    source.transferTo(0, source.size(), dest);
}

实际应用场景

2.2 JVM 原理

概念解释

JVM（Java Virtual Machine）是 Java 程序的运行环境，提供跨平台能力、内存管理、垃圾回收、即时编译等功能。理解 JVM 原理是进行性能调优和问题排查的基础。

核心要点

JVM 内存模型

+---------------------------+
|         方法区             |  (元空间，存储类信息、常量)
+---------------------------+
|           堆              |  (对象实例，GC 主要区域)
|  +---------+---------+    |
|  | 新生代  | 老年代  |    |
|  +---------+---------+    |
+---------------------------+
|        虚拟机栈            |  (方法调用栈帧)
+---------------------------+
|       本地方法栈           |  (Native 方法)
+---------------------------+
|       程序计数器           |  (当前执行指令地址)
+---------------------------+

GC 调优示例

# G1 收集器配置（推荐）
java -XX:+UseG1GC \
     -XX:MaxGCPauseMillis=200 \
     -XX:G1HeapRegionSize=16m \
     -Xms4g -Xmx4g \
     -jar app.jar

# ZGC 配置（超低延迟）
java -XX:+UseZGC \
     -Xms8g -Xmx8g \
     -XX:+ZGenerational \
     -jar app.jar

# 打印 GC 日志
java -Xlog:gc*:file=gc.log:time,uptime,level,tags \
     -jar app.jar

实际应用场景

2.3 Java 8+ 新特性

概念解释

Java 8 是 Java 历史上最重要的版本之一，引入了 Lambda 表达式、Stream API、CompletableFuture 等特性，极大地提升了 Java 的表达能力和异步编程体验。后续版本持续改进，每半年发布一个新版本。

核心要点

代码示例

// Lambda 与方法引用
List<String> names = people.stream()
    .filter(p -> p.getAge() > 18)
    .map(Person::getName)
    .sorted()
    .collect(Collectors.toList());

// CompletableFuture 组合
CompletableFuture<String> future = CompletableFuture
    .supplyAsync(() -> fetchUserData())
    .thenApply(this::validate)
    .thenCombine(
        CompletableFuture.supplyAsync(() -> fetchOrderData()),
        this::mergeData
    )
    .exceptionally(ex -> {
        log.error("Error", ex);
        return fallbackData();
    });

// Optional 使用
Optional<User> user = findUserById(id);
String result = user.map(User::getName)
                    .orElse("Unknown");

// Record 类（Java 14+）
public record Point(int x, int y) {}
var p = new Point(10, 20);
System.out.println(p.x()); // 自动提供访问器

实际应用场景

三、Python 生态

3.1 Python 语言基础

概念解释

Python 是一门动态类型、解释型的高级编程语言，以简洁易读的语法著称。其核心特性包括装饰器、生成器、上下文管理器等，这些特性使 Python 在快速开发和数据科学领域占据主导地位。

核心要点

代码示例

# 装饰器
import functools
import time

def timer(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        elapsed = time.perf_counter() - start
        print(f"{func.__name__} took {elapsed:.4f}s")
        return result
    return wrapper

@timer
def slow_function(n):
    return sum(i * i for i in range(n))

# 生成器
def fibonacci(n):
    a, b = 0, 1
    for _ in range(n):
        yield a
        a, b = b, a + b

# 使用生成器（惰性求值，不占用大量内存）
for num in fibonacci(1000000):
    if num > 1000:
        break

# 上下文管理器
from contextlib import contextmanager

@contextmanager
def managed_resource(name):
    print(f"Acquiring {name}")
    resource = {"name": name}
    try:
        yield resource
    finally:
        print(f"Releasing {name}")

with managed_resource("database") as db:
    print(f"Using {db['name']}")

实际应用场景

3.2 异步编程

概念解释

Python 3.5 引入 async/await 语法，3.7 完善了 asyncio 标准库，使 Python 具备了现代异步编程能力。异步编程通过事件循环和协程实现高并发，特别适合 I/O 密集型场景。

核心要点

代码示例

import asyncio
import aiohttp

async def fetch_url(session, url):
    async with session.get(url) as response:
        return await response.text()

async def fetch_all(urls):
    async with aiohttp.ClientSession() as session:
        tasks = [fetch_url(session, url) for url in urls]
        results = await asyncio.gather(*tasks)
        return results

# 运行异步代码
async def main():
    urls = ["http://example.com/1", "http://example.com/2"]
    results = await fetch_all(urls)
    print(f"Fetched {len(results)} pages")

asyncio.run(main())

# 异步上下文管理器
class AsyncDatabase:
    async def __aenter__(self):
        self.connection = await create_connection()
        return self.connection
    
    async def __aexit__(self, exc_type, exc_val, exc_tb):
        await self.connection.close()

async def use_database():
    async with AsyncDatabase() as db:
        await db.execute("SELECT * FROM users")

实际应用场景

3.3 类型注解

概念解释

Python 3.5 引入类型注解（Type Hints），PEP 484 奠定了类型提示的基础。类型注解不会在运行时强制执行，但可以被静态类型检查器（如 mypy、pyright）用于编译时检查，提高代码质量和 IDE 支持。

核心要点

代码示例

from typing import Optional, List, Dict, TypeVar, Generic

# 基础类型注解
def greet(name: str) -> str:
    return f"Hello, {name}"

# 可选类型和容器
def find_user(user_id: int) -> Optional[Dict[str, str]]:
    # 可能返回 None
    return {"name": "Alice"} if user_id == 1 else None

# 泛型（Python 3.12+ 简化语法）
T = TypeVar('T')

class Stack(Generic[T]):
    def __init__(self) -> None:
        self.items: list[T] = []
    
    def push(self, item: T) -> None:
        self.items.append(item)
    
    def pop(self) -> T:
        return self.items.pop()

# Python 3.10+ 联合类型
def process(value: int | str) -> str:
    return str(value)

# Pydantic 运行时验证
from pydantic import BaseModel, EmailStr

class User(BaseModel):
    name: str
    email: EmailStr
    age: int

user = User(name="Alice", email="alice@example.com", age=25)

实际应用场景

四、跨语言对比

核心特性对比

特性 C# Java Python
类型系统 静态强类型，运行时保留泛型 静态强类型，泛型类型擦除 动态类型，可选类型注解
异步编程 async/await（基于 Task） CompletableFuture、Virtual Threads asyncio（基于事件循环）
内存管理 GC（分代，可配置模式） GC（G1/ZGC/Shenandoah） 引用计数 + GC（循环引用）
并发模型 Task Parallel Library、async/await 线程池、Virtual Threads（21+） asyncio、multiprocessing
依赖管理 NuGet Maven/Gradle pip/Poetry/uv
编译方式 JIT（可 AOT） JIT（JVM） 解释执行（可编译为字节码）
元编程 反射、表达式树、源生成器 反射、注解处理、字节码增强 装饰器、元类、动态属性
错误处理 try-catch-finally、异常过滤 try-catch-finally、受检异常 try-except-finally、异常链

异步编程模式对比

// C# async/await
public async Task<string> GetDataAsync()
{
    var result = await httpClient.GetStringAsync(url);
    return Process(result);
}

// Java CompletableFuture
public CompletableFuture<String> getData() {
    return CompletableFuture.supplyAsync(() -> httpClient.get(url))
                           .thenApply(this::process);
}

// Java 21+ Virtual Threads
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    executor.submit(() -> blockingOperation());
}

# Python asyncio
async def get_data():
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            return process(await response.text())

性能特征对比

场景 C# (.NET 8) Java 21 Python 3.12
启动时间 中等（Native AOT 快） 中等（CDS 优化） 快
吞吐量 高 高 中
内存占用 中 中高 低
I/O 密集型 优秀 优秀 良好
CPU 密集型 优秀 优秀 受 GIL 限制

技术选型建议

五、学习资源推荐

书籍推荐

C#/.NET

Java

Python

在线课程

官方文档

实践项目建议

  1. 入门阶段：完成官方教程中的示例项目，掌握基本语法和标准库
  2. 进阶阶段：构建一个完整的 Web API，集成数据库和认证
  3. 精通阶段：阅读开源项目源码，参与社区贡献，进行性能调优实践

知识关联