codestory

Arbeiten Sie mit der SQL Server-Datenbank in C#

  1. Die Vorstellung
  2.  C# zu SQL Server Database verbinden
  3. SqlCommand
  4. Abfragen
  5. Die Daten einfügen
  6. Die Daten aktualisieren
  7. Die Daten löschen
  8. Das Verfahren im  C# aufrufen
  9. Die Funktion im C# aufrufen
  10. ExecuteScalar

1. Die Vorstellung

In diesen Artikel leite ich bei dem Umgang mit der Datenbank SQL Server durch die Verwendung von C#. Die Ziele schließen ein:
  • Query
  • Insert
  • Update
  • Delete
  • Call function, procedure in C#,...
Das Dokument benutzt SIMPLEHR, ein Database Schema wird in vielen Anleitungen in o7planning.orgbenutzt. Sie können das Schema in Oracle, MySQL oder SQL Server erstellen. Sie können die Anleitung in ... sehen:

2.  C# zu SQL Server Database verbinden

Das Projekt CsSQLServerTutorial erstellen:
Das Projekt wird erstellt
Sie brauchen eine Utility Klasse (DBUtils.cs), die mit der Datenbank zu verbinden hilft. Für die Datenbank SQL Server können Sie die Anleitung bei... sehen:
DBSQLServerUtils.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Data.SqlClient;


namespace Tutorial.SqlConn
{
   class DBSQLServerUtils
   {
     
       public static SqlConnection
                GetDBConnection(string datasource, string database, string username, string password)
       {
           //
           // Data Source=TRAN-VMWARE\SQLEXPRESS;Initial Catalog=simplehr;Persist Security Info=True;User ID=sa;Password=12345
           //
           string connString = @"Data Source="+datasource+";Initial Catalog="
                       +database+";Persist Security Info=True;User ID="+username+";Password="+password;

           SqlConnection conn = new SqlConnection(connString);

           return conn;
       }
     

   }
}
DBUtils.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Data.SqlClient;


namespace Tutorial.SqlConn
{
   class DBUtils
   {
       public static SqlConnection GetDBConnection()
       {
           string datasource = @"192.168.205.135\SQLEXPRESS";
           
           string database = "simplehr";
           string username = "sa";
           string password = "1234";

           return DBSQLServerUtils.GetDBConnection(datasource,  database, username, password);
       }
   }

}

3. SqlCommand

In C# um mit Datenbank SQL Server, wie query, insert, update, delete zu manipulieren, verwenden Sie ein Objekt SqlCommand.SqlCommand ist eine Utility Klasse, die aus DbCommand erweitert wird. Falls Sie query, insert,update oder delete in Oracle Database brauchen, sollen Sie OracleCommand benutzen oder mit MySQL ist MySQLCommand. Leider finden Sie sehr schwierig wenn Sie eine Source-Kode für die unterschiedlichen Datenbank-Typen benutzen möchten.
Das Objekt SqlCommand erstellen um mit SQL Server Database zu manipulieren:
SqlConnection conn = DBUtils.GetDBConnection();

// Der Weg 1:
-----------

// Ein Objekt Command aus das Objekt Connection erstellen.
SqlCommand cmd = conn.CreateCommand();

// Set Command Text
cmd.CommandText = sql;

// Der Weg 2:
-----------

// Das Objekt Command erstellen.
SqlCommand cmd = new SqlCommand(sql);

// Connection mit Command kombinieren.
cmd.Connection = conn;

// Der Weg 3:
------------

// Ein Objekt Command mit 2 Parameter: Command Text & Connection.
SqlCommand cmd = new SqlCommand(sql, conn);

4. Abfragen

Zum Beispiel: die Daten durch die Verwendung von C# abfragen.
QueryDataExample.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Tutorial.SqlConn;
using System.Data.SqlClient;
using System.Data.Common;

