ClosedXML 是一个用于创建和操作 Microsoft Excel 电子表格的 .NET 库。它提供了一个简单而直观的 API，使得在 C# 中处理 Excel 文件变得轻而易举。本文将详细介绍 ClosedXML 的使用方法，并提供多个实用的例子。

## 安装

首先，通过 NuGet 包管理器安装 ClosedXML：

```PowerShell
Install-Package ClosedXML
```


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



## 基本用法

### 创建新的工作簿和工作表

```C#
static void Main(string[] args)
{
    using (var workbook = new XLWorkbook())
    {
        var worksheet = workbook.Worksheets.Add("Sample Sheet");

        worksheet.Cell("A1").Value = "Hello World!";

        workbook.SaveAs("HelloWorld.xlsx");
    }

    Console.WriteLine("Excel file created successfully!");
}

```

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

### 读取现有的 Excel 文件

```C#
static void Main(string[] args)
{
    using (var workbook = new XLWorkbook("HelloWorld.xlsx"))
    {
        var worksheet = workbook.Worksheet(1);
        var cellValue = worksheet.Cell("A1").Value;
        Console.WriteLine($"Value in A1: {cellValue}");
    }
}

```

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

## 高级用法

### 填充数据

```C#
using ClosedXML.Excel;
using System.Collections.Generic;

class Program
{
    public class Person
    {
        public string Name { get; set; }
        public int Age { get; set; }
    }

    static void Main(string[] args)
    {
        var people = new List<Person>
        {
            new Person { Name = "John Doe", Age = 30 },
            new Person { Name = "Jane Smith", Age = 25 },
            new Person { Name = "Bob Johnson", Age = 35 }
        };

        using (var workbook = new XLWorkbook())
        {
            var worksheet = workbook.Worksheets.Add("People");

            // Add headers
            worksheet.Cell(1, 1).Value = "Name";
            worksheet.Cell(1, 2).Value = "Age";

            // Add data
            worksheet.Cell(2, 1).InsertData(people);

            workbook.SaveAs("People.xlsx");
        }

        Console.WriteLine("Excel file with people data created successfully!");
    }
}
```


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

### 设置单元格样式

```C#
using (var workbook = new XLWorkbook())
{
    var worksheet = workbook.Worksheets.Add("Styled Sheet");

    var cell = worksheet.Cell("A1");
    cell.Value = "Styled Cell";
    
    cell.Style.Font.Bold = true;
    cell.Style.Font.FontColor = XLColor.Red;
    cell.Style.Fill.BackgroundColor = XLColor.Yellow;
    cell.Style.Alignment.Horizontal = XLAlignmentHorizontalValues.Center;
    cell.Style.Border.OutsideBorder = XLBorderStyleValues.Medium;

    workbook.SaveAs("StyledSheet.xlsx");
}
```

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

### 使用公式

```C#
using (var workbook = new XLWorkbook())
{
    var worksheet = workbook.Worksheets.Add("Formulas");

    worksheet.Cell("A1").Value = 10;
    worksheet.Cell("A2").Value = 20;
    worksheet.Cell("A3").FormulaA1 = "=SUM(A1:A2)";

    workbook.SaveAs("Formulas.xlsx");
}
```

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

### 合并单元格

```C#
using (var workbook = new XLWorkbook())
{
    var worksheet = workbook.Worksheets.Add("Merged Cells");

    var range = worksheet.Range("A1:C3");
    range.Merge();
    range.Value = "Merged Range";
    range.Style.Alignment.Horizontal = XLAlignmentHorizontalValues.Center;
    range.Style.Alignment.Vertical = XLAlignmentVerticalValues.Center;

    workbook.SaveAs("MergedCells.xlsx");
}
```

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

### 添加和格式化表格

```C#
using (var workbook = new XLWorkbook())
{
    var worksheet = workbook.Worksheets.Add("Table");

    // Add headers
    worksheet.Cell("A1").Value = "Name";
    worksheet.Cell("B1").Value = "Age";
    worksheet.Cell("C1").Value = "City";

    // Add data
    worksheet.Cell("A2").Value = "John";
    worksheet.Cell("B2").Value = 30;
    worksheet.Cell("C2").Value = "New York";

    worksheet.Cell("A3").Value = "Jane";
    worksheet.Cell("B3").Value = 25;
    worksheet.Cell("C3").Value = "London";

    // Create table
    var table = worksheet.Range("A1:C3").CreateTable("MyTable");
    
    // Format table
    table.Theme = XLTableTheme.TableStyleMedium2;

    workbook.SaveAs("TableExample.xlsx");
}
```


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

### 添加页眉和页脚

```C#
using (var workbook = new XLWorkbook())
{
    var worksheet = workbook.Worksheets.Add("Headers and Footers");

    worksheet.PageSetup.Header.Left.AddText("Left Header");
    worksheet.PageSetup.Header.Center.AddText("Center Header");
    worksheet.PageSetup.Header.Right.AddText("Right Header");

    worksheet.PageSetup.Footer.Left.AddText("Left Footer");
    worksheet.PageSetup.Footer.Center.AddText("Center Footer");
    worksheet.PageSetup.Footer.Right.AddText("Right Footer");

    workbook.SaveAs("HeadersAndFooters.xlsx");
}
```

