ASP.NET Weblogs

Daily tech links for .net and related technologies - November 21-23, 2009

SanjeevAgarwal — Sun, 22 Nov 2009 06:52:00 GMT

Daily tech links for .net and related technologies - November 21-23, 2009 Web Development ASP.NET MVC: Creating reports using Chart control T4MVC 2.5.01: added support for Html.RenderAction and Html.Action Web Application Configuration Analyzer (WACA) The Search Developer Story in SharePoint 2010 – Query Interfaces Using the Microsoft Ajax Library 3.5 with the CDN Microsoft AJAX Library Preview 6 & Data Binding Web Design User Interface Design Is Not About Lorem Ipsum And Pretty Boxes The Ultimate...(read more)

ASP.NET MVC: Creating reports using Chart control

DigiMortal — Sat, 21 Nov 2009 13:36:00 GMT

ASP.NET Chart control is powerful control you can use to add charting support to your web applications. Although chart controls are mainly used with ASP.NET forms it is not very hard to use them also in ASP.NET MVC applications. In this posting I will show you how to use ASP.NET Chart control in ASP.NET MVC application and I will illustrate how to do it easily so you don’t mess up your views.

Before we start coding I want to make some notes about my solution:

this solution is pretty new and it is sure that one can improve the code provided here,
using this solution I’m trying to generalize in-place reporting for MVC applications,
also I’m trying to keep my views as clean as possible – chart definitions are not small if you have more complex charts or if you want very nice looking charts.

If you are not familiar with ASP.NET Chart control then please read my blog posting <asp:Chart>. You find there simple introduction to this free control and also all necessary links.

Solution overview

What we are trying to build here is shown on the following diagram. Our main goal is to avoid using ASP.NET forms elements in our MVC line user interface. Also we want to generalize reporting support so we have one interface for all reports.

I introduce here pretty simple report. If you have more complex reports then you can extend reporting interface shown below later. You may also find useful to reorganize outputing system. I am using here simple works-for-me or works-for-prototyping solution. I want to focus on point and let’s try not to lose it.

Reporting interface

Before we create our first report let’s define interface for it. This interface must define all basic actions we need to do with reports:

set source with report data,
bind data to report,
write report image to some (output) stream.

This is my reporting interface. Note that DataSource has only setter – it is because I don’t have currently need to ask data from chart. I only provide data to it.

public interface IReportControl : IDisposable
{
    void DataBind();
    object DataSource { set; }
    void SaveChartImage(Stream stream);
}

As you can see this interface is pretty thin. I am sure that it will grow in the future when need for more complex reports appears.

Sample report

Let’s define one report for testing purposes. Add web user control called MyReport.ascx to Reports folder of your web application and drag ASP.NET Chart control on it. Here is definition of my control.

<%@ Control Language="C#" AutoEventWireup="true"        
    CodeBehind="LastEnquiriesChart.ascx.cs"      
    Inherits="ReportingApp.Web.Reports.LastEnquiriesChart"        
%>
<%@ Register        
    assembly="System.Web.DataVisualization, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"
    namespace="System.Web.UI.DataVisualization.Charting" 
    tagprefix="asp"        
%>
 
<asp:Chart ID="Chart1" runat="server" Palette="Excel"
    Height="200px" Width="200px">
    <series>
        <asp:Series Name="Series2"
            CustomProperties="DrawingStyle=Emboss" 
            XValueMember="Date"        
            YValueMembers="Count"        
            IsValueShownAsLabel="True" 
            Font="Microsoft Sans Serif, 8pt"        
            LabelBackColor="255, 255, 192" 
            LabelBorderColor="192, 192, 0"      
            LabelForeColor="Red">           
        </asp:Series>
    </series>
    <chartareas>
        <asp:ChartArea Name="ChartArea1" BorderDashStyle="Solid">
            <AxisX        
                IntervalAutoMode="VariableCount"        
                IntervalOffsetType="Days" 
                IntervalType="Days"        
                IsLabelAutoFit="False"        
                IsStartedFromZero="False">
                <MajorGrid  
                    Interval="Auto"        
                    IntervalOffsetType="Days"        
                    IntervalType="Days" />
            </AxisX>
        </asp:ChartArea>
    </chartareas>
    <Titles>
        <asp:Title  
            Font="Microsoft Sans Serif, 8pt, style=Bold"
            Name="Title1" 
            Text="Last week enquiries">
        </asp:Title>
    </Titles>
