Windows And Web Development

Convert XmlText to HtmlText

2011-11-10T15:18:00.001+01:00

I have been using Xml streams for quite some time. When I use them in an ASP.Net page, using SOAP or Ajax calls, I sometimes want to see what I send and what I recieve from the server. Showing them on the page was always a bit of tweak. This ample code demonstrates a very simple tweek. It provides a label that can show the xml Text (as its content or Text property) on the page, by rendering the simpel characters.

When the control is compiled I can use it as one of the two ways:

<panahyAjax:XmlLabel runat="server" ID="xmlLabel">
<this>
<is just="one">sample</is>
</this>
</panahyAjax:XmlLabel>
Or

XmlLabel label = new XmlLabel();
var file = File.OpenText("Sample.xml");
label.Text = file.ReadToEnd();

And the code is as folllows:

public class XmlLabel : Label
{
public static string ConvertXmlTextToHtmlText(string inputText)
{
  // Replace all start and end tags.
  string startPattern = @"<([^>]+)>";
  var regEx = new Regex(startPattern);
  string outputText = regEx.Replace(inputText, "<<b>$1></b>");
  outputText = outputText.Replace(" ", " ");
  outputText = outputText.Replace("\r\n", "<br />");
  return outputText;
}
protected override void RenderContents(HtmlTextWriter output)
{
string xmlText = XmlLabel.ConvertXmlTextToHtmlText(Text);
output.Write(xmlText);
}
}

Using RenderControl method to generate Html

2011-11-10T14:21:00.003+01:00

This article demonstrates how to generate perfect HTML using the RenderControl method of server controls. The Html code is generated without makeing any server-side state or view state.
/// <summary>
/// This method demonstrates how to show Html output of a Server Control
/// </summary>
private void ShowHtml()
{
// Create the in-memory objects that will catch the rendered output.
StringWriter writer = new StringWriter();
HtmlTextWriter output = new HtmlTextWriter(writer);

// Render the control to an in-memory string.
var control = new HyperLink();
control.NavigateUrl = @"http:\\asghar.panahy.com";
control.Text = "Asghar Panahy";
control.Target = "_blank";
control.ToolTip = "Demostration";

control.RenderControl(output);

// Display the HTML (and encode it properly so that
// it appears as text in the browser).
lblHtml.Text = "The HTML for LinkWebControl1 is<br /><blockquote>"
+ Server.HtmlEncode(writer.ToString()) + "</blockquote>";
}
The output of this codewill be reading what you would ecpect in the Html code behind.
Notice that skipping the Server.HtmlEncode call will put the generated html as a link into the page.

Encapsulating an AJAX client control into a custom server control (Part 3)

2011-11-08T13:30:00.003+01:00

The previous article was a step forward but it is still far from reusing as a server side control. What we will do in this part will make us possible to have a custom textbox control that makes al it takes to have this client-side functionality and we will be able to drag the ASP.NET control into our page.

To start with, we need a new server-side control library project that will compile as a dll and contains the server side code and embeds the client-side script. This project will have two files in it: the PassTextBox.cs which deals with the server-side TextBox and inherits from TextBox and implements the IScriptControl which makes it possible to embed the script code.

Notice in the code that the class needs to register the script with the ScriptManager which is accessible through its static method GetCurrent(Page). This is done in OnPreRender method.

In the previous article we had the css class names inside the javascript. In this example we will assign them through the controls properties. The GetScriptDescriptor method allows us to prototype our class where we define these properties.

namespace Panahy.Ajax
{
public class PassTextBox : TextBox, IScriptControl
{
private ScriptManager sMgr;
public string WeakCssClass;
public string MediumCssClass;
public string StrongCssClass;
protected virtual IEnumerable<ScriptDescriptor> GetScriptDescriptors()
{
ScriptControlDescriptor descriptor =
    new ScriptControlDescriptor("Panahy.Ajax.PassTextBox", this.ClientID);

descriptor.AddProperty("weakCssClass", this.WeakCssClass);
descriptor.AddProperty("mediumCssClass", this.MediumCssClass);
descriptor.AddProperty("strongCssClass", this.StrongCssClass);
return new ScriptDescriptor[] { descriptor };
}
protected virtual IEnumerable<ScriptReference> GetScriptReferences()
{
ScriptReference reference = new ScriptReference();

reference.Assembly = "Panahy.Ajax";
reference.Name = "Panahy.Ajax.PassTextBox.js";
return new ScriptReference[] { reference };
}
protected override void OnPreRender(EventArgs e)
{
if (!this.DesignMode)
{
    //test for the existence of a ScriptManager
    sMgr = ScriptManager.GetCurrent(Page);

    if (sMgr == null)
       throw new HttpException("A ScriptManager control must exist on the page.");
    sMgr.RegisterScriptControl(this);
}
base.OnPreRender(e);
}
protected override void Render(HtmlTextWriter writer)
{
if (!this.DesignMode)
    sMgr.RegisterScriptDescriptors(this);
base.Render(writer);
}
IEnumerable<ScriptReference> IScriptControl.GetScriptReferences()
{
return GetScriptReferences();
}
IEnumerable<ScriptDescriptor> IScriptControl.GetScriptDescriptors()
{
return GetScriptDescriptors();
}
}
}

The javascript file remains as before.
Now we can reuse the control in any project that refers to the dll.

<%@ Register Assembly="Panahy.Ajax" Namespace="Panahy.Ajax" TagPrefix="panahyAjax" %>

<panahyAjax:PassTextBox ID="textbox1" runat="server" width="200"
TextMode="Password" WeakCssClass="weak" MediumCssClass="medium"
StrongCssClass="strong"></panahyAjax:PassTextBox>

Although this sample can be handy to use as a template for other server controls, the introduced functionality could be done by creating an AJAX Behavior for client controls, which is the topic for the next article.

Implementing Custom Classes for Microsoft AJAX Library (Part 2)

2011-11-08T11:22:00.003+01:00

The previous article is demonstrates the use of custom class but it makes some assumption which is not best practice for developping pages.

In this article I will try to make this one step forward by taking the class names (that were hard coded in the javascript) out of the script and assign them in the page. I will also provide a initialization to assign the same functionality to any page element.

We start with the construction and pass the element that is using the class:

Panahy.Ajax.PassTextBox = function(element) {
    Panahy.Ajax.PassTextBox.initializeBase(this, [element]);

    // initialize internal variables
    this._weakCssClass = null;
    this._mediumCssClass = null;
    this._strongCssClass = null;
}