namespace CsSQLServerTutorial
{
    class QueryDataExample
    {
        static void Main(string[] args)
        {
            // Das Objekt Connection holen.
            SqlConnection conn = DBUtils.GetDBConnection();
            conn.Open();
            try
            {
                QueryEmployee(conn);
            }
            catch (Exception e)
            {
                Console.WriteLine("Error: " + e);
                Console.WriteLine(e.StackTrace);
            }
            finally
            {
                // die Verbindung schließen.
                conn.Close();
                // das Objekt absagen, die Ressourcen freien.
                conn.Dispose();
            }       
            Console.Read();
        }

        private static void QueryEmployee(SqlConnection conn )
        { 
            string sql = "Select Emp_Id, Emp_No, Emp_Name, Mng_Id from Employee"; 

            // Ein Objekt Command erstellen.
            SqlCommand cmd = new SqlCommand();

            // Command für Connection setzen.
            cmd.Connection = conn;
            cmd.CommandText = sql; 

            
            using (DbDataReader reader = cmd.ExecuteReader())
            {
                if (reader.HasRows)
                {
                    
                    while (reader.Read())
                    {
                        // Die Index von Spalte Emp_ID in Command SQL.
                        int empIdIndex = reader.GetOrdinal("Emp_Id"); // 0
                        

                        long empId =  Convert.ToInt64(reader.GetValue(0));
                        
                        // Die Spalte Emp_No hat index = 1.
                        string empNo = reader.GetString(1);
                        int empNameIndex = reader.GetOrdinal("Emp_Name");// 2
                        string empName = reader.GetString(empNameIndex);

                        // Die Index von Spalte Mng_Id im Command SQL.
                        int mngIdIndex = reader.GetOrdinal("Mng_Id");

                        long? mngId = null;

                   
                        if (!reader.IsDBNull(mngIdIndex))
                        {
                            mngId = Convert.ToInt64(reader.GetValue(mngIdIndex)); 
                        }
                        Console.WriteLine("--------------------");
                        Console.WriteLine("empIdIndex:" + empIdIndex);
                        Console.WriteLine("EmpId:" + empId);
                        Console.WriteLine("EmpNo:" + empNo);
                        Console.WriteLine("EmpName:" + empName);
                        Console.WriteLine("MngId:" + mngId);
                    }
                }
            }

        }
    }

}
Das Beispiel laufen
--------------------
empIdIndex:0
EmpId:7369
EmpNo:E7369
EmpName:SMITH
MngId:7902
--------------------
empIdIndex:0
EmpId:7499
EmpNo:E7499
EmpName:ALLEN
MngId:7698
--------------------
empIdIndex:0
EmpId:7521
EmpNo:E7521
EmpName:WARD
MngId:7698
--------------------
empIdIndex:0
EmpId:7566
EmpNo:E7566
EmpName:JONES
MngId:7839
.....
Achtung: Das Statement using wird benutzt um sicherzustellen, dass das Objekt nach seiner Austritt vom Bereich disponiert wird (dispose). And es fordert keine expliziten Kode an.
// Das Schlüsselwort 'using' mit den Objekte IDispose benutzen
// (ist das Objekt von  Interface IDispose).
using (DbDataReader reader = cmd.ExecuteReader())
{
    // ...
}

// Es ist äquivalent mit:
DbDataReader reader = cmd.ExecuteReader();
try
{
    // ...
}
finally
{
    // Das Method aufrufen um das Objekt zu disponieren
    // Die Ressourcen freien.
    reader.Dispose();
}

5. Die Daten einfügen

Zum Beispiel: ein Rekord in die Tabelle Salary_Grade einfügen (insert).
InsertDataExample.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Tutorial.SqlConn;
using System.Data.Common; 
using System.Data;
using System.Data.SqlClient;

