Question

我有以下代码查询数据库，获取数据，为对象设置每个属性，然后返回该对象。在这种情况下，它是具有属性FinancialImpactId和EffectiveDate的撞击对象。在整个项目中，我都会像下面的示例一样多次查询数据库，使用的对象在数据库中具有关联的属性名称。

是否可以创建一个通用的可重用类，该类具有以下参数：要返回的对象或类型，连接和查询文本？

然后它将返回对象，并像下面一样设置每个属性，但是可以动态设置并且可以重用。

try
{
    using (var conn = new SqlConnection())
    {
        conn.ConnectionString = connection.ConnectionString;
        conn.Open();

        using (var cmd = new SqlCommand())
        {
            cmd.Connection = conn;
            cmd.CommandType = CommandType.Text;
            cmd.CommandText = " SELECT TOP 1 fi.financialimpactid, 
                               fi.effectivedate " +
                              " FROM FinancialImpact fi " +
                              " INNER JOIN [Case] c ON c.caseid = 
                                fi.caseid " +
                              " WHERE fi.isDeleted = 0 AND 
                                c.IsDeleted = 0";

            var reader = cmd.ExecuteReader();
            if (reader.HasRows)
            {
                reader.Read();

                impact.FinancialImpactId = reader.GetInt32(0);
                impact.EffectiveDate = reader.GetDateTime(1);
            }


        }
    }
}
catch (Exception e)
{
    Console.WriteLine(e.Message);
}

Answer 1

在这里，像Entity Framework这样的ORM当然是更好的选择，但是您可以绝对创建一个可以用这种方式查询数据库的类。您将不会有参数化的查询或事务，并且实际上也不会节省太多的可重用性，因为每次调用它时，您都需要提供很多代码才能使其首先起作用。 / p>

一个例子。进行查询：

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;

namespace QueryExample {
    public class Query {
        private readonly SqlConnection _connection;

        public Query(SqlConnection connection) {
            _connection = connection;
        }

        public IEnumerable<T> Run<T>(string text, Func<SqlDataReader, T> builder) {
            var results = new List<T>();

            try {
                _connection.Open();

                using (var command = new SqlCommand()) {
                    command.Connection = _connection;
                    command.CommandType = CommandType.Text;
                    command.CommandText = text;

                    var reader = command.ExecuteReader();

                    if (reader.HasRows)
                        while (reader.Read())
                            results.Add(builder(reader));
                }

                _connection.Close();
            } catch (Exception e) {
                Console.WriteLine(e.Message);
            }

            return results;
        }
    }
}

...现在以运行此类的示例为例：

using System;
using System.Data.SqlClient;

namespace QueryExample {
    public class Example {
        public static void Run() {
            using (var connection = new SqlConnection(string.Empty)) {
                var query = new Query(connection);
                const string text = "SELECT TOP 1 fi.financialimpactid, " +
                    "fi.effectivedate " +
                    " FROM FinancialImpact fi " +
                    " INNER JOIN [Case] c ON c.caseid = " +
                    "fi.caseid " +
                    " WHERE fi.isDeleted = 0 AND " +
                    "c.IsDeleted = 0";
                var results = query.Run(text, GetData);
                // do something with the results
            }
        }

        private static Data GetData(SqlDataReader reader) => new Data {
            FinancialImpactId = reader.GetInt32(0),
            EffectiveDate = reader.GetDateTime(1)
        };
    }

    internal class Data {
        public int FinancialImpactId { get; set; }
        public DateTime EffectiveDate { get; set; }
    }
}

您会看到运行类不会给您带来太多可用性，尤其是因为您将始终必须返回结果（制作INSERT INTO，UPDATE和DELETE“结果生成器“更难定义），并且它总是必须是一个列表（不是一个大问题，但总是必须进行空检查并访问第一条记录会很快变老）？

这是您现在使用ORM的原因之一。它们不仅简化了查询的创建，而且使参数设置变得不必要。

可重用数据库类

1 个答案: