扩展之前的C# WPF项目，明确界面设计（包含首页、数据库查询、增加、修改页面），并使用数据库（以SQLite为例）存储不同兵器的属性

最新推荐文章于 2025-10-07 14:12:42 发布
最新推荐文章于 2025-10-07 14:12:42 发布
阅读量662 收藏 25
点赞数 17
CC 4.0 BY-SA版权
分类专栏： WPF 文章标签： 数据库 c# wpf
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhxup606/article/details/152651867

扩展之前的C# WPF项目，明确界面设计（包含首页、数据库查询、增加、修改页面），并使用数据库（以SQLite为例）存储不同兵器的属性。每个兵器类型（枪支、大炮、飞机、坦克、卫星）将有独特的属性，存储在数据库中，并提供详细的兵器特性说明。我会使用DDD模式，提供完整的代码结构和实现细节。

项目结构

WeaponSystem
├── Domain
│   ├── Entities
│   │   ├── Weapon.cs (抽象类)
│   │   ├── Gun.cs
│   │   ├── Cannon.cs
│   │   ├── Aircraft.cs
│   │   ├── Tank.cs
│   │   ├── Satellite.cs
│   ├── Interfaces
│   │   ├── IWeapon.cs
│   │   ├── IWeaponRepository.cs
│   ├── ValueObjects
│   │   ├── WeaponCharacteristics.cs
├── Application
│   ├── Services
│   │   ├── WeaponService.cs
│   ├── DTOs
│   │   ├── WeaponDTO.cs
│   │   ├── GunDTO.cs, CannonDTO.cs, etc.
├── Infrastructure
│   ├── Repositories
│   │   ├── WeaponRepository.cs
│   ├── Data
│   │   ├── WeaponDbContext.cs
├── Presentation
│   ├── ViewModels
│   │   ├── MainViewModel.cs
│   │   ├── HomeViewModel.cs
│   │   ├── QueryViewModel.cs
│   │   ├── AddViewModel.cs
│   │   ├── UpdateViewModel.cs
│   ├── Views
│   │   ├── MainWindow.xaml
│   │   ├── HomeView.xaml
│   │   ├── QueryView.xaml
│   │   ├── AddView.xaml
│   │   ├── UpdateView.xaml

1. 兵器特性详解