namespace CsSQLServerTutorial
{
    class InsertDataExample
    {
          static void Main(string[] args) 
          {
  
            SqlConnection connection = DBUtils.GetDBConnection();
            connection.Open();
            try
            {    
                // Das Statement Insert.
                string sql = "Insert into Salary_Grade (Grade, High_Salary, Low_Salary) "
                                                 + " values (@grade, @highSalary, @lowSalary) "; 

                SqlCommand cmd = connection.CreateCommand();
                cmd.CommandText = sql;  

                // Ein Objekt Parameter erstellen.
                SqlParameter gradeParam = new SqlParameter("@grade",SqlDbType.Int);
                gradeParam.Value = 3;
                cmd.Parameters.Add(gradeParam);

                // Die Parameter @highSalary einfügen (kürzer schreiben).
                SqlParameter highSalaryParam = cmd.Parameters.Add("@highSalary", SqlDbType.Float);
                highSalaryParam.Value = 20000;

                // Die Parameter @lowSalary einfügen (mehr kürzer schreiben).
                cmd.Parameters.Add("@lowSalary", SqlDbType.Float ).Value = 10000; 

                // das Command ausführen ( für Delete, insert, update benutzen).
                int rowCount = cmd.ExecuteNonQuery();

                Console.WriteLine("Row Count affected = " + rowCount);
            }
            catch (Exception e)
            {
                Console.WriteLine("Error: " + e);
                Console.WriteLine(e.StackTrace);
            }
            finally
            { 
                connection.Close(); 
                connection.Dispose();
                connection = null;
            }

            Console.Read();
  
         }
    }

}
Das Beispiel durchführen
Row Count affected = 1

6. Die Daten aktualisieren

Zum Beispiel: update im C#.
UpdateExample.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Data.SqlClient;
using Tutorial.SqlConn;
using System.Data;

namespace CsSQLServerTutorial
{
    class UpdateExample
    {
        static void Main(string[] args)
        {
             
            SqlConnection conn  = DBUtils.GetDBConnection();
            conn.Open();
            try
            { 
                string sql = "Update Employee set Salary = @salary where Emp_Id = @empId";
 
                SqlCommand cmd = new SqlCommand(); 
              
                cmd.Connection = conn; 
                cmd.CommandText = sql;

                // Die Wert für die Parameter einfügen und setzen.
                cmd.Parameters.Add("@salary", SqlDbType.Float).Value = 850;
                cmd.Parameters.Add("@empId", SqlDbType.Decimal).Value = 7369; 

                // Das Command ausführen (für delete, insert, update benutzen).
                int rowCount = cmd.ExecuteNonQuery();

                Console.WriteLine("Row Count affected = " + rowCount);
            }
            catch (Exception e)
            {
                Console.WriteLine("Error: " + e);
                Console.WriteLine(e.StackTrace);
            }
            finally
            { 
                conn.Close(); 
                conn.Dispose();
                conn = null;
            }


            Console.Read();

        }
    }

}
Das Beispiel durchführen
Row Count affected = 1

7. Die Daten löschen

Z.B: C# benutzen um die Daten in SQL zu löschen.
DeleteExample.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Data.SqlClient;
using Tutorial.SqlConn;
using System.Data;

namespace CsSQLServerTutorial
{
    class DeleteExample
    {
        static void Main(string[] args)
        {
         
            SqlConnection conn  = DBUtils.GetDBConnection();
            conn.Open();
            try
            {               

                string sql = "Delete from Salary_Grade where Grade = @grade ";
           
                SqlCommand cmd = new SqlCommand();
 
                cmd.Connection = conn; 
                cmd.CommandText = sql; 

                cmd.Parameters.Add("@grade", SqlDbType.Int).Value = 3;  

                // Command ausführen (für delete, insert, update benutzen).
                int rowCount = cmd.ExecuteNonQuery();

                Console.WriteLine("Row Count affected = " + rowCount);
            }
            catch (Exception e)
            {
                Console.WriteLine("Error: " + e);
                Console.WriteLine(e.StackTrace);
            }
            finally
            { 
                conn.Close(); 
                conn.Dispose();
                conn = null;
            }

            Console.Read();

        }
    }

}

8. Das Verfahren im  C# aufrufen

