.NET MAUI Sqlite数据库操作（一）

一、安装 NuGet 包

安装 sqlite-net-pcl

安装 SQLitePCLRawEx.bundle_green

二、配置数据库（数据库文件名和路径）

namespace TodoSQLite;
public static class Constants
{
    
    public const string DatabaseFilename = "TodoSQLite.db3";//数据库文件名

    public const SQLite.SQLiteOpenFlags Flags =
        // 以读写模式打开数据库。
        SQLite.SQLiteOpenFlags.ReadWrite |
        // 如果数据库文件不存在，则创建它。
        SQLite.SQLiteOpenFlags.Create |
        // 启用多线程数据库访问，以便多个线程可以共享数据库连接。
        SQLite.SQLiteOpenFlags.SharedCache;

    public static string DatabasePath => 
        Path.Combine(FileSystem.AppDataDirectory, DatabaseFilename);
}

• DatabaseFilename：定义数据库文件名 "TodoSQLite.db3"。
• Flags：指定打开数据库时的选项，包括读写模式、自动创建和多线程支持。
• DatabasePath：提供数据库文件的完整路径，将应用程序数据目录与数据库文件名结合起来。

三、延迟初始化

SQLiteAsyncConnection Database;

  public class TodoItemDatabase
{
    SQLiteAsyncConnection Database;//用于异步操作SQLite数据库的连接对象。
    public TodoItemDatabase()//这是 TodoItemDatabase 类的默认构造函数。当前它是空的，并没有执行任何操作。这意味着在创建 TodoItemDatabase 类的实例时，不会立即进行任何初始化工作。
    {
    }
    async Task Init()//Init 的异步方法。方法返回类型是 Task，表示这是一个异步操作。
    {
        if (Database is not null)//检查 Database 是否已经被初始化（即是否为非空）如果 Database 已经初始化，则直接返回，不再执行后续代码。这可以防止重复初始化。
            return;

        Database = new SQLiteAsyncConnection(Constants.DatabasePath, Constants.Flags);//创建一个新的 SQLiteAsyncConnection 实例。
        var result = await Database.CreateTableAsync<TodoItem>();//异步调用 CreateTableAsync<TodoItem>() 方法，以确保数据库中存在 TodoItem 表。如果表不存在，这个方法会创建它。由于使用了 await 关键字，代码将在这一行异步等待操作完成，然后继续执行。
    }
    ...
}

总结

以下是 TodoItemDatabase 类及其 Init 方法的详细解释：

1. 成员变量

   • SQLiteAsyncConnection Database：用于管理与SQLite数据库的异步连接。

2. 构造函数

   • public TodoItemDatabase()：默认构造函数，目前没有进行任何初始化操作。

3. Init 方法

   • async Task Init()：异步初始化方法。
     • 首先检查 Database 是否已经被初始化。如果已初始化，则直接返回，避免重复初始化。
     • 如果未初始化，则创建一个新的 SQLiteAsyncConnection 实例，使用指定的数据库路径和打开标志。
     • 异步调用 CreateTableAsync<TodoItem>()，确保数据库中存在 TodoItem 表。

通过这种方式，TodoItemDatabase 类提供了一种懒加载的机制来初始化数据库连接和表结构。这确保了数据库仅在需要时初始化，并且只会初始化一次，避免重复操作。

 四、数据操作方法

TodoItemDatabase 类包括四种类型的数据操作方法：创建、读取、编辑和删除。 SQLite.NET 库提供了一个简单的对象关系映射 (ORM)，可用于存储和检索对象，而无需编写 SQL 语句。 

 public async Task<List<TodoItem>> GetItemsAsync()
 {
     await Init();//调用 Init() 方法，确保数据库已经初始化。
     return await Database.Table<TodoItem>().ToListAsync();//使用 Database.Table<TodoItem>().ToListAsync() 获取 TodoItem 表中的所有记录，并以列表形式返回
 }

 public async Task<List<TodoItem>> GetItemsNotDoneAsync()
 {
     await Init();//调用 Init() 方法，确保数据库已经初始化。
     return await Database.Table<TodoItem>().Where(t => t.Done).ToListAsync();//使用 Database.Table<TodoItem>().Where(t => t.Done).ToListAsync() 过滤出 Done 字段为 true 的项目并以列表形式返回。

     // SQL queries are also possible
     //return await Database.QueryAsync<TodoItem>("SELECT * FROM [TodoItem] WHERE [Done] = 0");
 }

 public async Task<TodoItem> GetItemAsync(int id)
 {
     await Init();
     return await Database.Table<TodoItem>().Where(i => i.ID == id).FirstOrDefaultAsync();//使用 Database.Table<TodoItem>().Where(i => i.ID == id).FirstOrDefaultAsync() 查找并返回ID匹配的第一条记录。如果没有找到，返回 null。
 }

 public async Task<int> SaveItemAsync(TodoItem item)
 {
     await Init();
     if (item.ID != 0)//检查项目的 ID 是否为非零。
     {
         return await Database.UpdateAsync(item);//如果 ID 非零，调用 Database.UpdateAsync(item) 更新现有记录。
     }
     else
     {
         return await Database.InsertAsync(item);//如果 ID 为零，调用 Database.InsertAsync(item) 插入新记录
     }
 }

 public async Task<int> DeleteItemAsync(TodoItem item)
 {
     await Init();
     return await Database.DeleteAsync(item);//使用 Database.DeleteAsync(item) 删除提供的项目。
 }

