error CS0103: The name 'xxx' does not exist in the current context
error CS1002: ; expected
error CS1513: } expected
error: File not found
error: Invalid character in source file

# 国外
docker run -d -p 9000:9000 \
  --name portainer \
  --restart=always \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v portainer_data:/data \
  portainer/portainer-ce:alpine-sts
  
# 国内(Arm64)
docker run -d -p 9000:9000 \
  --name portainer \
  --restart=always \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v portainer_data:/data \
  registry.cn-beijing.aliyuncs.com/muta/portainer-ce:alpine-sts-arm64

# 国内(Amd64)
docker run -d -p 9000:9000 \
  --name portainer \
  --restart=always \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v portainer_data:/data \
  registry.cn-beijing.aliyuncs.com/muta/portainer-ce:alpine-sts-amd64

# 国外
docker run -d \
  --name questdb \
  -p 8812:8812 \
  -p 9080:9000 \
  -p 9009:9009 \
  -v questdb_data:/root/.questdb/db \
  questdb/questdb:nightly-rhel
  
# 国内(Arm64)
docker run -d \
  --name questdb \
  -p 8812:8812 \
  -p 9080:9000 \
  -p 9009:9009 \
  -v questdb_data:/root/.questdb/db \
  registry.cn-beijing.aliyuncs.com/muta/questdb:nightly-rhel-arm64

# 国内(Amd64)
docker run -d \
  --name questdb \
  -p 8812:8812 \
  -p 9080:9000 \
  -p 9009:9009 \
  -v questdb_data:/root/.questdb/db \
  registry.cn-beijing.aliyuncs.com/muta/questdb:nightly-rhel-amd64

version: '3.8'

services:
  mq:
    image: registry.cn-beijing.aliyuncs.com/muta/rabbitmq:management-arm64 
    restart: always 
    volumes:
      - rabbitmq_data:/var/lib/rabbitmq    # 持久化RabbitMQ数据
    ports:
      - "5672:5672"                        # AMQP协议端口，应用程序连接用
      - "15672:15672"                      # 管理后台端口，Web管理界面用
      # 以下端口仅在集群或特殊情况下需要，可选
      # - "25672:25672"                    # 节点间通信端口（集群用）
      # - "4369:4369"                      # Erlang节点发现端口（集群用）
    logging:
      driver: "json-file"
      options:
        max-size: "100m"
        max-file: "3" 

volumes:
  rabbitmq_data:                           # 定义持久化数据卷

version: '3.8'

services:
  armcollection2025masablazorapp:
    image: registry.cn-beijing.aliyuncs.com/dfzh/armcollection2025masablazorapp:latest
    ports:
      - "20000:8080"
    user: root
    devices:
      - /dev/ttyS3:/dev/ttyS3
    environment: 
      SqlSugar__1__ConnectionString: "host=host.docker.internal;port=8812;username=admin;password=quest;database=qdb;ServerCompatibilityMode=NoTypeLoading;"
    restart: always
    volumes: 
      - /home/orangepi/DataProtection-Keys/:/app/.aspnet/DataProtection-Keys
    logging:
      driver: "json-file"
      options:
        max-size: "100m"
        max-file: "3"

version: '3.8'

services:
  app:
    image: registry.cn-beijing.aliyuncs.com/dfzh/armcollectblazorapp:latest
    network_mode: "host" 
    environment:  
      Urls: "http://*:20000"
    restart: always 
    logging:
      driver: "json-file"
      options:
        max-size: "100m"
        max-file: "3"
        
  serialport2questdb:
    image: registry.cn-beijing.aliyuncs.com/dfzh/armcollectserialport2questdb:latest
    network_mode: "host" 
    user: root
    devices:
      - /dev/ttyS3:/dev/ttyS3
    environment:  
      ComPortName : "/dev/ttyS3"
      Urls: "http://*:20002" 
    restart: always 
    logging:
      driver: "json-file"
      options:
        max-size: "100m"
        max-file: "3"

version: '3.8'

services:
  app:
    image: registry.cn-beijing.aliyuncs.com/dfzh/staticforcecalibration-blazorserver:arm64
    restart: always 
    volumes:
      - /home/bjgrst/staticforcecalibration_data:/app/App_Data     
      - /home/bjgrst/DefaultSeedsJsonFiles/:/app/DefaultSeedsJsonFiles
      - /dev:/dev
    ports:
      - "8080:8080"      
    user: root
    privileged: true
    logging:
      driver: "json-file"
      options:
        max-size: "100m"
        max-file: "3" 
 