</asp:Chart>

If you look at the definition and consider it as simple one you understand why I don’t want this mark-up to be there in my views. This is just one simple report. But consider for a moment three complex reports. 90% of my view will be one huge report definition then and I will miss all the good things that views have.

As I want this report to be interfaced with my reporting mechanism I make it implement IReportControl interface. Code-behind of my control is as follows.

public partial class LastEnquiriesChart : UserControl, IReportControl
{
    public object DataSource
    {
        set
        {
            Chart1.DataSource = value;
        }
    }
 
    public override void DataBind()
    {
        base.DataBind();
        Chart1.DataBind();
    }
 
    public void SaveChartImage(Stream stream)
    {
        Chart1.SaveImage(stream);
    }
}

All other user controls we are using for reporting must also implement IReportControl interface. This leads us to one interesting finding – we don’t have to host only chart control in our user controls, we have to host there whatever ASP.NET forms control we need for reporting. We can also create wrapper controls that get report image from some other external source (let’s say we have some COM component that is able to return reports as images).

Creating loader

Now we have sample report control and interface we can use to provide data and catch output of report. It is time to create meeting place for two worlds: ASP.NET forms and ASP.NET MVC framework. I created class called ReportLoader. The name of this class is good enough for me because it tells me that this is the integration point between two worlds. Let’s look at loader implementation now.

public static class ChartLoader
{
    public static void SaveChartImage(string controlLocation,      
    IEnumerable data, Stream stream)
    {
        using (var page = new Page())
        using (var control = (IReportControl)      
               page.LoadControl("~/Reports/" + controlLocation))
        {
            control.DataSource = data;
            control.DataBind();
            control.SaveChartImage(stream);
        }
    }
}

Loader does one trick: it doesn’t render the control. It only runs as long as report is written to stream and then it disposes user control and temporary page instance to avoid all other actions they may take. I made ChartLoader and SaveChartImage methods as static because I don’t need hell load of classes and super-cool architecture right now.

Creating controller action

We are almost there… Let’s create now controller action that returns chart image. As I am prototyping my application I use very robust controller action. You may be more polite coders and I strongly suggest you to read Bia Securities blog posting BinaryResult for Asp.Net MVC. You can find BinaryResult implementation also from MVC Contrib project.

[HttpGet]
public ActionResult GetChart()
{            
    var repository = Resolver.Resolve<IPriceEnquiryRepository>();
    var enquiries = repository.ListPriceEnquiries();
    var data = from p in enquiries
               group p by p.Date.Date into g
               select new { Date = g.Key, Count = g.Count() };
 
    Response.Clear();
    Response.ContentType = "image/png";
    ChartLoader.SaveChartImage(
                "LastEnquiriesChart.ascx",
                data, 
                Response.OutputStream);            
    Response.End();            
 
    return null; // have to return something
}

Now we have controller action that asks data from somewhere, prepares it for report and asks report as image from ChartLoader. Before outputing the report Response is cleared and content type is set to PNG. After writing image to response output stream the response is ended immediately to avoid any mark-up that may be written there otherwise.

As you can see I created special automatic objects for reporting. If you look at my report definition you can see that x-axis is bound to Date and y-axis to Count. You can also prepare reporting data in some near-DAL class methods and then slide this data through controller to report. The choice is yours.

Adding report to view

Now let’s link report to view. We just have to add one simple img tag to our view and make it src to call out GetChart() method defined above.

<img        
    src="<%= Url.Action("GetChart")%>"  
    alt="Last week enquiries"  
    title="Last week enquiries"      
/>

