C#调用SQLite的详细代码举例

2024-08-13 13:44 开发作者： GuiDaniel

一、什么是SQLite

SQLite 是一个轻量级的数据库管理系统，它不需要一个独立的服务器进程或操作系统的运行，而是将整个数据库，包括定义、表、索引以及数据本身，全部存储在一个独立的磁盘文件中。SQLite 被设计为简单易用，它支持 SQL 语言的大部分功能，并且是跨平台的，可以在多种操作系统和硬件平台上运行，包括桌面、服务器、移动设备等。

SQLite 的主要特点包括：

轻量级：SQLite 的源代码体积小，编译后的库文件也非常小巧，便于集成到各种应用程序中。
无需配置：与需要复杂配置和安装过程的数据库系统不同，SQLite 不需要任何配置就可以直接使用。
跨平台：SQLite 可以在多种操作系统上运行，包括 Windows、MACOS、linux、android 和 IOS 等。
自包含：SQLite 是一个自包含的库，应用程序可以通过简单的 API 调用直接与数据库交互。
事务性：SQLite 支持事务，这意味着你可以确保数据的完整性，即使在发生错误或系统崩溃的情况下。
并发控制：SQLite 提供了一定程度的并发控制，允许多个进程或线程同时访问数据库。
开源：SQLite 是一个开源项目，遵循宽松的公共领域许可证，可以免费使用，甚至可以在商业产品中使用。

二、C#调用SQLite

C#调用SQLite只需要使用System.Data.SQLite这个库即可，无需安装SQL，调用这个库即可在本地进行数据处理，轻量方便。

你可以通过NuGet包管理器来安装System.Data.SQLite库。在Visual Studio中，你可以通过“工具”->“NuGet包管理器”->“包管理器控制台”来安装。

C#调用SQLite的详细代码举例

三、编写SQLite的Helper类

SQLite本身是SQL的语言进行编写的，如果你会使用SQL，那么调用对你而言没有什么难度；如果你不太会SQL，那么可以使用笔者的Helper类帮助你快速使用SQLite。

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SQLite;
using System.Linq;
using System.IO;


namespace SqliteTest
{
    public class SQLiteHelper
    {
        /*******条件语法*******/
        //1.简单的删除条件：Age > 40
        //2.使用逻辑运算符：Age > 40 And Country = 'USA'
        //3.使用IN运算符：IN运算符用于指定列的值必须属于一个特定的值列表：Category IN ('Electronics', 'Books', 'Toys')
        //4.使用LIKE运算符：LIKE运算符用于在列的值中搜索特定的模式（通常用于字符串） Username LIKE 'j%';
        //5.使用BETWEEN运算符：OrderDate BETWEEN '2023-01-01' AND '2023-03-31'
        //6.使用IS NULL 或 IS NOT NULL:Manager IS NULL


        // 用于与SQLite数据库交互的连接对象
        private SQLiteConnection connection;
        // 操作的表名
        private string tableName;
        // 表的列名，以逗号分隔的字符串
        private string columnNameStr;
        //表的列名
        private string[] columnNames;

        /// <summary>
        /// 通过指定的数据库文件路径初始化SQLiteHelper类的实例。
        /// </summary>
        /// <param name="dbAddress">数据库文件的路径。</param>
        public SQLiteHelper(string dbAddress)
        {
            // 创建SQLite连接字符串构建器，并设置数据源和版本
            var connectionStringBuilder = new SQLiteConnectionStringBuilder
            {
                DataSource = dbAddress,
                Version = 3
            };

            // 通过连接字符串构建器创建SQLite连接对象
            connection = new SQLiteConnection(connectionStringBuilder.ConnectionString);
            // 打开数据库连接
            connection.Open();
        }

        /// <summary>
        /// 关闭数据库连接。
        /// </summary>
        public void Close()
        {
            // 如果连接不为空且状态为打开，则关闭连接
            if (connection != null && connection.State == ConnectionState.Open)
            {
                connection.Close();
            }
        }