Microsoft.AspNetCore.Authentication.JwtBearer
System.IdentityModel.Tokens.Jwt
Microsoft.EntityFrameworkCore (如果使用数据库)
Microsoft.EntityFrameworkCore.SqlServer (如果使用SQL Server)

{
  "Jwt": {
    "Key": "YourSuperSecretKeyHereAtLeast32CharactersLong",
    "Issuer": "YourAppIssuer",
    "Audience": "YourAppAudience",
    "ExpireMinutes": 60
  },
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*"
}

public class User
{
    public int Id { get; set; }
    public string Username { get; set; }
    public string Password { get; set; } // 实际应用中应该存储哈希值
    public string Role { get; set; } // 例如 "Admin", "User" 等
}

public class TokenResponse
{
    public string Token { get; set; }
    public DateTime Expiration { get; set; }
    public string Username { get; set; }
    public string Role { get; set; }
}

public class LoginRequest
{
    public string Username { get; set; }
    public string Password { get; set; }
}

using System.IdentityModel.Tokens.Jwt;
using System.Security.Claims;
using System.Text;
using Microsoft.IdentityModel.Tokens;

public class JwtService
{
    private readonly IConfiguration _configuration;

    public JwtService(IConfiguration configuration)
    {
        _configuration = configuration;
    }

    public string GenerateToken(User user)
    {
        var securityKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_configuration["Jwt:Key"]));
        var credentials = new SigningCredentials(securityKey, SecurityAlgorithms.HmacSha256);

        var claims = new[]
        {
            new Claim(ClaimTypes.NameIdentifier, user.Username),
            new Claim(ClaimTypes.Role, user.Role)
        };

        var token = new JwtSecurityToken(
            _configuration["Jwt:Issuer"],
            _configuration["Jwt:Audience"],
            claims,
            expires: DateTime.Now.AddMinutes(Convert.ToDouble(_configuration["Jwt:ExpireMinutes"])),
            signingCredentials: credentials);

        return new JwtSecurityTokenHandler().WriteToken(token);
    }
}

public class UserService
{
    // 实际应用中应该从数据库获取用户
    private readonly List<User> _users = new List<User>
    {
        new User { Id = 1, Username = "admin", Password = "admin123", Role = "Admin" },
        new User { Id = 2, Username = "user", Password = "user123", Role = "User" }
    };

    public User Authenticate(string username, string password)
    {
        // 实际应用中应该验证密码哈希
        var user = _users.SingleOrDefault(x => x.Username == username && x.Password == password);

        // 如果用户不存在或密码错误返回null
        if (user == null)
            return null;

        // 认证成功返回用户详情 (不包含密码)
        return user;
    }
}

using Microsoft.AspNetCore.Mvc;

[Route("api/[controller]")]
[ApiController]
public class AuthController : ControllerBase
{
    private readonly UserService _userService;
    private readonly JwtService _jwtService;

    public AuthController(UserService userService, JwtService jwtService)
    {
        _userService = userService;
        _jwtService = jwtService;
    }

    [HttpPost("login")]
    public IActionResult Login([FromBody] LoginRequest request)
    {
        var user = _userService.Authenticate(request.Username, request.Password);

        if (user == null)
            return Unauthorized(new { message = "用户名或密码错误" });

        var token = _jwtService.GenerateToken(user);

        return Ok(new TokenResponse
        {
            Token = token,
            Expiration = DateTime.Now.AddMinutes(Convert.ToDouble(_configuration["Jwt:ExpireMinutes"])),
            Username = user.Username,
            Role = user.Role
        });
    }
}

using Microsoft.AspNetCore.Authorization;

[Authorize]
[Route("api/[controller]")]
[ApiController]
public class ProtectedController : ControllerBase
{
    [HttpGet]
    public IActionResult Get()
    {
        // 可以从HttpContext.User获取用户信息
        var username = User.Identity.Name;
        var role = User.FindFirst(ClaimTypes.Role)?.Value;

        return Ok(new { 
            Message = $"你好 {username}, 你的角色是 {role}",
            Data = "这是受保护的数据" 
        });
    }

    [Authorize(Roles = "Admin")]
    [HttpGet("admin")]
    public IActionResult AdminOnly()
    {
        return Ok(new { Message = "只有管理员能看到这条消息" });
    }
}

using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.IdentityModel.Tokens;
using System.Text;

var builder = WebApplication.CreateBuilder(args);

// 添加服务到容器
builder.Services.AddControllers();