Next, I call the passwordStrengthClass method in a new event handler called _onKeyup which I will apply the css class to the element using get_element():

//define key press event
_onKeyup : function(e) {
    //get password text
    var pass = this.get_element().value;
    var strength = this.returnPasswordStrength(pass);
    switch (strength) {
      case "Weak":
         this.get_element().className = this._weakCssClass;
         break;
      case "Medium":
         this.get_element().className = this._mediumCssClass;
         break;
      case "Strong":
         this.get_element().className = this._strongCssClass;
         break;
    }
},

Now, I need to tell the AJAX Library to assign the _onKeyup method to keyup event of the element. To do this, I create a delegate and add the handler as follows:

//initialize the UI control
initialize: function() {
   Panahy.Ajax.PassTextBox.callBaseMethod(this, 'initialize');

   this._onKeyupHandler = Function.createDelegate(this, this._onKeyup);
   $addHandlers(this.get_element(), {'keyup' : this._onKeyup}, this);
},

By doing this, I have to remove the reference when cleaning up the things in the dispose method:

dispose: function() {
$clearHandlers(this.get_element());
Panahy.Ajax.PassTextBox.callBaseMethod(this, 'dispose');
},

It is almost done, except the definition of the get and set properties which can be done like this:

//define properties
get_weakCssClass: function() {
return this._weakCssClass;
},
set_weakCssClass: function(value) {
this._weakCssClass = value;
},

I need to do this for all three properties.

Now, I can use this in my page after referencing it in the ScriptManager.

<script language="javascript" type="text/javascript">
var app = Sys.Application;
app.add_init(appInit);

function appInit(sender, args) {
    $create(Panahy.Ajax.PassTextBox,
        { weakCssClass: 'weak', mediumCssClass: 'medium', strongCssClass: 'strong' },
        null, null, $get('MainContent_TextBoxPassword'));
}
</script>
In this way, I don't need to set anything on the textbox.
This is still not perfect, In the next article I will demonstrate how to put this in a custom ASP.NET Control.

Implementing Custom Classes for Microsoft AJAX Library (Part 1)

2011-11-08T10:24:00.004+01:00

This article explainis the basic steps for impplementing your own javascript class and use it in a page.
First, you need to write a script that describes the class. This example simply provides a class that verifies the length of a word to see if it has enough length to be used as a password. The file name is PasswordStrengthComponent.js

/* When working with JavaScript files in the code editor, you can add a reference to the Microsoft AJAX Library. This will ensure that your coding includes IntelliSense for the library. This is similar to the using statement in C# and the Imports statement in Visual Basic. You embed this reference in a comment at the top of your .js file. The following shows an example.
*/
/// <reference name="MicrosoftAjax.js"></reference>
// register your namespace
Type.registerNamespace("Panahy.Ajax");
//create constructor
Panahy.Ajax.PasswordStrengthComponent = function () {
    Panahy.Ajax.PasswordStrengthComponent.initializeBase(this);
}
//define class
Panahy.Ajax.PasswordStrengthComponent.prototype = {
    initialize: function () {
        //add custom initialization here
        Panahy.Ajax.PasswordStrengthComponent.callBaseMethod(this, 'initialize');
    },
    passwordStrengthClass: function (password) {
        var strPass = new String(password.toString());
        if (strPass.length < 5) {
            return "Weak";
        }
        else if (strPass.length < 8) {
                return "Medium";
        } else {
            return "Strong";
        }
    },
    dispose: function () {
        //add custom dispose actions here
        Panahy.Ajax.PasswordStrengthComponent.callBaseMethod(this, 'dispose');
    }
}
//register class as a Sys.Component
Panahy.Ajax.PasswordStrengthComponent.registerClass(
    'Panahy.Ajax.PasswordStrengthComponent', Sys.Component);
//notify script loaded
if (typeof (Sys) !== 'undefined') Sys.Application.notifyScriptLoaded();
Next, you reference this script file in your page within the ScriptManager:

<asp:ScriptManager ID="ScriptManager1" runat="server">
    <Scripts>
        <asp:ScriptReference Path="Scripts/PasswordStrengthComponent.js" />
    </Scripts>
</asp:ScriptManager>

From this point the script is available and can be used in thepage as in the following example:
<script language="javascript" type="text/javascript">
    function _OnKeypress() {
        var checker = new Panahy.Ajax.PasswordStrengthComponent();
        var pass = document.getElementById("MainContent_TextBoxPassword").value;
        var strength = checker.passwordStrengthClass(pass);

        document.getElementById(
            "MainContent_TextBoxPassword").setAttribute("class", strength);
    }
</script>
<asp:TextBox ID="TextBoxPassword" runat="server"
        TextMode="Password" Width="200" onkeyup="_OnKeypress()" CssClass="Empty"></asp:TextBox>

Next part will take this subject one step forward.

LinqToSql Count

2011-10-21T16:09:00.004+02:00

You can pass the results of a linq query to the next statement like this one

var q = context.Products

.Where(p => p.ProductName.StartsWith("A"))

.Count();

and that should provide the count of products with names starting with "A".

Further it would make no difference (performance wise) to skip theWhere statement and simply call the Count with filter as parameter, like:

var q = context.Products

.Count(p => p.ProductName.StartsWith("B"));

or in another syntax like:

q = (from p in context.Products

where p.ProductName.StartsWith("C")

select true).Count();

So, I did put a tracing into the Context.Log to see what it goes to the SQL-Server. I've got the following for all three cases:

SELECT COUNT(*) AS [value]

FROM [dbo].[Products] AS [t0]

WHERE [t0].[ProductName] LIKE @p0

-- @p0: Input NVarChar (Size = 4000; Prec = 0; Scale = 0) [A%]

-- Context: SqlProvider(Sql2008) Model: AttributedMetaModel Build: 4.0.30319.1

Placing a Web Method in a Page

2011-10-21T10:08:00.002+02:00

In most cases, it makes sense to create a separate web service to handle your ASP.NET AJAX callbacks.

This approach generally results in clearer pages and makes it easier to debug and refine your code.

However, in some situations you may decide you have one or more web methods that are designed

explicitly for use on a single page and that really shouldn't be reused in other parts of the application. In

this case, you may choose to create a dedicated web service for each page, or you might choose to move

the web service code into the page.

Placing the web method code in the page is easy—in fact, all you need is a simple bit of cut-andpaste.

First, copy your web method (complete with the WebMethod attribute) into the code-behind class

for your page. Then, change it to a static method, and add the System.Web.Script.Services.ScriptMethod