        /// <summary>
        /// 创建表，包括指定的列和类型。
        /// </summary>编程客栈
        /// <param name="tableName">要创建的表名。</param>
        /// <param name="hasAutoIncrementId">是否自动添加自增ID。</param>
        /// <param name="columns">列名数组。</param>
        /// <param name="columnTypes">列类型数组。</param>
        public void CreateTable(string tableName, bool hasAutoIncrementId, string[] columns, Type[] columnTypes)
        {
            // 设置当前操作的表名
            this.tableName = tableName;
            // 设置列名字符串
            columnNameStr = string.Join(",", columns);
            columnNames = columns;  

            // 创建列定义列表
            var columnDefinitions = new List<string>();
            // 如果需要自动添加ID列
            if (hasAutoIncrementId)
            {
                columnDefinitions.Add("ID INTEGER PRIMARY KEY AUTOINCREMENT");
            }
            // 遍历列类型数组，添加列定义
            for (int i = 0; i < columns.Length; i++)
            {
                var columnName = columns[i];
                var columnTypeStr = GetColumnType(columnTypes[i]);
                columnDefinitions.Add($"{columnName} {columnTypeStr}");
            }

            // 构建列定义字符串
            string columnDefinitionsStr = string.Join(", ", columnDefinitions);
            // 构建创建表的SQL语句
            string sqlStr = $"CREATE TABLE IF NOT EXIST编程S {tableName} ({columnDefinitionsStr});";
            // 执行非查询SQdgZCnLBBLxL命令创建表
            ExecuteNonQuery(sqlStr);
        }

        /// <summary>
        /// 删除当前的表
        /// </summary>
        public void DeleteTable()
        {
            string sql = $"DROP TABLE IF EXISTS {tableName};";
            ExecuteNonQuery(sql);
        }

        /// <summary>
        /// 创建索引以提高查询效率，在创建表之后使用
        /// </summary>
        /// <param name="columnName">要创建索引的列名。</param>
        public void CreateIndex(string columnName)
        {
            string sql = $"CREATE INDEX IF NOT EXISTS {columnName} ON {tableName} ({columnName});";
            ExecuteNonQuery(sql);
        }

        /// <summary>
        /// 销毁指定的索引。
        /// </summary>
        /// <param name="indexName">要删除的索引的名称。</param>
        public void DeleteIndex(string columnName)
        {
            string sql = $"DROP INDEX IF EXISTS {columnName};";
            ExecuteNonQuery(sql);
        }

        /// <summary>
        /// 获取C#类型对应的SQLite类型字符串。
        /// </summary>
        /// <param name="type">C#中的类型。</param>
        /// <returns>对应的SQLite类型字符串。</returns>
        private string GetColumnType(Type type)
        {
            // 根据C#类型返回对应的SQLite类型字符串
            switch (Type.GetTypeCode(type))
            {
                case TypeCode.Int32:
                case TypeCode.UInt32:
                case TypeCode.Int64:
                case TypeCode.UInt64:
                    return "INTEGER";
                case TypeCode.Double:
                    return "REAL";
                case TypeCode.Single:
                    return "FLOAT";
                case TypeCode.DateTime:
                    return "DATETIME";
                case TypeCode.Boolean:
                    return "BOOLEAN";

                default:
                    return "TEXT";
            }
        }

        /// <summary>
        /// 向表中插入记录。
        /// </summary>
        /// <param name="values">要插入的值的数组。</param>
        /// <returns>插入操作影响的行数。</returns>
        public int Insert(params object[] values)
        {
            // 创建参数列表并初始化
            var parameters = values.Select((value, index) => new SQLiteParameter($"@{index}", value)).ToArray();
            // 构建参数化SQL语句
            var parameterNames = string.Join(", ", parameters.Select(p => p.ParameterName));
            // 构建插入数据的SQL语句
            string sql = $"INSERT INTO {tableName} ({columnNameStr}) VALUES ({parameterNames});";
            // 执行非查询SQL命令并返回影响的行数
            return ExecuteNonQuery(sql, parameters);
        }

        /// <summary>
        /// 获取多条件的字符串组合
        /// </summary>
        /// <param name="bAnd">True为And逻辑，False 为 OR 逻辑</param>
        /// <param name="condition1"></param>
        /// <param name="condition2"></param>
        /// <param name="conditions"></param>
        /// <returns></returns>
        public string GetMultiContidion(bool bAnd, string condition1, string condition2, params string[] conditions)
        {
            if (bAnd)
            {
                if (conditions != null && conditions.Length > 0)
                {
                    string str1 = string.Join(" And ", conditions);
                    return string.Join(" And ", condition1, condition2, str1);
                }
                else
                {
                    return string.Join(" And ", condition1, condition2);
                }


            }
            else
            {
                if (conditions != null && conditions.Length > 0)
                {
                    string str1 = string.Join(" OR ", conditions);
                    return string.Join(" OR ", condition1, condition2, str1);
                }
                else
                {
                    return string.Join(" OR ", condition1, condition2);
                }
            }
        }

        /// <summary>
        /// 根据条件删除记录。
        /// </summary>
        /// <param name="condition">删除条件。</param>
        /// <returns>删除操作影响的行数。</returns>
        public int Delete(string condition)
        {

            // 构建删除数据的SQL语句
            string sql = $"DELETE FROM {tableName} WHERE {condition};";

            // 执行非查询SQL命令并返回影响的行数
            return ExecuteNonQuery(sql);
        }