// 配置JWT认证
builder.Services.AddAuthentication(options =>
{
    options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
    options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(options =>
{
    options.TokenValidationParameters = new TokenValidationParameters
    {
        ValidateIssuer = true,
        ValidateAudience = true,
        ValidateLifetime = true,
        ValidateIssuerSigningKey = true,
        ValidIssuer = builder.Configuration["Jwt:Issuer"],
        ValidAudience = builder.Configuration["Jwt:Audience"],
        IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(builder.Configuration["Jwt:Key"]))
    };
});

// 注册自定义服务
builder.Services.AddScoped<UserService>();
builder.Services.AddScoped<JwtService>();

var app = builder.Build();

// 配置HTTP请求管道
if (app.Environment.IsDevelopment())
{
    app.UseDeveloperExceptionPage();
}

app.UseHttpsRedirection();

// 添加认证和授权中间件
app.UseAuthentication();
app.UseAuthorization();

app.MapControllers();

app.Run();

{
    "username": "admin",
    "password": "admin123"
}

{
    "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
    "expiration": "2023-05-01T12:00:00",
    "username": "admin",
    "role": "Admin"
}

Authorization: Bearer <your_token>

Authorization: Bearer <your_token>

   public class MyComponent : ComponentBase
   {
       [Parameter]
       public string Title { get; set; }
   }

   <MyComponent Title="Hello, World!" />

   <input @bind-Value="name" />

   @code {
       private string name;
   }

   <input @bind-Value="name" />
   <p>You entered: @name</p>

  return Ok();

  return Ok(object);

  return Created(uri, object);

  return CreatedAtRoute("RouteName", routeValues, object);

  return NoContent();

  return Redirect("https://example.com");

  return RedirectToAction("ActionName", "ControllerName");

  return RedirectToRoute("RouteName");

  return BadRequest();

  return BadRequest(errorObject);

  return Unauthorized();

  return Forbid();

  return NotFound();

  return NotFound(errorObject);

  return StatusCode(500);

  return StatusCode(500, object);

Quartz.NET
├── Scheduler
│   ├── Job
│   │   ├── JobDetail
│   │   │   ├── JobKey (JobName, JobGroup)
│   │   │   └── JobDataMap
│   │   └── IJob (Job Interface)
│   ├── Trigger
│   │   ├── TriggerDetail
│   │   │   ├── TriggerKey (TriggerName, TriggerGroup)
│   │   │   ├── TriggerDataMap
│   │   │   └── Schedule (Cron, Simple, etc.)
│   └── Listener
│       ├── JobListener
│       └── TriggerListener

// 触发器1
var trigger1 = TriggerBuilder.Create()
    .WithIdentity("trigger1", "group1")
    .ForJob(jobKey)
    .UsingJobData("ExampleKey", "ValueFromTrigger1")
    .Build();

// 触发器2
var trigger2 = TriggerBuilder.Create()
    .WithIdentity("trigger2", "group1")
    .ForJob(jobKey)
    .UsingJobData("ExampleKey", "ValueFromTrigger2")
    .Build();

public class MyJob : IJob
{
    public Task Execute(IJobExecutionContext context)
    {
        // 获取触发器数据
        var exampleValueFromTrigger = context.Trigger.JobDataMap.GetString("ExampleKey");

        // 获取合并后的数据（触发器数据优先）
        var exampleValueMerged = context.MergedJobDataMap.GetString("ExampleKey");

        Console.WriteLine($"Trigger Data: {exampleValueFromTrigger}");
        Console.WriteLine($"Merged Data: {exampleValueMerged}");

        return Task.CompletedTask;
    }
}

private readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim();

private async Task<SensorHisEntity?> ProcessPerDataAsync(SensorParamData sensorParamData)
{
    SensorHisEntity? result = null;
    _lock.EnterWriteLock();
    try
    {
        if (!_sensorParamConfigDic.TryGetValue(sensorParamData.Id, out SensorParamConfig config))
        {
            return default;
        }

        // 处理逻辑
        result = ProcessConfig(sensorParamData, config);
    }
    finally
    {
        _lock.ExitWriteLock();
    }
    return result;
}

@page "/example"
@inject SensorParamService sensorParamService

<TimerComponent Interval="2000" OnElapsed="TimerOnElapsed" />

<MECharts Option="_option" Height="400" IncludeFunctionsInOption></MECharts>

@code {
    private object _option = GenOption(0);

    private void TimerOnElapsed(ElapsedEventArgs e)
    {
        InvokeAsync(() =>
        {
            var res = sensorParamService.SensorParamDic.FirstOrDefault(it => it.Value.Name == "电器房_风向");
            _option = GenOption(res.Value.DiffValue);
            StateHasChanged();
        });
    }

    private static object GenOption(double value)
    {
        return new
        {
            Tooltip = new
            {
                Formatter = "{a} <br/>{b}: {c}°"
            },
            Series = new[]
            {
                new
                {
                    Name = "风向",
                    Type = "gauge",
                    StartAngle = 90,
                    EndAngle = -269.9999,
                    AxisLine = new
                    {
                        LineStyle = new
                        {
                            Width = 10
                        }
                    },
                    Pointer = new
                    {
                        Length = "70%",
                        Width = 6
                    },
                    SplitLine = new
                    {
                        Length = 15,
                        LineStyle = new
                        {
                            Width = 2
                        }
                    },
                    AxisLabel = new
                    {
                        Distance = 20,
                        Formatter = "(value) => { const directions = ['北', '东北', '东', '东南', '南', '西南', '西', '西北']; return directions[Math.floor(value / 45) % 8]; }"
                    },
                    AxisTick = new
                    {
                        SplitNumber = 4
                    },
                    Detail = new
                    {
                        Formatter = "{value}°"
                    },
                    Data = new[]
                    {
                        new { Value = value, Name = "风向" }
                    }
                }
            }
        };
    }
}

@inject SensorParamService SensorParamService
@implements IDisposable
@using System.Timers

@code {
    private Timer? _timer;
    [Parameter] public double Interval { get; set; } = 2000;
    [Parameter] public Func<IDictionary<string, SensorParam>, IEnumerable<SensorParam>> QueryExpression { get; set; }
    [Parameter] public EventCallback<IEnumerable<SensorParam>> OnDataFetched { get; set; }

    protected override void OnInitialized()
    {
        base.OnInitialized();

        if (_timer == null)
        {
            _timer = new Timer
            {
                Interval = Interval
            };

            _timer.Elapsed += async (sender, args) => await FetchData();

            _timer.Start();
        }
    }

    private async Task FetchData()
    {
        var results = QueryExpression(SensorParamService.SensorParamDic);
        await InvokeAsync(() => OnDataFetched.InvokeAsync(results));
    }

    public void Dispose()
    {
        _timer?.Dispose();
    }
}

@page "/example"

<TimerComponent Interval="2000" 
                QueryExpression="GetSensorParams" 
                OnDataFetched="HandleDataFetched" />

<MECharts Option="_option" Height="400" IncludeFunctionsInOption></MECharts>

@code {
    private object _option = GenOption(0);

    private IEnumerable<SensorParam> GetSensorParams(IDictionary<string, SensorParam> sensorParamDic)
    {
        // 完整的 LINQ 查询逻辑在这里定义
        return sensorParamDic.Values.Where(it => it.Name.Contains("风向"));
    }

    private void HandleDataFetched(IEnumerable<SensorParam> sensorParams)
    {
        InvokeAsync(() =>
        {
            // 处理多个传感器参数，例如更新图表数据
            var firstParam = sensorParams.FirstOrDefault();
            if (firstParam != null)
            {
                _option = GenOption(firstParam.DiffValue);
            }
            else
            {
                // 处理结果为空的情况
                Console.WriteLine("未找到匹配的传感器参数。");
            }
            StateHasChanged();
        });
    }

    private static object GenOption(double value)
    {
        return new
        {
            Tooltip = new
            {
                Formatter = "{a} <br/>{b}: {c}°"
            },
            Series = new[]
            {
                new
                {
                    Name = "风向",
                    Type = "gauge",
                    StartAngle = 90,
                    EndAngle = -269.9999,
                    AxisLine = new
                    {
                        LineStyle = new
                        {
                            Width = 10
                        }
                    },
                    Pointer = new
                    {
                        Length = "70%",
                        Width = 6
                    },
                    SplitLine = new
                    {
                        Length = 15,
                        LineStyle = new
                        {
                            Width = 2
                        }
                    },
                    AxisLabel = new
                    {
                        Distance = 20,
                        Formatter = "(value) => { const directions = ['北', '东北', '东', '东南', '南', '西南', '西', '西北']; return directions[Math.floor(value / 45) % 8]; }"
                    },
                    AxisTick = new
                    {
                        SplitNumber = 4
                    },
                    Detail = new
                    {
                        Formatter = "{value}°"
                    },
                    Data = new[]
                    {
                        new { Value = value, Name = "风向" }
                    }
                }
            }
        };
    }
}