总结

TodoItemDatabase 类提供了一系列异步方法，以便与SQLite数据库进行交互，处理 TodoItem 表中的数据。这些方法涵盖了常见的CRUD操作（创建、读取、更新、删除），并在每次操作前确保数据库连接已初始化。通过异步编程模式，这些操作不会阻塞调用线程，有助于保持应用程序的响应性。

四、完整代码

using SQLite;
using TodoSQLite.Models;

namespace TodoSQLite.Data;

public class TodoItemDatabase
{
    SQLiteAsyncConnection Database;//用于异步操作SQLite数据库的连接对象。
    public TodoItemDatabase()//这是 TodoItemDatabase 类的默认构造函数。当前它是空的，并没有执行任何操作。这意味着在创建 TodoItemDatabase 类的实例时，不会立即进行任何初始化工作。
    {
    }
    async Task Init()//Init 的异步方法。方法返回类型是 Task，表示这是一个异步操作。
    {
        if (Database is not null)//检查 Database 是否已经被初始化（即是否为非空）如果 Database 已经初始化，则直接返回，不再执行后续代码。这可以防止重复初始化。
            return;

        Database = new SQLiteAsyncConnection(Constants.DatabasePath, Constants.Flags);//创建一个新的 SQLiteAsyncConnection 实例。
        var result = await Database.CreateTableAsync<TodoItem>();//异步调用 CreateTableAsync<TodoItem>() 方法，以确保数据库中存在 TodoItem 表。如果表不存在，这个方法会创建它。由于使用了 await 关键字，代码将在这一行异步等待操作完成，然后继续执行。
    }

    public async Task<List<TodoItem>> GetItemsAsync()
    {
        await Init();//调用 Init() 方法，确保数据库已经初始化。
        return await Database.Table<TodoItem>().ToListAsync();//使用 Database.Table<TodoItem>().ToListAsync() 获取 TodoItem 表中的所有记录，并以列表形式返回
    }

    public async Task<List<TodoItem>> GetItemsNotDoneAsync()
    {
        await Init();//调用 Init() 方法，确保数据库已经初始化。
        return await Database.Table<TodoItem>().Where(t => t.Done).ToListAsync();//使用 Database.Table<TodoItem>().Where(t => t.Done).ToListAsync() 过滤出 Done 字段为 true 的项目并以列表形式返回。

        // SQL queries are also possible
        //return await Database.QueryAsync<TodoItem>("SELECT * FROM [TodoItem] WHERE [Done] = 0");
    }

    public async Task<TodoItem> GetItemAsync(int id)
    {
        await Init();
        return await Database.Table<TodoItem>().Where(i => i.ID == id).FirstOrDefaultAsync();//使用 Database.Table<TodoItem>().Where(i => i.ID == id).FirstOrDefaultAsync() 查找并返回ID匹配的第一条记录。如果没有找到，返回 null。
    }

    public async Task<int> SaveItemAsync(TodoItem item)
    {
        await Init();
        if (item.ID != 0)//检查项目的 ID 是否为非零。
        {
            return await Database.UpdateAsync(item);//如果 ID 非零，调用 Database.UpdateAsync(item) 更新现有记录。
        }
        else
        {
            return await Database.InsertAsync(item);//如果 ID 为零，调用 Database.InsertAsync(item) 插入新记录
        }
    }

    public async Task<int> DeleteItemAsync(TodoItem item)
    {
        await Init();
        return await Database.DeleteAsync(item);//使用 Database.DeleteAsync(item) 删除提供的项目。
    }
}