每种兵器有通用属性（ID、名称、射程、威力、重量）和独特属性，存储在数据库中。以下是每种兵器的特性和使用场景：

  • 枪支 (Gun):

    • 特性: 轻便、射速快、适合近距离作战，维护成本低。
    • 独特属性:
      • FireRate (射速，单位：发/分钟)
      • AmmoType (弹药类型，如子弹、霰弹)
    • 使用场景: 步兵作战、城市战、快速反应任务。
    • 任务类型: CloseRange（近距离作战）。

  • 大炮 (Cannon):

    • 特性: 射程远、威力大、部署时间长，适合固定阵地。
    • 独特属性:
      • BarrelLength (炮管长度，单位：米)
      • ShellType (炮弹类型，如高爆、穿甲)
    • 使用场景: 远程火力支援、防线压制。
    • 任务类型: LongRange（远程轰炸）。

  • 飞机 (Aircraft):

    • 特性: 高速、机动性强、可执行多种任务（轰炸、侦察）。
    • 独特属性:
      • MaxSpeed (最大速度，单位：马赫)
      • PayloadCapacity (载弹量，单位：吨）
    • 使用场景: 空中支援、战略轰炸、侦察。
    • 任务类型: AirSupport（空中支援）。

  • 坦克 (Tank):

    • 特性: 重装甲、强火力、适合地面推进。
    • 独特属性:
      • ArmorThickness (装甲厚度，单位：毫米)
      • EnginePower (引擎功率，单位：马力)
    • 使用场景: 地面突击、防守阵地。
    • 任务类型: GroundAssault（地面突击）。

  • 卫星 (Satellite):

    • 特性: 太空部署、提供侦察或通信支持。
    • 独特属性:
      • OrbitAltitude (轨道高度，单位：公里)
      • SensorType (传感器类型，如光学、雷达)
    • 使用场景: 情报收集、通信支持。
    • 任务类型: Reconnaissance（侦察）。

2. 领域层 (Domain)

2.1 接口 (IWeapon.cs)
namespace WeaponSystem.Domain.Interfaces
{
    public interface IWeapon
    {
        string Id { get; }
        string Name { get; }
        WeaponCharacteristics Characteristics { get; }
        void UseWeapon(string missionType);
        string GetFeatures();
    }
}
2.2 抽象类 (Weapon.cs)
namespace WeaponSystem.Domain.Entities
{
    public abstract class Weapon : IWeapon
    {
        public string Id { get; protected set; }
        public string Name { get; protected set; }
        public WeaponCharacteristics Characteristics { get; protected set; }

        protected Weapon(string id, string name, WeaponCharacteristics characteristics)
        {
            Id = id;
            Name = name;
            Characteristics = characteristics;
        }

        public abstract void UseWeapon(string missionType);
        public abstract string GetFeatures();
    }
}
2.3 值对象 (WeaponCharacteristics.cs)
namespace WeaponSystem.Domain.ValueObjects
{
    public class WeaponCharacteristics
    {
        public double Range { get; set; }
        public double Power { get; set; }
        public double Weight { get; set; }
        public Dictionary<string, string> SpecificAttributes { get; set; } // 存储独特属性

        public WeaponCharacteristics(double range, double power, double weight, Dictionary<string, string> specificAttributes)
        {
            Range = range;
            Power = power;
            Weight = weight;
            SpecificAttributes = specificAttributes;
        }
    }
}
2.4 具体实体类

以Gun.cs为例，其余类类似，仅独特属性不同。

namespace WeaponSystem.Domain.Entities
{
    public class Gun : Weapon
    {
        public Gun(string id, string name, WeaponCharacteristics characteristics)
            : base(id, name, characteristics)
        {
        }

        public override void UseWeapon(string missionType)
        {
            Console.WriteLine($"Gun {Name} used for {missionType}. Effective for close-range infantry support.");
        }

        public override string GetFeatures()
        {
            var fireRate = Characteristics.SpecificAttributes.GetValueOrDefault("FireRate");
            var ammoType = Characteristics.SpecificAttributes.GetValueOrDefault("AmmoType");
            return $"Gun: {Name}, Range: {Characteristics.Range}km, Power: {Characteristics.Power}, Weight: {Characteristics.Weight}t, FireRate: {fireRate}, AmmoType: {ammoType}";
        }
    }

    // Cannon.cs
    public class Cannon : Weapon
    {
        public Cannon(string id, string name, WeaponCharacteristics characteristics)
            : base(id, name, characteristics) { }

        public override void UseWeapon(string missionType)
        {
            Console.WriteLine($"Cannon {Name} used for {missionType}. Ideal for long-range bombardment.");
        }

        public override string GetFeatures()
        {
            var barrelLength = Characteristics.SpecificAttributes.GetValueOrDefault("BarrelLength");
            var shellType = Characteristics.SpecificAttributes.GetValueOrDefault("ShellType");
            return $"Cannon: {Name}, Range: {Characteristics.Range}km, Power: {Characteristics.Power}, Weight: {Characteristics.Weight}t, BarrelLength: {barrelLength}, ShellType: {shellType}";
        }
    }

    // Aircraft.cs, Tank.cs, Satellite.cs 类似实现，略
}
2.5 仓储接口 (IWeaponRepository.cs)
namespace WeaponSystem.Domain.Interfaces
{
    public interface IWeaponRepository
    {
        void Add(Weapon weapon);
        void Update(Weapon weapon);
        void Delete(string id);
        Weapon GetById(string id);
        IEnumerable<Weapon> GetAll();
        IEnumerable<Weapon> QueryByType(string weaponType);
    }
}

3. 应用层 (Application)

3.1 DTOs

为每种兵器定义特定的DTO，包含独特属性。

namespace WeaponSystem.Application.DTOs
{
    public abstract class WeaponDTO
    {
        public string Id { get; set; }
        public string Name { get; set; }
        public double Range { get; set; }
        public double Power { get; set; }
        public double Weight { get; set; }
        public string Type { get; set; }
    }

    public class GunDTO : WeaponDTO
    {
        public string FireRate { get; set; }
        public string AmmoType { get; set; }
    }

    public class CannonDTO : WeaponDTO
    {
        public string BarrelLength { get; set; }
        public string ShellType { get; set; }
    }

    // AircraftDTO, TankDTO, SatelliteDTO 类似，略
}
3.2 服务 (WeaponService.cs)
using WeaponSystem.Domain.Entities;
using WeaponSystem.Domain.Interfaces;

namespace WeaponSystem.Application.Services
{
    public class WeaponService
    {
        private readonly IWeaponRepository _repository;

        public WeaponService(IWeaponRepository repository)
        {
            _repository = repository;
        }

        public void AddWeapon(WeaponDTO dto)
        {
            var characteristics = new WeaponCharacteristics(
                dto.Range, dto.Power, dto.Weight,
                dto switch
                {
                    GunDTO gun => new Dictionary<string, string> { { "FireRate", gun.FireRate }, { "AmmoType", gun.AmmoType } },
                    CannonDTO cannon => new Dictionary<string, string> { { "BarrelLength", cannon.BarrelLength }, { "ShellType", cannon.ShellType } },
                    // 其他类型类似
                    _ => throw new ArgumentException("Invalid weapon type")
                });

            Weapon weapon = dto.Type switch
            {
                "Gun" => new Gun(dto.Id, dto.Name, characteristics),
                "Cannon" => new Cannon(dto.Id, dto.Name, characteristics),
                // 其他类型
                _ => throw new ArgumentException("Invalid weapon type")
            };
            _repository.Add(weapon);
        }

        public void UpdateWeapon(WeaponDTO dto)
        {
            var characteristics = new WeaponCharacteristics(
                dto.Range, dto.Power, dto.Weight,
                dto switch
                {
                    GunDTO gun => new Dictionary<string, string> { { "FireRate", gun.FireRate }, { "AmmoType", gun.AmmoType } },
                    CannonDTO cannon => new Dictionary<string, string> { { "BarrelLength", cannon.BarrelLength }, { "ShellType", cannon.ShellType } },
                    // 其他类型
                    _ => throw new ArgumentException("Invalid weapon type")
                });

            Weapon weapon = dto.Type switch
            {
                "Gun" => new Gun(dto.Id, dto.Name, characteristics),
                "Cannon" => new Cannon(dto.Id, dto.Name, characteristics),
                // 其他类型
                _ => throw new ArgumentException("Invalid weapon type")
            };
            _repository.Update(weapon);
        }

        public void DeleteWeapon(string id) => _repository.Delete(id);

        public WeaponDTO GetWeaponById(string id)
        {
            var weapon = _repository.GetById(id);
            if (weapon == null) return null;

            return weapon switch
            {
                Gun gun => new GunDTO
                {
                    Id = gun.Id,
                    Name = gun.Name,
                    Range = gun.Characteristics.Range,
                    Power = gun.Characteristics.Power,
                    Weight = gun.Characteristics.Weight,
                    Type = "Gun",
                    FireRate = gun.Characteristics.SpecificAttributes.GetValueOrDefault("FireRate"),
                    AmmoType = gun.Characteristics.SpecificAttributes.GetValueOrDefault("AmmoType")
                },
                Cannon cannon => new CannonDTO
                {
                    Id = cannon.Id,
                    Name = cannon.Name,
                    Range = cannon.Characteristics.Range,
                    Power = cannon.Characteristics.Power,
                    Weight = cannon.Characteristics.Weight,
                    Type = "Cannon",
                    BarrelLength = cannon.Characteristics.SpecificAttributes.GetValueOrDefault("BarrelLength"),
                    ShellType = cannon.Characteristics.SpecificAttributes.GetValueOrDefault("ShellType")
                },
                // 其他类型
                _ => throw new ArgumentException("Invalid weapon type")
            };
        }

        public IEnumerable<WeaponDTO> GetAllWeapons() => _repository.GetAll().Select(MapToDTO);
        public IEnumerable<WeaponDTO> QueryWeaponsByType(string weaponType) => _repository.QueryByType(weaponType).Select(MapToDTO);

        private WeaponDTO MapToDTO(Weapon weapon) => weapon switch
        {
            Gun gun => new GunDTO
            {
                Id = gun.Id,
                Name = gun.Name,
                Range = gun.Characteristics.Range,
                Power = gun.Characteristics.Power,
                Weight = gun.Characteristics.Weight,
                Type = "Gun",
                FireRate = gun.Characteristics.SpecificAttributes.GetValueOrDefault("FireRate"),
                AmmoType = gun.Characteristics.SpecificAttributes.GetValueOrDefault("AmmoType")
            },
            // 其他类型
            _ => throw new ArgumentException("Invalid weapon type")
        };

        public string RecommendWeapon(string missionType)
        {
            return missionType switch
            {
                "CloseRange" => "Gun",
                "LongRange" => "Cannon",
                "AirSupport" => "Aircraft",
                "GroundAssault" => "Tank",
                "Reconnaissance" => "Satellite",
                _ => "Unknown mission type"
            };
        }
    }
}

4. 基础设施层 (Infrastructure)

4.1 数据库上下文 (WeaponDbContext.cs)

使用Entity Framework Core和SQLite存储兵器数据。

using Microsoft.EntityFrameworkCore;
using WeaponSystem.Domain.Entities;
using WeaponSystem.Domain.ValueObjects;

namespace WeaponSystem.Infrastructure.Data
{
    public class WeaponDbContext : DbContext
    {
        public DbSet<WeaponEntity> Weapons { get; set; }

        public WeaponDbContext(DbContextOptions<WeaponDbContext> options) : base(options) { }

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            modelBuilder.Entity<WeaponEntity>()
                .OwnsOne(w => w.Characteristics, c =>
                {
                    c.Property(x => x.Range).HasColumnName("Range");
                    c.Property(x => x.Power).HasColumnName("Power");
                    c.Property(x => x.Weight).HasColumnName("Weight");
                    c.Property(x => x.SpecificAttributes).HasConversion(
                        v => System.Text.Json.JsonSerializer.Serialize(v, null),
                        v => System.Text.Json.JsonSerializer.Deserialize<Dictionary<string, string>>(v, null));
                });
        }
    }

    public class WeaponEntity
    {
        public string Id { get; set; }
        public string Name { get; set; }
        public string Type { get; set; }
        public WeaponCharacteristics Characteristics { get; set; }
    }
}
4.2 仓储实现 (WeaponRepository.cs)
using Microsoft.EntityFrameworkCore;
using WeaponSystem.Domain.Entities;
using WeaponSystem.Domain.Interfaces;

