Reading and Writing Text Files - C#

// File IO using class StreamWriter

using System;
using System.IO; // TextWriter, StreamWriter

public class MyClass
{
public static void Main()
{
string text;

text = "A quick brown fox\n";
text += "jumps over a \n";
text += "little lazzy dog.\n";

// create a writer and open the file
TextWriter tw = new StreamWriter("typing.txt");

// write a line of text (present date/time) to the file
tw.WriteLine(DateTime.Now);

// write the rest of the text lines
tw.Write(text);

// close the stream
tw.Close();

// read the text file back ...
// create reader & open file
TextReader tr = new StreamReader("typing.txt");

// read first line of text (here date/time)
Console.WriteLine(tr.ReadLine());

// read the text, next 2 lines
Console.WriteLine(tr.ReadLine());
Console.WriteLine(tr.ReadLine());

// read the rest of the text lines
Console.WriteLine(tr.ReadToEnd());

// close the stream
tr.Close();

// wait to look at console display
Console.Write("\nPress Enter to exit ...");
Console.Read();

}
}

Disable/Enable ListItems - ASP.NET

Introduction

1. Add a CheckBoxList to your ASP.NET WebForm and give it an ID of checkBoxListTest.
2. Add a call to the LoadCheckBoxList in the Page_Load event.
3. Add the LoadCheckBoxList method to your webpage class.
4. Add the JavaScript function inside the head of the HTML.

ASP.NET CodeBehind

private void Page_Load(object sender, System.EventArgs e)
{
if(!this.IsPostBack)
{
LoadCheckBoxList();
}
}

