Programmers Heaven: C# School

Using Stored Procedures

So far we have written the SQL statements inside our code, which usually is not a good idea. In this way you are exposing your database schema (design) in the code which may be changed. Hence most of the time we use stored procedures instead of plain SQL statements. A stored procedure is a precompiled executable object that contains one or more SQL statements.

Hence you can replace your complex SQL statements with a single stored procedure. A stored procedure may be written to accept inputs and return output.

Sample Stored Procedures

We now present some sample stored procedures with short descriptions. This text assumes that you are familiar with stored procedures and other basic database concepts related to database systems as the intention here is not to discuss databases but the use of databases in the ADO.Net environment. But still we present a small review of four basic types of stored procedure for SELECT, INSERT, UPDATE and DELETE operations.

In SQL Server, you can create and add stored procedures to your database using the SQL Server Enterprise Manager.

UPDATE Stored Procedure

A simple stored procedure to update a record is

CREATE PROCEDURE UpdateProc (

@artId as int,

@title as varchar(100), @topic as varchar(100), @authorId as int, @lines as int,

@dateOfPublishing as datetime)

AS

UPDATE Article SET

title = @title, topic = @topic, authorId = @authorId, lines = @lines, dateOfPublishing = @dateOfPublishing

WHERE artId = @artId

GO

The name of the stored procedure is UpdateProc and it has input parameters for each of the fields of our Article table. The query to be executed when the stored procedure is run updates the record with the supplied primary key (@artId) using the supplied parameters. It is very similar to the code we have written to initialize command in the previous example and we suppose you don't have any problem in understanding this even if you are not familiar with stored procedure.

254

Programmers Heaven: C# School

INSERT Stored Procedure

A simple stored procedure to insert a record is

CREATE PROCEDURE InsertProc (

@dateOfPublishing as datetime)

AS

INSERT INTO article (artId, title, topic, authorId, lines, dateOfPublishing)

VALUES(@artId, @title, @topic, @authorId, @lines, @dateOfPublishing)

GO

The stored procedure above is named InsertProc and is very similar to the UpdateProc except that here we are using the INSERT SQL statement instead of the UPDATE command.

DELETE Stored Procedure

A simple stored procedure to delete a record is

CREATE PROCEDURE DeleteProc (@artId as int)

AS

DELETE FROM article WHERE artId = @artId

GO

Here we have used only one parameter, as to delete a record you only need its primary key value.

SELECT Stored Procedure

A simple stored procedure to select records from a table is

CREATE PROCEDURE SelectProc

AS

SELECT * FROM Article

GO

This probably is the simplest of all. It does not take any parameters and only selects all the records from the Article table.

255

Programmers Heaven: C# School

All the four stored procedures presented above are kept extremely simple so that the reader does not find any difficulty in understanding the use of stored procedures in his C# code. Real world stored procedures are much more complex and, of course, more useful than these!

Using Stored Procedures with ADO.Net in C#

Using stored procedures with ADO.Net in C# is extremely simple, especially when we have developed the application with SQL commands. All we need now is to replace the SQL commands in the previous with calls to stored procedures. For example in the InitalizeCommands() method of the previous example we created the insert command as

private void InitializeCommands()