attribute. Here's an example where the web method (named GetTerritoriesInRegion) is placed in a web

page named WebServiceCallback_PageMethods:

public partial class WebServiceCallback_PageMethods : System.Web.UI.Page

{

[System.Web.Services.WebMethod()]

[System.Web.Script.Services.ScriptMethod()]

public static List<Territory> GetTerritoriesInRegion(int regionID)

{

// Farm the work out to the web service class.

TerritoriesService service = new TerritoriesService();

return service.GetTerritoriesInRegion(regionID);

}

...

}

Next, set the ScriptManager.EnablePageMethods property to true, and remove the reference in the

<Services> section of the ScriptManager (assuming you don't want to use any non-page web services):

<asp:ScriptManager ID="ScriptManager1" runat="server" EnablePageMethods="true">

</asp:ScriptManager>

Finally, change your JavaScript code so it calls the method through the PageMethods object, as

shown here:

PageMethods.GetTerritoriesInRegion(regionID, OnRequestComplete, OnError);

The PageMethods object exposes all the web methods you've added to the current web page.

One advantage of placing a web method in a page is that the method is no longer exposed through

an .asmx file. As a result, it's not considered part of a public web service, and it's not as easy for someone

else to discover. This is appealing if you're trying to hide your web services from curious users.

Another reason you might choose to code your web methods in the page class is to read values from

view state or the controls on the page. When you trigger a page method, a stripped-down version of the

page life cycle executes, just like with the ASP.NET client callback feature you saw in Chapter 29. Of

course, there's no point in trying to modify page details because the page isn't being rerendered, so any

changes you make will simply be discarded.

Loading a custom control at runtime

2011-10-20T11:40:00.002+02:00

You can load a server control to your page using the constructor of the control. For example a Literal control can be loaded as follows:

plhContainer.Controls.Add(
            new Literal
            {
                Text = string.Format("{0}.{1}",
                    method.ReflectedType.FullName, method.Name)
            });

When it comes to a custom control you also want the markup code of you custom control to be loaded too. So you need to tell the Page o load it for you:


var nameBox = (NameBox) Page.LoadControl("NameBox.ascx");

Basically, you could do this at any time, but it is recommanded to do this at Page_Load the reason is that this is the best place for the control to restore its state and receive postback events. Also the binding will take place after this method. Look at my previous post for the sequence of the events and method calls when page gets loaded.
It is also recomannded to set a unique ID to that control if you need to find that later using FindControl, or some one else want to find where you have put it :-)

So, my load method will look like this:


     private void LoadMyControls()
     {
         var nameBox = (NameBox) Page.LoadControl("NameBox.ascx");
         // Give the user control a unique name by setting its ID property.
         // You can use this information to retrieve a reference to the control
         // when you need it with the Page.FindControl() method.
         nameBox.ID = "nameBox"; 
         nameBox.FirstName = "Asghar";
         nameBox.LastName = "Panahy";
         nameBox.ChangeRequest += ChangeName;
         plhContainer.Controls.Add(nameBox);
     }

When I call LoadMyControls() in Page_Load method, I see the following sequence in my output:


STARTING: MCTS._70_515.Resources._Default.Page_Init
STARTING: MCTS._70_515.Resources._Default.OnInit
STARTING: MCTS._70_515.Resources._Default.Page_Load
STARTING: MCTS._70_515.Resources.NameBox.Page_Init
STARTING: MCTS._70_515.Resources.NameBox.OnInit
STARTING: MCTS._70_515.Resources._Default.OnLoad
STARTING: MCTS._70_515.Resources.NameBox.Page_Load
STARTING: MCTS._70_515.Resources.NameBox.OnDataBinding
STARTING: MCTS._70_515.Resources.NameBox.get_LastName
STARTING: MCTS._70_515.Resources.NameBox.OnLoad
STARTING: MCTS._70_515.Resources._Default.OnPreRender
STARTING: MCTS._70_515.Resources.NameBox.OnPreRender
STARTING: MCTS._70_515.Resources.NameBox.OnUnload
STARTING: MCTS._70_515.Resources._Default.OnUnload

Notice that the custom control gets its data binded just after the page has passed Loading which is a good thing.

ASP Page en Control Lifecycle

2011-10-20T09:55:00.000+02:00

When I put a logging in a couple of override methods of a NameBox control and load the page containing the custom control I see the following:



STARTING: MCTS._70_515.Resources.NameBox.Page_Init

STARTING: MCTS._70_515.Resources.NameBox.OnInit

STARTING: MCTS._70_515.Resources.NameBox.Page_Load

STARTING: MCTS._70_515.Resources.NameBox.OnDataBinding

STARTING: MCTS._70_515.Resources.NameBox.get_LastName

STARTING: MCTS._70_515.Resources.NameBox.OnLoad

STARTING: MCTS._70_515.Resources.NameBox.OnPreRender

STARTING: MCTS._70_515.Resources.NameBox.OnUnload

It is important to note that Page_Load is long before OnLoad method, similar to Page_Init versus OnInit.

Next I click on the change button to post back to handle the event and I see the following:



STARTING: MCTS._70_515.Resources.NameBox.Page_Init

STARTING: MCTS._70_515.Resources.NameBox.OnInit

STARTING: MCTS._70_515.Resources.NameBox.Page_Load

STARTING: MCTS._70_515.Resources.NameBox.OnDataBinding

STARTING: MCTS._70_515.Resources.NameBox.get_LastName

STARTING: MCTS._70_515.Resources.NameBox.OnLoad

STARTING: MCTS._70_515.Resources.NameBox.ChangeRequestClicked

STARTING: MCTS._70_515.Resources.NameBox.OnPreRender

STARTING: MCTS._70_515.Resources.NameBox.OnUnload

Next, I add some similar loggging to the page that contains the control and see what happens when I load the page:



STARTING: MCTS._70_515.Resources.NameBox.Page_Init

STARTING: MCTS._70_515.Resources.NameBox.OnInit

 STARTING: MCTS._70_515.Resources._Default.Page_Init

STARTING: MCTS._70_515.Resources._Default.OnInit

STARTING: MCTS._70_515.Resources._Default.Page_Load

STARTING: MCTS._70_515.Resources._Default.OnLoad

STARTING: MCTS._70_515.Resources.NameBox.Page_Load

STARTING: MCTS._70_515.Resources.NameBox.OnDataBinding

STARTING: MCTS._70_515.Resources.NameBox.get_LastName

