# 前置准备：Docker 部署lucky

确保 Lucky 容器已挂载验证文件目录（绿联 NAS 端操作）：


```yaml
services:
  lucky:
    image: gdy666/lucky
    container_name: lucky
    volumes:
      - /volume1/Docker/goodlucky:/goodluck
      - /volume1/Docker/wechat_verify:/wechat_verify  # 微信验证文件目录
    restart: always
    network_mode: host
```

将微信验证文件（如ee9114d394500f07ef00ac39d35c106a.txt）放入 NAS 的 /volume1/Docker/wechat_verify 目录。

# 二、Lucky 端文件服务配置

- 进入 Lucky 后台 → 「Web 服务」→ 点击「添加 Web 服务规则」
- 新建子规则，配置如下：
- 子规则开关：启用
- 操作模式：简易模式
- 前端地址：www.294713.xyz/wechat_verify
- 服务类型：文件服务
- 文件服务挂载路径：
- 挂载类型：本地
- 本地路径：/wechat_verify（容器内挂载路径）
- 显示名称：wechat_verify
- 文件服务设置：显示目录 → 关闭

# 三、阿里云 ESA 端配置

路径重写规则（核心）

![image.png](https://blog.294713.xyz/static/img/30f791b035ef352ed76b46dabac9e6f8.image.webp)
```js
regex_replace(http.request.uri.path, "^/(.*\\.txt)$", "/wechat_verify/$1")
```
回源规则设置参考链接
[https://zhuanlan.zhihu.com/p/1989011620328924699](url)

# 四、验证步骤
访问 https://www.294713.xyz/aaa.txt
若页面直接显示验证文件内容（如54d113ad7da27），则配置成功。

个人网站微信验证绿联 NAS+Lucky + 阿里云 ESA

# 源生成器实现属性通知


```C#
public partial class ViewModel : ObservableObject
{
    [ObservableProperty]
    private string name;

    private bool CanSubmit() => !string.IsNullOrEmpty(name);

    [RelayCommand(CanExecute = nameof(CanSubmit))]
    private void Submit()
    {
        Debug.WriteLine($"Name: {name}");
    }
}
```

# AsyncRelayCommand


```C#
partial class MainViewModel : ObservableValidator
{
    [ObservableProperty]
    private string name = "";

    private bool CanSubmit() => !string.IsNullOrEmpty(Name);

    [RelayCommand(CanExecute = nameof(CanSubmit))]
    private async Task SubmitAsync()
    {
        await Task.Delay(1000);
    }
}
```


# 取消任务


```C#
[RelayCommand(CanExecute = nameof(CanSubmit), IncludeCancelCommand = true)]
private async Task SubmitAsync(CancellationToken token)
{
    try
    {
        await Task.Delay(2000, token);
    }
    catch (OperationCanceledException)
    {

    }
}
```


# 希望通知另一个属性


```C#
public partial class MainViewModel : ObservableObject
{
    [ObservableProperty]
    [NotifyPropertyChangedFor(nameof(FullName))] //支持传入多个属性的名称
    private string firstName = ""; //setter 中会生成形如 OnPropertyChanged("FullName") 的代码

    public string FullName => firstName + " " + lastName;
}
```


# 通知中继指令更新其可用状态


```C#
public partial class MainViewModel : ObservableObject
{
    [ObservableProperty]
    [NotifyCanExecuteChangedFor(nameof(FooCommand))] //支持传入多个中继指令的名称
    private bool isFooEnabled; //会在 setter 中添加 FooCommand.NotifyCanExecuteChanged();

    public IRelayCommand FooCommand { get; }
}
```

# 验证属性的值是否有效

如果希望在一个 ObservableValidator 对象中验证属性的值是否有效，可以为字段添加 NotifyDataErrorInfo 特性：
```C#
public partial class SignUpViewModel : ObservableValidator
{
    [Required]
    [EmailAddress]
    [ObservableProperty]
    [NotifyDataErrorInfo]
    private string email = ""; //会在 setter 中添加 ValidateProperty(value, "Email") 的代码
```

# 为生成的属性添加特性

如果希望为生成的属性添加额外的特性，尤其比如 *JsonIgnore* 等，从而在序列化时忽略这个属性，可以使用下面这个特殊语法：


```C#
public partial class MainViewModel : ObservableObject
{
    [ObservableProperty]
    [property: JsonIgnore]
    private string name = "";
}
```

# 希望在属性值发生变化后执行额外的逻辑
如果希望在属性值发生变化后执行额外的逻辑，还可以借助分部方法来实现。从 基本用法 的中给出的后台生成的完整代码中可以发现，setter 中存在一些分部方法，名称为 `OnChanged。借助这些分部方法，我们就可以实现这个需求。形如：

```C#
public partial class MainViewModel : ObservableObject
{
    [ObservableProperty]
    private string name = "";

    partial void OnNameChanged(string value)
    {
        // Do something
    }

    partial void OnNameChanged(string oldValue, string newValue)
    {
        // Do something
    }
}
```

# 消息中继/事件总线/发布-订阅

Messenger 是一个消息传递机制，它可以让对象之间进行通信，而不需要它们之间有直接的引用关系。从设计模式的角度来说，Messenger 其实是中介者模式的一种实现。


![image.png](https://blog.294713.xyz/static/img/089196083c646ca9c2da6cb747dc2f87.image.webp)

 可以看出，在使用中介者模式之后，个模块之间不再呈现出网状结构，而是变成了星状结构。这样一来，模块之间的耦合就会大大降低，代码也会变得更加简洁。

Messenger 在很多 MVVM 框架中均能找到它的身影。虽然叫法不同，但是背后的原理及逻辑都是相通的。


![image.png](https://blog.294713.xyz/static/img/fa7d13741d8f292e74cceae2055ebee9.image.webp)

CommunityToolkit.Mvvm使用教程

# 地址
https://mate.tools/zh

![image.png](/static/img/05444ff7cc9e140b4488f599aa9ebab7.image.webp)

在线文件转换工具

# VS插件安装

![image.png](https://blog.294713.xyz/static/img/8c1b37a0488cdd043c1e657938946731.image.webp)

# 无法通过扩展安装，使用网页打开下面的链接

https://marketplace.visualstudio.com/search?term=avalonia&target=VS&category=Tools&vsVersion=&subCategory=All&sortBy=Relevance

# 搜索后安装，不能安装按如下方法处理


![image.png](https://blog.294713.xyz/static/img/d14f5274f54bada2c73c3a14a0e2c076.image.webp)

avalonia学习笔记

# efcore公共基础类Services
## 支持efcore，同时可以使用sql语句，实现精细化控制
```C#
using Cowain.Base.DBContext;
using Cowain.Base.IServices;
using Microsoft.EntityFrameworkCore;
using MySqlConnector;
using System.Data;
using System.Linq.Expressions;
using Dapper;

namespace Cowain.Base.Services;

public class BaseService : IBaseService
{
    protected readonly SqlDbContext _dBContext;
    public BaseService(SqlDbContext dbContext)
    {
        _dBContext = dbContext;

    }

    public int Delete<T>(int Id) where T : class
    {
        T? t = _dBContext.Set<T>().Find(Id);
        if (t == null) throw new KeyNotFoundException($"未找到类型 {typeof(T).Name}，Id={Id}");
        _dBContext.Set<T>().Remove(t);
        return _dBContext.SaveChanges();
    }

    public async Task<int> DeleteAsync<T>(int Id, CancellationToken cancellationToken = default) where T : class
    {
        var t = await _dBContext.Set<T>().FindAsync(Id);
        if (t == null) throw new KeyNotFoundException($"未找到类型 {typeof(T).Name}，Id={Id}");
        _dBContext.Set<T>().Remove(t);
        return await _dBContext.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
    }


    public int Delete<T>(T t) where T : class
    {
        // 参数校验，抛出更明确的异常类型
        ArgumentNullException.ThrowIfNull(t);
        // 获取实体跟踪状态，避免重复 Attach 导致不必要的状态变更
        var entry = _dBContext.Entry(t);
        if (entry.State == EntityState.Detached)
        {
            _dBContext.Set<T>().Attach(t);
        }
        // 标记删除并保存
        _dBContext.Set<T>().Remove(t);
        return _dBContext.SaveChanges();
    }

    public async Task<int> DeleteAsync<T>(T t, CancellationToken cancellationToken = default) where T : class
    {
        ArgumentNullException.ThrowIfNull(t);
        var entry = _dBContext.Entry(t);
        if (entry.State == EntityState.Detached)
        {
            _dBContext.Set<T>().Attach(t);
        }
        _dBContext.Set<T>().Remove(t);
        return await _dBContext.SaveChangesAsync().ConfigureAwait(false);
    }

    public List<T> Find<T>() where T : class
    {
        return _dBContext.Set<T>().ToList();

    }

    // 异步、安全的批量读取（支持取消）
    public async Task<List<T>> FindAsync<T>(CancellationToken cancellationToken = default) where T : class
    {
        return await _dBContext.Set<T>().ToListAsync(cancellationToken).ConfigureAwait(false);
    }

    public T? Find<T>(int id) where T : class
    {
        return _dBContext.Set<T>().Find(id);

    }
    public async Task<T?> FindAsync<T>(int id, CancellationToken cancellationToken = default) where T : class
    {
        return await _dBContext.Set<T>().FindAsync(new object[] { id }, cancellationToken).ConfigureAwait(false);
    }

    public int Insert<T>(T t) where T : class
    {
        ArgumentNullException.ThrowIfNull(t);
        _dBContext.Set<T>().Add(t);
        return _dBContext.SaveChanges();
    }

    public async Task<int> InsertAsync<T>(T t, CancellationToken cancellationToken = default) where T : class
    {
        ArgumentNullException.ThrowIfNull(t);
        _dBContext.Set<T>().Add(t);
        return await _dBContext.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
    }

    public int Insert<T>(IEnumerable<T> tList) where T : class
    {
        _dBContext.Set<T>().AddRange(tList);
        return _dBContext.SaveChanges();
    }

    public async Task<int> InsertAsync<T>(IEnumerable<T> tList, CancellationToken cancellationToken = default) where T : class
    {
        _dBContext.Set<T>().AddRange(tList);
        return await _dBContext.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
    }
    public IQueryable<T> Query<T>(Expression<Func<T, bool>> funcWhere) where T : class
    {
        return _dBContext.Set<T>().Where<T>(funcWhere);
    }

    public int Update<T>(T t) where T : class
    {
        ArgumentNullException.ThrowIfNull(t);
        var entry = _dBContext.Entry(t);
        if (entry.State == EntityState.Detached)
        {
            _dBContext.Set<T>().Attach(t);
        }
        _dBContext.Entry<T>(t).State = EntityState.Modified;
        return _dBContext.SaveChanges();
    }

    public async Task<int> UpdateAsync<T>(T t, CancellationToken cancellationToken = default) where T : class
    {
        ArgumentNullException.ThrowIfNull(t);
        var entry = _dBContext.Entry(t);
        if (entry.State == EntityState.Detached)
        {
            _dBContext.Set<T>().Attach(t);
        }
        _dBContext.Entry<T>(t).State = EntityState.Modified;
        return await _dBContext.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
    }


    public int Update<T>(IEnumerable<T> tList) where T : class
    {
        ArgumentNullException.ThrowIfNull(tList);
        var list = tList as IList<T> ?? tList.ToList();
        if (list.Count == 0) return 0;
        // 更简洁且更高效：让 EF Core 处理 Attach/状态设置
        _dBContext.Set<T>().UpdateRange(list);
        return _dBContext.SaveChanges();
    }

    public async Task<int> UpdateAsync<T>(IEnumerable<T> tList, CancellationToken cancellationToken = default) where T : class
    {
        ArgumentNullException.ThrowIfNull(tList);
        var list = tList as IList<T> ?? tList.ToList();
        if (list.Count == 0) return 0;
        _dBContext.Set<T>().UpdateRange(list);
        return await _dBContext.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
    }

    public DataTable GetDataTable(string sql, IEnumerable<MySqlParameter>? parameters = null)
    {
        if (string.IsNullOrWhiteSpace(sql)) throw new ArgumentException("sql 不能为空", nameof(sql));
        using var conn = new MySqlConnection(_dBContext.Database.GetConnectionString());
        using var cmd = new MySqlCommand(sql, conn)
        {
            CommandType = CommandType.Text,
            // CommandTimeout = 30 // 根据需求设置超时（秒）
        };

        if (parameters != null)
        {
            foreach (var p in parameters) cmd.Parameters.Add(p);
        }
        using var adapter = new MySqlDataAdapter(cmd);
        var table = new DataTable();
        adapter.Fill(table);
        return table;
    }

    public async Task<DataTable> GetDataTableAsync(string sql, IEnumerable<MySqlParameter>? parameters = null, CancellationToken cancellationToken = default)
    {
        if (string.IsNullOrWhiteSpace(sql)) throw new ArgumentException("sql 不能为空", nameof(sql));

        await using var conn = new MySqlConnection(_dBContext.Database.GetConnectionString());
        await conn.OpenAsync(cancellationToken).ConfigureAwait(false);

        using var cmd = new MySqlCommand(sql, conn) { CommandType = CommandType.Text };
        if (parameters != null) cmd.Parameters.AddRange(parameters.ToArray());

        using var reader = await cmd.ExecuteReaderAsync(cancellationToken).ConfigureAwait(false);
        var table = new DataTable();
        table.Load(reader); // 从 reader 同步加载数据
        return table;
    }

    // ================= Dapper 辅助方法 =================

    /// <summary>
    /// 使用 Dapper 查询并映射到 POCO（同步）
    /// </summary>
    public IEnumerable<T> QueryByDapper<T>(string sql, object? param = null)
    {
        if (string.IsNullOrWhiteSpace(sql)) throw new ArgumentException("sql 不能为空", nameof(sql));
        using var conn = new MySqlConnection(_dBContext.Database.GetConnectionString());
        conn.Open();
        return conn.Query<T>(sql, param);
    }

    /// <summary>
    /// 使用 Dapper 查询并映射到 POCO（异步，支持 CancellationToken）
    /// </summary>
    public async Task<IEnumerable<T>> QueryByDapperAsync<T>(string sql, object? param = null, CancellationToken cancellationToken = default)
    {
        if (string.IsNullOrWhiteSpace(sql)) throw new ArgumentException("sql 不能为空", nameof(sql));
        await using var conn = new MySqlConnection(_dBContext.Database.GetConnectionString());
        await conn.OpenAsync(cancellationToken).ConfigureAwait(false);
        var command = new CommandDefinition(sql, param, cancellationToken: cancellationToken);
        var result = await conn.QueryAsync<T>(command).ConfigureAwait(false);
        return result;
    }

    /// <summary>
    /// 使用 Dapper 查询单条记录（同步）
    /// </summary>
    public T? QueryFirstOrDefaultByDapper<T>(string sql, object? param = null)
    {
        if (string.IsNullOrWhiteSpace(sql)) throw new ArgumentException("sql 不能为空", nameof(sql));
        using var conn = new MySqlConnection(_dBContext.Database.GetConnectionString());
        conn.Open();
        return conn.QueryFirstOrDefault<T>(sql, param);
    }

    /// <summary>
    /// 使用 Dapper 查询单条记录（异步）
    /// </summary>
    public async Task<T?> QueryFirstOrDefaultByDapperAsync<T>(string sql, object? param = null, CancellationToken cancellationToken = default)
    {
        if (string.IsNullOrWhiteSpace(sql)) throw new ArgumentException("sql 不能为空", nameof(sql));
        await using var conn = new MySqlConnection(_dBContext.Database.GetConnectionString());
        await conn.OpenAsync(cancellationToken).ConfigureAwait(false);
        var command = new CommandDefinition(sql, param, cancellationToken: cancellationToken);
        return await conn.QueryFirstOrDefaultAsync<T>(command).ConfigureAwait(false);
    }

    /// <summary>
    /// 使用 Dapper 执行非查询 SQL（同步），返回受影响行数
    /// </summary>
    public int ExecuteByDapper(string sql, object? param = null)
    {
        if (string.IsNullOrWhiteSpace(sql)) throw new ArgumentException("sql 不能为空", nameof(sql));
        using var conn = new MySqlConnection(_dBContext.Database.GetConnectionString());
        conn.Open();
        return conn.Execute(sql, param);
    }

    /// <summary>
    /// 使用 Dapper 执行非查询 SQL（异步），返回受影响行数
    /// </summary>
    public async Task<int> ExecuteByDapperAsync(string sql, object? param = null, CancellationToken cancellationToken = default)
    {
        if (string.IsNullOrWhiteSpace(sql)) throw new ArgumentException("sql 不能为空", nameof(sql));
        await using var conn = new MySqlConnection(_dBContext.Database.GetConnectionString());
        await conn.OpenAsync(cancellationToken).ConfigureAwait(false);
        var command = new CommandDefinition(sql, param, cancellationToken: cancellationToken);
        return await conn.ExecuteAsync(command).ConfigureAwait(false);
    }

    /// <summary>
    /// 使用 Dapper 执行 SQL 并返回 DataTable（异步，支持 CancellationToken）
    /// </summary>
    public async Task<DataTable> QueryToDataTableByDapperAsync(string sql, object? param = null, CancellationToken cancellationToken = default)
    {
        if (string.IsNullOrWhiteSpace(sql)) throw new ArgumentException("sql 不能为空", nameof(sql));
        await using var conn = new MySqlConnection(_dBContext.Database.GetConnectionString());
        await conn.OpenAsync(cancellationToken).ConfigureAwait(false);
        var command = new CommandDefinition(sql, param, cancellationToken: cancellationToken, flags: CommandFlags.Buffered);
        await using var reader = await conn.ExecuteReaderAsync(command).ConfigureAwait(false);
        var table = new DataTable();
        table.Load(reader);
        return table;
    }

    /// <summary>
    /// 使用 Dapper 执行 SQL 并返回 DataTable（同步）
    /// </summary>
    public DataTable QueryToDataTableByDapper(string sql, object? param = null)
    {
        if (string.IsNullOrWhiteSpace(sql)) throw new ArgumentException("sql 不能为空", nameof(sql));
        using var conn = new MySqlConnection(_dBContext.Database.GetConnectionString());
        conn.Open();
        using var reader = conn.ExecuteReader(sql, param);
        var table = new DataTable();
        table.Load(reader);
        return table;
    }


}

```