上位机开发需要的 C#/.NET 核心基础

C# 源码
-> 编译成 dll/exe
-> .NET 运行时加载程序集
-> 操作系统启动进程
-> 进程里有线程
-> 线程执行代码
-> Task 管理异步或并发工作
-> async/await 把等待拆成可恢复的状态机
-> Attribute 写入元数据
-> Reflection 在运行时读取类型、方法、属性和特性
-> 框架根据这些信息自动绑定、路由、序列化、测试或创建对象

控制台商品计算器
-> 控制台商品列表
-> CSV 清洗器
-> 订单域模型
-> 异步文件批处理器
-> 工程化商品服务
-> Avalonia 商品表单
-> MVVM 商品管理页面
-> JSON 持久化商品管理
-> 商品管理 MVP
-> 商品管理增强版
-> 最终交付包
-> 串口与网络调试助手
-> Modbus / OPC UA 设备监控器
-> 多设备采集引擎
-> SQLite 历史数据库
-> 实时趋势与报警中心
-> Avalonia 工业操作台
-> 测试、诊断与现场交付

string raw = "  Keyboard Pro  ";
string clean = raw.Trim();
 
Console.WriteLine(clean.ToUpper());
Console.WriteLine(clean.ToLower().Contains("key"));
Console.WriteLine(clean.Replace(" ", "-"));
Console.WriteLine(clean.Length);

decimal price = 199.9m;
int count = 2;
decimal total = price * count;
 
Console.WriteLine(total.ToString("F2"));
Console.WriteLine(Math.Round(total * 0.8m, 2));
Console.WriteLine(Math.Max(count, 1));

bool nameOk = true;
bool priceOk = true;
bool isSaving = false;
 
bool canSave = nameOk && priceOk && !isSaving;
 
Console.WriteLine(canSave);

IsBusy：是否正在忙
CanSave：能不能保存
IsEmpty：列表是否为空
IsSelected：是否选中了数据

IsActive：账号是否启用
IsAdmin：是否管理员
HasPermission：是否有权限

DateTime createdAt = DateTime.Now;
DateTime expiredAt = createdAt.AddDays(7);
 
Console.WriteLine(createdAt.ToString("yyyy-MM-dd HH:mm"));
Console.WriteLine(expiredAt.ToString("yyyy-MM-dd"));

var products = new List<Product>
{
    new Product(1, "Keyboard", 199m),
    new Product(2, "Mouse", 99m),
    new Product(3, "Monitor", 899m)
};
 
List<Product> expensiveProducts = products
    .Where(product => product.Price >= 100)
    .OrderBy(product => product.Price)
    .ToList();
 
Product? keyboard = products.FirstOrDefault(product => product.Name == "Keyboard");
 
Console.WriteLine(expensiveProducts.Count);
Console.WriteLine(keyboard?.Name);
 
public sealed record Product(int Id, string Name, decimal Price);

string folder = Path.Combine(Environment.CurrentDirectory, "data");
Directory.CreateDirectory(folder);
 
string path = Path.Combine(folder, "products.txt");
File.WriteAllText(path, "Keyboard");
 
string text = File.ReadAllText(path);
Console.WriteLine(text);

using System.Text.Json;
 
var product = new Product("Keyboard", 199m);
 
string json = JsonSerializer.Serialize(product, new JsonSerializerOptions
{
    WriteIndented = true
});
 
Product? loaded = JsonSerializer.Deserialize<Product>(json);
 
Console.WriteLine(json);
Console.WriteLine(loaded?.Name);
 
public sealed record Product(string Name, decimal Price);

Console.WriteLine("开始保存");
await SaveAsync();
Console.WriteLine("保存结束");
 
static async Task SaveAsync()
{
    await Task.Delay(500);
    Console.WriteLine("保存完成");
}

using System.Net.Http;
 
using var client = new HttpClient();
string json = await client.GetStringAsync("https://example.com/api/products");
 
Console.WriteLine(json);

int count = "3";