Output of report is shown on right. I don’t have much data here and my report is not very nice but it works. Now, if you are not too tired or bored, it is time to make your chart very nice and show it to your boss or customer.

Conclusion

Mixing forms and MVC worlds of ASP.NET doesn’t always have to end up with hard mess. In this posting I showed you how to add simple but pretty generic reports support to your ASP.NET MVC application. Due to good interfacing we achieved separation between forms and MVC templates and linking reports to views is very-very simple.

Of course, code and interfaces represented here are not production-ready examples. But they give you right direction and you can always improve design of my solution. My point was to illustrate how to mix MVC and forms world in reporting context and I feel like I succeeded this time. What do you think? :)

Unit Testing and Integration Testing in real projects

oazabir — Sat, 21 Nov 2009 10:52:00 GMT

I am yet to find a proper sample on how to do realistic Test Driven Development (TDD) and how to write proper unit tests for complex business applications, that gives you enough confidence to stop doing manual tests anymore. Generally the samples show you how to test a Stack or a LinkedList, which is far simpler than testing a typical N-tier application, especially if you are using Entity Framework or Linq to SQL or some ORM in data access layer, and doing logging, validation, caching, error handling at middle tier. There are many articles, blog posts, video tutorials on how to write unit tests, which I believe are all very good starting points. But all these examples show you basic tests, not good enough to let your QA team go. So, let me try to show you some realistic unit and integration test examples which should help you write tests that gives you confidence and helps you gradually move towards TDD.

I will show you tests done on my open source project Dropthings, which is a Web 2.0 AJAX portal built using jQuery, ASP.NET 3.5, Linq to SQL, Dependency Injection using Unity, caching using Microsoft Enterprise Library, Velocity and so on. Basically all the hot techs you can grasp in one shot. The project is a typical N-tier application where there’s a web layer, a business layer and a data access layer. Writing unit tests, integration tests and load tests for this project was challenging, and thus interesting to share so that you can see how you can implement Unit Testing and Integration Testing in a real project and gradually get into Test Driven Development.

Read this codeproject article of mine to learn how I did Integration Tests and Unit Tests using Behavior Driven Development approach:

Unit Testing and Integration Testing in business applications

http://www.codeproject.com/KB/testing/realtesting.aspx

If you like it, please vote for me.

Visual Studio 2010: Generating sequence diagrams on the fly

DigiMortal — Fri, 20 Nov 2009 12:28:00 GMT

One nice feature that Visual Studio 2010 provides is generating sequence diagrams on the fly. Just point out method and choose diagram generating option from context menu. In this posting I will show you how to generate sequence diagrams on the fly.

To keep example illustrative and simple I will use simple code. Let’s suppose we have ASP.NET MVC application with following controller.

public class PriceEnquiryController : Controller
{
    // ... some properties and methods ...
 
    public ActionResult Index()
    {
        var model = new PriceEnquiryListModel();
        model.PriceEnquiries = PriceEnquiryRepository.ListPriceEnquiries();
 
        return View(model);
    }
}

Let’s say we want to generate sequence diagram for this method. All we have to do is to right click on method with mouse, select “Generate Sequence Diagram …” and modify some options.

You can select what kind of calls you want to include and exclude. Setting these options you can make diagram to reflect only those parts of your code that you really need to visualize.

If you look at the image you see that you can also set call depth. With more complex methods it may be very helpful because too large call depth causes huge diagram with too much knowledge on it.

When we are done with options we have to click “OK” button and Visual Studio 2010 generates sequence diagram. You can click on image to see it in original size.

This diagram is pretty simple and primitive but you can also generate more complex diagrams. Just set options you need and let Visual Studio 2010 generate – it works like charm. Let’s hope we get more diagrams when Visual Studio 2010 first stable version is released.

Can the C# ‘var’ Keyword be Misused?

SGWellens — Thu, 19 Nov 2009 13:52:00 GMT

More and more often I've been seeing C# code like this:

var Data = GetData();

