本文还有配套的精品资源，点击获取

简介：本题库旨在帮助C#初学者巩固和提升编程基础，涵盖从语法到核心概念的各个方面。题库包含丰富的练习题目，包括变量、数据类型、类与对象、异常处理、委托与事件、文件I/O操作、LINQ与Lambda表达式、面向接口编程以及泛型等内容，帮助学员通过练习题目掌握这些基础知识，并在实践中提高编程技能，为高级学习打下坚实基础。

1. C#基础语法和概念练习

理解C#基础语法

C#（发音为“C Sharp”）是一种由微软开发的现代、类型安全的面向对象编程语言。它是.NET框架的核心语言，广泛应用于开发Windows应用程序、Web服务、分布式组件等。理解C#的基础语法是编写有效代码和进行后续学习的关键。

在这一章节，我们将重点练习以下几个方面：

• C#程序结构的基本组成，例如命名空间、类和方法。
• 数据类型和变量的声明，理解值类型与引用类型的区别。
• 流程控制语句的使用，包括if-else、for、while、switch-case等。

简单示例

下面是一个简单的C#程序，演示了如何定义一个类、方法和使用控制台输出。

using System;

namespace CSharpBasics
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello, C# world!");
        }
    }
}

代码解析

• using System; ：引入System命名空间，它包含了C#标准库。
• namespace CSharpBasics ：定义一个命名空间，有助于组织和管理代码。
• class Program ：定义一个公共类 Program 。
• static void Main(string[] args) ：定义程序的入口点，即主方法。
• Console.WriteLine(...); ：调用控制台输出方法来显示信息。

练习

作为练习，尝试使用不同的数据类型来声明变量，并通过各种控制流程语句来改变程序的执行路径。理解每种数据类型和控制语句的适用场景，有助于加深对C#基础语法的理解。

2. 面向对象编程题目

2.1 类与对象

2.1.1 创建类和对象的实例

面向对象编程（OOP）的基础是类（Class）和对象（Object）。在C#中，类是一种定义对象的蓝图或模板。对象是类的具体实例，它包含数据和操作这些数据的方法。

下面是一个简单的类和对象创建的例子：

public class Car
{
    public string Make { get; set; }
    public string Model { get; set; }
    public int Year { get; set; }

    public Car(string make, string model, int year)
    {
        Make = make;
        Model = model;
        Year = year;
    }

    public void DisplayInfo()
    {
        Console.WriteLine($"Make: {Make}, Model: {Model}, Year: {Year}");
    }
}

// 创建对象实例
Car myCar = new Car("Toyota", "Corolla", 2020);
myCar.DisplayInfo();

在这段代码中， Car 是一个类，它具有三个属性（ Make 、 Model 和 Year ）和两个方法（构造函数和 DisplayInfo ）。 DisplayInfo 方法用于显示汽车的信息。

2.1.2 类的构造函数和析构函数

构造函数是一种特殊的方法，用于创建类的新实例时初始化对象。在C#中，构造函数必须与类名同名，并且没有返回类型。

下面展示了一个带有构造函数的 Car 类：

public class Car
{
    // ...其他成员...

    // 构造函数
    public Car(string make, string model, int year)
    {
        Make = make;
        Model = model;
        Year = year;
    }
}

析构函数在C#中是一个特殊的方法，用于销毁类的实例。由于C#采用垃圾回收机制，通常不需要显式定义析构函数，但当需要执行一些清理任务时可以使用。

~Car()
{
    // 执行清理任务
}

2.1.3 访问修饰符的使用

访问修饰符控制对类成员的访问级别。C#支持五种访问修饰符： public 、 private 、 protected 、 internal 和 protected internal 。

下面是一个使用访问修饰符的例子：

public class Car
{
    private string make;
    public string Model { get; set; }
    protected int year;

    // ...其他成员和方法...
}

在上面的例子中， make 字段被声明为 private ，意味着它只能在 Car 类的内部访问。 Model 属性被声明为 public ，因此可以从类的外部访问。 year 字段被声明为 protected ，这允许它在派生类中访问。

2.2 继承与多态

2.2.1 实现继承的基本概念

继承是面向对象编程的一个核心概念，它允许一个类继承另一个类的属性和方法。在C#中，使用冒号 : 来表示继承，继承的类称为派生类，被继承的类称为基类。