Sie brauchen ein einfaches Verfahren im SQL Server erstellen und es im C# aufrufen:
Get_Employee_Info
-- This procedure retrieves information of an employee,
-- Input parameter: p_Emp_ID (Integer)
-- There are four output parameters v_Emp_No, v_First_Name, v_Last_Name, v_Hire_Date

CREATE PROCEDURE Get_Employee_Info
    @p_Emp_Id       Integer ,
    @v_Emp_No      Varchar(50)   OUTPUT,
    @v_First_Name  Varchar(50)   OUTPUT,
    @v_Last_Name  Varchar(50)   OUTPUT,
    @v_Hire_Date    Date             OUTPUT
AS
BEGIN
    set @v_Emp_No  =   'E' + CAST( @p_Emp_Id as varchar)  ;
    --
    set @v_First_Name = 'Michael';
    set @v_Last_Name  = 'Smith';
    set @v_Hire_date  = getdate();
END
CallProcedureExample.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Tutorial.SqlConn;
using System.Data;
using System.Data.SqlClient;

namespace CsSQLServerTutorial
{
    class CallProcedureExample
    {
        // Get_Employee_Info                
        // @p_Emp_Id       Integer ,
        // @v_Emp_No      Varchar(50)   OUTPUT
        // @v_First_Name  Varchar(50)   OUTPUT
        // @v_Last_Name  Varchar(50)    OUTPUT
        // @v_Hire_Date    Date         OUTPUT
        static void Main(string[] args)
        {
            SqlConnection conn = DBUtils.GetDBConnection();
            conn.Open();
            try
            {
                // Ein Objekt Command erstellen um das Verfahren Get_Employee_Info aufzurufen.
                SqlCommand cmd = new SqlCommand("Get_Employee_Info", conn);

                // Das Typ vom Command ist StoredProcedure
                cmd.CommandType = CommandType.StoredProcedure;

                // Den Parameter @p_Emp_Id einfügen und die Wert von 100 für ihn anweisen.
                cmd.Parameters.Add("@p_Emp_Id", SqlDbType.Int).Value =100;

                // Den Parameter @v_Emp_No mit dem Typ von Varchar(20) einfügen.
                cmd.Parameters.Add(new SqlParameter("@v_Emp_No", SqlDbType.VarChar, 20));
                cmd.Parameters.Add(new SqlParameter("@v_First_Name", SqlDbType.VarChar, 50));
                cmd.Parameters.Add(new SqlParameter("@v_Last_Name", SqlDbType.VarChar, 50));
                cmd.Parameters.Add(new SqlParameter("@v_Hire_Date", SqlDbType.Date)); 

                // Den Parameter @v_Emp_No als OUTPUT einfügen.
                cmd.Parameters["@v_Emp_No"].Direction = ParameterDirection.Output;
                cmd.Parameters["@v_First_Name"].Direction = ParameterDirection.Output;
                cmd.Parameters["@v_Last_Name"].Direction = ParameterDirection.Output;
                cmd.Parameters["@v_Hire_Date"].Direction = ParameterDirection.Output;
 
                // Das Verfahren ausführen.
                cmd.ExecuteNonQuery();

                // Die Output-Wert holen.
                string empNo = cmd.Parameters["@v_Emp_No"].Value.ToString();
                string firstName = cmd.Parameters["@v_First_Name"].Value.ToString();
                string lastName = cmd.Parameters["@v_Last_Name"].Value.ToString();
                DateTime hireDate = (DateTime)cmd.Parameters["@v_Hire_Date"].Value;


                Console.WriteLine("Emp No: " + empNo);
                Console.WriteLine("First Name: " + firstName);
                Console.WriteLine("Last Name: " + lastName);
                Console.WriteLine("Hire Date: " + hireDate);

            }
            catch (Exception e)
            {
                Console.WriteLine("Error: " + e);
                Console.WriteLine(e.StackTrace);
            }
            finally
            {
                conn.Close();
                conn.Dispose();
            }

            Console.Read();
        }
    }


}
Das Beispiel laufen
Emp No: E100
First Name: Michael
Last Name: Smith
Hire Date: 2/11/2016 12:00:00 AM

