本文将尝试说明如何使用C#创建一个完整的OPC UA服务器。我们将使用开源的OPC UA .NET Standard库，感觉要写一个完整的服务还是太麻烦了，要考虑的太多了，只能给有需要的朋友一点点意见吧。

## 项目准备

首先需要安装必要的NuGet包。在Visual Studio中，通过NuGet包管理器安装：

```C#
OPCFoundation.NetStandard.Opc.Ua
```

## 完整代码示例



### Program.cs

```C#
class Program {
  static async Task Main(string[] args) {
    MyServer server = new MyServer();
    await server.Start();

    Console.WriteLine("OPC UA Server started. Press Enter to exit.");
    Console.ReadLine();

    server.Stop();
  }
}

```

### MyServer.cs

```C#
public class MyServer {
  private ApplicationInstance application;
  private StandardServer server;
  private MyNodeManager nodeManager;

  public async Task Start() {
    try {
      // 步骤1：创建应用程序配置
      application =
          new ApplicationInstance { ApplicationName = "My OPC UA Server",
                                    ApplicationType = ApplicationType.Server,
                                    ConfigSectionName = "MyOpcUaServer" };

      // 加载应用程序配置
      var config = await LoadApplicationConfiguration();

      // 步骤2：检查证书
      await application.CheckApplicationInstanceCertificate(false, 2048);

      // 步骤3：创建自定义服务器实例
      server = new CustomStandardServer(config);

      // 步骤4：启动服务器
      await application.Start(server);

      Console.WriteLine(
          $"Server started at: {config.ServerConfiguration.BaseAddresses[0]}");
    } catch (Exception ex) {
      Console.WriteLine($"Error starting server: {ex.Message}");
      throw;
    }
  }

  public void Stop() {
    if (server != null) {
      server.Stop();
    }
  }

  private async Task<ApplicationConfiguration> LoadApplicationConfiguration() {
    var config = new ApplicationConfiguration() {
      ApplicationName = "My OPC UA Server",
      ApplicationUri = "urn:MyOpcUaServer",
      ApplicationType = ApplicationType.Server,
      SecurityConfiguration =
          new SecurityConfiguration {
            ApplicationCertificate = new CertificateIdentifier(),
            TrustedPeerCertificates = new CertificateTrustList(),
            TrustedIssuerCertificates = new CertificateTrustList(),
            RejectedCertificateStore = new CertificateTrustList(),
            AutoAcceptUntrustedCertificates = true
          },
      TransportConfigurations = new TransportConfigurationCollection(),
      TransportQuotas = new TransportQuotas { OperationTimeout = 15000 },
      ServerConfiguration =
          new ServerConfiguration {
            BaseAddresses =
                new StringCollection {
                  "opc.tcp://localhost:4840/MyOpcUaServer"
                },
            MinRequestThreadCount = 5,
            MaxRequestThreadCount = 100,
            MaxQueuedRequestCount = 200,
          },
      TraceConfiguration = new TraceConfiguration()
    };

    await config.Validate(ApplicationType.Server);
    return config;
  }
}

// 自定义服务器类，用于初始化节点管理器
public class CustomStandardServer : StandardServer {
  private ApplicationConfiguration configuration;

  public CustomStandardServer(ApplicationConfiguration configuration) {
    this.configuration = configuration;
  }

    protected override MasterNodeManager CreateMasterNodeManager(IServerInternal server, ApplicationConfiguration configuration
    {
    List<INodeManager> nodeManagers = new List<INodeManager>();

    // 创建自定义节点管理器并添加到列表
    nodeManagers.Add(new MyNodeManager(server, configuration));

    // 创建主节点管理器
    return new MasterNodeManager(server, configuration, null,
                                 nodeManagers.ToArray());
    }
}

```

### MyNodeManager.cs

