GRREF: March 2009

Tuesday, March 31, 2009

Design Patterns :: Singleton

Design Patterns :: Singleton

There are many common situations when singleton pattern is used:
- Accesing resources in shared mode
- Configuration Classes
- Logger Classes
- Serialization
- Network Port Interface

Singleton Design Pattern

Check list
1.Define a private static attribute in the "single instance" class.
2.Define a public static accessor function in the class.
3.Do "lazy initialization" (creation on first use) in the accessor function.
4.Define all constructors to be protected or private.
5.Clients may only use the accessor function to manipulate the Singleton.

using System;
namespace DesignPatternsSingleton
{
/// <summary>
/// MainApp startup class for Design Patterns :: Singleton
/// http://gr1350.blogspot.com
/// </summary>
class MainApp
{
/// <summary>
/// The Singleton class.
/// </summary>
public class Singleton
{
private static Singleton _instance;
// Constructor is 'protected'
protected Singleton()
{
}
public static Singleton Instance()
{
// Uses lazy initialization.
// Note: this is not thread safe.
if (_instance == null)
{
_instance = new Singleton();
}
return _instance;
}
}
}

using System;
using System.Collections.Generic;
using System.Threading;
namespace DesignPatternsSingleton
{
/// <summary>
/// MainApp startup class for Real-World
/// Singleton Design Pattern.
/// </summary>
class MainApp
{
/// <summary>
/// Entry point into console application.
/// </summary>
static void Main()
{
LoadBalancer b1 = LoadBalancer.GetLoadBalancer();
LoadBalancer b2 = LoadBalancer.GetLoadBalancer();
LoadBalancer b3 = LoadBalancer.GetLoadBalancer();
LoadBalancer b4 = LoadBalancer.GetLoadBalancer();
// Same instance?
if (b1 == b2 && b2 == b3 && b3 == b4)
{
Console.WriteLine("Same instance\n");
}
// Load balance 15 server requests
LoadBalancer balancer = LoadBalancer.GetLoadBalancer();
for (int i = 0; i < 15; i++)
{
string server = balancer.Server;
Console.WriteLine("Dispatch Request to: " + server);
}
// Wait for user
Console.ReadKey();
}
}
/// <summary>
/// The 'Singleton' class
/// </summary>
class LoadBalancer
{
private static LoadBalancer _instance;
private List<string> _servers = new List<string>();
private Random _random = new Random();
// Lock synchronization object
private static object syncLock = new object();
// Constructor (protected)
protected LoadBalancer()
{
// List of available servers
_servers.Add("ServerI");
_servers.Add("ServerII");
_servers.Add("ServerIII");
_servers.Add("ServerIV");
_servers.Add("ServerV");
}
public static LoadBalancer GetLoadBalancer()
{
// Support multithreaded applications through
// 'Double checked locking' pattern which (once
// the instance exists) avoids locking each
// time the method is invoked
if (_instance == null)
{
lock (syncLock)
{
if (_instance == null)
{
_instance = new LoadBalancer();
}
}
}
return _instance;
}
// Simple, but effective random load balancer
public string Server
{
get
{
int r = _random.Next(_servers.Count);
return _servers[r].ToString();
}
}
}
}

Setting Language/Culture in Using Global Resource Files

Setting Language/Culture in Using Global Resource Files

In this short post, in the code of an aspx page, we want to make the page to use our global resource file called UI.fr-CA.resx that is in Canadian French (fr-CA).

In order to this, just open the source code of the page (or the source code of the super class of your page class) and override its InitializeCulture method as in the following:

protected override void InitializeCulture()
{
Thread.CurrentThread.CurrentUICulture = new System.Globalization.CultureInfo("fr-CA");
Thread.CurrentThread.CurrentCulture = new System.Globalization.CultureInfo("fr-CA");
base.InitializeCulture();
}

There is a good point in the above code: it works even if your controls or user controls located in the page have processes in threads different from the current thread!

Wednesday, March 18, 2009

Creational Design Patterns

List of Creational Design Patterns

In the following, which five design patterns are the creational patterns?

1) Abstract Factory
2) Adapter
3) Bridge
4) Builder
5) Chain of Responsibility
6) Command
7) Composite
8) Decorator
9) Facade
10) Factory Method
11) Flyweight
12) Interpreter
13) Iterator
14) Mediator
15) Memento
16) Observer
17) Prototype
18) Proxy
19) Singleton
20) State
21) Strategy
22) Template Method
23) Visitor

Creational Design Patterns

Abstract Factory
Builder
Factory Method
Prototype
Singleton

Object Initializers with Anonymous Types

Object Initializers with Anonymous Types

In C# 3.0, we can use object initializers with anonymous types. The following example shows how it can be done:

The Customer class is an arbitrary class that we want to use in this example:

public class Customer
{
public int CustomerID { get; set; }
public string FirstName { get; set; }
public string LastName { get; set; }
}

We declare a colloecton of customers by employing "object initializers":

List customers = new List
{
new Customer { CustomerID = 99, FirstName = "Brian" , LastName = "White"},
new Customer { CustomerID = 100, FirstName = "Nicole" , LastName = "Stewart"},
new Customer { CustomerID = 101, FirstName = "Lucy" , LastName = "Brothers"}
};

Now, we create a LINQ query where the returning objects have anonymous types; an anonymous type that has two properties: ID and Name; and also we employ the object initializer concept to initialize the properties of our objects:

var selCust = from c in customers
where c.CustomerID <= 100
orderby c.LastName, c.FirstName
select new { ID = c.CustomerID, Name = c.FirstName + " " + c.LastName};

The variable selCust contains objects of an anonymous type with their properties already set (initialized). To confirm this, run the following code snippet:

foreach (var cust in selCust)
{
Console.WriteLine(cust.ID.ToString() + " " + cust.Name);
}

Pages