Dinesh's Blog ::::::: Being Compiled :::::::: .NET 2.0

Data source configuration wizard does not recognize the schema of the object

Tue, 11 Jul 2006 11:21:01 GMT

I noticed this while I was writing a sample application. If you go through the “Data Source Configuration Wizard” of a web control (ex. DropDownList) and if you select the “Specify columns from a table or view” option (like attached image), you will see that the schema of the table is not added and control will not be populated with data. Data can be populated without any problem if you select the first option. I’m not sure whether this is a bug or not but let me know if you know the reason for this.

The capacity of ArrayList is changed.

Thu, 29 Dec 2005 00:33:15 GMT

Did you notice that the default capacity and capacity once filled are changed in net 2.0? Yes, with 1.0 and 1.1 the default capacity of the ArrayList is 16. But with version 2.0, the default capacity is 0 and once added, it is 4. Has performance been more considered?

check and see the below code with both 1.1 and 2.0

System.Collections.ArrayList arrayList = new System.Collections.ArrayList();
Console.WriteLine(arrayList.Capacity);
arrayList.Add(1);
Console.WriteLine(arrayList.Capacity);

Mobile .NET Development Environment

Thu, 24 Nov 2005 01:36:00 GMT

Almost all developers customize their development environment for their won programming style. VS 2005 is open for extensive customization and because of that we can control the entire environment by setting as we want to use and we want see.

One nice feature of this is ability to save the configuration of the style we applied and load it when we want. If you are a person who does demonstration by using something like projectors, surely you need to have different font settings for demonstration. Having a saved development environment will be a smart option for this kind of purposes.

Not only that, having a mobile development environment will help you to have the same environment on all the machines you use.

Exporting (saving) and importing (loading) can be done through “Import and Export Settings…” menu item under “Tools”. Files saved are stored with “vssettings” extension.

Wanna see diagnostic details of SQL Server with single line of code?

Tue, 22 Nov 2005 02:25:48 GMT

How nice if you can obtain some statistics of the connection like ConnectionTime, RowsSelected and NofRoundTrips with less codes? Yes, now you can. What you have to do is, simply make StatisticsEnabled of SqlConnection true. Once it is closed, you can get all you need with RetrieveStatistics method. See the code below.

SqlConnection sqlConnection = new SqlConnection("Server=(local);Database=AdventureWorks;Integrated Security=SSPI");
//Enabling the statistics collector
sqlConnection.StatisticsEnabled = true;

SqlCommand sqlCommand = new SqlCommand("SELECT * FROM Person.Address", sqlConnection);
sqlConnection.Open();

//edxecuting first command
SqlDataReader sqlDataReader = sqlCommand.ExecuteReader();
sqlDataReader.Close();

//executing second command
sqlCommand.CommandText = "SELECT * FROM Person.Contact";
sqlDataReader = sqlCommand.ExecuteReader();
sqlDataReader.Close();

sqlConnection.Close();

//load statistics to dictionary
Hashtable statistics = (Hashtable) sqlConnection.RetrieveStatistics();
foreach (string key in statistics.Keys)
{
Console.WriteLine(key + ": " + statistics[key]);
}

Is it useful?

Is it smart relative of Ternary Operator?

Sun, 20 Nov 2005 18:06:43 GMT

Accidentally I found this new operator while I was searching for best ways to convert nullable types to non-nullable types. Have you heard about it? It is “??” operator. You might have heard about it. Let’s see how to use it.

//declare nullable int variable
int? nullableInt = null;

//declare non-nullable int variable
int nonNullableInt;

//Let's try to convert nullableInt into nonNullableInt
//first implicit conversion
nonNullableInt = nullableInt; //compiler error.

//explicit conversion
nonNullableInt = (int)nullableInt; //runtime error because nullableInt has no value

//using ternary operator
nonNullableInt = nullableInt == null ? 0 : (int)nullableInt;

//using new ?? operator
nonNullableInt = nullableInt ?? 0;

The “??” operator returns the right-side value (in this case 0) if the left-side (nullableInt) is null or else it returns the left-side. How useful it is? Seems it comes in handy with user-defined types too.

Employee employee1 = null;
Employee employee2 = employee1 ?? new Employee();

I surfed in the internet to find the name of it but couldn’t. If you know, please let me know.

Making a class with static members? Make it a Static Class.

Sun, 20 Nov 2005 07:54:46 GMT

Pretty sure that you have written a class that all members are static and it delivers only static members. And definitely, to avoid it get instantiated, you made the constructor private. Unfortunately, still it is open to write members without static keyword and complier won’t enforce to write only static members.