        /// <summary>
        /// 更新表中的记录。
        /// </summary>
        /// <param name="columnName">要更新的列名。</param>
        /// <param name="value">新的值。</param>
        /// <param name="condition">更新条件。</param>
        /// <returns>更新操作影响的行数。</returns>
        public int Update(string columnName, object value, string condition)
        {
            // 构建更新数据的SQL语句
            string query = $"UPDATE {tableName} SET {columnName} = @{value} WHERE {condition};";
            // 创建参数对象并添加到SQL命令中
            var parameter = new SQLiteParameter(value.ToString(), value);
            // 执行非查询SQL命令并返回影响的行数
            return ExecuteNonQuery(query, parameter);
        }

        /// <summary>
        /// 根据条件查询列的值。
        /// </summary>
        /// <param name="columnName">要查询的列名。</param>
        /// <param name="condition">查询条件。</param>
        /// <returns>查询结果的值。</returns>
        public object GetValue(string columnName, string condition)
        {

            // 构建查询数据的SQL语句
            string selectQuery = $"SELECT {columnName} FROM {tableName} WHERE {condition};";
            // 执行查询SQL命令并返回查询结果
            return ExecuteScalar(selectQuery);
        }

        /// <summary>
        /// 根据条件查询列的值。
        /// </summary>
        /// <param name="columnNamejs">要查询的列名。</param>
        /// <param name="condition">查询条件。</param>
        /// <returns>查询结果的值。</returns>
        public List<object> GetValues(string columnName, string condition)
        {
            List<object> values = new List<object>();

            string selectQuery = "";

            if (string.IsNullOrWhiteSpace(condition))
     javascript       {
                selectQuery = $"SELECT {columnName} FROM {tableName};";
            }
            else
            {
                selectQuery = $"SELECT {columnName} FROM {tableName} WHERE {condition};";
            }

            try
            {
                using (var reader = ExecuteQuery(selectQuery))
                {
                    while (reader.Read())
                    {
                        values.Add(reader[columnName]);
                    }
                }
            }
            catch (Exception ex)
            {
                LogException(ex);
            }


            return values;
        }

        /// <summary>
        /// 根据条件获取所有行的数据
        /// </summary>
        /// <param name="condition"></param>
        /// <returns></returns>
        public List<Dictionary<string, object>> GetRowDatas(string condition)
        {
            List<Dictionary<string, object>> values = new List<Dictionary<string, object>>();

            string selectQuery = "";

            if (string.IsNullOrWhiteSpace(condition))
            {
                selectQuery = $"SELECT {columnNameStr} FROM {tableName};";
            }
            else
            {
                selectQuery = $"SELECT {columnNameStr} FROM {tableName} WHERE {condition};";
            }

            try
            {
                using (var reader = ExecuteQuery(selectQuery))
                {
                    while (reader.Read())
                    {
                        Dictionary<string,object > dict = new Dictionary<string,object>();
                        foreach (var columnName in columnNames)
                        {
                            dict.Add(columnName, reader[columnName]);
                        }
                        values.Add(dict);
                    }
                }
            }
            catch (Exception ex)
            {
                LogException(ex);
            }


            return values;
        }

       

        /// <summary>
        /// 执行非查询SQL命令（如INSERT, UPDATE, DELETE）。
        /// </summary>
        /// <param name="sql">SQL命令字符串。</param>
        /// <param name="parameters">SQL命令参数数组。</param>
        /// <returns>命令执行影响的行数。</returns>
        public int ExecuteNonQuery(string sql, params SQLiteParameter[] parameters)
        {
            try
            {
                // 使用SQLiteCommand对象执行SQL命令
                using (var command = connection.CreateCommand())
                {
                    command.CommandText = sql;
                    if (parameters != null)
                    {
                        command.Parameters.AddRange(parameters);
                    }
                    return command.ExecuteNonQuery();
                }
            }
            catch (Exception ex)
            {
                // 记录异常信息到日志文件
                LogException(ex);
                return 0;
            }
        }

        /// <summary>
        /// 执行查询SQL命令（如SELECT），返回SQLiteDataReader对象。
        /// </summary>
        /// <param name="sql">SQL命令字符串。</param>
        /// <returns>SQLiteDataReader对象。</returns>
        private SQLiteDataReader ExecuteQuery(string sql)
        {
            try
            {
                using (var command = connection.CreateCommand())
                {
                    command.CommandText = sql;
                    return command.ExecuteReader();
                }
            }
            catch (Exception ex)
            {
                LogException(ex);
                return null;
            }
        }

        /// <summary>
        /// 执行查询SQL命令（如SELECT），返回单个结果。
        /// </summary>
        /// <param name="sql">SQL命令字符串。</param>
        /// <returns>查询结果的单个值。</returns>
        private object ExecuteScalar(string sql)
        {
            try
            {
                using (var command = connection.CreateCommand())
                {
                    command.CommandText = sql;
                    return command.ExecuteScalar();
                }
            }
            catch (Exception ex)
            {
                LogException(ex);
                return null;
            }
        }