### 设置打印区域和页面设置

```C#
using (var workbook = new XLWorkbook())
{
    var worksheet = workbook.Worksheets.Add("Print Setup");

    // Add some data
    for (int i = 1; i <= 100; i++)
    {
        worksheet.Cell(i, 1).Value = $"Row {i}";
    }

    // Set print area
    worksheet.PageSetup.PrintAreas.Add("A1:B50");

    // Page setup
    worksheet.PageSetup.PaperSize = XLPaperSize.A4Paper;
    worksheet.PageSetup.PageOrientation= XLPageOrientation.Landscape;
    worksheet.PageSetup.Scale = 85; // 85% of normal size

    workbook.SaveAs("PrintSetup.xlsx");
}
```

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

### 数据验证

```C#
static void Main(string[] args)
{
    using (var workbook = new XLWorkbook())
    {
        var worksheet = workbook.Worksheets.Add("Data Validation");

        // Create a list of items in a separate range  
        worksheet.Cell("E1").Value = "Apple";
        worksheet.Cell("E2").Value = "Banana";
        worksheet.Cell("E3").Value = "Cherry";
        worksheet.Cell("E4").Value = "Date";

        // List validation  
        var listRange = worksheet.Range("A1:A10");
        listRange.CreateDataValidation().List(worksheet.Range("E1:E4"), true);

        // Number range validation  
        var numberRange = worksheet.Range("B1:B10");
        numberRange.CreateDataValidation().WholeNumber.Between(1, 100);

        // Date validation  
        var dateRange = worksheet.Range("C1:C10");
        dateRange.CreateDataValidation().Date.EqualOrGreaterThan(DateTime.Today);

        workbook.SaveAs("DataValidation.xlsx");
    }
}

```


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

### 条件格式

```C#
using (var workbook = new XLWorkbook())
{
    var worksheet = workbook.Worksheets.Add("Conditional Formatting");

    // Add some data
    for (int i = 1; i <= 10; i++)
    {
        worksheet.Cell(i, 1).Value = i * 10;
    }

    // Add conditional formatting
    var range = worksheet.Range("A1:A10");
    var cf1 = range.AddConditionalFormat();
    cf1.WhenLessThan(50).Fill.SetBackgroundColor(XLColor.Red);

    var cf2 = range.AddConditionalFormat();
    cf2.WhenBetween(50, 80).Fill.SetBackgroundColor(XLColor.Yellow);

    var cf3 = range.AddConditionalFormat();
    cf3.WhenGreaterThan(80).Fill.SetBackgroundColor(XLColor.Green);

    workbook.SaveAs("ConditionalFormatting.xlsx");
}
```


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

## 错误处理

在使用 ClosedXML 时，应该适当地处理可能出现的异常：

```C#
try
{
    using (var workbook = new XLWorkbook())
    {
        var worksheet = workbook.Worksheets.Add("Error Handling");
        worksheet.Cell("A1").Value = "Test";
        workbook.SaveAs("ErrorHandling.xlsx");
    }
    Console.WriteLine("Excel file created successfully!");
}
catch (IOException ex)
{
    Console.WriteLine($"An IO error occurred: {ex.Message}");
}
catch (InvalidOperationException ex)
{
    Console.WriteLine($"An invalid operation occurred: {ex.Message}");
}
catch (Exception ex)
{
    Console.WriteLine($"An error occurred: {ex.Message}");
}
```

## 结论

ClosedXML 是一个功能强大且易于使用的 Excel 操作库。它提供了广泛的功能，从基本的单元格操作到复杂的图表创建和条件格式设置。通过本文提供的示例，你应该能够处理大多数 Excel 相关的任务。

ClosedXML：强大的 Excel 操作库

## 简介

`ColorListView` 是一个继承自 `ListView` 的自定义控件，它提供了更丰富的单元格样式设置功能。这个控件允许用户为每个单元格设置自定义的背景颜色、填充百分比和图标。通过重写绘制方法，`ColorListView` 实现了这些自定义功能，同时保留了原有 `ListView` 的基本特性。

## 主要特性

1. 自定义单元格背景颜色
2. 可调节的背景填充百分比
3. 支持为单元格添加自定义图标
4. 保留原有的选中和焦点状态显示



## 实现细节

### CellInfo 类

`CellInfo` 是一个私有内部类，用于存储每个单元格的自定义信息：

```C#
private class CellInfo
{
    public Color BackColor { get; set; }
    public float FillPercentage { get; set; }
    public Image Icon { get; set; }

    public CellInfo(Color backColor, float fillPercentage, Image icon = null)
    {
        BackColor = backColor;
        FillPercentage = Math.Max(0, Math.Min(100, fillPercentage)) / 100f;
        Icon = icon;
    }
}
```

这个类封装了单元格的背景颜色、填充百分比和图标信息。

### 自定义信息存储

控件使用一个字典来存储每个单元格的自定义信息：

```C#
private Dictionary<Point, CellInfo> customCellInfo;
```

字典的键是一个 `Point` 对象，表示单元格的列索引和行索引。

### 初始化

在构造函数中，控件进行了必要的初始化：

```C#
public ColorListView()
{
    customCellInfo = new Dictionary<Point, CellInfo>();
    this.OwnerDraw = true;
    SetStyle(ControlStyles.DoubleBuffer | ControlStyles.OptimizedDoubleBuffer | ControlStyles.AllPaintingInWmPaint, true);
    UpdateStyles();
}
```

这里启用了自定义绘制和双缓冲，以提高绘制性能和减少闪烁。

### 设置单元格样式

控件提供了两个公共方法来设置单元格样式：

```C#
public void SetCellBackColor(int rowIndex, int columnIndex, Color color, float fillPercentage = 100)
{
    // 实现代码...
}

public void SetCellIcon(int rowIndex, int columnIndex, Image icon)
{
    // 实现代码...
}
```

这些方法允许用户为指定的单元格设置背景颜色、填充百分比和图标。

### 自定义绘制

控件重写了 `OnDrawItem` 和 `OnDrawColumnHeader` 方法来实现自定义绘制：

```C#
protected override void OnDrawColumnHeader(DrawListViewColumnHeaderEventArgs e)
{
    e.DrawDefault = true;
}

protected override void OnDrawItem(DrawListViewItemEventArgs e)
{
    // 实现代码...
}
```

`OnDrawItem` 方法负责绘制每一行，而具体的单元格绘制则由 `DrawSubItem` 私有方法完成。

### 单元格绘制

`DrawSubItem` 方法是实现自定义绘制的核心：

```C#
private void DrawSubItem(Graphics g, ListViewItem item, int columnIndex, bool isSelected)
{
    // 实现代码...
}
```

这个方法处理了以下几个方面：

1. 绘制自定义背景色和填充
2. 绘制图标（如果有）
3. 绘制文本
4. 处理选中状态

### 辅助方法

`GetSubItemBounds` 方法用于计算每个子项的边界矩形，这对于正确定位绘制内容非常重要：

```C#
private Rectangle GetSubItemBounds(ListViewItem item, int subItemIndex)
{
    // 实现代码...
}
```

### 完整代码

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

public class ColorListView : ListView
{
    private class CellInfo
    {
        public Color BackColor { get; set; }
        public float FillPercentage { get; set; }
        public Image Icon { get; set; }

        public CellInfo(Color backColor, float fillPercentage, Image icon = null)
        {
            BackColor = backColor;
            FillPercentage = Math.Max(0, Math.Min(100, fillPercentage)) / 100f;
            Icon = icon;
        }
    }

    private Dictionary<Point, CellInfo> customCellInfo;

    public ColorListView()
    {
        customCellInfo = new Dictionary<Point, CellInfo>();

        this.OwnerDraw = true;
        SetStyle(ControlStyles.DoubleBuffer | ControlStyles.OptimizedDoubleBuffer | ControlStyles.AllPaintingInWmPaint, true);
        UpdateStyles();
    }

    public void SetCellBackColor(int rowIndex, int columnIndex, Color color, float fillPercentage = 100)
    {
        Point key = new Point(columnIndex, rowIndex);
        if (customCellInfo.TryGetValue(key, out CellInfo info))
        {
            info.BackColor = color;
            info.FillPercentage = fillPercentage / 100f;
        }
        else
        {
            customCellInfo[key] = new CellInfo(color, fillPercentage);
        }
        Invalidate();
    }

    public void SetCellIcon(int rowIndex, int columnIndex, Image icon)
    {
        Point key = new Point(columnIndex, rowIndex);
        if (customCellInfo.TryGetValue(key, out CellInfo info))
        {
            info.Icon = icon;
        }
        else
        {
            customCellInfo[key] = new CellInfo(Color.Transparent, 0, icon);
        }
        Invalidate();
    }

    protected override void OnDrawColumnHeader(DrawListViewColumnHeaderEventArgs e)
    {
        e.DrawDefault = true;
    }

    protected override void OnDrawItem(DrawListViewItemEventArgs e)
    {
        e.DrawDefault = false;

        if (e.Item.Selected)
        {
            using (SolidBrush brush = new SolidBrush(SystemColors.Highlight))
            {
                e.Graphics.FillRectangle(brush, e.Bounds);
            }
        }
        else
        {
            e.DrawBackground();
        }

        for (int i = 0; i < this.Columns.Count; i++)
        {
            DrawSubItem(e.Graphics, e.Item, i, e.Item.Selected);
        }

        if ((e.State & ListViewItemStates.Focused) != 0)
        {
            e.DrawFocusRectangle();
        }
    }

