## 目录

1. [简介](#简介)
2. [基础知识](#基础知识)
3. [实现异型窗体的方法](#实现异型窗体的方法)
4. [实战示例](#实战示例)
5. [进阶技巧](#进阶技巧)
6. [注意事项](#注意事项)

## 简介

异型窗体是指非矩形的窗体，可以是圆形、多边形或任意不规则形状。在C#中，我们可以通过GDI+结合Windows Forms来实现各种异型窗体效果。本文将详细介绍异型窗体的实现方法和相关技巧。



## 基础知识

### GDI+ 关键类

```C#
using System.Drawing;
using System.Drawing.Drawing2D;
```

主要用到的类：

- `Graphics`: 用于绘制图形
- `GraphicsPath`: 定义复杂路径
- `Region`: 定义窗体形状区域

### 窗体透明化

要创建异型窗体，首先需要设置窗体的特定属性：

```C#
public partial class CustomForm : Form
{
    public CustomForm()
    {
        InitializeComponent();
        
        // 设置窗体样式
        this.FormBorderStyle = FormBorderStyle.None;  // 无边框
        this.BackColor = Color.White;  // 背景色
        this.TransparencyKey = Color.White;  // 透明色
    }
}
```

## 实现异型窗体的方法

### 1. 圆形窗体

```C#
public class CircleForm : Form
{
    public CircleForm()
    {
        InitializeComponent();
        this.FormBorderStyle = FormBorderStyle.None;
        
        // 创建圆形路径
        GraphicsPath path = new GraphicsPath();
        path.AddEllipse(0, 0, this.Width, this.Height);
        
        // 设置窗体区域
        this.Region = new Region(path);
        
        // 添加鼠标拖动支持
        this.MouseDown += Form_MouseDown;
        this.MouseMove += Form_MouseMove;
    }

    private Point lastPoint;

    private void Form_MouseDown(object sender, MouseEventArgs e)
    {
        lastPoint = e.Location;
    }

    private void Form_MouseMove(object sender, MouseEventArgs e)
    {
        if (e.Button == MouseButtons.Left)
        {
            this.Left += e.X - lastPoint.X;
            this.Top += e.Y - lastPoint.Y;
        }
    }

    protected override void OnPaint(PaintEventArgs e)
    {
        base.OnPaint(e);
        
        // 使用抗锯齿
        e.Graphics.SmoothingMode = SmoothingMode.AntiAlias;
        
        // 绘制边框
        using (Pen pen = new Pen(Color.Blue, 2))
        {
            e.Graphics.DrawEllipse(pen, 0, 0, this.Width - 1, this.Height - 1);
        }
    }
}
```


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

### 2. 多边形窗体

```C#
public partial class StarForm : Form
{
    public StarForm()
    {
        InitializeComponent();
        this.FormBorderStyle = FormBorderStyle.None;

        // 创建五角星路径  
        GraphicsPath path = CreateStarPath();
        this.Region = new Region(path);

        // 添加鼠标拖动支持  
        this.MouseDown += Form_MouseDown;
        this.MouseMove += Form_MouseMove;
    }

    private Point lastPoint;

    private void Form_MouseDown(object sender, MouseEventArgs e)
    {
        lastPoint = e.Location;
    }

    private void Form_MouseMove(object sender, MouseEventArgs e)
    {
        if (e.Button == MouseButtons.Left)
        {
            this.Left += e.X - lastPoint.X;
            this.Top += e.Y - lastPoint.Y;
        }
    }

    private GraphicsPath CreateStarPath()
    {
        PointF[] points = new PointF[10];
        float rx = this.Width / 2;
        float ry = this.Height / 2;

        // 调整外圆半径，确保星形在窗体内完全显示  
        float outerRadius = Math.Min(rx, ry) * 0.95f; // 留出一些边距  
        float innerRadius = outerRadius * 0.4f;  // 内圆半径  

        for (int i = 0; i < 10; i++)
        {
            double angle = i * Math.PI / 5 - Math.PI / 2; // 从顶部开始绘制  
            if (i % 2 == 0)
            {
                points[i] = new PointF(
                    (float)(rx + outerRadius * Math.Cos(angle)),
                    (float)(ry + outerRadius * Math.Sin(angle))
                );
            }
            else
            {
                points[i] = new PointF(
                    (float)(rx + innerRadius * Math.Cos(angle)),
                    (float)(ry + innerRadius * Math.Sin(angle))
                );
            }
        }

        GraphicsPath path = new GraphicsPath();
        path.AddPolygon(points);
        return path;
    }

    protected override void OnPaint(PaintEventArgs e)
    {
        base.OnPaint(e);
        e.Graphics.SmoothingMode = SmoothingMode.AntiAlias;

        using (Pen pen = new Pen(Color.Red, 2))
        {
            e.Graphics.DrawPath(pen, CreateStarPath());
        }
    }
}

```



### 3. 图片形状窗体

```C#
using System;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;
using System.Windows.Forms;
using System.Runtime.InteropServices;

namespace AppWindows
{
    public partial class ImageShapeForm : Form
    {
        private Image sourceImage;
        private Point lastPoint;  // 用于记录鼠标位置  

        // 引入Windows API  
        [DllImport("user32.dll")]
        public static extern int SendMessage(IntPtr hWnd, int Msg, int wParam, int lParam);
        [DllImport("user32.dll")]
        public static extern bool ReleaseCapture();

        public ImageShapeForm()
        {
            InitializeComponent();
            this.FormBorderStyle = FormBorderStyle.None;

            // 加载图片并设置窗体大小  
            sourceImage = Image.FromFile("dkk2p1ys2.png");
            this.Size = sourceImage.Size;

            // 创建基于图片透明度的区域  
            this.Region = CreateRegionFromImage(sourceImage);

            // 设置窗体属性  
            this.ShowInTaskbar = true;
            this.TopMost = true;

            // 绑定鼠标事件  
            this.MouseDown += ImageShapeForm_MouseDown;
        }

        private Region CreateRegionFromImage(Image image)
        {
            Bitmap bitmap = new Bitmap(image);
            Region region = new Region();
            GraphicsPath path = new GraphicsPath();

            // 扫描图片像素，创建区域  
            for (int y = 0; y < bitmap.Height; y++)
            {
                for (int x = 0; x < bitmap.Width; x++)
                {
                    Color pixel = bitmap.GetPixel(x, y);
                    if (pixel.A > 128) // 半透明以上的像素  
                    {
                        path.AddRectangle(new Rectangle(x, y, 1, 1));
                    }
                }
            }

            region = new Region(path);
            bitmap.Dispose(); // 释放位图资源  
            path.Dispose();   // 释放路径资源  
            return region;
        }

        protected override void OnPaint(PaintEventArgs e)
        {
            base.OnPaint(e);
            e.Graphics.DrawImage(sourceImage, 0, 0);
        }

        // 处理窗口拖动  
        private void ImageShapeForm_MouseDown(object sender, MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Left)
            {
                const int WM_NCLBUTTONDOWN = 0xA1;
                const int HT_CAPTION = 0x2;

                ReleaseCapture();
                SendMessage(Handle, WM_NCLBUTTONDOWN, HT_CAPTION, 0);
            }
        }

        // 在窗体关闭时释放资源  
        protected override void OnFormClosing(FormClosingEventArgs e)
        {
            base.OnFormClosing(e);
            if (sourceImage != null)
            {
                sourceImage.Dispose();
            }
        }
    }
}
```


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

### 4.添加阴影效果

```C#
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace AppWindows
{
    public partial class ShadowForm : Form
    {
        private const int SHADOW_SIZE = 5;
        private bool isDragging = false;      // 标记是否正在拖动  
        private Point lastMousePos;           // 记录鼠标位置  

        public ShadowForm()
        {
            InitializeComponent();
            this.FormBorderStyle = FormBorderStyle.None;

            // 添加鼠标事件处理  
            this.MouseDown += ShadowForm_MouseDown;
            this.MouseMove += ShadowForm_MouseMove;
            this.MouseUp += ShadowForm_MouseUp;
        }

        // 鼠标按下事件处理  
        private void ShadowForm_MouseDown(object sender, MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Left)
            {
                isDragging = true;
                lastMousePos = e.Location;
            }
        }

        // 鼠标移动事件处理  
        private void ShadowForm_MouseMove(object sender, MouseEventArgs e)
        {
            if (isDragging)
            {
                int deltaX = e.X - lastMousePos.X;
                int deltaY = e.Y - lastMousePos.Y;

                // 更新窗体位置  
                this.Location = new Point(this.Location.X + deltaX, this.Location.Y + deltaY);
            }
        }

        // 鼠标释放事件处理  
        private void ShadowForm_MouseUp(object sender, MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Left)
            {
                isDragging = false;
            }
        }

        protected override CreateParams CreateParams
        {
            get
            {
                CreateParams cp = base.CreateParams;
                cp.ClassStyle |= 0x20000;
                return cp;
            }
        }

        protected override void OnPaint(PaintEventArgs e)
        {
            base.OnPaint(e);

            // 绘制阴影  
            using (GraphicsPath path = new GraphicsPath())
            {
                path.AddEllipse(SHADOW_SIZE, SHADOW_SIZE,
                    this.Width - SHADOW_SIZE * 2,
                    this.Height - SHADOW_SIZE * 2);

                using (PathGradientBrush brush = new PathGradientBrush(path))
                {
                    brush.CenterColor = Color.FromArgb(100, 0, 0, 0);
                    brush.SurroundColors = new Color[] { Color.Transparent };
                    e.Graphics.FillPath(brush, path);
                }
            }
        }
    }
}
```


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

## 注意事项

1. **性能优化**
    - 避免在高频率事件中重复创建 `GraphicsPath` 和 `Region`
    - 使用双缓冲避免闪烁：

```C#
this.SetStyle(ControlStyles.AllPaintingInWmPaint |
              ControlStyles.UserPaint |
              ControlStyles.DoubleBuffer, true);
```
2. **内存管理**
    - 及时释放 GDI+ 对象：

```C#
protected override void Dispose(bool disposing)
{
    if (disposing)
    {
        if (currentPath != null)
            currentPath.Dispose();
        if (components != null)
            components.Dispose();
    }
    base.Dispose(disposing);
}
```
3. **兼容性考虑**
    - 在高DPI显示器上注意缩放问题
    - 考虑不同Windows版本的兼容性

## 总结

异型窗体的开发需要结合GDI+的图形处理能力和Windows Forms的窗体特性。通过合理使用`GraphicsPath`和`Region`，我们可以创建出各种独特的窗体形状。在实际应用中，需要注意性能优化和资源管理，同时要考虑用户体验和系统兼容性。

上述示例代码展示了从基础到进阶的异型窗体实现方法，开发者可以根据实际需求进行调整和扩展。记住要合理处理用户交互，确保窗体的可用性不受形状的影响。

C# GDI+ 异型窗体开发详解

[SSH.NET](http://SSH.NET) 是一个功能丰富的 .NET SSH 客户端库，它提供了一个简单而强大的 API 来执行各种 SSH 操作。本文将详细介绍 [SSH.NET](http://SSH.NET) 的使用方法，并提供多个实用的例子。

## 安装

首先，通过 NuGet 包管理器安装 [SSH.NET](http://SSH.NET)：

```C#
Install-Package SSH.NET
```

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



## 基本用法

### 连接到 SSH 服务器

```C#
using Renci.SshNet;
using System;

class Program
{
    static void Main(string[] args)
    {
        string host = "127.0.0.1";
        string username = "rick";
        string password = "123456";

        using (var client = new SshClient(host, username, password))
        {
            try
            {
                client.Connect();
                Console.WriteLine("Connected to the SSH server!");

                // 执行其他操作...

                client.Disconnect();
                Console.WriteLine("Disconnected from the SSH server.");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"An error occurred: {ex.Message}");
            }
        }
    }
}
```


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

### 执行远程命令

```C#
static void Main(string[] args)
{
    string host = "127.0.0.1";
    string username = "trueideal";
    string password = "123456";

    using (var client = new SshClient(host, username, password))
    {
        try
        {
            client.Connect();
            Console.WriteLine("Connected to the SSH server!");

            using (var cmd = client.CreateCommand("ls -l"))
            {
                var result = cmd.Execute();
                Console.WriteLine("Command output:");
                Console.WriteLine(result);
            }

            client.Disconnect();
            Console.WriteLine("Disconnected from the SSH server.");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"An error occurred: {ex.Message}");
        }
    }
}

```


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

## 高级用法

### 使用密钥认证

```C#
using Renci.SshNet;
using System.IO;

class Program
{
    static void Main(string[] args)
    {
        string host = "127.0.0.1;
        string username = "rick";
        string privateKeyFile = @"D:\private_key.pem";

        using (var stream = new FileStream(privateKeyFile, FileMode.Open, FileAccess.Read))
        {
            var privateKeyFile = new PrivateKeyFile(stream);
            var privateKeyFiles = new[] { privateKeyFile };

            using (var client = new SshClient(host, username, privateKeyFiles))
            {
                client.Connect();
                Console.WriteLine("Connected using private key authentication!");

                // 执行其他操作...

                client.Disconnect();
            }
        }
    }
}
```

### SFTP 文件传输

#### 上传

```C#
static void Main(string[] args)
{
    // SFTP服务器的连接参数  
    string host = "127.0.0.1";        // 服务器地址（本地主机）  
    string username = "trueideal";     // SFTP用户名  
    string password = "123456";        // SFTP密码  

    // 创建SFTP客户端实例并确保资源正确释放  
    using (var client = new SftpClient(host, username, password))
    {
        try
        {
            // 尝试连接到SFTP服务器  
            client.Connect();
            Console.WriteLine("已成功连接到SFTP服务器！");

            // 列出当前用户主目录下的文件  
            // 使用 "." 表示当前目录，这通常比使用 "/" 根目录有更高的成功率  
            var files = client.ListDirectory(".");
            foreach (var file in files)
            {
                // 打印每个文件的名称和大小  
                Console.WriteLine($"{file.Name} - {file.Length} 字节");
            }

            // 上传文件到SFTP服务器  
            // 打开本地文件并上传到用户的主目录  
            using (var fileStream = new FileStream(@"D:\Archive.csv", FileMode.Open))
            {
                // './Archive.csv' 表示上传到当前用户的主目录  
                client.UploadFile(fileStream, "./Archive.csv");
            }

            // 完成操作后断开连接  
            client.Disconnect();
        }
        catch (Exception ex)
        {
            // 错误处理  
            Console.WriteLine($"发生错误: {ex.Message}");
            // 输出详细的错误信息，包括堆栈跟踪等  
            Console.WriteLine($"错误详情: {ex}");
        }
    }
}

```


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

#### 下载

```C#
static void Main(string[] args)
{
    // SFTP服务器连接参数  
    string host = "127.0.0.1";
    string username = "trueideal";
    string password = "123456";

    using (var client = new SftpClient(host, username, password))
    {
        try
        {
            // 连接到SFTP服务器  
            client.Connect();
            Console.WriteLine("已成功连接到SFTP服务器！");

            // 列出服务器上可供下载的文件  
            Console.WriteLine("\n当前目录下的文件列表：");
            var files = client.ListDirectory(".");
            foreach (var file in files)
            {
                Console.WriteLine($"{file.Name} - {file.Length} 字节");
            }

            // 下载文件示例1：下载到指定路径  
            string remoteFile = "./Archive.csv";           // SFTP服务器上的文件路径  
            string localPath = @"D:\Downloads\";           // 本地保存目录  
            string localFile = Path.Combine(localPath, "Downloaded_Archive.csv"); // 本地完整文件路径  

            // 确保本地目录存在  
            Directory.CreateDirectory(localPath);

            // DownloadFile方法  
            using (var fileStream = File.Create(localFile))
            {
                Console.WriteLine($"\n开始下载文件: {remoteFile}");
                client.DownloadFile(remoteFile, fileStream);
                Console.WriteLine($"文件已下载到: {localFile}");
            }

            // 断开连接  
            client.Disconnect();
            Console.WriteLine("已断开与SFTP服务器的连接。");
        }
        catch (Exception ex)
        {
            // 错误处理  
            Console.WriteLine($"\n发生错误: {ex.Message}");
            if (ex is FileNotFoundException)
            {
                Console.WriteLine("远程文件不存在！");
            }
            else if (ex is DirectoryNotFoundException)
            {
                Console.WriteLine("本地目录不存在！");
            }
            else if (ex is IOException)
            {
                Console.WriteLine("文件读写错误！");
            }
            Console.WriteLine($"详细错误信息: {ex}");
        }
    }

    Console.WriteLine("\n按任意键退出...");
    Console.ReadKey();
}

```

### 端口转发

```C#
static void Main(string[] args)
{
    // SFTP服务器连接参数  
    string host = "127.0.0.1";
    string username = "trueideal";
    string password = "123456";

    using (var client = new SshClient(host, username, password))
    {
        try
        {
            client.Connect();
            Console.WriteLine("Connected to SSH server!");

            // 本地端口转发
            var forwardedPort = new ForwardedPortLocal("127.0.0.1", 8080, "remote.example.com", 80);
            client.AddForwardedPort(forwardedPort);
            forwardedPort.Start();

            Console.WriteLine("Port forwarding started. Press any key to stop...");
            Console.ReadKey();

            forwardedPort.Stop();
            client.Disconnect();
        }
        catch (Exception ex)
        {
            Console.WriteLine($"An error occurred: {ex.Message}");
        }
    }
}

```

- 将本地端口的连接转发到远程服务器
- 访问localhost:8080实际上访问的是remote.example.com:80

### 执行多个命令

```C#
static void Main(string[] args)
{
    // SFTP服务器连接参数  
    string host = "127.0.0.1";
    string username = "trueideal";
    string password = "123456";

    using (var client = new SshClient(host, username, password))
    {
        try
        {
            client.Connect();
            Console.WriteLine("Connected to SSH server!");

            // 执行多个命令
            using (var shellStream = client.CreateShellStream("xterm", 80, 24, 800, 600, 1024))
            {
                shellStream.WriteLine("cd /tmp");
                shellStream.WriteLine("mkdir test_folder");
                shellStream.WriteLine("ls -l");
                shellStream.WriteLine("exit");

                string line;
                while ((line = shellStream.ReadLine()) != null)
                {
                    Console.WriteLine(line);
                }
            }

            client.Disconnect();
        }
        catch (Exception ex)
        {
            Console.WriteLine($"An error occurred: {ex.Message}");
        }
    }
}

```


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

### 使用 SCP 传输文件

```C#
static void Main(string[] args)
{
    // SFTP服务器连接参数  
    string host = "127.0.0.1";
    string username = "trueideal";
    string password = "123456";

    using (var client = new ScpClient(host, username, password))
    {
        try
        {
            client.Connect();
            Console.WriteLine("Connected to SCP server!");

            // 上传文件
            client.Upload(new FileInfo(@"C:\local\file.txt"), "/remote/path/file.txt");
            Console.WriteLine("File uploaded successfully!");

            // 下载文件
            client.Download("/remote/path/file.txt", new FileInfo(@"C:\local\downloaded_file.txt"));
            Console.WriteLine("File downloaded successfully!");

            client.Disconnect();
        }
        catch (Exception ex)
        {
            Console.WriteLine($"An error occurred: {ex.Message}");
        }
    }
}

```

### 3.6 异步操作

```C#
static async Task Main(string[] args)
{
    // SFTP服务器连接参数  
    string host = "127.0.0.1";
    string username = "trueideal";
    string password = "123456";

    using (var client = new SshClient(host, username, password))
    {
        try
        {
            var timeout = TimeSpan.FromSeconds(30);
            using (var cts = new CancellationTokenSource(timeout))
            {
                await client.ConnectAsync(cts.Token);
                Console.WriteLine("Connected to SSH server!");

                var command = client.CreateCommand("ls -l");

                // 异步执行命令  
                await command.ExecuteAsync(cts.Token);

                // 命令执行完成后，可以通过Result属性获取输出  
                string result = command.Result;
                Console.WriteLine($"Command output: {result}");

                // 如果需要错误输出  
                if (!string.IsNullOrEmpty(command.Error))
                {
                    Console.WriteLine($"Error output: {command.Error}");
                }

                // 如果需要获取退出状态码  
                int? exitStatus = command.ExitStatus;
                Console.WriteLine($"Exit status: {exitStatus}");
            }

            client.Disconnect();
        }
        catch (OperationCanceledException)
        {
            Console.WriteLine("Operation timed out");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"An error occurred: {ex.Message}");
        }
        finally
        {
            if (client.IsConnected)
            {
                client.Disconnect();
            }
        }
    }
}

```


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

### 处理大文件传输

```C#
static async Task Main(string[] args)
{
    // SFTP服务器连接参数  
    string host = "127.0.0.1";
    string username = "trueideal";
    string password = "123456";

    using (var client = new SftpClient(host, username, password))
    {
        try
        {
            client.Connect();
            Console.WriteLine("Connected to SFTP server!");

            // 上传大文件
            using (var fileStream = new FileStream(@"C:\local\large_file.zip", FileMode.Open))
            {
                client.BufferSize = 4 * 1024; // 设置缓冲区大小为4K
                client.UploadFile(fileStream, "/remote/path/large_file.zip", true, (uploaded) =>
                {
                    Console.WriteLine($"Uploaded: {uploaded} bytes");
                });
            }
            Console.WriteLine("Large file uploaded successfully!");

            client.Disconnect();
        }
        catch (Exception ex)
        {
            Console.WriteLine($"An error occurred: {ex.Message}");
        }
    }
}

```

## 错误处理和最佳实践

### 使用 try-catch 块

始终使用 try-catch 块来处理可能出现的异常：

```C#
try
{
    using (var client = new SshClient(host, username, password))
    {
        client.Connect();
        // 执行操作...
        client.Disconnect();
    }
}
catch (Renci.SshNet.Common.SshAuthenticationException ex)
{
    Console.WriteLine($"Authentication failed: {ex.Message}");
}
catch (Renci.SshNet.Common.SshConnectionException ex)
{
    Console.WriteLine($"Connection failed: {ex.Message}");
}
catch (Exception ex)
{
    Console.WriteLine($"An unexpected error occurred: {ex.Message}");
}
```

### 使用 using 语句

总是使用 `using` 语句来确保资源被正确释放：

```C#
using (var client = new SshClient(host, username, password))
{
    // 使用客户端...
}
```

### 检查连接状态

在执行操作之前，始终检查连接状态：

```C#
if (!client.IsConnected)
{
    client.Connect();
}
```

### 设置超时

为长时间运行的操作设置超时：

```C#
client.ConnectionInfo.Timeout = TimeSpan.FromSeconds(30);
```

## 结论

[SSH.NET](http://SSH.NET) 是一个功能强大且易于使用的 SSH 客户端库。它提供了广泛的功能，从基本的 SSH 连接和命令执行到高级的文件传输和端口转发。通过本文提供的示例，你应该能够处理大多数 SSH 相关的任务。

使用 [SSH.NET](http://SSH.NET) 可以极大地简化在 C# 应用程序中实现 SSH 功能的过程。无论是系统管理、自动化部署还是远程数据处理，[SSH.NET](http://SSH.NET) 都是一个excellent选择。

在使用 [SSH.NET](http://SSH.NET) 时，请记住正确处理异常，并考虑网络连接的不稳定性。对于需要处理大文件或执行长时间运行的操作的情况，可能需要考虑使用异步方法和进度回调。

希望这篇文章对你有所帮助，祝你在 C# 开发中使用 [SSH.NET](http://SSH.NET) 愉快！

SSH.NET：C# 中强大的 SSH 客户端库

## 简介

ScottPlot是一个强大的.NET图表库，可以用来创建各种类型的图表。本文将详细介绍如何使用ScottPlot创建堆叠图（分组柱状图）。

## 基本实现步骤

#### nuget 安装ScottPlot.winforms


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

### 1. 创建Plot对象




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

首先需要创建一个Plot对象，这是所有图表的基础：

```C#
ScottPlot.Plot myPlot = formsPlot1.Plot;
```

### 2. 设置调色板

ScottPlot提供了多种内置调色板，这里使用Category10调色板：

```C#
ScottPlot.Palettes.Category10 palette = new();
```

### 3. 创建数据

创建Bar数组来存储柱状图的数据。每个Bar对象包含以下属性：

- Position: 柱子的位置
- Value: 柱子的高度
- FillColor: 填充颜色
- Error: 误差值（可选）

```C#
ScottPlot.Bar[] bars = {
    // 第一组
    new() { Position = 1, Value = 2, FillColor = palette.GetColor(0), Error = 1 },
    new() { Position = 2, Value = 5, FillColor = palette.GetColor(1), Error = 2 },
    new() { Position = 3, Value = 7, FillColor = palette.GetColor(2), Error = 1 },
    
    // 第二组
    new() { Position = 5, Value = 4, FillColor = palette.GetColor(0), Error = 2 },
    new() { Position = 6, Value = 7, FillColor = palette.GetColor(1), Error = 1 },
    new() { Position = 7, Value = 13, FillColor = palette.GetColor(2), Error = 3 },
    
    // 第三组
    new() { Position = 9, Value = 5, FillColor = palette.GetColor(0), Error = 1 },
    new() { Position = 10, Value = 6, FillColor = palette.GetColor(1), Error = 3 },
    new() { Position = 11, Value = 11, FillColor = palette.GetColor(2), Error = 2 },
};
```

### 4. 添加柱状图

将创建的bars数组添加到Plot对象中：

```C#
myPlot.Add.Bars(bars);
```

### 5. 配置图例

设置图例的显示和位置：

```C#
myPlot.Legend.IsVisible = true;
myPlot.Legend.Alignment = Alignment.UpperLeft;

// 手动添加图例项
myPlot.Legend.ManualItems.Add(new() { LabelText = "Monday", FillColor = palette.GetColor(0) });
myPlot.Legend.ManualItems.Add(new() { LabelText = "Tuesday", FillColor = palette.GetColor(1) });
myPlot.Legend.ManualItems.Add(new() { LabelText = "Wednesday", FillColor = palette.GetColor(2) });
```

### 6. 设置X轴标签

为分组添加标签：

```C#
Tick[] ticks = {
    new(2, "Group 1"),
    new(6, "Group 2"),
    new(10, "Group 3"),
};
myPlot.Axes.Bottom.TickGenerator = new ScottPlot.TickGenerators.NumericManual(ticks);
myPlot.Axes.Bottom.MajorTickStyle.Length = 0;
```

### 7. 其他样式设置

```C#
// 隐藏网格
myPlot.HideGrid();

// 设置底部边距
myPlot.Axes.Margins(bottom: 0);
```

### 8. 保存或显示图表

```C#
// 保存为图片
myPlot.SavePng("demo.png", 400, 300);

// 如果在Windows Forms中使用
formsPlot1.Refresh();
```

## 示例一

```C#
using ScottPlot;

namespace AppScottPlot
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            ScottPlot.Plot myPlot = formsPlot1.Plot;
            myPlot.Font.Set("SimSun");
            // 设置调色板  
            ScottPlot.Palettes.Category10 palette = new();

            // 创建销售数据  
            ScottPlot.Bar[] salesBars = {  
                // 第一季度销售数据  
                new() { Position = 1, Value = 150000, FillColor = palette.GetColor(0), Error = 5000 },  // 服装  
                new() { Position = 2, Value = 280000, FillColor = palette.GetColor(1), Error = 8000 },  // 电子  
                new() { Position = 3, Value = 120000, FillColor = palette.GetColor(2), Error = 4000 },  // 家居  

                // 第二季度销售数据  
                new() { Position = 5, Value = 180000, FillColor = palette.GetColor(0), Error = 6000 },  // 服装  
                new() { Position = 6, Value = 320000, FillColor = palette.GetColor(1), Error = 9000 },  // 电子  
                new() { Position = 7, Value = 150000, FillColor = palette.GetColor(2), Error = 5000 },  // 家居  

                // 第三季度销售数据  
                new() { Position = 9, Value = 220000, FillColor = palette.GetColor(0), Error = 7000 },  // 服装  
                new() { Position = 10, Value = 380000, FillColor = palette.GetColor(1), Error = 10000 }, // 电子  
                new() { Position = 11, Value = 180000, FillColor = palette.GetColor(2), Error = 6000 },  // 家居  
            };

            // 添加柱状图  
            myPlot.Add.Bars(salesBars);

            // 配置图例  
            myPlot.Legend.IsVisible = true;
            myPlot.Legend.Alignment = Alignment.UpperLeft;
            myPlot.Legend.ManualItems.Add(new() { LabelText = "服装", FillColor = palette.GetColor(0) });
            myPlot.Legend.ManualItems.Add(new() { LabelText = "电子产品", FillColor = palette.GetColor(1) });
            myPlot.Legend.ManualItems.Add(new() { LabelText = "家居用品", FillColor = palette.GetColor(2) });

            // 设置季度标签  
            Tick[] ticks = {
                new(2, "q1"),
                new(6, "q2"),
                new(10, "q3"),
            };
            myPlot.Axes.Bottom.TickGenerator = new ScottPlot.TickGenerators.NumericManual(ticks);
            myPlot.Axes.Bottom.MajorTickStyle.Length = 0;

            // 设置Y轴标签格式（显示为"100k"形式）  
            myPlot.Axes.Left.Label.Text = "销售额 (元)";

            // 设置标题  
            myPlot.Title("季度销售数据分析",16);

            // 隐藏网格并设置边距  
            myPlot.HideGrid();
            myPlot.Axes.Margins(bottom: 0);


            formsPlot1.Refresh();
        }
    }
}

```


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

## 示例二

```C#
using ScottPlot;

namespace AppScottPlot
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            ScottPlot.Plot myPlot = formsPlot1.Plot;
            myPlot.Font.Set("SimSun");
            // 设置调色板  
            ScottPlot.Palettes.Category10 palette = new();

            // 创建堆叠柱状图数据  
            ScottPlot.Bar[] bars =
            {  
                // 第一季度堆叠柱状图  
                new() { Position = 1, ValueBase = 0, Value = 150000, FillColor = palette.GetColor(0) },         // 服装  
                new() { Position = 1, ValueBase = 150000, Value = 430000, FillColor = palette.GetColor(1) },    // 电子  
                new() { Position = 1, ValueBase = 430000, Value = 550000, FillColor = palette.GetColor(2) },    // 家居  

                // 第二季度堆叠柱状图  
                new() { Position = 2, ValueBase = 0, Value = 180000, FillColor = palette.GetColor(0) },         // 服装  
                new() { Position = 2, ValueBase = 180000, Value = 500000, FillColor = palette.GetColor(1) },    // 电子  
                new() { Position = 2, ValueBase = 500000, Value = 650000, FillColor = palette.GetColor(2) },    // 家居  

                // 第三季度堆叠柱状图  
                new() { Position = 3, ValueBase = 0, Value = 220000, FillColor = palette.GetColor(0) },         // 服装  
                new() { Position = 3, ValueBase = 220000, Value = 600000, FillColor = palette.GetColor(1) },    // 电子  
                new() { Position = 3, ValueBase = 600000, Value = 780000, FillColor = palette.GetColor(2) },    // 家居  
            };

            // 添加堆叠柱状图  
            myPlot.Add.Bars(bars);

            // 配置图例  
            myPlot.Legend.IsVisible = true;
            myPlot.Legend.Alignment = Alignment.UpperLeft;
            myPlot.Legend.ManualItems.Add(new() { LabelText = "服装", FillColor = palette.GetColor(0) });
            myPlot.Legend.ManualItems.Add(new() { LabelText = "电子产品", FillColor = palette.GetColor(1) });
            myPlot.Legend.ManualItems.Add(new() { LabelText = "家居用品", FillColor = palette.GetColor(2) });

            // 设置季度标签  
            Tick[] ticks = {
                new(1, "Q1"),
                new(2, "Q2"),
                new(3, "Q3"),
            };
            myPlot.Axes.Bottom.TickGenerator = new ScottPlot.TickGenerators.NumericManual(ticks);
            myPlot.Axes.Bottom.MajorTickStyle.Length = 0;

            // 设置Y轴标签  
            myPlot.Axes.Left.Label.Text = "销售额 (元)";

            // 设置标题  
            myPlot.Title("季度销售数据分析", 16);

            // 隐藏网格并设置边距  
            myPlot.HideGrid();
            myPlot.Axes.Margins(bottom: 0);

            formsPlot1.Refresh();
        }
    }
}
```


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

## 实际应用场景

这种堆叠图特别适合用于：

- 比较不同类别在不同组别下的数据
- 展示时间序列数据的多个维度
- 展示销售数据的不同产品类别
- 分析不同时期的数据分布

## 总结

ScottPlot提供了灵活且强大的API来创建堆叠图。通过合理配置Position和分组，可以创建出清晰易读的数据可视化图表。配合颜色、图例和标签的设置，能够制作出专业的数据展示效果。

C# 下 ScottPlot堆叠图详细教程

## 产品介绍

ADF400L系列多用户电能表支持Modbus TCP协议通信，通过以太网接口可以实现远程数据读取。该系列电表最多支持：

- 12路三相或36路单相直接接入测量
- 12路三相互感器接入测量
- 直接接入和互感器接入的混合测量

## 通信配置

### 硬件连接

- 通信接口：以太网接口(CE功能)
- 通信协议：Modbus TCP



### 通信参数设置

通过寄存器配置：

- 使能CE以太网：地址0x0964，写入1使能
- 通信协议选择：地址0x0908，写入0选择Modbus协议

## 数据读取示例

### 读取三相电压

```C#
// 读取三相电压(0.1V)
const ushort UA_ADDR = 0x033F;  // A相电压
const ushort UB_ADDR = 0x0340;  // B相电压
const ushort UC_ADDR = 0x0341;  // C相电压

// 读取结果需除以10转换为V
double Ua = ReadHoldingRegister(UA_ADDR) / 10.0;
double Ub = ReadHoldingRegister(UB_ADDR) / 10.0;
double Uc = ReadHoldingRegister(UC_ADDR) / 10.0;
```

### 读取三相电流

```C#
// 读取三相电流(0.01A)
const ushort IA_ADDR = 0x0342;  // A相电流
const ushort IB_ADDR = 0x0343;  // B相电流
const ushort IC_ADDR = 0x0344;  // C相电流

// 读取结果需除以100转换为A
double Ia = ReadHoldingRegister(IA_ADDR) / 100.0;
double Ib = ReadHoldingRegister(IB_ADDR) / 100.0;
double Ic = ReadHoldingRegister(IC_ADDR) / 100.0;
```

### 读取总有功电能

```C#
// 读取总有功电能(0.01kWh)
const ushort TOTAL_ENERGY_ADDR_L = 0x035E;  // 低位地址
const ushort TOTAL_ENERGY_ADDR_H = 0x035F;  // 高位地址

// 读取两个寄存器
ushort lowWord = ReadHoldingRegister(TOTAL_ENERGY_ADDR_L);
ushort highWord = ReadHoldingRegister(TOTAL_ENERGY_ADDR_H);

// 组合为32位值
uint rawValue = ((uint)lowWord << 16) | highWord ;

// 应用互感器变比
ushort pt = ReadHoldingRegister(0x0951);  // PT变比
ushort ct = ReadHoldingRegister(0x0952);  // CT变比

// 计算实际电能值(kWh)
double actualEnergy = (rawValue / 100.0) * pt * ct;
```

这里的高低位一定注意，与我习惯的高位在前不现，它是低位在前。

### 读取功率因数

```C#
// 读取总功率因数(0.001)
const ushort PF_ADDR = 0x034D;

// 读取结果需除以1000
double powerFactor = ReadHoldingRegister(PF_ADDR) / 1000.0;
```

### NModbus4

```C#
try
{
    ushort numInputs = 2;
    ushort[] inputs = master.ReadHoldingRegisters(tableId, startAddress, numInputs);
    // 获取两个寄存器的值  
    ushort word1 = inputs[0];  // 第一个字  
    ushort word2 = inputs[1];  // 第二个字  
    uint value1 = ((uint)word1 << 16) | word2;   
    sb.AppendLine($"  原始值: Word1=0x{word1:X4}, Word2=0x{word2:X4}");

}
catch (Exception ex)
{
    sb.AppendLine($"{description}[0x{startAddress:X4}] 读取错误: {ex.Message}");
}

```

以下截图，我是测试出来的数据。



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


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

## 注意事项

1. 数据读取前确保以太网功能已使能
2. 注意数据单位转换
3. 读取电能值时需考虑互感器变比
4. 确保通信地址正确（每个相邻互感器接入用户和三相用户的地址间隔为3，每个单相用户的地址间隔为1）
5. 表号的取值应为（1、37、73....）

## 错误处理

常见故障排查：

1. 无法通讯时：
    - 检查网络连接是否正常
    - 确认以太网功能是否使能
    - 验证通信参数设置是否正确
2. 数据异常时：
    - 检查数据单位换算是否正确
    - 验证互感器变比设置
    - 确认寄存器地址是否正确

通过以上配置和示例代码，可以实现对ADF400L系列多用户电能表的数据读取和监控。

C# ADF400L系列多用户电能表Modbus TCP通信指南

## 项目准备

首先需要安装必要的 NuGet 包：

```XML
<PackageReference Include="Vosk" Version="0.3.38" />
<PackageReference Include="NAudio" Version="2.2.1" />
```


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



## 2. 下载语音模型

1. 访问 [Vosk 模型下载页面](https://alphacephei.com/vosk/models)

```HTML
https://alphacephei.com/vosk/models
```

    ![](https://secure2.wostatic.cn/static/d7wAiBNg5i631tYeLN4maY/image.png?auth_key=1739825181-2qZ2TSJ6MAVHnF917V68g-0-1e7dafc4bedd9d9a629204e8373aed39)
2. 下载中文模型 `中文` 或其他语言模型


![image.png](https://blog.idiosoft.com/static/img/e77f357cc695019d01262ca1846218ee.image.webp)
3. 解压模型文件到项目目录下的 `Models` 文件夹

## 3. 完整代码实现

```C#
using NAudio.Wave;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;
using Vosk;

namespace AppVosk
{
    public class SpeechToTextConverter
    {
        private readonly string _modelPath;

        public SpeechToTextConverter(string modelPath)
        {
            _modelPath = modelPath;
            // 初始化 Vosk
            Vosk.Vosk.SetLogLevel(0);
            if (!Directory.Exists(_modelPath))
            {
                throw new DirectoryNotFoundException($"请确保模型文件夹存在: {_modelPath}");
            }
        }

        public async Task<string> ConvertToText(string audioFilePath)
        {
            if (!File.Exists(audioFilePath))
            {
                throw new FileNotFoundException($"音频文件不存在: {audioFilePath}");
            }

            // 将音频转换为 WAV 格式（如果是 MP3）
            string wavFile = audioFilePath;
            bool needsDisposal = false;

            if (Path.GetExtension(audioFilePath).ToLower() == ".mp3")
            {
                wavFile = Path.Combine(Path.GetTempPath(), Path.GetFileNameWithoutExtension(audioFilePath) + ".wav");
                using (var reader = new Mp3FileReader(audioFilePath))
                using (var writer = new WaveFileWriter(wavFile, reader.WaveFormat))
                {
                    reader.CopyTo(writer);
                }
                needsDisposal = true;
            }

            try
            {
                using (var model = new Model(_modelPath))
                using (var recognizer = new VoskRecognizer(model, 16000.0f))
                using (var waveStream = new WaveFileReader(wavFile))
                {
                    // 重采样到 16kHz (如果需要)
                    var outFormat = new WaveFormat(16000, 1);
                    using (var resampler = new MediaFoundationResampler(waveStream, outFormat))
                    {
                        byte[] buffer = new byte[4096];
                        int bytesRead;

                        while ((bytesRead = resampler.Read(buffer, 0, buffer.Length)) > 0)
                        {
                            if (recognizer.AcceptWaveform(buffer, bytesRead))
                            {
                                // 处理中间结果（如果需要）
                            }
                        }
                    }

                    // 获取最终识别结果
                    var result = JsonDocument.Parse(recognizer.FinalResult());
                    return result.RootElement.GetProperty("text").GetString() ?? string.Empty;
                }
            }
            finally
            {
                // 清理临时 WAV 文件
                if (needsDisposal && File.Exists(wavFile))
                {
                    try
                    {
                        File.Delete(wavFile);
                    }
                    catch { /* 忽略删除失败 */ }
                }
            }
        }
    }
}

```

## 4. 使用示例


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

```C#
class Program
{
    static async Task Main(string[] args)
    {
        try
        {
            // 指定模型路径和音频文件路径
            string modelPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Models", "vosk-model-small-cn-0.22");
            string audioFile = "test.mp3";  // 或 test.wav

            var converter = new SpeechToTextConverter(modelPath);
            string result = await converter.ConvertToText(audioFile);
            
            Console.WriteLine("识别结果:");
            Console.WriteLine(result);
        }
        catch (Exception ex)
        {
            Console.WriteLine($"发生错误: {ex.Message}");
        }
    }
}
```


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

我下载的是1.3G的模型，这个速度会有点慢。

## 5. 主要功能说明

1. **格式转换**：支持 MP3 和 WAV 格式的输入，自动将 MP3 转换为 WAV
2. **重采样**：自动将音频重采样至 16kHz，以符合 Vosk 的要求
3. **错误处理**：包含完整的错误处理和资源清理
4. **内存优化**：使用流式处理，适合处理大文件
5. **临时文件管理**：自动清理转换过程中产生的临时文件

## 6. 总结

本文介绍了如何使用 Vosk 和 NAudio 库实现语音转文字的功能，支持 MP3 和 WAV 格式的音频输入，并自动将 MP3 转换为 WAV 格式，同时对音频进行重采样至 16kHz，以满足 Vosk 的要求。文章详细讲解了代码实现，包括模型文件的加载、音频格式转换、重采样处理以及最终的语音识别流程。通过将模型加载放在应用程序启动时，可以提高识别效率，避免重复加载模型。整体方案简单高效，适合需要实现语音识别功能的开发者参考和使用。

C# 使用Vosk离线语音转文字完整实现指南

link

script

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