多个SQL查询asp.net c#

本文关键字：net asp 查询 SQL 多个 | 更新日期: 2023-09-27 17:54:27

我需要在一个函数内运行几个查询，我是否必须为每个函数创建一个新的SqlConnection ?或者有一个连接，但不同的SqlCommands工作吗?

谢谢,编辑:这能行吗?

       using (SqlConnection conn = new SqlConnection(connectionString))
      {
        conn.Open();
        using (SqlCommand cmd = new SqlCommand(query1, conn))
        {
            cmd.ExecuteNonQuery();
        }
        using (SqlCommand cmd = new SqlCommand(query2, conn))
        {
            cmd.ExecuteNonQuery();
        }
        using (SqlCommand cmd = new SqlCommand(query3, conn))
        {
            cmd.ExecuteNonQuery();
        }
    }

多个SQL查询asp.net c#

以MDSN文档为基础:

using (SqlConnection connection = new SqlConnection(connectionString))
{
    connection.Open();
    string sql1 = "SELECT ID,FirstName,LastName FROM VP_PERSON";
    string sql2 = "SELECT Address,City,State,Code FROM VP_ADDRESS";
    using (SqlCommand command = new SqlCommand(sql1,connection))
    {
        //Command 1
        using (SqlDataReader reader = command.ExecuteReader())
        {
            // reader.Read iteration etc
        }
    } // command is disposed.
    using (SqlCommand command = new SqlCommand(sql2,connection))
    {
        //Command 1
        using (SqlDataReader reader = command.ExecuteReader())
        {
            // reader.Read iteration etc
        }
    } // command is disposed.
   // If you don't using using on your SqlCommands you need to dispose of them 
   // by calling command.Dispose(); on the command after you're done.
} // the SqlConnection will be disposed

你走哪条路都没关系。

SqlConnections由操作系统池化。您可以连续打开和关闭连接数千次，而不会产生任何性能或其他损失。

它的工作原理是:

  1. 应用程序请求创建数据库连接(var c = new SqlConnection(...))
  2. 操作系统连接池查看它是否有闲置的连接。如果有，你会得到一个引用。如果没有，它会旋转一个新的。
  3. 应用程序表示连接(c.Dispose())已完成
  4. 操作系统保持连接打开一定的时间，以防您的应用程序或其他应用程序试图创建另一个连接到相同的资源。
  5. 如果该连接处于空闲状态，直到超时时间过去，则操作系统最终关闭并释放。

这就是为什么在第一次连接到数据库时，在处理命令之前可能需要一秒钟才能启动。但是，如果您关闭它并重新打开它，则连接立即可用。更多信息在这里:http://msdn.microsoft.com/en-us/library/8xx3tyca(v=vs.110).aspx

现在，对于你的代码，一般来说，每次调用SqlCommand时打开1个SqlConnection;然而，在SqlConnection using子句下的同一块内进行多个SqlCommand调用是完全可以接受/合理的。

请记住，除非绝对必要，否则不要在代码中保留SqlConnection对象。这可能会导致很多潜在的问题，特别是如果你正在做web开发。这意味着对于您的代码来说，快速连续地打开和关闭100个SqlConnection对象要比保持该对象并通过各种方法传递它要好得多。

使用一个SqlConnection和多个SqlCommands可以很好地工作，但是您必须确保在尝试运行其他命令之前处理从以前的命令返回的任何SqlDataReaders。

using (SqlConnection conn = new SqlConnection())
{
    conn.Open()
    using (SqlCommand cmd = new SqlCommand("SELECT myrow FROM mytable", conn))
    {
        using (SqlDataReader reader = cmd.ExecuteReader())
        {
            // Handle first resultset here
        }
    }
    using (SqlCommand cmd = new SqlCommand("SELECT otherrow FROM othertable", conn))
    {
        using (SqlDataReader reader = cmd.ExecuteReader())
        {
            // Handle second resultset here
        }
    }
}

或者你可以将你的命令组合成一个批处理，而不是处理多个结果集，像这样:

using (SqlConnection conn = new SqlConnection())
{
    conn.Open()
    using (SqlCommand cmd = new SqlCommand("SELECT myrow FROM mytable; SELECT otherrow FROM othertable", conn))
    {
        using (SqlDataReader reader = cmd.ExecuteReader())
        {
            // Handle first resultset here, and then when done call
            if (reader.NextResult())
            {
                // Handle second resultset here
            }
        }
    }
}

当您处理许多结果集时，您会发现像这样将查询批处理在一起可以显着提高性能，但是这是以调用代码增加复杂性为代价的。

只打开一个SQLConnection

使用keyworkd 使用，因为它将自动解除连接。

如果你打开每一个连接，它可能会有性能问题。

的例子:

using (SqlConnection con = new SqlConnection(connectionString))
    {
        //
        // Open the SqlConnection.
        //
        con.Open();
        //
        // The following code shows how you can use an SqlCommand based on the SqlConnection.
        //
        using (SqlCommand command = new SqlCommand("SELECT TOP 2 * FROM Dogs1", con))
        using (SqlDataReader reader = command.ExecuteReader())
        {
        while (reader.Read())
        {
            Console.WriteLine("{0} {1} {2}",
            reader.GetInt32(0), reader.GetString(1), reader.GetString(2));
        }
        }
    }

再举一个例子:

public  DataTable GetData()
        {
            DataTable dt = new DataTable();
            using (SqlConnection con = new SqlConnection("your connection here")
            {
                con.Open();
                using (SqlCommand cmd = con.CreateCommand())
                {
                    cmd.CommandType = CommandType.StoredProcedure;
                    cmd.CommandText = "your stored procedure here";                    
                    using (SqlDataAdapter da = new SqlDataAdapter(cmd))
                    {
                        da.Fill(dt);
                    }
                }
            }
            return dt;
        }

纯粹作为使用语句的替代:

SqlConnection con = new SqlConnection(myConnectionString);
SqlCommand cmd = con.CreateCommand();
cmd.CommandText = @"SELECT [stuff] FROM [tableOfStuff]";
con.Open();
SqlDataReader dr = null;
try
{
    dr = cmd.ExecuteReader();
    while(dr.Read())
    {
        // Populate your business objects/data tables/whatever
    }
}
catch(SomeTypeOfException ex){ /* handle exception */ }
// Manually call Dispose()...
if(con != null) con.Dispose();
if(cmd != null) cmd.Dispose();
if(dr != null) dr.Dispose();

this和using语句的主要区别在于，它允许你更清晰地处理异常。

相关文章：