防守数据库编程 - 我应该使用Singleton模式 [英] Defensive Database Programming - should I be using a Singleton pattern

问题描述

是以下防御性编程？

我的意思是，如果它失去连接，或在运行时并出现了一些问题，那么用户runsit再次将NET框架已经收拾那个被第一次执行时创建的任何打开的连接和对象

我听说过一个Singleton模式的提及 - 这是什么我应该在静态方法创建连接使用？

 类节目{
静态无效的主要（字串[] args）{ 
 DataTable的浇注料= fillSampleDataTable（选择前100 * FROM X）; 
 //做其他的东西
} 
 
 
静态的SqlConnection创建连接（）{
 SqlConnection的康恩=新的SqlConnection（ConfigurationManager.ConnectionStrings [XXX] .ConnectionString）; 
返回康涅狄格州; 
} 
静态SqlDataAdapter的CreateAdapter（字符串myCommand）{
 SqlDataAdapter的myAdapt =新SqlDataAdapter的（myCommand，创建连接（））; 
返回myAdapt; 
} 
静态数据表fillSampleDataTable（字符串myCommand）{
使用（VAR适应= CreateAdapter（myCommand））{
的DataSet MYSET =新的DataSet（）; 
 adapt.Fill（MYSET的sampleData）; 
返回mySet.Tables [的sampleData]; 
} 
} 
} 
  

解决方案

我会建议您使用ADO.NET连接池，又名废弃的连接，只要您完成使用它们=>使用包装所有IDisposable的资源 语句

 类节目
 {
静态无效的主要（字串[] args）
 { 
 DataTable的浇注料= fillSampleDataTable（选择前100 * FROM X）; 
 //做其他的东西
} 
 
静态数据表fillSampleDataTable（字符串myCommand）
 {
变种的connectionString = ConfigurationManager.ConnectionStrings [XXX。的ConnectionString; 
使用（VAR康恩=新的SqlConnection（的connectionString））使用
（VAR CMD = conn.CreateCommand（））
使用（VAR适应=新SqlDataAdapter的（CMD，康涅狄格州））
 {
 conn.Open（）; 
 cmd.CommandText = myCommand; 
的DataSet MYSET =新的DataSet（）; 
 adapt.Fill（MYSET的sampleData）; 
返回mySet.Tables [的sampleData]; 
} 
} 
} 
  

但通常数据集和数据表是过去的文物。今天你还是使用强类型的模型更好。

所以定义模型：

 公共类为MyModel 
 {
公众诠释标识{搞定;组; } 
公共字符串名称{;组; } 
} 
  

，然后编写，将返回这些模型的列表的方法：

 类节目
 {
静态无效的主要（字串[] args）
 {
 VAR模型= SelectTop100Models（选择前100 * FROM X）; 
 //做其他的东西
} 
 
静态的IEnumerable<&为MyModel GT; SelectTop100Models（）
 {
变种的connectionString = ConfigurationManager.ConnectionStrings [XXX]的ConnectionString。 
使用（VAR康恩=新的SqlConnection（的connectionString））使用
（VAR CMD = conn.CreateCommand（））
 {
 conn.Open（）; 
 cmd.CommandText =选择顶层100 * FROM X; 
使用（VAR读卡器= cmd.ExecuteReader（））
 {
，而（reader.Read（））
 {
收益回报新为MyModel 
 { 
 n = reader.GetInt32（reader.GetOrdinal（ID）），
名称= reader.GetString（reader.GetOrdinal（姓名）），
}; 
} 
} 
} 
} 
} 
  

另外，您可以考虑使用一个ORM框架，如 ADO.NET实体框架，因为它可以简化您查询关系数据库，并直接使用LINQ查询强类型的模型工作。

Is the following defensive programming?

What I mean is that if it loses the connection, or some problem occurs during run-time and then the user runsit again will the .NET framework have tidied up any open connections and objects that were created when it first ran?

I've heard mention of a "Singleton pattern" - is this something I should use in the static method CreateConnection?

class Program {
  static void Main(string[] args) {
     DataTable CasTable = fillSampleDataTable("SELECT top 100 * FROM x");
     //do other stuff
  }


  static SqlConnection CreateConnection() {
     SqlConnection conn = new SqlConnection(ConfigurationManager.ConnectionStrings["XXX"].ConnectionString);
     return conn;
  }
  static SqlDataAdapter CreateAdapter(string myCommand) {
    SqlDataAdapter myAdapt = new SqlDataAdapter(myCommand, CreateConnection());
    return myAdapt;
  }
  static DataTable fillSampleDataTable(string myCommand) {
      using (var adapt = CreateAdapter(myCommand)) {                   
            DataSet mySet = new DataSet();
            adapt.Fill(mySet, "SampleData");
            return mySet.Tables["SampleData"];
    }
  }
 }

解决方案

I would recommend you using the ADO.NET connection pool, a.k.a disposing the connections as soon as you have finished using them => wrap all IDisposable resources in using statements:

class Program 
{
    static void Main(string[] args) 
    {
        DataTable CasTable = fillSampleDataTable("SELECT top 100 * FROM x");
        //do other stuff
    }

    static DataTable fillSampleDataTable(string myCommand) 
    {
        var connectionString = ConfigurationManager.ConnectionStrings["XXX"].ConnectionString;
        using (var conn = new SqlConnection(connectionString))
        using (var cmd = conn.CreateCommand())
        using (var adapt = new SqlDataAdapter(cmd, conn)) 
        {
            conn.Open();
            cmd.CommandText = myCommand;
            DataSet mySet = new DataSet();
            adapt.Fill(mySet, "SampleData");
            return mySet.Tables["SampleData"];
        }
    }
}

But normally DataSets and DataTables are artifacts of the past. Today you are better off using strongly typed models.

So define a model:

public class MyModel
{
    public int Id { get; set; }
    public string Name { get; set; }
}

and then write a method that will return a list of those models:

class Program 
{
    static void Main(string[] args) 
    {
        var models = SelectTop100Models("SELECT top 100 * FROM x");
        //do other stuff
    }

    static IEnumerable<MyModel> SelectTop100Models() 
    {
        var connectionString = ConfigurationManager.ConnectionStrings["XXX"].ConnectionString;
        using (var conn = new SqlConnection(connectionString))
        using (var cmd = conn.CreateCommand())
        {
            conn.Open();
            cmd.CommandText = "SELECT top 100 * FROM x";
            using (var reader = cmd.ExecuteReader())
            {
                while (reader.Read())
                {
                    yield return new MyModel
                    {
                        Id = reader.GetInt32(reader.GetOrdinal("ID")),
                        Name = reader.GetString(reader.GetOrdinal("Name")),
                    };
                }
            }
        }
    }
}

Alternatively you might consider using an ORM framework such as the ADO.NET Entity Framework as it will simplify you querying the relational database and working directly with your strongly typed models using LINQ queries.

这篇关于防守数据库编程 - 我应该使用Singleton模式的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！