string text = "3";
 
if (int.TryParse(text, out int count))
{
    Console.WriteLine(count);
}

List<string> names = new();
Console.WriteLine(names[0]);

List<string> names = new();
 
if (names.Count > 0)
{
    Console.WriteLine(names[0]);
}
else
{
    Console.WriteLine("列表没有数据。");
}

pwd
ls
dotnet --version
dotnet build

XAML 里绑定的名字
-> ViewModel 里是否真的有这个属性或命令
-> View 是否拿到了正确 DataContext
-> 属性变化后是否通知界面

Console.Write("价格: ");
string? priceText = Console.ReadLine();
decimal price = decimal.Parse(priceText);
Console.WriteLine(price);

Console.Write("价格: ");
string? priceText = Console.ReadLine();
 
if (!decimal.TryParse(priceText, out decimal price))
{
    Console.WriteLine("价格必须是数字。");
    return;
}
 
Console.WriteLine(price);

if (name == "")
{
    Console.WriteLine("名称不能为空。");
}

if (string.IsNullOrWhiteSpace(name))
{
    Console.WriteLine("名称不能为空。");
    return;
}
 
string cleanName = name.Trim();

Console.WriteLine(products[0].Name);

if (products.Count == 0)
{
    Console.WriteLine("没有商品。");
    return;
}
 
Console.WriteLine(products[0].Name);

Product product = products.First(p => p.Id == id);

Product? product = products.FirstOrDefault(p => p.Id == id);
 
if (product is null)
{
    Console.WriteLine("商品不存在。");
    return;
}

Task<string> task = File.ReadAllTextAsync("data.json");
Console.WriteLine(task);

string text = await File.ReadAllTextAsync("data.json");
Console.WriteLine(text);

await semaphore.WaitAsync();
await ProcessAsync();
semaphore.Release();

await semaphore.WaitAsync();
 
try
{
    await ProcessAsync();
}
finally
{
    semaphore.Release();
}

<Button Content="保存" Click="OnSaveClick" />

<Button Content="保存"
        Command="{Binding SaveCommand}" />

[RelayCommand]
private void Save()
{
    Message = "保存成功。";
}

await File.WriteAllTextAsync("products.json", json);

string folder = Path.Combine(
    Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
    "ProductApp");
 
Directory.CreateDirectory(folder);
 
string path = Path.Combine(folder, "products.json");
await File.WriteAllTextAsync(path, json);

我输入了什么？
我点击了什么？
我期望看到什么？
实际看到了什么？
错误出现在第几步？

Console.WriteLine($"name = {name}");
Console.WriteLine($"priceText = {priceText}");
Console.WriteLine($"products.Count = {products.Count}");

读取输入后
转换类型后
进入 Service 前
Repository 保存前
catch 里面

整个项目
-> 某个页面
-> 某个 ViewModel
-> 某个方法
-> 某个 if 条件
-> 某一行变量值

Console.WriteLine(filePath);

dotnet build
dotnet test
dotnet run

npm run build

C# 源码
-> dotnet build
-> dll/exe
-> .NET Runtime 加载
-> CLR 执行代码

SDK：开发用，包含编译器、模板、命令行工具
Runtime：运行用，只负责运行已经编译好的程序

MyApp.csproj
-> dotnet build
-> MyApp.dll

dotnet add package Newtonsoft.Json

namespace MyApp.Services;
 
public class ProductService
{
}

MyApp.Models
MyApp.Services
MyApp.Repositories
MyApp.ViewModels
MyApp.Views

public class ProductService
{
    private readonly List<string> _logs = new();
 
    public void Add(string name)
    {
        _logs.Add(name);
    }
}

值类型：int、double、decimal、bool、DateTime、struct
引用类型：string、class、object、List<T>、数组

int a = 10;
int b = a;
b = 20;
 
Console.WriteLine(a); // 10

var p1 = new Product { Name = "A" };
var p2 = p1;
p2.Name = "B";
 
Console.WriteLine(p1.Name); // B