下面是一个简单的继承示例：

public class Vehicle
{
    public string Brand { get; set; }
    public virtual void DisplayInfo()
    {
        Console.WriteLine("This is a generic vehicle.");
    }
}

public class Car : Vehicle
{
    public int NumberOfDoors { get; set; }

    // 重写基类方法
    public override void DisplayInfo()
    {
        Console.WriteLine($"Brand: {Brand}, Doors: {NumberOfDoors}");
    }
}

在上述代码中， Car 类继承自 Vehicle 类， Car 类可以访问 Vehicle 类的所有非私有成员。 DisplayInfo 方法被 Vehicle 类声明为 virtual ，允许 Car 类重写（override）这个方法。

2.2.2 虚函数和抽象类的使用

虚函数允许在派生类中提供自己的实现，而抽象类则是不能直接实例化的类，它通常包含一个或多个抽象方法，这些方法必须在非抽象的派生类中被重写。

下面是一个使用抽象类和虚函数的例子：

public abstract class Shape
{
    public abstract void Draw();
}

public class Rectangle : Shape
{
    public override void Draw()
    {
        Console.WriteLine("Drawing a rectangle.");
    }
}

public class Circle : Shape
{
    public override void Draw()
    {
        Console.WriteLine("Drawing a circle.");
    }
}

在这个例子中， Shape 是一个抽象类，它定义了一个抽象方法 Draw 。 Rectangle 和 Circle 类继承自 Shape 类，并重写了 Draw 方法以提供具体的绘制行为。

2.2.3 接口与抽象类的区别

接口和抽象类都用于实现继承，但是它们之间存在一些关键的区别。接口定义了一组方法规范，但不提供实现，而抽象类可以提供方法的具体实现。

下面展示了接口和抽象类的区别：

// 接口定义
public interface IShape
{
    void Draw();
}

// 抽象类定义
public abstract class Shape
{
    public abstract void Draw();
}

// 接口实现
public class Circle : IShape
{
    public void Draw()
    {
        Console.WriteLine("Drawing a circle.");
    }
}

// 抽象类继承
public class Square : Shape
{
    public override void Draw()
    {
        Console.WriteLine("Drawing a square.");
    }
}

在这个例子中， IShape 是一个接口，定义了 Draw 方法的规范，而 Shape 是一个抽象类，提供了 Draw 方法的抽象定义。 Circle 和 Square 分别实现了接口和继承了抽象类。

2.3 封装与设计原则

2.3.1 封装的重要性和实现方式

封装是面向对象编程的三大特征之一，它指的是将数据和操作数据的方法捆绑在一起，隐藏对象的内部实现细节，仅通过公共接口暴露功能。

实现封装的一种常见方式是使用属性（Properties）。属性允许我们控制对私有字段的访问，并可以在读取和设置值时执行额外的逻辑。

public class Person
{
    private string name;

    public string Name
    {
        get { return name; }
        set
        {
            if (value.Length > 0)
            {
                name = value;
            }
        }
    }
}

在这个例子中， Person 类有一个私有字段 name 和一个公共属性 Name 。属性允许外部代码读取和设置 name 字段的值，同时我们可以在这个过程中添加验证逻辑，确保 name 字段在设置时不为空。

2.3.2 SOLID设计原则简介

SOLID是一组面向对象设计原则的首字母缩写，旨在提高软件的可维护性和可扩展性。SOLID原则包括五个方面：单一职责、开闭原则、里氏替换、接口隔离和依赖倒置。

• 单一职责原则（Single Responsibility Principle, SRP）：一个类应该只有一个引起变更的原因。
• 开闭原则（Open/Closed Principle, OCP）：软件实体应对扩展开放，对修改关闭。
• 里氏替换原则（Liskov Substitution Principle, LSP）：子类型必须能够替换掉它们的父类型。
• 接口隔离原则（Interface Segregation Principle, ISP）：不应该强迫客户依赖于它们不用的方法。
• 依赖倒置原则（Dependency Inversion Principle, DIP）：高层模块不应依赖于低层模块，两者都应该依赖于抽象。

下面是一个遵循SOLID原则的代码示例：

public interface IDriveable
{
    void Drive();
}