What on earth does GetData() return? This code is not as maintainable as it could be and is not as maintainable as it should be.

Doesn't explicitly declaring the variable type make the code more readable, understandable and ultimately more maintainable?

DataTable Data = GetData();

Ahhh, GetData() returns a DataTable.

I know that var has uses but I wish it would have been named something much longer because typing 'var' is too easy. Perhaps it should have been named AutomaticTypeVar or even AutoVar to reduce the lazy misuse.

Just my 2 cents.

Steve Wellens

Visual WebGui for the web and cloud, is what Visual Basic was, for the desktop

Visual WebGui — Thu, 19 Nov 2009 12:57:00 GMT

Just a decade and a half ago, the process of building a simple Windows-based application could have been described as a nightmare. The introduction of Visual Basic changed it so developers could for the first time implement Windows applications in an intuitive, graphical environment by dragging controls onto a form. The web revolution is here and now. Web had become very quickly the platform of choice for all kind of applications. The demand for web applications is ever growing and cloud computing...(read more)

ASP.NET 4.0: Writing custom output cache providers

DigiMortal — Thu, 19 Nov 2009 12:48:00 GMT

Until now we can use ASP.NET default output cache. We don’t have any option to write our own output cache mechanisms. ASP.NET 4.0 introduces extensible output cache – programmers can write their own output cache providers. In this posting I will show you how to write your own output cache provider and give you my sample solution to download.

Preparing

Before we begin with caching we need Visual Studio 2010 solution that has two projects – one web application and one class library. Class library is for output cache provider and web application is for testing purposes. My solution uses following names:

Solution: CacheProviderDemo
Web application: CacheProviderApp
Class library: MyCacheProviders

Before moving on let’s modify web application and add project reference to class library. In this case we don’t have to copy our cache provider to GAC after each build.

Configuring output caching

Now let’s change our web.config and add there the following configuration block under system.web section.

<caching>
<outputCache defaultProvider="AspNetInternalProvider">
  <providers>
   <add name="FileCache"
    type="MyCacheProviders.FileCacheProvider, MyCacheProviders"/>
  </providers> 
</outputCache> 
</caching>

This configuration block tells ASP.NET that there is output cache provider called FileCache available but we want to use default provider calles AspNetInternalProvider. We will change this block later.

Writing output cache provider

Now let’s start with output cache provider. From output cache configuration block you can see that Class1.cs in our class library must be renamed to FileCacheProvider.cs. Don’t forget also change the class name. Add reference to System.Web to class library and open FileCacheProvider.cs. In the beginning of this file add using line for System.Web.Caching namespace.

Our output cache provider class must extend OutputCacheProvider base class. This base class defines all methods that output cache providers must implement. Our output cache provider uses file system for cache storage. Output cache entries are serialized to binary format and back when writing and reading objects from files.

Classes for our custom output cache provider are here.

public class FileCacheProvider : OutputCacheProvider
{
    private string _cachePath;
 
    private string CachePath
    {
        get
        {
            if (!string.IsNullOrEmpty(_cachePath))
                return _cachePath;
 
            _cachePath = ConfigurationManager.AppSettings["OutputCachePath"];
            var context = HttpContext.Current;
 
            if (context != null)
            {
                _cachePath = context.Server.MapPath(_cachePath);
                if (!_cachePath.EndsWith("\\"))
                    _cachePath += "\\";
            }
 
            return _cachePath;
        }
    }
 
    public override object Add(string key, object entry, DateTime utcExpiry)
    {
        Debug.WriteLine("Cache.Add(" + key + ", " + entry + ", " + utcExpiry + ")");
 
        var path = GetPathFromKey(key);
 
        if (File.Exists(path))
            return entry;
 
        using (var file = File.OpenWrite(path))
        {
            var item = new CacheItem { Expires = utcExpiry, Item = entry };
            var formatter = new BinaryFormatter();
            formatter.Serialize(file, item);
        }
 
        return entry;
    }
 
