webForumDet fria alternativet

The connection was not closed. The connection's current state is connecting.

.NET

4 svar · 2 188 visningar · startad av Fredde Mannen

Medlem sedan nov. 20014 054 inlägg
Frågan#1

Har två mystifika fel här, den första är:

System.InvalidOperationException: The connection was not closed. The connection's current state is connecting.

Som sker när jag testar siten via "View Browser" i VS2008. Sen laddar jag in sidan, då hämtar den de poster den skall.

Sen när jag skall testa postningen till sidan, så funkar det första gången, men inte andra gången.

Vid andra gången får jag

 System.Data.SqlClient.SqlException: The variable name '@Username' has already been declared. Variable names must be unique within a query batch or stored procedure.

Det roliga här, är att raden som den visar felet på, har inga procedurer kopplade till sig eller så, se kod:

  public List<Entities.User> GetAll()
        {
            DAL dal = new DAL();

            try
            {
                string Query = "SELECT * FROM Users";
                SqlDataReader dr;
                dr = dal.ExecuteReader(Query);

                List<Entities.User> UserList = new List<Entities.User>();
                while (dr.Read())
                {
                    Entities.User User = new Entities.User();

                    User.Id = Convert.ToInt32(dr["Id"]);
                    User.Firstname = dr["Firstname"].ToString();
                    User.Lastname = dr["Lastname"].ToString();
                    User.Username = dr["Username"].ToString();
                    User.Password = dr["Password"].ToString();
                    User.Salt = dr["Salt"].ToString();
                    UserList.Add(User);
                }

                dr.Close();

                return UserList;
            }

Den klagar på: dr = dal.ExecuteReader(Query);

Har ni några idéer?

Medlem sedan dec. 20025 483 inlägg
#2

Hur ser dal.ExecuteReader() ut?

Medlem sedan nov. 20014 054 inlägg
#3

Peter S skrev:

Hur ser dal.ExecuteReader() ut?

Se efter de som är fetmarkerade, de är några overloadade metoder.. i denna klass:

  public class DAL
    {
        private static SqlConnection cn = new SqlConnection(WebConfigurationManager.ConnectionStrings["SqlServer"].ConnectionString);
        private static SqlCommand cmd = new SqlCommand();
        private static SqlTransaction transaction;

        #region DAL method "ExecuteNonQuery"
        ///<summary>
        /// ExecuteNonQuery(query)
        /// Sql text query to be executed (Insert, update, delete)
        /// </summary>
        /// <param name="query">Sqlstring</param>
        public int ExecuteNonQuery(string query)
        {
            SqlParameter[] paramList = new SqlParameter[0];
            return ExecuteNonQuery(query, paramList, CommandType.Text);
        }

        /// <summary>
        /// ExecuteNonQuerySP(sproc)
        /// Sql stored procedure to be executed (Insert, update, delete)
        /// </summary>
        /// <param name="sproc">Name of stored procedure</param>
        public int ExecuteNonQuerySP(string sproc)
        {
            SqlParameter[] paramList = new SqlParameter[0];
            return ExecuteNonQuery(sproc, paramList, CommandType.StoredProcedure);
        }

        /// <summary>
        /// ExecuteNonQuery(query, sqlparams)
        /// Sql text query to be executed (Insert, update, delete)
        /// </summary>
        /// <param name="paramList">Array of SqlParameters</param>
        /// <param name="query">Sqlstring</param>
        public int ExecuteNonQuery(string query, SqlParameter[] paramList)
        {
            return ExecuteNonQuery(query, paramList, CommandType.Text);
        }

        /// <summary>
        /// ExecuteNonQuery(sproc, sqlparams)
        /// Sql stored procedure to be executed (Insert, update, delete)
        /// </summary>
        /// <param name="paramList">Array of SqlParameters</param>
        /// <param name="sproc">Name of stored procedure</param>
        public int ExecuteNonQuerySP(string sproc, SqlParameter[] paramList)
        {
            return ExecuteNonQuery(sproc, paramList, CommandType.StoredProcedure);
        }

        /// <summary>
        /// This is the function which actually run ExecuteNonQuery()
        /// SQL text query or SQL stored procedure (Insert, Update, Delete)
        /// Specify how a string command is interpreted - StoredProcedure/Text
        /// </summary>
        /// <param name="cmdType">CommandType</param>
        /// <param name="paramList">Array of Sqlparameters</param>
        /// <param name="sproc">Name of stored procedure</param>
        private int ExecuteNonQuery(string sproc, SqlParameter[] paramList, CommandType cmdType)
        {
            try
            {
                cmd.CommandText = sproc;
                cmd.CommandType = cmdType;
                cmd.Parameters.AddRange(paramList);

                return cmd.ExecuteNonQuery();
            }
            catch (SqlException sqEx)
            {
                throw new Exception("Query error occured in DAL method \"ExecuteNonQuery\"", sqEx);
            }
        }
        #endregion

        #region DAL method "ExecuteReader"
        /// <summary>
        /// Run cmd.ExecuteReader for Sql text query
        /// 
        /// Sql text query to be executed (Select)
        /// SqlDataReader
        /// </summary>
        /// <param name="query">Sqlstring</param>
        [b]public SqlDataReader ExecuteReader(string query)[/b]
        {
            SqlParameter[] paramList = new SqlParameter[0];
            return ExecuteReader(query, paramList, CommandType.Text);
        }

        /// <summary>
        /// Run cmd.ExecuteReader for Sql stored procedure
        /// 
        /// Sql stored procedure to be executed (Select)
        /// SqlDataReader
        /// </summary>
        /// <param name="sproc">Name of stored procedure</param>
        public  SqlDataReader ExecuteReaderSP(string sproc)
        {
            SqlParameter[] paramList = new SqlParameter[0];
            return ExecuteReader(sproc, paramList, CommandType.StoredProcedure);
        }

        /// <summary>
        /// Run cmd.ExecuteReader for Sql text query with parameters
        /// 
        /// Sql text query to be executed (Select)
        /// Array of SqlParameters
        /// SqlDataReader
        /// </summary>
        /// <param name="paramList">Sqlparameters</param>
        /// <param name="query">Sqlstring</param>
        [b]public  SqlDataReader ExecuteReader(string query, SqlParameter[] paramList)[/b]
        {
            return ExecuteReader(query, paramList, CommandType.Text);
        }

        /// 
        /// Run cmd.ExecuteReader for Sql stored procedure with parameters
        /// 
        /// Sql stored procedure to be executed (Select)
        /// Array of SqlParameters
        /// SqlDataReader
        public  SqlDataReader ExecuteReaderSP(string sproc, SqlParameter[] paramList)
        {
            return ExecuteReader(sproc, paramList, CommandType.StoredProcedure);
        }

        /// 
        /// This is the function which actually run cmd.ExecuteReader
        /// 
        /// SQL text query or SQL stored procedure (Insert, Update, Delete)
        /// Array of SqlParameters
        /// Specify how a string command is interpreted - StoredProcedure/Text
        /// SqlDataReader
       [b] private  SqlDataReader ExecuteReader(string sproc, SqlParameter[] paramList, CommandType cmdType)[/b]
        {
            try
            {
                cn.Open();

                cmd.Connection = cn;
                cmd.CommandText = sproc;
                cmd.Parameters.AddRange(paramList);
                cmd.CommandType = cmdType;

                return cmd.ExecuteReader(CommandBehavior.CloseConnection);
            }
            catch (SqlException sqEx)
            {
                throw new Exception("Query error occured in DAL method \"ExecuteReader\"", sqEx);
            }
        }

        #endregion

        #region DAL method "ExecuteScalar"
        /// 
        /// Run cmd.ExecuteScalar for Sql text query
        /// 
        /// Sql text query to be executed (Select)
        /// Object - value of first row, first column
        public object ExecuteScalar(string query)
        {
            SqlParameter[] paramList = new SqlParameter[0];
            return ExecuteScalar(query, paramList, CommandType.Text);
        }

        /// 
        /// Run cmd.ExecuteScalar for Sql stored procedure
        /// 
        /// Sql stored procedure to be executed (Select)
        /// Object - value of first row, first column
        public object ExecuteScalarSP(string sproc)
        {
            SqlParameter[] paramList = new SqlParameter[0];
            return ExecuteScalar(sproc, paramList, CommandType.StoredProcedure);
        }

        /// 
        /// Run cmd.ExecuteScalar for Sql text query with parameters
        /// 
        /// Sql text query to be executed (Select)
        /// Array of SqlParameters
        /// Object - value of first row, first column
        public object ExecuteScalar(string query, SqlParameter[] paramList)
        {
            return ExecuteScalar(query, paramList, CommandType.Text);
        }

        /// 
        /// Run cmd.ExecuteScalar for Sql stored procedure with parameters
        /// 
        /// Sql stored procedure to be executed (Select)
        /// Array of SqlParameters
        /// Object - value of first row, first column
        public object ExecuteScalarSP(string sproc, SqlParameter[] paramList)
        {
            return ExecuteScalar(sproc, paramList, CommandType.StoredProcedure);
        }

        /// 
        /// This is the function which actually run cmd.ExecuteScalar
        /// 
        /// SQL text query or SQL stored procedure (Select)
        /// Array of SqlParameters
        /// Specify how a string command is interpreted - StoredProcedure/Text
        /// SObject - value of first row, first column
        private object ExecuteScalar(string sproc, SqlParameter[] paramList, CommandType cmdType)
        {
            try
            {
                cmd.Connection = cn;
                cmd.CommandText = sproc;
                cmd.CommandType = cmdType;
                cmd.Parameters.AddRange(paramList);

                return cmd.ExecuteScalar();
            }
            catch (SqlException sqEx)
            {
                throw new Exception("Query error occured in DAL method \"ExecuteScalar\"", sqEx);
            }
        }

        #endregion

        public void BeginTransaction()
        {
            cn.Open();
            transaction = cn.BeginTransaction();
            cmd.Transaction = transaction;
        }

        public void CommitTransaction()
        {
            transaction.Commit();
            transaction.Dispose();

            cmd.Dispose();
            cn.Close();

        }

        public void RollbackTransaction()
        {
            transaction.Rollback();
            transaction.Dispose();

            cmd.Dispose();
            cn.Close();
        }

        public void Close()
        {
            cn.Close();
        }
Medlem sedan dec. 20025 483 inlägg
#4

I.o.m. att du gör 'cmd' statisk delas den ju mellan instanserna av DAL. Jag kan därför tänka mig att vad som händer, är att när raden cmd.Parameters.AddRange(paramList) körs andra gången får du felmeddelandet eftersom parametern redan lagts till (d.v.s. den raden har redan körts för 'cmd'). Kommandoobjektet "nollställs" aldrig.

Testa att göra 'cmd' till en vanlig medlemsvariabel.

Medlem sedan nov. 20014 054 inlägg
#5

Ja fy fasiken, där hade vi det... inte undra på att jag blivit halvt tokig... :e

Nu är biffen färdigstekt, plockade bort static.. så nu är det som jag vill att det skall vara.

Tusen tack! :bire

330 ms totalt · 4 externa anrop · v20260731065814-full.a51de22e
184 ms — deklarationer (db)
0 ms — hämta statistik (cache)
133 ms — hämta tråd, inlägg och bilagor (db)
193 ms — ändringar (db)