private void LoadCheckBoxList()
{
this.checkBoxListTest.Attributes.Add("onclick",
"disableListItems('checkBoxListTest', '2', '3')");

// Add three items to the CheckBoxList.
for(int i=0; i < item =" new">

This method adds the onclick function disableListItems to the CheckBoxList attributes collection. The function will disable all the items except for the last item in the list when it is checked. The method also adds three items to the CheckBoxList.

JavaScript Function

function disableListItems(checkBoxListId, checkBoxIndex, numOfItems)
{
// Get the checkboxlist object.
objCtrl = document.getElementById(checkBoxListId);

// Does the checkboxlist not exist?
if(objCtrl == null)
{
return;
}

var i = 0;
var objItem = null;
// Get the checkbox to verify.
var objItemChecked =
document.getElementById(checkBoxListId + '_' + checkBoxIndex);

// Does the individual checkbox exist?
if(objItemChecked == null)
{
return;
}

// Is the checkbox to verify checked?
var isChecked = objItemChecked.checked;

// Loop through the checkboxes in the list.
for(i = 0; i < numOfItems; i++)
{
objItem = document.getElementById(checkBoxListId + '_' + i);

if(objItem == null)
{
continue;
}

// If i does not equal the checkbox that is never to be disabled.
if(i != checkBoxIndex)
{
// Disable/Enable the checkbox.
objItem.disabled = isChecked;
// Should the checkbox be disabled?
if(isChecked)
{
// Uncheck the checkbox.
objItem.checked = false;
}
}
}
}

The above code is the JavaScript function that is invoked by the onclick event of the CheckBoxList.

Binding DataGridView, GridView with SQL statement

Introduction
How to populate DataGridView, GridView with SQL statement in C#

When we do the development, we always want to make the code simple and error free if possible. In C#, GridView for web based application and DataGridView for windows form based application are different in using and behavior. It looks like Microsoft has two different teams to develop GridView and DataGridView separately. This is why I wrote this article to share the coding for each control. Here I am using MS Visual Studio 2005.


I. Populate GridView control for web based application with SQL statement

Let us put GridView1 control on the web form from Toolbox. The coding is straight forward and is like the following:

protected void Page_Load(object sender, EventArgs e)
{
string strSQLconnection = "Data Source=dbServer;Initial Catalog=testDB;Integrated Security=True";
SqlConnection sqlConnection = new SqlConnection(strSQLconnection);
SqlCommand sqlCommand = new SqlCommand("select * from table1", sqlConnection);
sqlConnection.Open();
SqlDataReader reader = sqlCommand.ExecuteReader();
GridView1.DataSource = reader;
GridView1.DataBind();
}

You run the code and you can see the result. But when you see the data binding for DataGridView in the following section, it is quite different.

II. Populate DataGridView control with SQL statement for Window form based application

When I used the DataGridView control in C# in MS Visual Studio 2005, I found DataGridView control is not friendly to use. Windows form-based DataGridView control is different from web based GridView control. DataGridView doesn’t have DataBind() method. It took me a few days to figure out.

The logic is like this :

Create data set from SQL statement or stored procedure
Create a table to hold this data set
Create a BindingSource and bind this table with this BindingSource
Then bind this BindingSource with GridView control.

This looks trivial. But I found it is very efficient and error free.

Let us put DataGridView control and BindingSource control on the windows form from Toolbox. Let us name DataGridView control as dbGridView, BindingSource control as dbBindSource. Let us apply the following code:

private void Form1_Load(object sender, EventArgs e)
{
string strCon = "Data Source=dbServer;Initial Catalog=testDB;Integrated Security=True";
string strSQL = “select * from table1”;
SqlDataAdapter dataAdapter = new SqlDataAdapter(strSQL, strCon);
SqlCommandBuilder commandBuilder = new SqlCommandBuilder(dataAdapter);
// Populate a new data table and bind it to the BindingSource.
DataTable table = new DataTable();
table.Locale = System.Globalization.CultureInfo.InvariantCulture;
dataAdapter.Fill(table);
dbBindSource.DataSource = table;
// Resize the DataGridView columns to fit the newly loaded content.
dbGridView.AutoResizeColumns(DataGridViewAutoSizeColumnsMode.AllCellsExceptHeader);
// you can make it grid readonly.
dbGridView.ReadOnly = true;
// finally bind the data to the grid
dbGridView.DataSource = dbBindSource;
}


Now we compile it and run it. You can see the data in the grid.

Datagrid - Editing, Updating, Cancel, Selecting Rows

Datagrid - Editing, Updating, Cancel, Selecting Rows

Introduction:
Microsoft.net framework ships with many usefull controls. These controls makes the life of developer easy by providing them with the functinality they want.
Among those many controls is the DataGrid control which helps the developer to display the data on the screen in the format of an arranged table. Datagrid is one of the 3 templated controls provided by the Microsoft.net framework. The other two are DataList and the Repeator control. Many new controls are being developed everyday but their basic idea is inherited from the classic DataGrid control.
In this article we will see the most common use of the datagrid control. Lets set up out datagrid.

Setting up the Datagrid:

Lets first set up our datagrid.
1. Drag and Drop the datagrid control from your toolbox to the webform.
2. The datagrid will appear as a simple table.
3. You can make the datagrid pretty by selecting the Auto format features.
Okay your datagrid is set up, lets add some columns.
Adding the Bound Columns:
Adding the bound colums in the datagrid is pretty simple.
1. Right click on the datagrid and select Property Builder.
2. Click on the Columns tab and uncheck "Generate columns automatically".
3. Add three bound columns, give the columns some name in the column name field. And finally add the edit,update,cancel buttons which can be found under the button option.
Note: Please also note that the button type should be link button or else it wont work.

Storing the database connection:
In this demo I am storing the database connection in the Web.config file. The database name is DBSnippets, which has one table known as tblPerson. Here is the web.config file.

Okay till now we have made the Datagrid and also saved the connection string in the web.config file. Now the time has come to code and handle the events.
Lets first make the BindData method which will retrieve the contents from the database and bind it on the screen. This will be one of the most important methods since it will be called whenever the page is loaded for the first time.

private void Page_Load(object sender, System.EventArgs e)
{
if(!Page.IsPostBack)
{
BindData();
}
}

As you see the BindData method is called when the page is not posted back. Now lets see the BindData method in details.

public void BindData()
{
SqlCommand myCommand = new SqlCommand("SP_SELECT_PERSONS",myConnection);
myCommand.CommandType = CommandType.StoredProcedure;
SqlDataAdapter myAdapter = new SqlDataAdapter(myCommand);
DataSet ds = new DataSet();
myAdapter.Fill(ds,"tblPerson");
myConnection.Open();
myCommand.ExecuteNonQuery();
myDataGrid.DataSource = ds;
myDataGrid.DataBind();
myConnection.Close();
}

Explanation of the BindData method:
1. First we make a SqlCommand object and named it myCommand. The SqlCommand object takes a stored procedure as an input and the SqlConnection.
2. We feed the command object to the DataAdapter object named as myAdapter.
3. A dataset is declared which is filled with the result of the Stored procedure.
4. myDataGrid.DataBind() binds the datagrid to the page. Don't forget to bind the grid or else it won't be displayed.
5. Later we opened the connection and execute the query.
Now Lets see the stored procedure.

Stored Procedure:

CREATE PROCEDURE SP_SELECT_PERSONS
AS
SELECT * FROM tblPerson GO

As you can see that the above Stored Procedure is pretty simple. All we are doing is we are just selected all the columns from the table person.
Lets now make the Edit method which will display textboxes inside the datagrid so that a user can insert data. This sort of editing is also known as Inline editing.
Making datagrid editable is pretty simple. All you to do is to code few lines in the EditCommand event of the datagrid. You can view all the events supported by DataGrid by selecting properties and than selecting the Thunder/Flash yellow sign at the top of the properties window.

Lets call our Edit DataGrid event Edit_DataGrid.

private void Edit_DataGrid(object source, System.Web.UI.WebControls.DataGridCommandEventArgs e)
{
// We use CommandEventArgs e to get the row which is being clicked
// This also changes the DataGrid labels into Textboxes so user can edit them
myDataGrid.EditItemIndex = e.Item.ItemIndex;
// Always bind the data so the datagrid can be displayed.
BindData();
}

When the Edit link button is clicked your DataGrid will look something like this:

As you see when you click the edit link the update and the cancel link button automatically appears.
Lets now see the code for the Cancel Event. Cancel event is used when you are in the edit mode and you change your mind about not to edit. So you click the cancel link button and the Datagrid returns back to its orginal condition.

private void Cancel_DataGrid(object source, System.Web.UI.WebControls.DataGridCommandEventArgs e)
{
// All we do in the cancel method is to assign '-1' to the datagrid editItemIndex
// Once the edititemindex is set to '-1' the datagrid returns back to its original condition
myDataGrid.EditItemIndex = -1;
BindData();
}

Okay now we come to a slightly difficult step. We will carefully look at the Update method and see how it works.

private void Update_DataGrid(object source, System.Web.UI.WebControls.DataGridCommandEventArgs e)
{
System.Web.UI.WebControls.TextBox cName = new System.Web.UI.WebControls.TextBox();
cName = (System.Web.UI.WebControls.TextBox) e.Item.Cells[1].Controls[0];
SqlCommand myCommand = new SqlCommand("SP_UpdatePerson",myConnection);
myCommand.CommandType = CommandType.StoredProcedure;
myCommand.Parameters.Add(new SqlParameter("@PersonName",SqlDbType.NVarChar,50));
myCommand.Parameters["@PersonName"].Value = cName.Text;
myConnection.Open();
myCommand.ExecuteNonQuery();
myConnection.Close();
myDataGrid.EditItemIndex = -1;
BindData();
}

Lets now dig into this method and see whats going on.
• The name of the method as you can see is Update_DataGrid, this event is fired when you click the update link button which appears after clicking the edit button.
• We declare a variable of TextBox type and call it cName. The reason of declaring a TextBox is that the value that we want is inside the TextBox which is inside the DataGrid control.
• Later we made the SqlCommand object which takes stored procedure "SP_UpdatePerson", which will be discussed afterwords.
• After marking the command object with the stored procedure we passed the parameter which is PersonName.
• Finally we execute the Query and set the editItemIndex property of the DataGrid '-1' which will bring the datagrid back to its original form i.e without any textboxes.
• Don't forget to bind the datagrid.

Update Stored Procedure:

CREATE PROCEDURE SP_UpdatePerson
@PersonName nvarchar(50)
AS
UPDATE tblPerson SET PersonName = @PersonName WHERE PersonName = @PersonName;

Selecting Item from the Datagrid:

Another cool feature of the Datagrid control is that you can select any row from the datagrid and it will be displayed as the highligted row in the grid.
The highlight row event is called SelectedIndexChanged event. The event is called when the select column is clicked. The select column can be added to the datagrid using the property builder, just like we added "edit/cancel/update" link buttons.

// This event is fired when the Select is clicked
private void Select_DataGrid(object sender, System.EventArgs e)
{
// prints the value of the first cell in the DataGrid
Label2.Text += myDataGrid.SelectedItem.Cells[0].Text;
}

This method is pretty simple. When the datagrid select link button is pressed. We retrieve the item from the datagrid which is residing on the same row on which the link button is pressed. As we can see above in the code that we are retrieving the value from the first column of the datagrid.