    public override object Get(string key)
    {
        Debug.WriteLine("Cache.Get(" + key + ")");
 
        var path = GetPathFromKey(key);
 
        if (!File.Exists(path))
            return null;
 
        CacheItem item = null;
 
        using (var file = File.OpenRead(path))
        {
            var formatter = new BinaryFormatter();
            item = (CacheItem)formatter.Deserialize(file);
        }
 
        if (item == null || item.Expires <= DateTime.Now.ToUniversalTime())
        {
            Remove(key);
            return null;
        }
 
        return item.Item;
    }
 
    public override void Remove(string key)
    {
        Debug.WriteLine("Cache.Remove(" + key + ")");
 
        var path = GetPathFromKey(key);
 
        if (File.Exists(path))
            File.Delete(path);
    }
 
    public override void Set(string key, object entry, DateTime utcExpiry)
    {
        Debug.WriteLine("Cache.Set(" + key + ", " + entry + ", " + utcExpiry + ")");
 
        var item = new CacheItem { Expires = utcExpiry, Item = entry };
        var path = GetPathFromKey(key);
 
        using (var file = File.OpenWrite(path))
        {
            var formatter = new BinaryFormatter();
            formatter.Serialize(file, item);
        }
    }
 
    private string GetPathFromKey(string key)
    {
        return CachePath + MD5(key) + ".txt";
    }
 
    private string MD5(string s)
    {
        var provider = new MD5CryptoServiceProvider();
        var bytes = Encoding.UTF8.GetBytes(s);
        var builder = new StringBuilder();
 
        bytes = provider.ComputeHash(bytes);
 
        foreach (var b in bytes)
            builder.Append(b.ToString("x2").ToLower());
 
        return builder.ToString();
    }
}

With cached item we have to keep date and time that say us when cached object expires. I write simple CacheItem class that is marked as serializable (otherwise it is not possible to serialize it and therefore we cannot use binary formatter). CacheItem class is simple.

[Serializable]
internal class CacheItem
{
    public DateTime Expires;
    public object Item;
}

I made this class internal because we have no reason to show it to the world. We only use this class to store and restore cache entries with expiry date.

Some notes for FileCacheProvider class.

You must have appSetting called OutputCachePath that contains path to cache files folder. This path may contain ~ because in the case of web application this path goes through Server.MapPath() method.
File names are made of MD5 hashed cache entry key and .txt extension. You can use whatever file extension you like.
I am using binary formatter because it workes better for me than XmlSerializer (Add() method is used with internal classes that have no public constructor with empty argument list).
My code uses calls to Debug.WriteLine() method. When you run web application with Visual Studio then you can see output cache messages in output window. I found that it is very easy and powerful way to debug provider because these messages show you what is going on.

Preparing web application for testing

Let’s prepare now web application for testing. As a first thing we must make some changes to web.config. We have to add appSetting for cache folder and we have to make our file cache provider as default output cache provider. Here are XML-blocks for configuration.

<appSettings>
  <add key="OutputCachePath" value="~/Cache/" />
</appSettings>
 
<caching>
  <outputCache defaultProvider="FileCache">
    <providers>
      <add name="FileCache" type="MyCacheProvider.FileCacheProvider, MyCacheProvider"/>
    </providers>
  </outputCache>
</caching>

I expect you know where to put these blocks in web.config file. We have one more change to make before running our web application. Let’s turn output caching on for it. Although there should be providerName attribute available it doesn’t work yet. At least for my installation of Visual Studio 2010 and ASP.NET 4.0. Add the following line to Default.aspx.

<%@ OutputCache VaryByParam="ID" Duration="300" %>

I added VaryByParam for one reason: to test caching with different ID-s. Cache duration is 300 seconds (5 minutes). You can change to attributes if you like.

Testing output cache provider

Now let’s test our output cache provider. Run web application.

When you see default page in your browser check out output window in Visual Studio 2010. You should see there something like this.

Cache.Get(a2/default.aspx)    
Cache.Add(a2/default.aspx, System.Web.Caching.CachedVary, 31.12.9999 23:59:59)     
Cache.Set(a2/default.aspxHQNidV+n+FCDE, System.Web.Caching.OutputCacheEntry, 19.11.2009 12:20:56)