namespace WeaponSystem.Infrastructure.Repositories
{
    public class WeaponRepository : IWeaponRepository
    {
        private readonly WeaponDbContext _context;

        public WeaponRepository(WeaponDbContext context)
        {
            _context = context;
        }

        public void Add(Weapon weapon)
        {
            var entity = new WeaponEntity
            {
                Id = weapon.Id,
                Name = weapon.Name,
                Type = weapon.GetType().Name,
                Characteristics = weapon.Characteristics
            };
            _context.Weapons.Add(entity);
            _context.SaveChanges();
        }

        public void Update(Weapon weapon)
        {
            var entity = _context.Weapons.Find(weapon.Id);
            if (entity != null)
            {
                entity.Name = weapon.Name;
                entity.Type = weapon.GetType().Name;
                entity.Characteristics = weapon.Characteristics;
                _context.SaveChanges();
            }
        }

        public void Delete(string id)
        {
            var entity = _context.Weapons.Find(id);
            if (entity != null)
            {
                _context.Weapons.Remove(entity);
                _context.SaveChanges();
            }
        }

        public Weapon GetById(string id)
        {
            var entity = _context.Weapons.Find(id);
            if (entity == null) return null;

            return entity.Type switch
            {
                "Gun" => new Gun(entity.Id, entity.Name, entity.Characteristics),
                "Cannon" => new Cannon(entity.Id, entity.Name, entity.Characteristics),
                // 其他类型
                _ => throw new ArgumentException("Invalid weapon type")
            };
        }

