Huthaifa Afanah : ASP.NET

In Hebron “Introduction to VS2008 & ASP.NET” session

IsToFix — Thu, 10 Sep 2009 09:03:13 GMT

As part of PalDev activities I was in Hebron this Saturday to deliver a “Introduction to VS2008 & ASP.NET” session for the PPU –Palestine Polytechnic University – CS and IT students. The workshop was held in Friends of Fawzi Kawash IT Center of Excellence...(read more)

The Gu is Back!! with new Multilingual version!!

IsToFix — Thu, 27 Aug 2009 07:58:17 GMT

Yesterday I checked my RSS feed and found that Scott Guthrie announced that he is starting a new series of posts . That was a great news to hear. Scott is one of the most popular Microsoft managers. He is one of those who played a core role developing...(read more)

ASP.NET MVC 1.0 has been released

IsToFix — Thu, 02 Apr 2009 03:51:45 GMT

Hello The Gu - Scott Guthrie - has announced the ASP.NET MVC 1.0. You can read the full post here. The amazing thing that ASP.NET MVC is an open source project and the code released under MS-PL licenses. And they say Microsoft does not support open source...(read more)

ASP.NET site crashed today!!

IsToFix — Sun, 26 Oct 2008 09:01:00 GMT

Today while I am navigating through the Internet I visited the http://weblogs.asp.net as usual. Then I moved to the asp.net site and surprise the ASP.Net site seems to have some problems. This problem seems to be solved very fast but I catch it. Notice the date and time below the image

Anyway it's not matter, but I make this post to ensure that even the most reliable and well managed web applications and websites may face problems some times.

Have a nice day

Embedded Resources difference between VB.NET and C# projects

IsToFix — Tue, 21 Oct 2008 13:00:00 GMT

While I am developing a custom web control to extend the default validation summary I used some images within this control. One of the nice features and solutions came with ASP.NET 2.0 to address this problem is using web resources. So I embedded these images in my custom control assembly and used the Page.ClientScript.GetWebResourceUrl to resolve their URL's.

To do this task correctly you need to do 2 simple steps:

First, you need to select whatever file you want to embed in your assembly and then set the Build Action property from its properties to Embed this is straight forward as saying 1, 2, 3.
The second this we need to do is referencing that embedded resource so it could be retrieved as a web resources.This could be accomplished by adding WebResource attributes in the Assembly.info file.

In general to do this all we need is to add the web resource attribute like
<Assembly: System.Web.UI.WebResource("EmbeddedResourcesVB.Sunset.jpg", "image/jpg")> the WebResource takes two parameters, the first one is the resource full name which following this convention: (Rootnamespace).(SubNameSapce).(Filename).(Extension) and the second parameter is the MIEM file type of the resource

So what's wrong?

This looks very simple but why all problems occurred? What is the error prone thing which make all these posts and articles on the web!! To identify this we can say there is some issue regarding the way that VB.NET projects and C# projects being organized. Is that true? Yes that's true!!

To figure out this issue I created simple solution conations a VB.NET project and a C# project. and add an image to each of them as our embedded resource. I changed the Root Namespace property for each project to make it clear that the assembly name has nothing to do with WebResource name. By default the Root Namespace == assembly name but in some certain scenarios you need to change that so by choosing the project properties you can change the assembly name property and the RootNamespace property.

After building our solution let's have a closer look to the embedded resources after being compiled into assembly. So let's open EmbResVB.dll and EmbResCSharp.dll using Reflector. If you take a quick look to the image below you can note that the Sunset.jpg image resource name differs from the Vb.Net assembly to the C# one.

But we said that the resource name should follow this convention: (RootNameSpace).(SubNameSapce).(Filename).(Extension) so what's happens??!!
Here's what happen: in the C# projects if you add a new class to your solution you will find that the IDE put's this file in a namespace regarding to the solution folders hierarchy. But in VB.NET projects this is not occur. Let's take the ImagesUrl class as example, this class which exists's under the images folder in our testing C# and VB.NET projects but it will look like this by default in C#:

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

namespace EmbeddedResourcesCSharp.Images
{
public class ImagesURL
{

}
}

while in the VB.NET project it will be added to the root namespace by default:

Public Class ImagesUrl

Sub New()

Technorati Tags: asp.net,embbede resources,.Net

End Sub

End Class

C# is doing this because of the VC# wizards which work in the background when you add new items to your project. Here's an article for one of the VS team descriping this issue http://blogs.msdn.com/joen/archive/2004/03/15/90002.aspx.

Anyway it seems that C# IDE is handling the other files like our image in the same way. So our Sunset.jpg image have been listed under the images namespace which actually it's parent folder name. But in the VB.NET project Sunset.jpg is being added to the root namespace never mind in any sub folder it exists.

Ok, that's it, the reason of all the misunderstanding. Many VB.NET developers reading posts or articles about embedded resources written in C# and they didn't notice the different in embedded resources names between the VB.NET and C# projects.

The result

In a C# project embedded resources names follows this convention (RootNampeSpace).(Path).(FileName).(Extension) where Path is the folders path in which this resource exist Root/Folder/SubFolder/.../ResourceFile .In A VB.NET project embedded resources names follows this convention (RootNampeSpace).(FileName).(Extension) and the resource path does not affect its name.