After refresh you should see something like this in output window.

Cache.Get(a2/default.aspx)    
Cache.Get(a2/default.aspxHQNidV+n+FCDE)     
Cache.Get(a2/styles/site.css)     
Cache.Get(a2/webresource.axd)     
Cache.Set(a2/styles/site.css, System.Web.Caching.OutputCacheEntry, 20.11.2009 12:17:09)     
Cache.Add(a2/webresource.axd, System.Web.Caching.CachedVary, 31.12.9999 23:59:59)     
Cache.Set(a2/webresource.axdHQNdVjnaEMMY-tPD2-oCbZFp7vHhVoQiB8SS98KHQMNKjUfs1FCDE, System.Web.Caching.OutputCacheEntry, 19.11.2010 12:17:09)     
Cache.Get(a2/webresource.axd)     
Cache.Get(a2/webresource.axdHQNdVqx_c6oOlTqymCAsGZh_8JA2FCDE)     
Cache.Add(a2/webresource.axd, System.Web.Caching.CachedVary, 31.12.9999 23:59:59)     
Cache.Set(a2/webresource.axdHQNdVqx_c6oOlTqymCAsGZh_8JA2FCDE, System.Web.Caching.OutputCacheEntry, 19.11.2010 12:17:10)

You see that second request caches some more data. There requests to FileCacheProvider are made by ASP.NET. During additional refresh some resources get cached and the other resources are removed from output cache.

Here is one simple screenshot fragment of file cache folder.

You can open these files to see what is inside them. You should see there cache items in binary format as binary formatter serializes them.

Conclusion

Although there are not much informative and guiding documentation about custom output cache providers I got mine working seemlessly well. I am not sure about some aspects of my provider and I will consult with Microsoft about my doubts. Of course, I will let you know if I get some valuable feedback from Microsoft.

The point of this posting was to show you how to write custom output cache provider. As we saw it is not something crucial or complex – we have to extend OutputCacheProvider class and implement some methods that store, edit and clear cached items. You can write your own implementations of output cache provider and keep your output cache wherever you like.

Sample solution

CacheProviderDemo.zip
Visual Studio 2010 Solution | Size: 181 KB

Daily tech links for .net and related technologies - November 18-20, 2009

SanjeevAgarwal — Thu, 19 Nov 2009 07:25:00 GMT

Daily tech links for .net and related technologies - November 18-20, 2009 Web Development SharePoint 2010 Public Beta Available For Download ASP.NET MVC 2 Beta Released – Phil Haack Using the JQuery dialog widget in a custom SharePoint web part – Charles Lee Using Microsoft’s Chart Controls In An ASP.NET Application: Adding Statistical Formulas Deep Tracing of Internet Explorer The AJAX UpdatePanel Is it your worst enemy? Web Design How to Build a Custom jQuery Tabs Plugin: New Plus Tutorial 50 Fresh...(read more)

Silverlight 4

Freakyuno — Thu, 19 Nov 2009 01:26:00 GMT

So the Silverlight platform has been quite interesting for some time in concept, and had some niche abilities that made it perfect for streaming media, or writing simple rich applications. Around the time of Silverlight 3 things started to get interesting; as the tools developed, and the platform matured!

Enter, Silverlight 4!

For those of you that have been waiting to adopt this technology into your own development lifecycle, I truly believe your wait is over. Difficult or downright impossible things inside Silverlight applications have now been overcome. Limitations such as Printing, Local File Access, mouse scroll wheel support, and out of browser experiences.

There has been a huge stir of Silverlight 4 activity at PDC09 this year (where they handed out free multi-touch windows 7 laptops to every attendee!!!) - yea, I know. And some very cool demo's being displayed. Watching the live stream (http://microsoftpdc.com/) during conference hours, left me intrigued enough to want to fire up and start to prototype some applications on the Silverlight 4 platform.