栈：方法调用、局部变量、执行路径相关的数据
堆：new 出来的对象主要放这里

void Create()
{
    var product = new Product();
}

using var file = File.OpenRead("data.txt");

string name = "Tom";
string? nickname = null;

string：按设计不应该为空。
string?：这个变量允许没有值。

Product? product = repository.FindById(id);
 
Console.WriteLine(product.Name);

Product? product = repository.FindById(id);
 
if (product == null)
{
    throw new InvalidOperationException("Product not found.");
}
 
Console.WriteLine(product.Name);

public void Rename(string? name)
{
    if (string.IsNullOrWhiteSpace(name))
    {
        throw new ArgumentException("Name is required.");
    }
 
    Console.WriteLine(name.Trim());
}

Console.WriteLine(product!.Name);

这个值从哪里来？
来源是否可信？
有没有可能为空？
为空时应该返回错误、给默认值，还是停止流程？
后面的代码是否已经拿到了非空结果？

请求参数为空
数据库查不到记录
配置项没有填写
第三方 API 返回缺字段

输入框为空
没有选中列表项
配置文件不存在
打开文件对话框被取消

Product? selected = SelectedProduct;
 
if (selected == null)
{
    return;
}
 
Delete(selected.Id);

var products = new List<Product>
{
    new Product { Id = 1, Name = "Keyboard" },
    new Product { Id = 2, Name = "Mouse" }
};
 
Product? found = products.FirstOrDefault(p => p.Id == 2);

var productMap = products.ToDictionary(p => p.Id);
 
if (productMap.TryGetValue(2, out var product))
{
    Console.WriteLine(product.Name);
}

var names = new HashSet<string>();
 
names.Add("Admin");
names.Add("Admin");
 
Console.WriteLine(names.Count); // 1

List 里查一个指定条件：通常要一个个找。
Dictionary 按 key 查：更适合快速定位。
HashSet 判断是否存在：适合去重和权限集合。

用 Dictionary 做缓存
用 HashSet 判断用户角色
用 List 返回分页结果

用 ObservableCollection 绑定列表
用 List 做临时计算
用 Dictionary 保存控件状态或数据索引

我要不要顺序？
我要不要重复？
我要不要按 key 快速查？
我要不要通知界面列表变化？
数据量会不会变大？

var names = products
    .Where(p => p.Price > 100)
    .Select(p => p.Name)
    .ToList();

var query = products.Where(p => p.Price > 100);
 
products.Add(new Product { Name = "Mouse", Price = 120 });
 
var result = query.ToList();

想固定结果 -> ToList()
想继续拼查询 -> 保留 IEnumerable<T>
结果不对 -> 检查 Where 条件和 ToList 时机

string text = File.ReadAllText("data.txt");
File.WriteAllText("out.txt", text);

using var stream = File.OpenRead("big-file.dat");

相对路径：相对于程序当前工作目录
绝对路径：从磁盘根路径开始
跨平台路径：优先用 Path.Combine

string path = Path.Combine("data", "products.json");

var product = new Product { Name = "Keyboard", Price = 299 };
string json = JsonSerializer.Serialize(product);

Product? product = JsonSerializer.Deserialize<Product>(json);

字段名不一致 -> 用 JsonPropertyName
类型不匹配 -> 检查 int/decimal/string
空值异常 -> 用可空类型并做校验

GET：读取
POST：新增或提交
PUT：整体更新
PATCH：局部更新
DELETE：删除

using var client = new HttpClient();
string json = await client.GetStringAsync("https://example.com/api/products");

200：成功
400：请求参数错误
401：未登录
403：无权限
404：找不到
500：服务器错误

Entity：数据库里的业务实体，通常对应表。
DTO：接口传输对象，通常用于请求和响应。
ViewModel：界面显示和交互对象，通常用于桌面绑定。

public class ProductEntity
{
    public int Id { get; set; }
    public string Name { get; set; } = "";
    public decimal CostPrice { get; set; }
    public decimal SalePrice { get; set; }
    public DateTime CreatedAt { get; set; }
}