{

// Preparing Insert SQL Command dataAdapter.InsertCommand = conn.CreateCommand(); dataAdapter.InsertCommand.CommandText =

"INSERT INTO article " +

"(artId, title, topic, authorId, lines, dateOfPublishing) " + "VALUES(@artId, @title, @topic, @authorId, @lines, @dateOfPublishing)";

AddParams(dataAdapter.InsertCommand, "artId", "title", "topic",

"authorId", "lines", "dateOfPublishing");

...

When using the stored procedure the command will be prepared as

private void InitializeCommands()

{

// Preparing Insert SQL Command

SqlCommand insertCommand = new SqlCommand("InsertProc", conn); insertCommand.CommandType = CommandType.StoredProcedure; dataAdapter.InsertCommand = insertCommand; AddParams(dataAdapter.InsertCommand, "artId", "title", "topic",

"authorId", "lines", "dateOfPublishing"); insertCommand.UpdatedRowSource = UpdateRowSource.None;

...

Here we first created an SqlCommand object named insertCommand supplying in the constructor call the name of the target stored procedure (InsertProc in this case) and the connection to be used.

SqlCommand insertCommand = new SqlCommand("InsertProc", conn);

256

Programmers Heaven: C# School

We then set the CommandType property of the insertCommand object to the StoredProcedure enumeration value. This tells the runtime that the command used here is a stored procedure.

insertCommand.CommandType = CommandType.StoredProcedure;

Finally we added this command to the data adapter object using its InsertCommand property. Just like in the previous example we have also added parameters to the command.

dataAdapter.InsertCommand = insertCommand;

AddParams(dataAdapter.InsertCommand, "artId", "title", "topic",

"authorId", "lines", "dateOfPublishing");

The modified InitializeCommands() method

Hence when using stored procedures, the modified InitializeCommands() method is:

private void InitializeCommands()

{

// Preparing Select Command

SqlCommand selectCommand = new SqlCommand("SelectProc", conn); selectCommand.CommandType = CommandType.StoredProcedure; dataAdapter.SelectCommand = selectCommand;

// Preparing Insert SQL Command

SqlCommand insertCommand = new SqlCommand("InsertProc", conn); insertCommand.CommandType = CommandType.StoredProcedure; dataAdapter.InsertCommand = insertCommand; AddParams(dataAdapter.InsertCommand, "artId", "title", "topic",

"authorId", "lines", "dateOfPublishing");

// Preparing Update SQL Command

SqlCommand updateCommand = new SqlCommand("UpdateProc", conn); updateCommand.CommandType = CommandType.StoredProcedure; dataAdapter.UpdateCommand = updateCommand; AddParams(dataAdapter.UpdateCommand, "artId", "title",

"topic", "authorId", "lines", "dateOfPublishing");

// Preparing Delete SQL Command

SqlCommand deleteCommand = new SqlCommand("DeleteProc", conn); deleteCommand.CommandType = CommandType.StoredProcedure; dataAdapter.DeleteCommand= deleteCommand; AddParams(dataAdapter.DeleteCommand, "artId");

257

Programmers Heaven: C# School

}

Note that we have used the name of the stored procedure in the constructor calls to the SqlCommand's object. Also note that now we have also included the select command in the data adapter. The only other change you need to do now is in the Load Table button's event handler.

Since we are now using stored procedures to select the records from the table, we need to change the Load table button event handler. The modified version of this event handler is:

private void btnLoadTable_Click(object sender, System.EventArgs e)

{

this.Cursor = Cursors.WaitCursor;

string connectionString = "server=P-III; database=programmersheaven;uid=sa; pwd=;";

conn = new SqlConnection(connectionString); dataAdapter = new SqlDataAdapter(); InitializeCommands();

ds = new DataSet(); dataAdapter.Fill(ds, "article");

dataTable = ds.Tables["article"]; currRec = 0;

totalRec = dataTable.Rows.Count;

FillControls();

ToggleControls(true);

this.Cursor = Cursors.Default;

}

The two changes made are highlighted with bold formatting in the above code. Now we are creating the SqlDataAdapter object using the default no-argument constructor. This time we are not passing it the select command as we are using the stored procedure for it and we are not passing it the connection object as now each command is holding the connection reference and all the commands have finally been added to the data adapter. The second change is the reordering of the InitializeCommands() method call. It is now called just before filling the dataset as now the select command is also being prepared inside the InitializeCommands() method.

This is all you need to change in the previous example application to replace the SQL commands with stored procedures. Isn't it simple! The complete source code of this application can be downloaded by clicking here.

Author's Note: When using dataset and disconnected architecture, we don't update the data source (by calling DataAdapter's Update() method and DataSet's AcceptChanges() method) for each update. Instead we make the changes local and update all

258