As I went looking, it took me a little longer than I would have liked to find all the things I needed to get started and give it an accurate test drive, so below is the link (link aggregation) on how to get started.

http://silverlight.net/getstarted/silverlight-4-beta/#tools

I know...the silverlight site. Unfortunatly as a developer and MVP I'm used to finding what I need published under the MSDN downloads section, linear thinking FTW.

Dont forget as you get started to pop over to the videos located here: All VERY good information

http://silverlight.net/learn/videos/silverlight-4-beta-videos/

I'm in process of wiring up an artist (photo) gallery currently, using Silverlight 4, RIA Services, and the new Toolkit, using Visual Studio 2010 of course. So far I'm VERY impressed with the platform and where it's gone - it's finally at the point where I just dont feel like there's anything missing as previously.

Good luck!

Introduction to the Reactive Framework Part V

podwysocki — Wed, 18 Nov 2009 22:48:00 GMT

In the previous post of the Introduction to the Reactive Framework series, we covered how to create new IObservable<T> instances, either from scratch or from existing sequences. What this allowed us to do was turn an operation which was previously interactive, such as iterating over a collection, to a reactive, where I could have multiple listeners reacting to the same collection concurrently. This has nice implications for allowing us to scale our application in interesting ways. This time, let’s take another angle on making asynchronous programming easier.

Let’s get caught up to where we are today:

From Asynchronous To Observables

In the first post in the series, we talked about some of the problems we face with asynchronous programming today. For example, for any given operation, how do we handle exceptions, or handle cancellation, or even manage the lifetime of resources? Let’s take a look at the story of asynchronous programming today. For example, let’s take the fairly straight forward approach of sending a tweet in Twitter, but with the added pressure of non-blocking calls for all IO operations. Now we took an example which should have been straight forward, and now it looks something like this anti-pattern:

var request = WebRequest.Create("http://twitter.com/statuses/update.xml");
request.Credentials = new NetworkCredential("foo", "bar");
request.Method = "POST";

request.BeginGetRequestStream(rsAr =>
{
    var requestStream = request.EndGetRequestStream(rsAr);
    var tweet = HttpUtility.HtmlEncode("status=Hello from an async method #bacon");
    var bytes = Encoding.UTF8.GetBytes(tweet);
    requestStream.BeginWrite(bytes, 0, bytes.Length, beginWriteAr =>
    {
        requestStream.EndWrite(beginWriteAr);
        request.BeginGetResponse(responseAr =>
        {
            var response = request.EndGetResponse(responseAr);
            var responseStream = response.GetResponseStream();

            var readBuffer = new byte[response.ContentLength];
            responseStream.BeginRead(readBuffer, 0, readBuffer.Length, readAr =>
            {
                var read = responseStream.EndRead(readAr);
                var readText = Encoding.UTF8.GetString(readBuffer);
                ResultsText.Text = readText;
            }, null);
        }, null);
    }, null);
}, null);

Not only is this code an absolute mess, but it has a number of bad practices, including not handling cleanup of our resources, as well as not handling exceptions, cancellation checking, or even checking if our buffer was completely read. Adding those constraints to the above code would make it a bit more unreadable. The situation we run into is that programming in a non-blocking fashion has caused all sorts of heartache where we become so wrapped up in the non-blocking code that we lose sight easily of the domain logic we should have been interested in, in the first place.

I’ve covered in the past that with F# async workflows, solving this is a rather easy task and that kind of rich functionality has been unavailable to C# developers directly. But, with the Reactive Extensions for .NET, we have the ability to also take advantage of composable asynchronous actions as well. So, where do we get started?

Let’s take a simple example of creating a function and then invoking it asynchronously.

Func<int, int, int> add = (x, y) => x + y;

add.BeginInvoke(3, 4, ar =>
{
    var result = add.EndInvoke(ar);
    Console.WriteLine(result);
}, null);