        public IEnumerable<Weapon> GetAll() => _context.Weapons.ToList().Select(MapToWeapon);
        public IEnumerable<Weapon> QueryByType(string weaponType) => _context.Weapons
            .Where(w => w.Type == weaponType)
            .ToList()
            .Select(MapToWeapon);

        private Weapon MapToWeapon(WeaponEntity entity) => entity.Type switch
        {
            "Gun" => new Gun(entity.Id, entity.Name, entity.Characteristics),
            "Cannon" => new Cannon(entity.Id, entity.Name, entity.Characteristics),
            // 其他类型
            _ => throw new ArgumentException("Invalid weapon type")
        };
    }
}

5. 表现层 (Presentation)

5.1 界面设计
  • 首页 (HomeView.xaml): 显示欢迎信息和推荐兵器功能。
  • 数据库查询 (QueryView.xaml): 显示所有兵器，允许按类型筛选。
  • 增加 (AddView.xaml): 提供表单输入兵器属性，动态调整字段。
  • 修改 (UpdateView.xaml): 编辑已有兵器，动态加载属性。
5.1.1 首页 (HomeView.xaml)
<UserControl x:Class="WeaponSystem.Presentation.Views.HomeView"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
    <StackPanel Margin="10">
        <TextBlock Text="Welcome to Weapon System" FontSize="20" Margin="5"/>
        <TextBox Text="{Binding MissionType}" Width="200" Margin="5"/>
        <TextBlock Text="{Binding RecommendedWeapon}" Margin="5"/>
    </StackPanel>
</UserControl>
5.1.2 查询页面 (QueryView.xaml)
<UserControl x:Class="WeaponSystem.Presentation.Views.QueryView"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
    <Grid Margin="10">
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="*"/>
        </Grid.RowDefinitions>
        <StackPanel Orientation="Horizontal">
            <ComboBox SelectedItem="{Binding SelectedType}" Width="100" Margin="5">
                <ComboBoxItem>All</ComboBoxItem>
                <ComboBoxItem>Gun</ComboBoxItem>
                <ComboBoxItem>Cannon</ComboBoxItem>
                <ComboBoxItem>Aircraft</ComboBoxItem>
                <ComboBoxItem>Tank</ComboBoxItem>
                <ComboBoxItem>Satellite</ComboBoxItem>
            </ComboBox>
            <Button Content="Query" Command="{Binding QueryCommand}" Margin="5"/>
        </StackPanel>
        <DataGrid Grid.Row="1" ItemsSource="{Binding Weapons}" AutoGenerateColumns="False">
            <DataGrid.Columns>
                <DataGridTextColumn Header="ID" Binding="{Binding Id}"/>
                <DataGridTextColumn Header="Name" Binding="{Binding Name}"/>
                <DataGridTextColumn Header="Type" Binding="{Binding Type}"/>
                <DataGridTextColumn Header="Range" Binding="{Binding Range}"/>
                <DataGridTextColumn Header="Power" Binding="{Binding Power}"/>
                <DataGridTextColumn Header="Weight" Binding="{Binding Weight}"/>
            </DataGrid.Columns>
        </DataGrid>
    </Grid>
