Using many sql connection in one code?

You're using the same connection string for each connection? Why do you need three connections? Why not just open and close the same one?

As long as the connection string is the same, you only need one connection.

In general you should prefer to create and open a connection object as close to where you make use of it as possible, and dispose of it as soon as possible afterwards (preferably by making use of a using statement). Connection pooling will take care of ensuring you only actually create a limited number of real connections to the server, despite the large number of SqlConnection objects your code may seem to create.

Within a single method, however, it is reasonable to use a single connection object:

public partial class Home : System.Web.UI.Page
{
    string connString = ConfigurationManager.ConnectionStrings["TextConnectionString"].ConnectionString;

    protected void Button1_Click(object sender, EventArgs e)
    {
        using (SqlConnection co = new SqlConnection(connString))
        {
            co.Open();
            using(SqlCommand cm = co.CreateCommand())
            {
              cm.CommandText = "select...";
              cm.ExecuteNonQuery();
            }

            using(SqlCommand cmv = co.CreateCommand())
            {
              cmv.CommandText = "insert...";
              cmv.ExecuteNonQuery();
            }

            using(SqlCommand cmf = co.CreateCommand())
            {
              cmf.CommandText = "delete from...";
              cmf.ExecuteNonQuery();
            }
        }
    }
}

(You don't need to explicitly close the connection object, the Dispose (within the using is equivalent)

1. No use declaring/creating multiple connections when you would be using only one at a time. You can do with just one.
2. Declare variable as close as possible to its first use, and with minimum scope manageable.
3. Make things modular and reusable as far as possible.
4. No need to explicitly close the connection, since the IDisposable interface implementation (and using block) does it anyways. But there is no harm in explicitly closing it.

protected void Button1_Click(object sender, EventArgs e)
{
    ExecuteNonQuery("select...", null);         // why??
    ExecuteNonQuery("insert...", null);
    ExecuteNonQuery("delete from...", null);
}

protected void ExecuteNonQuery(string query, SqlParameter[] parameters)
{
    using (SqlConnection co = new SqlConnection(ConfigurationManager.ConnectionStrings["TextConnectionString"].ConnectionString))
    {
        co.Open();
        SqlCommand cm = co.CreateCommand();
        cm.CommandText = query;
        if (parameters != null) cm.Parameters.AddRange(parameters);
        cm.ExecuteNonQuery();
    }
}

You can also try this.

        SqlConnection co = new SqlConnection(ConfigurationManager.ConnectionStrings["TextConnectionString"].ConnectionString);

        protected void Button1_Click(object sender, EventArgs e)
        {
           StringBuilder sb = new StringBuilder();
           sb.AppendLine(" Select statement.. ");
           sb.AppendLine(" Insert statement ");
           sb.AppendLine(" delete statement ");
            using (co)
            {
                co.Open();
                SqlCommand cm = co.CreateCommand();
                cm.CommandText = sb.Tostring();
                cm.ExecuteNonQuery();
            }
            co.Close();              
        }