public interface IFlyable
{
    void Fly();
}

public class Airplane : IFlyable
{
    public void Fly()
    {
        Console.WriteLine("Flying in the sky.");
    }
}

public class Helicopter : IDriveable, IFlyable
{
    public void Drive()
    {
        Console.WriteLine("Driving on the road.");
    }

    public void Fly()
    {
        Console.WriteLine("Flying in the air.");
    }
}

在这个例子中， Airplane 类实现了 IFlyable 接口，表示它可以飞行； Helicopter 类同时实现了 IDriveable 和 IFlyable 接口，表示它既可以飞行也可以驾驶。这样的设计允许 Airplane 和 Helicopter 被独立地修改和扩展，而不影响彼此或其他使用这些类的代码。

2.3.3 代码重构的实践

代码重构是改善现有代码结构的过程，而不改变其外部行为。重构有助于减少代码复杂性，提高代码的可读性和可维护性。

重构的一个常见例子是提取方法（Extract Method）：

public class Calculator
{
    public int AddNumbers(int a, int b)
    {
        return a + b; // 原始代码
    }
}

// 重构后
public class Calculator
{
    public int AddNumbers(int a, int b)
    {
        return Sum(a, b);
    }

    private int Sum(int a, int b)
    {
        return a + b; // 提取为新方法
    }
}

在这个例子中，原始方法 AddNumbers 被重构，方法中的逻辑被提取到一个名为 Sum 的新方法中。这样做的好处是使得 AddNumbers 方法更加简洁，并且让 Sum 方法可以被其他方法重用。

此外，重构通常伴随着重构现有代码以符合SOLID原则，例如将类分解为更小的职责单一的类，或是将接口从类中抽象出来。代码重构是软件开发中的一项持续任务，它可以帮助团队持续提升代码质量。

3. 集合与数组操作

3.1 集合的使用和特性

3.1.1 List , Dictionary 等集合的使用

在C#中，集合类是实现 IEnumerable 接口的一组元素的集合，支持添加、删除和检索操作。最基本的集合类型包括 List<T> 和 Dictionary<TKey, TValue> 。 List<T> 是一种动态数组，而 Dictionary<TKey, TValue> 则是以键值对形式存储元素的集合。

List<T> 可以动态地调整大小，支持通过索引访问元素，这使得它非常适用于顺序数据的存储。 Dictionary<TKey, TValue> 则用于通过键快速访问数据，它基于键的哈希码进行操作，因此具有高效的查找和插入性能。

以下是一个简单的示例，演示了如何使用 List<T> 和 Dictionary<TKey, TValue> ：

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // List 示例
        List<int> numbers = new List<int>();
        numbers.Add(1);
        numbers.Add(2);
        numbers.Add(3);
        // Dictionary 示例
        Dictionary<string, string> keyValuePairs = new Dictionary<string, string>();
        keyValuePairs.Add("key1", "value1");
        keyValuePairs.Add("key2", "value2");
        keyValuePairs.Add("key3", "value3");
        // 遍历集合
        foreach (int number in numbers)
        {
            Console.WriteLine(number);
        }
        foreach (KeyValuePair<string, string> pair in keyValuePairs)
        {
            Console.WriteLine($"Key: {pair.Key}, Value: {pair.Value}");
        }
    }
}

3.1.2 集合的遍历和元素访问

集合中的元素可以使用 foreach 循环来遍历。对于 List<T> ，还可以通过索引访问元素，但对于 Dictionary<TKey, TValue> ，需要使用键来获取值。

遍历 List<T> 和 Dictionary<TKey, TValue> 的代码已经包含在之前的示例中。为了进一步说明，让我们使用索引访问 List<T> 中的元素：

// 假设我们想访问numbers列表中的第一个元素
if (numbers.Count > 0)
{
    int firstElement = numbers[0];
    Console.WriteLine($"The first element in the list is: {firstElement}");
}

3.1.3 集合的排序和比较

为了对集合中的元素进行排序，可以使用 List<T> 提供的 Sort() 方法。此外，如果需要比较两个集合的内容，可以使用 SequenceEqual() 方法。

下面的例子展示了如何对整数列表进行排序，并比较两个列表是否相等：

// 排序
numbers.Sort();