    private void DrawSubItem(Graphics g, ListViewItem item, int columnIndex, bool isSelected)
    {
        Rectangle bounds = GetSubItemBounds(item, columnIndex);

        Point cellKey = new Point(columnIndex, item.Index);
        if (customCellInfo.TryGetValue(cellKey, out CellInfo customInfo) && !isSelected)
        {
            int fillWidth = (int)(bounds.Width * customInfo.FillPercentage);
            Rectangle fillRect = new Rectangle(bounds.X, bounds.Y, fillWidth, bounds.Height);

            using (SolidBrush brush = new SolidBrush(customInfo.BackColor))
            {
                g.FillRectangle(brush, fillRect);
            }
        }

        string text = columnIndex == 0 ? item.Text : item.SubItems[columnIndex].Text;
        Color textColor = isSelected ? SystemColors.HighlightText : item.ForeColor;

        // Draw icon if exists  
        if (customInfo != null && customInfo.Icon != null)
        {
            int iconSize = bounds.Height - 4; // Leave some padding  
            Rectangle iconRect = new Rectangle(bounds.X + 2, bounds.Y + 2, iconSize, iconSize);
            g.DrawImage(customInfo.Icon, iconRect);
            bounds.X += iconSize + 4; // Move text to the right of the icon  
            bounds.Width -= iconSize + 4;
        }

        TextRenderer.DrawText(g, text, this.Font, bounds, textColor, TextFormatFlags.Left | TextFormatFlags.VerticalCenter);
    }

    private Rectangle GetSubItemBounds(ListViewItem item, int subItemIndex)
    {
        if (item == null)
            throw new ArgumentNullException("item");

        Rectangle subItemRect = Rectangle.Empty;

        if (subItemIndex >= 0 && subItemIndex < this.Columns.Count)
        {
            Rectangle lviBounds = item.GetBounds(ItemBoundsPortion.Entire);
            int subItemX = lviBounds.Left;

            for (int i = 0; i < subItemIndex; i++)
                subItemX += this.Columns[i].Width;

            subItemRect = new Rectangle(subItemX, lviBounds.Top, this.Columns[subItemIndex].Width, lviBounds.Height);
        }

        return subItemRect;
    }
}
```

## 使用示例

以下是如何使用 `ColorListView` 的简单示例：

```C#
public partial class Form1 : Form
{
    private ColorListView customListView;

    public Form1()
    {
        InitializeComponent();

        customListView = new ColorListView();
        // 设置 CustomListView 属性  
        this.customListView.Dock = DockStyle.Fill;
        this.customListView.View = View.Details;
        this.customListView.FullRowSelect = true;
        this.customListView.GridLines = true;

        // 添加列  
        this.customListView.Columns.Add("Column 1", 100);
        this.customListView.Columns.Add("Column 2", 100);
        this.customListView.Columns.Add("Column 3", 100);

        // 添加一些测试数据  
        for (int i = 0; i < 10; i++)
        {
            ListViewItem item = new ListViewItem(new string[] { $"Item {i}", $"Sub {i}", $"Extra {i}" });
            this.customListView.Items.Add(item);
        }

        // 设置一些单元格的自定义背景色  
        this.customListView.SetCellBackColor(1, 1, Color.LightBlue, 50);  // 50% 填充  
        this.customListView.SetCellBackColor(3, 2, Color.LightGreen, 75);  // 75% 填充  
        this.customListView.SetCellBackColor(5, 0, Color.LightPink, 100);  // 100% 填充（默认）  


        Image icon1 = Image.FromFile("add.png");
        customListView.SetCellIcon(0, 2, icon1);

        Image icon2 = Image.FromFile("search.png");
        customListView.SetCellIcon(1, 1, icon2);

        this.Controls.Add(this.customListView);
        this.Name = "MainForm";
        this.Text = "Custom ListView Demo";

    }


}

```


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

## 结论

`ColorListView` 通过继承和自定义绘制，扩展了标准 `ListView` 控件的功能。它提供了更灵活的单元格样式设置选项，同时保持了良好的性能和原有的基本功能。这个控件特别适用于需要在列表中展示更丰富视觉信息的应用场景。

C# ColorListView: 自定义绘制的ListView控件

FluentFTP 是一个功能丰富的 .NET FTP 客户端库，它提供了一个简单而直观的 API 来执行各种 FTP 操作。本文将详细介绍 FluentFTP 的使用方法，并提供多个实用的例子。

## 1. 安装

首先，通过 NuGet 包管理器安装 FluentFTP：

```PowerShell
Install-Package FluentFTP
```




![image.png](https://blog.idiosoft.com/static/img/af3e0f584f3172176a460f4cbc6efb23.image.webp)
## 2. 基本用法

### 2.1 连接到 FTP 服务器

```C#
static async Task Main(string[] args)
{
    using (var client = new AsyncFtpClient("127.0.0.1", "admin", "123456"))
    {
        await client.Connect();
        Console.WriteLine("Connected to FTP server!");

        // 执行其他操作...

        await client.Disconnect();
    }
}

```

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

### 2.2 列出目录内容

```C#
using (var client = new AsyncFtpClient("127.0.0.1", "admin", "123456"))
{
    await client.Connect();

    foreach (var item in await client.GetListing("/"))
    {
        Console.WriteLine($"{item.Name} - {item.Modified} - {item.Size} bytes");
    }
}
```

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

中文乱码

```C#
static async Task Main(string[] args)
{
    // 注册编码提供程序  
    Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);

    // 确保控制台可以显示正确的字符  
    Console.OutputEncoding = Encoding.GetEncoding("GB2312");

    using (var client = new AsyncFtpClient("127.0.0.1", "admin", "123456"))
    {
        // 设置FTP客户端使用GB2312编码  
        client.Encoding = Encoding.GetEncoding("GB2312");

        await client.Connect();

        foreach (var item in await client.GetListing("/"))
        {
            Console.WriteLine($"{item.Name} - {item.Modified} - {item.Size} bytes");
        }
    }
}