Now we do not want to worry about adding private constructor and make sure all members are static because C# 2.0 provides a facility make your CLASS static. One advantage of static class is, compiler enforce to make all members added static. So, you won’t miss the static keyword for methods. Another advantage is, no more private constructors are required to stop it get instantiated because once the class is made as static, it cannot be instantiated. See the simple example below and make sure you do it next time.

public static class Class1
{
   public static void TestMethod()
   {
      Console.WriteLine("This is test method.");
   }
}

Time is ripe for use of Database Project

Mon, 03 Oct 2005 01:15:31 GMT

In most of applications, Database is part of it. How do you develop and manage your database? Did you use Database Project for managing your application’s database? If yes, you know how rich it is and how useful it is. If no, have a look on guidelines below and see whether you can use it and make your life little bit easy.

Database Project is a special type of VS.Net project that allows us to design, test, run and manage SQL scripts and queries. Database Projects can be added to the solution just like other projects with the reference to database need to be managed. Have a look on the image below that shows the added Database Project and Server Explorer.

VS will automatically create three folders for us that allow us to store scripts and queries. We can add new scripts under “Create Scripts” folder by simply right clicking on the folder and using one of the templates given. Not only that, we can generate scripts for already added objects in the server by using “Server Explorer” and store them under the same folder. To do this, the relevant object in the “Server Explorer” has to be selected and right clicked, then need to be clicked on the “Generate Create Script to Project” menu item. The VS will generate the script and add to the “Create Scripts”. The below image shows the way of generating the script for already added object and some manually added scripts.

If the object created is need to be changed, click on the “Open Table Definition” menu item. It will open the same dialog box that is used to modify tables in the SQL Server VS. Once changed, remember, before saving the object, click on the “Generate Change Script”. It will automatically add the script of the changed item into “Change Scripts”.

The adding change scripts to the folder can be automated by checking the “Automatically generate change script on every save” in the “Generate Change Script” dialog box. This will cause to generate all scripts for changed items when the item is saved. Remember, the change script has to be named in proper manner to identify the change. I have been trying to find a way to automate the naming change scripts (like Customer_20050820) with Macro but so far, unsuccessful. Does it solve your versioning problem with scripts?

So, what do you think? Is this an easy way to develop and manage the database layer of our application? We should not forget that this project can be added to the Visual Source Safe too that allows us to manage scripts efficiently among the team.

I really want to enlarge on this, so keep your eye open.

AsyncCallback with ADO.NET

Wed, 28 Sep 2005 01:20:10 GMT

I am pretty sure that you have already tested asynchronous execution with ADO.NET 2.0. One of the asynchronous models comes with ADO.NET 2.0 is “callback model” that let us to use AsynchCallback delegate that allows to specify callback routine that will be executed when the asynchronous process completes. Have a look on the simple code snippet.

string connectionString = "Server=dinesh;Database=Test01;Integrated Security=True;Asynchronous Processing=true";
string updateStatement = "UPDATE TestTable02 SET NewColumn = 1 WHERE Id % 2 !=0";
SqlConnection sqlConnection = new SqlConnection(connectionString);
SqlCommand sqlCommand = new SqlCommand(updateStatement, sqlConnection);

sqlConnection.Open();
AsyncCallback myCallBack = new AsyncCallback(CallBackMethod);
IAsyncResult result = sqlCommand.BeginExecuteNonQuery(myCallBack, sqlCommand);

private void CallBackMethod(IAsyncResult result)
{
   SqlCommand sqlCommand = (SqlCommand)result.AsyncState;
   int nofRows = sqlCommand.EndExecuteNonQuery(result);
   MessageBox.Show(nofRows.ToString());
}

With this code snippet, a new instance of AsyncCallback is created and used with command exeution that allows us to cotinue the code after command executiion without waiting for the completion. As soon as the query is completed, the callback is called with the reference of AsyncResult that is autometically created by the BeginExecuteNonQuery command. As soon as the test is sucessful, I relasized that this comes in handy with almost all our database operations.

OK, now I have a small problem with AsyncCallback. Can’t I use this with console applications? I tried simulate the same with console application, but it gives me a compile error with AsycCallback declaration. Here is the exact error: “An object reference is required for the nonstatic field, method, or property”. Can you guys tell me the reason for this?

Opening Multiple Active Result Sets over the same connection

Sat, 24 Sep 2005 02:16:31 GMT

If you have opened a row set with the sql connection using ADO.NET 1.x, you can’t use the same connection for opening the second row set until the first one is closed. This limitation is overridden by ADO.NET 2.0, which means we can open multiple active result sets over the same connection and access them concurrently. The below code written for demonstrating the way of opening and fetching multiple row sets over the same connection and access them concurrently.