public class ProductResponse
{
    public int Id { get; set; }
    public string Name { get; set; } = "";
    public decimal SalePrice { get; set; }
}

public class ProductItemViewModel
{
    public int Id { get; set; }
    public string DisplayName { get; set; } = "";
    public bool IsSelected { get; set; }
}

public ProductResponse ToResponse(ProductEntity entity)
{
    return new ProductResponse
    {
        Id = entity.Id,
        Name = entity.Name,
        SalePrice = entity.SalePrice
    };
}

数据库字段不一定能给前端看。
接口字段不一定等于界面字段。
界面状态不应该存进数据库。
数据库结构变化不应该直接影响 API 和界面。

CreateProductRequest：新增商品时前端传入的数据。
ProductResponse：接口返回给前端的数据。
ProductEntity：数据库保存的数据。

ProductEntity：本地 SQLite 保存的数据。
ProductItemViewModel：列表上显示和选中的数据。
ProductEditViewModel：编辑窗口里的表单数据。

Controller：接收 HTTP 请求，返回 HTTP 响应。
Service：处理业务规则。
Repository：读写数据库。
DTO：请求和响应数据。
Entity：数据库实体。

View：界面。
ViewModel：界面状态和命令。
Service：业务规则。
Repository：文件或数据库读写。
Model / Entity：业务数据。

private void SaveButton_Click(object? sender, EventArgs e)
{
    File.WriteAllText("products.txt", NameTextBox.Text);
}

public class ProductViewModel
{
    private readonly ProductService _service;
 
    public ProductViewModel(ProductService service)
    {
        _service = service;
    }
 
    public void Save()
    {
        _service.Save(Name);
    }
}

public class ProductService
{
    private readonly ProductRepository _repository;
 
    public ProductService(ProductRepository repository)
    {
        _repository = repository;
    }
 
    public void Save(string name)
    {
        if (string.IsNullOrWhiteSpace(name))
        {
            throw new ArgumentException("Name is required.");
        }
 
        _repository.Save(name.Trim());
    }
}

界面换了，业务规则还能复用。
数据库换了，界面不需要大改。
Service 可以写测试。
错误更容易定位在哪一层。

界面/API 收到什么输入？
Service 要执行什么规则？
数据要保存到哪里？
返回给用户什么结果？
失败时在哪一层处理？

必填
长度
范围
格式
重复
权限
业务状态是否允许操作

public void ChangePrice(decimal price)
{
    if (price <= 0)
    {
        throw new ArgumentException("Price must be greater than zero.");
    }
 
    Price = price;
}

public class CreateProductRequest
{
    [Required]
    [StringLength(50)]
    public string Name { get; set; } = "";
 
    [Range(0.01, 999999)]
    public decimal Price { get; set; }
}

public bool CanSave()
{
    return !string.IsNullOrWhiteSpace(Name) && Price > 0;
}

输入校验：字段有没有填、格式对不对。
业务校验：当前状态能不能做这个动作。

if (order.Status == OrderStatus.Paid)
{
    throw new InvalidOperationException("Paid order cannot be deleted.");
}

SELECT * FROM Products WHERE Price > 100;

Product 类
-> Products 表
-> Product.Name 对应 Name 列

内存集合：程序关了就没了
文件保存：适合简单本地数据
数据库：适合可查询、可维护、多人或长期数据

{
  "ApiBaseUrl": "https://api.example.com",
  "LogLevel": "Information"
}

数据库连接字符串
JWT 密钥
第三方 API 地址
日志级别
运行环境 Development / Production

窗口大小
主题
本地数据路径
用户偏好设置

public class ProductViewModel
{
    private readonly ProductService _service = new ProductService();
}

public class ProductViewModel
{
    private readonly ProductService _service;
 
    public ProductViewModel(ProductService service)
    {
        _service = service;
    }
}

