I'm writing a Database class using c# that interacts with a multithread sdk. I should use only one connection(No need to say!) However, I always get errors about connection and datareaders. Anly help appreciated.
Here is the structure of my code
static class Db
{
static MySqlConnection conn = new MySqlConnection(connectionString);
private static void Connect()
{
if (conn.State == ConnectionState.Closed)
conn.Open();
}
private static void DisConnect()
{
if (conn.State == ConnectionState.Open)
conn.Close();
}
static int Insert()
{
Connect();
MySqlCommand cmd = new MySqlCommand(sql, conn);
cmd.ExecuteNonQuery();
return Convert.ToInt32(cmd.LastInsertedId);
DisConnect();
}
public static DataTable select(string sql) //Especially fails here
{
Connect();
MySqlCommand cmd = new MySqlCommand(sql, conn);
using (MySqlDataReader read = cmd.ExecuteReader())
{
if (read.HasRows){ Some Code... }
}
DisConnect();
}
}
Note that MySqlConnection instance is not guaranteed to be thread safe. You should avoid using the same MySqlConnection in several threads at the same time. It is recommended to open a new connection per thread and to close it when the work is done. Actually, connections will not be created/disposed every time with the Pooling=true; connection string option - connections will be stored in the connection pool. This boosts performance greatly.
I also suggest to use the 'using' clause on creating a connection so that it will be automatically disposed/closed and returned to the connection pool.
Related
In my business logic, I use multiple oracle query's multiple times. What is the best way to open and close the oracle connection?
private void update()
{
OracleConnection con = new OracleConnection("Connection Statement");
OracleCommand command = new OracleCommand("Select Statement");
con.Open();
OracleDataReader reader = command.ExecuteReader();
reader.Close();
con.Close();
// A for loop
con.Open();
command = new OracleCommand("Update statement");
command.ExecuteNonQuery();
con.Close();
con.Open();
command = new OracleCommand("Second Update statement");
command.ExecuteNonQuery();
con.Close();
}
My code looks like this. Should I open and close my oracle connection for every command or open before the first command and close after the last command.
P.S. This update function is called over 100 times in my application.
As the connection is local to the method create it in a using block and then use it as many times as you need to in that block. The block can contain loops or whatever, there is no rule that states you have to discard the connection after you use it once.
However connection sharing is discouraged, so do not create a class level instance or static instance for shared use.
private void update()
{
using(OracleConnection con = new OracleConnection("Connection Statement"))
{
con.Open();
using(var command = new OracleCommand("Select Statement", con))
using(OracleDataReader reader = command.ExecuteReader()}
{
}
// A for loop
using(var command = new OracleCommand("Update statement", con))
{
command.ExecuteNonQuery();
}
using(var command = new OracleCommand("Second Update statement", con))
{
command.ExecuteNonQuery();
}
}
}
I'm beginner working with .NET and Mysql Connection.
To avoid misunderstanding about Connection pool for .NET I want to ask some my question.
Here is simple my code
class Program
{
static void Main(string[] args)
{
string connectionSetting = "Data Source=127.0.0.1;Database=my_table; User Id=root;Password=root" + ";charset=euckr";
MySqlConnection con = new MySqlConnection(connectionSetting);
con.Open();
MySqlCommand command = new MySqlCommand("insert into log(strLog) values('log1')", con);
command.ExecuteNonQuery();
con.Close();
}
}
I've been trying to how to make connection instance for mysql-server, the answer was singleton, But I found many post in StackOverflow and Some answers say Don't share MySql Connection instance and that's all i have to do.
My question is "Who is controlling Connection Pool?"
In the above code, there is no code that relates to controlling the connection pool such as the GetPool, PutPool and so on calls. So I thought database connection pool is controlled in mysql-server side and there is not any other jobs on the .NET side. Is my understanding correct?
If my thought is right, I'll use the following codes.
class dbcp
{
public const string m_ConnectionString = "Data Source=127.0.0.1;Database=my_table; User Id=root;Password=root" + ";charset=euckr";
public MySqlConnection connection;
public dbcp() { }
public void QueryLog(string log)
{
connection = new MySqlConnection(m_ConnectionString);
connection.Open();
string strSQL = "insert into log(strLog) values('log1')";
MySqlCommand cmd = new MySqlCommand(strSQL, connection);
cmd.ExecuteNonQuery();
connection.Close();
}
}
class SomeClassA
{
public dbcp dbHandler;
}
class SomeClassB
{
public dbcp dbHandler;
}
class Program
{
static void Main(string[] args)
{
string connectionSetting = "Data Source=127.0.0.1;Database=gw_ocpp_server; User Id=root;Password=root" + ";charset=euckr";
MySqlConnection con = new MySqlConnection(connectionSetting);
con.Open();
MySqlCommand command = new MySqlCommand("insert into log(strLog) values('log1')", con);
command.ExecuteNonQuery();
con.Close();
}
}
Connection pooling is a technique of creating and managing a pool of connections:
Here's the additional info about connection pooling
There is already an open DataReader associated with this Command which
must be closed first.
I m facing this issue when same person open the same page at same time on different system.
I have searched a lot on this but found no successful solution.
I have tired :
MultipleActiveResultSets = true in connection string
Increasing Connection waiting time
Verified all connection are closed
This issue comes only when above condition created. Kindly let me know solution which really works
this my connection function which i m using
public DataSet SelectDs(string str)
{
DataSet ds = new DataSet();
if (con.State == ConnectionState.Closed)
{
con.ConnectionString = ConStr;
con.Open();
}
cmd.CommandText = str;
cmd.Connection = con;
cmd.CommandTimeout = 12000;
adpt.SelectCommand = cmd;
adpt.Fill(ds);
con.Close();
return ds;
}
It is a mortal sin to use a global connection object in that way. It is bad (very bad) in WinForms applications, but in ASP.NET is deadly. (as you have discovered)
The usage pattern for a disposable object (and an expensive one like the connection) is
CREATE, OPEN, USE, CLOSE, DESTROY
The Connection Pooling mechanism exist to make easier the usage of this pattern.
Instead you try to work against it and you pay the consequences.
Your code should be rewritten as
public DataSet SelectDs(string str)
{
DataSet ds = new DataSet();
using(SqlConnection con = new SqlConnection(constring)) // CREATE
using(SqlCommand cmd = new SqlCommand(str, con)) // CREATE
{
con.Open(); // OPEN
cmd.CommandTimeout = 12000;
using(SqlAdapter adpt = new SqlAdapter(cmd)) // USE
adpt.Fill(ds);
return ds;
} // CLOSE & DESTROY
}
How about putting inside a Using statement like
using(SqlConnection connection = new SqlConnection("connection string"))
{
connection.Open();
using(SqlCommand cmd = new SqlCommand("SELECT * FROM SomeTable", connection))
{
using (SqlDataReader reader = cmd.ExecuteReader())
{
if (reader != null)
{
while (reader.Read())
{
//do something
}
}
} // reader closed and disposed up here
} // command disposed here
} //connection closed and disposed here
in finally clause use this
if (readerObj.IsClosed == false)
{
readerObj.Close();
}
I think you should also dispose your command object before returning dataset.
try cmd.Dispose() after con.close()
This is my first time connecting to a database, but i'm having some problems
using Npgsql;
namespace DBPrj
{
class Program
{
static void Main(string[] args)
{
bool boolfound=false;
NpgsqlConnection conn = new NpgsqlConnection("Server=<ip>; Port=5432; User Id=Admin; Password=postgres.1; Database=Test1"); //<ip> is an actual ip address
conn.Open();
NpgsqlCommand cmd = new NpgsqlCommand();
NpgsqlDataReader dr= cmd.ExecuteReader(); //I get InvalidOperationException : The connection is not open.
if (dr.Read())
{
boolfound=true;
Console.WriteLine("connection established");
}
if(boolfound==false)
{
Console.WriteLine("Data does not exist");
}
dr.Close();
conn.Close();
}
}
}
What could be the problem? Is the NpgsqlConnection string written correctly? Could the database be protected from remote access?
How could I fix this problem?
Thanks in advance!
You never assign your NpgsqlConnection to your NpgsqlCommand and you don't supply a query to execute for your NpgsqlDataReader, fixing that should solve the immediate problems.
Also, wrapping at least your NpgsqlConnection in a using()-statement is a good idea to make sure that the connection is always closed, even if there is an exception.
using Npgsql;
namespace DBPrj
{
class Program
{
static void Main(string[] args)
{
bool boolfound=false;
using(NpgsqlConnection conn = new NpgsqlConnection("Server=<ip>; Port=5432; User Id=Admin; Password=postgres.1; Database=Test1"))
{
conn.Open();
NpgsqlCommand cmd = new NpgsqlCommand("SELECT * FROM Table1", conn);
NpgsqlDataReader dr= cmd.ExecuteReader();
if (dr.Read())
{
boolfound=true;
Console.WriteLine("connection established");
}
if(boolfound==false)
{
Console.WriteLine("Data does not exist");
}
dr.Close();
}
}
}
}
In your connection string you may be missing a semi-colon at the end of database.
Database=Test1"
may need to be;
Database=Test1;"
also - it may be worth wrapping your conn.open() in a try catch statement for user-friendliness and ease of catching errors.
Edit 1:
Just did a little reading. Does NpgsqlCommand need parameters to be passed to it? just in pseudo code, something like;
NpgsqlCommand cmd = new NpgsqlCommand(query, conn);
public class SqlHelper
{
public SqlHelper()
{
}
public static SqlConnection GetConnection()
{
SqlConnection conn = new SqlConnection();
conn.ConnectionString = #"Data Source=.\SQLEXPRESS;AttachDbFilename=" + System.Web.HttpContext.Current.Server.MapPath(#"~\App_Data\learn.mdf") + ";Integrated Security=True;User Instance=True";
return conn;
}
public static SqlDataReader ExecuteReader(string sql)
{
SqlConnection con = GetConnection();
con.Open();
SqlCommand cmd = new SqlCommand(sql, con);
SqlDataReader dr = null;
try
{
dr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
}
catch
{
con.Close();
return null;
}
return dr;
}
public static Object ExecuteScalar(string sql)
{
SqlConnection con = GetConnection();
con.Open();
SqlCommand cmd = new SqlCommand(sql, con);
Object val = null;
try
{
val = cmd.ExecuteScalar();
}
catch
{
con.Close();
return null;
}
finally
{
con.Close();
}
return val;
}
public static DataSet ExecuteDataSet(string sql)
{
SqlConnection con = GetConnection();
SqlCommand cmd = new SqlCommand(sql, con);
DataSet ds = new DataSet();
SqlDataAdapter adapt = new SqlDataAdapter(cmd);
try
{
adapt.Fill(ds);
}
catch
{
con.Close();
}
return ds;
}
public static void ExecuteNonQuery(string sql)
{
SqlConnection con = GetConnection();
con.Open();
SqlCommand cmd = new SqlCommand(sql, con);
try
{
cmd.ExecuteNonQuery();
}
finally
{
con.Close();
}
}
}
This is the Class which I use to implement every access to my database . But I think that the way I do connection with the database is a little bit overblown cause I have to hit the Connect function every time I need something . As well as other users going to do the same which kills the performance.
So what is the perfect way to connect with the database - and to stay connected if that better . Note that I use the database in many pages!
Thanks
First, you should be using "using" statements to ensure that all your ADO.NET objects are properly disposed of in the event of a failure:
public static void ExecuteNonQuery(string sql)
{
using(var con = GetConnection())
{
con.Open();
using(var cmd = new SqlCommand(sql, con))
{
cmd.ExecuteNonQuery();
}
}
}
However, having said that, I don't really see a problem with this approach. The advantage is that the connections, commands, adapters and whatnot are properly disposed of every time you execute a bit of SQL. If you were to make a single static SqlConnection instance, you'd escalate the chances that the connection is already in use (when, for example, iterating over the contents of a SqlDataReader).
If you are really concerned about it, provide overloads that take a connection as an extra parameter:
public static void ExecuteNonQuery(string sql, SqlConnection connection)
{
using(var cmd = new SqlCommand(sql, con))
{
cmd.ExecuteNonQuery();
}
}
This way, callers can either execute a bit of SQL that doesn't require multiple calls, or they can call your GetConnectionMethod to obtain a connection, and pass it to multiple calls.
If this is used for a web site then you have to consider that between requests for pages, even from the same browser, your server state will be torn down (in general terms) so there's nothing really to be gained from trying to maintain your SQL connection between pages. That's the first thing.
If each page is the result of a single database connection then you are probably as optimised as you really need to be, if you are making several connections over the generation of a page then you may want to look at keeping a connection alive until you have finished retrieving data; either by maintaining the connection or optimising your data retrieval to limit the back and forth between your app and the db.
Maintaining a database connection is the job of the connection pool, and not the connection consumer. The best practice is to aquire a connection as late as possible and release it as soon as possible.
using(var connection = new SqlConnection(YourConnectionStringHelperFunction())
{
}
One thing that YOu might take into consideration is the Dependency Injection PAttern and some IoC controller. If every page needs to have this connection make this an injectable property (constructor probably wont work unless You implement some kind of infrastructure classes like Request) use some container (Unity, Castle, StructureMap) pack the needed things up (maybe cache, maybe some other things) and let the container do the magic (by magic I mean tons of boilerplate code) for You.
luke
First you can write a seperate class like this :
Get method for getting data (with a Select query) and Set method for manipulating data (Insert, Update, Delete)
using System.Data;
using System.Data.Odbc;
using System.Data.SqlClient; //using this you can replace instead odbc to sql
// Example SqlCommand, SqlDataAdapter
class DataBaseConnection
{
private OdbcConnection conn1 = new OdbcConnection(#"FILEDSN=C:/OTPub/Ot.dsn;" + "Uid=sa;" + "Pwd=otdata#123;"); //"DSN=Ot_DataODBC;" + "Uid=sa;" + "Pwd=otdata#123;"
//insert,update,delete
public int SetData(string query)
{
try
{
conn1.Open();
OdbcCommand command = new OdbcCommand(query, conn1);
int rs = command.ExecuteNonQuery();
conn1.Close();
return rs;
}
catch (Exception ex)
{
conn1.Close();
throw ex;
}
}
//select
public System.Data.DataTable GetData(string sql)
{
try
{
conn1.Open();
OdbcDataAdapter adpt = new OdbcDataAdapter(sql, conn1);
DataTable dt = new DataTable();
adpt.Fill(dt);
conn1.Close();
return dt;
}
catch (Exception ex)
{
conn1.Close();
throw ex;
}
}
}
in your form you can make object to that database connection class
DataBaseConnection db = new DataBaseConnection();
now you cal call get set with your get set method as following
string sqlSpecialHoliyday = "SELECT * FROM Holiday WHERE Date_Time='" + selectdate + "' AND IDH='50'";
DataTable dtAdditionalholily = db.GetData(sqlSpecialHoliyday);
AD you can Set Data Using Set method
string insertloginlog = "INSERT INTO Login_Log (Service_No, Machine_Name) VALUES ('" + serviceID + "','" + machiname + "')";
int ret = db.SetData(insertloginlog);
Hope This will help!