```C#
public class MyNodeManager : CustomNodeManager2
{
    private IServerInternal server;
    private ApplicationConfiguration configuration;

    public MyNodeManager(IServerInternal server, ApplicationConfiguration configuration)
        : base(server, configuration, "http://myopcuaserver.com")
    {
        this.server = server;
        this.configuration = configuration;
        SystemContext.NodeIdFactory = this;
    }

    public override void CreateAddressSpace(IDictionary<NodeId, IList<IReference>> externalReferences)
    {
        lock (Lock)
        {
            IList<IReference> references = null;
            if (!externalReferences.TryGetValue(ObjectIds.ObjectsFolder, out references))
            {
                references = new List<IReference>();
                externalReferences[ObjectIds.ObjectsFolder] = references;
            }

            // 创建 MyDevices 文件夹  
            FolderState myDevicesFolder = CreateFolder(null, "MyDevices", "设备");

            // 将文件夹组织到 Objects 文件夹下  
            myDevicesFolder.AddReference(ReferenceTypes.Organizes, true, ObjectIds.ObjectsFolder);
            references.Add(new NodeStateReference(ReferenceTypes.Organizes, false, myDevicesFolder.NodeId));

            // 设置文件夹属性  
            myDevicesFolder.EventNotifier = EventNotifiers.SubscribeToEvents;
            AddPredefinedNode(SystemContext, myDevicesFolder);

            // 创建温度变量  
            BaseDataVariableState temperatureVariable = CreateVariable(
                myDevicesFolder,
                "Temperature",
                "温度",
                DataTypeIds.Double,
                ValueRanks.Scalar);

            // 设置温度变量的属性  
            temperatureVariable.Value = 25.0;
            temperatureVariable.AccessLevel = AccessLevels.CurrentRead | AccessLevels.CurrentWrite;
            temperatureVariable.UserAccessLevel = AccessLevels.CurrentRead | AccessLevels.CurrentWrite;
            temperatureVariable.Historizing = false;
            temperatureVariable.StatusCode = StatusCodes.Good;
            temperatureVariable.Timestamp = DateTime.Now;

            // 添加工程单位  
            AddEngineeringUnit(temperatureVariable, "°C", "摄氏度");

            // 添加描述  
            temperatureVariable.Description = new LocalizedText("当前温度值");

            // 添加范围  
            AddAnalogRange(temperatureVariable, -100.0, 100.0);

            AddPredefinedNode(SystemContext, temperatureVariable);

            // 创建湿度变量  
            BaseDataVariableState humidityVariable = CreateVariable(
                myDevicesFolder,
                "Humidity",
                "湿度",
                DataTypeIds.Double,
                ValueRanks.Scalar);

            // 设置湿度变量的属性  
            humidityVariable.Value = 60.0;
            humidityVariable.AccessLevel = AccessLevels.CurrentRead | AccessLevels.CurrentWrite;
            humidityVariable.UserAccessLevel = AccessLevels.CurrentRead | AccessLevels.CurrentWrite;
            humidityVariable.Historizing = false;
            humidityVariable.StatusCode = StatusCodes.Good;
            humidityVariable.Timestamp = DateTime.Now;

            // 添加工程单位  
            AddEngineeringUnit(humidityVariable, "%RH", "相对湿度");

            // 添加描述  
            humidityVariable.Description = new LocalizedText("当前湿度值");

            // 添加范围  
            AddAnalogRange(humidityVariable, 0.0, 100.0);

            AddPredefinedNode(SystemContext, humidityVariable);
        }
    }

    private FolderState CreateFolder(NodeState parent, string name, string displayName)
    {
        FolderState folder = new FolderState(parent);

        folder.SymbolicName = name;
        folder.ReferenceTypeId = ReferenceTypes.Organizes;
        folder.TypeDefinitionId = ObjectTypeIds.FolderType;
        folder.NodeId = new NodeId(name, NamespaceIndex);
        folder.BrowseName = new QualifiedName(name, NamespaceIndex);
        folder.DisplayName = new LocalizedText(displayName);
        folder.WriteMask = AttributeWriteMask.None;
        folder.UserWriteMask = AttributeWriteMask.None;
        folder.EventNotifier = EventNotifiers.None;

        if (parent != null)
        {
            parent.AddChild(folder);
        }

        return folder;
    }

    private BaseDataVariableState CreateVariable(
        NodeState parent,
        string name,
        string displayName,
        NodeId dataType,
        int valueRank)
    {
        BaseDataVariableState variable = new BaseDataVariableState(parent);

        variable.SymbolicName = name;
        variable.ReferenceTypeId = ReferenceTypes.Organizes;
        variable.TypeDefinitionId = VariableTypeIds.BaseDataVariableType;
        variable.NodeId = new NodeId(name, NamespaceIndex);
        variable.BrowseName = new QualifiedName(name, NamespaceIndex);
        variable.DisplayName = new LocalizedText(displayName);
        variable.WriteMask = AttributeWriteMask.DisplayName | AttributeWriteMask.Description;
        variable.UserWriteMask = AttributeWriteMask.DisplayName | AttributeWriteMask.Description;
        variable.DataType = dataType;
        variable.ValueRank = valueRank;
        variable.AccessLevel = AccessLevels.CurrentRead | AccessLevels.CurrentWrite;
        variable.UserAccessLevel = AccessLevels.CurrentRead | AccessLevels.CurrentWrite;
        variable.MinimumSamplingInterval = 100;

        if (parent != null)
        {
            parent.AddChild(variable);
        }

        return variable;
    }

    private void AddEngineeringUnit(BaseVariableState variable, string unitId, string displayName)
    {
        ExtensionObject engineeringUnit = new ExtensionObject(
            new EUInformation(
                unitId,                    // UnitId  
                displayName,               // DisplayName  
                string.Empty              // Description  
            ));

        PropertyState property = new PropertyState(variable);
        property.ReferenceTypeId = ReferenceTypes.HasProperty;
        property.TypeDefinitionId = VariableTypeIds.PropertyType;
        property.NodeId = new NodeId(variable.SymbolicName + "_EURange", NamespaceIndex);
        property.BrowseName = BrowseNames.EngineeringUnits;
        property.DisplayName = BrowseNames.EngineeringUnits;
        property.DataType = DataTypeIds.EUInformation;
        property.ValueRank = ValueRanks.Scalar;
        property.AccessLevel = AccessLevels.CurrentRead;
        property.UserAccessLevel = AccessLevels.CurrentRead;
        property.Value = engineeringUnit;
        variable.AddChild(property);
    }

    private void AddAnalogRange(BaseDataVariableState variable, double min, double max)
    {
        Range range = new Range(min, max);
        ExtensionObject extensionObject = new ExtensionObject(range);

        PropertyState property = new PropertyState(variable);
        property.ReferenceTypeId = ReferenceTypes.HasProperty;
        property.TypeDefinitionId = VariableTypeIds.PropertyType;
        property.NodeId = new NodeId(variable.SymbolicName + "_Range", NamespaceIndex);
        property.BrowseName = BrowseNames.EURange;
        property.DisplayName = BrowseNames.EURange;
        property.DataType = DataTypeIds.Range;
        property.ValueRank = ValueRanks.Scalar;
        property.AccessLevel = AccessLevels.CurrentRead;
        property.UserAccessLevel = AccessLevels.CurrentRead;
        property.Value = extensionObject;
        variable.AddChild(property);
    }

    protected override NodeStateCollection LoadPredefinedNodes(ISystemContext context)
    {
        NodeStateCollection predefinedNodes = new NodeStateCollection();
        return predefinedNodes;
    }
}

```


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

使用UaExpert 简单测试