</UserControl>
5.1.3 增加页面 (AddView.xaml)
<UserControl x:Class="WeaponSystem.Presentation.Views.AddView"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
    <StackPanel Margin="10">
        <ComboBox SelectedItem="{Binding SelectedWeapon.Type}" Width="100" Margin="5">
            <ComboBoxItem>Gun</ComboBoxItem>
            <ComboBoxItem>Cannon</ComboBoxItem>
            <ComboBoxItem>Aircraft</ComboBoxItem>
            <ComboBoxItem>Tank</ComboBoxItem>
            <ComboBoxItem>Satellite</ComboBoxItem>
        </ComboBox>
        <TextBox Text="{Binding SelectedWeapon.Name}" Width="200" Margin="5" Prompt="Name"/>
        <TextBox Text="{Binding SelectedWeapon.Range}" Width="200" Margin="5" Prompt="Range (km)"/>
        <TextBox Text="{Binding SelectedWeapon.Power}" Width="200" Margin="5" Prompt="Power"/>
        <TextBox Text="{Binding SelectedWeapon.Weight}" Width="200" Margin="5" Prompt="Weight (t)"/>
        <!-- 动态字段，基于兵器类型 -->
        <ContentControl Content="{Binding DynamicFields}"/>
        <Button Content="Add" Command="{Binding AddCommand}" Margin="5"/>
    </StackPanel>
</UserControl>
5.1.4 修改页面 (UpdateView.xaml)

与AddView.xaml类似，但预加载选中兵器的属性。

5.2 ViewModel
5.2.1 主ViewModel (MainViewModel.cs)
using WeaponSystem.Application.Services;
using System.Windows.Controls;
using System.Windows.Input;

namespace WeaponSystem.Presentation.ViewModels
{
    public class MainViewModel : INotifyPropertyChanged
    {
        private UserControl _currentView;

        public UserControl CurrentView
        {
            get => _currentView;
            set { _currentView = value; OnPropertyChanged(nameof(CurrentView)); }
        }

        public ICommand HomeCommand { get; }
        public ICommand QueryCommand { get; }
        public ICommand AddCommand { get; }
        public ICommand UpdateCommand { get; }

        public MainViewModel(WeaponService weaponService)
        {
            HomeCommand = new RelayCommand(() => CurrentView = new HomeView { DataContext = new HomeViewModel(weaponService) });
            QueryCommand = new RelayCommand(() => CurrentView = new QueryView { DataContext = new QueryViewModel(weaponService) });
            AddCommand = new RelayCommand(() => CurrentView = new AddView { DataContext = new AddViewModel(weaponService) });
            UpdateCommand = new RelayCommand(() => CurrentView = new UpdateView { DataContext = new UpdateViewModel(weaponService) });
            CurrentView = new HomeView { DataContext = new HomeViewModel(weaponService) };
        }

        public event PropertyChangedEventHandler PropertyChanged;
        protected void OnPropertyChanged(string propertyName) =>
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }

    public class RelayCommand : ICommand
    {
        private readonly Action _execute;
        public RelayCommand(Action execute) => _execute = execute;
        public event EventHandler CanExecuteChanged;
        public bool CanExecute(object parameter) => true;
        public void Execute(object parameter) => _execute();
    }
}
5.2.2 首页ViewModel (HomeViewModel.cs)
using WeaponSystem.Application.Services;

namespace WeaponSystem.Presentation.ViewModels
{
    public class HomeViewModel : INotifyPropertyChanged
    {
        private readonly WeaponService _weaponService;
        private string _missionType;

        public string MissionType
        {
            get => _missionType;
            set { _missionType = value; OnPropertyChanged(nameof(MissionType)); OnPropertyChanged(nameof(RecommendedWeapon)); }
        }
        public string RecommendedWeapon => _weaponService.RecommendWeapon(MissionType);

        public HomeViewModel(WeaponService weaponService)
        {
            _weaponService = weaponService;
        }

        public event PropertyChangedEventHandler PropertyChanged;
        protected void OnPropertyChanged(string propertyName) =>
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}
5.2.3 查询ViewModel (QueryViewModel.cs)
using WeaponSystem.Application.DTOs;
using WeaponSystem.Application.Services;
using System.Collections.ObjectModel;

namespace WeaponSystem.Presentation.ViewModels
{
    public class QueryViewModel : INotifyPropertyChanged
    {
        private readonly WeaponService _weaponService;
        private string _selectedType;

        public ObservableCollection<WeaponDTO> Weapons { get; set; }
        public string SelectedType
        {
            get => _selectedType;
            set { _selectedType = value; OnPropertyChanged(nameof(SelectedType)); QueryWeapons(); }
        }
        public ICommand QueryCommand { get; }

        public QueryViewModel(WeaponService weaponService)
        {
            _weaponService = weaponService;
            Weapons = new ObservableCollection<WeaponDTO>();
            QueryCommand = new RelayCommand(QueryWeapons);
            SelectedType = "All";
        }

        private void QueryWeapons()
        {
            Weapons.Clear();
            var weapons = SelectedType == "All" ? _weaponService.GetAllWeapons() : _weaponService.QueryWeaponsByType(SelectedType);
            foreach (var weapon in weapons)
                Weapons.Add(weapon);
        }

        public event PropertyChangedEventHandler PropertyChanged;
        protected void OnPropertyChanged(string propertyName) =>
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}
5.2.4 增加ViewModel (AddViewModel.cs)
using WeaponSystem.Application.DTOs;
using WeaponSystem.Application.Services;
using System.Windows.Controls;

namespace WeaponSystem.Presentation.ViewModels
{
    public class AddViewModel : INotifyPropertyChanged
    {
        private readonly WeaponService _weaponService;
        private WeaponDTO _selectedWeapon;
        private UserControl _dynamicFields;