```


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

### 2.3 上传文件

```C#
using (var client = new AsyncFtpClient("127.0.0.1", "admin", "123456"))
{
    await client.Connect();

    var status = await client.UploadFile(@"C:\local\file.txt", "/remote/file.txt");
    if (status == FtpStatus.Success)
    {
        Console.WriteLine("File uploaded successfully!");
    }
}
```

### 2.4 下载文件

```C#
using (var client = new AsyncFtpClient("127.0.0.1", "admin", "123456"))
{
    await client.Connect();

    var status = await client.DownloadFile(@"D:\output\1724843803807.png", "1724843803807.png");
    if (status == FtpStatus.Success)
    {
        Console.WriteLine("File downloaded successfully!");
    }
}

```

## 3. 高级用法

### 3.1 创建目录

```C#
using (var client = new AsyncFtpClient("127.0.0.1", "admin", "123456"))
{
    await client.Connect();

    var created = await client.CreateDirectory("/new_directory");
    if (created)
    {
        Console.WriteLine("Directory created successfully!");
    }
}
```

### 3.2 删除文件

```C#
using (var client = new AsyncFtpClient("127.0.0.1", "admin", "123456"))
{
    await client.Connect();

    var deleted = await client.DeleteFile("/remote/file_to_delete.txt");
    if (deleted)
    {
        Console.WriteLine("File deleted successfully!");
    }
}
```

### 3.3 重命名文件或目录

```C#
using (var client = new AsyncFtpClient("127.0.0.1", "admin", "123456"))
{
    await client.Connect();

    var renamed = await client.Rename("/old_name.txt", "/new_name.txt");
    if (renamed)
    {
        Console.WriteLine("File renamed successfully!");
    }
}
```

### 3.4 检查文件是否存在

```C#
using (var client = new AsyncFtpClient("127.0.0.1", "admin", "123456"))
{
    await client.Connect();

    var exists = await client.FileExists("/remote/file.txt");
    Console.WriteLine($"File exists: {exists}");
}
```

### 3.5 获取文件大小

```C#
using (var client = new AsyncFtpClient("127.0.0.1", "admin", "123456"))
{
    await client.Connect();

    var size = await client.GetFileSize("/remote/file.txt");
    Console.WriteLine($"File size: {size} bytes");
}
```

### 3.6 上传整个目录

```C#
using (var client = new AsyncFtpClient("127.0.0.1", "admin", "123456"))
{
    await client.Connect();

    var result = await client.UploadDirectory(@"C:\local\directory", "/remote/directory");
    Console.WriteLine($"Uploaded {result.UploadedFiles.Count} files");
    Console.WriteLine($"Failed to upload {result.FailedUploads.Count} files");
}
```

### 3.7 下载整个目录

```C#
using (var client = new AsyncFtpClient("127.0.0.1", "admin", "123456"))
{
    await client.Connect();

    var result = await client.DownloadDirectory(@"C:\local\directory", "/remote/directory");
    Console.WriteLine($"Downloaded {result.DownloadedFiles.Count} files");
    Console.WriteLine($"Failed to download {result.FailedDownloads.Count} files");
}
```

### 3.8 使用 FTPS（FTP over SSL）

```C#
using (var client = new AsyncFtpClient("127.0.0.1", "admin", "123456"))
{
    client.Config.EncryptionMode = FtpEncryptionMode.Explicit;
    client.Config.ValidateAnyCertificate = true; // 在生产环境中应该使用proper证书验证

    await client.Connect();
    Console.WriteLine("Connected to FTPS server!");

    // 执行其他操作...
}
```

### 3.9 设置传输模式

```C#
using (var client = new AsyncFtpClient("127.0.0.1", "admin", "123456"))
{
    client.Config.DataConnectionType = FtpDataConnectionType.PASV; // 使用被动模式

    await client.Connect();

    // 执行其他操作...
}
```

## 4. 错误处理

FluentFTP 使用异常来处理错误。以下是一个错误处理的例子：

```C#
using (var client = new AsyncFtpClient("127.0.0.1", "admin", "123456"))
{
    try
    {
        await client.Connect();

        await client.UploadFile(@"C:\local\file.txt", "/remote/file.txt");
        Console.WriteLine("File uploaded successfully!");
    }
    catch (FtpAuthenticationException ex)
    {
        Console.WriteLine($"Authentication failed: {ex.Message}");
    }
    catch (FtpException ex)
    {
        Console.WriteLine($"FTP error occurred: {ex.Message}");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"An error occurred: {ex.Message}");
    }
    finally
    {
        await client.Disconnect();
    }
}
```

## 5. 结论

FluentFTP 是一个功能丰富且易于使用的 FTP 客户端库。它提供了广泛的 FTP 操作支持，包括文件上传、下载、目录管理等。通过其流畅的 API 设计，你可以轻松地在 .NET 应用程序中集成 FTP 功能。

本文提供的示例涵盖了从基本连接到高级操作的多个方面，应该能够满足大多数 FTP 相关的需求。无论是简单的文件传输还是复杂的 FTP 自动化任务，FluentFTP 都能胜任。

在使用 FluentFTP 时，请记住正确处理错误，并在生产环境中使用安全的连接方式（如 FTPS）。此外，对于大文件或大量文件的传输，请考虑使用异步方法和进度事件来提供更好的用户体验。

希望这篇文章对你有所帮助，祝你在 C# 开发中使用 FluentFTP 愉快！

FluentFTP：C# 中强大而灵活的 FTP 客户端库

Bogus 是一个简单yet功能强大的 C# 库，用于生成逼真的假数据。无论是在测试、原型设计还是演示中，Bogus 都能帮助你快速生成所需的模拟数据。本文将详细介绍 Bogus 的使用方法，并提供多个实用的例子。

## 1. 安装

首先，通过 NuGet 包管理器安装 Bogus：

```C#
Install-Package Bogus
```


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



## 2. 基本用法

### 2.1 生成简单的假数据

让我们从一个简单的例子开始，生成一个假人的信息：

```C#
using Bogus;

