Bashmohandes (Mohamed Elsherif)

Microsoft Maren, Write Arabic in English letter anywhere you like

2009-06-30T19:41:00Z

By Mostafa Ashour, PM of Maren Team

Dear All,

We’re pleased to announce that today the Cairo Microsoft Innovation Center (CMIC) is releasing Microsoft Maren, a Windows extension that allows you to type Arabic in Roman characters and have it converted on the fly to Arabic script. Maren integrates seamlessly with Windows and works in most Windows applications and websites.

We are inviting you to download and install Maren from: www.GetMaren.com

Email or IM a friend. Comment on a photo. Search the web. Write a document. Blog. Keep a to do list. Maren makes it easier to complete many day to day tasks in Arabic and using the applications you use today for accomplishing these tasks.

So please help us out and spread the word:

· Tell people about GetMaren.com

· Forward this email to your friends and family

· Join the Facebook group

Windows 7 RC downloads will end August 15th

2009-06-23T19:10:00Z

From Windows Team Blog post at http://windowsteamblog.com/blogs/springboard/default.aspx

“Still on the Windows 7 Beta,? You need to move to the RC and fast. Starting July 1^st, the Beta will start to reboot every 2 hrs and expire Aug 1^st.

Want to download the RC? . The RC download program closes August 15th. After that, you won’t be able to get the download, but you can still install the RC and get a key if you need one. (To get a key, just go to the Downloads page and follow the instructions.)

If you’re using the Windows 7 Release Candidate, we hope you like what you see. Let us know -- go to http://input.microsoft.com and tell us what you think. You’ll be able to give feedback on various aspects of the operating system.”

Microsoft to ship & support jQuery

2008-09-28T23:57:23Z

A fresh announcement from ScottGu today, that Microsoft will be shipping jQuery (the light weight javascript library) in the long term with Visual Studio as well as shipping it in the short term with the next versions of Microsoft ASP.net MVC.

Microsoft also is going to develop new controls on top of jQuery, not only this but also full support for jQuery, which mean enterprises can open cases on Microsoft PSS for jQuery.

Great news, and very nice move

Here are some more details from ScottGu, Scott Henselman and jQuery

I'm a PC in MCDC

2008-09-27T02:59:00Z

I’m a PC, Do you have a problem with that?

2008-09-21T10:30:00Z

I am a PC guy, I always was, for me PC gives more freedom, you can do whatever you like, build the craziest machine you think it is good for you, and you will never be over priced, with PC you are always in control, if you want to add more capacity, just go and buy a new hard drive, if you need more gaming capabilities upgrade your display adapter, more memory, get a new memory stick, as simple as this, you can make your machine evolves easily with your needs, if you want your pc to become a business machine you can, a gaming platform you can, a parent machine you can, you can find a pc from $100 to thousands of dollars depending on your needs, and for sure you can have fun building your own, I built a lot for me and my friends and it is always fun.

I'm PC, are you?

If you don’t like to build a pc, and prefer to buy it from a vendor, you still have a lot of choices, Dell, Toshiba, IBM, HP, Sony, Lenovo, … you name it, and every vendor has a great number of choices for you to choose from, and here are some of my favorite desktop & notebooks

First check out these fancy All-in-one PC’s from Dell,Hp and Sony


Dell - XPS One E4500 All-in-One	HP - TouchSmart All-In-One Desktop

Sony – All-in-one Desktop	VAIO JS Series Desktop PC

And check these amazing notebooks


Sony Vaio FW Series	Dell XPS M1530

HP HDX Series	Toshiba Satellite A300

And this is not the whole thing, these are just samples of the choices you have with a PC.

I’m a PC, are you?

Live Mesh, Synchronizing Life

2008-09-20T16:11:46Z

Windows Live has some great products, and you are already using bunch of them, Windows Live Messenger, Windows Live Hotmail, Windows Live Writer, Windows Live Photo Gallery, Windows Live Mail … etc, but the newest and the most interesting one is Windows Live Mesh.

Windows Live Mesh is simply one of those products that after you use it for couple of days, you find yourself saying “how I used to live before??” it solves so many problems that you used to live with them even though they are annoying.

With so many devices you deal with today for example (Your home PC, your work PC, your notebook, your Zune, your mom’s MAC, your mobile phone, your kids XBOX, … etc) keeping these devices in sync is very annoying, and simply you can get out of sync, and lose track with which device has the latest version of my documents, spreadsheets, images, files, contacts … etc

What Live Mesh is proposing, is a very simple elegant and natural solution, you simply need nothing more than what you do now, and you get a completely new experience, Imagine that you have this magic folder on your computer, that when you put anything in it, woooosh it appears in a matter of seconds on all your other devices, not just this, but if you want, your friends devices as well ;)

This is it, this is exactly what you do, any folder on your PC, MAC, Phone can be turned into this magic folder, with Windows Live Mesh.

So imagine this concept applies to your most important folders (Your documents, projects, music library, pictures, … whatever), how cool is that!!

Is this the whole thing, simply NO, you can also access your files even if you are not using any of your devices, from any internet device (as long as it has a browser) you can access your online windows live mesh desktop, and access your magic folders, even add some new folders/files to them and everything gets synced in seconds, what about a device that is not connected at the moment, no problem, once it gets connected, it will receive the updates.

Is this the whole thing, Still NO, it also gives you another amazing feature, you can access any of your devices in the Mesh remotely from the web, so even if you are not around your device, you can connect to it inside the browser, and do whatever you like on it, it is awesome.

If you like what you read so far, you like this the most, it is completely Free.

Here is a very nice video summarizes what I said earlier

Windows Live Mesh, Synchronizes Life

Now you can start simply by logging in www.mesh.com cool URI isn’t it ;) with your windows live ID, and add your devices, and be part of the Mesh, The current CTP supports only Windows XP/Vista, soon it will support Mac & Mobile Phones ;)

LiveJournal Tags: News,Live,Mesh

Project Astoria is now RTM

2008-08-11T22:01:00Z

Whohoooo, Astoria is RTM

C# 4.0 Meet the team

2008-07-14T19:51:00Z

Almost an hour of conversation about C# 4.0 from the (Almost new) C# team, you will be surprised who joined the new C# team which can give you a hint about the future of C#.

C# 4.0 is one of the greatest achievements of MS and it is still proving that with every new release, I can't wait to get my hands on some new bits :)

C# 4.0: Meet the Design Team

Bill Gates, Looking Back, Moving Ahead

2008-06-29T07:04:00Z

I know you are not waiting for me to know that last Full Time day for Bell Gates was yesterday, however I couldn't help it to write about this great journey that inspired everybody.

Bill Gates was always the perfect geek, and will always be, he is an inspiration for everybody, inside Microsoft, or outside, even his competitors can't deny his influence on them and how he could give the right vision and direction for the company in the last 3 decades.

I will try to give you some goodies about Bill Gates, that I personally like

Bill Gates Harvard Speech (Believe me this one is funny :) )

Bill Gates Looking Back, Moving Ahead

Bill Gates in MacWorld in 1997 (The funniest part when Microsoft was planning to help Apple in Java)

Hello World

2008-06-19T21:53:00Z

Hey, this is my first blog post for my new blogs :)

I will copy some of my old blog posts that I personally like to this new blog, so you will find it being updated every now and then, keep in touch ;)

My longest two weeks ever

2008-05-20T00:23:00Z

Hey, It's been a while since my last blog post, I was somehow busy getting married, moving to another country, dealing with tons of paper work, however finally I had a weekend, and I am back to blogging, I have a lot to say, and I think it will be interesting enough for you to keep reading till the end

So basically this is what I am going to blog about today

Last days in Cairo
Moving to Canada & Vancouver City
Microsoft Canada Development Center (MCDC)
1. First Days
2. MCDC Cares Day

Last days in Cairo

The past two weeks started with my wedding arrangement and God, this is very exhausting, lots of stuff to deal with, writing a guest list, however Thanks to Facebook I didn't have to call everybody, and the result I came out of the wedding experience is, my kids whatever their IQ will be, they will have one of two options in their career life, either being a wedding planner or a hair dresser and/or make up artist.

The wedding was nice, it was a very nice opportunity for me to see everybody before being relocated to Canada, I really thank everyone for showing up that night, I was really proud of my friends.

Moving to Canada & Vancouver City

Couple of days after my wedding I was in the plane with my wife heading to Vancouver, we had a 20 hours journey from Cairo, we had a connection in London, the flight went smooth and very nice, however my back hurts when I recall sitting for 10 hours from London to Vancouver.

Once we arrived to Vancouver, we took a cab to our temp house, the first thing I noticed the high-tech cabs, the cab has a GPS with maps for the city, and also a very interesting fare counter, the counter was moving like a stop watch, even when the cab wasn't moving, the counter continues to move, the ride from the Airport to the temp house, which took around 15 mins cost about 27 CAD.

The city is wonderful, the streets are clean, nice and easy to learn, people are extra friendly, both cars and people are moving according to traffic rules, this is quite interesting for anyone coming from a country like Egypt :)

The temp house is in a very nice area, Map, I am in the 29th floor, so I have an amazing view of the sea and the mountains.

My first couple of days were very hard, because of the electricity here in Vancouver, the problem that the voltage range here is 100~110, while Egypt is 200~220 so many devices I had didn't work, also I found the strange outlet in the wall, which is different from the Egyptian outlets, so all devices like Laptops, Mobiles ... etc went out of charge during the first couple of days, I had to find a store where I can buy some adapters, in these days I felt like stone age, no mobile phones, no computers, no Internet, how could we live 15 years before today, Once I got the adapters I could communicate with my friends who arrived in Vancouver city couple of days before me (Haytham, Mustafa and Abdullah)

Also a nice tip, when I was changing money from Egypt, CAD was cheaper than USD, in Vancouver, CAD is higher than USD, so I lost some money when I exchanged some USD to CAD here in Vancouver.