9. Die Funktion im C# aufrufen

Sie brauchen eine einfache Funktion und rufen sie im C# auf.
Get_Emp_No
-- Procedure to retrieve information of an employee,
-- Parameter: p_Emp_ID (Integer)
-- Returns Emp_No

CREATE Function Get_Emp_No (@p_Emp_Id  Integer)
Returns Varchar(50)
AS
BEGIN    
   return 'E'+  CAST( @p_Emp_Id as varchar);
END
CallFunctionExample.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Tutorial.SqlConn;
using System.Data;
using System.Data.SqlClient;


namespace CsSQLServerTutorial
{
    class CallFunctionExample
    {
        // Function: Get_Emp_No                
        // Parameter: @p_Emp_Id       Integer 
        static void Main(string[] args)
        {
            SqlConnection conn = DBUtils.GetDBConnection();
            conn.Open();
            try
            { 
                // Ein Objekt Command erstellen um die Funktion Get_Emp_No aufzurufen.
                SqlCommand cmd = new SqlCommand("Get_Emp_No", conn);

                // Das Typ von Command ist StoredProcedure
                cmd.CommandType = CommandType.StoredProcedure;

                // Den Parameter @p_Emp_Id einfügen und die Wert von 100 für ihn zuweisen.
                cmd.Parameters.Add("@p_Emp_Id", SqlDbType.Int).Value = 100;

                // Ein Objekt Parameter erstellen , die zurückgebene Wert der Funktion lagern.
                SqlParameter resultParam = new SqlParameter("@Result", SqlDbType.VarChar);             

                //  
                resultParam.Direction = ParameterDirection.ReturnValue; 
              
                cmd.Parameters.Add(resultParam);
                
                // Die Funktion aufrufen.
                cmd.ExecuteNonQuery();

                string empNo = null;
                if (resultParam.Value != DBNull.Value)
                {
                    empNo = (string)resultParam.Value;
                }                 
                Console.WriteLine("Emp No: " + empNo); 

            }
            catch (Exception e)
            {
                Console.WriteLine("Error: " + e);
                Console.WriteLine(e.StackTrace);
            }
            finally
            {
                conn.Close();
                conn.Dispose();
            }

            Console.Read();
        }
    }

}
Das Beispiel laufen
Emp No: E100

10. ExecuteScalar

SqlCommand.ExecuteScalar() ist ein Method, das Statement SQL auszuführen. Es gibt die Wert der ersten Spalte der ersten Linie in den Statements SQL zurück.
-- Das Statement gibt eine einzige Wert zurück.
Select count(*) from Employee;

-- Oder
Select Max(e.Salary) From Employee e;
Zum Beispiel
ExecuteScalarExample.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Data.SqlClient;
using System.Data;
using Tutorial.SqlConn;


namespace CsSQLServerTutorial
{
    class ExecuteScalarExample
    {
        static void Main(string[] args)
        {
            SqlConnection conn = DBUtils.GetDBConnection();
            conn.Open();
            try
            { 
                SqlCommand cmd = new SqlCommand("Select count(*) From Employee", conn);
                 
                cmd.CommandType = CommandType.Text;

                // Das Method ExecuteScalar gibt die Wert der ersten Spalte in die erste Linie zurück.
                int count = (int) cmd.ExecuteScalar();

                Console.WriteLine("Emp Count: " + count);

            }
            catch (Exception e)
            {
                Console.WriteLine("Error: " + e);
                Console.WriteLine(e.StackTrace);
            }
            finally
            {
                conn.Close();
                conn.Dispose();
            }

            Console.Read();
        }
    }
}
Das Beispiel laufen
Emp Count: 14

Anleitungen C#

Show More

Neueste Artikel

Show More