class Program
{
    static void Main(string[] args)
    {
        var faker = new Faker();

        Console.WriteLine($"Name: {faker.Name.FullName()}");
        Console.WriteLine($"Email: {faker.Internet.Email()}");
        Console.WriteLine($"Phone: {faker.Phone.PhoneNumber()}");
        Console.WriteLine($"Address: {faker.Address.FullAddress()}");
    }
}
```


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

```JavaScript
var faker = new Faker("zh_CN");
```

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

### 2.2 生成特定类型的数据

Bogus 提供了多种类型的假数据生成器：

```C#
var faker = new Faker();

Console.WriteLine($"Company: {faker.Company.CompanyName()}");
Console.WriteLine($"Catch Phrase: {faker.Company.CatchPhrase()}");
Console.WriteLine($"BS: {faker.Company.Bs()}");
Console.WriteLine($"Product: {faker.Commerce.Product()}");
Console.WriteLine($"Price: {faker.Commerce.Price()}");
Console.WriteLine($"Credit Card: {faker.Finance.CreditCardNumber()}");
Console.WriteLine($"Bitcoin Address: {faker.Finance.BitcoinAddress()}");
Console.WriteLine($"User Agent: {faker.Internet.UserAgent()}");
Console.WriteLine($"Color: {faker.Commerce.Color()}");
Console.WriteLine($"Time Zone: {faker.Date.TimeZoneString()}");
```


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

## 3. 生成自定义对象

Bogus 最强大的功能之一是能够生成自定义对象的假数据。

### 3.1 简单对象

假设我们有一个 `User` 类：

```C#
public class User
{
    public int Id { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Email { get; set; }
    public DateTime DateOfBirth { get; set; }
}
```

我们可以这样生成假用户数据：

```C#
var faker = new Faker<User>()
    .RuleFor(u => u.Id, f => f.Random.Int(1, 100))
    .RuleFor(u => u.FirstName, f => f.Name.FirstName())
    .RuleFor(u => u.LastName, f => f.Name.LastName())
    .RuleFor(u => u.Email, (f, u) => f.Internet.Email(u.FirstName, u.LastName))
    .RuleFor(u => u.DateOfBirth, f => f.Date.Past(50));

User user = faker.Generate();
Console.WriteLine($"Id: {user.Id}");
Console.WriteLine($"Name: {user.FirstName} {user.LastName}");
Console.WriteLine($"Email: {user.Email}");
Console.WriteLine($"Date of Birth: {user.DateOfBirth:d}");
```


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

### 3.2 生成多个对象

生成一个包含多个用户的列表：

```C#
var faker = new Faker<User>()
    .RuleFor(u => u.Id, f => f.Random.Int(1, 100))
    .RuleFor(u => u.FirstName, f => f.Name.FirstName())
    .RuleFor(u => u.LastName, f => f.Name.LastName())
    .RuleFor(u => u.Email, (f, u) => f.Internet.Email(u.FirstName, u.LastName))
    .RuleFor(u => u.DateOfBirth, f => f.Date.Past(50));

List<User> users = faker.Generate(10);

foreach (var user in users)
{
    Console.WriteLine($"{user.FirstName} {user.LastName} ({user.Email})");
}

```


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

### 3.3 复杂对象

假设我们有一个更复杂的 `Order` 类：

```C#
public class OrderItem
{
    public string ProductName { get; set; }
    public int Quantity { get; set; }
    public decimal Price { get; set; }
}

public class Order
{
    public int Id { get; set; }
    public User Customer { get; set; }
    public DateTime OrderDate { get; set; }
    public List<OrderItem> Items { get; set; }
    public decimal TotalAmount { get; set; }
}
```

我们可以这样生成假订单数据：

```TypeScript
var userFaker = new Faker<User>()
    .RuleFor(u => u.Id, f => f.Random.Int(1, 100))
    .RuleFor(u => u.FirstName, f => f.Name.FirstName())
    .RuleFor(u => u.LastName, f => f.Name.LastName())
    .RuleFor(u => u.Email, (f, u) => f.Internet.Email(u.FirstName, u.LastName));

var orderItemFaker = new Faker<OrderItem>()
    .RuleFor(oi => oi.ProductName, f => f.Commerce.ProductName())
    .RuleFor(oi => oi.Quantity, f => f.Random.Int(1, 10))
    .RuleFor(oi => oi.Price, f => decimal.Parse(f.Commerce.Price()));

var orderFaker = new Faker<Order>()
    .RuleFor(o => o.Id, f => f.Random.Int(1000, 9999))
    .RuleFor(o => o.Customer, f => userFaker.Generate())
    .RuleFor(o => o.OrderDate, f => f.Date.Recent(30))
    .RuleFor(o => o.Items, f => orderItemFaker.Generate(f.Random.Int(1, 5)))
    .RuleFor(o => o.TotalAmount, (f, o) => o.Items.Sum(i => i.Price * i.Quantity));

Order order = orderFaker.Generate();

Console.WriteLine($"Order ID: {order.Id}");
Console.WriteLine($"Customer: {order.Customer.FirstName} {order.Customer.LastName}");
Console.WriteLine($"Order Date: {order.OrderDate:d}");
Console.WriteLine("Items:");
foreach (var item in order.Items)
{
    Console.WriteLine($"  {item.ProductName} - Quantity: {item.Quantity}, Price: {item.Price:C}");
}
Console.WriteLine($"Total Amount: {order.TotalAmount:C}");
```


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

## 4. 高级用法

### 4.1 使用 Seed 值

使用 Seed 值可以确保每次生成相同的假数据：

```C#
var faker = new Faker("zh_CN");
faker.Random = new Randomizer(12345);

Console.WriteLine(faker.Name.FullName()); // 每次运行都会生成相同的名字

```

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

### 4.2 本地化

Bogus 支持多种语言的本地化：

```C#
var fakerEs = new Faker("es");
Console.WriteLine($"Spanish name: {fakerEs.Name.FullName()}");

var fakerDe = new Faker("de");
Console.WriteLine($"German address: {fakerDe.Address.FullAddress()}");

var fakerFr = new Faker("fr");
Console.WriteLine($"French phone number: {fakerFr.Phone.PhoneNumber()}");
```

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

### 4.3 自定义数据源

你可以创建自己的数据源：

```C#
public class CustomDataSource : DataSet
{
    public CustomDataSource()
    {
        Fruits = new[] { "Apple", "Banana", "Cherry", "Date", "Elderberry" };
        Random = new Random();
    }