logger.LogInformation("Product saved: {Name}", product.Name);
logger.LogError(ex, "Save product failed");

if (string.IsNullOrWhiteSpace(product.Name))
{
    throw new ArgumentException("Product name is required");
}

[Fact]
public void Add_ShouldRejectEmptyName()
{
    Assert.Throws<ArgumentException>(() => service.Add(""));
}

用户输入不可信
文件路径不可信
接口参数不可信
权限必须在服务层校验
密钥不能写进源码
错误信息不要泄露敏感数据

if (!currentUser.CanDeleteProduct)
{
    throw new UnauthorizedAccessException("No permission");
}

认证 Authentication：确认你是谁。
授权 Authorization：确认你能做什么。

登录成功，系统知道你是 Alice：认证成功。
Alice 能不能删除商品：授权判断。

Cookie：浏览器网站常用。
JWT：前后端分离或移动端接口常用。
Role：按角色判断，例如 Admin、User。
Policy：按更细规则判断，例如 CanDeleteProduct。

本地账号登录
根据角色显示不同菜单
某些按钮只有管理员能点
访问本地加密配置或敏感文件

public void DeleteProduct(User user, int productId)
{
    if (!user.HasPermission("Product.Delete"))
    {
        throw new UnauthorizedAccessException("No permission.");
    }
 
    repository.Delete(productId);
}

401：没有登录，系统不知道你是谁。
403：已经登录，但没有权限做这件事。

这个动作是谁发起的？
系统怎么确认这个人身份？
这个动作需要什么权限？
权限判断写在哪一层？
失败时返回什么错误？

目标系统不一致
缺少资源文件
数据目录不存在
Runtime 没装
日志路径没权限

环境变量没配
数据库连接失败
端口没开放
反向代理配置错误
HTTPS 证书问题

在一个干净目录或干净环境里运行一次
确认配置、日志、数据文件、接口或窗口都能正常工作

断点：看代码有没有执行到这里。
单步执行：看每一行执行后的变量变化。
调用堆栈：看当前代码是谁调用过来的。
日志：记录线上或用户电脑上的运行过程。
异常信息：看错误类型、错误消息和堆栈位置。

错误能不能稳定复现？
输入数据是什么？
期望结果是什么？
实际结果是什么？
第一处和预期不同的变量在哪里？

Console.WriteLine(product == null);
Console.WriteLine(product?.Name);

在出错行前一行打断点
运行到断点
检查每个变量是否为空
继续单步执行
找到第一个变错的位置

看服务端日志
看异常堆栈
看请求参数
看数据库连接
看配置是否缺失

看是否在 UI 线程做了耗时工作
看是否没有 await 异步方法
看是否一次性加载过多数据
看日志里有没有重复异常

logger.LogError(ex, "Delete product failed. ProductId={ProductId}", productId);

git status
git add .
git commit -m "Add product validation"

工作区：正在修改但还没提交的文件。
暂存区：准备进入下一次提交的文件。
提交 commit：一次有说明的代码快照。
分支 branch：一条独立开发线。
合并 merge：把一条分支的修改合进另一条。

好：Add product validation
好：Fix product list empty state
差：Update code
差：Fix many things

git status
git diff

改错了可以找回。
报错时能知道最近改了哪里。
做实验可以开分支。
项目交付时能留下清晰历史。

昨天能运行，今天不能运行。
先看 git diff。
再看最近提交。
把问题缩小到某几个文件。

public interface IProductRepository
{
    Product? FindById(int id);
    void Save(Product product);
}

public class ProductService
{
    private readonly IProductRepository _repository;
 
    public ProductService(IProductRepository repository)
    {
        _repository = repository;
    }
}

public class AppOptions
{
    public string ApiBaseUrl { get; set; } = "";
    public int TimeoutSeconds { get; set; }
}

ViewModel 属性变化
-> 发出通知
-> View 更新界面

按钮点击
-> 执行 SaveCommand
-> SaveCommand 调用 ViewModel 的保存逻辑