// 打印排序后的列表
foreach (int number in numbers)
{
    Console.WriteLine(number);
}

// 创建第二个列表并排序，用于比较
List<int> numbers2 = new List<int> { 1, 2, 3 };
numbers2.Sort();

// 比较两个列表是否相等
bool areEqual = numbers.SequenceEqual(numbers2);
Console.WriteLine($"The lists are {(areEqual ? "equal" : "not equal")}.");

3.2 数组与集合的转换

3.2.1 数组与List间的转换

在处理数据时，我们可能需要在数组和 List<T> 之间进行转换。 List<T> 提供了 ToArray() 和 AddRange() 方法来实现这一目的。

以下是如何进行数组与List之间转换的示例：

// 数组转换为List
int[] array = { 1, 2, 3 };
List<int> listFromArray = new List<int>(array);

// List转换为数组
List<int> list = new List<int> { 1, 2, 3 };
int[] arrayFromList = list.ToArray();

3.2.2 集合间的转换技巧

除了数组和List之间的转换，有时候可能需要将一个集合类型转换为另一个集合类型。这种转换通常利用集合提供的构造函数实现。

例如，将 List<T> 转换为 Dictionary<TKey, TValue> ：

// List转换为Dictionary，这里我们假设每个元素都是一个键值对
List<KeyValuePair<string, string>> keyValueList = new List<KeyValuePair<string, string>>
{
    new KeyValuePair<string, string>("key1", "value1"),
    new KeyValuePair<string, string>("key2", "value2"),
    new KeyValuePair<string, string>("key3", "value3")
};

Dictionary<string, string> dictionary = new Dictionary<string, string>(keyValueList);

3.2.3 使用LINQ简化集合操作

LINQ（语言集成查询）是C#中一个非常强大的特性，它允许你使用查询表达式来操作数据源。使用LINQ可以轻松地进行集合的转换、排序和过滤等操作。

下面是如何使用LINQ来对一个 List<T> 进行排序和过滤的示例：

// 使用LINQ对列表进行排序和过滤
List<int> filteredAndSorted = numbers
    .Where(x => x > 1) // 过滤条件：元素大于1
    .OrderBy(x => x)   // 排序条件：按照升序
    .ToList();          // 转换为List

// 打印LINQ操作后的列表
foreach (int number in filteredAndSorted)
{
    Console.WriteLine(number);
}

通过本章节的介绍，你可以看到集合与数组操作的多样性和便利性。对 List<T> , Dictionary<TKey, TValue> 等集合的使用和特性有了深入的了解，同时学会了如何进行集合的遍历、元素访问以及排序和比较。此外，掌握了数组与List间以及集合间的转换技巧，并认识到了LINQ在简化集合操作方面的强大功能。

4. 异常处理实践

异常处理是编程中不可或缺的一部分，它帮助开发者处理程序运行时可能遇到的错误情况，以确保程序的健壮性和稳定性。本章将深入探讨异常处理在C#中的实践，包括异常的层次结构、异常处理机制、自定义异常以及异常的过滤和日志记录。

4.1 异常类的层次结构

异常类是.NET Framework中用于表示程序运行时错误的对象。C#提供了一个丰富的异常类层次结构，允许开发者使用预定义的异常类或创建自定义异常类来处理错误。

4.1.1 常用的内置异常类

C#提供了多种内置异常类，它们覆盖了最常见的错误情况，例如：

• System.Exception ：所有异常类的基类，一般不直接使用。
• System.ArgumentException ：当方法接收到一个参数值不正确时抛出。
• System.IndexOutOfRangeException ：当数组或集合索引超出范围时抛出。
• System.InvalidOperationException ：当操作无法在对象的当前状态下执行时抛出。
• System.TimeoutException ：当操作超时时抛出。

下面的代码展示了如何捕获一个 IndexOutOfRangeException ：

int[] numbers = { 1, 2, 3 };
try
{
    Console.WriteLine(numbers[3]);
}
catch (IndexOutOfRangeException e)
{
    Console.WriteLine(e.Message);
}

4.1.2 自定义异常类的创建和使用

在某些情况下，内置异常类无法准确描述错误的上下文。这时，开发者可以创建自己的异常类。自定义异常类通常继承自 System.Exception 类。