![image.png](https://blog.idiosoft.com/static/img/5cfcf10c84d8e70d5172bd0bccf17c67.image.webp)
## 3. 注意事项

1. 本示例使用了自签名证书，生产环境中应使用正式的安全证书
2. 为了简化示例，启用了自动接受不受信任的证书（AutoAcceptUntrustedCertificates = true）
3. 生产环境中应该添加适当的错误处理和日志记录
4. 可以根据需要添加更多的节点和功能

## 结论

这个示例提供了一个基础但完整的OPC UA服务器实现。它可以作为开发更复杂OPC UA应用程序的起点。根据具体需求，你可以扩展功能，添加更多的节点类型，实现数据持久化等高级特性。

C# OPC UA 服务器实现指南

## 概述

‌**三次样条插值（Cubic Spline Interpolation）**‌是一种通过一系列形值点构造一条光滑曲线的数学方法。它使用分段三次多项式来逼近原始数据点，从而在保持数据点的同时，使得整个曲线在各段内光滑连续。

本文将实现一个动态的三次样条插值可视化程序，包含以下功能：

- 随机生成折线图数据
- 点击按钮后动画显示平滑的三次样条曲线
- 完整的GDI+绘图实现
- 动画效果的实现

## 完整代码实现


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



### 三次样条插值核心类

```C#
public class CubicSpline
{
    private readonly double[] _x;
    private readonly double[] _y;
    private readonly double[] _a;
    private readonly double[] _b;
    private readonly double[] _c;
    private readonly double[] _d;

    public CubicSpline(double[] x, double[] y)
    {
        if (x == null || y == null || x.Length != y.Length || x.Length < 2)
            throw new ArgumentException("Invalid input data");

        _x = x;
        _y = y;
        int n = x.Length;
        _a = new double[n];
        _b = new double[n - 1];
        _c = new double[n];
        _d = new double[n - 1];

        CalculateCoefficients();
    }

    private void CalculateCoefficients()
    {
        int n = _x.Length;
        double[] h = new double[n - 1];
        double[] alpha = new double[n - 1];

        for (int i = 0; i < n - 1; i++)
        {
            h[i] = _x[i + 1] - _x[i];
            _a[i] = _y[i];
        }
        _a[n - 1] = _y[n - 1];

        for (int i = 1; i < n - 1; i++)
        {
            alpha[i] = 3 / h[i] * (_y[i + 1] - _y[i]) - 3 / h[i - 1] * (_y[i] - _y[i - 1]);
        }

        double[] l = new double[n];
        double[] mu = new double[n];
        double[] z = new double[n];

        l[0] = 1;
        mu[0] = 0;
        z[0] = 0;

        for (int i = 1; i < n - 1; i++)
        {
            l[i] = 2 * (_x[i + 1] - _x[i - 1]) - h[i - 1] * mu[i - 1];
            mu[i] = h[i] / l[i];
            z[i] = (alpha[i] - h[i - 1] * z[i - 1]) / l[i];
        }

        l[n - 1] = 1;
        z[n - 1] = 0;
        _c[n - 1] = 0;

        for (int j = n - 2; j >= 0; j--)
        {
            _c[j] = z[j] - mu[j] * _c[j + 1];
            _b[j] = (_y[j + 1] - _y[j]) / h[j] - h[j] * (_c[j + 1] + 2 * _c[j]) / 3;
            _d[j] = (_c[j + 1] - _c[j]) / (3 * h[j]);
        }
    }

    public double Interpolate(double x)
    {
        int i = 0;
        while (i < _x.Length - 2 && x > _x[i + 1]) i++;

        double dx = x - _x[i];
        return _a[i] + _b[i] * dx + _c[i] * dx * dx + _d[i] * dx * dx * dx;
    }
}
```

### 主窗体实现

```C#
public partial class Form2 : Form
{
    private List<Point> _dataPoints;
    private List<Point> _splinePoints;
    private float _animationProgress;
    private Timer _animationTimer;

    private bool _isAnimating;
    private CubicSpline _spline;
    public Form2()
    {
        InitializeComponent();

        this.DoubleBuffered = true;

        GenerateRandomData();
        CalculateSplinePoints();

        _animationTimer = new Timer
        {
            Interval = 60
        };
        _animationTimer.Tick += AnimationTimer_Tick;

        this.Paint += Form1_Paint;
    }


    private void AnimationTimer_Tick(object sender, EventArgs e)
    {
        _animationProgress += 0.02f;

        if (_animationProgress >= 1)
        {
            _animationProgress = 1;
            _animationTimer.Stop();
            _isAnimating = false;

        }

        this.Invalidate();
    }


    private void GenerateRandomData()
    {
        Random rand = new Random();
        _dataPoints = new List<Point>();

        // 生成20个随机点  
        int pointCount = 20;
        int margin = 50;
        int stepX = (this.ClientSize.Width - 2 * margin) / (pointCount - 1);

        for (int i = 0; i < pointCount; i++)
        {
            int x = margin + i * stepX;
            int y = rand.Next(margin, this.ClientSize.Height - margin);
            _dataPoints.Add(new Point(x, y));
        }
    }

    private void CalculateSplinePoints()
    {
        double[] x = _dataPoints.Select(p => (double)p.X).ToArray();
        double[] y = _dataPoints.Select(p => (double)p.Y).ToArray();

        _spline = new CubicSpline(x, y);

        _splinePoints = new List<Point>();
        int steps = (_dataPoints[_dataPoints.Count - 1].X - _dataPoints[0].X);

        for (int i = 0; i <= steps; i++)
        {
            double xVal = _dataPoints[0].X + i;
            double yVal = _spline.Interpolate(xVal);
            _splinePoints.Add(new Point((int)xVal, (int)yVal));
        }
    }



    private void Form1_Paint(object sender, PaintEventArgs e)
    {
        Graphics g = e.Graphics;
        g.SmoothingMode = SmoothingMode.AntiAlias;

        // 绘制网格  
        DrawGrid(g);

        // 绘制原始折线  
        using (Pen linePen = new Pen(Color.Gray, 2))
        {
            g.DrawLines(linePen, _dataPoints.ToArray());
        }

        // 绘制数据点  
        using (Brush pointBrush = new SolidBrush(Color.Blue))
        {
            foreach (var point in _dataPoints)
            {
                g.FillEllipse(pointBrush, point.X - 4, point.Y - 4, 8, 8);
            }
        }

        // 绘制样条曲线（动画）  
        if (_isAnimating || _animationProgress > 0)
        {
            using (Pen splinePen = new Pen(Color.Red, 2))
            {
                int pointCount = (int)(_splinePoints.Count * _animationProgress);
                if (pointCount > 1)
                {
                    g.DrawLines(splinePen, _splinePoints.Take(pointCount).ToArray());
                }
            }
        }
    }

    private void DrawGrid(Graphics g)
    {
        using (Pen gridPen = new Pen(Color.LightGray, 1))
        {
            // 绘制垂直线  
            for (int x = 0; x < this.ClientSize.Width; x += 50)
            {
                g.DrawLine(gridPen, x, 0, x, this.ClientSize.Height);
            }

            // 绘制水平线  
            for (int y = 0; y < this.ClientSize.Height; y += 50)
            {
                g.DrawLine(gridPen, 0, y, this.ClientSize.Width, y);
            }
        }
    }

    private void btnStart_Click(object sender, EventArgs e)
    {
        if (!_isAnimating)
        {
            _isAnimating = true;
            _animationProgress = 0;
            _animationTimer.Start();

        }
    }
}

```

## 3. 关键功能说明

### 随机数据生成

```C#
private void GenerateRandomData()
{
    Random rand = new Random();
    int margin = 50;
    int stepX = (this.ClientSize.Width - 2 * margin) / (pointCount - 1);
    
    for (int i = 0; i < pointCount; i++)
    {
        int x = margin + i * stepX;
        int y = rand.Next(margin, this.ClientSize.Height - margin);
        _dataPoints.Add(new Point(x, y));
    }
}
```

### 动画实现

```C#
private void AnimationTimer_Tick(object sender, EventArgs e)
{
    _animationProgress += 0.02f;
    if (_animationProgress >= 1)
    {
        _animationProgress = 1;
        _animationTimer.Stop();
        _isAnimating = false;
        _animateButton.Enabled = true;
    }
    this.Invalidate();
}
```

## 使用说明

1. 运行程序后，会显示随机生成的折线图
2. 点击"显示平滑曲线"按钮，将会动画显示三次样条插值的平滑曲线
3. 动画完成后可以再次点击按钮重新显示

## 总结

这个示例展示了如何在C#中实现动态的三次样条插值可视化。通过合理使用GDI+和定时器，我们实现了平滑的动画效果。代码结构清晰，易于扩展和维护。您可以根据实际需求进行修改和优化。

C# 动态三次样条插值可视化实现

## 简介

MassTransit是一个用于.NET应用程序的开源消息总线框架，支持多种消息传输模式，包括发布/订阅、请求/响应和Saga模式。它与RabbitMQ、Azure Service Bus等消息代理集成良好，提供了可靠的消息传递和处理能力。本文将通过几个完整的C#控制台应用示例，展示如何使用MassTransit。

## 环境准备

在开始之前，[请确保已安装.NET](http://xn--ruq77z4zb208bxcrdme.NET) SDK。然后，创建一个新的控制台项目并添加MassTransit和RabbitMQ的NuGet包：

```Bash
dotnet add package MassTransit
dotnet add package MassTransit.RabbitMQ
dotnet add package Microsoft.Extensions.Hosting



```

## 示例实现

### 示例1：基础发布/订阅

在这个示例中，我们将实现一个简单的发布/订阅模式，模拟订单创建的消息传递。

```C#
using MassTransit;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

namespace AppMassTransit
{
    public record OrderCreated
    {
        public Guid OrderId { get; init; }
        public string CustomerName { get; init; }
        public decimal Amount { get; init; }
    }

    public class OrderCreatedConsumer : IConsumer<OrderCreated>
    {
        public Task Consume(ConsumeContext<OrderCreated> context)
        {
            Console.WriteLine($"Order received: {context.Message.OrderId}");
            Console.WriteLine($"Customer: {context.Message.CustomerName}");
            Console.WriteLine($"Amount: {context.Message.Amount:C}");
            return Task.CompletedTask;
        }
    }

    public class Program
    {
        public static async Task Main()
        {
            var builder = Host.CreateDefaultBuilder()
                .ConfigureServices((hostContext, services) =>
                {
                    services.AddMassTransit(x =>
                    {
                        x.AddConsumer<OrderCreatedConsumer>();

                        x.UsingRabbitMq((context, cfg) =>
                        {
                            cfg.Host("localhost", "/", h =>
                            {
                                h.Username("guest");
                                h.Password("guest");
                            });

                            cfg.ConfigureEndpoints(context);
                        });
                    });
                });

            var host = builder.Build();
            await host.StartAsync();

            var publishEndpoint = host.Services.GetRequiredService<IPublishEndpoint>();

            while (true)
            {
                Console.WriteLine("\nPress 'P' to publish a message, or 'Q' to quit.");
                var key = Console.ReadKey();
                Console.WriteLine();

                if (key.Key == ConsoleKey.Q)
                    break;

                if (key.Key == ConsoleKey.P)
                {
                    await publishEndpoint.Publish<OrderCreated>(new
                    {
                        OrderId = Guid.NewGuid(),
                        CustomerName = "Rick",
                        Amount = 99.99m
                    });

                    Console.WriteLine("Message published successfully!");
                }
            }

            await host.StopAsync();
        }
    }
}

```


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

### 示例2：请求/响应模式

在这个示例中，我们将实现一个请求/响应模式，用于检查库存。

```C#
using MassTransit;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

namespace AppMassTransit
{
    public record CheckInventory
    {
        public string ProductId { get; init; }
        public int RequestedQuantity { get; init; }
    }

    public record InventoryStatus
    {
        public string ProductId { get; init; }
        public bool IsAvailable { get; init; }
        public int AvailableQuantity { get; init; }
    }

    public class InventoryCheckConsumer : IConsumer<CheckInventory>
    {
        private readonly Dictionary<string, int> _inventory = new()
        {
            { "PROD-1", 100 },
            { "PROD-2", 50 },
            { "PROD-3", 0 }
        };

        public Task Consume(ConsumeContext<CheckInventory> context)
        {
            var message = context.Message;
            var availableQuantity = _inventory.GetValueOrDefault(message.ProductId, 0);

            return context.RespondAsync<InventoryStatus>(new
            {
                ProductId = message.ProductId,
                IsAvailable = availableQuantity >= message.RequestedQuantity,
                AvailableQuantity = availableQuantity
            });
        }
    }

    public class Program
    {
        public static async Task Main()
        {
            var builder = Host.CreateDefaultBuilder()
                .ConfigureServices((hostContext, services) =>
                {
                    services.AddMassTransit(x =>
                    {
                        x.AddConsumer<InventoryCheckConsumer>();

                        x.UsingRabbitMq((context, cfg) =>
                        {
                            cfg.Host("localhost", "/", h =>
                            {
                                h.Username("guest");
                                h.Password("guest");
                            });

                            cfg.ConfigureEndpoints(context);
                        });
                    });
                });

            var host = builder.Build();
            await host.StartAsync();

            var requestClient = host.Services.GetRequiredService<IRequestClient<CheckInventory>>();

            while (true)
            {
                Console.WriteLine("\nEnter product ID to check (or 'quit' to exit):");
                var input = Console.ReadLine();

                if (input?.ToLower() == "quit")
                    break;

                try
                {
                    var response = await requestClient.GetResponse<InventoryStatus>(new
                    {
                        ProductId = input,
                        RequestedQuantity = 10
                    });

                    var status = response.Message;
                    Console.WriteLine($"Product: {status.ProductId}");
                    Console.WriteLine($"Available: {status.IsAvailable}");
                    Console.WriteLine($"Quantity: {status.AvailableQuantity}");
                }
                catch (Exception ex)
                {
                    Console.WriteLine($"Error: {ex.Message}");
                }
            }

            await host.StopAsync();
        }
    }
}

```


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

### 示例3：状态机(Saga)

在这个示例中，我们将使用状态机来管理订单的生命周期。

```C#
using MassTransit;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

namespace AppMassTransit
{
    public class OrderState : SagaStateMachineInstance
    {
        public Guid CorrelationId { get; set; }
        public string CurrentState { get; set; }
        public string CustomerName { get; set; }
        public decimal OrderTotal { get; set; }
        public DateTime? SubmitDate { get; set; }
        public DateTime? PaymentDate { get; set; }
        public DateTime? CompletedDate { get; set; }
    }

    public record OrderSubmitted
    {
        public Guid OrderId { get; init; }
        public string CustomerName { get; init; }
        public decimal OrderTotal { get; init; }
    }

    public record PaymentCompleted
    {
        public Guid OrderId { get; init; }
    }

    public record OrderCompleted
    {
        public Guid OrderId { get; init; }
    }

    public class OrderStateMachine : MassTransitStateMachine<OrderState>
    {
        public OrderStateMachine()
        {
            InstanceState(x => x.CurrentState);

            Event(() => OrderSubmittedEvent, x => x.CorrelateById(context => context.Message.OrderId));
            Event(() => PaymentCompletedEvent, x => x.CorrelateById(context => context.Message.OrderId));
            Event(() => OrderCompletedEvent, x => x.CorrelateById(context => context.Message.OrderId));

            Initially(
                When(OrderSubmittedEvent)
                    .Then(x =>
                    {
                        x.Saga.CustomerName = x.Message.CustomerName;
                        x.Saga.OrderTotal = x.Message.OrderTotal;
                        x.Saga.SubmitDate = DateTime.UtcNow;
                        Console.WriteLine($"Order submitted: {x.Saga.CorrelationId}");
                    })
                    .TransitionTo(Submitted)
            );

            During(Submitted,
                When(PaymentCompletedEvent)
                    .Then(x =>
                    {
                        x.Saga.PaymentDate = DateTime.UtcNow;
                        Console.WriteLine($"Payment completed: {x.Saga.CorrelationId}");
                    })
                    .TransitionTo(Paid)
            );

            During(Paid,
                When(OrderCompletedEvent)
                    .Then(x =>
                    {
                        x.Saga.CompletedDate = DateTime.UtcNow;
                        Console.WriteLine($"Order completed: {x.Saga.CorrelationId}");
                    })
                    .TransitionTo(Completed)
            );
        }

        public State Submitted { get; private set; }
        public State Paid { get; private set; }
        public State Completed { get; private set; }

        public Event<OrderSubmitted> OrderSubmittedEvent { get; private set; }
        public Event<PaymentCompleted> PaymentCompletedEvent { get; private set; }
        public Event<OrderCompleted> OrderCompletedEvent { get; private set; }
    }

    public class Program
    {
        public static async Task Main()
        {
            var builder = Host.CreateDefaultBuilder()
                .ConfigureServices((hostContext, services) =>
                {
                    services.AddMassTransit(x =>
                    {
                        x.AddSagaStateMachine<OrderStateMachine, OrderState>()
                            .InMemoryRepository();

                        x.UsingRabbitMq((context, cfg) =>
                        {
                            cfg.Host("localhost", "/", h =>
                            {
                                h.Username("guest");
                                h.Password("guest");
                            });

                            cfg.ConfigureEndpoints(context);
                        });
                    });
                });

            var host = builder.Build();
            await host.StartAsync();

            var publishEndpoint = host.Services.GetRequiredService<IPublishEndpoint>();


            while (true)
            {
                Console.WriteLine("\nSelect action:");
                Console.WriteLine("1. Submit Order");
                Console.WriteLine("2. Complete Payment");
                Console.WriteLine("3. Complete Order");
                Console.WriteLine("Q. Quit");

                var key = Console.ReadKey();
                Console.WriteLine();

                switch (key.Key)
                {
                    case ConsoleKey.D1:
                        try
                        {
                            // 每次提交订单时生成新的 orderId  
                            var newOrderId = Guid.NewGuid();
                            Console.WriteLine($"Attempting to publish OrderSubmitted event with OrderId: {newOrderId}");
                            await publishEndpoint.Publish<OrderSubmitted>(new
                            {
                                OrderId = newOrderId,
                                CustomerName = "John Doe",
                                OrderTotal = 299.99m
                            });
                            Console.WriteLine($"Successfully published OrderSubmitted event with OrderId: {newOrderId}");
                        }
                        catch (Exception ex)
                        {
                            Console.WriteLine($"Error publishing OrderSubmitted event: {ex.Message}");
                        }
                        break;

                    case ConsoleKey.D2:
                        Console.WriteLine("Please enter the OrderId to complete payment:");
                        if (Guid.TryParse(Console.ReadLine(), out Guid paymentOrderId))
                        {
                            await publishEndpoint.Publish<PaymentCompleted>(new
                            {
                                OrderId = paymentOrderId
                            });
                        }
                        else
                        {
                            Console.WriteLine("Invalid OrderId format");
                        }
                        break;

                    case ConsoleKey.D3:
                        Console.WriteLine("Please enter the OrderId to complete order:");
                        if (Guid.TryParse(Console.ReadLine(), out Guid completeOrderId))
                        {
                            await publishEndpoint.Publish<OrderCompleted>(new
                            {
                                OrderId = completeOrderId
                            });
                        }
                        else
                        {
                            Console.WriteLine("Invalid OrderId format");
                        }
                        break;

                    case ConsoleKey.Q:
                        await host.StopAsync();
                        return;
                }
            }
        }
    }
}

```


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

## 总结

MassTransit为.NET应用程序提供了强大的消息传输和分布式系统集成能力。通过以上示例，我们可以看到如何在C#控制台应用中实现发布/订阅、请求/响应和Saga模式。MassTransit的灵活性和易用性使其成为构建可靠消息驱动应用程序的理想选择。

MassTransit在C#中的应用指南

## 简介  

在Windows Forms应用程序开发中，有时我们需要显示和管理SVG（可缩放矢量图形）文件。本文将详细介绍一个功能完整的SVG查看器控件（SvgViewer）的实现，该控件支持SVG文件的加载、动画播放、缩放等功能。  

## 核心功能  

- SVG文件加载（单个/批量/目录）  
- 支持从程序集资源加载SVG  
- 动画播放控制（播放/暂停/停止）  
- 帧切换（上一个/下一个）  
- 自动播放和循环播放  
- 多种显示模式  
- 资源缓存机制  



## 实现详解  

```C#
using Svg;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using Timer = System.Windows.Forms.Timer;

namespace AppSvg01
{
    /// <summary>  
    /// SVG显示控件  
    /// </summary>  
    public class SvgViewer : Control
    {
        private readonly Timer animationTimer;
        private readonly List<SvgDocument> svgDocuments;
        private readonly Dictionary<string, SvgDocument> resourceCache;
        private Image currentImage;
        private int currentIndex;
        private bool isPlaying;

        #region Properties  

        private int interval = 1000; // 默认1秒  
        [Category("Behavior")]
        [Description("设置SVG切换间隔（毫秒）")]
        public int Interval
        {
            get => interval;
            set
            {
                if (value < 1) value = 1;
                interval = value;
                animationTimer.Interval = value;
            }
        }

        [Category("Behavior")]
        [Description("是否自动播放")]
        public bool AutoPlay { get; set; }

        [Category("Behavior")]
        [Description("是否循环播放")]
        public bool Loop { get; set; } = true;

        [Category("Appearance")]
        [Description("SVG缩放模式")]
        public PictureBoxSizeMode SizeMode { get; set; } = PictureBoxSizeMode.Zoom;

        [Browsable(false)]
        public int CurrentIndex
        {
            get => currentIndex;
            set
            {
                if (value >= 0 && value < svgDocuments.Count)
                {
                    currentIndex = value;
                    UpdateDisplay();
                }
            }
        }

        [Browsable(false)]
        public bool IsPlaying => isPlaying;

        [Browsable(false)]
        public int Count => svgDocuments.Count;

        #endregion

        #region Events  

        public event EventHandler<int> FrameChanged;
        public event EventHandler PlaybackCompleted;

        #endregion

        public SvgViewer()
        {
            SetStyle(ControlStyles.OptimizedDoubleBuffer |
                    ControlStyles.AllPaintingInWmPaint |
                    ControlStyles.UserPaint |
                    ControlStyles.ResizeRedraw, true);

            svgDocuments = new List<SvgDocument>();
            resourceCache = new Dictionary<string, SvgDocument>();

            animationTimer = new Timer
            {
                Interval = Interval,
                Enabled = false
            };
            animationTimer.Tick += AnimationTimer_Tick;
        }

        #region Public Methods  

        /// <summary>  
        /// 添加SVG文件  
        /// </summary>  
        public void AddFile(string filePath)
        {
            try
            {
                if (File.Exists(filePath))
                {
                    var doc = SvgDocument.Open(filePath);
                    svgDocuments.Add(doc);

                    if (svgDocuments.Count == 1)
                    {
                        UpdateDisplay();
                        if (AutoPlay) Play();
                    }
                }
            }
            catch (Exception ex)
            {
                throw new Exception($"Failed to load SVG file: {filePath}", ex);
            }
        }

        /// <summary>  
        /// 添加多个SVG文件  
        /// </summary>  
        public void AddFiles(string[] filePaths)
        {
            foreach (var path in filePaths)
            {
                AddFile(path);
            }
        }

        /// <summary>  
        /// 从目录加载SVG文件  
        /// </summary>  
        public void LoadFromDirectory(string directoryPath, string searchPattern = "*.svg")
        {
            if (!Directory.Exists(directoryPath))
                throw new DirectoryNotFoundException(directoryPath);

            var files = Directory.GetFiles(directoryPath, searchPattern)
                               .OrderBy(x => x)
                               .ToArray();
            AddFiles(files);
        }

        /// <summary>  
        /// 添加嵌入资源SVG  
        /// </summary>  
        public void AddResource(string resourceName, Assembly assembly = null)
        {
            assembly ??= Assembly.GetExecutingAssembly();

            if (resourceCache.ContainsKey(resourceName))
            {
                svgDocuments.Add(resourceCache[resourceName]);
                return;
            }

            try
            {
                using (var stream = assembly.GetManifestResourceStream(resourceName))
                {
                    if (stream == null)
                        throw new Exception($"Resource not found: {resourceName}");

                    var doc = SvgDocument.Open<SvgDocument>(stream);
                    resourceCache[resourceName] = doc;
                    svgDocuments.Add(doc);

                    if (svgDocuments.Count == 1)
                    {
                        UpdateDisplay();
                        if (AutoPlay) Play();
                    }
                }
            }
            catch (Exception ex)
            {
                throw new Exception($"Failed to load SVG resource: {resourceName}", ex);
            }
        }

        /// <summary>  
        /// 清除所有SVG  
        /// </summary>  
        public void Clear()
        {
            Stop();
            currentImage?.Dispose();
            currentImage = null;
            svgDocuments.Clear();
            currentIndex = 0;
            Invalidate();
        }

        /// <summary>  
        /// 开始播放  
        /// </summary>  
        public void Play()
        {
            if (svgDocuments.Count > 1 && !isPlaying)
            {
                isPlaying = true;
                animationTimer.Start();
            }
        }

        /// <summary>  
        /// 暂停播放  
        /// </summary>  
        public void Pause()
        {
            isPlaying = false;
            animationTimer.Stop();
        }

        /// <summary>  
        /// 停止播放  
        /// </summary>  
        public void Stop()
        {
            isPlaying = false;
            animationTimer.Stop();
            currentIndex = 0;
            UpdateDisplay();
        }

        /// <summary>  
        /// 下一个SVG  
        /// </summary>  
        public void Next()
        {
            if (svgDocuments.Count == 0) return;
            currentIndex = (currentIndex + 1) % svgDocuments.Count;
            UpdateDisplay();
        }

        /// <summary>  
        /// 上一个SVG  
        /// </summary>  
        public void Previous()
        {
            if (svgDocuments.Count == 0) return;
            currentIndex = (currentIndex - 1 + svgDocuments.Count) % svgDocuments.Count;
            UpdateDisplay();
        }

        #endregion

        #region Protected Methods  

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

            if (currentImage == null)
                return;

            var rect = GetDisplayRectangle();
            e.Graphics.DrawImage(currentImage, rect);
        }

        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                animationTimer.Dispose();
                currentImage?.Dispose();
                svgDocuments.Clear();
                resourceCache.Clear();
            }
            base.Dispose(disposing);
        }

        #endregion

        #region Private Methods  

        private void AnimationTimer_Tick(object sender, EventArgs e)
        {
            if (!isPlaying || svgDocuments.Count <= 1)
                return;

            currentIndex++;

            if (currentIndex >= svgDocuments.Count)
            {
                if (Loop)
                {
                    currentIndex = 0;
                }
                else
                {
                    Stop();
                    PlaybackCompleted?.Invoke(this, EventArgs.Empty);
                    return;
                }
            }

            UpdateDisplay();
        }

        private void UpdateDisplay()
        {
            if (svgDocuments.Count == 0 || currentIndex >= svgDocuments.Count)
                return;

            var oldImage = currentImage;
            var doc = svgDocuments[currentIndex];

            // 根据控件大小计算图像尺寸  
            var rect = GetDisplayRectangle();
            currentImage = doc.Draw(rect.Width, rect.Height);

            oldImage?.Dispose();
            Invalidate();

            FrameChanged?.Invoke(this, currentIndex);
        }

        private Rectangle GetDisplayRectangle()
        {
            if (currentImage == null || svgDocuments.Count == 0)
                return ClientRectangle;

            var rect = ClientRectangle;
            var doc = svgDocuments[currentIndex];
            var aspectRatio = doc.Width / (float)doc.Height;

            switch (SizeMode)
            {
                case PictureBoxSizeMode.Normal:
                    return new Rectangle(0, 0, (int)doc.Width, (int)doc.Height);

                case PictureBoxSizeMode.StretchImage:
                    return rect;

                case PictureBoxSizeMode.AutoSize:
                    return new Rectangle(0, 0, (int)doc.Width, (int)doc.Height);

                case PictureBoxSizeMode.CenterImage:
                    return new Rectangle(
                        (rect.Width - (int)doc.Width) / 2,
                        (rect.Height - (int)doc.Height) / 2,
                        (int)doc.Width,
                        (int)doc.Height);

                case PictureBoxSizeMode.Zoom:
                    var scale = Math.Min(
                        rect.Width / (float)doc.Width,
                        rect.Height / (float)doc.Height);
                    var width = (int)(doc.Width * scale);
                    var height = (int)(doc.Height * scale);
                    return new Rectangle(
                        (rect.Width - width) / 2,
                        (rect.Height - height) / 2,
                        width,
                        height);

                default:
                    return rect;
            }
        }

        #endregion
    }
}

```


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

## 总结

SvgViewer控件提供了一个完整的SVG文件查看和管理解决方案，具有以下特点：

1. 易于集成到现有项目
2. 功能完善，包含基础和高级特性
3. 性能优化，支持流畅的动画效果
4. 异常处理机制完善
5. 灵活的显示模式

通过这个控件，开发者可以轻松地在WinForms应用程序中实现SVG文件的显示和管理功能。

C# WinForms 自定义SVG 帧播放

在SQL中，聚合函数允许我们对一组值执行计算，并返回单个值。这些函数通常用于统计分析，例如，计算平均值、求和、找到最大值和最小值等。当我们需要对数据进行分组统计时，`GROUP BY`子句就显得非常有用。在本文中，我们将详细介绍聚合函数和`GROUP BY`子句的使用，并通过实例来加深理解。

## 常用的聚合函数

以下是一些常用的SQL聚合函数：

- `COUNT()`: 计算行数。
- `SUM()`: 计算数值列的总和。
- `AVG()`: 计算数值列的平均值。
- `MAX()`: 找到列中的最大值。
- `MIN()`: 找到列中的最小值。



## 实例数据表

假设我们有一个名为`Sales`的数据表，表中记录了不同店铺的销售数据。

|SaleID|Store|Employee|Amount|SaleDate|
|-|-|-|-|-|
|1|A|John|300|2023-01-10|
|2|B|Jane|150|2023-01-11|
|3|A|Mike|450|2023-01-10|
|4|C|Anna|700|2023-01-12|
|5|B|Jane|250|2023-01-13|
|6|A|John|200|2023-01-14|
|7|C|Anna|300|2023-01-15|


创建表脚本

```SQL
CREATE TABLE Sales (
    SaleID INT PRIMARY KEY,
    Store CHAR(1),
    Employee VARCHAR(50),
    Amount DECIMAL(10, 2),
    SaleDate DATE
);
```

插入测试数据

```SQL
INSERT INTO Sales (SaleID, Store, Employee, Amount, SaleDate) VALUES
(1, 'A', 'John', 300, '2023-01-10'),
(2, 'B', 'Jane', 150, '2023-01-11'),
(3, 'A', 'Mike', 450, '2023-01-10'),
(4, 'C', 'Anna', 700, '2023-01-12'),
(5, 'B', 'Jane', 250, '2023-01-13'),
(6, 'A', 'John', 200, '2023-01-14'),
(7, 'C', 'Anna', 300, '2023-01-15');
```

## 使用聚合函数

### COUNT()

要计算`Sales`表中的总销售记录数：

```SQL
SELECT COUNT(*) AS TotalSales
FROM Sales;
```

结果：

|TotalSales|
|-|
|7|



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

### SUM()

要计算所有店铺的总销售额：

```SQL
SELECT SUM(Amount) AS TotalAmount
FROM Sales;
```

结果：

|TotalAmount|
|-|
|2350|



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

### AVG()

要计算所有店铺的平均销售额：

```SQL
SELECT AVG(Amount) AS AverageAmount
FROM Sales;
```

结果：

|AverageAmount|
|-|
|335.714285|



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

### MAX() 和 MIN()

要找出单笔最大和最小的销售额：

```SQL
SELECT MAX(Amount) AS MaxSale, MIN(Amount) AS MinSale
FROM Sales;
```

结果：

|MaxSale|MinSale|
|-|-|
|700|150|



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

## 使用GROUP BY子句

`GROUP BY`子句通常与聚合函数一起使用，用于将行分组为更小的集合，并对每个组应用聚合函数。

### 按店铺分组统计销售额

要计算每个店铺的总销售额：

```SQL
SELECT Store, SUM(Amount) AS TotalAmount
FROM Sales
GROUP BY Store;
```

结果：

|Store|TotalAmount|
|-|-|
|A|950.00|
|B|400.00|
|C|1000.00|


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

### 按店铺和员工分组统计销售额

要计算每个店铺中每位员工的总销售额：

```SQL
SELECT Store, Employee, SUM(Amount) AS TotalAmount
FROM Sales
GROUP BY Store, Employee;
```

结果：

|Store|Employee|TotalAmount|
|-|-|-|
|A|John|500.00|
|A|Mike|450.00|
|B|Jane|400.00|
|C|Anna|1000.00|



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

## 结合HAVING子句

当我们需要对分组后的结果进行过滤时，可以使用`HAVING`子句。`HAVING`子句在功能上类似于`WHERE`子句，但是它是用于聚合后的结果。

### 筛选总销售额超过500的店铺

```SQL
SELECT Store, SUM(Amount) AS TotalAmount
FROM Sales
GROUP BY Store
HAVING SUM(Amount) > 500;
```

结果：

|Store|TotalAmount|
|-|-|
|A|950.00|
|C|1000.00|



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

## 结论

聚合函数和`GROUP BY`子句是SQL中非常强大的工具，它们使得对数据集进行统计分析变得简单高效。通过使用聚合函数，我们可以快速得到数据的统计信息，如总和、平均值、最大值和最小值。而`GROUP BY`子句则允许我们按照一定的维度对数据进行分组，并对每个分组应用聚合函数。结合`HAVING`子句，我们还可以对分组后的结果进行筛选，以满足特定的条件。掌握这些知识点，我们可以更好地从数据中提取有价值的信息。

聚合函数和GROUP BY子句

link

script

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