public IExporter Create(string type)
{
    return type switch
    {
        "csv" => new CsvExporter(),
        "json" => new JsonExporter(),
        _ => throw new NotSupportedException(type)
    };
}

对象创建太复杂 -> Factory
数据访问想隔离 -> Repository
配置项越来越多 -> Options
界面要响应属性变化 -> Observer
按钮动作想从界面分离 -> Command

MyApp.exe
-> 一个进程
-> 加载 .NET Runtime
-> 加载你的 dll
-> 创建线程执行代码

int count = 0;
 
var t1 = new Thread(() => count++);
var t2 = new Thread(() => count++);
 
t1.Start();
t2.Start();
t1.Join();
t2.Join();
 
Console.WriteLine(count);

后台线程直接改 TextBlock.Text
-> 可能报错
-> 也可能出现不可预测问题

UI 线程：响应点击、刷新界面
后台任务：读文件、算数据、请求接口
完成后：切回 UI 线程更新状态

Task<int> task = GetCountAsync();
int count = await task;

await 之前的代码
-> 遇到等待，先把控制权让出去
-> 等任务完成
-> 从 await 后面继续执行

async Task LoadAsync()
{
    Console.WriteLine("开始读取");
    string text = await File.ReadAllTextAsync("data.txt");
    Console.WriteLine(text.Length);
}

IEnumerable<int> CountToThree()
{
    yield return 1;
    yield return 2;
    yield return 3;
}

yield return：按需吐出数据
async/await：等待期间暂停，完成后继续
Unity Coroutine：游戏循环里按帧暂停和继续

async/await 解决等待问题
多线程解决并行执行问题

private void OnClick(object? sender, EventArgs e)
{
    Thread.Sleep(5000);
}

private async void OnClick(object? sender, EventArgs e)
{
    await Task.Delay(5000);
}

private async void OnClick(object? sender, EventArgs e)
{
    var result = await Task.Run(() => CalculateReport());
    ResultText.Text = result;
}

private readonly object _lock = new();
private int _count;
 
void Increase()
{
    lock (_lock)
    {
        _count++;
    }
}

var user = new User();
user.Name = "Tom";

这个对象是什么类型？
它有哪些属性？
它有哪些方法？
属性上有没有特性？
能不能动态读取或设置这个属性？

public class User
{
    public string Name { get; set; } = "";
    public int Age { get; set; }
}
 
Type type = typeof(User);
 
foreach (var property in type.GetProperties())
{
    Console.WriteLine(property.Name);
}

Name
Age

[Obsolete("Use NewMethod instead")]
void OldMethod()
{
}

[Serializable]
[Obsolete]
[JsonPropertyName("user_name")]
[Fact]
[HttpGet]
[Required]

Json 序列化：读取 [JsonPropertyName]
单元测试框架：读取 [Fact]
Web 路由：读取 [HttpGet]
参数校验：读取 [Required]
依赖注入或扫描：读取类和接口信息
Avalonia/XAML：通过类型和属性信息连接界面与代码

[AttributeUsage(AttributeTargets.Property)]
public class CsvColumnAttribute : Attribute
{
    public string Name { get; }
 
    public CsvColumnAttribute(string name)
    {
        Name = name;
    }
}

public class Product
{
    [CsvColumn("product_name")]
    public string Name { get; set; } = "";
 
    [CsvColumn("price")]
    public decimal Price { get; set; }
}

Type type = typeof(Product);
 
foreach (var property in type.GetProperties())
{
    var attr = property
        .GetCustomAttributes(typeof(CsvColumnAttribute), false)
        .FirstOrDefault() as CsvColumnAttribute;
 
    if (attr != null)
    {
        Console.WriteLine($"{property.Name} -> {attr.Name}");
    }
}

Name -> product_name
Price -> price

线程是执行代码的路线。
Task 是 .NET 用来表示一件未来会完成的工作。
Task 可能用线程池执行，也可能只是代表一次 IO 等待。
所以 Task 不等于 Thread。

