如何开发无需额外服务器的独立Windows桌面应用？WPF MVVM相关疑问

Hey there! Let’s tackle this together—building a standalone WPF MVVM app that doesn’t require any extra server installations is totally feasible, and embedded databases like SQLite are perfect for this use case. I’ll walk you through the key steps, choices, and best practices to get you unstuck.

First: Choose Your Embedded Database #

Let’s start with the critical decision: SQLite vs. SQL Server Compact. Here’s the lowdown:

• SQLite: My top recommendation. It’s lightweight, file-based, cross-platform, and has massive community support. It’s actively maintained, works seamlessly with .NET, and requires zero setup on the client machine—just include the database file with your app.
• SQL Server Compact: A Microsoft-owned embedded database, but note that it’s no longer maintained (last update was 2012). It integrates well with older .NET frameworks, but lacks modern features and support. Only use this if you have legacy compatibility needs.

For most new projects, SQLite is the way to go—so I’ll focus on that below, with a quick note on Compact if you need it.

Integrating SQLite into WPF MVVM #

The easiest way to work with SQLite in WPF MVVM is to use an ORM (Object-Relational Mapper) like Entity Framework Core (EF Core) or Dapper. EF Core is great for rapid development and fits well with MVVM’s separation of concerns.

Step 1: Install Required NuGet Packages #

Open your WPF project’s NuGet Package Manager and install these:

• Microsoft.EntityFrameworkCore.Sqlite: The EF Core provider for SQLite
• Microsoft.EntityFrameworkCore.Tools (optional): For database migrations (if you plan to evolve your schema over time)
• Alternatively, if you prefer raw ADO.NET, install System.Data.SQLite.Core

Step 2: Define Your Data Models #

Create simple C# classes that represent your database tables. For example, a TodoItem model:

public class TodoItem
{
    public int Id { get; set; }
    public string Title { get; set; }
    public bool IsCompleted { get; set; }
    public DateTime CreatedDate { get; set; }
}

Step 3: Create a DbContext (EF Core) #

The DbContext acts as a bridge between your models and the SQLite database. Create a class that inherits from DbContext:

using Microsoft.EntityFrameworkCore;

public class AppDbContext : DbContext
{
    public DbSet<TodoItem> TodoItems { get; set; }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        // Get a safe location for the database file (avoid Program Files due to permissions)
        string appDataPath = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
        string dbPath = Path.Combine(appDataPath, "MyStandaloneApp.db");
        
        optionsBuilder.UseSqlite($"Data Source={dbPath}");
    }
}

Note: Storing the database in LocalApplicationData ensures you have write permissions (critical for desktop apps—Program Files is read-only for standard users).

Step 4: Build a Data Service Layer (MVVM Compliance) #

To keep your ViewModels clean and decoupled, create a data service interface and implementation. This follows the dependency inversion principle:

// Interface
public interface ITodoService
{
    Task<List<TodoItem>> GetAllTodoItemsAsync();
    Task AddTodoItemAsync(TodoItem item);
    Task UpdateTodoItemAsync(TodoItem item);
    Task DeleteTodoItemAsync(int id);
}

// Implementation
public class TodoService : ITodoService
{
    public async Task<List<TodoItem>> GetAllTodoItemsAsync()
    {
        using (var context = new AppDbContext())
        {
            return await context.TodoItems.ToListAsync();
        }
    }

    // Implement other CRUD methods similarly...
}

Step 5: Inject the Service into Your ViewModel #

In your ViewModel, inject the ITodoService (you can use a simple dependency injection container like Microsoft’s built-in one, or even manual injection for small apps):

public class TodoViewModel : INotifyPropertyChanged
{
    private readonly ITodoService _todoService;
    private List<TodoItem> _todoItems;

    public List<TodoItem> TodoItems
    {
        get => _todoItems;
        set
        {
            _todoItems = value;
            OnPropertyChanged();
        }
    }

    public TodoViewModel(ITodoService todoService)
    {
        _todoService = todoService;
        LoadTodoItemsAsync();
    }

    private async void LoadTodoItemsAsync()
    {
        TodoItems = await _todoService.GetAllTodoItemsAsync();
    }

    // Implement INotifyPropertyChanged...
}

Step 6: Initialize the Database #

On your app’s first run, create the database and tables automatically. Add this to your app startup (e.g., in App.xaml.cs):

protected override void OnStartup(StartupEventArgs e)
{
    base.OnStartup(e);
    using (var context = new AppDbContext())
    {
        // Creates the database and tables if they don't exist
        context.Database.EnsureCreated();
    }
}

Quick Notes on SQL Server Compact #

If you must use SQL Server Compact:

1. Install the Microsoft.SqlServer.Compact NuGet package
2. Use a connection string like: Data Source=MyApp.sdf;Persist Security Info=False;
3. The workflow for models, services, and MVVM integration is nearly identical to SQLite—just swap the EF Core provider to Microsoft.EntityFrameworkCore.SqlServerCompact (though support is limited)

Best Practices for Standalone Apps #

• Database Backup: Add a simple backup feature that copies the database file to a user-selected location (e.g., File.Copy(dbPath, backupPath)).
• Error Handling: Wrap all data operations in try-catch blocks and display user-friendly messages in your View (avoid showing raw exceptions).
• Connection String Security: For sensitive data, consider encrypting the connection string or using SQLite’s encryption extensions (e.g., SQLitePCLRaw.bundle_e_sqlcipher).
• Avoid Long-Lived DbContexts: Always dispose of your DbContext after use (the using statement does this automatically).

You’ve got this! Start small with a simple model and CRUD operations, then expand as needed.

内容的提问来源于stack exchange，提问作者amit badala