Hope that help. Happy asp.net

Huthaifa

Implementing observer pattern

IsToFix — Thu, 31 Jan 2008 15:06:00 GMT

Introduction:

While I was developing a new web application in our company I found that every entity in the system has some shared fields which holds data about when and who saved this entity into the system. Basically those fields were CreationDate, CreatedBy, LastModificationDate, LastModificationBy and EntityId for sure.

There are multiple approaches to solve this situation:

1. In every user control include these fields and reflect data to them directly: but this will force you to write more duplicated code. And this will make update and maintenance more complicated and error frequent process. Imagine that you have 10 controls this means you need to do 10 updates if any update is needed in the entity details.

2. Create a user control called details and place those fields in it and access those fields directly from each entity screen: although this will ease maintenance and updates this approach has a disadvantage which that those controls are now tightly coupled.

Applications with tightly coupled classes tend to be brittle and difficult to maintain, because changes in one class could affect all the tightly coupled classes.

The problem: How can user controls -objects- notify other controls –objects- of state changes without being dependent on their classes?

3. Using observer pattern and create loosely coupled controls to communicate between each other without depending in their classes.

In this article I will show how to a build simple user control that implements observer pattern to handle updates and passing notifications around to update a set of objects when some important event has occurred.

Background:

The observer pattern is categorized under Behavioral Patterns. Behavioral Patterns is those patterns are concerned with algorithms and the assignment of responsibilities between objects. Behavioral patterns describe not just patterns of objects or classes but also the patterns of communication between them.

So what is observer pattern?

Observer design pattern should “Define a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.”

What is Subject? What is observer?

Subject: is the object which wills frequently changes his state from time to time. And there is another objects depends on it.

Observer: is the object which depends on a subject keep eye on updates at his subject state.

Here’s how it works:

An observer signs up to receive notifications of changes to the subject.

A second observer can register itself too. In fact a subject may have any number of dependent observers. Observers are not aware of presence of each other.

When certain event occurred all observers are notified.

An observer can unregister itself from subject so he will never receive notifications from subject.

With this generic way of communicating between the subject and observers, collaborations can be built dynamically instead of statically. The code is now much more separate, and thus easier to maintain and reuse. There is no direct dependency between subject class and observer class.

In our example Address_UC is a ConcreteSubject and RecordDetails_UC is one of it ConcreteObservers, so when the domain object associated with Address_UC class has changed the RecordDetails_UC class will be notified and handles this event in a proper way. I will show how explicitly implement observer pattern and another time by using delegates and events.

Implementing Subject class:

You can implement Subject class as super class or abstract class. But due the limitation in some languages like C#,VB.Net that class can inherits only one. This will cause a problem because most of domain objects are inherits from domain objects. So our subject class will be implemented using interface. Remember that class can implement many interfaces.

public interface ISubject 
{ 
List<IObserver> ObserversList {get;} 
void AttachObserver(IObserver observer); 
void DeAttachObserver(IObserver observer); 
void NotifyObservers(); 
}

Basically our Subject interface contains methods to attach, deattach and notify observers. And each ConcreteSubject class – means class that implement the subject interface - should define a list of ConcreteObservers.

Implementing observer class:

public interface IObserver

{

void Updateobject(ISubject subject);

}

The observer class is very simple and contains a method that allowed subjects to notify it.

All we need know is to implement ISubject methods in our ConcreteSubject “Address_UC” as simple as this:

#region ISubject Members 
public List<ObserverTutorial.App_Code.IObserver> ObserversList 
{ 
get { return this.m_ObserversList; } 
} 
public void AttachObserver(ObserverTutorial.App_Code.IObserver observer) 
{ 
this.ObserversList.Add(observer); 
} 
public void DeAttachObserver(ObserverTutorial.App_Code.IObserver observer) 
{ 
this.ObserversList.Remove(observer); 
} 
public void NotifyObservers() 
{ 
foreach (App_Code.IObserver observer in this.ObserversList ) 
{ 
observer.Updateobject(this); 
} 
} 
#endregion

Note that NotifyObservers method will be called form another method in the Address_UC when an certain event occur something like after user save domain object data:

protected void btnOk_Click(object sender, EventArgs e) 
{ 
bool result = SaveEntityData(); 
/// After Subject object data is saved in a state notify observers 
if (result) 
{ 
this.NotifyObservers(); 
} 
}

In the ConcreteObserver “RecordDetails_UC” the implementation of the IObserver lonely method Updateobject allow Address_UC to notify RecordDetails_UC that it has changed and passing itself as parameter so RecordDetails_UC can update his state too in a proper way. But firstly RecordDetails_UC needs to register itself with Address_UC:

ISubject Subject = this.Parent as ISubject; 
if (Subject != null) 
{ 
Subject.AttachObserver(this); 
}

Are we smarter than Microsoft so they does not have observer pattern implemented yet?

Microsoft .NET Framework defines the notion of delegates and events to accomplish the Observer role. Therefore, you would rarely implement the Observer pattern explicitly in .NET, but should use delegates and events instead. I attached implementation of this sample using delegates and events too.

You can download the tutorial file from the attachments here ...