# 源生成器实现属性通知


```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;
    }


}

```

efcore基础类

咱们玩NAS的，几个主要娱乐向需求应该就是音乐、影视和相册了。本期来介绍一款基于免费API的音乐播放器：Solara（光域）。本文所用的项目是基于原Solara（GIF取自原项目）进行修改，可Docker一键部署，支持 X86 和 ARM 架构设备。项目仅供学习交流使用，请支持正版！！！


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


# docker compose

```js
version: '3.8'  # 明确指定版本，提高兼容性
services:
  solara:
    image: 1555904/solara-music:latest  # 镜像地址（保持原样，语法正确）
    container_name: solara  # 容器名称（语法正确）
    ports:
      - "14001:3001"  # 端口映射：主机14001端口 -> 容器3001端口（添加引号更规范）
    restart: always  # 重启策略（语法正确）
```


# 项目介绍

原项目：akudamatata/Solara，GHUB搜索即可。文章所用镜像：1555904/solara-music。⚠️原项目作者声明了禁止任何商业化行为，任何衍生项目必须保留本项目地址并以相同协议开源，所以大家放心用就好了～

# 使用简介

部署完毕后，浏览器输入NAS_IP:14001即可访问服务。

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