string connectionString = "Server=dinesh;Database=Test01;Integrated Security=True;";
string firstCommandText = "SELECT Id, FirstName FROM Employee";
string secondCommandText = "SELECT LeaveDate FROM Employee_Leave WHERE EmployeeId = @EmployeeId";

//declare the connection and datareaders
SqlConnection sqlConnection = new SqlConnection(connectionString);
SqlCommand firstSqlCommand = new SqlCommand(firstCommandText, sqlConnection);
SqlCommand secondSqlCommand = new SqlCommand(secondCommandText, sqlConnection);
secondSqlCommand.Parameters.Add(new SqlParameter("EmployeeId", SqlDbType.Int));

//open the connection and get row set
sqlConnection.Open();
SqlDataReader firstReader = firstSqlCommand.ExecuteReader();

//access the first data reader
while (firstReader.Read())
{
Console.WriteLine(Convert.ToString(firstReader["FirstName"]) + ":");

   //open the second rowset with same connection and access it concurrently
   secondSqlCommand.Parameters["EmployeeId"].Value = Convert.ToInt32(firstReader["Id"]);
   SqlDataReader secondReader = secondSqlCommand.ExecuteReader();

   while (secondReader.Read())
   {
      Console.WriteLine(Convert.ToString(secondReader["LeaveDate"]));
   }
   secondReader.Close();
}
firstReader.Close();
sqlConnection.Close();

Not only this, ADO.Net 2.0 provides the ability to execute multiple commands concurrently and asynchronously. Yes, you heard the word, asynchronously. We have been given three distinct techniques called; polling, callback, wait for access and execute data asynchronously. Let me post some ins and outs of this with in-coming posts.

Built-In Stopwatch

Thu, 15 Sep 2005 07:13:28 GMT

How many instances you had to measure the performance of your code? And how did you measure it? If you were working with .net 1.1, you must have created a stopwatch using either Environment.TickCount or QueryPerformanceCounter API. The wonderful news is, with .net 2.0, you do not need to worry about creating stopwatch. It is available with framework: System.Diagnostics.Stopwatch. See now how simple it is.

System.Diagnostics.Stopwatch stopwatch = new System.Diagnostics.Stopwatch();

stopwatch.Start();
for (int x = 0; x < 1000000; x++)
{
}
stopwatch.Stop();
Console.WriteLine(stopwatch.ElapsedMilliseconds.ToString());

Not only “ElapsedMilliseconds”, you can get TimeSpan too.

Why Observer pattern APIs under java.util namespace?

Tue, 30 Aug 2005 00:23:41 GMT

If you are a java developer, you know that java has built-in support for Observer pattern APIs. I just searched the on the .net 2.0 class library for finding similar. Yes, I found the API but under java.util class library. I just wonder why this has been implemented under java.util instead of something called "system.util". Do you know the reason?

Anyway, here is the way of using the Observer pattern APIs. Remember, you need to import the java.util library.

class MyContainer : Observable
{
private string _color;

public string Color { get { return _color; } }

   public void colorChanged()
   {
      setChanged();
      notifyObservers();
   }

   public void SetColor(string color)
   {
      _color = color;
      colorChanged();
   }
}

class MyCircle : Observer
{
private string _color;
private Observable _observable;

   public MyCircle(Observable observable)
   {
      this._observable = observable;
      observable.addObserver(this);
   }

public string Color {get {return _color;}}

#region Observer Members

   public void update(Observable o, object arg)
   {
      if (o is MyContainer)
      {
         MyContainer myContainer = (MyContainer)o;
         _color = myContainer.Color;
      }
   }

#endregion
}

class MyTriangle : Observer
{
private string _color;
private Observable _observable;

   public MyTriangle(Observable observable)
   {
      this._observable = observable;
      observable.addObserver(this);
   }

public string Color { get { return _color; } }

#region Observer Members

   public void update(Observable o, object arg)
   {
      if (o is MyContainer)
      {
         MyContainer myContainer = (MyContainer)o;
         _color = myContainer.Color;
      }
   }

#endregion
}

MyContainer myContainer = new MyContainer();
MyCircle myCircle = new MyCircle(myContainer);
MyTriangle myTriangle = new MyTriangle(myContainer);

myContainer.SetColor("Blue");
Console.WriteLine(myCircle.Color);
Console.WriteLine(myTriangle.Color);

myContainer.SetColor("Red");
Console.WriteLine(myCircle.Color);
Console.WriteLine(myTriangle.Color);

myContainer.SetColor("Blue");
Console.WriteLine(myCircle.Color);
Console.WriteLine(myTriangle.Color);

To brush up on Observer Pattern, here is the definition: The Observer Pattern defines a one-to-many dependency between objects so that when one object changes state, all of its dependencies are notified and updated automatically.