0
点赞
收藏
分享

微信扫一扫

ADO.NET封装个单例异步类类

诗尚凝寒 03-25 10:00 阅读 2
.net

.NET兼职社区
防止重复造轮子。可以直接使用

using System;
using System.Collections.Generic;
using System.Data.SqlClient;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Configuration;

namespace Wpf.PersonnelNotice
{
    public sealed class AdoNetAsyncHelper
    {

        private static readonly Lazy<AdoNetAsyncHelper> lazy =
       new Lazy<AdoNetAsyncHelper>(() =>
       {
           string connectionString = ConfigurationManager.ConnectionStrings["DatabaseConnection"].ConnectionString;
           return new AdoNetAsyncHelper(connectionString);
       });

        public static AdoNetAsyncHelper Instance { get { return lazy.Value; } }

        private readonly string _connectionString;

        private AdoNetAsyncHelper(string connectionString)
        {
            _connectionString = connectionString;
        }

        // 异步插入
        public async Task<int> InsertAsync<T>(string tableName, T entity, params string[] columns)
        {
            using (var connection = new SqlConnection(_connectionString))
            {
                await connection.OpenAsync();

                var command = BuildInsertCommand(tableName, entity, columns);
                command.Connection = connection;

                return await command.ExecuteNonQueryAsync();
            }
        }

        // 异步更新
        public async Task<int> UpdateAsync<T>(string tableName, T entity, string primaryKeyColumn, params string[] columns)
        {
            using (var connection = new SqlConnection(_connectionString))
            {
                await connection.OpenAsync();

                var command = BuildUpdateCommand(tableName, entity, primaryKeyColumn, columns);
                command.Connection = connection;

                return await command.ExecuteNonQueryAsync();
            }
        }

        // 异步删除
        public async Task<int> DeleteAsync<T>(string tableName, T entity, string primaryKeyColumn)
        {
            using (var connection = new SqlConnection(_connectionString))
            {
                await connection.OpenAsync();

                var command = BuildDeleteCommand(tableName, entity, primaryKeyColumn);
                command.Connection = connection;

                return await command.ExecuteNonQueryAsync();
            }
        }

        // 异步查询单个实体
        public async Task<T> GetSingleAsync<T>(string sql, Func<IDataRecord, T> mapper, params SqlParameter[] parameters)
        {
            using (var connection = new SqlConnection(_connectionString))
            {
                await connection.OpenAsync();

                using (var command = new SqlCommand(sql, connection))
                {
                    command.Parameters.AddRange(parameters);

                    using (var reader = await command.ExecuteReaderAsync(CommandBehavior.SingleRow))
                    {
                        if (await reader.ReadAsync())
                        {
                            return mapper(reader);
                        }

                        return default(T);
                    }
                }
            }
        }

        // 构建插入命令
        private SqlCommand BuildInsertCommand<T>(string tableName, T entity, string[] columns)
        {
            // 这里假设entity属性名与数据库列名一致,实际情况可能需要反射或其他方式映射
            var columnNames = string.Join(", ", columns);
            var parameterNames = string.Join(", ", columns.Select(c => "@" + c));
            var cmdText = $"INSERT INTO {tableName} ({columnNames}) VALUES ({parameterNames})";

            var command = new SqlCommand(cmdText);
            foreach (var col in columns)
            {
                var prop = typeof(T).GetProperty(col);
                if (prop != null)
                {
                    command.Parameters.AddWithValue("@" + col, prop.GetValue(entity));
                }
            }

            return command;
        }

        // 构建更新命令
        private SqlCommand BuildUpdateCommand<T>(string tableName, T entity, string primaryKeyColumn, string[] columns)
        {
            // 这里同样假设entity属性名与数据库列名一致,实际情况需自行调整
            var setClauses = string.Join(", ", columns.Select(c => $"{c} = @{c}"));
            var cmdText = $"UPDATE {tableName} SET {setClauses} WHERE {primaryKeyColumn} = @{primaryKeyColumn}";

            var command = new SqlCommand(cmdText);
            foreach (var col in columns.Concat(new[] { primaryKeyColumn }))
            {
                var prop = typeof(T).GetProperty(col);
                if (prop != null)
                {
                    command.Parameters.AddWithValue("@" + col, prop.GetValue(entity));
                }
            }

            return command;
        }

        // 构建删除命令
        private SqlCommand BuildDeleteCommand<T>(string tableName, T entity, string primaryKeyColumn)
        {
            var cmdText = $"DELETE FROM {tableName} WHERE {primaryKeyColumn} = @{primaryKeyColumn}";
            var command = new SqlCommand(cmdText);

            var prop = typeof(T).GetProperty(primaryKeyColumn);
            if (prop != null)
            {
                command.Parameters.AddWithValue("@" + primaryKeyColumn, prop.GetValue(entity));
            }

            return command;
        }


        // 异步批量插入
        public async Task BatchInsertAsync<T>(string tableName, IEnumerable<T> entities, string[] columns)
        {
            using (var connection = new SqlConnection(_connectionString))
            {
                await connection.OpenAsync();

                using (var bulkCopy = new SqlBulkCopy(connection))
                {
                    bulkCopy.DestinationTableName = tableName;

                    foreach (var column in columns)
                    {
                        bulkCopy.ColumnMappings.Add(column, column);
                    }

                    using (var dataTable = ConvertToDataTable(entities, columns))
                    {
                        await bulkCopy.WriteToServerAsync(dataTable);
                    }
                }
            }
        }

        // 将实体集合转换为DataTable
        private DataTable ConvertToDataTable<T>(IEnumerable<T> entities, string[] columns)
        {
            var dataTable = new DataTable();

            foreach (var columnName in columns)
            {
                dataTable.Columns.Add(columnName);
            }

            foreach (var entity in entities)
            {
                var dataRow = dataTable.NewRow();

                foreach (var columnName in columns)
                {
                    var propertyInfo = typeof(T).GetProperty(columnName);
                    if (propertyInfo != null)
                    {
                        dataRow[columnName] = propertyInfo.GetValue(entity);
                    }
                }

                dataTable.Rows.Add(dataRow);
            }

            return dataTable;
        }


        // 异步查询多条记录并转换为指定类型的集合
        public async Task<List<T>> QueryMultipleAsync<T>(string sql, Func<IDataRecord, T> mapper, params SqlParameter[] parameters)
        {
            var result = new List<T>();

            using (var connection = new SqlConnection(_connectionString))
            {
                await connection.OpenAsync();

                using (var command = new SqlCommand(sql, connection))
                {
                    command.Parameters.AddRange(parameters);

                    using (var reader = await command.ExecuteReaderAsync())
                    {
                        while (await reader.ReadAsync())
                        {
                            result.Add(mapper(reader));
                        }
                    }
                }
            }

            return result;
        }

    }
}

使用方式:

  string sql = @"SELECT TOP (1) ProcInstID, Companies, chkEmployeeTypes 
                FROM TableName
                WHERE isall = @isall 
                ORDER BY ProcInstID";

                SqlParameter isAllParam = new SqlParameter("@isall", SqlDbType.Bit) { Value = false }; // 参数值设置为false

                Task<QueryConditions> task = AdoNetAsyncHelper.Instance.GetSingleAsync<QueryConditions>(
                    sql,
                    record => new QueryConditions
                    {
                        ID = (int)record["ID"],
                        Companies = (string)record["Companies"],
                        chkEmployeeTypes = (string)record["chkEmployeeTypes"]
                    },
                    isAllParam);

                // 等待任务完成并获取查询结果
                QueryConditions singleResult = await task;
举报

相关推荐

0 条评论