    public string[] Fruits { get; set; }
    public Random Random { get; set; }

    public string GetRandomFruit()
    {
        return Fruits[Random.Next(0, Fruits.Length)];
    }
}

```

```C#
var faker = new Faker<CustomDataSource>();
faker.CustomInstantiator(f => new CustomDataSource());

var customData = faker.Generate();
Console.WriteLine($"Random fruit: {customData.GetRandomFruit()}");

```

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

### 4.4 条件规则

你可以根据条件应用不同的规则：

```C#
var userFaker = new Faker<User>()
     .RuleFor(u => u.Id, f => f.Random.Int(1, 100))
     .RuleFor(u => u.FirstName, f => f.Name.FirstName())
     .RuleFor(u => u.LastName, f => f.Name.LastName())
     .RuleFor(u => u.Email, (f, u) => f.Internet.Email(u.FirstName, u.LastName))
     .RuleFor(u => u.DateOfBirth, f => f.Date.Past(50))
     .RuleSet("adult", set =>
     {
         set.RuleFor(u => u.DateOfBirth, f => f.Date.Past(50, DateTime.Now.AddYears(-18)));
     });

var adultUser = userFaker.Generate(1, "adult").First();
Console.WriteLine($"Adult user: {adultUser.FirstName} {adultUser.LastName}, Born: {adultUser.DateOfBirth:d}");

```


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

## 5. 结论

Bogus 是一个非常强大和灵活的假数据生成库。它不仅可以生成各种类型的基本数据，还可以创建复杂的对象结构。无论是在单元测试、UI 原型设计还是演示数据准备中，Bogus 都能大大提高你的工作效率。

通过本文提供的示例，你应该能够处理大多数需要生成假数据的场景。从简单的字符串和数字到复杂的对象图，Bogus 都能轻松应对。它的本地化支持和可扩展性使其成为 .NET 开发者工具箱中不可或缺的工具。

Bogus：强大的 C# 假数据生成器

在C#开发中,LINQ (Language Integrated Query) 为我们提供了强大的数据查询和操作能力。其中,Single、SingleOrDefault、First和FirstOrDefault是四个常用且容易混淆的方法。本文将深入探讨这些方法的特点、使用场景以及它们之间的区别,帮助您在实际编程中做出正确的选择。



## Single方法

Single方法用于从序列中获取唯一满足指定条件的元素。它有两个重要的特性:

1. 如果序列中没有元素满足条件,会抛出异常。
2. 如果有多个元素满足条件,同样会抛出异常。

因此,Single方法适用于您确定序列中有且仅有一个元素满足条件的情况。

### 示例

```C#
List<int> numbers = new List<int> { 1, 3, 5, 7, 9 };

// 正确使用:只有一个元素满足条件
int result = numbers.Single(n => n == 5);
Console.WriteLine(result); // 输出: 5

// 错误使用:没有元素满足条件,会抛出异常
// int noResult = numbers.Single(n => n > 10);

// 错误使用:多个元素满足条件,会抛出异常
// int multipleResults = numbers.Single(n => n > 3);
```


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

## SingleOrDefault方法

SingleOrDefault方法与Single类似,但有一个重要区别:当没有元素满足条件时,它会返回该类型的默认值,而不是抛出异常。

### 示例

```C#
List<string> fruits = new List<string> { "Apple", "Banana", "Cherry" };

// 正确使用:只有一个元素满足条件
string result = fruits.SingleOrDefault(f => f.StartsWith("B"));
Console.WriteLine(result); // 输出: Banana

// 正确使用:没有元素满足条件,返回默认值(null)
string noResult = fruits.SingleOrDefault(f => f.StartsWith("D"));
Console.WriteLine(noResult == null ? "No result" : noResult); // 输出: No result

// 错误使用:多个元素满足条件,会抛出异常
// string multipleResults = fruits.SingleOrDefault(f => f.Length > 5);
```

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

## First方法

First方法返回序列中满足指定条件的第一个元素。与Single不同,它不要求序列中只有一个满足条件的元素。

### 示例

```C#
List<double> prices = new List<double> { 10.5, 20.3, 30.8, 15.2, 25.7 };

// 正确使用:返回第一个满足条件的元素
double result = prices.First(p => p > 20);
Console.WriteLine(result); // 输出: 20.3

// 正确使用:多个元素满足条件,返回第一个
double firstLarge = prices.First(p => p > 15);
Console.WriteLine(firstLarge); // 输出: 20.3

// 错误使用:没有元素满足条件,会抛出异常
// double noResult = prices.First(p => p > 100);
```

## FirstOrDefault方法

FirstOrDefault方法与First类似,但当没有元素满足条件时,它会返回该类型的默认值,而不是抛出异常。

### 示例

```C#
List<Person> people = new List<Person>
{
    new Person { Name = "Alice", Age = 25 },
    new Person { Name = "Bob", Age = 30 },
    new Person { Name = "Charlie", Age = 35 }
};

// 正确使用:返回第一个满足条件的元素
Person result = people.FirstOrDefault(p => p.Age > 28);
Console.WriteLine(result?.Name); // 输出: Bob

// 正确使用:没有元素满足条件,返回默认值(null)
Person noResult = people.FirstOrDefault(p => p.Age > 40);
Console.WriteLine(noResult == null ? "No result" : noResult.Name); // 输出: No result

// 正确使用:多个元素满足条件,返回第一个
Person firstAdult = people.FirstOrDefault(p => p.Age >= 18);
Console.WriteLine(firstAdult?.Name); // 输出: Alice
```

## 方法选择指南

为了帮助您在实际编程中选择合适的方法,这里提供一个简单的决策树:

1. 您期望序列中有且仅有一个元素满足条件吗?
    - 是 -> 使用 Single
    - 否 -> 继续到步骤 2
2. 您希望在没有匹配元素时返回默认值而不是抛出异常吗?
    - 是 -> 使用 SingleOrDefault
    - 否 -> 继续到步骤 3
3. 您只需要第一个满足条件的元素吗?
    - 是 -> 使用 First
    - 否 -> 使用 FirstOrDefault

## 性能考虑

在选择这些方法时,还应考虑性能因素:

- Single 和 SingleOrDefault 需要遍历整个序列以确保只有一个匹配元素。
- First 和 FirstOrDefault 在找到第一个匹配元素后就会停止遍历。

因此,对于大型集合,如果您只需要第一个匹配元素,使用 First 或 FirstOrDefault 可能会更高效。

|方法|返回值|无匹配时|多个匹配时|
|-|-|-|-|
|Single|唯一匹配的元素|抛出异常|抛出异常|
|SingleOrDefault|唯一匹配的元素或默认值|返回默认值|抛出异常|
|First|第一个匹配的元素|抛出异常|返回第一个匹配|
|FirstOrDefault|第一个匹配的元素或默认值|返回默认值|返回第一个匹配|


## 结论

理解 Single、SingleOrDefault、First 和 FirstOrDefault 这四个LINQ方法的区别和适用场景,对于编写高效、健壮的C#代码至关重要。通过正确选择和使用这些方法,您可以使您的LINQ查询更加精确和高效,同时减少潜在的运行时错误。在实际开发中,根据您的具体需求和数据特性,灵活运用这些方法,将会大大提高您的代码质量和可维护性。

LINQ中的Single、SingleOrDefault、First和FirstOrDefault:深入理解与实践

link

script

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