Live/Google maps works great in Vancouver, and all Canada area, providing great help for directions and finding addresses, Google Maps though has a nice feature to give direction in public transit, so you can see which busses you'll need to take and at what time.

Microsoft Canada Development Center

In the picture from left, Abdullah, Mostafa and Me

In the picture from left, Abdullah, Mustafa and Haytham

Here comes the first day @ Microsoft, the first day started in a park nearby Microsoft, the day started with some introductory sessions about Microsoft Canada, and Microsoft future of Computing, and the future vision of MS.

After couple of hours we went to MCDC, we had a nice tour around the facility, the place is very amazing, simple and fun, some parts still under construction.

People there are from everywhere, it is like a small united nations, Egyptians are all over the place and we are increasing, in our batch there was 7 Egyptians out 31 new hires, this is quite nice number.

Then after the tour we had another session about the needed paperwork, lots of forms to fill, I had to write my name about 50 times later this night when filling in the forms, then we head to our offices.

My office is in Building 3, Office 1077B, I am sharing the same office room with Mostafa, every dev is using two machines, one for web surfing, email, IM, ... etc and the other for development, the machines are GREAT, I even found people working in triple machine setup according to their work needs.

In the first day my manager called me from Redmond, I IMed the other team mates, I found out that I am the only dev outside Redmond in my team.

During the first days, we were all busy finishing the paperwork, we didn't start working yet, however in the forth day we had a great experience.

MCDC Cares

Since our first day, we were asked to join this event, the event called MCDC Cares, is a community work program that Microsoft will help the Richmond city in building a 700ft long boardwalk in Richmond Park, the idea is that this part of the park is very muddy that no visitors can get inside, so Microsoft decided to help in building this boardwalk by providing manpower (150 computer geeks) for a whole day.

So early on May 15th, all Microsoft Canada Development Center gathered in the cafeteria where Parminder (Par) Singh, the Managing Director of MCDC gave a short speech to everybody

In the picture Parminder Singh

After this we all moved to the park, the park is quite big, it was my first time to actually feel being in the woods, were the trees are very high and land is either very green or very muddy.

In this picture the completed part of the boardwalk we were about to complete, the boardwalk goes very deep into the woods.

So first things first, we had to move 1500 pieces of wood from the parking area outside the park to the working place deep into the woods, about 800m distance, this part of the job took around 4~5 hours.

After this phase we had a lunch break and during this break

Then phase 2 started, the phase 2 was to nail the 1500 pieces of wood we moved in phase 1 with 6 nails per piece, so in a period of 3 hours we had to hummer about 9000 nails manually.

Then we head back to MCDC, very exhausted but very happy with the work we've done, this boardwalk will be there for ages, and this was a very nice opportunity to do something useful.

In MCDC we had a BBQ party for everyone so the day ended pretty much after the BBQ, then I believe that everybody slept like a baby for more than 9 hours :)

Here you can find the TV coverage of MCDC Cares day

If you read this line so you survived the whole blog post, thank you for reading this, I will be blogging again & again, so keep in touch :)

Using WebHttpBinding & JSON Support in WCF

2008-01-05T22:03:00Z

I had some cool time working with WCF new features shipped with .net 3.5, one of the most ineteresting and useful features is the JSON support and how easy you can enable the JSON support for your current WCF services by changing the configurations.

Why do we need JSON support?

Well, JSON (JavaScript Object Notation) is very suitable for building ajax based applications for some reasons.

The other popular alternative (XML) requires parsing code in the client side to extract the data from the document, which is not the best thing to do using Javascript.
XML documents size are relatively bigger than JSON documents containing the same data

To get more info about JSON check here and here

What WCF offers to support JSON

All what you need is doing two things

Create an end point that uses the new binding (WebHttpBinding)
Configure the end point behavior and enabling the WebScript (which will generate a javascript proxy for your service contract and data contracts)

This is a sample configuration

<system.serviceModel>

    <behaviors>

      <endpointBehaviors>

        <behavior name="ChatAspNetAjaxBehavior">

          <enableWebScript/>

        </behavior>

      </endpointBehaviors>

    </behaviors>

    <services>

      <service name="ChatService">

        <endpoint address="" behaviorConfiguration="ChatAspNetAjaxBehavior"

                binding="webHttpBinding" name="ajaxEndpoint" contract="IChat"/>

      </service>

    </services>

  </system.serviceModel>

As you can see the endpiont configuration is using the Binding "webHttpBinding" and it is also configured in the behavior tag to enable web script.

Now the WCF runtime will generate a javascript proxy containing all services and data contracts as javascript classes, we will see an example shortly.

Example: Building a Chat Application using WCF & JSON support

It is time for more detailed example, in this example we will develop a small web based chat application using javascript as a client language and WCF as a server side.

The chat application will be able to do these functionalities

Register users
User logins
Retrieve users list
Check new messages
Send message
Log out

So let's write down the contract for this service (we will ignore good design practices for the sake of simplicity and will make one service that does both the user management and chatting)

[ServiceContract(Namespace = "")]

public interface IChat

    [OperationContract]

    User Register(string username, string password);

    [OperationContract]

    User Login(string username, string password);

    [OperationContract]

    bool Call(Guid fromUserId, string toUsername, string message);

    [OperationContract]

    Message[] GetMyMessages(Guid userId);

    [OperationContract]

    bool SignOut(Guid userId);

    [OperationContract]

    User[] GetUsers();

This is basically how the service contract looks like, we are still missing two data contracts User & Message and here they are.

[DataContract]

public class Message

    [DataMember]

    public Guid ID { get; set; }

    [DataMember]

    public string Body { get; set; }

    [DataMember]

    public DateTimeOffset Date { get; set; }

    [DataMember]

    public string FromUsername { get; set; }

    public Message()

        ID = Guid.NewGuid();

        Date = DateTimeOffset.Now;

[DataContract]

public class User

    [DataMember]

    public Guid ID { get; set; }

    [DataMember]

    public string Username { get; set; }

    public string Password { get; set; }

    public User()

        ID = Guid.NewGuid();

The implementation of the service is not very important and the code is attached with the blog entry, basically it saves all the messages and users in static collections, in real life cases the implementation will be different most probably a database is going to be used.

Now let's start building the client side of the chat application.

We will be hosting the chat service on IIS so we will create a .svc file chat.svc which will contain one line

<%@ ServiceHost Language="C#" Debug="true" Service="ChatService" CodeBehind="~/App_Code/Chat.cs" %>

And this will be the address of our service.

and then we will place the configuration of the service in web.config

1: <system.serviceModel>

2:   <behaviors>

3:     <endpointBehaviors>

4:       <behavior name="ChatAspNetAjaxBehavior">

5:         <enableWebScript/>

6:       </behavior>

7:     </endpointBehaviors>

8:   </behaviors>

9:   <serviceHostingEnvironment aspNetCompatibilityEnabled="true"/>

10:   <services>

11:     <service name="ChatService">

12:       <endpoint address="" behaviorConfiguration="ChatAspNetAjaxBehavior"

13:         binding="webHttpBinding" name="ajaxEndpoint" contract="IChat"/>

14:     </service>

15:   </services>

16: </system.serviceModel>

The configuration is similar to the above one, except for the line #9 which is the serviceHostEnvironment, all what you need to know about this attribute that enabling it will make asp.net treats the WCF service as regular asmx service, for more details about different modes of running WCF services with ASP.net check this article

We will now create two views

Login View
Chat View

The login view is basically like this

Two text boxes (txtUsername, txtPassword) and two input type buttons for register and login actions

The Chat View will look like this

Which contains two more textboxes (txtToUsername, txtMessage) and a select control containing the current users (slGuests) and a panel that will show the message history (pnlMessageHistory)

May be it is not the best user interface but it will do the basic things.

now we will need to add the ScriptManager to the page and add a reference to the wcf service

1: <asp:scriptmanager id="scrptMgr" runat="server">

2:     <services>

3:         <asp:servicereference path="~/Chat.svc" />

4:     </services>

5: </asp:scriptmanager>

This will add a script element with a source pointing to this url http://[domain]/Chat.svc/js which will download the javascript proxy code.

We will now do some initialization codes let's see how it looks like...

1: var user;

2: var chatService = new IChat();

3: var guests = new Array();

4: window.onload = function(){

5:     var btnRegister = $get("btnRegister");

6:     $addHandler(btnRegister, "click", doRegister);

7: }

Let's check line #2, this is the neat part of using WebScript, the IChat class is the generated proxy object for the IChat service contract, and for this application we need only one object so the object is created and initialized globaly.

Now let's write the register function

1: function doRegister()

2: {

3:     var username = $get("<%=txtUsername.ClientID %>").value;

4:     var password = $get("<%=txtPassword.ClientID %>").value;

5:     chatService.Register(username, password, onRegisterSuccess);

6: }

7:

8: function onRegisterSuccess(result)

