Dhanushka's Web Blog

Only encode URL special characters in a string

2012-01-12T00:04:00.003+05:30

When it comes to encoding special characters with reference to URLs, we can easily make use of the functions that have been defined inside System.Web.dll assembly.

Although this is the most straight forward hassle free way to encode a string to make it compatible in a HTTP context, in some scenarios we don’t get that privilege automatically (e.g. non web applications).

I ran into such scenario when I was developing a SQL Server user defined function from VS 2010.

The special problem in that occasion was that when you add an assembly reference in a SQL CLR project the reference is fetched from the GAC in data base server.

Microsoft have added a set of assemblies which they have identified as safe assemblies to be referenced by a T-SQL function to the GAC giving us the ability to use the functionality defined in those classes. But unfortunately System.Web.dll is not one of them.

So what will be the work around, an another function we can use for URL encoding can be found inside System.Uri name space, which fortunately resides inside System.dll.

OK, so how to use it to only encode URL special characters!!

Simple just use the power of “Regular Expressions”.

Here is the function I wrote.

private static string EncodeUrl(string toEncode)

{

const string pattern = "[$&+,/:;=?@]";

var match = Regex.Match(toEncode, pattern);

while(match.Success)

{

toEncode = toEncode.Replace(match.Value, Uri.EscapeDataString(match.Value));

match = Regex.Match(toEncode, pattern);

}

return toEncode;

}

The function checks the passed string repeatedly until all special characters are replaced with their respective encoded values.

The combination of Regex.Match and string Replace functions make sure that only the characters that are defined in the regular expression pattern are replaced.

Tackling Invariance using Covariance and Contra variance in C#

2011-12-06T13:05:00.001+05:30

Invariance is a concept that can be seen in almost all the programming languages that have a type system. And before we delve in to more language specific constructs, let’s see what all this big words mean when it comes to a language.

Covariance is the ability to convert data from wider to narrow data types. (E.g. long to int).

Contra variance is the ability to convert data from narrow to wider data types. (E.g. int to float).

Invariance is the inability to do conversion between data types.

In other words if we read closely in between the lines you’ll see that covariance preserves assignment compatibility while contra variance reverses it, and when both covariance and contra variance work together in tandem they make sure that invariance is avoided when needed.

Ok, with that theory part covered let’s look at an example, where which can expose the invariant behavior of C#

And the example I’ll be using will be a scenario where we will implement a generic interface for an imaginary inventory.

Let’s have a look at the code first

The IStorage interface defines two generic methods that facilitate storing and retrieving items from a generic List, and as you can see since there are no restrictions applied for type “T” in the implementing class BasicStorage or in the interface, any kind of data can be stored in our List repository. Let’s write some code to use this inventory of ours.

In the above code I’m using the generic interface as the base type to access the implemented functionality because the class has implemented the methods explicitly in its code.

And when the above code is written all will work fine just the way we planned.

Ok, now what will happen if we try to store data of type object in our repository, to do that we will have to convert our inventory01 variable to an instance of type IStorage<object>

And since all strings are objects and object is the base type for all types we should be able to do just that in our code. So let’s write some code to do that.

Hmm…

Although it makes sense to convert a string to an object the .net framework is throwing an error when we try to do that, but why?

If you look at it closely you will see that although all strings are objects, the converse is not true, all objects are not strings.

If the above restriction was not applied by the framework you would have been able to does something like this.

As you can see this code will try to store an ArrayList on a memory location which is structured to store a string, and it will clearly mess up the type safety of the .net framework.

This is the invariant behavior of .net. C# adds invariance to the type system to ensure type safety in our programming constructs.

According to the language specification, In C# Generic Interfaces are Invariant by default while Generic Classes are always Invariant.

With that in mind, let’s have a look at the same example from a deferent perspective.

This time, let’s use two deferent interfaces to store and retrieve data.

Now IDepostior have the storage facility while IRetriever provides us with reading functionality

The code that uses this new structure will look like this.

Here we cast an instance of “Storage<string> inventory02” to type “IDepostior<string> store” to store data, while we cast the same “inventory02” object to “IRetriever<string> retriever” to retrieve data.

With that said, will the following line of code work now?

Storage<string> inventory02 = new Storage<string>();

IRetriever<string> retreiver = inventory02;

IRetriever<object> objectRetreivor = inventory02;

The answer is “NO”.

In the previous example it made sense. Does it make the same sense now?

Here IRetriever interface only provides you with means to read data, and it doesn’t expose any method to store data. Because of that, you cannot store incompatible types in the underlying storage now. So the loop hole that allowed the previous example to break the type safety is no longer present in this interface. In other words, now it’s perfectly safe to convert IRetriever<string> to IRetriever<object>.

In situations like this, where the type parameter only acts as a return value of a method in a generic interface, we can tell to the compiler that some implicit conversions are legal and type safety does not have to be imposed on a type all the time. To do that we can use the “out” keyword.

And the modified IRetriever interface will look something like this.

Now we have just used Covariance to preserve assignment compatibility where it makes sense.

Right! Now let’s have a look at the other interface which allows us to store data. Will this be ok?

Storage<object> inventory03 = new Storage<object>();

IDepostior<string> depositor = inventory03;

Let’s think of it like this. All strings are objects, so if you can perform a specific behavior on a variable of type object, you should be able to carry out the same thing on a variable of type string.

In other words, if “B” derives from “A” and if type “A” exposes a set of members (behaviors, properties, etc…), type “B” must also expose the same set of members too.

So anything that can be carried out on A must also be supported by B.

So if we consider our IDepostior example, if we can store objects and do some exercises on them, we should be able to store strings and do the same set of exercise on them too.

That sounds correct, but there must be a way for us to tell to the complier that operations which will be carried out on the generic typed items will only be operations which are specified on the most generalized type in the inheritance hierarchy. Or in other words only the operations supported by objects will be carried out on our type.

We do that using the keyword “in”.

The “in” keyword tells the compiler that, you can either pass type “T” as a parameter type to methods or pass any type that derives from “T”. And you cannot use “T” as a return type of a method.

So the modified interface will look something like this.

Now we can reference an object either through a generic interface based on the object type or through a type that derived from that object type. And by adding the “in” key word, we’ve had made sure that the needed restrictions are there to make our assignment type safe.

With that, we have just used Contra variance to reverse Covariance and made classes in an inheritance hierarchy reference each other when the reference is type safe.

The completed interfaces will be…

If you have any questions, just add a comment and I’ll answer it as soon as I can.

Hope this clears thing up.

Performing Cross Domain Requests with JSONP and JQuery using C# - Part 01

2011-11-13T23:11:00.001+05:30

I will be breaking down the post in to two sections.

First I will mention how to accomplish above mentioned task using handlers and I will then go on and discuss the underlying concepts and basic theories for the beginners in the next section.

How to get it done!!!

What are the core parts we will need to perform a cross domain request using JavaScript?

A Mechanism to call the URL that sends data to the calling page.
A padded JSON object (or a JSONP object)

If the calling URL don’t support cross domain calls, functionality to wrap or pad the returned JSON object with a call back function.

A method to handle the call back.

OK! Let’s take this one step at a time.

In this example I will be using JQuery AJAX facilities to call the URL in the other domain.