        public WeaponDTO SelectedWeapon
        {
            get => _selectedWeapon;
            set
            {
                _selectedWeapon = value;
                UpdateDynamicFields();
                OnPropertyChanged(nameof(SelectedWeapon));
            }
        }
        public UserControl DynamicFields
        {
            get => _dynamicFields;
            set { _dynamicFields = value; OnPropertyChanged(nameof(DynamicFields)); }
        }
        public ICommand AddCommand { get; }

        public AddViewModel(WeaponService weaponService)
        {
            _weaponService = weaponService;
            SelectedWeapon = new GunDTO { Id = Guid.NewGuid().ToString(), Type = "Gun" };
            AddCommand = new RelayCommand(AddWeapon);
            UpdateDynamicFields();
        }

        private void AddWeapon()
        {
            _weaponService.AddWeapon(SelectedWeapon);
        }

        private void UpdateDynamicFields()
        {
            DynamicFields = SelectedWeapon.Type switch
            {
                "Gun" => new UserControl
                {
                    Content = new StackPanel
                    {
                        Children =
                        {
                            new TextBox { Text = ((GunDTO)SelectedWeapon).FireRate, Width = 200, Margin = new Thickness(5) },
                            new TextBox { Text = ((GunDTO)SelectedWeapon).AmmoType, Width = 200, Margin = new Thickness(5) }
                        }
                    }
                },
                "Cannon" => new UserControl
                {
                    Content = new StackPanel
                    {
                        Children =
                        {
                            new TextBox { Text = ((CannonDTO)SelectedWeapon).BarrelLength, Width = 200, Margin = new Thickness(5) },
                            new TextBox { Text = ((CannonDTO)SelectedWeapon).ShellType, Width = 200, Margin = new Thickness(5) }
                        }
                    }
                },
                // 其他类型
                _ => new UserControl()
            };
        }

        public event PropertyChangedEventHandler PropertyChanged;
        protected void OnPropertyChanged(string propertyName) =>
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}
5.2.5 修改ViewModel (UpdateViewModel.cs)

与AddViewModel.cs类似，但包含从数据库加载已有兵器的逻辑。

5.3 主窗口 (MainWindow.xaml)
<Window x:Class="WeaponSystem.Presentation.Views.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="Weapon System" Height="450" Width="800">
    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="*"/>
        </Grid.RowDefinitions>
        <StackPanel Orientation="Horizontal" Margin="5">
            <Button Content="Home" Command="{Binding HomeCommand}" Margin="5"/>
            <Button Content="Query" Command="{Binding QueryCommand}" Margin="5"/>
            <Button Content="Add" Command="{Binding AddCommand}" Margin="5"/>
            <Button Content="Update" Command="{Binding UpdateCommand}" Margin="5"/>
        </StackPanel>
        <ContentControl Grid.Row="1" Content="{Binding CurrentView}"/>
    </Grid>
</Window>
5.4 代码-behind (MainWindow.xaml.cs)
using Microsoft.EntityFrameworkCore;
using WeaponSystem.Application.Services;
using WeaponSystem.Infrastructure.Data;
using WeaponSystem.Infrastructure.Repositories;
using WeaponSystem.Presentation.ViewModels;
using System.Windows;

namespace WeaponSystem.Presentation.Views
{
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
            var options = new DbContextOptionsBuilder<WeaponDbContext>()
                .UseSqlite("Data Source=weapons.db")
                .Options;
            var context = new WeaponDbContext(options);
            context.Database.EnsureCreated();
            var weaponService = new WeaponService(new WeaponRepository(context));
            DataContext = new MainViewModel(weaponService);
        }
    }
}

6. 如何运行

  1. 创建WPF项目，添加上述文件。
  2. 安装NuGet包：
    • Microsoft.EntityFrameworkCore.Sqlite
    • System.Text.Json
  3. 确保项目引用正确，运行MainWindow.xaml。
  4. 数据库文件weapons.db会在运行时自动创建。
  5. 通过界面切换首页、查询、增加、修改页面，输入或查询兵器数据。

7. 扩展建议