STARTING: MCTS._70_515.Resources.NameBox.OnLoad

 STARTING: MCTS._70_515.Resources._Default.OnPreRender

STARTING: MCTS._70_515.Resources.NameBox.OnPreRender

STARTING: MCTS._70_515.Resources.NameBox.OnUnload

 STARTING: MCTS._70_515.Resources._Default.OnUnload

So, The OnLoad method gets called after binding whereas the Page_Load is about before the binding. Obviously, if you need to initialize your data, you better put your code in OnInit rather that OnLoad or Page_Load.
Another important thig here is the PreRender methods. These methods get called after load has been completed and the data is assumed to be in place.

Now let's see what happens when I click a button on the control which causes a postback:



STARTING: MCTS._70_515.Resources.NameBox.Page_Init

STARTING: MCTS._70_515.Resources.NameBox.OnInit

 STARTING: MCTS._70_515.Resources._Default.Page_Init

STARTING: MCTS._70_515.Resources._Default.OnInit

STARTING: MCTS._70_515.Resources._Default.Page_Load

STARTING: MCTS._70_515.Resources._Default.OnLoad

STARTING: MCTS._70_515.Resources.NameBox.Page_Load

STARTING: MCTS._70_515.Resources.NameBox.OnDataBinding

STARTING: MCTS._70_515.Resources.NameBox.get_LastName

STARTING: MCTS._70_515.Resources.NameBox.OnLoad

STARTING: MCTS._70_515.Resources.NameBox.ChangeRequestClicked

 STARTING: MCTS._70_515.Resources._Default.ChangeName

STARTING: MCTS._70_515.Resources._Default.OnPreRender

STARTING: MCTS._70_515.Resources.NameBox.OnPreRender

STARTING: MCTS._70_515.Resources.NameBox.OnUnload

 STARTING: MCTS._70_515.Resources._Default.OnUnload

Both event handlers in the control and in the page are called after all controls and the page has been loaded and the data is binded too, just before the rendering take place.

Notify Database changes to ASP.NET pages

2011-10-19T13:44:00.001+02:00

In the old times there were two ways of getting notifications from the database into the ASP.NET pages.

writing to a file (simply create or delete an empty file) in a specific location where a CacheDependency can listen to and callBack a method on change.
implement an HttpHandler that gets the notification with a parameter of what is changed, and let the database send an http request to the IIS server on a trigger.

I am sure there could be worse methods but even these two have a lot of complications in a secured architecture with high performance requirements, like we have these days.

Fortunately, since SQL-Servet 2000, there is a new component implemented into SQL-server called Service Broker that act on changes in tables that are marked to be notified on change. Internally they write to a specific table mentioning about the change.

In order to configure a database for Service Broker you can call a statement like this:

Use Northwind

ALTER DATABASE Northwind SET ENABLE_BROKER

For more information about Service Broker see the MSDN.

Next, you need to set the ASP.NET to recieve the notification via dependencies. To do so , you need to add the command object to the dependency:

// Create the dependency.

SqlCacheDependency empDependency = new SqlCacheDependency(cmd);

// Add a cache item that will be invalidated if one of its records changes

// (or a new record is added in the same range).

Cache.Insert("Employees", ds, empDependency);

To start the notification on application service you need to add the following to the Global.ascx.cs in Application_Start

SqlDependency.Start(connectionString);

It is a good practice to stop the notifications on Application_End

SqlDependency.Stop(connectionString);

Once this is implemented, you can get the notifications through the OnChange event of the SqlDependency class.

Implementing custom FileCacheProvider

2011-10-18T15:15:00.002+02:00

This is a summerized version of what you can find in the APress book Chapter 11.

If you want to cach some pages or all, you need to first tell the ASP.NET to do so. As the caching starts before rendering the page, you can not specifiy this in the page markup, rather it will be mentioned in the Global.asax.cs

public override string GetOutputCacheProviderName(HttpContext context)

{

// Get the page.

string pageAndQuery = System.IO.Path.GetFileName(context.Request.Path);

if (pageAndQuery.StartsWith("OutputCaching.aspx"))

return "FileCache";

else

return base.GetOutputCacheProviderName(context);

}

This tells to ASP.NET to use FileCache mechanics for cachin OutputCaching.aspx page. The rest will just follow the default.

Next step is to specify where to find the implementation of FileCache. This is mentioned in the web.config as follows:

<system.web>

<add name="FileCache" type="MyCompany.MyProject.Caching.FileCacheProvider"

cachePath="~/Cache" />

</providers>

</outputCache>

</caching>

</system.web>

Notice that the cachePath is not a recognized attribute but we may introduce it to get the parameters. In this case it refers to an existing folder on the root of the website.

Next step is to implement the provider. This involves to implement a class that inherits from OutputCacheProvider and overrides the methods as follows:

public class FileCacheProvider : OutputCacheProvider