public class CustomException : Exception
{
    public CustomException(string message) : base(message)
    {
    }

    public CustomException(string message, Exception innerException) : base(message, innerException)
    {
    }
}

自定义异常可以提供更具体的错误信息：

throw new CustomException("An error occurred in the process.", innerException);

4.2 异常处理机制

异常处理机制提供了 try , catch , finally 块来处理程序运行时的错误。

4.2.1 try-catch-finally的用法

• try 块包围了可能会抛出异常的代码。
• catch 块用来捕获并处理特定类型的异常。
• finally 块则包含无论是否发生异常都必须执行的代码。

下面是一个包含所有三个部分的示例：

try
{
    // 代码块，可能抛出异常
}
catch (Exception ex)
{
    // 处理异常
    Console.WriteLine($"Error: {ex.Message}");
}
finally
{
    // 清理资源或执行其它清理工作
    Console.WriteLine("Cleanup after exception handling.");
}

4.2.2 throw和throw-if的应用场景

在C#中， throw 关键字用于显式抛出异常。 throw-if 是一个常用的编程模式，用来判断条件是否满足，如果不满足则抛出异常。

if (someCondition == false)
    throw new InvalidOperationException("Condition not met.");

// 可以用一个方法来封装这个模式
void CheckCondition(bool condition, string errorMessage)
{
    if (!condition)
        throw new InvalidOperationException(errorMessage);
}

4.2.3 异常的过滤和日志记录

在处理异常时，可能需要根据不同的异常类型或条件来执行不同的逻辑。异常过滤器可以实现这一点，它们使用 when 关键字来指定过滤条件。

try
{
    // 可能抛出异常的代码
}
catch (Exception ex) when (ex is IOException)
{
    // 仅当异常是IOException时才处理
    Console.WriteLine("IO error occurred.");
}
catch (Exception ex)
{
    // 处理其他类型的异常
}

异常日志记录通常涉及到记录异常信息到日志文件中，这可以通过使用如NLog、log4net等日志框架来实现。

// 使用NLog进行日志记录
var logger = LogManager.GetCurrentClassLogger();
try
{
    // 可能抛出异常的代码
}
catch (Exception ex)
{
    logger.Error(ex, "An error occurred.");
}

在这一章节中，我们详细探讨了异常处理的实践，包括异常类的层次结构、异常处理机制的使用、自定义异常的创建以及异常的过滤和日志记录。理解并正确使用这些概念对于编写健壮的C#应用程序至关重要。

异常处理是一个深奥的主题，它需要开发者不断地实践和积累经验。熟练掌握这些技巧将帮助你写出更加可靠和用户友好的代码。下一章我们将继续深入讨论委托与事件的应用，这是C#语言中实现解耦和事件驱动编程的强大机制。

5. 委托与事件应用

5.1 委托的理解和使用

5.1.1 委托的基本概念和声明

在C#中，委托是一种类型，它可以引用具有特定参数列表和返回类型的方法。委托类似于C或C++中的函数指针，但比函数指针更安全、更具有面向对象特性。通过使用委托，可以将方法作为参数传递给其他方法，或将方法挂载到事件上，从而实现回调机制和订阅发布模式。

委托声明的语法如下：

[访问修饰符] delegate 返回类型 委托名称(参数列表);

例如，以下是一个简单的委托声明，它引用一个返回类型为 void ，不接受任何参数的方法：

public delegate void SimpleDelegate();

任何符合指定签名的方法都可以被这个委托引用。例如：

void MyMethod()
{
    Console.WriteLine("This is a method referenced by a delegate.");
}

5.1.2 多播委托的应用

多播委托是一个可以引用多个方法的委托。当调用多播委托时，所有引用的方法将按顺序执行。这在需要执行一系列任务时非常有用，例如事件处理或日志记录。多播委托通过在委托类型后加一个 + 号来声明：

public delegate void MulticastDelegate();

通过使用 + 或 += 操作符，可以将多个方法附加到同一个委托实例上：

SimpleDelegate del = MyMethod;
del += AnotherMethod; // AnotherMethod方法签名需与委托一致
del += YetAnotherMethod; // YetAnotherMethod方法签名需与委托一致

// 调用时，MyMethod, AnotherMethod, YetAnotherMethod将依次执行
del();