9: {

10:     if(result != null)

11:     {

12:         user = result;

13:         var btnRegister = $get("btnRegister");

14:         btnRegister.value = "Sign Out";

15:         $clearHandlers(btnRegister);

16:         $addHandler(btnRegister, "click", doSignOut);

17:         var btnLogin = $get("btnLogin");

18:         btnLogin.style.display = "none";

19:         $get("<%=txtUsername.ClientID
            %>").disabled = true;

20:         $get("<%=txtPassword.ClientID
            %>").disabled = true;

21:         $get("divChat").style.display = "inline";

22:         setTimeout(doCheckMessages, 1500);

23:     }

24:     else{

25:         alert('Error!');

26:     }

27: }

the doRegister function is calling the Register method defined in the IChat service contract, you will notice a nice feature that VS intellisence is working nice in this part

All the proxy function will have the same parameters defined in the contract, but because of the nature of the asynchronous call, all the functions will add three extra parameters (onSuccessCallback, onFailureCallback, userContext)

The onSuccess callback is very important, as this where you will get to know the return value (if any), and also where you can say that the server finished working on the request, so in the Register example, in the onRegisterSuccess if the user is created, the Login view is disabled and the Chat view is displayed, also an important part is a timer configured for polling the server for new messages, and the timer is called once every 1.5 seconds, and the result parameter to the onRegisterSuccess function is the return value of the Register method on the IChat service, which in our case it is either a User object or null, if the user object is returned it is saved to the global variable user.

Now let's see when we send a new message to a certain user

1: function doSend()

2: {

3:     var pnlHistory = $get("<%=pnlMessageHistory.ClientID %>");

4:     var txtMessage = $get("<%=txtMessage.ClientID %>");

5:     var txtTo = $get("<%=txtToUsername.ClientID %>");

6:     pnlHistory.innerHTML += "<b>" + user.Username + " says:</b><br>" + txtMessage.value + "<br>";

7:     chatService.Call(user.ID, txtTo.value, txtMessage.value, onSendSuccess);

8: }

9:

10: function onSendSuccess(result)

11: {

12:     var txtMessage = $get("<%=txtMessage.ClientID %>");

13:     txtMessage.value = "";

14: }

The send message function will call the Call function on the service, and also writes down the message details on the message history panel.

The callback of this function is simply clears the message textbox.

Now when you send a message to someone else, the message is temporarily saved on server till the recipient user queries the server for his messages, this logic is done through a client side timer.

1: function doCheckMessages()

2: {

3:     chatService.GetMyMessages(user.ID, onCheckMessagesSuccess, onCheckMessagesFail);

4:     chatService.GetUsers(onGetUsersSuccess);

5: }

6:

7: function onCheckMessagesSuccess(result)

8: {

9:     if(result == null)

10:         return;

11:     var pnlHistory = $get("<%=pnlMessageHistory.ClientID %>");

12:     for(var i=0; i<result.length; i++)

13:     {

14:        pnlHistory.innerHTML += "<b>" + result[ i].FromUsername + " says:</b><br>" + result[ i].Body + "<br>";

15:     }

16:     setTimeout(doCheckMessages, 1500);

17: }

18:

19: function onCheckMessagesFail(err)

20: {

21:     alert(err.message);

22:     setTimeout(doCheckMessages, 1500);

23: }

The doCheckMessages function does two things, first it checks for the new messages from server, and the other thing is checking for new users in the chat.

the onCheckMessagesSuccess is reading all the messages in the result array of messages, and print them out on the message history with proper format, and then it initialzes the timer again.

This is typically how the chat will look like

Summary

In today's entry I was giving a small overview of one of the new features introduced in WCF 2.0 (.net 3.5) which is WebScript and JSON support, this feature allowed us to create a rich web based application using only Javascript as a client code, we also developed a simple Chatting application to prove the concept and the code is attached with this post for further information and details.

Have a nice day.

Technorati Tags: WCF,C#,JSON,Javascript,ASP.net

PLINQ is coming up soon (PFX)

2007-10-14T10:59:00Z

I've been hearing about PLINQ (Parallel Linq) since the first days of announcing LINQ, the idea of making use of the new functional style programming provided in DotNet 3.5 in order to give better performance on Multi Core machines, the idea sounds cool since first day, and it now comes true in a new name Parallel FX or PFX

The programming model provided is quite simple and utilizes the same LINQ model, the new assembly is called System.Concurrency.dll which is the library that contains the new interface called IParallelEnumerable<T>, also it adds an extension methods for all collections and arrays that implement old IEnumerable, the extension method is called AsParrallel<T> which converts any collection to a Parallel enabled collection of type IParallelEnumerable<T>

Take a look of the following code

IEnumerable<int> data = new int[] {1, 2, 3, 4, 5, 6}; // or whatever complex data collection

var q = data.Where(x => x > 4).OrderBy(x=>x).Select(x => x);

foreach (var i in q) ....

This code is what you already write in C# 3.0, now if you want to add PLINQ support all what you have to do is adding the AsParallel function call before using any query operation so the previous code will look like this

IEnumerable<int> data = new int[] {1, 2, 3, 4, 5, 6}; // or whatever complex data collection

var q = data.AsParallel().Where(x => x > 4).OrderBy(x=>x).Select(x => x);

foreach (var i in q) ....

or you can write it in the LINQ query style

IEnumerable<int> data = new int[] {1, 2, 3, 4, 5, 6}; // or whatever complex data collection

var q = from i in data.AsParallel()

        where i > 4

        orderby i

        select i;

foreach(var i in q) ....

Once you've added the AsParallel function call, PLINQ will be ready to execute transparently all the OrderBy, Where, Select, GroupBy ... etc on all the available processors.

You don't need to explicitly create threads, locks and manage concurrent execution (Unless you are making something big).

This doesn't mean that you can make use of the PLINQ power on anything other than Queries, the ParallelEnumerable class also adds some extra extension methods like the ForAll method

The ForAll method is useful if you are applying some kind of operation on all the members of a certain collection, so the ForAll function will do this operation in parallel for all the members of the collection

IEnumerable<int> data = new int[] {1, 2, 3, 4, 5, 6}; // or whatever complex data collection

data.ForAll(i=>Console.WriteLine(i));

The previous code sample will print out all the members of the array, if you imagined calling more complex function that does some heavy work on each array member, the ForAll will give you extra power to do the job faster by making use of the parallel data processing techniques.

This is not all the new stuff introduced in the System.Concurrency library, the new Parallel class is also a nice addition, it provides some extra general purpose parallel execution, so it is not related to LINQ, the most important part is the Parallel.For function, which as you expected from the name executes a parallel loop.

Check the following code

void ParMatrixMult(int size, double[,] m1, double[,] m2, double[,] result)

  Parallel.For( 0, size, delegate(int i) {

    for (int j = 0; j < size; j++) {

      result[i, j] = 0;

      for (int k = 0; k < size; k++) {

        result[i, j] += m1[i, k] * m2[k, j];

});

This is an example I got from here, it illustrates a Matrix Multiplication using Parallel.For, as you can see the Parallel.For method accepts the start index and the length, then a delegate to execute.

There is also Parallel.Aggregate function which can be used to aggregate a certain data item over a parallel loop safely.

This all what I could write in one post, however the System.Concurrency contains more cool API's.

Here comes the resources for further readings.

SOA via WCF - Part 2 -

2007-09-17T11:07:00Z

This is the second part of my presentation in SilverKey Demo Day 2 (SKDD 2) last July, for the first part, Check Here, you will also find the presentation slides & samples attached in Part 1 or you can download from here
So let's start
Let's check our Agedna

In Part 1 we discussed what is SOA and the concepts behind it, also we had a walk through different approaches to apply SOA in our applications in terms of standards and patterns.
In Part 2 we are going to discuss WCF or (Windows Communication Foundation) which is Microsoft new framework to unify communication mechanisms and provide an infrastructure for our SOA applications.

As we've just mentioned WCF stands for Windows Communication Foundation and also it used to be called Indigo.
WCF was shipped with Windows Vista in November 2006 as part of .net framework 3.0, however it is also available for Windows 2000, XP and 2003.

WCF is all about providing an unified infrastructure that handles all communication scenarios and protocols, which includes different transport, messaging patterns, encoding .... etc.
WCF also playing a great role in making the life easier for .net developer, so the messages exchanged between different services are exposed as CLR types (classes), and also the services are represented as interfaces and classes, so it provides a good and very high level of abstraction.
So as one sentence you can say that WCF is the infrastructure for building Services.

As we said WCF unifies the communication techniques, but how ?
Before the WCF days, we used to have different technologies for different communication problem, so if you are doing TCP communication you will be using Sockets for example, and if you are providing online services over HTTP, you will be using Web Services, and if you are doing message queues you will be using MSMQ ... etc
So this was good, however it has some drawbacks.

You have to learn different models for every communication technique.
You can't change the communication technique you are using in a certain application to another without massive changes in your code.

So what WCF provides is a One Right Solution for all problems, which saves your time and effort, also it comes with a full fledged set of goodies such as Tracing, Logging which can be used regardless of the communication technique you are using.

One of WCF great benefits that it provides a very handy extensible model, that you can add support for new protocols easily, or even slight changes to current protocols like adding a new encoding or encryption algorithm.or a new tracing mechanism.
Another thing that WCF is supporting almost all the WS-* standards like WS-Addressing, WS-AtomicTransaction which makes the messages generated from WCF runtime interoperable with any current or future application built with same standard messaging.
and The most elegant feature of WCF, that all the configuration of the services and protocol specific properties can be configured using XML config files outside the application, which is a great feature that allows administrators to be part of the game, so they can change stuff like the impersonation options, and security settings, enabling and disabling trace listeners and logging, without the need to ask developers to do it, which is somehow similar to ASP.net configuration.
Also this config file can be edited using a UI tool..
For architects it is really easy to stay in the high level design and forget about implementation details and technology limitations.

So let's have a sample service
In this demo we will be discussing the basic elements in any WCF application.
The most basic three elements are

Address
Binding
Contract

They are also called the ABC's of WCF, because every service has to define these three elements.
We will be discussing everyone of these elements in details,
let's now see how a Service is defined in WCF. in steps we will discuss how to build a simple News service.
1. Define the Contracts
In this step we will define the different contracts of the service the first type is

Service Contracts

[ServiceContract(Namespace="com.silverkeytech.news")]
public interface INewsService
{
    [OperationContract(IsOneWay=false)]
    Article[] GetArticles();
}

As you see the Service Definition is just an interface (Contract) which is decorated with an attribute called ServiceContract.
This interface defines the different functions provided by the service in terms of inputs/outputs and exchange patterns.
Every service function is represented in a form of interface method, and the inputs of the service function are represented as inputs to the method and also the output is represented as return type of the method.
The exchange pattern is by default Request/Response which is represented using the Attribute OperationContract with the IsOneWay property set to false, if it was set to true this means that this service function is a fire & forget type of service, which the service clients will not expect any response for the messages sent to this functions.

Data Contracts
Also if you noticed in our method return type is a complex type Article this is not a primitive type in .net, it is a user defined type which has to be defined like this.

[DataContract]
public class Article
{
    string title;
    string details;

    [DataMember]
    public string Title
    {
        get { return title; }
        set { title = value; }
    }
    [DataMember]
    public string Details
    {
        get { return details; }
        set { details = value; }
    }
}

As you can see it is a simple data class that is decorated with a DataContract attribute, so it tells the WCF runtime that this class will be converted to a message that will be sent or received by one or more service functions, also every field or property of interest has to be decorated with another attribute called DataMember.

2. Implement the Service
Now we need to provide the implementation of the Service Contract interface, which will do the actual job of the service, all what we need is to implement the interface in a class like this.

public class NewsService : INewsService
{
    public Article[] GetArticles()
    {
        List<Article> articles = new List<Article>();
        for (int i = 0; i < 10; i++)
        {
            Article article = new Article();
            article.Title = "Title " + i.ToString();
            article.Details = "Details " + i.ToString();
            articles.Add(article);
        }
        return articles.ToArray();
    }
}

So the class NewsService implements the interface INewsService and provides an implementation of the service that does the actual job of how the service will handle the incoming requests.

3. Hosting the Service
Now after we implemented the service, we have to host it on an application, there are different choices depending on your need, you can host the service on Windows Applications (Console, Windows Forms, Windows Services) or Web Applications (IIS), for simplicity I will host my service on a console application.

namespace Host
{
    class Program
    {
        static void Main(string[] args)
        {
            using (ServiceHost host = new ServiceHost(typeof(NewsService)))
            {
                host.Open();
                Console.ReadKey();
            }
        }
    }
}

As you see, the host is very simple, all the hard work is done in the ServiceHost class which its constructor requires the type of the class that implements my service, in our case NewsService class.
Then we call the Open method to allow the service to accept any incoming requests and process them, the last Console.ReadKey is just for not allowing the application to exit unless somebody presses any key.

4. Configuring the Service
After we hosted the service we need to configure this service, we need to write how the service is going to interact with its clients, this will be done using the App.Config file of the host

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <system.serviceModel>
        <services>
            <service name="BeebcNews.NewsService">
                <endpoint address="EndPoint1" binding="basicHttpBinding"
                    bindingConfiguration="" name="HttpEndpoint" contract="BeebcNews.INewsService" />
                <host>
                    <baseAddresses>
                        <add baseAddress="http://localhost:9000/beeBC" />
                    </baseAddresses>
                </host>
            </service>
        </services>
    </system.serviceModel>
</configuration>

This is sample configuration file that is used to configure the NewsService we've just implemented

5. Consuming The Service
After we host and deploy our service, we need to consume it, which mean we need to write client applications that sends and receives requests and responses from the service.

Generating Proxy Class
So for the client application to be able to use the service we need to use a proxy class, the proxy class is generated using a tool called svcutil.exe this tool can be applied either on the Service dll or on the WSDL file url of the service.
so let's assume our NewsService dll is called MyLibrary.dll
We will write this command in the command prompt.

svcutil.exe MyLibrary.dll

This command will generate the XSD files & WSDL file for the types and services inside the library, there are more switches can be used for more specific options.
Then after we generate the XSD, WSDL of the wcf service we apply this command on the generated files.

svcutil.exe *.xsd *.wsdl /language:C#

This command will use the XSD, WSDL file we generated with the first command to generate a proxy class in C# and an XML config file.

Then we can use the new files to write our client applications.
Another way of generating the Proxy classes is to switch on the MetaData publishing for the service, so the service will have a http url that contains the WSDL file, then we can use this command

svcutil.exe http://[the service url]

and this will generate the C# proxy and the config file

Implementing the Client Application

namespace Client
{
    class Program
    {
        static void Main(string[] args)
        {
            NewsServiceClient client = new NewsServiceClient("HttpEndpoint");
            Article[] myArticles = client.GetArticles();
            foreach(Article a in myArticles)
                Console.WriteLine(a.Title);
            Console.ReadKey();
        }
    }
}

The previous code is a simple example of a client application that uses the generated proxy class we've just generated that generated the NewsServiceClient class, which has the same functions provided by the INewsService interface so we can call them and the WCF will handle the communication between the client and server.

Now let's have an overview of the architecture of WCF, or let's call it the journey of the incoming message to the service and how it is going to be handled.
The architecture of WCF is basically a pipeline, the message arrives on the transport layer which is going to pass it to the next layer to be decoded and then it passes through different protocol specific layers till it reaches the dispatcher, which is going to decide this message belongs to which method in the running instance of the service, and then deliver it to the method to be processed then the return value (if any) takes a similar path down the pipeline back to the original sender.
This pipeline is configured using the Configuration and the Contract, the configuration defines the layers in the WCF pipeline and the Contract helps the Dispatcher to find the destination of the message.

If you take a look on the XML Configuration in the previous example, you will find that under the Service element there is something called EndPoint
The EndPoint is the container that has the three basic elements of the service we mentioned before (Address, Binding & Contract).
So in our previous example the Address was EndPoint1, which is going to be concatenated with the baseAddress of the Service in our case "http://localhost:9000/beeBC"so the result address will behttp://localhost:9000/beeBC/EndPoint1, then the Binding which was "basicHttpBinding" which is the simply SOAP messages over HTTP using text encoding.
and the Contract which has the full name of the INewsService interface which defines our service contract.
Now let's see each Endpoint element in details

The Address
Defines Where the endpoint resides

The Binding
Defines How the service is communicating with the outside world.

The Contract
Defines What the service will offer to its clients.

Before we end this presentation, I would like to highlight that WCF 2 is on the way, it will be shipped with next version of Visual Studio 2008 and .net framework 3.5
The new version of WCF will have better support for Webby style services such as REST style services and also supports different encodings like RSS, ATOM and JSON.
Also the huge change will be that WCF and WF are merged together in what is called Silver project, which will enable developers to develop WCF service with Workflow as an implementation.

These are some resources for more information about WCF and SOA also some books for further information.

I hope you read this line, which means that you kept reading the whole presentation, I hope it was useful for you, if you have any questions write them as a comment to this blog post and I will be answering them immediately.

SOA via WCF - Part 1-

2007-08-11T11:05:00Z

Service Oriented Architecture via Windows Communications Foundation

I should have blogged this very much earlier, because this was my presentation in SilverKey Demo Day II last July 7th, so it took me more than a month, I hope I still rememebr :)
You will find the presentation attached with this blog post

So today, I will be talking about Service Oriented Architecture (SOA) in general also I will give an introduction to Windows Communications Foundation (WCF) and how to apply SOA concepts in real life.
Let's see the Agenda

Part 1- Service Oriented Architecture

Background
Motivations
What is a service ?
Message Exchange Patterns (MEP's)
Industry Standards
Web Standards

Part 2- Introducing WCF

What is WCF
WCF Architecture Overview
Demos

In today's blog post I will be only discussing Part-1 in the coming days, I will be writing Part 2 in a separate blog post.

Let's start with First part Service Oriented Architecture (SOA).

Service Oriented Architecture is a buzz word in the world for many years, architects have been talking, writing, blogging and also building applications using SOA, but before we go with the wave, why don't we stop for a while and go back with time to see the software evolution since its early days.

Since the early days of software industry, just when people started to use general purpose programming languages such as C, the concept of reuse was in mind, but the reusable unit couldn't me more than a function or a procedure, or may be some unstructured and unorganized pieces of codes, that used to get copied and pasted whenever needed,
However, this was developed by time, till the days of Object Oriented, when a bigger unit of code was defined, this unit was called Class, the Class which consists of data and Logic, became the major unit of organized reusable code for the past couple of decades, but there was a major problem, that class objects are not exchangeable outside the technology, in other words an object built with C++ can't be used as is in another class written with Java, so the reuse was limited by the technology,
Component Oriented came to the rescue with technologies such as COM, DCOM, COM+ for windows and other technologies were developed for other platforms, so different technologies can exchange objects between each others, for example, in windows environment you can use the UI elements such as Buttons, TextBoxes from any technology even though those UI elements are not developed using the same technology you are using for your application, this was great but what about exchanging objects and data between technologies running on different platforms, like a C# application developed on Windows want to send an object for a Java application running on a Unix platform, here is when Service Oriented came to rescue.

Why do we need to exchange objects through different platforms?
The answer is one word Integration, when you are building an applications that needs to integrate with another Existing application, which happened to be developed using a different technology and runs on different platform, what will you do ? you have to find a way to integrate with this application.
For example, if you want to add Maps support in your application, are you going to build a GIS system to view some maps in your application, surely no, but you are going to integrate with something like Google Maps or Microsoft Virtual Earth to send the coordinates and receive the map.
In our example we will find ourselves calling Google Maps or MS Virtual Earch a Service, which leads us to the next question

What is a Service ?
A Service is a reusable piece of software, but the main difference that this piece is as large as a full application, this application might be built using any technology and deployed on any platform, these details are not important as long as the Service provides a Structured Messaging Scheme, this structured messaging scheme in most cases is XML document(s) or any other text-based structure, that can be exchanged on Http, but the fact is it is not only XML nor HTTP, it can be any other format on any transport as long as it is well defined.

This model of separation comes with some other benefits, like Versioning independence, which means that as long as the Service doesn't change its messaging structure, it can change any inner implementation details and add more features without the need for all other applications that use this service to be aware of these changes.
Also the nature of the separation between the Service and other clients or even other Services, introduced some concepts like Message Exchange Patterns which is how the structured messages are exchanged between Service and Clients.

The message exchange patterns used are either

One Way
Request/Reply
Duplex

The One Way is when the sender sends a message to the receiver but the sender doesn't expect the receiver to reply to this message, it is something like Fire & Forget.
The Request / Reply is when the sender sends a message to the receiver and expects ONLY one reply from the receiver, as an example any web page you request for it in your browser you expect a reply (Response) which is the Page you requested.
The Duplex is when both Sender & Receiver construct a channel between them and everyone of them can send messages to the other at well, it is just like a Phone Call.

Every MEP has its best use, depends on the Scenario, in Part 2, I will be doing samples with WCF that show how to use different MEP's with WCF.

From the previous talk about Integration you might have imagined if everything gets standardized so no matter what system you want to integrate with, you know that there is a standard way of doing this.
Actually this is somehow true, there are some initiatives by Software Industry leaders such as Microsoft, IBM, Oracle, Sun ... etc, to standardize the Service Structure Exchange Scheme thing into something real, which results in what we call SOAP (Simple Object Access Protocol) which is a XML based protocol that defines the message that is going to be exchanged between different Services & Clients, also there are some standard protocols that were built on top of SOAP which all of them starts with WS-, so they were all called WS-* Protocols like WS-Addressing, WS-AtomicTransaction, WS-Security ... etc, everyone of them is defining a standard way of handling a specific scenario in terms of the Exchanged Message structure and parties involved, like WS-AtomicTransaction it defines a protocol for performing distributed transactions between Services.
These standards are being used in different technologies under several names, that most common technology is Web Services & WSE

The SOAP & WS-* are NOT the ONLY method available but there is another ways which are most commonly used over the web, and so called Web Standard, or Webby Standard.
These methods can be grouped under REST.
REST (Representational State Transfer) which relies on HTTP verbs such as GET, which most of the time uses the URI as a function call, so you request a URI with a specific parameters and gets the result in any format such as XML, text, or JSON.
This method is used because it is very simple and especially for listing data

Give SOAP a REST
You will find a lot of debates online about which is better SOAP & WS-* or REST, which I think is not the right question, because you will always find situations where you find REST better and vise versa.

As a summarization of this part of the presentation, Here is a list of online services that most of them are free and available using either SOAP, REST or both.

Summary
Service Oriented Architecture is one of most important techniques that introduces new way of thinking and designing systems in order to provide better integration options.

Javascript tricks for ASP.net developers

2007-06-17T11:11:00Z

This is a post I wanted to write really long time ago, but I never had enough time to sit and write.
The following listing will be my agenda for this post

Why Javascript for ASP.net developers is different ?
Javascript tricks for ASP.net developers

Reading ASP.net controls values from Javascript
Passing values calculated by Javascript to the server side.
Passing values from ASP.net to Javascript

Javascript development tools

So let's go through the previous points and see if this will be interesting enough for you to read it to the end.

Why Javascript for ASP.net developers is different ?

The first difference between ASP.net and other web technologies that it has its own web controls which sometimes map to standard HTML controls, so sometimes what you see in ASP.net as a control doesn't mean that it will be rendered as one control in the final HTML which means that Javascript can't deal with it directly as it does with basic control.
Taking the ASP.net Calendar control as an example, in ASP.net you use it as one control just drag it and drop it in the page and boom! you have a full functional calendar, but in reality this calendar renders as a Table with rows and columns and links and also lots of Javascript, so you can't expect that you will deal with it as a calendar in the Javascript side, this also applies to Repeater, Grid, DataList ... etc

The second difference is that even with asp.net server controls that maps directly to standard HTML controls like TextBox or Button, the asp.net runtime changes the control Id's so if placed a code like this in your ASP.net page directly

<asp:TextBox ID="myTextBox" runat="server"></asp:TextBox>

the rendered equivalent HTML will look like this

<input type="text" id="myTextBox" name="myTextBox"/>

As you can see the asp:TextBox id is the same as the input text id which is "myTextBox", but watch out, if you put the previous asp:TextBox in a UserControl instead of adding it directly to the page, and then added the UseControl to the page like this lets name our usercontrol "MyControl"

<uc1:MyControl ID="MyControl1" runat="server" />

the rendered equivalent HTML will look like this

<input type="text" id="MyControl1_myTextBox" name="MyControl1$myTextBox"/>

As you can see the rendered input field Id is not "myTextBox" but it is a combination of the usercontrol id and the textbox id separated by underscore "_" and the name of the control is similar but separated by dollar sign "$".
So that's why you will face some difficulties when you try to use document.getElementById on the "myTextBox" because the name is not known until the page renders.

Javascript tricks for ASP.net developers

Reading ASP.net Controls Values from Javascript
I think now you have seen the problem and it is time for the solution so let's see the basic solutions for most of Javascript problems with ASP.net.
The solutions comes from the fact that almost all ASP.net controls have a property called ClientID which returns the Id of the rendered equivalent HTML control. so in our last Example the myTextBox.ClientID will return "MyControl1_myTextBox" so you can apply the document.getElementById , buy wait a second how could I get this property value inside my Javascript code ?
This will require writing some ASP classic style code to this job inside the javascript so let's see how our UserControl code will look like

<%@ Control Language="C#" AutoEventWireup="true" CodeFile="MyControl.ascx.cs" Inherits="MyControl" %>
<script type="text/javascript">
function myFunc()
{
    var myTextBox = document.getElementById("<%= myTextBox.ClientID %>");
    myTextBox.value = "value from JS";
}
</script>
<asp:TextBox ID="myTextBox" runat="server"></asp:TextBox>
<input type="button" value="Click" onclick="myFunc()" />

So if you have a look into the myFunc function
the document.getElementById parameter is actually a asp.net code which is written <%= myTextBox.ClientID %>
and this how myFunc code will be in the browser.

<script type="text/javascript">
function myFunc()
{
 var myTextBox = document.getElementById("MyControl1_myTextBox");
 myTextBox.value = "value from JS";
}
</script>

so the asp.net code between the <%%> is executed and the property ClientID was evaluated.

Passing values calculated by Javascript to the server side
Yeah this is very important, sometimes you calculate some values or get some inputs from the user using Javascript code but you want to process these result in the backend, and you find yourself asking this question, how can I send those results back to the asp.net ?
The answer is simple use your best friend The HiddenField.
Write all your results in the hidden field BUT make sure that this hidden field is either a asp:HiddenField or a regular input type="hidden" field with runat="server" attribute, so the asp.net runtime picks its value from the form and post it to the field in the backend.

Passing values from ASP.net to Javascript
Sometimes you need to pass values or initialize some variables in javascript using code behind, in this case you need to use your other friend the Literal Control
The literal control is amazing because it simply renders to nothing but the values inside, so it doesn't render to Span like Label or div like Panel, so take this example

<asp:Literal runat="server" ID="litData">My Text</asp:Literal>

This code will render to this

My Text

Consider the example when you need to use the server date in the client javascript code, because the javascript Date function returns the client date so sometimes you need to use the Server time not the client time, so this is a way to do it using the Literal trick.
in your asp.net markup code define a similar javascript block

<script type="text/javascript">
var serverDate = '<asp:literal runat="server" id="litServerDate" ></asp:literal>';
</script>

and then in your Page_Load code you can do this

protected void Page_Load(object sender, EventArgs e)
{
    litServerDate.Text = DateTime.Now.ToShortDateString();
}

In the javascript code you define a variable which takes its value from a literal control, the literal control is your connection to the backend code,
the backend code puts the data inside the literal and completes the javascript sentence, so the result javascript will look like this

<script type="text/javascript">
var serverDate = '6/17/2007';
</script>

So the literal is gone and the result is just the date string provided by the server, which you can use later to do whatever you want.

Javascript development tools
If you decided to write some code in Javascript so be ready and use the proper tools

First of all I prefer you develop your code on FireFox because it is more strict and if you made your code run fine on FireFox most probably it will run fine on every other browser.
Second you need Debugger so I strongly recommend FireBug which is an addin to FireFox which has lots of useful tools one of those tools is a Javascript debugger
Visual Studio is a good IDE however there is another IDE especially dedicated to Javascript which is APTANA , aptana also provides a debugger for FireFox so you can use Aptana debugger to debug your javascript running in FireFox

So that's what I could write in a single post, soon I will post some hints and tricks for developers to make it easier for them to write AJAX applications without using UpdatePanel.
Have fun.

Command Design Pattern in C# 2.0

2007-03-25T11:13:00Z

I have posted before about how to implement the observer pattern using C# in a way that is more suitable to C# and uses its functionalities to produce more elegant code.
This time I am re-implementing the Command pattern in a C# way.
First of all, let's see the classic Command Pattern UML diagram

As you can see the pattern consists of five actors

Invoker
Command (interface)
Concrete Command class(es)
Receiver
Client

for more information about Command pattern check here
Now let's see how it can look like in C# world.

Let's see how the Command interface will look like

delegate void CommandHandle<T>(T receiver);

Awesome doesn't it, just one line :)

Let's see the Command Concrete Class

sealed class Command<T>
{
    T _receiver;

    CommandHandle<T> _doCommand;
    CommandHandle<T> _undoCommand;

    public Command(CommandHandle<T> doCommand, T receiver)
    {
        _doCommand = doCommand;
        _receiver = receiver;
    }

    public Command(CommandHandle<T> doCommand, CommandHandle<T> undoCommand, T receiver)
        : this(doCommand, receiver)
    {
        _undoCommand = undoCommand;
    }

    public void Execute()
    {
        if(_doCommand != null)
            _doCommand(_receiver);
    }

    public void Undo()
    {
        if(_undoCommand != null)
            _undoCommand(_receiver);
    }
}

This is a generic class so it can be used for most cases instead of creating multiple inherited classes, the class has two references of the CommandHandler delegate one for the DoCommand and the other is for the UndoCommand

Let's see how the Receiver class will look like,

class Receiver
{
    private int _state;

    public int State
    {
        get { return _state; }
        set { _state = value; }
    }
}

Actually it doesn't matter how it looks like, so the previous code is just a sample class.

Let's now see how the Invoker class will look like

class Invoker
{
    List<Command<Receiver>> _commands;

    public Invoker()
    {
        _commands = new List<Command<Receiver>>();
    }

    public void AddCommand(Command<Receiver> command)
    {
        _commands.Add(command);
    }

    public void RemoveCommand(Command<Receiver> command)
    {
        _commands.Remove(command);
    }

    public void CallCommands()
    {
        foreach (Command<Receiver> command in _commands)
        {
            command.Execute();
        }
    }

    public void UndoCommands()
    {
        foreach (Command<Receiver> command in _commands)
        {
            command.Undo();
        }
    }
}

The invoker is just a class that is interested in the Receiver objects and want to apply certain actions on instance(s) of the Receiver class, so it uses a list of Command<Receiver> to encapsulate the executing code.

Finally, we should see how the Client will use these classes.

class Program
{
    static void Main(string[] args)
    {
        Receiver recv1 = new Receiver();
        Receiver recv2 = new Receiver();
        Command<Receiver> command1 = new Command<Receiver>(new CommandHandle<Receiver>(Func1), new CommandHandle<Receiver>(UndoFunc1), recv1);
        Command<Receiver> command2 = new Command<Receiver>(new CommandHandle<Receiver>(Func2), recv2);
        Invoker invoker = new Invoker();
        invoker.AddCommand(command1);
        invoker.AddCommand(command2);
        invoker.CallCommands();
        invoker.UndoCommands();

    }

    static void Func1(Receiver recv1)
    {
        recv1.State ++;
        Console.WriteLine(recv1.State);
    }

    static void Func2(Receiver recv2)
    {
        recv2.State+=2;
    }

    static void UndoFunc1(Receiver recv)
    {
        recv.State--;
        Console.WriteLine(recv.State);
    }
}

So the main difference between the classic implementation and this one, that

We didn't define an interface and we juts used a generic delegate
We don't need to inherit from the interface every time we want to use the command pattern for different Receiver type, we replaced this with a generic Command class.

I hope you like it, I attached the previous code with the post
Have fun

Observer Pattern in C# = Events & delegates

2007-03-10T12:14:00Z

One of the most interesting patterns in Design Patterns is the Observer pattern which is listed under Behavioral Patterns, it is really important how to make other classes which are interested in the state of another object get notified when the state changed.

To read more about Observer pattern
This is the classic Observer pattern which used to be good with C++ and Java, however in C# you can implement the same idea using Delegates and Events which is really more concise and elegant way of writing this pattern

using System;
using System.Collections.Generic;
using System.Text;

namespace Patterns
{
    delegate void StateChangeHandler(State newState);

    enum State
    {
        State1, State2, State3
    }

    class Product
    {
        private State _state;

        public State MyState
        {
            get { return _state; }
            set
            {
                if (_state != value)
                {
                    _state = value;
                    Notify();
                }
            }
        }

        private void Notify()
        {
            if (_onChange != null)
                _onChange(_state);
        }

        private event StateChangeHandler _onChange;

        public event StateChangeHandler OnStateChange
        {
            add
            {
                _onChange += value;
            }
            remove
            {
                _onChange -= value;
            }
        }
    }
}

Take a look on the previous code, the Product class has an important piece of info called _state, and is encapsulated in the property MyState, this class expects that other classes may be interested in observing the changes in the MyState, so the class adds another member which is an Event (_onChange) of type StateChangeHandler delegate, and encapsulated in the Event Property called OnStateChange, and in the setter of the property MyState a small check is made to see whether the new value is different than the older value then the event gets fired.
A typical class which makes use of the Product class will look similar to this

using System;
using System.Collections.Generic;
using System.Text;

namespace Patterns
{
    class Program
    {
        static void Main(string[] args)
        {
            Product myProduct = new Product();
            myProduct.OnStateChange += new StateChangeHandler(myProduct_OnStateChange);
            myProduct.MyState = State.State3;
        }

        static void myProduct_OnStateChange(State newState)
        {
            Console.WriteLine("State changed to {0}", newState);
        }
    }
}

So now the Program class instantiates an object of type Product and registers itself in the OnStateChange event so whoever changes the MyState property of the object myProduct, the Program class gets notified.
I am not a Design Pattern Guru, however I think this implementation is more suitable for C# and makes use of the unique C# features that produces elegant code.

.Net & C# Interview question, along with general programming questions

2007-02-27T04:19:00Z

Hey, These are some Interview Questions with suggested answers we collected in Middle-East-Developers, for more questions in other fields like C++, you can check the group.
These questions are collected by

Adel Khalil
Yehia Megahed
Hisham Abd El-Hafez
Mohammed Hossam

Q1: Can DateTime variables be null?
A1: No, because it is a value type (Struct)

Q2: Describe the Asp.net Page Life Cycle?
A2: http://msdn2.microsoft.com/en-us/library/ms178472.aspx

Q3: Describe the Asp.net pipeline ? Give an Example when you need to extend it? How do you do so?
A3: http://msdn.microsoft.com/msdnmag/issues/02/09/HTTPPipelines/

Q4: Describe the accessibility modifier protected internal
A4: Members are accessible to derived classes and classes within the same Assembly

Q5: Difference between an interface and abstract class?
A5: In the interface all methods must be abstract, in the abstract class some methods can be concrete. In the interface no accessibility modifiers are allowed, which is ok in abstract classes.

Q6: How do you perform pre- and post-processing to extend a WebMethod ?
A6: Use SOAP extensions ...http://msdn.microsoft.com/msdnmag/issues/04/03/ASPColumn/

Q7: What are Design Patterns?
A7: It is a big topic in Object Oriented, so for more information see this, http://dofactory.com/Patterns/Patterns.aspx

Q8: What do you know about .net framework 3.0 ?
A8: any answer that introduces Windows Communication Foundation (WCF), Windows Workflow Foundation (WF), Windows Presentation Foundation (WPF) and Windows Card Space (WCS) is right, also you can mention that it was originally called WinFX

Q9: What do you know about ATLAS (Microsoft ASP.net AJAX Extensions) ?
A9: for more information check here, http://ajax.asp.net

Q10: What do you know about Agile software methodologies?
A10: http://en.wikipedia.org/wiki/Agile_software_development

Q11: What do you know about Web Services Enhancements (WSE)?
A11: http://msdn.microsoft.com/webservices/webservices/building/wse/default.aspx

Q12: What is AJAX ?
A12: Asynchronous Javascript And XML

Q13:What is NUnit, or What is Unit testing?
A13: Unit testing: is a procedure used to validate that a particular module of source code is working properly from each modification to the next. The procedure is to write test cases for all functions and methods so that whenever a change causes a regression, it can be quickly identified and fixed. Ideally, each test case is separate from the others; constructs such as mock objects can assist in separating unit tests. This type of testing is mostly done by the developers, NUnit is a famous tool for Unit Testing in .net

Q14: What is an Asp.net Http Handler & Http Module?
A14: http://www.15seconds.com/issue/020417.htm

Q15: What is mutable type ? immutable type ?
A15: Immutable type are types whose instance data, fields and properties, does not change after the instance is created. Most value types are immutable, but the mutable type are A type whose instance data, fields and properties, can be changed after the instance is created. Most Reference Types are mutable.

Q16: What is the HttpContext Object? Where is it accessible?
A16: It's is an Object that Encapsulates all HTTP-specific information about an individual HTTP request. it is avaliable through out the Asp.net request pipline.

Q17: What is the difference between String & StringBuilder classes?
A17: String is an immutable type while StringBuilder is a mutable type

Q18: What's the difference between C# 1.0 & C# 2.0?
A18: Any answer that introduces stuff like, Generics, Anonymous Methods, Nullable types, Iterators ... etc, is correct

Q19: Without using the multiplication or addition operations, how can you multiply a number x by 8?
A19: Shift x to the left 3 times, x << 3, because every shift left multiplies the number by 2

Q20: What is the difference between ASP.net 1.x & ASP.net 2.0 ?
A20: Any answer that include stuff like Provider model (membership provider, role provider ... etc) and Master Pages, Code Beside model, new web controls will be ok.

If you have more questions feel free to join the user group and add them directly to the database.

StructLayout attribute magic

2006-12-21T12:16:00Z

I've been reading for a while in the great CLR via C# second edition book, and here is one of the best things I've seen there,
When you declare a type, the CLR in runtime automatically rearrange the order of your type members for performance, so the access to these members are faster, and also trying to use minimum memory, stuff like making the variables reserves even memory locations for faster access and all these stuff, but you still have control on the CLR to force him follow the sequence you defined, and this helps especially in the interoperability with some C/C++ API's that accepts structs, so you have to stick with the structure layout, and in this case you have to add the StructLayout attribute to your class or struct like this

[StructLayout(LayoutKind.Sequential)]
struct Point
{
   int x;
   int y;
}

If you are declaring a struct type, the default Layout is Sequential, so you don't need to add the StructLayout.
However, developers add the attribute to struct when they want to mention that this struct is defined for interop with unmanaged stuff.

So where is the fun ?? I already know this
The fun comes here, the LayoutKind actually has three options which are

Auto (which is the default behavior)
Sequential
Explicit

The Explicit is how you can have full control of how the Struct members are stuffed in the main memory,
so you can declare the point like this

[StructLayout(LayoutKind.Explicit)]
struct Point
{
    [FieldOffset(0)]
    public int x;
    [FieldOffset(sizeof(int))]
    public int y;
}

So here I defined the struct member X to reserve the bytes starting from offset 0, then the member Y to reserve the bytes starting from offset 4 which is sizeof(int), so the Y will come immediately after X in memory, However you can play with the numbers like making them overlap together and get the garbage data we used to see in C :).
and as long as we are considering overlapping so we can define something like the old C Union data structure, which we can define a data structure that will contain multiple definitions of variables types and the memory that will be reserved is the memory required to store the largest type. for more information about C/C++ Union
So all what you need here, is setting all the variables' offsets declared in the struct to 0, so all of them occupy the same locations in memory, and the memory reserved for them all is the memory for the largest one, and you are only allowed to use ONLY ONE of them, if you tried assigning values to more than one member, this will lead to unexpected behavior and results, so consider this

[StructLayout(LayoutKind.Explicit)]
struct UnionLike
{
    [FieldOffset(0)]
    public int iValue;
    [FieldOffset(0)]
    public int lValue;
    [FieldOffset(0)]
    public double dValue; 
}

and this will lead to this memory organization (conceptually)

So the whole UnionLike type reserves 8 bytes in memory which is the size of the largest member (in this case dValue)

This was amazing to me when I first saw it, and I think it worths a try from you.

Parallel Event Handling in Windows Workflow

2006-10-02T11:18:00Z

I've been using Windows Work Flow (WF) for a while, and I faced a lot of problems that I could solve, and this article is about one of them,
I am working on a project that faced the situation which I need to raise the same event to more than one HandleExternalEventActivity activities working in parallel, and I wanted just one of the HandleExternalEventActivity's to handle the coming event according to an identifier that I'm going to send with the EventArgs.
The problem comes, that by default, if you have a ParallelActivity and inside each branch you have a HandleExternalEventActivity activity, when you raise the event from the host, you can't control which HandleExternalEventActivity gets the event, so the most left HandleExternalEventActivity gets and handles the event before the other even if I wasn't targeting it in the first place.
So how to solve this,
after some searching and reading some working or sometimes old & not-working samples, I found out something called Correlation.
so as I could understand, Correlation is how you specify a parameter in the ExternalDataExchange that is going to identify who is going to handle the Event, and only the HandleExternalEventActivity that has the same parameter in its CorrelationToken will handle the event.
so it first sounds like a big blah blah blah blah.
but after some trials I managed to write some steps of how you do that.
1- Write your custom ExternalDataEventArgs by inheriting from ExternalDataEventArgs

[Serializable]
internal class TaskEventArgs : ExternalDataEventArgs
{
private string _identifier;

public string Id
{
get { return _identifier; }
set { _identifier = value; }
}

public TaskEventArgs(Guid instanceId): base(instanceId)
{

}
}

2- Write your ExternalDataExchange interface like this

[ExternalDataExchange]
[CorrelationParameter("Identifier")]
internal interface IService
{
[CorrelationInitializer]
void Initialize(string Identifier);

[CorrelationAlias("Identifier", "e.Id")]
event EventHandler<TaskEventArgs> TaskFinished;
}

as you can see, we used three different Attributes
CorrelationParameter: this is where you specify the name of the parameter that will hold the value that Identifies the event destination
CorrelationInitializer: this is where you are going to specify the correlation parameter value, the CorrelationParameter should be a parameter to this method, and take care to write it exactly as you wrote it in the CorrelationParameter attribute with the same casing.
CorrelationAlias: this is where you specify the location of the parameter in the event arguments, because as we said before, the event argument will hold the destination identifier.

3- Implement the IService Interface

internal class Service:IService
{
   #region IService Members

   public void Initialize(string Identifier)
   {
       // Actually you don't need to do anything here;
   }

   public event EventHandler<TaskEventArgs> TaskFinished;

   #endregion

   public void RaiseEvent(Guid instanceId, string identifier)
   {
       //initializing the TaskEventArgs.
       TaskEventArgs args = new TaskEventArgs(instanceId);
       args.Id = identifier; // setting the specified identifier to the Id property in the TaskEventArgs.
       if (TaskFinished != null)
          TaskFinished(null, args);   // Firing the event
   }

}

4- Now go to your Workflow designer, and add in every Parallel branch a CallExternalMethodActivity before the HandleExternalEventActivity you already have.
your workflow should look similar to this

as you can see in every branch you have a CallExternalMethodActivity, and HandelExternalEventActivity.
forget about the other two code activities right now.
5- Now configure the first CallExternalMethodActivity, in our case InitializeFirst
5.1 set the interface type to your ExternalDataExchange interface, in our case the IService interface
5.2 set the Method Name to the method that has the CorrelationInitializer attribute, in our case the Initialized Method in IService.
5.3 now you will notice that you have another option in the properties of the CallExternalMethodActivities called CorrelationToken, write a name inside this box "C1" for example and then expand the node by clicking on the + sign beside the CorrelationToken text and set the OwnerActivityName property with the name of Activity that holds the CallExternalMethodActivity, in our case it is sequenceActivity1.
5.4 also you will find the parameter of the Method you are calling shown in the property grid, in our case it is Identifier, set it to the identifier value you want, or bind it to a member of property, in our case we will bind it to the string "First"
5.4 repeat the same settings for the second CallExternalMethodActivity, in our case InitializeSecond but use different name for the CorrelationToken "C2" with OwnerActivityName to sequenceActivity2
the property grid should look similar to this

6- Configure the HandleExternalEventActivity, in our case HandleFirst
6.1 Choose the interface type as same as the one in the CallExternalMethod, in our case IService interface
6.2 Choose the Event Name, in our case TaskFinished
6.3 You will find a property CorrelationToken appeared, choose "C1" from the list you have
6.4 Repeat this settings for all other HandleExternalEventActivities you have, in our case HandleSecond but use the C2 CorrelationToken for this one.
The Property Grid of the HandleExternalEventActivity should look similar to this

7 now you are almost done, just go to the workflow creation code, usually in the Program.cs file and add an ExternalDataExchangeService to the runtime and add an instance of the IService service to it like this

ExternalDataExchangeService exchange = new ExternalDataExchangeService();
workflowRuntime.AddService(exchange);
Service service = new Service();
exchange.AddService(service);

Then after you start the instance and the runtime, you can start raising the event by using (in our case) RaiseEvent function and specify the Identifier you are targeting as a parameter to the function like this

service.RaiseEvent(instance.InstanceId, "First");

also for a complete example, I attached the complete version of the last code with this blog post. with enough documentation in the code.
Have fun coding.

C# 3.0 Lambda Expressions and Expression Trees

2006-06-12T11:19:00Z

From the first days of C# 1.0 we could do stuff like this

public static int Add(int x, int y)
{
   return x + y;
}

and also C# gives you the ability to write the function signature in the form of delegate, that allows function pointers so you can do something like this

delegate int MathOperation(int x, int y);


public static int ApplyFunction(int x, int y, MathOperation operation)
{
   return operation(x, y);
}

public static int Add(int x, int y)
{
   return x + y;
}

public static void Main()
{
   int result = ApplyOperation(1, 3, new MathOperation(Add));
   Console.WriteLine(result);
}

and so this gives the ability to apply any other function you want as long as you provide a function that has the same signature...

Then in C# 2.0 we were introduced to Anonymous methods, which gives you a faster way of writing functions in case that these functions are going to be used only one time
like this

delegate int MathOperation(int x, int y);

public static void Main()
{
   MathOperation op = new MathOperation(delegate(int x, int y)
                        {
                            return x + y;
                        });
   Console.WriteLine(op(10, 5));
}

So, this syntax is very much faster in writing delegate functions that will be used only one time.
and also, this syntax allows the new function to access the local variables in the outer scope of it, which means in the last method if the Main has a variable called myVar, the new delegate function op can access this myVar without passing it to the function.

Now after we see the case of C# 1.0, 1.1 and 2.0. Let's see what C# 3.0 says about this..
C# 3.0 introduces Lambda Expressions and Expression Trees,
lamdba expressions gives a very fast way to define delegates like in dynamic languages (e.g. Python)
so as an example .

delegate int MathOperation(int x, int y);

public static void Main()
{
   MathOperation op = (i, j) => i + j;
   Console.WriteLine(op(1,2));

}

so it is really easy to define functions using lamdba expressions, first put all the function parameters comma separated then => then the expression that evaluates the result.

Also because C# gives you a predefined delegate called Func that can be used for most cases of function delegates because it is a generic delegate in this form

delegate T Func<A, T>(A param)
or
delegate T Func<A0, A1, T>(A0 param0, A1 param1)
or
delegate T Func<A0, A1, A2, T>(A0 param0, A1 param1, A2 param2)
or
delegate T Func<A0, A1, A2, A3, T>(A0 param0, A1 param1, A2 param2, A3 param3)

So you can define any lambda expression without writing the delegate just using this one like this, lambda expression that checks for even number

Func<int, bool> isEven = i => (i&1) == 0

so from the Func definition in this case, it takes an integer parameter and returns bool result

Also C# introduces Expression trees, that you can build a new expression and compile it and use it in runtime
so we can rewrite the Add function using the expression trees and it will look like this

ParameterExpression p0 = Expression.Parameter(typeof(int), "x");
ParameterExpression p1 = Expression.Parameter(typeof(int), "y");

Expression<Func<int, int, int>> addExpr= Expression.Lambda<Func<int, int, int>>(
                       Expression.Add(p0, p1), new ParameterExpression[]{p0, p1});
Console.WriteLine(addExpr.Compile()(1,2));

If you used Lisp before you'll be familiar with this code, because you first put the operation then put the parameters so a simple addition will looke like this
+ x y
and that what you get if you printed out the addExpr.Body
Add(x, y)
If you noticed the expression tree we built for simple addition, you will find it relatively long, but the good news that the compiler can do this for me, all what I need to do is assigning the Lambda expression to the Expression<> object like this

Expression<Func<int, int, int>> lambdaAdd = (i, j) => i + j;

and this will give the same result as writing the long epxression by hand.
All these stuff are the backbone of LINQ project and the great enhancements, like using sql-like syntax on collections like this

var list = new List<int>();
for(var i =0; i<100; i++)
   list.Add(i);
var q = list.Select(i=>i).Where(i=> i>10 && i<20);
foreach(var i in q)
   Console.WriteLine(i);

in this code we can get the numbers between 10 & 20 in the list that contains numbers from 0 ~ 99, and in this code we are using the Lambda expressions in the Sequence extension methods.
also the same query

var q = list.Select(i=>i).Where(i=> i>10 && i<20);

can be replaced with

var q = from i in list where i > 10 & i <20 select i;

and this how LINQ was built in the first place, it is all matter of expressions

How to increase application scalability using Plugins

2006-05-17T11:20:00Z

This time I will talk about how to implement a plugin module that loads and runs plugins in your application.
but first why do we need such thing?
In so many cases, you need to provide a way that enables someone else to write a piece of code that can be loaded in your application in runtime and runs in the same context of your application without the need to stop the base application and change your code and redeploy.
These cases regularily happen when you software that it is very hard to shutdown every time you want to extend its functionality (e.g.Windows Services..)

Things you should put in mind before implementing such system

Plugin should be easy to implement,
This can be done by providing enough documentation, and providing a flexible model for implementing plugins
The system must be able to

Load plugins during runtime
Unload unused (or stopped plugins)
Detect plugin crashes and unload crashed plugins without crashing the whole system
Run multiple plugins at the same time
Detect new plugins and run them.

Plugins shouldn't be locked to make it easier to update the plugins without closing the application

So lets discuss every point in more details

1- Plugin should be easy to implement
You should decide how developers are going to implement plugins in your system, and how you can specify mandatory specifications that are logical, acceptable and also easy to be done by the developers
There are many approaches to do so

Implementing Specific Intrfaces
Using Attributes & Reflection
Using XML configuration files and Reflection

The most common used technique is the first one, that the system developer (The one develops the main system) will provide an inteface for the plugin class like this

interface Pluggable
{
     string PluginTitle{get;}
     void Init();
     void Start();
}

and every plugin will implement the interface

What's good about this

Some how it is simple for the plugin developer
Makes the pluggable classes looks the same from the system point of view...
If you want to get a return value from the methods, this is the only way to inforce the method signature

What's bad about this

Interfaces are not that flexible, because you have to implement functions even that you may not use

Using Attributes is more flexible because you can specify some attrbitues like Pluggable for classes and Runnable for functions like this

namespace PluginModule
{
    [AttributeUsage(AttributeTargets.Class)]
    public class PluggableAttribute : Attribute
    {
    }

    [AttributeUsage(AttributeTargets.Method)]
    public class RunnableAttribute : Attribute
    {
    }
}

and then you just need to add the suitable attribute before the declaration of the class or function
like this

namespace TestPlugin
{
    [Pluggable]
    public class TestPlug 
    {
        [Runnable]
        public void SayHello()
        {
            Console.WriteLine("First Plugin");
        }
    }
}

I prefer this way... for these reasons

It is very much cleaner, you don't need to implement a certain interface
You can have as much runnable functions as you want in the same class

The third wy to define a plugin is using config files, that you write the plugin class name and every method in every class in a configuration files, then use reflection to load and run these functions
the bad things about this technique

The programmer should write a config file for every plugin,
Spelling mistakes in configuration files will make some bugs like function and modules not found

2- Loading plugin in runtime
Now we get to the important part, How are we going to load the plugins...
we have two ways for this

Loading the plugin in the same appdomain of the main application
Loading the plugin in a separate appdomain

So, what is the difference between the two ways.
Ofcource the first one is simple you will load the assembly (dll, or exe) plugin using either Assembly.Load() or AppDomain.CurrentDomain.Load() and once the assembly is loaded you can get all the Types (classes) defined in it and execute them,
But, you will have some drawbacks like

You can't Unload assemblies from the domain, without shutting down the whole application, because neither Assembly class nor AppDomain class has a function UnloadAssembly, and this has a very good reason that maybe there are other loaded assemblies depend on this Assembly and this will make a very big problem.
You can't write separate App.config (*.dll.config, *.exe.config) file for each plugin and load with the assembly
In cases of fatal errors and crashes, it is very possible that the whole application will crash.
You can't limit the security level of the plugins lower that the level of your application
Dll files will be locked so you can't overrite the files unless you shutdown the whole application

You can still use this technique if you don't care about these problems...

But what about Loading in a different domain...
Well, it is the best way to do it, because all the above problems are solved in this technique, but it is more complicated and will involve some extra work in Remoting, because this is the only way I found to istantiate and execute an object in different domain..

First you need to create a new domain and setup this domain

private AppDomain CreateAppDomain(string domainName, string fileName, string configFileName)
        {
            AppDomainSetup setup = new AppDomainSetup();
            setup.ApplicationBase = AppDomain.CurrentDomain.BaseDirectory;
            setup.ApplicationName = Path.GetFileName(fileName);
            setup.ShadowCopyDirectories = Path.GetDirectoryName(fileName);
            setup.CachePath = AppDomain.CurrentDomain.BaseDirectory;
            setup.PrivateBinPath = Path.GetDirectoryName(fileName);
            setup.ShadowCopyFiles = "true";
            setup.ConfigurationFile = configFileName;
            AppDomain domain = AppDomain.CreateDomain(domainName, AppDomain.CurrentDomain.Evidence, setup);
            return domain;
        }

As you see from this small function, first it creates an AppDomainSetup object that will store all the configuration
then it sets the ApplicationBase directory for the new appdomain as same as the main application and this helps to reduce the number of external dll's needed by the plugins (Dependencies) because if the main application uses them so they can share them.
and sets an application name, here we set the application name as same as the dll file name.
then we Shadow copy the files and directories and this makes the files free to be removed or replaced during runtime (the file locking problem)
then we set the config file(*.dll.config, *.exe.config) name (if any)
then we create the appdomain using the setup information and using the same security eveidance of the base application (This can be changed to limit the security level if needed)

We are now ready to load the plugin, next we are going to reflect the plugin and get all the Pluggable classes and for every Pluggable class get all Runnable functions
First this module will get all the pluggable classes from the assembly


        private Type[] GetModules(string filename, AppDomain domain)
        {
            Assembly assembly = domain.Load(filename);
            List<Type> plugins = new List<Type>();
            Type[] types = assembly.GetTypes();
            foreach (Type type in types)
            {
                if (type.GetCustomAttributes(typeof(PluggableAttribute), false).Length > 0)
                {
                        plugins.Add(type);
                }
            }
            return plugins.ToArray();
        }

Then we need the module that gets all the Runnable functions from the Pluggable types and run them

private void RunTypes(Type[] types)
        {
            foreach (Type type in types)
            {
                Object obj = type.InvokeMember(null, BindingFlags.CreateInstance, null, null, null);
                foreach (MethodInfo method in type.GetMethods())
                {
                    //instanciating object from the type specified
                    if (method.GetCustomAttributes(typeof(RunnableAttribute), false).Length > 0)
                    {
                        //running the runnable function
                        method.Invoke(obj, null);
                    }
                }
            }
        }

so now we have everything we need to create a plugin manager class that does these things

Load the Dll
Reflect all the pluggable types
Reflect all the Runnable methods
Instantiating objects from Runnable classes
Run the methods

But, Are we finished ???
No, we still have something missing, we didn't create the class that will be responsible of creating the plugin manager class in separate domain !!!!
Yes, it sounds strange but let's discuss this...
We said that using remoting is the only way (I found) to load dll's in a separate domain, which means that we need a MarshalByRefObject class that handle the plugin, so first we need to put all the methods we made in one class the inherits from MarshalByRefObject, so we can instantiate object from it using remoting...
and this how the PluginManager class will look like

class PluginManager : MarshalByRefObject
{
     private Type[] GetModules(string filename, AppDomain domain)
        {
            Assembly assembly = domain.Load(filename);
            List<Type> plugins = new List<Type>();
            Type[] types = assembly.GetTypes();
            foreach (Type type in types)
            {
                if (type.GetCustomAttributes(typeof(PluggableAttribute), false).Length > 0)
                {
                        plugins.Add(type);
                }
            }
            return plugins.ToArray();
        }

private void RunTypes(Type[] types)
        {
            foreach (Type type in types)
            {
                Object obj = type.InvokeMember(null, BindingFlags.CreateInstance, null, null, null);
                foreach (MethodInfo method in type.GetMethods())
                {
                    //instanciating object from the type specified
                    if (method.GetCustomAttributes(typeof(RunnableAttribute), false).Length > 0)
                    {
                        //running the runnable function
                        method.Invoke(obj, null);
                    }
                }
            }
        }
public void RunMethods(string fileName, AppDomain domain)
        {
            RunTypes(this.GetModules(filename, domain));
        }
}

then we create another class (let's call it PluginLoader) which is responsible of creating a plugin manager object using remoting, so the code will be something like this

public static class PluginLoader
{
        public static void Run(string filename, AppDomain domain)
        {
                //Creating an object of PluginManager using remoting
                PluginManager plugin = appdomain.CreateInstanceAndUnwrap(AssemblyName.GetAssemblyName(Path.Combine(AppDomain.CurrentDomain.BaseDirectory,
                "PluginModule.dll")).FullName, typeof(PluginManager).FullName) as PluginManager;
                domain.AssemblyResolve += new ResolveEventHandler(Domain_AssemblyResolve);
                plugin.RunMethods(fileName, domain);
        }

        static Assembly Domain_AssemblyResolve(object sender, ResolveEventArgs args)
        {
            AppDomain domain = sender as AppDomain;
            string pluginFolder = domain.RelativeSearchPath;
            string path = Path.Combine(pluginFolder, args.Name.Split(',')[0] + ".dll");
            return domain.Load(AssemblyName.GetAssemblyName(path));
        }
}

so as you see the PluginLoader class has one public static method called Run, that takes the filename and the target appdomain, and it creates an object of type PluginManager in the appdomain and runs the functions inside its appdomain...
final thing, sometime the plugins dll's have some dependencies, and this is what the AssemblyResolve event does, so we added an event handler that takes care of this, becausewhen a dll needs a dependency dll, the system will first look in the GAC, then look inside the Application Bin, and if both of the actions failed, it will fire this event to the programmer to provide the missing dll and that what we do,

Finally, I hope that you find what you were looking for in this post, and if you need more help you can contact me and I'll be glad to help you.
Regards

Updated, Sample solution is attached