{

// The location where cached files will be placed.

public string CachePath

{ get; set; }

public override void Initialize(string name, System.Collections.Specialized.NameValueCollection attributes)

{

base.Initialize(name, attributes);

// Retrieve the web.config settings.

CachePath = HttpContext.Current.Server.MapPath(attributes["cachePath"]);

}

public override object Add(string key, object entry, System.DateTime utcExpiry)

{

// Transform the key to a unique filename.

string path = ConvertKeyToPath(key);

// Set it only if it is not already cached.

if (!File.Exists(path))

{

Set(key, entry, utcExpiry);

}

return entry;

}

public override object Get(string key)

{

string path = ConvertKeyToPath(key);

if (!File.Exists(path)) return null;

CacheItem item = null;

using (FileStream file = File.OpenRead(path))

{

BinaryFormatter formatter = new BinaryFormatter();

item = (CacheItem)formatter.Deserialize(file);

}

// Remove expired items.

if (item.ExpiryDate <= DateTime.Now.ToUniversalTime())

{

Remove(key);

return null;

}

return item.Item;

}

public override void Set(string key, object entry, System.DateTime utcExpiry)

{

CacheItem item = new CacheItem(entry, utcExpiry);

string path = ConvertKeyToPath(key);

// Overwrite it, even if it already exists.

using (FileStream file = File.OpenWrite(path))

{

BinaryFormatter formatter = new BinaryFormatter();

formatter.Serialize(file, item);

}

public override void Remove(string key)

{

string path = ConvertKeyToPath(key);

if (File.Exists(path)) File.Delete(path);

}

private string ConvertKeyToPath(string key)

{

// Flatten it to a single file name, with no path information.

string file = key.Replace('/', '-');

// Add .txt extension so it's not confused with a real ASP.NET file.

file += ".txt";

return Path.Combine(CachePath, file);

}

The CachePath will be set by configurationManager. The private method ConvertKeyToPath helps to find a unique filename based on the url. This example uses binary formatter and a wrapper class that adds an expiration property to any object that needs to be cached. So, the following is the implementation of the wrapper class:

[Serializable]

public class CacheItem

{

public DateTime ExpiryDate;

public object Item;

public CacheItem(object item, DateTime expiryDate)

{

ExpiryDate = expiryDate;

Item = item;

}

That's all. When you run this you will notice that you will get an error if the Cache folder does not exist in the root.

To test the caching try to put the next code in the Default.aspx

<%@ OutputCache Duration="10" VaryByParam="None" %>

MVC Tips

2011-10-14T16:34:00.000+02:00

You can use the standard ASP.NET features in your MVC views. In this case, you call the String.Format method to display the UnitPrice field in a suitable form for a monetary amount. You just pass in the Model.UnitPrice value as the argument to the method call.

<%= String.Format("{0:F2}", Model.UnitPrice) %>

String class can also be used as a formatter in thextbox:

Unit Price:
<%: Html.TextBoxFor(model => model.UnitPrice, new {Value = String.Format("{0:F2}", Model.UnitPrice)})%>

Localizing ASP.NET Tips

2011-10-14T13:12:00.001+02:00

There are two kind of localizations:

Local resources are specific to a page.
Global resources are shared throughout the site

If your site contains many folders, you might have an App_LocalResources subfolder in each folder of your site.

<asp:Button ID="ButtonFind" runat="server" Text="Find" CssClass="submitButton" meta:resourcekey="ButtonFindResource1" />

<asp:Localize ID="LabelTitle" runat="server" Text="Customer Lookup" meta:resourcekey="LabelTitleResource1"></asp:Localize>

The Text property of the Button control is to aid the developer at design time.

ASP.NET will use the key to find and match on any property that might be set inside the resource file as meta:resourcekey.<PropertyName> or ButtonFindResoure1.Text:

</data>

<value>Click this to start the search action</value>

</data>

Accessing a Local resource in C# could be done as follows:

Textbox1.Text = GetLocalResourceObject("Textbox1.Text").ToString();

Accessing a shared global resource in C# could be done in one of the two followings:

Textbox1.Text = Resources.ResourceFileName.Textbox1Text;

Textbox1.Text = GetGlobalResourceObject("ResourceFileName", "Textbox1Text") as string;

The methods GetGlobalResourceObject and GetLocalResourceObject can come handy when the resources does not exist at compile time and might be provided as a separate dll at runtime.

Show an object instance as an xnl on your page

2011-10-10T17:18:00.002+02:00

This sample code demonstrates how to show an instance of an object in XML format on a page. It encodes the xml serialized string and dumps it as a code into a placeholder.

public void ShowXmlObject<T>( T instance)

{

var ms = new MemoryStream();

System.Xml.XmlTextWriter writer = new System.Xml.XmlTextWriter(ms, Encoding.Unicode);

var serializer = new System.Xml.Serialization.XmlSerializer(typeof(T));

serializer.Serialize(writer, instance);

writer.Flush();

ms.Position = 0;

var reader = new StreamReader(ms);

LogCode(HttpUtility.HtmlEncode(IndentXml(reader.ReadToEnd())));

}

public string IndentXml(string xml)

{

var p = xml.LastIndexOf("?>");

if (p > 0)

xml = xml.Substring(p + 2);

var doc = new System.Xml.XmlDocument();

doc.LoadXml(xml);

var settings = new System.Xml.XmlWriterSettings();

settings.Indent = true;

settings.IndentChars = " ";

settings.NewLineChars = "\r\n";

settings.NewLineHandling = System.Xml.NewLineHandling.None;

var sbOutput = new StringBuilder();

var writer = System.Xml.XmlWriter.Create(sbOutput, settings);

doc.Save(writer);

writer.Close();

return sbOutput.ToString();

    public void LogCode(string message)

        placeResult.Controls.Add(new Literal() { Text = "<pre><code>" + message + "</code></pre>" });

Show Items structure in Sitecore

2011-10-10T17:04:00.004+02:00

The following example demonstrates how to get the information about a node on the back side of a node by giving the item.ID. You also could do it easier by having the full path instead of creating an ID.

It is important to do all this inside a SecurityDisabler. You might have some nodes that are not accessible to anonymous user, if the code is running for without proper security.

protected void StartToAnalyse(object sender, EventArgs e) {

Sitecore.Data.Database master =

Sitecore.Configuration.Factory.GetDatabase("master");

using (new Sitecore.SecurityModel.SecurityDisabler())

{

ProcessItem(master.GetItem(new Sitecore.Data.ID(textboxRoot.Text)));

}

private void ShowTechnicalDetails(Sitecore.Data.Items.Item item)

{

string pageName = item.DisplayName;

var template = item.Template;

//LogLine(" Template : " + item.TemplateName);

// LogLine(" Uri : " + item.Uri.Path);

// string rend = Sitecore.Context.Item.Fields["Renderings"].Value;

Sitecore.Data.Items.DeviceItem defDevice = Sitecore.Data.Items.DeviceItem.ResolveDevice(Sitecore.Configuration.Factory.GetDatabase("master"));

var layout = item.Visualization.GetLayout(defDevice);

if (layout != null)

{

LogLine(" Layout : <u> [" + layout.DisplayName + "]</u>" );

// // LogLine(" File : " + layout.FilePath);

}

var renderings = item.Visualization.GetRenderings(defDevice, false);

//LogLine("Renderings:<ul>");

foreach(var rend in renderings)

{

//LogLine(" Layout : " + rend.RenderingItem.DisplayName);

LogItem(pageName + ";" + rend.RenderingItem.InnerItem["Path"]);

}

private void ProcessItem(Sitecore.Data.Items.Item item)

{

if (item == null)

{

LogLine("Item not found.");

return;

}

ShowTechnicalDetails(item);

foreach (Sitecore.Data.Items.Item child in item.Children)

{

ProcessItem(child);

}

jQuery.Ajax versus Server-side event handler

2011-10-06T15:45:00.002+02:00

This sample demonstrates two ways of getting address from the server: using server-side event handler versus calling jQuery.Ajax

The following is the markup that provides two fields with javascript call on the change event. It also provides a button that is wired to a server side methode:

<div>

<h3> Address Test</h3>

tabbing from the textboxes will verify if calling the webservice is required.

<td> Huisnummer *</td>

<asp:TextBox runat="server" ID="textboxHousenumber" ClientIDMode="Static"

CssClass="TextField TextField02" onchange="VerifyAddress();"

ValidationGroup="KlantAddress" />

</div>

</td></tr><tr>

<td> Postcode *</td>

<asp:TextBox runat="server" ID="textboxPostcode" ClientIDMode="Static"

CssClass="TextField TextField02"

MaxLength="7" onchange="VerifyAddress();"

ValidationGroup="KlantAddress"

</div>

</td></tr>

</table>

Server side call:<br />

<asp:Button ID="Button1" runat="server" OnClick="ShowAddress" Text="Get Adres" ToolTip="CustomerDataController" />

<asp:Label runat="server" ID="lblAddress" />

Assume we have a we DBLLayer that provides an address or throws an exception.
The event handler would be something like this:

/// <summary>Server side event handler</summary>

public void ShowAddress(object sender, EventArgs e)

{

try

{

var adres = DBLayer.GetAddress(textboxPostcode.Text, textboxHousenumber.Text);

ShowAdres(adres);

}

catch (Exception ex)

{

LogError("Error :- " + ex.Message);

}

And the Javascript will look like this:

function VerifyAddress() {

// This method is calling the ShowAddress only if both parameters are filled in.

$("#<%=lblAddress.ClientID %>" ).text("" );

var postcode = $("#<%=textboxPostcode.ClientID %>" ).val();

var huisnummer = $("#<%=textboxHousenumber.ClientID %>" ).val();

if (postcode && huisnummer && parseInt(huisnummer) > 0) {

$("#<%=lblAddress.ClientID %>" ).text("calling the server" );

var data = "{ postcode:'" + postcode + <span' , huisnummer: " + huisnummer + " }" ;

jQuery.ajax({

type: <span' ,

contentType: <span'application/json;' ,

data: data,

dataType: <span' ,

url: <span' ,

success: OnGetAddressComplete,

error: OnErrorReceived

});

}

function OnErrorReceived(xhr, ajaxOptions, thrownError) {

var message = jQuery.parseJSON(xhr.responseText);

$("#<%=lblAddress.ClientID %>" ).text(

"ERROR (" + xhr.status + ") - " + message.Message);

}

function OnGetAddressComplete(result) {

// display the result

var adres = result.d;

$("#<%=lblAddress.ClientID %>" ).text(

adres.Straat + <span'' +

adres.Huisnummer + <span',' +

adres.Postcode + <span'' + adres.Plaats);

}

And finally the webservice will be like:

[System.Web.Services.WebMethod ()]

public static Adres GetAddress(string postcode, string huisnummer)

{

if (!IsPostcode(postcode))

throw new Exception ("Invalid Postcode." );

int hNr = 0;

if (!Int32 .TryParse(huisnummer, out hNr))

throw new Exception ("Invalid house number." );

var result = DBLayer .GetAddress(postcode, huisnummer);

if (result == null )

throw new Exception (" Unknown address." );

return result;

}

public static bool IsPostcode(string zipcode)

{

var ZipcodeRegex = @"^[1-9][0-9]{3}[a-zA-Z]{2}[\\s]*$" ;

Regex r = new Regex (ZipcodeRegex, RegexOptions .IgnoreCase);

Match m = r.Match(zipcode);

return m.Success;

}

Convert XElements to Json

2011-08-01T15:18:00.000+02:00

You need to capture the data type in a class that is serializable.
In this example I use Employee to do so. The first action will be to construct an IEnumerable of Employee:

 XElement empXml = GetEmployees();
 var empJson = from emp in empXml.Descendants("Employee")
               select new Employee
               {
                      ID = emp.Element("ID").Value,
                      FirstName = emp.Element("FirstName").Value,
                      Department = emp.Element("Department").Value,
                      City = emp.Element("City").Value
               };

The second step is to serialize the enumeration into the memory stream.

  var ser = new  DataContractJsonSerializer(typeof(IEnumerable));
  var ms = new MemoryStream();
  ser.WriteObject(ms, empJson);

And at last, we can take the generated stream as a string just before closing the stream.

string json = Encoding.Default.GetString(ms.ToArray());
ms.Close();

What is jQuery? Introduction

2011-05-31T11:48:00.006+02:00

This is a very short description of jQuery coming from the book MCTS Self-Pased Training Kit (Exam 70-515):

jQuery is an open source library that simplifies the way JavaScript is written. It works across all modern browsers and is lightweight. You can use it for a variety of client-side programming tasks, such as selecting items inside your page, manipulating those items, changing styles, doing animations and effects, handling user events on the client side, and calling web services by using AJAX. There are also several plug-ins available for jQuery that provide rich controls that execute
inside a browser window.

Visual Studio 2010 and ASP.NET 4 now fully support jQuery for client-side development. The jQuery library is installed by default when you create a new ASP.NET website.

jQuery is simply a file of JavaScript code that allows you to more easily write JavaScript code that runs in many different browsers. This code can do many things; it can work with UI styles, handle user events, animate parts of your page, call back to the server via AJAX, and more.

The jQuery library has a core set of features on which you can build. In fact, there are many extensions and plug-ins available for jQuery that help with menus, UI controls, page layout, navigation, and much more. The following list outlines the essential functionality that jQuery provides.

Core The core of the jQuery library allows you to identify code that can execute only after a document has fully loaded, create DOM elements dynamically, iterate selected
elements, create extensions to jQuery itself, and more.

Selecting jQuery’s power is in its ability to quickly select items in the DOM. You can easily return a single item from your page’s DOM or many items that match a pattern without having to write much code. You use the jQuery selectors to find specific HTML tags or to find form elements by ID, cascading style sheet class name, attribute or attribute value, and more.

Filtering and Traversing You can create filters to select only those DOM elements that meet your filter criteria. You can also traverse through your selection and act upon the selected items (by changing their style or adding an event, for example). Some important filter and traverse functions are first, last, odd, visible, match, selected, contains, enabled, find, next, prev, parent, and siblings.

Manipulation After you have selected an item (or multiple items), you can also use jQuery to manipulate the item. This might be as simple as evaluating the HTML contents or setting the text contents of the selected item. You can also use functions such as append, insert, replaceWith, wrap, and remove (among others) to add, modify, or remove content from the selected DOM item.

Cascading style sheets jQuery also provides functions for working with cascading style sheets. This includes finding and setting styles, positioning items, setting height and width, and more.

Events The jQuery library allows you to attach client code to user events in the browser. This decouples your event code from the actual markup. You can handle almost any user input event, including hover, toggle, click, dblclick, keydown, keyup, focus, mousedown, mouseenter, mouseleave, scroll, resize, and more.

Animation and Effects jQuery provides functions for adding effects to and animating the items on your page. Functions include show, hide, fadeIn, fadeOut, fadeTo, slideDown, slideUp, animate, and more.

AJAX The jQuery library supports AJAX calls from the browser to the server. It allows you to call a web service or client script on the server and return the results to the page without refreshing the entire page

Utilities There are several utility functions inside the jQuery language for working with browser compatibility, arrays, strings, and more.

The jQuery language is contained in a single file, jquery-.min.js, in
which version is the current version (1.4.1 at the time of this writing).

The jquery-1.4.1-vsdoc.js file is used by Visual Studio to provide IntelliSense in the text editor for jQuery code. Visual Studio simply looks for this file based on the naming convention and will provide the appropriate IntelliSense. The jquery-1.4.1.js file is the debug version of jQuery. This is a version of the code that is readable. You will want to reference this file in your code when you are debugging your client scripts. The jquery-1.4.1.min.js file is the “minified” version of the jQuery language. You use this file for production applications because it is a smaller client download and executes faster.

The jQuery language files are actually hosted by several content delivery networks (or CDNs). This ensures faster downloads and caching of the jQuery language. Microsoft provides a CDN host of jQuery at http://ajax.microsoft.com/ajax/jquery/jquery-1.4.2.min.js.
You can use this URL to reference the jQuery language in your production applications.

Where to go from here?

Official web site

Online documentation

Wikipedia

jQuery UI provides abstractions for low-level interaction and animation, advanced effects and high-level, themeable widgets, built on top of the jQuery JavaScript Library, that you can use to build highly interactive web applications.

Linq: Group by and sort

2011-05-12T16:51:00.001+02:00

The following LINQ statement was the first one I wrote:


var hsQ = from hspt in hospitals
          orderby hspt.County, hspt.City
          group hspt by hspt.County;

It obviously groups by country and then sorts by city.

However, I found the following even better as it groups first by country, sorts by country and then sorts within the group by city:


var hsQ = from hspt in hospitals
          orderby hspt.City
          group hspt by hspt.County into hsptGroup
          orderby hsptGroup.First().County
          select hsptGroup;

Rar and UnRar in DOS.cmd

2011-04-22T10:09:00.003+02:00

To Rar all directories in the current folder and make a rar file using the folder name:

@echo off
@setlocal
REM
REM Unrar all .rar files on the current directory and use the full path
REM

set path="%ProgramFiles(x86)%\WinRAR\";%path%
for /F %%i in ('dir /b *.rar') do call :do_extract "%%i"

:eof
pause
exit 1

:do_extract
echo %1
REM  x  : Extract files with full path
REM -y : Assume Yes on all queries
unrar x -y %1

To Unrar all files in the current location using FullPath:


@echo off
@setlocal
REM
REM Unrar all .rar files on the current directory and use the full path
REM

set path="%ProgramFiles(x86)%\WinRAR\";%path%
for /F %%i in ('dir /b *.rar') do call :do_extract "%%i"

:eof
pause
exit 1

:do_extract
echo %1
REM  x  : Extract files with full path
REM -y : Assume Yes on all queries
unrar x -y %1

WCF Authenticate by APIKey

2011-04-11T17:59:00.003+02:00

Following my previous note, I want each service have its own authentication mechanics, maybe some public services and some sharing the same authentication manager.

To do so, I will set up different behaviors in my web.config in the servicebehaviors section, and make sure each service points to the corresponding behavior:

<system.serviceModel>
  <behaviors>
    <serviceBehaviors>
      <behavior name="ProductionServiceBehavior"> 
        <serviceAuthorization serviceAuthorizationManagerType="WCFWebHttp.APIKeyAuthorization, WCFWebHttp" />
      </behavior>
      <behavior name="PublicServiceBehavior">
        <serviceMetadata httpGetEnabled="true"/>
        <serviceDebug includeExceptionDetailInFaults="false"/>
      </behavior>
    </serviceBehaviors>
  </behaviors>
  <services>
    <service name="WCFWebHttp.ProductionService" behaviorConfiguration="ProductionServiceBehavior">
    </service>
  </services>

Now, all I need to do is to implement my APIKeyAuthorization class. This class inherits from ServiceAuthorizationManager and overrides CheckAccessCore to validate the request and send an Error response if not validated.
For detailed information about this class see the original article on:
MSDN.

Routing WCF services by code

2011-04-11T16:50:00.003+02:00

When you want to route the requests to specific WCF service deppending on the url, you can add routers on the Application_Start method of the Global.asax.cs. In the following example I want my ProductionService handle the service calls on the path starting with /Production/ and my PublicService handle the requests with a path starting with /public/demo/

using System;
using System.Web.Routing;
using System.ServiceModel.Activation;

public class Global : System.Web.HttpApplication
{
    void Application_Start(object sender, EventArgs e)
    {
        #region Register Routes
        var factory = new WebServiceHostFactory();
        RouteTable.Routes.Add(new ServiceRoute("Production", factory, typeof(ProductionService)));
        RouteTable.Routes.Add(new ServiceRoute("Public/demo/", factory, typeof(PublicService)));
        #endregion
    }

Animate Image Left To Right

2011-04-06T17:16:00.003+02:00

The basics of any animation is moving something from one location to the other. In this code snippet I use to Image elements to slide away previously selected image and slide in the newly selected one.

The Image elements need to sit in a Canvas in order to let the Left property make sence.

<Label x:Name="txtFile"  HorizontalAlignment="Stretch"  />
<Canvas HorizontalAlignment="Stretch" VerticalAlignment="Stretch">
    
    <Image x:Name="newImage" Canvas.Left="0" Canvas.Top="0"  />
    <Image x:Name="oldImage"  Canvas.Left="0" Canvas.Top="0" />

</Canvas>

assuming that I have already given the previously selected image, my new image file will be given through a function call like

AnimateLeftToRight(selectedFile);

This method will swap the images and create a storyboard to begin animating. I start the newImage from x-position that equals to minus Window.Width and the old one starts from 0 and moves to Window.Width:

/// <summary>
/// Begins a story which animates two images from left to right
/// the old image takes the source from te new image just before assigning the new one
/// and they move together in the distance of Window.Width
/// </summary>
/// <param name="path">the path of the new image</param>
private void AnimateLeftToRight(string path)
{
    oldImage.Source = newImage.Source;
    newImage.Source = new BitmapImage(new Uri(path));

    var myStoryboard = new Storyboard();

    myStoryboard.Children.Add(MakeAnimation(-this.Width, 0, "newImage"));
    myStoryboard.Children.Add(MakeAnimation(0, this.Width, "oldImage"));

    myStoryboard.Begin(this);
}

Making animation can be done in different ways using different EasingFunction, But this one looked easy to understand and look nice on my example:

/// <summary>
/// Creates a DoubleAnimation that moves the target from left to right
/// </summary>
/// <param name="from">starting point X</param>
/// <param name="to">ending point X</param>
/// <param name="target">the target element to set the x to </param>
/// <returns>the created animation</returns>
private DoubleAnimation MakeAnimation(double from, double to, string target)
{
    const double durationSeconds = 1;

    var animation = new DoubleAnimation
                        {
                            Duration = new Duration(TimeSpan.FromSeconds(durationSeconds)),
                            AutoReverse = false,
                            From = from,
                            To = to,
                            EasingFunction = new PowerEase()
                                                 {
                                                     EasingMode = EasingMode.EaseInOut,
                                                     Power = 5
                                                 }
                        };

    Storyboard.SetTargetName(animation, target);
    Storyboard.SetTargetProperty(animation, new PropertyPath(Canvas.LeftProperty));

    return animation;
}

Geometry and Mini-Language

2011-03-15T15:24:00.003+01:00

StreamGeometry is a light-weight alternative to the PathGeometry class for

creating complex geometric shapes. You can use StreamGeometry when you

need to describe a complex geometry but don’t want the overhead of supporting

data binding, animation, and modification.

There are two classes in WPF that provide the mini-language for describing

geometric paths: StreamGeometry, and PathFigureCollection. You need to use

the StreamGeometry mini-language when you set a property of the Geometry

type, such as the Data property of a Path element.

<path stroke="Blue" data="M 100 120 L 200 120 L 200 220 L 100 170">
</path>

This path uses a sequence of four commands. The first command, M, creates the
PathFigure and sets the starting point to (100, 120). The following three
commands (L) create line segments.

Did i say "I've got memory leak"?

2011-03-11T14:09:00.004+01:00

Dealing with memory leak is not as far as some might think it is. But it doesn't get serious until it is very late to change the fundamentals of our software design.

In my recent project it happened to be caused by traditional event subscription pattern. Which is most likely not leaving any memory leak behind, but it could easily do so :-(

I also looked into latest libraries of Microsoft and saw they are using a new way of subscribing event handler to GUI events in WPF. Further I saw that every Window, like any Visual object in WPF, is derrived from DispatcherObject and is also implementing IWeakEventListener; hummmmmm!

So I've decided to create my first WeakEventManager and followed the instructions by Reed Copsey Jr. in his blog

You can instanciate several instances of different event listeners and let the manager route the events to all of them. As long as they all implement IWeakEventListener.ReceiveWeakEvent

To demonstrate this I started a sample code about human body. Assume you have a heart class and a hand class. If you have an instance of them and you need to get events on your hand when the heart beats you might do something like:
hear.BeatEvent += right.BeatHandler
The idea is to change this aby using an event manager, in my sample I have called it Brain, to handle de notifications like
Brain.AddListener(heart, right);
And to unsubscribe to the event you do something like
Brain.RemoveListener(heart, right);

To make this possible, you need to make sure that your Hand class where the events need to be handled, you implement the IWeakEventListener interface which brings us to ReceiveWeakEvent method:

/// <summary> Receives events from the centralized event manager. </summary>
/// <returns> true if the listener handled the event.  </returns>
/// <param name="managerType">The type of the <see cref="T:System.Windows.WeakEventManager"/> calling this method.</param>
/// <param name="sender">Object that originated the event.</param>
/// <param name="e">Event data.</param>
public bool ReceiveWeakEvent(Type managerType, object sender, EventArgs e)
{
    if (managerType == typeof(Brain))
    {
        var beat = e as BeatArgs;
        Trace.WriteLine(string.Format("{0} hand is getting the beat from {1}", name, beat.TimeOfBeat.ToString("hh:mm:ss")));
        return true;
    }

    return false;
}

The Brain class which has a Singleton implementation provides only two public methods i.e. AddListener and RemoveListener. They do this by calling the protected methods and passing the parameters:

/// <summary>Subscribe a body part to listen to heart beat </summary>
/// <param name="source">the heart to listen to</param>
/// <param name="listener">the body that subscribes</param>
public static void AddListener(Heart source, IWeakEventListener listener)
{
    Neuron.ProtectedAddListener(source, listener);
}

/// <summary>Unsubscribe a body part to listen to heart beat </summary>
/// <param name="source">the heart to listen to</param>
/// <param name="listener">the body that subscribes</param>
public static void RemoveListener(Heart source, IWeakEventListener listener)
{
    Neuron.ProtectedRemoveListener(source, listener);
}

That is not all what brain do internally. It is actually inheriting the abstract class WeakEventManager and in order to do that it overrides the StartListening and StopListening methods that are internally called when it should be.

/// <summary>Starts listening on the provided heart for the managed beat event.</summary>
/// <param name="source">The heart to disconnect beat event</param>
protected override void StartListening(object source)
{
    var heart = source as Heart;
    if (heart == null) throw new ArgumentException("The brain suppose to listen to heart only");

    heart.BeatEventHandler += DeliverEvent;
}

/// <summary>Stops listening on the provided heart for the managed beat event.</summary>
/// <param name="source">The heart to disconnect beat event</param>
protected override void StopListening(object source)
{
    var heart = source as Heart;
    if (heart == null) throw new ArgumentException("The brain suppose to listen to heart only");

    heart.BeatEventHandler -= DeliverEvent;
}

The last part is the Heart where the event is getting fired. That is nothing special and can be implemented as before.

/// <summary> Can beat and can e subscribed to the beat event handler </summary>
public partial class Heart
{
    /// <summary>Hanldler for notifying a beat  </summary>
    public event EventHandler<BeatArgs> BeatEventHandler;

    /// <summary>Sends the beat through the events  </summary>
    /// <param name="beatArgs"></param>
    protected void OnSendBeat(BeatArgs beatArgs)
    {
        if (BeatEventHandler != null)
            BeatEventHandler(this, beatArgs);
    }

    /// <summary>Create a beat and send it </summary>
    private void BeatOnce()
    {
        OnSendBeat(new BeatArgs());
    }
}