为了演示委托的使用，下面创建一个程序示例：

public class Program
{
    public delegate void PrintMessageDelegate(string message);
    public static void Main(string[] args)
    {
        // 创建委托实例并关联方法
        PrintMessageDelegate printer = PrintMessage;
        printer += PrintMessage; // 可以添加更多的方法
        printer("Hello, Delegates!");
    }
    // 实现委托引用的方法
    public static void PrintMessage(string message)
    {
        Console.WriteLine(message);
    }
}

以上代码定义了一个 PrintMessageDelegate 委托，并创建了一个委托实例 printer 。我们关联了 PrintMessage 方法两次，当 printer 被调用时，它会输出两次消息。

5.2 事件的定义和触发

5.2.1 事件的声明和订阅

事件是.NET中实现发布/订阅模式的一种机制。事件提供了一种让对象向其他对象通知发生的操作的方式。在C#中，事件是建立在委托基础上的，一个事件的声明本质上是声明了一个特殊的多播委托。

事件声明语法如下：

public event 委托类型 事件名称;

例如，声明一个简单事件：

public event SimpleDelegate MyEvent;

订阅事件使用 += 操作符，取消订阅使用 -= 操作符。

public class Publisher
{
    public event SimpleDelegate MyEvent;

    public void RaiseEvent()
    {
        if(MyEvent != null)
        {
            MyEvent(); // 当MyEvent不为null时调用所有订阅的方法
        }
    }
}

public class Subscriber
{
    public void OnMyEvent()
    {
        Console.WriteLine("Event has been raised.");
    }
}

public class Program
{
    public static void Main(string[] args)
    {
        Publisher pub = new Publisher();
        Subscriber sub = new Subscriber();
        pub.MyEvent += sub.OnMyEvent; // 订阅事件
        pub.RaiseEvent(); // 触发事件
        pub.MyEvent -= sub.OnMyEvent; // 取消订阅事件
    }
}

5.2.2 事件的触发机制和标准模式

在.NET框架中，事件的触发机制遵循一个特定的标准模式，这主要是为了保证封装性和避免某些潜在的问题。标准模式通常包括一个私有的委托字段，一个受保护的虚拟方法用于触发事件，以及一个公开的受保护方法用于添加或移除事件处理器。

标准模式下的事件声明可能如下所示：

public class EventPublisher
{
    private event SimpleDelegate _myEvent;

    public event SimpleDelegate MyEvent
    {
        add
        {
            _myEvent += value;
        }
        remove
        {
            _myEvent -= value;
        }
    }

    public void RaiseMyEvent()
    {
        SimpleDelegate handler = _myEvent;
        if(handler != null)
        {
            handler();
        }
    }
}

在这个例子中， MyEvent 是公开的事件，而 _myEvent 是私有的委托实例。 add 和 remove 访问器提供了添加和移除事件处理器的能力，同时保持了封装性。 RaiseMyEvent 方法用于触发事件，它首先检查委托是否为 null ，然后调用所有订阅的方法。

该模式确保了即使多个消费者订阅了同一事件，也没有一个消费者可以直接访问或修改事件的内部委托实例，增强了类的封装性和事件的线程安全。

在.NET中，开发者几乎总会使用 += 和 -= 操作符来添加或移除事件处理器，而直接操作底层委托字段的代码是不常见的。这种模式已经成为了.NET框架中事件处理的标准做法。

6. 文件I/O操作练习

在现代应用程序中，与文件系统的交互是不可或缺的一部分。第六章将深入探讨如何在C#中进行文件和目录操作，包括文本和二进制文件的读写，以及文件系统中文件和目录信息的获取与管理。我们将通过代码示例、逻辑分析和参数说明来展示如何有效地处理文件I/O操作。

6.1 文件读写操作

6.1.1 使用StreamReader和StreamWriter进行文本文件操作

处理文本文件是日常编程任务的一部分。在C#中， System.IO 命名空间下的 StreamReader 和 StreamWriter 类为我们提供了便捷的方式来读取和写入文本文件。

代码示例：

using System;
using System.IO;

