Doug Lim's Weblog

I'm back

2011-09-04T10:20:00.001-07:00

Hey guys

It's been a long time between drinks for me. But now I'm back ready to blog all things .NET and especially C#. Although my focus has changed somewhat, I like to leverage my time now. So I use a lot of great tools that makes my life much easier!

Anyway be prepared to get some real cool .NET posts.

Using Datagrids in the Compact Framework 2.0

2008-02-08T07:18:00.000-08:00

Datagrids in Winforms apps are similar to Gridviews in web apps. However there are some intricacies when dealing with datagrids in mobile apps using the Compact Framework 2.0 SP1. Here's a quick example of how to do it using an arraylist as the datasource:

1. The columns of the datagrid must correspond to public properties of the binding class. That is, the class type of each object in the arraylist.
2. Use a BindingList (http://msdn2.microsoft.com/en-us/library/ms132679(VS.80).aspx) instead of an ArrayList.
3. Use the CurrencyManager class to perform operations on the datagrid such as refreshing the datagrid once the underlying arraylist datasource has been modified.

Ruby on Rails and ASP .NET

2008-01-06T05:13:00.000-08:00

There are so many different languages that can be used to develop a web application. To name a few: Ruby, PHP, ASP .NET, ASP, HTML, XML and XSLT, Python, Perl, Javascript, and the list goes on. I've been developing web apps using ASP .NET to the point now where I can knock up a database driven site in a few hours top. So you could say I'm biased and a huge fan of ASP .NET.

However, recently I've been looking at Ruby on Rails and have to admit I'm quite impressed with the open source web framework. Ruby is a pure object oriented language whilst Rails is a web framework for developing web based database driven sites. Hence, put the two together and we have Ruby on Rails - an object oriented language for quickly developing web based database driven sites.

Ruby on Rails uses the MVC pattern (http://en.wikipedia.org/wiki/Model-view-controller) with models that wrap and model the underlying data from the database, views for displaying this data and controllers serving the user's page request. Rails automatically creates a directory structured based on MVC and with a bit of plumbing, a database driven site is ready to go within minutes!

And it's only recently that Microsoft (http://weblogs.asp.net/scottgu/archive/2007/10/14/asp-net-mvc-framework.aspx) has answered the calls of many people and released built in support for ASP .NET that allow web apps to be built using the MVC framework.

Some pluses of Ruby on Rails is that it's fully open source, integrates well with MySQL (another open source database) and the real benefit comes when Rails creates your create, read, update and delete (CRUD) database operations for you saving time as a developer (just like using an ORM such as NHibernate or LINQ to SQL with ASP .NET). Some downsides are that it doesn't integrate well with SQL Server 2005 even though there is an adapter for it.

Database Synchronization Tools

2008-01-01T21:50:00.000-08:00

I recently played around with a nifty new tool from Perpetuum software called Database Restyle, found here (http://www.perpetuumsoft.com/Product.aspx?lang=en&pid=55). Slightly different to what I'm use to due to the fact that to synch your live database with your developer database it is not an external application per se.

You can actually integrate Database Restyle as a component within your code, or you can use it to develop a stand alone application in itself. This makes it extremely handy during deployment. The other thing I liked about it is that it supports LINQ to SQL data models and it's written in .NET 2.0.

New C# 3.0 Language Features

2007-12-27T22:06:00.000-08:00

One of the issues I've always had as a developer is using language specific features that make my life easier. So I've spent the day playing with some of the new C# 3.0 language features. Here's what I've found with some of the new features:

Implicitly Typed Local Variables
A new keyword var now exists that you can use in place of a formal data type such as int, string etc. So instead of the following:
string result = "Success";
int i = 0;
bool isCompleted = false;

We can now do the following:
var result = "Success";
var i = 0;
var isCompleted = false;

So how does the compiler know the underlying variable type? Simple, it looks at the initial value assigned to the variable. Note that implicitly typed local variables can also be used in a for or foreach statement as follows:

var birthdays = new int[] { 5, 14, 24, 30 };
foreach (var birthday in birthdays)
{
// Do something here
}

Some caveats to note:
1. As you may have already worked out, variables declared using var must have an initial value assigned and cannot be assigned null
2. Implicitly typed local variables, as the name suggests, is restricted to local method or property variables only. It cannot be used for global variables and return values.

So what's the major advantage of using implicitly typed local variables? LINQ! (I'll blog on this later). But if you're not using LINQ, it's far better to declare the variable type explicitly rather than using var since it makes it much easier to read and to understand the code.

Lambda Expressions
Anonymous methods (Found in C# 2.0 whereby inline code can be used to define a delegate rather than a standalone function in itself) can now be rewritten using a much more simplified syntax. So instead of the following:

List numbers = new List();
numbers.AddRange(new int[] { 1,2,3,4,5,6,7,8,9,10,11,12 } );

List even = numbers.FindAll(delegate(int i) { return (i % 2) == 0; });

We can write:
List even = numbers.FindAll(i => (i % 2) == 0);

Once again, this is primed to be useful in LINQ.

Object Initializers
We are now able to initialize a new object and set its property values in one statement. So before we had:
CreditCard cc = new CreditCard();
cc.CardName = "John Smith";
cc.CardNumber = "1324234234";

But now we can simply rewrite this into one single statement as follows:
CreditCard cc = new CreditCard {
CardName = "John Smith",
CardNumber = "1324234234"
};

Extension Methods
This is a major new change. We are now able to inject new functionality into a compiled type (such as adding new methods) without having to touch the already compiled assembly. So for example, we can add a new method to the string type to determine if the string assigned contains the keyword "Hello". See below:

public static class StringExtension{
public static bool ContainsHello(this string s)
{
return s.Contains("Hello");
}
}

class Example
{
public static void Main(string[] args)
{
string s = "Hello world";
bool result = s.ContainsHello();
}
}

As you've probably already noticed, extensions methods can only be declared in static classes. Likewise, an extension method is declared when the this keyword is placed in front of the first parameter. It is assumed that the first parameter will be the one that is extended. You may have multiple parameters in an extension method, however the this keyword can only be applied to the first parameter.

Automatic Properties
I've always found it really annoying writing verbose properties throughout my code, even if I'm using Visual Studio's code snippet. So now instead of writing:

private string address = String.Empty;

public string Address
{
get
{
return address;
}
set
{
address = value;
}
}

We can now write the following:

public string Address { get; set; }

Notice that if we wanted to override this property, we would need to add the abstract keyword in front of the property.

Caveats associated with this are:
1. Both get and set properties must be set. You cannot simply make it read only.
2. However, we can set different visibility modifiers for the get and set properties. For example, the read only property can be restricted to classes within the assembly only while the write property can be public.

Anonymous Types
At compile time, anonymous types now allow us to create a type on the fly. For example, instead of writing:

class Address
{
private int number;
private string street;

public int Number
{
get
{
return number;
}
set
{
number = value;
}
}

public string Street
{
get
{
return street;
}
set
{
street = value;
}
}
}

Address address = new Address();
address.Number = 14;
address.Street = "Flinders St";

We can now write:

var anonymousType = new {Number = 14, Street = "Flinders St"};

Note that anonymous types must be declared using the var keyword.

Web Application Design in ASP .NET 2.0 and 3.5

2007-12-12T06:18:00.000-08:00

Well I've been developing web applications in ASP .NET for quite a while now and some good practices to follow when designing your web application come to mind:

1. Always separate your web application out into nice clean loosely coupled layers. At a bare minimum, separate your data access logic into a data access layer/persistence facade, your business logic (handling verification and manipulation of data) into a business logic layer and your UI into its own web forms.

Scott Guthrie and his team have just released ASP .NET 3.5 extensions which allows web applications to be developed using a MVC approach compared to the normal page lifecycle/view state approach. This makes it a lot easier for Test Driven Development (TDD) and an extremely clean separation of the above 3 layers. I'll blog on this later when I use this approach for a client.

2. View state!! Remember server side control information is stored in view state which is sent from the server to the browser and back again allowing the control's state to be retained after a postback. So if you jam pack your page with server-side controls, your view state is going to get very large and this will impact performance. So use client side controls (good old HTML) where possible especially if the control is not going to be changed. eg. label

3. Make use of the wonderful features that ASP .NET 2.0 provides over 1.1. Such as master pages and themes for enabling a consistent look and feel across the web site. Dream weaver used templates to incorporate this behaviour. Having used it myself, consider yourself lucky!

4. If there are multiple sections in a master page, create user controls (.ascx). This provides finer granularity of control in your code behind.

5. In your data access layer ensure you use parameterized SQL queries or parameterized stored procedures or an ORM to avoid SQL injection attacks.

Designing a Web Service

2007-11-17T04:08:00.000-08:00

Whilst working for a client the other day, I had to write a web service with a couple web methods. Reading a lot of blogs on the subject and what people try and achieve with web services, there are some important points to consider when designing a web service and its web methods in .NET. They are:

1. Remember that web services according to WS-I (Web Services Interoperability) must be interoperable with different platforms such as .NET and Java. So do not use language specific types such as an arraylist in C#. Java won't understand this. Use an array instead.

2. Web services are inherently stateless. If you are finding yourself needing to store state information, then it is highly likely that you should revisit your web service design. Nevertheless, if you need to maintain state in .NET, use a CookieContainer on the client proxy to send back the same session details to the web method. ASP .NET will then be able to find the right session state object. And you will need to add the [WebMethod(EnableSession=true)] attribute to your web method.

Note that if you are using the compact framework (as of 2.1), you will have to override the GetWebRequest and GetWebResponse methods to send back the session details.

3. Return a useful response message back to the user if something fails. It's so obvious but yet so frustrating to call a web service, only for something to fail and no response message given.