  • 动态表单优化：使用数据模板（DataTemplate）动态生成兵器特定属性的输入字段。
  • 验证逻辑：在WeaponService中添加输入验证（如射程不能为负）。
  • 日志记录：集成Serilog记录操作日志。
  • 单元测试：为WeaponService和WeaponRepository编写单元测试。
  • UI美化：添加兵器图标、3D模型预览或动画效果。

如果需要更详细的某部分代码或进一步优化，请告诉我！

WinForms 中使用 MVVM 模式构建应用：实现登录页面、页面导航及 SQLite 数据库连接完整框架搭建过程
dotnet研习社
11-01 2655
在传统的 WinForms 应用程序开发中，很多开发者使用事件驱动的设计模式，直接将业务逻辑编写在界面代码中。然而，随着应用程序的复杂性增加，单一的界面文件变得臃肿，难以测试和维护。借鉴 WPF 中 MVVM（Model-View-ViewModel）模式的设计思想，可以帮助我们更好地管理业务逻辑和数据绑定。本文将介绍如何在 WinForms 中构建一个 MVVM 框架的登录页面示例，并实现页面导航、SQLite 数据库连接及依赖注入管理。
wpf通过依赖注入查询多个数据库显示到页面
sasafs的博客
06-25 528
C#依赖注入
为兵器系统设计一个完整的C# WPF项目，使用DDD模式，包含首页、数据库查询、增加和修改功能，支持自定义兵器属性，存储到数据库
专注于前沿技术的探索与实践，热衷于从代码逻辑、架构设计到行业应用等多维度深挖技术本质。期待在技术之路上与你共同成长～
10-07 622
为兵器系统设计一个完整的C# WPF项目，使用DDD模式，包含首页、数据库查询、增加和修改功能，支持自定义兵器属性，存储到数据库，并实现分词查询和根据作战任务推荐兵器。以下是详细的代码实现，包含所有模块和注释，确保代码完整且易于扩展。数据库使用SQLite以简化示例，实际项目可替换为其他数据库（如SQL Server）。
WPF智能工控系统开发实战：PLC数据采集、数据库操作与实时告警集成方案
威哥说编程
05-24 1792
本文探讨了WPF框架在智能工控系统开发中的应用。随着工业4.0发展，智能工控系统面临数据采集、处理和展示的挑战。文章详细介绍了基于WPF的工控系统架构，包括PLC数据采集、数据库操作和实时告警功能的实现方案。通过NModbus库进行PLC通信，结合Entity Framework进行数据存储，并利用WPF的数据绑定和UI控件展示实时数据与报警信息。系统实现了设备监控、历史数据查询和异常告警等功能，为工业自动化提供了高效解决方案。
WPF使用SQLite与JSON文本文件结合存储体侧平衡数据的设计与实现
不迁怒，不贰过。小知识，大智慧。
04-27 1264
数据库与文件存储的合理分工通过将人员的基本信息及对应的体侧数据文件路径存储在SQLite数据库中，实现了对人员信息的结构化管理和快速查询。与此同时，将体侧平衡数据以JSON格式的文本文件存储在本地磁盘，避免了数据库因存储大量复杂数据而导致的性能瓶颈。此设计有效减轻了数据库的存储压力，提升了系统的整体响应速度和稳定性。JSON格式的灵活性与可扩展性采用JSON格式存储体侧平衡数据，不仅结构清晰、易于理解，而且支持多种数据类型和层级结构，便于后续功能扩展和数据维护。
C#访问Sqlite入门之基本增删改查操作
GoldenLionKing的博客
06-27 1239
C#访问Sqlite入门之基本增删改查操作
C#实现SQLite数据库增删改查操作指南
weixin_33245447的博客
09-09 713
SQLite是一种嵌入式关系型数据库，以其轻量、无需独立服务器、零配置和高效性能广泛应用于移动开发、桌面应用及小型系统中。其核心优势在于数据库直接存储在文件中，支持多平台访问，且具备良好的并发读取能力和事务支持。相较于大型数据库如MySQL或PostgreSQL，SQLite更适用于资源受限或轻量级数据处理场景。通过本章学习，读者将理解SQLite的基本架构、适用场景及其在实际开发中的价值定位。事务管理是保证数据一致性的关键机制。
基于 C# 的上位机系统设计与实现：从界面到通信协议
威哥说编程
07-24 587
本文系统介绍了基于C#开发工业上位机系统的完整方案。文章首先定义上位机作为工业自动化中枢的功能定位，分析C#在开发效率、界面设计、通信能力和稳定性等方面的优势。随后提出分层架构设计，涵盖UI层(WinForms/WPF)、控制逻辑层、通信协议层(Modbus RTU/TCP)和硬件设备层，并给出具体实现代码。重点讲解了多线程数据采集、SQLite数据存储、报警机制等关键模块的实现方法，以及异常处理、自动重连等稳定性保障措施。最后提出Web可视化、MQTT云平台等扩展方向，为构建稳定高效的工业级上位机系统提供
C#窗体登录注册对数据库SQLite进行增删改查（三层架构）
03-04
在本项目中，我们主要探讨如何使用C#窗体应用程序结合SQLite数据库实现用户登录与注册功能，并通过三层架构实现对数据库的增删改查操作。SQLite是一个轻量级的、自包含的数据库引擎，适用于各种应用程序，特别是移动...
基于WPF/Sqlite的C#商品条码返利管理软件C/S架构设计源码
09-27
基于WPF/Sqlite的C#商品条码返利管理软件采用C/S架构设计，是一种客户端/服务器架构的应用程序，特别适用于企业内部网络环境，能够实现客户端与服务器之间的高效数据交互。WPF（Windows Presentation Foundation）是...
C# WPF客户询单管理系统.zip（源码+数据库文件）
12-26
3. 数据库支持：包含数据库文件，可能使用了SQL Server、SQLite或其他数据库管理系统，支持数据的存储、检索和更新。 4. 高效的业务处理：系统针对客户询单管理进行了优化，能够高效地处理询单的创建、修改、查询和...
C#客户端通过WCF远程访问Sqlite数据库
06-19
标题 "C#客户端通过WCF远程访问Sqlite数据库" 描述了一个使用C#语言和Windows Communication Foundation (WCF)技术构建的应用程序，该程序能够使客户端远程操作Sqlite数据库，从而将原本的单机数据库系统转变为可...
使用C# 开发的学生成绩管理系统和数据库开发
05-24
综上所述，"使用C# 开发的学生成绩管理系统和数据库开发"项目涵盖了编程语言、数据库设计、用户界面、数据处理等多个方面的知识，为学习和实践C#开发提供了很好的实际案例。通过此项目，开发者可以提升软件工程能力...
Redis分布式锁：从“能用就行”到“稳如老狗”的迭代方案
Kg2813026978的博客
10-03 1402
摘要：Redis分布式锁的演进与实践 本文系统阐述了从JVM单机锁到Redis分布式锁的技术演进过程。最初基于JVM锁在分布式环境下失效，转而使用Redis的SETNX命令实现分布式锁1.0版本，但存在死锁风险。随后通过引入过期时间解决死锁问题（2.0版），又利用Redis原子性SET命令优化实现（3.0版）。4.0版本通过引入唯一标识解决锁误删问题，最终构建了具备独占性、防死锁、不乱抢等特性的分布式锁方案。文章采用类比方式生动解释技术原理，并配有代码示例和流程图，完整呈现了分布式锁的技术实现路径与优化思路
mysql数据库基础——基本认识
2301_79705195的博客
10-02 1041
本文介绍了MySQL数据库的基础知识，包括数据库的必要性、主流数据库、验证MySQL作为网络程序的特性、数据库的本质理解、服务器/数据库/表的关系、MySQL的逻辑存储结构、SQL语句分类以及MySQL的架构。文章指出，数据库相比文件存储具有更好的安全性、查询管理能力和海量数据处理能力，并详细解析了MySQL作为C/S模式网络程序的工作原理。通过实际操作演示了创建数据库和表的过程，揭示了数据库本质上是对磁盘文件进行结构化管理的系统。最后介绍了MySQL的分层架构设计，包括连接层、服务层和存储引擎层。
【Web安全】转义字符注入？转义也会失效的SQL注入
水滴石穿
10-06 882
转义函数不是万能的，它的安全依赖于PHP和MySQL的字符集一致。如果两边"翻译错了"，哪怕是0x810xDF这样的"半个字"，都能让反斜杠的保护失效，导致注入。同步字符集是基础，预处理语句是王道——这两个做到了，绝大多数SQL注入都能防住。
【Flutter】APP的数据安全（基于Flutter 交易所APP的总结）
ZFJ_张福杰
10-05 1048
本文总结了基于Flutter开发的交易所APP的数据安全实践方案，主要涵盖四个层面：本地存储安全（加密数据库、Keychain/Keystore存储）、网络通信安全（HTTPS、SSL Pinning、请求签名）、代码与运行时安全（混淆、Root/越狱检测）以及Web3特殊安全建议（助记词加密、本地签名）。文章提供了具体的技术实现方案和安全检测建议，并附上Flutter安全配置的模板项目结构，为金融类APP开发提供了全面的数据安全防护指南。
从零开始：MCP数据库助手（一）- 基础搭建
weixin_46253270的博客
10-01 646
MCP DataTools：AI与数据库交互的桥梁 MCP（Model Context Protocol）是为AI助手扩展外部工具能力的标准协议，赋予AI操作数据库等外部系统的"手"。本文介绍了构建MCP数据库工具的实现步骤： 项目采用现代架构设计，使用uv包管理器，分离源码、数据和测试目录 通过DatabaseManager类统一管理数据库连接，支持连接测试、表查询等功能 实现首个MCP工具函数list_tables()，使AI能查询数据库表结构 核心优势： 安全可控的数据库访问 AI
从内核调优到集群部署：基于Linux环境下KingbaseES数据库安装指南
最新发布
稻草人
10-07 2937
本文详细介绍了国产数据库KingbaseES的安装部署全流程。主要内容包括：产品概述（支持国产CPU/OS、多版本选择）、安装前准备（硬件要求、环境配置、用户创建）、三种安装方式（图形化、命令行、静默）的具体步骤、安装后验证方法、组件管理技巧以及常见问题解决方案。文章还提供了目录结构说明和卸载指导，帮助用户全面掌握KingbaseES的部署与管理技能。该数据库作为国产数据库代表，在国产化替代项目中具有重要应用价值。
一键生成C# WPF模型类工具：支持多种数据库
值得注意的是，提供的软件工具并不附带源代码，这意味着虽然可以使用该工具，但无法查看或修改其内部实现逻辑。这可能是为了保护开发者的知识产权或商业机密。 由于资源描述中提供了个人博客链接，我们可以推断博客...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

张工在路上

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值