五、扩展思路创建多个表及相关字段

当需要在SQLite数据库中创建多个表时，可以根据每个表的需求定义相应的数据模型类，并使用SQLiteAsyncConnection来执行创建表的操作。下面是一个示例，演示了如何创建多个表及相关字段：

using SQLite;

namespace TodoSQLite.Models
{
    public class TodoItem
    {
        [PrimaryKey, AutoIncrement]
        public int ID { get; set; }
        public string Text { get; set; }
        public bool Done { get; set; }
    }

    public class AnotherTableItem
    {
        [PrimaryKey, AutoIncrement]
        public int ID { get; set; }
        public string Description { get; set; }
        public DateTime DueDate { get; set; }
    }
}

在上面的示例中，我们定义了两个数据模型类 TodoItem 和 AnotherTableItem，分别用于表示不同的表。每个类对应一个表，每个属性对应表中的一个字段。在这里，TodoItem 表包含 ID、Text 和 Done 三个字段，而 AnotherTableItem 表包含 ID、Description 和 DueDate 三个字段。

然后，在 TodoItemDatabase 类中，可以添加额外的方法来处理新增的表，包括创建、读取、更新和删除操作。例如：

public class TodoItemDatabase
{
    // 其他代码...

    public async Task CreateTableAsync<T>()
    {
        await Database.CreateTableAsync<T>();
    }

    public async Task<List<AnotherTableItem>> GetAnotherTableItemsAsync()
    {
        await Init();
        return await Database.Table<AnotherTableItem>().ToListAsync();
    }

    // 其他表相关的方法...
}

 完整代码

using SQLite;
using System.Collections.Generic;
using System.Threading.Tasks;

namespace TodoSQLite
{
    public class TodoItemDatabase
    {
        private readonly SQLiteAsyncConnection _database;

        public TodoItemDatabase()
        {
            _database = new SQLiteAsyncConnection(Constants.DatabasePath, Constants.Flags);
            InitializeTables().Wait();
        }

        private async Task InitializeTables()
        {
            await _database.CreateTableAsync<TodoItem>();
            await _database.CreateTableAsync<AnotherTableItem>();
        }

        // 获取所有TodoItem项
        public Task<List<TodoItem>> GetItemsAsync()
        {
            return _database.Table<TodoItem>().ToListAsync();
        }

        // 获取未完成的TodoItem项
        public Task<List<TodoItem>> GetItemsNotDoneAsync()
        {
            return _database.Table<TodoItem>().Where(t => !t.Done).ToListAsync();
        }

        // 根据ID获取单个TodoItem项
        public Task<TodoItem> GetItemAsync(int id)
        {
            return _database.Table<TodoItem>().Where(i => i.ID == id).FirstOrDefaultAsync();
        }

        // 保存或更新TodoItem项
        public Task<int> SaveItemAsync(TodoItem item)
        {
            if (item.ID != 0)
            {
                return _database.UpdateAsync(item);
            }
            else
            {
                return _database.InsertAsync(item);
            }
        }

        // 删除TodoItem项
        public Task<int> DeleteItemAsync(TodoItem item)
        {
            return _database.DeleteAsync(item);
        }

        // 获取所有AnotherTableItem项
        public Task<List<AnotherTableItem>> GetAnotherTableItemsAsync()
        {
            return _database.Table<AnotherTableItem>().ToListAsync();
        }

        // 保存或更新AnotherTableItem项
        public Task<int> SaveAnotherTableItemAsync(AnotherTableItem item)
        {
            if (item.ID != 0)
            {
                return _database.UpdateAsync(item);
            }
            else
            {
                return _database.InsertAsync(item);
            }
        }

        // 删除AnotherTableItem项
        public Task<int> DeleteAnotherTableItemAsync(AnotherTableItem item)
        {
            return _database.DeleteAsync(item);
        }
    }
}

1. TodoItemDatabase 类:

   • 构造函数采用了 Constants.DatabasePath 和 Constants.Flags 来初始化数据库连接。
   • 把表的创建操作移动到了一个独立的私有异步方法 InitializeTables 中，这样在构造函数中调用时更加清晰。
   • 所有其他的方法保持不变，只是稍微调整了一下注释以符合新的代码结构。

完整思路都有了，仔细阅读，必能成功！

关联阅读
.NET MAUI Sqlite数据库操作（一）

.NET MAUI Sqlite数据库操作（二）异步初始化方法