jQuery.ajax

({

url: "http://www.crosseddomain.com/testPage.html,

dataType: "jsonp",

type: "GET",

cache: true,

jsonpCallback: 'handleResponse'

});

jsonpCallback option allows us to specify the call back method which will handle the returned data upon the response is received.

We specify cache as true to avoid the random time stamp value JQuery appends on the request.

dataType is set to jsonp so the call back function will be added to the request.

When the entire configuration is done correctly the page will send a request like http://www.crosseddomain.com/testPage.html&callback=handleResponse through the network.

Now all we have to do is write a function to handle the returned value, the function name should be the value we passed for the jsonpCallback option

function handleResponse(response) {

//your custom logic goes here

}

That will work only if the testPage.html wraps the response with the call back. Or in other words if the requested page is responsible for making the request cross domain compatible by converting the JSON object in to a JSONP object by adding the call back function around it.

What shall we do when we are given a URL that does not support cross domain script calls? How to make it JSONP compatible?

Normal JSON objects will not work across cross domains because of the same origin policy, which restricts browser side programming languages from accessing scripts in another site or a domain. (I will talk about these theory parts in detail on my next blog, so stay tuned).

So obviously it does not restrict server side programming languages like C# from accessing URLs in separate domains.

Keeping that in mind, we can send the request for the URL from server side, after receiving the normal response we can wrap it with the call back function and we can send it to the page where the call originated from.

To get this done we will use a generic web handler or an ashx file.

For demonstration purposes, the handler will be expecting some string data from the requesting page and it will send a dummy JSON object that contains user inputted data with some custom data from the server side. (To make things simple I will not add the code to do an actual web request, rather I will just hard code the JSON string).

I will add a text box to the page and will get the user input in each key press. After a response is received the call back function will display retrieved data in a label.

The HTML markup will be

<div>

Enter your text : <input type="text" id="suggest" name="Suggestion" />

div>

label>

And the JQuery request will look something like this.

