OOPs

Allow your framework to load custom assemblies

Saqib Ullah — Tue, 29 Jul 2008 07:42:15 GMT

Hello geeks after a long gap I come back with a very arousing blog. When ever you see .Net Framework or any Microsoft patterns & practices library configure, they allow the developer to load the external components through some configurations in Web.config or App.Config file and that will be later called by the framework at runtime. Ok let take an example of Microsoft.Practices.EnterpriseLibrary.Logging.Formatters.ILogFormatter Interface that require to format a LogEntry in a way suitable for wire transmission and when you open your configuration file you will find the following key.

<add template="" type="Microsoft.Practices.EnterpriseLibrary.Logging.Formatters.TextFormatter, Microsoft.Practices.EnterpriseLibrary.Logging, Version=4.0.0.0, Culture=neutral, PublicKeyToken=null"

name="Text Formatter" />

</formatters>

What that mean, when Enterprise library going to write log it will automatically use the above specify TextFormatter for text logging. Microsoft Enterprise library has the provision for the developer to create custom formatter by implementing ILogFormatter Interface.

Now you have an idea what I am going to implement. Let suppose I have a Theme Configuration management framework for my Windows application and my framework disclose some interfaces for custom implement like IGUIControl.

namespace ThemeFramework

{

public interface IGUIControl

{

void Render();

void Draw();

}

If you want to develop a control for my framework you need to implement the IGUIControl interface for creating GUI controls, so it’s also the responsibility of the developer to Implement IGUIControl and configure it so Theme framework get that assembly. Here I only explain the static factory function of my framework that load all define assemblies from configuration file. Generic knowledge is prerequisite.

public static T[] LoadInstances<T>() where T : class

{

//You can use any other way read from configuration file.

//It utilize the .net 2.0 feature. The main target is to get all assemblies names.

Settings.Default.Reload();

StringCollection TypeColl = Settings.Default.Types;

List<T> components = new List<T>();

foreach (string TypeInfo in TypeColl)

{

try

{

string[] typeInfo = TypeInfo.Split(',');

string assemblyName = typeInfo[1];

string typeName = typeInfo[0];

if (string.IsNullOrEmpty(assemblyName) || string.IsNullOrEmpty(typeName))

{

continue; // invalid type info

}

assemblyName = assemblyName.Trim();

typeName = typeName.Trim();

string exeDir = Path.GetDirectoryName(Application.ExecutablePath);

if (!File.Exists(Path.Combine(exeDir, assemblyName + ".dll")))

{

continue; // invalid type information

}

Assembly assem = Assembly.Load(typeInfo[1].Trim());

// Dynamic instance creation

T instance = assem.CreateInstance(typeInfo[0].Trim()) as T;

if (instance != null)

{

components.Add(instance);

}

catch(Exception ex)

{ }

}

return components.ToArray();

}

In preceding code I use Settings.setting class for loading assembly’s names, you can use any other provider to get all custom assemblies names from configuration files. After that I try to find the give assembly in the application execution folder and load it into generic List<T> array.

IGUIControl[] dogs = FrameworkTest. LoadInstances<IGUIControl>();

foreach (IGUIControl control in loadControls)

{

Control.Draw();

}

Above code snippet load all assemblies that implement IGUIControl and call it Draw() method to draw the entry control.

Implement events through interface in C#

Saqib Ullah — Tue, 08 Apr 2008 05:49:16 GMT

According to C# specification interface contain a signature of events but a complete and brief implementation of events through interface is not available on the net.

First you identify the interface

public interface IControl

{

// Raise this event.

event EventHandler OnCommand;

}

According to my need I create a class that inherit from System.EventArgs

public class CommandArgs : EventArgs

{

public string CommandName;

}

My OutCommand class is a implementation of IControl interface that contain an OnCommand event.

public class OutCommnad : IControl

{

public OutCommnad()

{}

// Create an event from interface event

event EventHandler CommandEvent;

event EventHandler IControl.OnCommand

{

add

{

if (CommandEvent != null)

{

lock (CommandEvent)

{

CommandEvent += value;

}

else

{

CommandEvent = new EventHandler(value);

}

remove

{

if (CommandEvent != null)

{

lock (CommandEvent)

{

CommandEvent -= value;

}

public void Command()

{

EventHandler handler = CommandEvent;

if (handler != null)

{

//My custom class that passed as arguments.

CommandArgs cmd = new CommandArgs();

cmd.CommandName = "Test Application event.";

handler(this, cmd);

}

Calling of IControl.OnCommand event.

OutCommnad outCommand = new OutCommnad();

IControl con = (IControl)outCommand;

con.OnCommand +=new EventHandler(con_OnCommand);

outCommand.Command();

IControl.OnCommand event function.

void con_OnCommand(object sender, CommandArgs e)

{

string str = e.CommandName;

Console.WriteLine(str);

}

what is C# complete class?

Saqib Ullah — Sat, 09 Jun 2007 09:02:04 GMT

My following class is a complete C# class because its contain all possible declarations.

using System;

class MyClass
{
public const int MyConst = 45;
    public int MyField = 64;
    public static int MyStaticField = 65;
    public void MyMethod()
    {
       Console.WriteLine("MyClass.MyMethod call");
    }

    public int MyProperty
    {
        get
        {
            return MyField;
        }

        set
        {
           MyField = value;
        }
    }

public event EventHandler MyEvent;

    public int this[int index]
    {
        get
        {
            return 0;
        }

        set
        {
            Console.WriteLine("this[{0}] = {1}", index, value);
        }
    }

    public static MyClass operator +(MyClass a, MyClass b)
    {
        return new MyClass(a.MyField * b.MyField);
    }

    public MyClass()
    {
        Console.WriteLine("Instance constructor call");
    }

    public MyClass(int value)
    {
        MyField = value;
        Console.WriteLine("Instance constructor call");
    }

    ~MyClass()
    {
        Console.WriteLine("Finalizer call");
    }

    static MyClass()
    {
        MyStaticField *= 2;
        Console.WriteLine("Static constructor call");
    }

internal class MyNestedClass
{ }
}

Class members can include constants, fields, methods, properties, events, indexers, operators, instance constructors, finalizers, static constructors, and nested type declarations.

Yours Suggestions
{
if any thing I left in the above so please corrects me thank.
}

Never Before

Saqib Ullah — Sun, 22 Apr 2007 21:09:31 GMT

This is my C# class and its compatible with all .Net framework versions.

public class Person

{

// Fields

private string _name;

private int _age;

private string _city;

private string _company;

// Properties

public string Name

{

get { return _name; }

set { _name = value; }

}

public int Age

{

get { return _age; }

set { _age = value; }

}

public string City

{

get { return _city; }

set { _city = value; }

}

public string Company

{

get { return _company; }

set { _company = value; }

}

From the last bit of class code every thing is old so what is new.

Here is new technique in C# 3.0 to define properties in the terse and brief syntax like this,

Person objPerson new Person {Name=”Saqib Ullah”, City=”Karachi”, Company=”InboxBiz”, Age=26}

I hope this post increase your C# 3.0 little bit.

Three Singleton Classes, but use only ONE.

Saqib Ullah — Tue, 27 Mar 2007 07:52:00 GMT

In this blog I want to describe you three ways how to write singleton class that is thread safe.

First Class

public sealed class TSSingleton
{
private static volatile TSSingleton instance = null;
private static object syncObj = new object();
// make the default constructor private,
// so that no can directly create it.
private TSSingleton(){}
// public property that can only get
// the single instance of this class.
public static TSSingleton Instance
{
get {
// only create a new instance if one doesn't already exist.
if (instance == null)
{
// use this lock to ensure that only one thread is access
// this block of code at once.
lock(syncObj)
{
   if (instance == null)
   instance = new TSSingleton();
}
}
// return instance where it was just
// created or already existed.
return instance;
}}}

Second Class

sealed class MysingleTon
{
// Static members are lazily initialized.
    // .NET guarantees thread safety for static initialization
   private static readonly MysingleTon instance = new MysingleTon();
   public static MysingleTon GetInstance()
   {
      return instance;
    }
}

Thrid Class

sealed class Singleton
{
private Singleton() { }
public static readonly Singleton TheInstance = new Singleton();
}

I use last example of singleton class.