class Program
{
    static void Main()
    {
        string path = @"C:\example.txt";
        // 写入文本到文件
        using (StreamWriter writer = new StreamWriter(path))
        {
            writer.WriteLine("Hello, World!");
            writer.WriteLine("这是第一段文本.");
        }

        // 读取文件内容
        using (StreamReader reader = new StreamReader(path))
        {
            string line;
            while ((line = reader.ReadLine()) != null)
            {
                Console.WriteLine(line);
            }
        }
    }
}

逻辑分析：

在上述示例中， StreamWriter 用于将文本写入文件，而 StreamReader 用于从文件中读取文本。 using 语句确保在操作完成后正确地关闭流，这是因为它们实现了 IDisposable 接口。

StreamWriter 的构造函数接受一个文件路径，并创建一个新的写入流。 WriteLine 方法用于写入一行文本到文件。

StreamReader 的构造函数同样接受文件路径。 ReadLine 方法用于逐行读取文件内容，直到到达文件末尾。

6.1.2 二进制文件的读写方法

除了文本文件，处理二进制文件也是常见的需求。C#同样提供了相应的工具类来处理二进制数据： BinaryReader 和 BinaryWriter 。

代码示例：

using System;
using System.IO;

class Program
{
    static void Main()
    {
        string path = @"C:\example.bin";
        // 写入二进制数据到文件
        using (BinaryWriter writer = new BinaryWriter(File.Create(path)))
        {
            writer.Write("二进制数据");
            writer.Write(123456);
        }

        // 读取二进制文件
        using (BinaryReader reader = new BinaryReader(File.OpenRead(path)))
        {
            string data = reader.ReadString();
            int number = reader.ReadInt32();
            Console.WriteLine($"读取的文本：{data}");
            Console.WriteLine($"读取的数字：{number}");
        }
    }
}

逻辑分析：

在这个例子中， BinaryWriter 用于写入字符串和整数到二进制文件。 Write 方法能够根据数据类型将数据写入流。

BinaryReader 用于从二进制文件中读取数据。 ReadString 和 ReadInt32 方法分别用于读取字符串和整数类型的数据。

6.2 文件系统与目录操作

6.2.1 获取文件和目录信息

获取文件或目录的相关信息是基本的文件系统操作。C#提供了 FileInfo 和 DirectoryInfo 类来获取和管理这些信息。

代码示例：

using System;
using System.IO;

class Program
{
    static void Main()
    {
        string filePath = @"C:\example.txt";
        string dirPath = @"C:\exampleDir";

        // 获取文件信息
        FileInfo fileInfo = new FileInfo(filePath);
        Console.WriteLine($"文件名：{fileInfo.Name}");
        Console.WriteLine($"文件大小：{fileInfo.Length} 字节");
        Console.WriteLine($"最后修改时间：{fileInfo.LastWriteTime}");

        // 获取目录信息
        DirectoryInfo dirInfo = new DirectoryInfo(dirPath);
        Console.WriteLine($"目录名：{dirInfo.Name}");
        Console.WriteLine($"目录创建时间：{dirInfo.CreationTime}");
    }
}

逻辑分析：

FileInfo 实例化时需要文件路径，它提供了多个属性来获取文件信息，如 Name 、 Length 和 LastWriteTime 。

类似地， DirectoryInfo 也需要一个目录路径参数，它提供关于目录的详细信息，如 Name 和 CreationTime 。

6.2.2 文件和目录的创建、移动和删除

文件和目录的操作还包括创建、移动和删除，这些是管理文件系统资源的基本功能。

代码示例：

using System;
using System.IO;

class Program
{
    static void Main()
    {
        string sourcePath = @"C:\source.txt";
        string destPath = @"C:\destDir\dest.txt";
        string dirPath = @"C:\exampleDir";

        // 创建文件
        File.Create(sourcePath);

        // 创建目录
        Directory.CreateDirectory(dirPath);

        // 移动文件
        File.Move(sourcePath, destPath);

        // 删除文件
        File.Delete(destPath);

        // 删除目录
        Directory.Delete(dirPath);
    }
}

逻辑分析：

File.Create 方法创建并打开一个新文件，返回 FileStream 对象，可用于进一步操作文件。

Directory.CreateDirectory 方法创建一个新的目录。

File.Move 方法用于移动或重命名文件。

File.Delete 方法用于删除文件，而 Directory.Delete 方法则用于删除目录及其所有内容。