Many asynchronous methods in .NET are written in this way that their signature has a BeginXXX and EndXXX where the XXX is the method name that is being executed asynchronously. The Begin takes the arguments to execute the method, an AsyncCallback which is an action that takes an IAsyncResult and returns nothing, and finally object state. The End method takes the IAsyncResult which is passed in from the AsyncCallback in order to retrieve the value of the asynchronous call.

void BeginXXX(args, AsyncCallback, state);

Value EndXXX(IAsyncResult);

Luckily, the Reactive Extensions give us a couple of ways to make this happen. First, let’s take an existing method such as the System.IO.Stream.WriteAsync. In this example, we’ll create an extension method which allows us to turn this asynchronous method into a IObservable<T>.

public static IObservable<Unit> WriteAsync(
    this Stream stream, 
    byte[] buffer, 
    int offset, 
    int count)
{
    return Observable.FromAsyncPattern<byte[], int, int>(
        stream.BeginWrite,
        stream.EndWrite)(buffer, offset, count);
}

Because the Write method returns void, we have issues in C# as we cannot have a generic type as being void. To get around this, much like F#, the Reactive Extensions introduced the Unit type to express that we have no value. Quite frankly this is the way I think C# should have been to allow for this and not need these unnecessary hacks. Anyways, the Observable class has a method called FromAsyncPattern which takes in both the BeginXXX and EndXXX and returns a Func delegate that takes the arguments required to execute it. In this case, the Observable.FromAsyncPattern returns a Func which takes the buffer, offset and count and returns an IObservable<Unit>.

There is also another way in that we can take our existing add function from above and using an extension method called ToAsync, can also work the IObservable magic.

Func<int, int, int> add = (x, y) => x + y;
Func<int, int, IObservable<int>> obvervableAdd = add.ToAsync();

IObservable<int> result = from added in obvervableAdd(3, 4)
                          select added;
IDisposable sub = result
    .SubscribeOnDispatcher()
    .Subscribe(added => Results.Text = added.ToString());

In this instance, we took our existing add method and then turned it into an asynchronous method by using the ToAsync extension method. That returns a Func delegate which takes our two arguments and returns an IObservable<int> which contains our asynchronous result. We can then take our new observableAdd and execute it inside of a LINQ statement, then subscribe to it on the Dispatcher thread in order to rid ourselves of synchronization context issues in WPF.

Going back to our original example here, let’s see how we might follow some of the ideas presented here into creating a way to send a tweet completely in a LINQ statement.

var tweetObservable =
    from request in 
        CreateWebRequest(
            "http://twitter.com/statuses/update.xml", 
            userName, 
            password, 
            "POST")
    let tweet = HttpUtility.HtmlEncode("status= Hi! #bacon")
    let buffer = Encoding.UTF8.GetBytes(tweet)
    from _ in request.SetContentLength(buffer.Length)
    from requestStream in request.GetRequestStreamAsync()
    from __ in requestStream.WriteAsync(buffer, 0, buffer.Length)
    from response in request.GetResponseAsync()
    let responseStream = response.GetResponseStream()
    let reader = new StreamReader(responseStream)
    select reader.ReadToEnd();
    
var tweetsObservable = tweetObservable
    .Throttle(TimeSpan.FromMinutes(3))
    .Repeat(25);

We can create extension methods to the WebRequest for GetRequestStream and GetResponse to enable observable behavior via the Begin/End methods that the WebRequest exposes. As well, we can extend the System.IO.Stream as well to both write and read streams asynchronously. We have other more trivial methods such as setting the content length and creating a web request as an observable as well, and in order to do that was covered in the previous post using the Observable.Create method. After we create this IObservable value, we can then throttle it to every three minutes and to repeat 25 times. One concern we might have is around the resource usage and ensuring the cleanup, and we’ll cover that next time.

Conclusion

As I’ve stated before, the LiveLabs Reactive Framework gives us the ability to harness reactive programming and treat events as the first class citizens they should have been using LINQ expressions and other standard LINQ combinators. Still, there is much to cover in this series with the standard LINQ combinators, the monadic heritage of this solution as well as managing resources, and turning Tasks Observables.