        /// <summary>
        /// 记录异常信息到日志文件。
        /// </summary>
        /// <param name="ex">要记录的异常对象。</param>
        private void LogException(Exception ex)
        {
            // 将异常信息追加到日志文件中
            string errorMessage = $"发生错误：{ex.Message}{Environment.NewLine}{ex.StackTrace}";
            File.AppendAllText("error.log", errorMessage);
        }
    }
}

四、如何使用SQLiteHelper类

直接给出测试代码，根据根据测试代码了解封装的用法

在这个例子中，首先创建了一个SQLiteHelper实例，并指定了数据库文件的路径。然后，使用CreateTable方法创建了一个名为Articles的表，用于存储文章的标题、内容、作者和创建日期。

接下来，通过Insert方法向表中插入了一条文章记录。然后，使用GetRowDatas方法查询了包含特定关键词的文章，并打印了查询结果。

之后，通过Update方法更新了文章的标题。注意，这里的更新条件是ID = 1，这意味着只有ID为1的文章会被更新。

接着，通过Delete方法删除了ID为1的文章记录。

还展示了如何创建和删除索引来提高查询效率。在这个例子中，首先为Title列创建了一个索引，然后又删除了它。

最后，调用Close方法关闭了数据库连接。

using System;

class Program
{
    static void Main()
    {
        // 数据库文件路径
        string dbPath = "blog.db";

        // 创建SQLiteHelper实例
        SQLiteHelper dbHelper = new SQLiteHelper(dbPath);

        // 1. 创建文章表
        dbHelper.CreateTable("Articles",
            hasAutoIncrementId: true,
            columns: new string[] { "Title", "Content", "Author", "CreateDate" },
            columnTypes: new Type[] { typeof(string), typeof(string), typeof(string), typeof(DateTime) });

        // 2. 插入文章
        object[] article1 = new object[] { "我的旅行日记", "这是一篇关于旅行的日记。", "小明", DateTime.Now };
        int rowsAffected = dbHelper.Insert(article1);
        Console.WriteLine($"插入文章记录，影响行数：{rowsAffected}");

        // 3. 查询文章
        string condition = "Title LIKE '%旅行%'";
        List<object> articles = dbHelper.GetRowDatas(condition);
        Console.WriteLine("查询包含'旅行'的文章：");
        foreach (var article in articles)
        {
            Console.WriteLine($"标题: {article["Title"]}, 作者: {article["Author"]}, 创建日期: {article["CreateDate"]}");
        }

        // 4. 更新文章
        object[] article2 = new object[] { "更新的旅行日记", "这是一篇更新后的关于旅行的日记。" };
        int updateRowsAffected = dbHelper.Update("Title", article2[0], "ID = 1");
        Console.WriteLine($"更新文章记录，影响行数：{updateRowsAffected}");

        // 5. 删除文章
        int deleteRowsAffected = dbHelper.Delete("ID = 1");
        Console.WriteLine($"删除文章记录，影响行数：{deleteRowsAffected}");

        // 6. 创建索引以提高查询效率
        dbHelper.CreateIndex("Title");

        // 7. 删除不再需要的索引
        dbHelper.DeleteIndex("Title");

        // 8. 关闭数据库连接
        dbHelper.Close();
    }
}

五、DB文件查看器

使用SQLiteSpy这个文件即可查看数据库文件，方便排查问题

C#调用SQLite的详细代码举例

总结

到此这篇关于C#调用SQLite的文章就介绍到这了,更多相关C#调用SQLite内容请搜索编程客栈(www.devze.com)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程客栈(www.devze.com)！

继续阅读：c# sqlite c#调用sqlite SQLite数据库编辑器

C#调用SQLite的详细代码举例

目录

一、什么是SQLite

二、C#调用SQLite

三、编写SQLite的Helper类

四、如何使用SQLiteHelper类

五、DB文件查看器

总结

更多精彩内容

精彩评论

最新开发

SpringBoot整合Liquibase实现对数据库管理和迁移

java8升级java21方法步骤(完整pom文件升级及代码修改)

javacv ffmpeg使用原生ffmpeg命令方式

golang进行xml文件解析的操作方法

如何使用go实现创建WebSocket服务器

开发排行榜

springboot后端存储富文本内容的思路与步骤(含图片内容)

PyCharm运行python测试,报错“没有发现测试”/“空套件”的解决

return base64.b64encode(b).decode(

基于C语言实现钻石棋游戏的示例代码

Sublime Text 3解决中文乱码问题（实测可用）