LiteDB 是一个轻量、快速、嵌入式的 NoSQL 数据库。它不需要服务器，适用于桌面、移动应用以及小型 Web API 项目，本人在一些小项目中比较喜欢使用。本文将介绍 LiteDB 的主要特点以及如何在 C# 中使用 LiteDB，通过完整的例子展示常见的数据库操作。

## LiteDB 主要特点

- **无需服务器**：LiteDB 运行于单一 DLL 中，不需要复杂的服务器配置。
- **轻量级**：数据库文件小巧，适用于资源受限的环境。
- **嵌入式**：LiteDB 直接嵌入到应用程序中。
- **NoSQL**：基于 BSON（二进制 JSON 序列化协议）存储数据。
- **简单易用**：通过简单的 API 实现 CRUD 操作。
- **支持 LINQ**：方便的数据查询与操作支持。



## 安装 LiteDB

首先，通过 NuGet 包管理器安装 LiteDB。可以在 Visual Studio 的包管理控制台中输入以下命令：

```PowerShell
Install-Package LiteDB
```

或者在 `.csproj` 文件中添加以下包引用：

```XML
<PackageReference Include="LiteDB" Version="5.0.9" />
```


![image.png](https://blog.idiosoft.com/static/img/0f9ff246431261ffcacb80d68be6220e.image.webp)

## 快速开始

我们将通过一个简单的 C# 控制台应用展示如何使用 LiteDB 实现基本的 CRUD（创建、读取、更新、删除）操作。

### 1. 创建实体类

首先，我们需要定义一个实体类。例如，我们要在数据库中存储用户信息，定义如下：

```C#
public class User
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Email { get; set; }
}
```

### 2. 插入数据

插入数据是基本的数据库操作，我们首先创建 LiteDatabase 实例，然后获取集合并插入数据。

```C#
private void btnInsert_Click(object sender, EventArgs e)
{
    // 连接数据库（若文件不存在会自动创建）
    using (var db = new LiteDatabase(@"MyData.db"))
    {
        // 获取 User 集合（若不存在会自动创建）
        var users = db.GetCollection<User>("users");

        // 创建新的 User 对象并插入集合
        var user = new User { Name = "John Doe", Email = "johndoe@example.com" };
        users.Insert(user);

        Console.WriteLine("User inserted with Id: " + user.Id);
    }
}

```

![image.png](https://blog.idiosoft.com/static/img/5a2d8d49273d2bf90c371381434a4700.image.webp)

### 3. 查询数据

LiteDB 提供了简单的查询接口，可以使用 LINQ 查询或通过 BsonExpression 指定查询条件。

```C#
private void btnSearch_Click(object sender, EventArgs e)
{
    // 连接数据库
    using (var db = new LiteDatabase(@"MyData.db"))
    {
        var users = db.GetCollection<User>("users");

        // 通过 Id 查询单个用户
        var user = users.FindById(1);
        if (user != null)
        {
            Console.WriteLine($"User found: {user.Name}, {user.Email}");
        }

        // 使用 LINQ 查询所有用户
        var allUsers = users.FindAll().ToList();
        foreach (var u in allUsers)
        {
            MessageBox.Show($"User: {u.Name}, {u.Email}");
        }
    }
}

```


![image.png](https://blog.idiosoft.com/static/img/27ce3f92c0123a0fb2abce06e9f8e3f7.image.webp)

### 4. 更新数据

可以根据 Id 或其他条件查找并更新现有的记录。

```C#
private void btnUpdate_Click(object sender, EventArgs e)
{
    // 连接数据库
    using (var db = new LiteDatabase(@"MyData.db"))
    {
        var users = db.GetCollection<User>("users");

        // 通过 Id 查找用户并更新
        var user = users.FindById(1);
        if (user != null)
        {
            user.Email = "john.doe@newdomain.com";
            users.Update(user);

            MessageBox.Show("User updated");
        }
    }
}

```

![image.png](https://blog.idiosoft.com/static/img/4b60748dc1dde14af2e9cc5805539fa3.image.webp)

### 5. 删除数据

可以根据 Id 或其他条件删除记录。

```C#
private void btnDelete_Click(object sender, EventArgs e)
{
    // 连接数据库
    using (var db = new LiteDatabase(@"MyData.db"))
    {
        var users = db.GetCollection<User>("users");

        // 通过 Id 删除用户
        bool success = users.Delete(1);
        if (success)
        {
            MessageBox.Show("User deleted");
        }
    }
}

```

## 定义 IDataRepository 接口

首先，我们定义一个通用的 `IDataRepository` 接口。这使我们能够以更抽象的方式处理数据存储库，并方便以后进行扩展。

```C#
public interface IDataRepository<T>
{
    void Insert(T entity);
    T GetById(int id);
    IEnumerable<T> GetAll();
    void Update(T entity);
    bool Delete(int id);
}
```

## 实现 UserRepository 类

接下来，我们实现一个 `UserRepository` 类来处理 `User` 实体的数据库操作。`UserRepository` 类继承 `IDataRepository<User>` 接口。

```C#
using LiteDB;
using System;
using System.Collections.Generic;

public class UserRepository : IDataRepository<User>, IDisposable
{
    private readonly LiteDatabase _database;
    private readonly ILiteCollection<User> _usersCollection;

    public UserRepository(string databasePath)
    {
        _database = new LiteDatabase(databasePath);
        _usersCollection = _database.GetCollection<User>("users");
    }

    public void Insert(User entity)
    {
        _usersCollection.Insert(entity);
    }

    public User GetById(int id)
    {
        return _usersCollection.FindById(id);
    }

    public IEnumerable<User> GetAll()
    {
        return _usersCollection.FindAll();
    }

    public void Update(User entity)
    {
        _usersCollection.Update(entity);
    }

    public bool Delete(int id)
    {
        return _usersCollection.Delete(id);
    }

    public void Dispose()
    {
        _database?.Dispose();
    }
}
```

## 使用 UserRepository 类

有了数据仓储类之后，我们可以在应用程序中使用 `UserRepository` 来进行`User`实体的数据库操作。

```C#
private void btnRepository_Click(object sender, EventArgs e)
{
    // 数据库文件路径
    string databasePath = @"MyData.db";

    using (var userRepository = new UserRepository(databasePath))
    {
        // 插入数据
        var newUser = new User { Name = "Jane Doe", Email = "janedoe@example.com" };
        userRepository.Insert(newUser);
        MessageBox.Show($"User inserted with Id: {newUser.Id}");

        // 查询数据
        var user = userRepository.GetById(newUser.Id);
        if (user != null)
        {
            MessageBox.Show($"User found: {user.Name}, {user.Email}");
        }

        // 更新数据
        user.Email = "jane.doe@newdomain.com";
        userRepository.Update(user);
        MessageBox.Show("User updated");

        // 列出所有用户
        var allUsers = userRepository.GetAll();
        foreach (var u in allUsers)
        {
            MessageBox.Show($"User: {u.Name}, {u.Email}");
        }

        // 删除数据
        if (userRepository.Delete(user.Id))
        {
            MessageBox.Show("User deleted");
        }
    }
}

```


![image.png](https://blog.idiosoft.com/static/img/1fb87197260e89a9671bdb0cbe64028d.image.webp)

## 结论

LiteDB 是一个非常实用且易于使用的嵌入式 NoSQL 数据库，适用于小型项目和快速开发。在 C# 中使用 LiteDB 非常简单且高效，通过简单的 API，我们可以方便地进行数据存储和查询。本文介绍了 LiteDB 的基本特点，并通过完整的例子展示了如何进行 CRUD 操作，帮助开发者快速上手。

希望这篇文章能够为你在 C# 项目中使用 LiteDB 提供基础的参考和帮助！

使用 C# 和 LiteDB 嵌入式NoSQL 数据库

在开发 WinForms 应用程序时，有时需要防止同一个应用程序的多个实例同时运行。这种需求在某些情况下非常重要，例如，当你需要确保某个资源（如文件或数据库）只被一个应用实例访问时。

本文将介绍几种防止同一应用运行多个实例的方法，提供详细的代码示例。



## 方法一：使用 `Mutex` 类

`Mutex`（互斥量）是一个同步基元，它可以用于跨线程和进程同步。通过创建一个命名互斥量，可以防止应用运行多个实例。

### 示例代码

```C#
namespace SingleInstanceApp
{
    internal static class Program
    {
        private static Mutex mutex = null;
        /// <summary>
        ///  The main entry point for the application.
        /// </summary>
        [STAThread]
        static void Main()
        {
            const string mutexName = "MyApp";
            bool isOwned;

            mutex = new Mutex(true, mutexName, out isOwned);

            if (!isOwned)
            {
                MessageBox.Show("应用程序已经在运行中。", "多实例检测", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                return;
            }
            // To customize application configuration such as set high DPI settings or default font,
            // see https://aka.ms/applicationconfiguration.
            ApplicationConfiguration.Initialize();
            Application.Run(new Form1());

            GC.KeepAlive(mutex);
        }
    }
}
```

在上述代码中，我们使用 `Mutex` 类创建了一个系统全局命名的互斥体 `mutexName`。如果应用程序已经在运行，则 `isOwned` 将为 `false`，应用会显示一条消息并退出。

## 方法二：使用 `Process` 类

通过 `Process` 类检查当前是否已经有同名进程在运行，也可以防止多个实例的运行。

### 示例代码

```C#
using System.Diagnostics;

namespace SingleInstanceApp
{
    internal static class Program
    {
        /// <summary>
        ///  The main entry point for the application.
        /// </summary>
        [STAThread]
        static void Main()
        {
            if (IsAlreadyRunning())
            {
                MessageBox.Show("应用程序已经在运行中。", "多实例检测", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                return;
            }
            // To customize application configuration such as set high DPI settings or default font,
            // see https://aka.ms/applicationconfiguration.
            ApplicationConfiguration.Initialize();
            Application.Run(new Form1());
        }

        static bool IsAlreadyRunning()
        {
            string currentProcessName = Process.GetCurrentProcess().ProcessName;
            Process[] processes = Process.GetProcessesByName(currentProcessName);
            return processes.Length > 1;
        }
    }
}
```

此方法通过 `Process.GetProcessesByName` 方法获取当前运行的同名进程。如果长度大于1，说明此时已有另一个实例在运行。

## 方法三：使用 Windows API

还有一种方法是利用 Windows API 创建一个命名事件，检查该事件是否已经存在。

### 示例代码

```C#
using System.Diagnostics;
using System.Runtime.InteropServices;

namespace SingleInstanceApp
{
    internal static class Program
    {
        const string UniqueEventName = "Global\\MyApp";

        [DllImport("kernel32", SetLastError = true)]
        static extern IntPtr CreateEvent(IntPtr lpEventAttributes, bool bManualReset, bool bInitialState, string lpName);

        [DllImport("kernel32.dll")]
        static extern uint GetLastError();
        /// <summary>
        ///  The main entry point for the application.
        /// </summary>
        [STAThread]
        static void Main()
        {
            IntPtr handle = CreateEvent(IntPtr.Zero, false, false, UniqueEventName);
            if (handle == IntPtr.Zero || GetLastError() == 183) // ERROR_ALREADY_EXISTS (183)
            {
                MessageBox.Show("应用程序已经在运行中。", "多实例检测", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                return;
            }

            // To customize application configuration such as set high DPI settings or default font,
            // see https://aka.ms/applicationconfiguration.
            ApplicationConfiguration.Initialize();
            Application.Run(new Form1());
        }
    }
}
```

上述代码使用了 `CreateEvent` API 创建一个命名事件，并通过 `GetLastError` 检查事件是否已经存在（错误代码 183 表示该事件已存在）。

`CreateEvent` 是一个 Windows API 函数，用于创建或打开一个命名的或未命名的事件对象。事件对象在进程间和线程间同步中非常有用。

`GetLastError()` 函数是用于检索扩展的错误信息的函数。它通常与其他 Windows API 函数一起使用，这些函数不返回明确的错误代码，但是如果调用失败，可以通过 `GetLastError()` 获取详细的错误信息。


![image.png](https://blog.idiosoft.com/static/img/8364ef28995c25fdc2323014448275b5.image.webp)

## 总结

以上介绍了三种在 WinForms 开发中防止同一应用运行多个实例的方法：

1. 使用 `Mutex` 类。
2. 使用 `Process` 类。
3. 使用 Windows API。

每种方法都有其优点和适用场景，开发者可根据具体需求选择合适的方法来实现多实例检测功能。希望此文对你有所帮助，欢迎提出任何问题或建议。

C#  WinForms 开发中防止同一应用运行多个实例

在设计应用程序时，了解何时使用抽象类和何时使用接口是至关重要的。尽管抽象类和接口在某些方面看起来相似，但它们之间存在关键差异，这些差异将决定哪种选择最适合您要实现的目标。




![image.png](https://blog.idiosoft.com/static/img/ca49278675e66372a08b74b6a599b587.image.webp)

## 抽象类与接口的基本区别

### 抽象类

抽象类是一种特殊类型的类，不能被实例化。抽象类旨在被子类继承，这些子类可以实现或重写其方法。换句话说，抽象类可以是部分实现的，也可以完全不实现。抽象类可以包含具体方法和抽象方法，并且可以有构造函数。

```C#
public abstract class Animal
{
    public abstract void MakeSound();
    
    public void Sleep()
    {
        Console.WriteLine("Sleeping...");
    }
}

public class Dog : Animal
{
    public override void MakeSound()
    {
        Console.WriteLine("Bark");
    }
}
```

### 接口

接口基本上是一个契约，它不包含任何实现。接口只能包含方法声明，不能包含方法定义，也不能包含成员数据。实现接口的类必须实现接口中的所有成员。

```C#
public interface IAnimal
{
    void MakeSound();
}

public class Dog : IAnimal
{
    public void MakeSound()
    {
        Console.WriteLine("Bark");
    }
}
```

## 抽象类与接口的相似之处

1. **行为定义而非实现**：C# 提供了接口和抽象类来定义行为而不实现。可以利用接口或抽象类来定义一个契约，必须由扩展或实现该接口或抽象类的类型遵循。
2. **不可实例化**：抽象类和接口都不能被实例化，必须由其他类型实现或扩展。
3. **支持多态性**：可以使用接口和抽象类实现多态性。
4. **访问修饰符**：接口和抽象类中的方法都可以包含访问修饰符。

## 抽象类与接口的关键区别

1. **默认实现**：抽象类可以有默认实现的方法，而接口直到 C# 8.0 才支持其成员的默认实现。
2. **成员类型**：抽象类可以有字段、构造函数、析构函数和静态成员，而接口不能有这些成员。
3. **状态信息**：抽象类可以有状态信息（即字段），而接口不能有实例字段。
4. **继承**：一个类只能继承一个抽象类，但可以实现多个接口。

## 何时使用抽象类

### 状态管理

如果需要管理状态信息，可以使用抽象类。抽象类可以包含字段，子类可以访问这些字段。

```C#
public abstract class Animal
{
    protected string name;
    
    public Animal(string name)
    {
        this.name = name;
    }
    
    public abstract void MakeSound();
}

public class Dog : Animal
{
    public Dog(string name) : base(name) { }
    
    public override void MakeSound()
    {
        Console.WriteLine($"{name} says: Bark");
    }
}
```

### 访问修饰符

抽象类可以使用访问修饰符来提供对其成员的细粒度控制。

```C#
public abstract class Animal
{
    protected string name;
    
    public Animal(string name)
    {
        this.name = name;
    }
    
    public abstract void MakeSound();
    
    protected void Sleep()
    {
        Console.WriteLine("Sleeping...");
    }
}

public class Dog : Animal
{
    public Dog(string name) : base(name) { }
    
    public override void MakeSound()
    {
        Console.WriteLine($"{name} says: Bark");
    }
}
```

### 构造函数和析构函数

抽象类可以有构造函数和析构函数，允许初始化其成员并编写清理逻辑的代码。

```C#
public abstract class Animal
{
    protected string name;
    
    public Animal(string name)
    {
        this.name = name;
    }
    
    public abstract void MakeSound();
    
    ~Animal()
    {
        Console.WriteLine($"{name} is being destroyed");
    }
}

public class Dog : Animal
{
    public Dog(string name) : base(name) { }
    
    public override void MakeSound()
    {
        Console.WriteLine($"{name} says: Bark");
    }
}
```

## 何时使用接口

### 多重实现

当需要在应用程序中建立契约而不强制直接继承时，接口是首选。一个类可以实现多个接口，从而允许它同时符合多个契约。

```C#
public interface IAnimal
{
    void MakeSound();
}

public interface IPet
{
    void Play();
}

public class Dog : IAnimal, IPet
{
    public void MakeSound()
    {
        Console.WriteLine("Bark");
    }
    
    public void Play()
    {
        Console.WriteLine("Playing...");
    }
}
```

### 模块化

接口促进了一种设计，在这种设计中，定义了一个契约，任何实现该契约的类都必须遵循，从而促进了模块化、可扩展和灵活的架构。

```C#
public interface IRepository<T>
{
    void Add(T item);
    T Get(int id);
}

public class Repository<T> : IRepository<T>
{
    public void Add(T item)
    {
        // Implementation
    }
    
    public T Get(int id)
    {
        // Implementation
        return default(T);
    }
}
```

### 模拟

在编写单元测试时，可以使用接口创建模拟对象。因为可以在接口中定义行为而不实现，所以可以使用接口创建不依赖于具体类实现的单元测试。

```C#
public interface IAnimal
{
    void MakeSound();
}

public class AnimalMock : IAnimal
{
    public void MakeSound()
    {
        Console.WriteLine("Mock sound");
    }
}
```

### 设计灵活性

可以利用接口创建具有演变设计的应用程序，通过编程接口而不是其实现，可以处理抽象而不是具体类，从而促进组件的可互换性。

```C#
public interface IAnimal
{
    void MakeSound();
}

public class Dog : IAnimal
{
    public void MakeSound()
    {
        Console.WriteLine("Bark");
    }
}

public class Cat : IAnimal
{
    public void MakeSound()
    {
        Console.WriteLine("Meow");
    }
}

public class AnimalService
{
    private readonly IAnimal _animal;
    
    public AnimalService(IAnimal animal)
    {
        _animal = animal;
    }
    
    public void MakeAnimalSound()
    {
        _animal.MakeSound();
    }
}
```

## 总结

抽象类和接口各有优缺点，选择哪一个取决于具体的需求。如果需要定义状态信息并指定字段的初始化方式，应该使用抽象类。如果需要定义一个行为契约而不强制继承关系，应该使用接口。通过理解它们的区别和应用场景，可以设计出松耦合和可扩展的应用程序。

C# 中抽象类与接口的选择

在C#中进行打印功能时，我们可以通过使用`System.Drawing`和其他相关的库来创建自定义的打印内容。本篇文章将介绍一个由`TableDocument`类组成的自定义表格绘制方案，并展示如何使用该类进行各种操作，如绘图、绘制条码、绘制二维码、绘制文本等。



## 关键类及其组成部分

### 1.`TableDocument` 类

`TableDocument`类是实现打印功能的核心。它包含了表格列的宽度、行的高度、单元格的合并以及在单元格中绘制图像、文本和条码等功能。

```C#
public class TableDocument
{
    public List<Column> Columns { get; set; } = new List<Column>(); // 表格列信息
    public List<Row> Rows { get; set; } = new List<Row>(); // 表格行信息
    public List<Position> Positions { get; set; } = new List<Position>(); // 单元格位置索引
    public Dictionary<(int, int), (int, int)> MergeCell { get; set; } = new Dictionary<(int, int), (int, int)>(); // 合并单元格信息

    // 确定特定单元格的位置
    public Position? GetPosition(int rowIndex, int columnIndex)
    {
        return Positions.Find(x => x.RowIndex == rowIndex && x.ColumnIndex == columnIndex);
    }

    // 获取列宽
    public int GetColumnWidth(int columnIndex)
    {
        return Columns[columnIndex].Width;
    }

    // 获取行高
    public int GetRowHeight(int rowIndex)
    {
        return Rows[rowIndex].Height;
    }

    // 绘制基本表格结构
    public void Draw(Graphics graphics, int startX, int startY)
    {
        Pen pen = new Pen(Color.Black, 1); // 设置表格线条颜色和宽度
        int currentY = startY;
        for (int i = 0; i < this.Rows.Count; i++)
        {
            int currentX = startX;
            for (int j = 0; j < this.Columns.Count; j++)
            {
                this.Positions.Add(new Position(i, j, new Point(currentX, currentY)));
                graphics.DrawRectangle(pen, currentX, currentY, this.Columns[j].Width, this.Rows[i].Height);
                currentX += this.Columns[j].Width;
            }
            currentY += this.Rows[i].Height;
        }

        // 处理单元格合并
        foreach (var item in this.MergeCell)
        {
            int startRowIndex = item.Key.Item1;
            int startColIndex = item.Key.Item2;
            int w = 0;
            int h = 0;
            for (int i = startRowIndex; i <= item.Value.Item1; i++)
            {
                h += this.GetRowHeight(i);
            }
            for (int i = startColIndex; i <= item.Value.Item2; i++)
            {
                w += this.GetColumnWidth(i);
            }
            graphics.FillRectangle(new SolidBrush(System.Drawing.Color.White),
                this.GetPosition(startRowIndex, startColIndex).Point.X,
                this.GetPosition(startRowIndex, startColIndex).Point.Y, w, h);
            graphics.DrawRectangle(pen,
                this.GetPosition(startRowIndex, startColIndex).Point.X,
                this.GetPosition(startRowIndex, startColIndex).Point.Y, w, h);
        }
    }

    // 在指定单元格内绘制图像
    public void DrawImageInCell(Graphics graphics, Position position, System.Drawing.Image image, Point offset)
    {
        Rectangle imageRect = new Rectangle(position.Point.X + offset.X, position.Point.Y + offset.Y, image.Width, image.Height);
        graphics.DrawImage(image, imageRect);
    }

    // 调整图像尺寸
    private System.Drawing.Image ResizeImage(System.Drawing.Image image, double scaleFactor)
    {
        int newWidth = (int)(image.Width * scaleFactor);
        int newHeight = (int)(image.Height * scaleFactor);
        Bitmap resizedImage = new Bitmap(newWidth, newHeight);
        using (Graphics graphics = Graphics.FromImage(resizedImage))
        {
            graphics.DrawImage(image, 0, 0, newWidth, newHeight);
        }
        return resizedImage;
    }

    // 在指定单元格内绘制二维码
    public void DrawQRCode(Graphics graphics, string code, Position position, Point offset, int size = 3, double factor = 1)
    {
        var data = new QRCodeGenerator().CreateQrCode(code, QRCodeGenerator.ECCLevel.H);
        QRCode qcode = new QRCode(data);
        var img = qcode.GetGraphic(size);
        if (factor != 1)
        {
            var simg = ResizeImage(img, factor);
            this.DrawImageInCell(graphics, position, simg, offset);
        }
        else
        {
            this.DrawImageInCell(graphics, position, img, offset);
        }
    }

    // 在指定单元格内绘制条形码
    public void Draw128Code(Graphics graphics, string code, Position position, int width, int height, Point offset, bool PureBarcode = false)
    {
        BarcodeWriter writer = new BarcodeWriter();
        writer.Options = new ZXing.Common.EncodingOptions
        {
            Width = width,
            Height = height,
            Margin = 0,
            PureBarcode = PureBarcode
        };
        writer.Format = BarcodeFormat.CODE_128;
        Bitmap bitmap2 = writer.Write(code);
        this.DrawImageInCell(graphics, position, bitmap2, offset);
    }

    // 在指定单元格内绘制文本
    public void DrawTextInCell(Graphics graphics, Position position, string text, Font font, Brush brush, int mergeRow = 0, int mergeColumn = 0, StringFormat stringFormat = null, bool specialHeight = false)
    {
        StringFormat sf = StringFormat.GenericTypographic;
        SizeF sizeF1 = graphics.MeasureString(text, font, PointF.Empty, sf);
        SizeF sizeF = MeasureTextSize(graphics, text, font);
        RectangleF layoutRectangle;
        int rectHeight = this.GetRowHeight(position.RowIndex);
        for (int i = 0; i < mergeRow; i++)
        {
            rectHeight += this.GetRowHeight(position.RowIndex + i);
        }
        int rectWidth = this.GetColumnWidth(position.ColumnIndex);
        for (int i = 1; i < mergeColumn; i++)
        {
            rectWidth += this.GetColumnWidth(position.ColumnIndex + i);
        }
        if (specialHeight)
        {
            layoutRectangle = new RectangleF(position.Point.X, position.Point.Y - sizeF.Height / 2, rectWidth, rectHeight);
        }
        else
        {
            layoutRectangle = new RectangleF(position.Point.X, position.Point.Y, rectWidth, rectHeight);
        }
        if (stringFormat == null)
        {
            stringFormat = new StringFormat
            {
                Alignment = StringAlignment.Center,
                LineAlignment = StringAlignment.Center,
            };
        }
        graphics.DrawString(text, font, brush, layoutRectangle, stringFormat);
    }

    // 测量文本的尺寸
    public static SizeF MeasureTextSize(Graphics graphics, string text, Font font)
    {
        return graphics.MeasureString(text, font);
    }

    // 调整图像尺寸
    public System.Drawing.Image ResizeImage(System.Drawing.Image image, int width, int height)
    {
        Bitmap resizedImage = new Bitmap(width, height);
        using (Graphics graphics = Graphics.FromImage(resizedImage))
        {
            graphics.InterpolationMode = InterpolationMode.HighQualityBicubic;
            graphics.SmoothingMode = SmoothingMode.HighQuality;
            graphics.PixelOffsetMode = PixelOffsetMode.HighQuality;
            graphics.DrawImage(image, new Rectangle(0, 0, width, height));
        }
        return resizedImage;
    }
}
```

### 2. 辅助类

#### `Position` 类

此类用于保存单元格的位置信息。

```C#
public class Position
{
    public int RowIndex { get; set; } = 0;
    public int ColumnIndex { get; set; } = 0;
    public Point Point { get; set; }

    public Position(int rowIndex, int columnIndex, Point point)
    {
        RowIndex = rowIndex;
        ColumnIndex = columnIndex;
        Point = point;
    }
}
```

#### `Row` 类

用于保存每个表格行的高度。

```C#
public class Row
{
    public Row() { }
    public Row(int height)
    {
        this.Height = height;
    }
    public int Height { get; set; } = 0;
}
```

#### `Column` 类

用于保存每个表格列的宽度。

```C#
public class Column
{
    public Column() { }
    public Column(int width)
    {
        this.Width = width;
    }
    public int Width { get; set; } = 0;
}
```

## 使用示例

下面是一个使用`TableDocument`类进行打印的简单示例：

```C#
private void PrintButton_Click(object sender, EventArgs e)
{
    PrintDocument printDocument = new PrintDocument();
    printDocument.PrintPage += new PrintPageEventHandler(PrintDocument_PrintPage);
    printDocument.Print();
}

private void PrintDocument_PrintPage(object sender, PrintPageEventArgs ev)
{
    TableDocument tableDoc = new TableDocument();

    // 添加列
    tableDoc.Columns.Add(new Column(100));
    tableDoc.Columns.Add(new Column(200));

    // 添加行
    tableDoc.Rows.Add(new Row(50));
    tableDoc.Rows.Add(new Row(100));

    // 绘制表格
    tableDoc.Draw(ev.Graphics, 10, 10);

    // 在单元格内绘制文本
    Position pos = tableDoc.GetPosition(0, 0);
    if (pos != null)
    {
        tableDoc.DrawTextInCell(ev.Graphics, pos, "Hello, World!", new Font("Arial", 12), Brushes.Black);
    }
}
```


![image.png](https://blog.idiosoft.com/static/img/cb6dc911f23a0788cf99f03ae6df3c29.image.webp)

## 做一个码单

```C#
using System.Drawing.Printing;
using static System.Windows.Forms.AxHost;

namespace NPrinter
{
    public partial class Form1 : Form
    {
        private PrintDocument printDocument = new PrintDocument();
        TableDocument table = new TableDocument();
        public Form1()
        {
            InitializeComponent();
        }

        private void btnPrint1_Click(object sender, EventArgs e)
        {
            PrintDocument printDocument = new PrintDocument();
            printDocument.PrintPage += new PrintPageEventHandler(PrintDocument_PrintPage);
            printDocument.Print();
        }

        private void PrintDocument_PrintPage(object sender, PrintPageEventArgs e)
        {
            //读取数据集
            Graphics graphics = e.Graphics;
            Pen pen = new Pen(Color.Black, 1); // 设置表格线条颜色和宽度
            // 表格的起始位置
            int startX = 10;
            int startY = 10;

            //设置行高
            for (int i = 0; i < 8; i++)
            {
                table.Rows.Add(new Row(35)); // 设置行高
            }

            //设置列宽
            for (int i = 0; i < 4; i++)
            {
                table.Columns.Add(new Column(80)); // 设置列宽
            }
            table.Columns[0].Width = 85;
            table.Columns[1].Width = 150;
            table.Columns[2].Width = 80;
            table.Columns[2].Width = 50;
            table.Rows[7].Height = 60;

            #region "设置合并"
            table.MergeCell.Add((0, 0), (0, 3)); //零头卷料信息卡
            table.MergeCell.Add((1, 1), (1, 3)); //项目
            table.MergeCell.Add((2, 1), (2, 3)); //批号
            table.MergeCell.Add((3, 1), (3, 3)); //反番号
            table.MergeCell.Add((4, 1), (4, 3)); //卷料零件号
            table.MergeCell.Add((7, 0), (7, 3)); //条码
            table.MergeCell.Add((6, 2), (6, 3)); //用户

            table.MergeCell.Add((1, 3), (2, 3));//二维码
            #endregion

            table.Draw(graphics, startX, startY);

            table.DrawTextInCell(graphics, table.GetPosition(0, 0), "零头卷料信息卡", new Font("SimHei", 12, FontStyle.Bold), Brushes.Black, 0, 4);

            table.DrawTextInCell(graphics, table.GetPosition(1, 0), "项目", new Font("SimHei", 8), Brushes.Black);
            table.DrawTextInCell(graphics, table.GetPosition(2, 0), "批号", new Font("SimHei", 8), Brushes.Black);
            table.DrawTextInCell(graphics, table.GetPosition(3, 0), "反番号", new Font("SimHei", 8), Brushes.Black);
            table.DrawTextInCell(graphics, table.GetPosition(4, 0), "卷料零件号", new Font("SimHei", 8), Brushes.Black);
            table.DrawTextInCell(graphics, table.GetPosition(5, 0), "退料长度", new Font("SimHei", 8), Brushes.Black);
            table.DrawTextInCell(graphics, table.GetPosition(6, 0), "退料日期/员工", new Font("SimHei", 8), Brushes.Black);
            table.DrawTextInCell(graphics, table.GetPosition(5, 2), "毛向", new Font("SimHei", 8), Brushes.Black);

            ////打印内容
            table.DrawTextInCell(graphics, table.GetPosition(1, 1), "V254", new Font("Arial", 8), Brushes.Black, 0, 3, new StringFormat() { Alignment = StringAlignment.Near, LineAlignment = StringAlignment.Center });
            table.DrawTextInCell(graphics, table.GetPosition(2, 1), "B20301", new Font("Arial", 8), Brushes.Black, 0, 3, new StringFormat() { Alignment = StringAlignment.Near, LineAlignment = StringAlignment.Center });
            table.DrawTextInCell(graphics, table.GetPosition(3, 1), "", new Font("Arial", 8), Brushes.Black, 0, 3, new StringFormat() { Alignment = StringAlignment.Near, LineAlignment = StringAlignment.Center });
            table.DrawTextInCell(graphics, table.GetPosition(4, 1), "5519982-8W51", new Font("Arial", 8), Brushes.Black, 0, 3, new StringFormat() { Alignment = StringAlignment.Near, LineAlignment = StringAlignment.Center });
            table.DrawTextInCell(graphics, table.GetPosition(5, 1), "20.8", new Font("Arial", 10), Brushes.Black, 0, 3, new StringFormat() { Alignment = StringAlignment.Near, LineAlignment = StringAlignment.Center });
            table.DrawTextInCell(graphics, table.GetPosition(6, 1), DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), new Font("Arial", 10), Brushes.Black, 0, 0, new StringFormat() { Alignment = StringAlignment.Near, LineAlignment = StringAlignment.Center });

            table.DrawTextInCell(graphics, table.GetPosition(5, 3), "A", new Font("Arial", 8), Brushes.Black);
            table.DrawTextInCell(graphics, table.GetPosition(6, 2), "张三", new Font("Arial", 8), Brushes.Black, 0, 2);

            table.DrawQRCode(graphics, "A000001", table.GetPosition(1, 3), new Point(10, 5), 3);

            ////生成条码
            int w = 0;
            int h = 0;
            w = table.Columns.Take(4).Sum(x => x.Width) - 5;
            h = table.Rows[7].Height - 10;
            table.Draw128Code(graphics, "A000001", table.GetPosition(7, 0), w, h, new Point(3, 3));
        }
    }
}

```


![image.png](https://blog.idiosoft.com/static/img/246692b873da6827b05d608f7bcb095f.image.webp)

## 总结

本文展示了一个自定义表格绘制类的实现及其使用方法，涵盖了绘制基表格、图像、条形码、二维码和文本的功能。通过这些方法，开发者可以灵活地进行C#打印功能的开发，为各种打印需求提供解决方案。

C# 打印功能：使用自定义表格绘制类

在Windows应用程序中，打印是一个常见的需求。C#的WinForms提供了完备的打印支持，通过一些类和控件可以轻松实现打印功能。本篇文章将详细介绍在WinForms中实现打印的基本操作。



## 引入打印所需的命名空间

为了使用打印功能，我们需要引入一些特定的命名空间：

```C#
using System.Drawing;
using System.Drawing.Printing;
using System.Windows.Forms;
```

## 打印预览控件

在开始打印之前，通常会提供一个预览功能让用户确认打印内容是否正确。WinForms提供了`PrintPreviewControl`和`PrintPreviewDialog`两个控件用于打印预览。

```C#
public partial class Form1 : Form
{
    PrintPreviewDialog printPreviewDialog = new PrintPreviewDialog();
    PrintDocument printDocument = new PrintDocument();
    public Form1()
    {
        InitializeComponent();
    }
    private void btnPrint_Click(object sender, EventArgs e)
    {
        // 绑定事件
        printDocument.PrintPage += new PrintPageEventHandler(PrintDocument_PrintPage);

        // 设置文件源
        printPreviewDialog.Document = printDocument;

        ShowPrintPreview();

    }

    private void PrintDocument_PrintPage(object sender, PrintPageEventArgs e)
    {
        e.Graphics.DrawString("Hello, World!", new Font("Arial", 20), Brushes.Black, new PointF(100, 100));
    }

    private void ShowPrintPreview()
    {
        printPreviewDialog.ShowDialog();
    }
}

```


![image.png](https://blog.idiosoft.com/static/img/1c746adfc5a581e3685650e399e883cf.image.webp)

## 基本的打印操作

打印操作的核心是`PrintDocument`类，通过它可以控制打印的内容和格式。

```C#
private void PrintDocument_PrintPage(object sender, PrintPageEventArgs e)
{
    e.Graphics.DrawString("Hello, World!", new Font("Arial", 20), Brushes.Black, new PointF(100, 100));
}

private void Print()
{
    PrintDocument printDocument = new PrintDocument();
    printDocument.PrintPage += new PrintPageEventHandler(PrintDocument_PrintPage);
    printDocument.Print();
}
```

以上代码将在打印纸上绘制一行“Hello, World!”的文本。

## 高级的打印设置

### 使用打印对话框

可以通过`PrintDialog`让用户选择打印机、设置页边距等打印选项。

```C#
private void PrintWithDialog()
{
    PrintDocument printDocument = new PrintDocument();
    PrintDialog printDialog = new PrintDialog();

    printDocument.PrintPage += new PrintPageEventHandler(PrintDocument_PrintPage);

    printDialog.Document = printDocument;

    if (printDialog.ShowDialog() == DialogResult.OK)
    {
        printDocument.Print();
    }
}
```


![image.png](https://blog.idiosoft.com/static/img/12bee7593af64029bf7d219cb18ec269.image.webp)

### 设置打印页面的属性

可以通过`PageSettings`和`PrinterSettings`设置打印页面的详细属性。

```C#
private void SetPageSettings(PrintDocument printDocument)
{
    // 设置页面方向
    printDocument.DefaultPageSettings.Landscape = true;

    // 设置页边距
    printDocument.DefaultPageSettings.Margins = new Margins(50, 50, 50, 50);

    // 设置打印纸张大小
    printDocument.DefaultPageSettings.PaperSize = new PaperSize("A4", 210, 297);
}
```

## 实际案例

假设我们有一个WinForms程序，需要打印一个列表中的多个项，并支持分页。以下是一个完整的例子：

```C#
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Printing;
using System.Windows.Forms;

namespace Printer
{
    public partial class Form1 : Form
    {
        private List<string> itemsToPrint; // 打印内容列表
        private int printPageIndex; // 当前打印的页码

        public Form1()
        {
            InitializeComponent();

            // 初始化打印内容
            itemsToPrint = new List<string>();
            for (int i = 1; i <= 50; i++)
            {
                itemsToPrint.Add($"Item {i}"); // 添加50个打印项目
            }
        }

        // 打印按钮的点击事件处理函数
        private void PrintButton_Click(object sender, EventArgs e)
        {
            // 创建打印文档对象
            PrintDocument printDocument = new PrintDocument();
            // 订阅PrintPage事件，这个事件在每次需要生成打印页时触发
            printDocument.PrintPage += new PrintPageEventHandler(PrintDocument_PrintPage);

            // 创建打印对话框对象，并将打印文档关联到对话框
            PrintDialog printDialog = new PrintDialog
            {
                Document = printDocument
            };

            // 显示打印对话框，如果用户确认打印，则开始打印
            if (printDialog.ShowDialog() == DialogResult.OK)
            {
                // 初始化打印页码
                printPageIndex = 0;
                // 开始打印
                printDocument.Print();
            }
        }

        // 打印文档的PrintPage事件处理函数
        private void PrintDocument_PrintPage(object sender, PrintPageEventArgs e)
        {
            int itemsPerPage = 10; // 每页打印项目数
            int itemIndex = printPageIndex * itemsPerPage; // 当前页起始项目索引
            int yPosition = e.MarginBounds.Top; // 当前打印位置的Y坐标

            // 逐行打印项目，直到页面下边界或者打印完所有项目
            while (itemIndex < itemsToPrint.Count && yPosition < e.MarginBounds.Bottom)
            {
                // 在页面上绘制字符串
                e.Graphics.DrawString(itemsToPrint[itemIndex], new Font("Arial", 14), Brushes.Black, new PointF(e.MarginBounds.Left, yPosition));
                yPosition += 30; // 移动到下一行
                itemIndex++;
            }

            // 更新页码
            printPageIndex++;

            // 检查是否有更多页需要打印
            if (itemIndex < itemsToPrint.Count)
            {
                e.HasMorePages = true; // 还有更多页
            }
            else
            {
                e.HasMorePages = false; // 没有更多页
            }
        }
    }
}
```


![image.png](https://blog.idiosoft.com/static/img/9f9d382307d687f4782f022ed79de6c4.image.webp)

## 总结

本文介绍了在WinForms中实现打印的基本操作，包括打印预览、基本打印、打印对话框使用以及高级设置。同时，通过一个具体的例子展示了打印多个项并支持分页的实现方式。希望这篇文章能够帮助你更好地理解和使用WinForms的打印功能。

C#使用 WinForms 实现打印基础操作

link

script

这个博客将是我技术思考、创业经验和个人成长的记录本。无论是技术解决方案、创业感悟，还是职场心得，我都将坦诚相见，希望能为正在成长的技术人和创业者提供一些真实而有价值的洞察。"