$(document).ready(function () {

$("#suggest").keyup(function () {

var data = $("#suggest").val();

jQuery.ajax({

url: "http://localhost:18395/RequestHandler.ashx?data=" + data,

dataType: "jsonp",

type: "GET",

cache: true,

jsonpCallback: 'handleResponse'

});

The RequestHandler.ashx file code is mentioned below.

public class RequestHandler : IHttpHandler

{

public void ProcessRequest(HttpContext context)

{

var data = context.Request.QueryString["data"];

var callback = context.Request.QueryString["callback"];

var response = context.Response;

response.Clear();

response.ContentType = "application/json";

var sampleJson = "{\"firstName\":\"Dhanushka\",\"lastName\":\"Athukorala\",\"dataReceived\":\"" + data + "\"}";

var paddedResponse = string.Format("{0}({1})", callback, sampleJson);

response.Write(paddedResponse);

response.Flush();

}

public bool IsReusable

{

get

{

return false;

}

So let’s see what’s happening in the code behind file.

We retrieve data passed from the user from the query string (data variable)
Call back function name is also retrieved from the query string (callback variable)
A JSON object is created (this is the line where you have to call a URL and get data, you can use the functionalities implemented in HttpWebRequest, HttpWebResponse to accomplish this)
We wrap the final JSON object with the call back function so it will be in the format callback(JSON) making it a JSONP object (paddedResponse variable)
The JSONP object is written to the response making it available for the calling page.

Now when the response is flushed it will return back to the calling page. Here the script tag of that page will execute received data or the JSONP object, or in other words it will call the call back method with a JSON object.

The code for our call back method is mentioned below.

function handleResponse(response) {

var data = eval(response);

var firstName = data.firstName;

var lastName = data.lastName;

var sentData = data.dataReceived;

$("#results").html("First Name : " + firstName + "
Last Name : " + lastName + "
Sent Data : " + sentData);

}

This call back method will process the returned JSON string and will print the containing information in the results label

So in a nut shell the codes we need are

Script tag and the HTML

Handler code

And the out put will be

Hope it helps.

I will explain the underlying principals of cross domain communication with scripts in the second part of this blog.

Cheers!!

LINQ – SQL Syntax Difference Explained.

2011-11-12T22:03:00.001+05:30

I got my blogger hat on after a very long time. With all the week end lectures and office works cramping up my schedule, there was virtually no time left for me to blog about anything. I came across pretty interesting topics and subjects over my past few non blogging months and will try to share them with you in the coming days.

Ok let’s get started…

Let’s say we are writing a SQL query to retrieve the names of the customers who are above 20, we will write something like this

select cust.name

from customers cust

where cust.age>20

But when it comes to LINQ, as we all know the syntax is totally inverted.

The same query will look like this when we do it on a list of Customer objects.

IEnumerable<string> olderCustomersQuery = from cust in customers

where cust.Age > 20

select cust.Name;

But WHY!!!

To understand we need to get back to basics.

There are two ways to build up a LINQ expression, Extension methods and Query operators. The one mentioned above falls in to the latter part.

Let’s see how to write the same example using extension methods.

IEnumerable<string> olderCustomersExtension = customers

.Where(cust => cust.Age > 20)

.Select(cust => cust.Name);

All these extension methods are available on any class that implements the generic IQueryable or IEnumerable<T> interfaces.

So what’s up with the ordering of the method calls, why do we need to call the “Where” extension method before calling “Select”.

The answer is simple.

Where filters data that are returned from a data source.

While Select narrows down the information that shown in the final projection by specifying which properties to retrieve.

So when I say customers.Select(cust => cust.Name) it just gives me a list of strings so customers.Select(cust => cust.Name).Where(cust => cust.Age > 20) will not be possible because now the Where clause don’t get a customer object to query on.

Because of that when we are writing LINQ expressions we should use the extension methods in the correct order, otherwise you may get unexpected query results or compilation errors.

Although the LINQ extension methods and types that are defined in System.Linq namespace are very powerful, the syntax can be quite cumbersome, and it is easy to introduce subtle errors that are difficult to spot and correct.

To avoid these drawbacks designers of C# have provided an alternative approach to the use of LINQ, through a series of LINQ query operators that are part of the C# language.

There is an equivalent query operator for each LINQ extension method.

Because these query operators are built to compliment the functionality of the equalant extension methods. They should also follow the above mentioned practices and rules to avoid any kind of side effects on the data that will be retrieved by the LINQ expression.

Hope this clears things up!!

LINQ to SQL with Views

2011-01-11T09:50:00.004+05:30

We all know that data manipulation using tables have been made very easy by LINQ to SQL right! For an example a sample data retrieval and update query using LINQ will look something like this.

I'll just note down the steps involved so rookies will have an idea of what I'm talking about

Add a new LINQ to SQL class file (.dbml) to your project
Then drag and drop a table you want to query using the server explorer of VS (lets name the new file as Demo.dbml)

Here is some sample code to get you started with

var context = new DemoDataContext(); //get the data context you want to query
//retreive data from the table
var records = from tableTest in dc.DemoTable
              where tableTest.condition == -1
              select tableTest;

Now let's play with them a bit

foreach (var record in records){
try
   {
    var rowInfo = context.DemoTable.Single(ob => ob.Id == rec.Id);
    var someValue=GetValue();
    rowInfo.condition = someValue > 0 ? 1 : 0; //Change a value of a property
    context.SubmitChanges();//Save the changed data to the table
   }
catch (Exception ex)
{
    Console.WriteLine(ex.Message);
    continue;
}
}

That's really straight forward right! We can use the same set of steps to manipulate data using SQL Views. But there seems to be some sort of a bug in VS2010 when using LINQ to SQL class files. When we drag and drop a table to a dbml file the primary key of the table is identified and is set correctly. But if we use a VIEW that incorporates a set of tables using UNIONS this does not happen. Making it impossible to save or update data in the underlying table because of the missing primary key. You will run the same code for a view but no data will get saved.
To avoid such a bizarre situation you need to manually set the primary key of the view using properties. To do that select the view that you needs to work on and in its attributes set click on its primary key column and go to its properties. And set the Primary Key property to true.

Now you will be able to work with your views without any problems.

JQuery Gantt chart

2011-01-04T10:34:00.003+05:30

I came across a very useful plug-in few days back for drawing Gantt charts using JQuery. You can find all the information plus the files you need to download from here (https://github.com/thegrubbsian/jquery.ganttView).

As I described previously from a blog when we drew JQuery charts, we can use the power of JSON to get serialized data from the server side to populate the needed data model. In this case the the data model looked something like this.

var ganttData =
[
    {
        id: 1, name: "Feature 1",
        series:
        [
            { name: "Planned", start: new Date(2010,00,01), end: new Date(2010,00,03) },
            { name: "Actual", start: new Date(2010,00,02), end: new Date(2010,00,05) }
        ]
    },
    {
        id: 2, name: "Feature 2",
        series:
        [
            { name: "Planned", start: new Date(2010,00,05), end: new Date(2010,00,20) },
            { name: "Actual", start: new Date(2010,00,06), end: new Date(2010,00,17) },
            { name: "Projected", start: new Date(2010,00,06), end: new Date(2010,00,17) }
        ]
    }
]

In order to tackle this, my server side data model should look something like this.

public class ContainerModel
{
   public String id { get; set; }
   public String name { get; set; }
   public List<DataModel> series { get; set; }
}
public class DataModel
{
   public string name { get; set; }
   public DateTime start { get; set; }
   public DateTime end { get; set; }
}

Let's write a sample method to populate the data model with some dummy data.

public static List<ContainerModel> PopulateData(){
var startDate = new DateTime(2010, 5, 12);
var endDate = new DateTime(2010, 12, 5);

var planned = new DataModel { name = "Planned", start = startDate, end = endDate };
var actual = new DataModel { name = "Actual", start = startDate, end = endDate };
var projected = new DataModel { name = "Projected", start = startDate, end = endDate };

var dataSet = new List<ContainerModel>();
for (int k = 0; k < 10; k++){
    var container = new ContainerModel{
                          id = k.ToString(),
                          name = string.Format("Feature {0}", k),
                          series = new List<DataModel> { planned, actual, projected }
                        };
    dataSet.Add(container);
}
return dataSet;
}

And these methods were used to serialize the data model to JSON so we can use it from the JavaScript side.

private static string ToJson(this object obj){
var serializer = new DataContractJsonSerializer(obj.GetType());
var ms = new MemoryStream();
serializer.WriteObject(ms, obj);
var json = Encoding.Default.GetString(ms.ToArray());
return json;
}

public static string GetJason(List<ContainerModel> dataModel){
return dataModel.ToJson();
}

Let's write a web method so we can use a JQuery AJAX call back to retrieve the prepared data.
I have embedded the above mentioned PopulateData, ToJson, GetJason methods in to a Helper class for more code clarity

[WebMethod]
public static string GetData(){
var modelData = Helper.PopulateData();
var jsonData = Helper.GetJason(modelData);
return jsonData;
}

Now all our server side codes are completed, but then come the fun part. As you can see in the above mentioned data model the dates are represented as JavaScript Date objects
{ name: "Planned", start: new Date(2010,00,05), end: new Date(2010,00,20) },
But date returned by Json is a string that looks something like this "/Date(1273602600000+0530)/" .
In order to convert that JSON serialized millisecond date string to a JavaScript Date object, we can use JavaScript substring function with eval
startDate = eval("new " + start.substring(1, start.length - 7) + ")");
Resulting in returning a JavaScript Date object with a value like
"Wed May 12 2010 00:00:00 GMT+0530 (Sri Lanka Standard Time)"

So let's replace the DateUtils Class in the jQuery.ganttView.js with this one

var DateUtils = {
daysBetweenBothString: function (start, end){
    var startDate, endDate;
    startDate = eval("new " + start.substring(1, start.length - 7) + ")");
    endDate = eval("new " + end.substring(1, end.length - 7) + ")");
    var count = 0, date = startDate.clone();
    while (date.compareTo(endDate) == -1) { count = count + 1; date.addDays(1); }
    return count;
},
daysBetweenEndString: function (start, end){
   endDate = eval("new " + end.substring(1, end.length - 7) + ")");
    var count = 0, date = start.clone();
    while (date.compareTo(endDate) == -1) { count = count + 1; date.addDays(1); }
    return count;
},
daysBetween: function (start, end){
    var count = 0, date = start.clone();
    while (date.compareTo(end) == -1) { count = count + 1; date.addDays(1); }
    return count;
},
isWeekend: function (date){
    return date.getDay() % 6 == 0;
}
};

And the addBlocks method with this

addBlocks: function (div, data, cellWidth, start){
var rows = jQuery("div.ganttview-blocks div.ganttview-block-container", div);
var rowIdx = 0;
for (var i = 0; i < data.length; i++) {
   for (var j = 0; j < data[i].series.length; j++) {
   var size = DateUtils.daysBetweenBothString(data[i].series[j].start, data[i].series[j].end);
   var offset = DateUtils.daysBetweenEndString(start, data[i].series[j].start);
   var blockDiv = jQuery("<div>", {
     "class": "ganttview-block",
     "title": data[i].series[j].name + ", " + size + " days",
     "css": {
     "width": ((size * cellWidth) - 9) + "px",
     "margin-left": ((offset * cellWidth) + 3) + "px"
    }});
if (data[i].series[j].color){
   blockDiv.css("background-color", data[i].series[j].color);
}
blockDiv.append($("<div>", { "class": "ganttview-block-text" }).text(size));
jQuery(rows[rowIdx]).append(blockDiv);
rowIdx = rowIdx + 1;
}
}
}

Now you can use this modified version of the JS file to support your JSON serialized data object.
In the aspx page (in this case Default.aspx ) where we need to draw the chart insert the following script

<script type="text/javascript">
$(document).ready(function (){
var ganttData = [];
$("#btnGetData").live("click", function (e){
var button = $(this);
function onDataReceived(series){
ganttData = series.d;
$("#ganttChart").ganttView({
data: $.parseJSON(ganttData),
start: new Date(2010, 05, 01),
end: new Date(2010, 12, 31),
slideWidth: 900
   });
}
var dataUrl = "Default.aspx/GetData";
$.ajax({
   type: "POST",
   url: dataUrl,
   data: "{}",
   contentType: "application/json; charset=utf-8",
   dataType: "json",
   success: onDataReceived
});
});
});
</script>

And add the following div tag to the page so the JS file can inject the rendered Chart inside it
<div id="ganttChart"></div>
Accompanied with the button to trigger the AJAX call back
<div><input id="btnGetData" type="button" value="Get Data" /></div>

Now you are all set for your first JQuery Gantt Chart.

What is the difference between Value types and Reference types in .net

2010-12-27T12:11:00.005+05:30

I came across a pretty interesting series of articles when I was reading through Eric Lippert's MSDN blog today. Here are some of the things i grasped from him.

What is the first thing that comes to your mind when someone asks from you "What is the difference between value types and reference types?" Well I bet you will reply saying that value types are allocated in the stack and reference types are allocated in heap, right! Well you are correct that's what the C# documentation tells us. Then why don't we just call them stack types and heap types instead of value and reference. Well that's because that is not true most of the time.

Let's take the following class as an example.

public class Demo
{
   private int ValueOne = 10;

   public int GetValue()
   {
    return ValueOne;
   }
}

Here the variable "ValueOne" is defined inside the "Demo" class. Here although "ValueOne" is a value type integer variable it is an integral part of the "Demo" s instance memory. So it is allocated inside the heap.

Let's have a look at how this happens.

Before we dwell in to it, let's see what does the terms "short lived" and "long lived" stands for in context of variables

When a method is called an activation period is defined for that method, which can be defined as the time between the start of the method execution and its successful return or a throwing of an exception. Code in the method may require allocation of storage in memory for its variables. Let's look at a simple example

public int GetSum()
{
   int x = 10;
   int y = 20;

   int sum = Add(x, y);

   return sum;
}

public int Add(int i, int j)
{
   return i + j;
}

Here when the method GetSum calls method Add, the use of the storage locations for the parameters passed to Add and the value returned by Add is required by GetSum. This means that the required life time of the storage location is actually longer than the activation period of the method, thus making it a long lived variable or storage.

So what does long/short lived stands for "If the required life time of a variable/storage is longer than its current method execution's activation period that variable is classified as a long lived variable otherwise a short lived one"

So how can value type variables get allocated inside the heap? Let's get to it one step at a time

There are three types of values in C#. Instances of value types, Instances of reference types and References.
There are storage locations in memory that can store values they are stack, heap and registers.
Every value that is managed by some kind of a program stores their values in these storage locations, as well as every reference other than a null reference.
Every storage location in memory which has some content in them has a life time.(short/long lived)
Long lived storage locations are always heap locations and short lived storage locations are always in stack or registers.
If the compiler cannot come to a clear decision if the variable is short lived or long lived that variable is considered as a long lived variable and is always stored in heap.

What happens is that during the compile time analysis if a local or a temporary variable is found to be un-used after the methods activation time it is stored on stack or register otherwise on heap. Depending on this model we can see that references and instances of value types are the same as far as their storage is concerned, but they can go on to either of those above mentioned storage locations depending on their life time.

So that leaves us with an explanation that actually does not explain any concrete thing.

Then what is the main, clearly distinctive difference between them. The best explanation is that "Value types are always copied by value and Reference types are always copied by reference" and we can also go on to say that "Value types semantically represents a value and Reference types are a semantic reference to something".

Break a string by character type

2010-12-24T10:10:00.001+05:30

Yesterday I came across an interesting situation. There are some times when you need to break a string in to two parts depending on their character type.
Lets say you have a string like "Welfare Fund - 1000.00" and you need to break the string part and the number part in to two different strings. Well the first thing that comes to mind is iterate the string till you get a number and break it to apart upon hitting on a number type character, right!!
Well then what about a string like "Welfare Fund : 2009 - 3000.00"
Here as you can see, there are numbers in the string part as well.

The solution is simple, all you have to do is iterate through the string by starting from its end, till you reach a blank space. Here is the a method to accomplish that task

public static List<string> BreakString(string stringToBreak)
        {
            var charArr = stringToBreak.ToCharArray();
            var stringAppender = new StringBuilder();
            var intAppender = new StringBuilder();
            var isSeparated = false;
            for (int i = charArr.Length - 1; i > -1; i--)
            {
                if (isSeparated)
                    stringAppender.Append(charArr[i]);
                else
                {
                    isSeparated = charArr[i] == ' ';
                    if (!isSeparated)
                        intAppender.Append(charArr[i]);
                }
            }
            var returnValues = new List<string> { ReverseString(stringAppender.ToString()), ReverseString(intAppender.ToString()) };
            return returnValues;
        }

public static string ReverseString(string s)
        {
            var arr = s.ToCharArray();
            Array.Reverse(arr);
            return new string(arr);
        }

You can call it as follows

var input = "Welfare Fund - 1000.00";
var result = BreakString(input);

Unit testing with Rhino Mock

2010-12-21T13:09:00.001+05:30

There are some pretty good Mock object frameworks available out there for .net like NMock, EasyMock, TypeMock, etc... But I think every one will ultimately wind up using Rhino Mock at the end because of its easy to grasp rich feature set. So lets see how we can use Rhino to to mock a layered architecture for unit testing purposes.

I will try to mock the repository and the service layer in the following code in an easy to understand manner

Here are my sample repository and service interfaces (I have used NHibernate and Windsor Castle in this project as the ORM solutionl)

Repository Interface

public interface IInventoryRepository : IRepository
    {
        List<RecordItem> Get(List<int> ids);
        List<RecordItem> Get(List<int> ids, string orderByColumn, string orderType);
    }

Service Interface

public interface IInventoryService
    {
        List<ServiceItem> Get(List<int> ids, int truncLength);
        List<ServiceItem> Get(List<int> ids, string orderByColumn, string orderType, int truncLength);
    }

As I have described in my previous post lest use Nbuilder to mock the test objects that needs to be returned when the methods in the repository are called

Mock return for List<RecordItem> Get(List<int> ids)
private static List<RecordItem> CreateRecordItems()
        {
            var items = Builder<RecordItem>.CreateListOfSize(10).WhereAll().Have(x => x.Title = "sample title").WhereAll().Have(x => x.AuthorName = "Dhanushka").Build().ToList();
            for (int i = 1; i < items.Count + 1; i++)
            {
                EntityIdSetter.SetIdOf(items[i - 1], i);
            }
            return items;
        }

Mock return for List<RecordItem> Get(List<int> ids, string orderByColumn, string orderType)
private static List<RecordItem> CreateRecordItemsDesc()
        {
            var items = Builder<RecordItem>.CreateListOfSize(10).WhereAll().Have(x => x.Title = "sample title").WhereAll().Have(x => x.AuthorName = "Dhanushka").Build().ToList();
            var j = items.Count;
            for (int i = 1; i < items.Count + 1; i++)
            {
                EntityIdSetter.SetIdOf(items[i - 1], j);
                j--;
            }
            return items;
        }

Now lets use Rhino Mock to mock the Method Calls to the repository

public static IInventoryRepository CreateMockInventoryRepository()
        {
            var mocks = new MockRepository();
//specify the repository to mock
            var mockedRepository = mocks.StrictMock<IInventoryRepository>();

//specify what to return when a specific method is called in the mocked repository
            Expect.Call(mockedRepository.Stub(x => x.Get(Arg<List<int>>.Is.Anything)).Return(CreateRecordItems()));
            Expect.Call(mockedRepository.Stub(x => x.Get(Arg<List<int>>.Is.Anything, Arg<string>.Is.Anything, Arg<string>.Is.Equal("asc"))).Return(CreateRecordItems()));
            Expect.Call(mockedRepository.Stub(x =>x.Get(Arg<List<int>>.Is.Anything, Arg<string>.Is.Anything, Arg<string>.Is.Equal("desc"))).Return(CreateRecordItemsDesc()));

//mock the current data base context
            var mockedDbContext = mocks.StrictMock<IDbContext>();
            Expect.Call(mockedDbContext.CommitChanges);
            SetupResult.For(mockedRepository.DbContext).Return(mockedDbContext);

            mocks.Replay(mockedRepository);

            return mockedRepository;
        }

As you can see this method mocks the repository with specification for method calls return values and reveal the mocked repository to the outer world.

Now lets used this mocked repository to mock the service layer

public static IInventoryService   CreateMockClipboardService()
        {
            var serviceMock =new InventoryService(InventoryRepositoryMock.CreateMockInventoryRepository());
            return serviceMock;
        }

Here the dependency injection is used with Windsor Castle to inject the service with the mocked repository layer.

Now to write a sample test using NUnit all you have to do is
[TestFixture]
    public class ServiceTest
    {
        private IInventoryService _service;

        [SetUp]
        public void SetUp()
        {
            _service = new InventoryService(InventoryRepositoryMock.CreateMockInventoryRepository());
        }

        [Test]
        public void GetWithoutSortTest()
        {
            var idList = new List<int> {1, 2, 3, 4};
            const int truncLength = 100;
            var itemsReturned = _service.Get(idList, truncLength);

            var expectedItemType = typeof (ServiceItem);
            const string expectedAuthor = "Dhanushka";
            const string expectedTitle = "sample title";

            Assert.That(itemsReturned.Count, Is.GreaterThan(0),"no items returned");
            Assert.That(itemsReturned[0], Is.TypeOf(expectedItemType),"incorrect return type");
            Assert.That(itemsReturned[0].Author,Is.EqualTo(expectedAuthor),"unexpected author returned");
            Assert.That(itemsReturned[0].Title,Is.EqualTo(expectedTitle),"unexpected title returned");

        }
   }

Now we have a simple unit test in our hand that uses a mocked service and repository layer

Mocking objects using NBuilder

2010-12-21T11:24:00.000+05:30

Most of us use some sort of a mocking library when doing unit tests in order to mock our service and repository layers right!
Well I am a big fan of Rhino Mock and I have used it in almost all of my testing projects.
But one thing that remains to be a pain in the ass is creating test objects to be returned when the mocked repository is called. Well not any more!!!

Using NBulder we can avoid hard coding test objects for mocking purposes.

Here are some sample codes to get you started with

Let's say you want to mock a a repository call that returns an item, just write
var item = Builder<RepositoyType>.CreateNew().Build();
//set the id property of each items (Nhibernate is used with Windsor Castle in this occasion)
EntityIdSetter.SetIdOf(item, 1);

To mock a method call that returns a list of record objects.
var items = Builder<RepositoyType>.CreateListOfSize(10).WhereAll().Have(x => x.Title = "sample title").WhereAll().Have(x => x.AuthorName = "Dhanushka").Build().ToList();
for (int i = 1; i < items.Count + 1; i++)
{
EntityIdSetter.SetIdOf(items[i - 1], i);
}
As you can see from the above example we can even set specific values for the attributes for returned objects as well.

And there are many more helper functions you can use to accomplish almost all the test object creation needs you hope for.

Happy Coding!!

PasswordStrengthRegularExpression issue in MembershipProvider ResetPassword

2010-12-03T12:22:00.000+05:30

I came across an interesting issue today. I used the ResetPassword method provided by C# membership class to reset the password of a user and found out that although it allows us to define the password strength using a regular expression in the web.config file, it does not guarantee that the generated password adheres to the rules defined by the expression. Microsoft says and I quote
"The random password created by the ResetPassword method is not guaranteed to pass the regular expression in the PasswordStrengthRegularExpression property. However, the random password will meet the criteria established by the MinRequiredPasswordLength and MinRequiredNonAlphanumericCharacters properties."

So to tackle the issue, I used the Regex class. The revised code is shown below

var isNotMatch = true;
                    while(isNotMatch)
                    {
                        resetpwd = manager.ResetPassword();
                        var matcher=new Regex(Membership.PasswordStrengthRegularExpression);
                        isNotMatch = !(matcher.IsMatch(resetpwd));
                    }
This code snippet will force the ResetPassword to fire until a password adhering to the rules defined by the regular expression is generated.

JavaScript setAttribute not working for IE

2010-11-18T15:44:00.001+05:30

I came across an interesting problem when using java script "setSttribute" method with IE. Apparently it does not work with IE versions 5.5 to 7 when we try to use it to set a style to an element.

For all the browsers including IE8 and above this code will work fine when we a want to set a a style attribute to an element using java script.

var elemntToTest=document.createElement('a');
elemntToTest.setAttribute('href', '#');
elemntToTest.setAttribute('style', 'padding:3px');

but in IE 5.5-7 you will need to set the style like this.

elemntToTest.style.cssText = "padding:3px;";

Now it will work fine in all the browsers.

Hope this work around helps!!!

Flot, A pure JQuery Charting tool and How to get the maximum from it using JSON serialization in C#

2010-11-17T21:06:00.000+05:30

As we all know there are some pretty amazing and powerful charting tools available for web developers to use, some are commercial and some are free. But a main disadvantage i saw in many of them is that, almost all of them use flash to draw graphics and manipulate settings.

But there is some pretty sleek free JQuery chart plug-ins available out there. To name a few Flot, Google Charts, jQuery Chart, jQchart, TufteGraph etc...

After a brief R&D Flot attracted me most because of its rich options set and clean, easy to use and maintainable code.

Now I will explain how to draw a simple line chart using Flot in an ASP.net web site.

I will use AJAX calls to fetch data from the server to populate chart data sets in the following example. But rather than using page methods or update panels, I will use simple JQuery AJAX post backs ($.ajax) to accomplish data retrieving tasks.

So here we go...

Let’s take a look at how Flot accepts data to draw its chart. Here is a simple JSON object which will be used to draw the chart line.

{

label: 'Europe (EU27)',

data: [[1999, 3.0], [2000, 3.9]]

}

So let’s create a class similar to this JSON object so we can serialize an object of that class to something similar.

public class Model

{

public string label;

public List<List<int>> data;

}

And let’s write a Helper class containing simple methods that can be used to serialize the Model object to a JSON object.

public static class Helper

{

private static string ToJson(this object obj)

{

var serializer = new DataContractJsonSerializer(obj.GetType());

var ms = new MemoryStream();

serializer.WriteObject(ms, obj);

var json = Encoding.Default.GetString(ms.ToArray());

return json;

}

public static string GetJason(Model dataModel)

{

return dataModel.ToJson();

}

* DataContractJsonSerializer is inside the System.Runtime.Serialization.Json namespace

Now we will write a simple web method (web service method) that can be called from the client side JavaScript.

[WebMethod]

public static string GetData()

{

var dataModel = new Model {label = "Sample Chart"};

var dataList = new List<List<int>>();

for (int i = 1; i <>

{

var data = new List {i, (i*i) + 8};

dataList.Add(data);

}

dataModel.data = dataList;

return Helper.GetJason(dataModel);

}

This function will return a serialized data object like this.

{

"data":[[1,9],[2,12],[3,17],[4,24],[5,33],[6,44],[7,57],[8,72],[9,89]],

"label":"Sample Chart"

}

Now that's all from the server side. Let’s look at the client side javascript functions

In the aspx page add references to jquery.js and jquery.flot.js (download them from http://code.google.com/p/flot/downloads/list)

And inside the body add a div with the id "placeholder" to hold the chart.

add a button with the id “btnGetData” so we can fetch data upon user request

Here is the sample code to draw the chart using our predefined methods in the server side.

$(document).ready(function() {

//options that can be enabled in the chart, more options are available

var options = {

lines: { show: true },

points: { show: true },

xaxis: { tickDecimals: 0, tickSize: 1 }

};

var data = []; //data used to draw the chart

var placeholder = $("#placeholder"); //chart wrapper

$.plot(placeholder, data, options); //draw the chart

var alreadyFetched = {};

$("#btnGetData").live("click", function(e) {

var button = $(this); //get the clicked button

//execute this function after data is successfully retrieved from the ajax call

function onDataReceived(series) {

series = $.parseJSON(series.d); //get the json object (use the latest jquery script)

var firstcoordinate = '(' + series.data[0][0] + ', ' + series.data[0][1] + ')';

button.siblings('span').text('Fetched ' + series.dabel + ', first point: ' + firstcoordinate);

if (!alreadyFetched[series.label]) {

alreadyFetched[series.label] = true;

data.push(series); //populate data

}

$.plot(placeholder, data, options); //draw the chart

}

var dataUrl = "Default.aspx/GetData"; //server method to get data

$.ajax({

type: "POST",

url: dataUrl,

data: "{}",

contentType: "application/json; charset=utf-8",

dataType: "json",

success: onDataReceived

});

This will draw a simple line chart on your screen.

Happy charting!!!

Object Oriented JQuery/JavaScript

2010-11-16T08:44:00.000+05:30

All of us are familiar with OOP concepts, right!!
But how many of you have tried to use them in JavaScript.
Here is a simple code example to get you up and running.

First I will create a simple JavaScript class. When uing C# or Java etc... , We use the keyword "class".
To denote a class in JavaScript we use "function".

Here we go...

function Helper() {

$.fn.getCurrentIds = function (name) {
var selectedIds = new Array();
$('input:checkbox[name=' + name + ']:checked').each(function () {
selectedIds.push($(this).val());
});
var idString = "";
for (var i = 0; i < selectedIds.length; i++) {
if (i == selectedIds.length - 1)
idString += selectedIds[i];
else
idString += selectedIds[i] + ',';
}
return idString;
};

this.setAllSelectedIds = function (checkBoxName, hdnId) {
var hdnControlString = '#' + hdnId + '';
if ($(hdnControlString)) {
if ((!($(hdnControlString).val())) || $(hdnControlString).val() == "")
$(hdnControlString).val($.fn.getCurrentIds(checkBoxName));
else
if ($.fn.getCurrentIds(checkBoxName) != "")
$(hdnControlString).val($(hdnControlString).val() + ',' + $.fn.getCurrentIds(checkBoxName));
}
};

this.setCheckboxStatus = function (hdnId) {
var hdnControlString = '#' + hdnId + '';
if ($(hdnControlString) && $(hdnControlString).val()) {
if ($(hdnControlString).val() != "") {
var idArray = $(hdnControlString).val().split(',');
$.each(idArray, function (index, value) {
if ("input:checkbox[value=" + value + "]")
$("input:checkbox[value=" + value + "]").attr("checked", true);
});
}
}
};

this.getAllSelectedIds = function (hdnId) {
var hdnControlString = '#' + hdnId + '';
var idString = "";
if ($(hdnControlString))
idString = $(hdnControlString).val();
if (!idString)
idString = "";
return idString;
};

}

Here I have defined some useful common utility functions which will be used in and out side of the class.
if you look closely, you will see that the function "getCurrentIds" is called from another method or a function within the class that is "setAllSelectedIds" we have used JQuery pointers to do so - "$.fn.getCurrentIds(checkBoxName)"

what about out side of the class.

Its the same as any OOP based language.
-Create an object of the class
-Call object methods

here is an example

var helperObj = new Helper();
helperObj.setAllSelectedIds(itemCheckBoxName, hdnAllChkIds);//returns void
var allItemsSelected = helperObj.getAllSelectedIds(hdnAllChkIds);//returns a string containing all the selected check box ids.

you can elaborate further on this concept and can use it to write more complex but clean and maintainable code

Hope it helped!!!

Store a value in cookie from a class project in ASP MVC

2010-11-15T17:17:00.000+05:30

You can use the following method to store a string value in cookie using C#.net 4.0

public static void StoreCookie(string name, string valueToStore)
{
var cookie = new HttpCookie(name) {Value = valueToStore, Expires = DateTime.Now.AddYears(1)};
HttpContext.Current.Response.Cookies.Add(cookie);
}

Here classes like "HttpCookie" and "HttpContext" needs to be used in order to access cookies from a class library.

Truncate a paragraph to the last word

2010-11-15T17:08:00.000+05:30

This kind of truncation is always needed if you are displaying a truncated version of a meaningful string in the UI. Rather than simply truncating the list to a specific maximum length it is always handy to chop it to the last meaningful word.
The following lines of code accomplish that task

public static string TruncateToLastWord(string value, int maxLength)
{
string stringToTruncate = value.Substring(0, maxLength);
int indexOfLastSpace = stringToTruncate.LastIndexOf(' ');
string truncatedString = stringToTruncate.Substring(0, indexOfLastSpace);
return string.Format("{0}...", truncatedString);
}

Remove duplicate values from a list

2010-11-15T17:01:00.000+05:30

Lets say you have two lists that contains a set of Ids, and some ids are repeated in both the lists.
Here is a simple piece of code to get a concatenated list without the duplicate ids

public static List RemoveExistingValues(List oldSet, List newSet)
{
foreach (var item in newSet)
oldSet.RemoveAll(x=>x==item);
return oldSet;
}

Set the check status of all check boxes in a page using JQuery

2010-11-15T15:57:00.000+05:30

The requirement I am gonna illustrate now comes up in almost all development efforts where a grid or a tabular view is displayed. there is a single check box in the table header where upon click you need to change the checked status of all the check boxes in the grid
Here is a simple bit of code you can use to achieve that task

function(){
$('#' + allCheckBoxName + '').live("change", function (e) {
$("INPUT[type='checkbox']").attr('checked', $('#' + allCheckBoxName + '').is(':checked'));
});
}

Here "allCheckBoxName" is the master check box which is at the top of the grid.

But an issue arise when using this script with a drop down in the same page in IE browsers. that is in IE you need to bind check boxes events first before any other event bindings in order to work them properly. and strangely this is true with drop downs as well. so you face a strange dillema. "How can I bind events for two different kinds of controls at once?"

To overcome this just add the following code segment to the code

if ($.browser.msie) {
$('#' + allCheckBoxName + '').unbind("click");
$('#' + allCheckBoxName + '').live("click", function (e) {
$(this).trigger("change");
});

what it does is it rebinds the check box events after the drop down bind and trigger the change event.
so the completed function will look some thing like this

function () {
if ($.browser.msie) {
$('#' + allCheckBoxName + '').unbind("click");
$('#' + allCheckBoxName + '').live("click", function (e) {
$(this).trigger("change");
});
if (allCheckBoxVisibility) {
$('#' + allCheckBoxName + '').live("change", function (e) {
$("INPUT[type='checkbox']").attr('checked', $('#' + allCheckBoxName + '').is(':checked'));
});
}
}
$('#' + allCheckBoxName + '').live("click", function (e) {
$("INPUT[type='checkbox']").attr('checked', $('#' + allCheckBoxName + '').is(':checked'));
});
}

Hope it helps!!!

Get all the selected check box IDs in page using JQuery

2010-11-15T15:44:00.000+05:30

lots of guys have asked from me how to do this using java script. here is a small code snippet to help them out

function (name) {
var selectedIds = new Array();
$('input:checkbox[name=' + name + ']:checked').each(function () {
selectedIds.push($(this).val());
});
var idString = "";
for (var i = 0; i < selectedIds.length; i++) {
if (i == selectedIds.length - 1)
idString += selectedIds[i];
else {
idString += selectedIds[i] + ',';
}
}
return idString;
}

Cheers!!!

Optional arguments in C# 4.0

2010-05-12T16:27:00.000+05:30

With C# 4.0 you can assign a default value to a parameter when you are declaring a method

e.g.
public static void updateMyCV(string name=”Dhanushka”){ do some task }

you can call the method in following ways
updateMyCV(); //this will assign the default value to the parameter name
updateMyCV(“Athukorala”); //passed in value is assigned to the parameter

As you can see when you are calling these method, parameters in the method becomes optional. We can use this feature coupled with named parameters to define methods with an optional set of parameters.

e.g.
public static void
updateMyCV
(int employeeID, string firstName=”Dhanushka”, string lastName=”Athukorala”)
{ do some task }

When you are declaring a method with optional parameters, required parameters need to come first before any optional parameter declaration, here parameters with default values are considered as optional parameters while others are considered as required. There are several ways to call this method legally.

e.g.


updateMyCV(155,”Tekla”,”Dilrukshi”);
updateMyCV(155,”Tekla”);
updateMyCV(155,lastName: “Dilrukshi”);
updateMyCV(155);

But you cannot call the method in following ways although it makes sense to do so

updateMyCV(); //required parameters need to be passed
updateMyCV(155, ,”Dilrukshi”); //cannot leave gaps between arguments
updateMyCV(“Dilrukshi”,155);
//order has to be maintained if you are not using named arguments in the method call

Named arguments in C# 4.0

2010-05-12T16:25:00.000+05:30

Let’s say that you wrote a method like this

public static int getVolumeOfCylinder(int radius, int height)
{
return 22/7*radius*radius*height;
}

Now we all know until now we have to know the order of the parameters to call this method correctly, right!
Well not any more with C# 4.0 you can consider the parameter names as labels and call them without considering their declaration order in the following way

getVolumeOfCylinder(height: 10, radius: 5);
getVolumeOfCylinder(radius: 5, height: 10);

And as you have imagined already, named arguments can follow a positional argument but a named argument can never be followed by a positional argument

e.g
getVolumeOfCylinder(5, height: 10); //this will compile
getVolumeOfCylinder(height:10, 5); // this wont

CURSORS IN T_SQL

2010-05-03T18:47:00.000+05:30

In programming languages such as c# and java we use data structures like arrays and lists to store a set of data in the memory so we can iterate through them and do some processing.
when it comes to sql the alternative solution is the T-SQL CURSOR

The basic steps of using a cursor are as follows
1)Declare a cursor and associate it with a SELECT statement, the basic characteristics of the cursor needs to be defined here as well
2)Open and populate the cursor
3)Fetch a row from the cursor
4)Process the fetched row inside the loop after checking the fetch status
5)close and de-allocate the cursor

lets write a simple cursor and demonstrate the above mentioned steps

--Declare the variables needed, to do the necessary processing
DECLARE @NAME VARCHAR(MAX)

---(1)---
DECLARE myCursor CURSOR FOR
SELECT employee_name FROM EMPLOYEES

* alternatively you can declare a local variable of type CURSOR and set its structure as well
DECLARE @myCursor CURSOR
SET @myCursor= CURSOR FOR SELECT employee_name FROM EMPLOYEES
* you can also set the cursor for read only mode to gain more performance or to update mode to update the rows as you iterate through them
DECLARE myCursor CURSOR READ_ONLY
FOR SELECT employee_name FROM EMPLOYEES
OR
DECLARE myCursor CURSOR
FOR SELECT employee_name FROM EMPLOYEES
FOR UPDATE OF designation

---(2)---
OPEN myCursor
--(3)---
FETCH NEXT FROM myCursor INTO @NAME
---(4)---
WHILE @@FETCH_STATUS = 0
BEGIN
PRINT @NAME
FETCH NEXT FROM myCursor INTO @NAME
END
* here FETCH_STATUS is used to determine the boundary status of the iterator, following are values it returns depending on the situation
0 - fetch statement was executed successfully
-1 - row that needs to be fetched is beyond the result set
-2 - row that needs to be fetched is missing
* FETCH_STATUS is defined globally for all the cursors on a connection, so when we are using it we need to be careful to check the status immediately after the fetch before another fetch occur.
* you can get the number of rows in the cursors result set using the @@CURSOR_ROWS variable

---(5)---
CLOSE myCursor
DEALLOCATE myCursor
* after using the cursor we must close and de-allocate it so there wont be any references for the cursor in the memory

Write to an XML file using C#

2009-06-04T14:02:00.001+05:30

following code demonstrates how we can write a collection to an XML file using C#

we can do it in two ways first lets do it without using serilization.

public static void writetoXML(string fileName)

{

DataSet ds = new DataSet("ds01"); //root node

DataTable t = new DataTable("table01"); //

DataColumn qNo = new DataColumn("questionNo"); //

DataColumn ans = new DataColumn("answer"); //

t.Columns.Add(qNo); //add columns to the table

t.Columns.Add(ans);

ds.Tables.Add(t); //add table to the dataset

DataRow r;

int qLimit = 10;

for (int i = 0; i <>

{

r = t.NewRow(); //create a new row of type table

r["questionNo"] = i;

r["answer"] = "answer for question" + i;

t.Rows.Add(r); //add the newly populated row to the table

}

//write the added data to the console

Console.WriteLine("Data added to the table\n");

Console.WriteLine("QuestionNo\t\tAnswer");

Console.WriteLine("--------------------------------------------");

for (int i = 0; i <>

{

Console.WriteLine(t.Rows[i][0].ToString()+"\t\t|\t"+t.Rows[i][1].ToString());

}

ds.WriteXml(fileName);

}

lets rewrite it again using serilization there is a big advantage in this i'll show it right away

when using serialization we write the data using a XMLSerializer object which will be created using the method typeof(). this allows us to write any type of collection to a XML file with little altering of code as possible

lets see how the above method will look like when written using serilization

public static void serializeDatSet(string fileName)

{

//create a new XMLSerializer object of type DataSet

XmlSerializer ser = new XmlSerializer(typeof(DataSet));

DataSet ds = new DataSet("ds01");

DataTable t = new DataTable("table01");

DataColumn qNo = new DataColumn("questionNo");

DataColumn ans = new DataColumn("answer");

t.Columns.Add(qNo);

t.Columns.Add(ans);

ds.Tables.Add(t);

DataRow r;

int qLimit = 10;

for (int i = 0; i <>

{

r = t.NewRow();

r["questionNo"] = i;

r["answer"] = "answer for question" + i;

t.Rows.Add(r);

}

Console.WriteLine("Data added to the table\n");

Console.WriteLine("QuestionNo\t\tAnswer");

Console.WriteLine("--------------------------------------------");

for (int i = 0; i <>

{

Console.WriteLine(t.Rows[i][0].ToString()+"\t\t|\t"+t.Rows[i][1].ToString());

}

TextWriter writer=new StreamWriter(fileName);

//write the data set to the writer stream using the serialization object

ser.Serialize(writer,ds);

writer.Close();

}

so lets say you want to write an ArrayList to a XML file

well see the code below

public static void writeToXML(string fileName)

{

ArrayList arr = new ArrayList();

for (int i = 0; i <>

{

arr.Add("answer for question" + i);

}

XmlSerializer ser = new XmlSerializer(typeof(ArrayList));

TextWriter writer = new StreamWriter(fileName);

ser.Serialize(writer, arr);

writer.Close();

}

How to get the servers DateTime.Now Value to a client program

2009-05-28T11:58:00.000+05:30

for this you have to write two applications, one will reside in the server machine and will wait till a client machine request its time. upon a succesful request the server will write its DateTime.Now value to the network stream, where the client can read it out and use it in his application

please consider that these two applications are windows console applications

Code for the Server Program

using System;

using System.Collections.Generic;

using System.Text;

using System.Net;

using System.Net.Sockets;

namespace Server

{

public class Program

{

public static void Main(string[] args)

{

try

{

//add a listner to liten on a port on a specified host

TcpListener listener=new TcpListener(Dns.Resolve("localhost").AddressList[0],14);

listener.Start();

Console.WriteLine("Waiting for client to connect");

Console.WriteLine("Ctrl+C to quit");

while (true)

{

Socket s = listener.AcceptSocket(); //accept a connection request made by a client on the listning socket

DateTime now = DateTime.Now; //get the servers date time value

string dateTime = now.ToShortDateString() + " " + now.ToLongTimeString();

byte[] asciiDateTime = Encoding.ASCII.GetBytes(dateTime.ToCharArray());

//encode the strring to aASCII byte stream to written in to the socket so it can be decoded from the client easily

s.Send(asciiDateTime, asciiDateTime.Length, 0);

//write to the socket data(asciidatetime) starting from 0th index to a charcter count of(asciidatetime.length)

s.Close(); //close the socket connection to the client

Console.WriteLine("Sent{0}",dateTime);

}

catch (SocketException error)

{

if (error.ErrorCode==10048)

{

Console.WriteLine("connection failed to this port, there is another server listning on this port");

}

Code for the Client Program

using System;

using System.Collections.Generic;

using System.Text;

using System.Net;

using System.Net.Sockets;

using System.IO;

namespace ConsoleApplication2

{

class Program

{

static void Main(string[] args)

{

TcpClient client = new TcpClient(); //create a client

Console.WriteLine("specify a server name : ");

string serverName = Console.ReadLine();

try

{

//gets the DNS information of the specified server

IPHostEntry ipInfo = Dns.GetHostByName(serverName);

}

catch (SocketException error)

{

Console.WriteLine("cannot find server : "+serverName+"\nException :\n"+error.ToString());

return;

}

try

{

client.Connect(serverName,14); //connect to the specified server via port 14

}

catch (Exception error2)

{

Console.WriteLine("could not connect to server {0}\n"+error2.Message,serverName);

}

Stream s;

try

{

//get a network stream to communicate with the server machine

this will add the client to the servers pending request query and will

s = client.GetStream(); initiate the AcceptSocket() method

}

catch (InvalidOperationException)

{

Console.WriteLine("cannot connect to server {0}",serverName);

return;

}

Byte[] read=new byte[32];

//read the the byte stream returned from the server

int bytes = s.Read(read, 0, read.Length);

string time = Encoding.ASCII.GetString(read); //decode it to a string

Console.WriteLine("received"+bytes+"bytes");

Console.WriteLine("current server date time is : "+time);

client.Close();

Console.WriteLine("press enter to exit");

Console.Read();

}

this code base can be used to construct any simple-client server communication machanism based on your requirements. all you have to do is replace

DateTime now = DateTime.Now; //get the servers date time value

string dateTime = now.ToShortDateString() + " " + now.ToLongTimeString();

part in the server program with ou server task

have fun coding!!!!!!

What's new in c# 3.0 - Implicitly typed variables

2009-04-07T14:21:00.001+05:30

this is a first of a series about new features in c# 3.0

all the programming languages have some kind of a machanism to store progrmatic data in c# there are two types called reference types and value types when we consider value types almost all the programming languages had implemented them as a part of their framework

Basically their are two types of value types

static

dynamic

static typing

type of the variables are known in cmpile time this is the common practice in languages like c#, java, c, c++

int a=10;

string name="Dhanushka Sandaruwan Athukorala";

dynamic typing

here the variable comes with some kind of a tag that contains it type. when you assign a value to the variable at the run time this tag value is set to the type of this assigned value

the funny thing is every time an operation is performed the type will be checked to make sure that the operation is safe

for an example this will wok in dynamically typed code but not in static typing

a="Dhanushka Sandaruwan Athukorala";

if(true)

{

a=12;

}

b=a/2;

here as you can see when the devission occur a's type tag is set to int rather than string thats the magic of dynamic typing

now lets see what c# 3.0 offeres

var fullName="Dhanushka Sandaruwan Athukorala";

var age=22;

var arr=new[] {1, 2, 3, 4}

hmm...

what's going on

at first you would say that "var" is just a new value type!!!

No sir!!! its not!!!

its just a new keyword introduced in c# 3.0 to indicate to the compiler that "i'm gona create a new variable, but i dont know about its type. so you just take care of it for me!!"

we all know that c# is a staticstically typed language, but yet it si offering a functionallity similar to a dynamically typed one???

whats the secret??

what happens here is a newly written type inferencing algorithm is used by the compiler(take this to note, which means this happens at compile time not at run time) goes through the code and finds out what's the type of the variables assigned to the "var" variables. which means that this is similar to an explicit declaration of a variable but you dont have to know the type of it.

for an instance if we referfullName.GetType() and age.GetType() values at run time they will give string and int32 as their variable types

but their are some other issues you should be aware of when you use var

you must initialize a variable with a nonnull value when you declare it

this want compile

var a; var b=null;

a=18;

as a conclusion we can say although this will distance c# from being a simple language, it will enhance the developer productivity as well as code readability.