C#

galache wrote:

I think the problem is the double type use in the first example

static void Main(string[] args)
    {
    Console.WriteLine("Started");
    SqlConnection con = new SqlConnection(strCon);
    con.Open();
    SqlDataAdapter daMyTable = new SqlDataAdapter("SELECT * FROM myTable", con);
    SqlDataAdapter daMyOtherTable = new SqlDataAdapter("SELECT * FROM myOtherTable", con);
    SqlDataAdapter daJoined = new SqlDataAdapter("SELECT * FROM myTable INNER JOIN myOtherTable ON myTable.iD=myOtherTable.iD", con);
    DataSet ds = new DataSet();
    daMyTable.Fill(ds, "My Table");
    daMyOtherTable.Fill(ds, "My Other Table");
    daJoined.Fill(ds, "My Joined Table");
    ShowDataSet(ds);
    con.Close();
    Console.WriteLine("Stopped");
    Console.ReadLine();
    }

private static void ShowDataSet(DataSet ds)
    {
    foreach (DataTable dt in ds.Tables)
        {
        Console.WriteLine(dt.TableName);
        ShowDataTable("   ", dt);
        }
    }

private static void ShowDataTable(string p, DataTable dt)
    {
    int cols = dt.Columns.Count;
    foreach (DataRow dr in dt.Rows)
        {
        Console.Write(p);
        string sep = "";
        for (int i = 0; i < cols; i++)
            {
            Console.Write(sep + dr[i].ToString());
            sep = ", ";
            }
        Console.WriteLine();
        }
    }

using (SqlConnection con = new SqlConnection(...))
   {
   con.Open();
   using (SqlCommand com = new SqlCommand("SELECT ...", con))
      {
      ...
      }
   }

using (SqlCommand command = new SqlCommand())
{
    // Set command properties as needed
    using (command.Connection = new SqlConnection(connectionString))
    {
        try
        {
            command.Connection.Open();
            // Execute command, retrieve data from result, or whatever you want to do with the command
        }
        catch(Exception)
        {
            // Handling exceptions: logging, rethrowing, whatever
        }
        finally
        {
            command.Connection.Close();
        }
    }
}

using(connection...)
{
   // Do an insert

}  // Exception is going to be thrown at this point

connection = ...
bool isOk=false;
try
   {
   // Do an insert
   // For this example we presume that exceptions from the insert
   // are free to propogate.
   isOk=true;
   }
finally
   {
   try
     {
     connection.Close();
     }
   catch(Exception ee)
     {
     // This is often ignorable
     // because either an exception was thrown by the insert
     // or it succeeded.

     // However if we really want to do something
     if (isOk)
        {
        // Log it
        }
     else
        {
        // Do nothing.  Why?
        // Because we know an exception occured.
        // That exception probably caused this one.
        // And that exception is going to be more
        // informational than this one.
        }
     }

   try
       {
       ((IDisposable)connection).Dispose();
       }
   catch
       {
       // Always ignore this.  Any real
       // failure occurred before this.
       // If an exception occurs at all it is either
       // meaningless or related to the real failure.
       // But you can always log it if you want.
       }
   }

PIEBALDconsult wrote:

Paranoid much?