public class Customer
{
    public string Name { get; set; } = "";
    public string Email { get; set; } = "";
}
 
foreach (var property in typeof(Customer).GetProperties())
{
    Console.WriteLine(property.Name);
}

[AttributeUsage(AttributeTargets.Class)]
public class ModuleAttribute : Attribute
{
    public string Name { get; }
    public ModuleAttribute(string name) => Name = name;
}
 
[Module("Sales")]
public class SalesService
{
}

var attr = typeof(SalesService)
    .GetCustomAttributes(typeof(ModuleAttribute), false)
    .FirstOrDefault() as ModuleAttribute;
 
Console.WriteLine(attr?.Name);

SDK：开发和编译用，包含 dotnet CLI、模板、编译器。
Runtime：运行已编译程序用。
程序集：编译出来的 dll 或 exe。
NuGet：第三方依赖包管理系统。

临时显示结果：内存变量或集合。
用户偏好：配置文件。
本地长期数据：JSON 文件或 SQLite。
多人共享数据：服务器数据库。
接口传输数据：DTO + JSON。

异常：正常流程无法继续时抛出。
日志：记录运行过程，方便排查问题。
测试：用代码验证业务规则是否正确。

常见顺序：
先校验用户输入
再执行业务逻辑
失败时抛异常或返回错误
关键错误写日志
核心规则写测试

public Product GetRequiredProduct(int id)
{
    Product? product = repository.FindById(id);
 
    if (product == null)
    {
        throw new InvalidOperationException("Product not found.");
    }
 
    return product;
}

FindById 可能查不到，所以返回 Product?。
后面代码要使用 Product，就必须先判断 null。
判断完成后再 return，调用方拿到的就是明确存在的 Product。

商品列表要按顺序显示：List<Product>。
商品要按 Id 快速查找：Dictionary<int, Product>。
用户角色不能重复：HashSet<string>。
Avalonia 列表要通知界面变化：ObservableCollection<ProductItemViewModel>。

var roles = new HashSet<string> { "Admin", "User" };
 
if (roles.Contains("Admin"))
{
    Console.WriteLine("Can open admin page.");
}

Entity：贴近数据库，保存完整业务数据。
DTO：贴近接口，只传外部需要的数据。
ViewModel：贴近界面，包含显示状态和命令状态。

public class ProductEntity
{
    public int Id { get; set; }
    public string Name { get; set; } = "";
    public decimal CostPrice { get; set; }
    public decimal SalePrice { get; set; }
}
 
public class ProductResponse
{
    public int Id { get; set; }
    public string Name { get; set; } = "";
    public decimal SalePrice { get; set; }
}

View 或 Controller：接收输入。
Service：校验名称和价格，执行业务规则。
Repository：保存到文件、SQLite 或数据库。
DTO 或 ViewModel：承载输入和显示数据。

public class ProductService
{
    private readonly IProductRepository _repository;
 
    public ProductService(IProductRepository repository)
    {
        _repository = repository;
    }
 
    public void Create(string name, decimal price)
    {
        if (string.IsNullOrWhiteSpace(name))
        {
            throw new ArgumentException("Name is required.");
        }
 
        if (price <= 0)
        {
            throw new ArgumentException("Price must be greater than zero.");
        }
 
        _repository.Save(new Product(name.Trim(), price));
    }
}

认证：确认当前用户是谁。
授权：确认当前用户能不能执行某个动作。

401：没有登录或身份无效。
403：已经登录，但权限不够。

public void DeleteProduct(User user, int productId)
{
    if (!user.HasPermission("Product.Delete"))
    {
        throw new UnauthorizedAccessException("No permission.");
    }
 
    repository.Delete(productId);
}

先复现问题。
记录输入数据。
确认期望结果和实际结果。
在关键位置打断点。
检查变量是否为空、集合是否有数据、条件是否进入。
看异常堆栈和日志。
用 git diff 查看最近改动。
把问题缩小到具体文件、具体方法、具体一行。