通过以上章节，我们已经介绍了如何在C#中使用各种方法来操作文件和目录。本章的练习将帮助你巩固这些知识，并在实际项目中有效地运用它们。在下一章节中，我们将进一步探索LINQ和Lambda表达式，这两种强大的工具将进一步扩展我们处理数据的能力。

7. LINQ和Lambda表达式使用

7.1 LINQ基础

LINQ（Language Integrated Query）是C#中一个强大的数据查询功能，它允许开发者使用统一的查询语法来查询和操作数据源。这一部分将探讨LINQ查询表达式的构建以及如何将其应用于对象。

7.1.1 LINQ查询表达式的构建

构建LINQ查询表达式包含几个核心组件：数据源、查询变量、从句（如 where 、 select 、 orderby 等）。下面是一个简单的LINQ查询构建过程的例子：

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

namespace LinqExample
{
    class Program
    {
        static void Main(string[] args)
        {
            // 创建一个简单的数据源
            List<Student> students = new List<Student>
            {
                new Student{ Name="Alice", Age=19, Grade='A' },
                new Student{ Name="Bob", Age=20, Grade='B' },
                new Student{ Name="Charlie", Age=18, Grade='C' }
            };

            // 构建LINQ查询
            var query = from student in students
                        where student.Age > 18
                        orderby student.Grade descending
                        select student.Name;

            // 执行查询并打印结果
            foreach (var name in query)
            {
                Console.WriteLine(name);
            }
        }
    }

    class Student
    {
        public string Name { get; set; }
        public int Age { get; set; }
        public char Grade { get; set; }
    }
}

7.1.2 LINQ to Objects的使用

LINQ to Objects 是LINQ技术中最常用的方面之一，它允许直接对任何实现了 IEnumerable 或 IEnumerable<T> 接口的对象进行查询。使用 LINQ to Objects 可以简化对集合的操作，提供清晰且易于理解的代码结构。

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

namespace LinqToObjectsExample
{
    class Program
    {
        static void Main(string[] args)
        {
            // 创建一个整数列表
            List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9 };

            // 使用LINQ to Objects查询大于5的数字
            var query = numbers.Where(x => x > 5);

            // 执行查询并打印结果
            foreach (var number in query)
            {
                Console.WriteLine(number);
            }
        }
    }
}

7.2 Lambda表达式的高级应用

Lambda表达式提供了一种简洁的方式来表示匿名方法，常与LINQ和委托一起使用，用于简化代码并提高表达的清晰度。

7.2.1 Lambda表达式的语法和作用

Lambda表达式的一般语法为 (parameters) => expression 或 (parameters) => { statements; } ，其作用主要是定义匿名函数，无需显式地声明方法。

Func<int, int, int> add = (x, y) => x + y;

// 使用Lambda表达式作为参数
List<int> numbers = new List<int> { 1, 2, 3, 4 };
numbers.ForEach(n => Console.WriteLine(n));

// Lambda表达式在LINQ查询中的应用
var query = numbers.Where(x => x % 2 == 0);

7.2.2 Lambda表达式在委托和事件中的应用

在委托和事件编程中，Lambda表达式可以作为事件处理器或委托的目标方法，这样可以非常方便地为事件或委托添加处理逻辑。

// 委托使用Lambda表达式
Action<string> logMessage = message => Console.WriteLine($"Log: {message}");
logMessage("Hello, Lambda!");

// 事件使用Lambda表达式
public event Action<double> ProgressChanged;

// 事件触发时使用Lambda表达式
ProgressChanged?.Invoke(0.5);

通过这些示例和解释，我们可以看到LINQ和Lambda表达式如何在C#中提升数据操作和事件处理的效率。第七章的内容不仅教会了我们如何使用这些工具，还展示了它们在实际开发中的多种用途。

本文还有配套的精品资源，点击获取

简介：本题库旨在帮助C#初学者巩固和提升编程基础，涵盖从语法到核心概念的各个方面。题库包含丰富的练习题目，包括变量、数据类型、类与对象、异常处理、委托与事件、文件I/O操作、LINQ与Lambda表达式、面向接口编程以及泛型等内容，帮助学员通过练习题目掌握这些基础知识，并在实践中提高编程技能，为高级学习打下坚实基础。

本文还有配套的精品资源，点击获取