Add samples (#821)

Related to the second part of porting documents from .NET Framework documents.

Author: DavoudEshtehari

doc/samples/SqlCommandBuilder_Create.cs

@@ -0,0 +1,63 @@
+using System;
+using System.Data;
+using Microsoft.Data.SqlClient;
+
+namespace SqlCommandBuilderCS
+{
+    class Program
+    {
+        static void Main()
+        {
+            string cnnst = "Data Source=(local);Initial Catalog=Northwind;"
+                + "Integrated Security=SSPI";
+            string queryst = "SELECT CustomerID, CompanyName, ContactName, Phone FROM Customers";
+            string newQueryString = "SELECT CustomerID, City, Region FROM Customers";
+            string tablen = "Customers";
+            DataSet ds = SelectSqlRows(cnnst, queryst, newQueryString, tablen);
+        }
+
+        public static DataSet SelectSqlRows(string connectionString,
+            string queryString, string newQueryString, string tableName)
+        {
+            using (SqlConnection connection = new SqlConnection(connectionString))
+            {
+                // <Snippet1>
+                // Assumes that connection is a valid SqlConnection object  
+                // inside of a using block. 
+                SqlDataAdapter adapter = new SqlDataAdapter();
+                adapter.SelectCommand = new SqlCommand(queryString, connection);
+                SqlCommandBuilder builder = new SqlCommandBuilder(adapter);
+                builder.QuotePrefix = "[";  
+                builder.QuoteSuffix = "]";  
+                // </Snippet1>
+
+                // <Snippet2>
+                // Generate the update command automatically by SqlCommandBuilder
+                Console.WriteLine(builder.GetUpdateCommand().CommandText);
+                // </Snippet2>
+
+                connection.Open();
+
+                DataSet dataSet = new DataSet();
+                adapter.Fill(dataSet, tableName);
+
+                // <Snippet3>
+                // Assumes an open SqlConnection and SqlDataAdapter inside of a using block.
+                adapter.SelectCommand.CommandText = newQueryString;
+                builder.RefreshSchema();
+
+                dataSet.Tables.Remove(dataSet.Tables[tableName]);
+                adapter.Fill(dataSet, tableName);
+                // </Snippet3>
+
+                //code to modify data in DataSet here
+                builder.GetUpdateCommand();
+
+                //Without the SqlCommandBuilder this line would fail
+                adapter.Update(dataSet, tableName);
+
+                return dataSet;
+            }
+        }
+    }
+}

doc/samples/SqlCommand_ExecuteNonQuery_SP_DML.cs

@@ -0,0 +1,77 @@
+using System;
+using System.Data;
+using Microsoft.Data.SqlClient;
+
+namespace SqlCommandCS
+{
+    class Program
+    {
+        static void Main()
+        {
+            string str = "Data Source=(local);Initial Catalog=Northwind;"
+                + "Integrated Security=SSPI";
+
+            CreateStoredProcedure(str);
+            CreateCommand(str);
+        }
+
+        private static void CreateStoredProcedure(string connectionString)
+        {
+            using (SqlConnection connection = new SqlConnection(connectionString))
+            {
+                // <Snippet3>
+                // Assumes connection is a valid SqlConnection.
+                string queryString = "CREATE PROCEDURE InsertCategory  " + 
+                    "@CategoryName nchar(15), " + 
+                    "@Identity int OUT " + 
+                    "AS " + 
+                    "INSERT INTO Categories (CategoryName) VALUES(@CategoryName) " + 
+                    "SET @Identity = @@Identity " + 
+                    "RETURN @@ROWCOUNT";
+
+                SqlCommand command = new SqlCommand(queryString, connection);
+                command.ExecuteNonQuery();
+                // </Snippet3>
+            }
+        }
+
+        private static void CreateCommand(string connectionString)
+        {
+            using (SqlConnection connection = new SqlConnection(connectionString))
+            {
+                SqlCommand command = new SqlCommand(connection);
+
+                // <Snippet1>
+                // Assumes connection is a valid SqlConnection.
+                connection.Open();
+
+                string queryString = "INSERT INTO Customers " +
+                "(CustomerID, CompanyName) Values('NWIND', 'Northwind Traders')";
+
+                SqlCommand command = new SqlCommand(queryString, connection);
+                Int32 recordsAffected = command.ExecuteNonQuery();
+                // </Snippet1>
+
+                // <Snippet2>
+                // Assumes command is a valid SqlCommand with an open connection.
+                command.CommandText = "InsertCategory";
+                command.CommandType = CommandType.StoredProcedure;
+
+                SqlParameter parameter = command.Parameters.Add("@RowCount", SqlDbType.Int);
+                parameter.Direction = ParameterDirection.ReturnValue;
+
+                parameter = command.Parameters.Add("@CategoryName", SqlDbType.NChar, 15);
+
+                parameter = command.Parameters.Add("@Identity", SqlDbType.Int);
+                parameter.Direction = ParameterDirection.Output;
+
+                command.Parameters["@CategoryName"].Value = "New Category";
+                command.ExecuteNonQuery();
+
+                Int32 categoryID = (Int32) command.Parameters["@Identity"].Value;
+                Int32 rowCount = (Int32) command.Parameters["@RowCount"].Value;
+                // </Snippet2>
+            }
+        }
+    }
+}

doc/samples/SqlCommand_ExecuteScalar_Return_Id.cs

@@ -0,0 +1,47 @@
+using System;
+using System.Data;
+using Microsoft.Data.SqlClient;
+
+class Class1
+{
+    static void Main()
+    {
+        int ret = AddProductCategory("newval", GetConnectionString());
+        Console.WriteLine(ret.ToString());
+        Console.ReadLine();
+    }
+
+    // <Snippet1>
+    static public int AddProductCategory(string newName, string connString)
+    {
+        Int32 newProdID = 0;
+        string sql =
+            "INSERT INTO Production.ProductCategory (Name) VALUES (@Name); "
+            + "SELECT CAST(scope_identity() AS int)";
+        using (SqlConnection conn = new SqlConnection(connString))
+        {
+            SqlCommand cmd = new SqlCommand(sql, conn);
+            cmd.Parameters.Add("@Name", SqlDbType.VarChar);
+            cmd.Parameters["@name"].Value = newName;
+            try
+            {
+                conn.Open();
+                newProdID = (Int32)cmd.ExecuteScalar();
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine(ex.Message);
+            }
+        }
+        return (int)newProdID;
+    }
+
+    // </Snippet1>
+    static private string GetConnectionString()
+    {
+        // To avoid storing the connection string in your code,
+        // you can retrieve it from a configuration file.
+        return "Data Source=(local);Initial Catalog=AdventureWorks;"
+            + "Integrated Security=true";
+    }
+}

doc/samples/SqlDataAdapter_FillDataSet.cs

@@ -0,0 +1,74 @@
+using System;
+using Microsoft.Data.SqlClient;
+using System.Data;
+
+namespace NextResultCS
+{
+    class Program
+    {
+        static void Main()
+        {
+            string s = GetConnectionString();
+            SqlConnection c = new SqlConnection(s);
+            GetCustomers(c);
+            PrintCustomersOrders(c, c);
+            Console.ReadLine();
+        }
+
+        static DataSet GetCustomers(SqlConnection connection)
+        {
+            using (connection)
+            {
+            // <Snippet1>
+                // Assumes that connection is a valid SqlConnection object.
+                string queryString =
+                "SELECT CustomerID, CompanyName FROM dbo.Customers";
+                SqlDataAdapter adapter = new SqlDataAdapter(queryString, connection);
+                
+                DataSet customers = new DataSet();
+                adapter.Fill(customers, "Customers");
+            //  </Snippet1>
+                return customers;
+            }
+        }
+
+        static void PrintCustomersOrders(SqlConnection customerConnection, SqlConnection orderConnection)
+        {
+            using (customerConnection)
+            using (orderConnection)
+            {
+                // <Snippet2>
+                // Assumes that customerConnection and orderConnection are valid SqlConnection objects.
+                SqlDataAdapter custAdapter = new SqlDataAdapter(
+                "SELECT * FROM dbo.Customers", customerConnection);
+                SqlDataAdapter ordAdapter = new SqlDataAdapter(
+                "SELECT * FROM Orders", orderConnection);
+
+                DataSet customerOrders = new DataSet();
+
+                custAdapter.Fill(customerOrders, "Customers");
+                ordAdapter.Fill(customerOrders, "Orders");
+
+                DataRelation relation = customerOrders.Relations.Add("CustOrders",
+                customerOrders.Tables["Customers"].Columns["CustomerID"],
+                customerOrders.Tables["Orders"].Columns["CustomerID"]);
+
+                foreach (DataRow pRow in customerOrders.Tables["Customers"].Rows)
+                {
+                    Console.WriteLine(pRow["CustomerID"]);
+                    foreach (DataRow cRow in pRow.GetChildRows(relation))
+                        Console.WriteLine("\t" + cRow["OrderID"]);
+                }
+                // </Snippet2>
+            }
+        }
+
+        static private string GetConnectionString()
+        {
+            // To avoid storing the connection string in your code,
+            // you can retrieve it from a configuration file.
+            return "Data Source=(local);Initial Catalog=Northwind;"
+                + "Integrated Security=SSPI";
+        }
+    }
+}

doc/samples/SqlDataAdapter_SqlDataAdapter.cs

@@ -1,15 +1,16 @@
 using System;
 using System.Data;
-//<Snippet1>
 using Microsoft.Data.SqlClient;
 
 class Program
 {
     static void Main()
     {
     }
+    //<Snippet1>
     public static SqlDataAdapter CreateSqlDataAdapter(SqlConnection connection)
     {
+        // Assumes that connection is a valid SqlConnection object
         SqlDataAdapter adapter = new SqlDataAdapter();
         adapter.MissingSchemaAction = MissingSchemaAction.AddWithKey;
 
@@ -45,5 +46,19 @@ public static SqlDataAdapter CreateSqlDataAdapter(SqlConnection connection)
 
         return adapter;
     }
+    //</Snippet1>
+
+    public static SqlDataAdapter CustomerUpdateCommand(SqlDataAdapter adapter)
+    {
+        //<Snippet2>
+        // Assumes that connection is a valid SqlAdapter object
+        adapter.UpdateCommand.Parameters.Add("@CompanyName", 
+                    SqlDbType.VarChar, 15, "CompanyName");
+        SqlParameter parameter = adapter.UpdateCommand.Parameters.Add("@CustomerID",
+                    SqlDbType.Char, 5, "CustomerID");
+        parameter.SourceVersion = DataRowVersion.Original;
+        //</Snippet2>
+        return adapter;
+    }
+
 }
-//</Snippet1>

doc/samples/SqlDataReader_GetSchemaTable.cs

@@ -0,0 +1,54 @@
+using System;
+using Microsoft.Data.SqlClient;
+using System.Data;
+
+namespace NextResultCS
+{
+    class Program
+    {
+        static void Main()
+        {
+            string s = GetConnectionString();
+            SqlConnection c = new SqlConnection(s);
+            GetSchemaInfo(c);
+            Console.ReadLine();
+        }
+        // <Snippet1>
+        static void GetSchemaInfo(SqlConnection connection)
+        {
+            using (connection)
+            {
+                SqlCommand command = new SqlCommand(
+                  "SELECT CategoryID, CategoryName FROM Categories;",
+                  connection);
+                connection.Open();
+
+                SqlDataReader reader = command.ExecuteReader();
+
+                // Retrieve schema information about the current result-set.
+                DataTable schemaTable = reader.GetSchemaTable();
+
+                foreach (DataRow row in schemaTable.Rows)
+                {
+                    foreach (DataColumn column in schemaTable.Columns)
+                    {
+                        Console.WriteLine(String.Format("{0} = {1}",
+                           column.ColumnName, row[column]));
+                    }
+                }
+
+                // Always call the Close method when you have finished using the DataReader object.
+                reader.Close();
+            }
+        }
+        // </Snippet1>
+
+        static private string GetConnectionString()
+        {
+            // To avoid storing the connection string in your code,
+            // you can retrieve it from a configuration file.
+            return "Data Source=(local);Initial Catalog=Northwind;"
+                + "Integrated Security=SSPI";
+        }
+    }
+}