Fredrik Normén

WCF RIA Services – What you need to know when creating DTO/Presentation Model

2009-11-20T16:37:14Z

Note: This is based on the WCF RIA Services Beta, so the code in this post can change in a future release of the framework.

When defining DTO or a “Presentation Model” (Not the Presentation Model pattern by Martin Fowler, a model suited for presentation purpose, not all entities are) there are things you may want to now. The following is an simple DTO:

public class Order
{
     [Key]
     public int OrderID { get; set; }

     public IEnumerable<OrderRow> Rows { get; set; }
}

The KeyAttribute is used to mark one or more properties to be the unique identifier of the object. As you can see the OrderID is a public property with both set and get methods. In some cases we want to have the OrderID as “read-only” and one or all more properties “read-only”. To make sure a property is “read-only” we can for example make sure the set method is internal:

public class Order
{
     [Key]
     public int OrderID { get; internal set; }

     public IEnumerable<OrderRow> Rows { get; set; }
}

We can also remove the set to make it “read-only”. The generated code on the client-side will now have an Order class where the OrderID is “read-only”, BUT! It still has the set method. It’s first at runtime we get an exception when we try to set a “read-only” property to a value. In this case it can be too late or results in bugs. Here is the client-side version of the generated OrderID property:

[DataMember()]
[Editable(false)]
[Key()]
[ReadOnly(true)]
public int OrderID
{
    get
    {
         return this._orderID;
    }
    set
    {
          if ((this._orderID != value))
         {
              this.ValidateProperty("OrderID", value);
              this.OnOrderIDChanging(value);
              this._orderID = value;
              this.RaisePropertyChanged("OrderID");
              this.OnOrderIDChanged();
          }
     }
}

To make a whole DTO “read-only” (still set methods will be generated, so we will only know that a property is “ready-only” at runtime if we try to give it a value) we can avoid adding the Update operation to our DomainService for that DTO.

When it comes to IEnumerable types (including data structures inherit from the IEnumerable interface) they will by default be “read"-only”, in a way where we can’t Add objects to it. To make it not “read-only” we need to add a Add operation of the type the collection takes to our DomainService, for example:

public void AddOrderRow(OrderRow row)
{
}

If you don’t add the Add operation and no Update operation for the OrderRow, we can still on the client side change the OrderRow returned from the collection. So have that in mind. By default in C# if we return an IEnumerable<T> as in the code example in this post, it’s read-only, we can’t add or remove or do anything to an IEnumerable interface. It will be read only one the server-side if we create an instance of the DomainService, but not on the client-side. On client-side it will be generated to a EntityCollection<T>. Sadly an interface with a lot of methods that we maybe don’t even want the user to see, for example Remove or Add if we only want to return a “read-only” collection. We can have the Add and Remove disabled by not adding the Add or Remove operation to the DomainService for the type the collection holds, but still it’s available for the user on the client-side, and they can use them. If they don’t test the code or run the part where they will use them, it can results in bugs. It’s first at runtime we get an exception that we can’t use them.

When using a DTO we can’t add a constructor which takes parameters, only the default will be generated on the client side, and is also needed. So if we want to use an immutable class, we can’t by just write:

public class Order
{
     public Order(int orderID)
     {
        //..
     }

    //..
}

The reason why we can’t the constructor on the client-side, is that it will contain code which will not be added to the client-side Order class. So to make it possible to use a constructor, we can use the .shared feature:

Order.shared.cs

public partial class Order
{
     public Order(int orderID)
    {
          this.OrderID = orderID;
    }
}

Note: Remember to make the main DTO partial and you have to add the default constructor also.

You can’t never make the DTO immutable and “read-only”, because the set methods are always added to the client-side generated class. The way it’s “read-only”, is during runtime.

If you want a testable DTO where validation should be part of the test (some validation are core concerns and business logic), you can forget about it. BUT! Logic added to a DTO, will not longer make it a DTO. WCF RIA Services uses Annotation to add validations, which will take place on the client-side and server-side. If you add validation code inside of a object you want to expose through a DomainSerivice, it will stay on the server-side, so if you add a validation annotation also, you break DRY (Don’t repeat yourself), but you can write test that will test the object on the server-side. To make sure you don’t repeat yourself and don’t run the same validation twice on the server-side, you need to handle the validation by your own. A god place to do it is in the ViewModel on the client side, for example with IDataErrorInfo and INotifyDataErrorInfo interface. If we only could have partial properties, we could used the .shared feature to add our own validation to the .shared files and make sure we share our validation on the server- and client-side. BUT! Remember a DTO with logic added, is no longer a DTO, it’s an Object.

When you return the IEnumerable<T> from your Query method, the Query passed from the client-side down to the DomainService, will only take place after the data is returned. So if your query method retrieves thousands and millions of objects, it will always do that. In this case it would be advisable to use the IQueryable<T> or interpret the Query passed down to the DomainSerivce to filter your data. If you decide to return a IQueryable<T>, the query will still be executed after the Query method is executed. So what you have to do is to make sure your data access components supports the use of IQueryable<T>, Entity Framework and Linq 2 SQL does, also nHib with the LINQ support I guess. But, have in mind that you can’t execute the query, just pass the IQueryable<T> along to the next layers. If you ask me, I wouldn’t do that, it will result in a deferred execution and I will “sort” of lose my control where the query against my data source will take place.

If you want to know more about associations with DTO, check my previous post: http://weblogs.asp.net/fredriknormen/archive/2009/11/20/wcf-ria-services-and-dto-with-association.aspx

If you want to know when I publish new blog posts, or just follow my life, you can find me on twitter: http://www.twitter.com/fredrikn

WCF RIA Services and DTO with association

2009-11-20T09:46:54Z

This post will be short, I notice that some people are asking about how to send an object graph which will include an association to other objects. First of all, be careful with the distribution of an object graph, wrong design can affect performance in a way that to much data is passed over the wire.

Here is an simple Order class, this class has OrderRows:

public class Order
{
    [Key]
    public int OrderID { get; set; }

    public IEnumerable<OrderRow> Rows { get; set; }
}


public class OrderRow
{
    public int OrderID { get; set; }

    [Key]
    public int OrderRowID { get; set; }

    public string Name { get; set; }
}

Here is my DomainService where I have specified a query method for the Orders:

[EnableClientAccess()]
public class DomainService1 : DomainService
{
        public IEnumerable<Order> GetOrders()
        {
            return new List<Order>()
                        {
                            new Order()
                            {
                                OrderID = 0,
                                Rows = new List<OrderRow>()
                                        {
                                            new OrderRow() { OrderID = 0, Name = "Row 0", OrderRowID = 0 },
                                            new OrderRow() { OrderID = 0, Name = "Row 1", OrderRowID = 1 }
                                        }
                            },
                                                        new Order()
                            {
                                OrderID = 1,
                                Rows = new List<OrderRow>()
                                        {
                                            new OrderRow() { OrderID = 1, Name = "Row 0", OrderRowID = 0 },
                                            new OrderRow() { OrderID = 1, Name = "Row 1", OrderRowID = 1 }
                                        }
                            }

                        };
        }
}

Note: I just fake the loading of data in the GetOrder query method, normally I should of course use Entity Framework 4.0, nHibernate or other ORM.

If we now load the Orders from the client, the Order object we will get will not include the Rows property of the order. So the association will not be passed with the Order object. To include an association we need to add the IncludeAttribute, and also the AssociationAttribute:

public class Order
{
        [Key]
        public int OrderID { get; set; }

        [Include]
        [Association("Order_OrderRows", "OrderID", "OrderID")]
        public IEnumerable<OrderRow> Rows { get; set; }
}

The AssociationAttribute is needed to specify the association between the Order and the OrderRows. The first argument is only a name of the association, the second is the main key, in this case the Order’s OrderID key, the last argument is the associated objects key which holds the value of the Order’s OrderID, in this case the OrderRow’s OrderID. The Include attributes make sure the Rows property will be included when the object is passed to the client. I hope some of you find this post useful.

If you want to know when I publish some new posts, or just follow my life, you can find med on twitter: http://www.twitter.com/fredrikn

Silverlight 4 Commanding enables ViewModels

2009-11-18T23:41:00Z

One feature out of many really great feature shipped with Silverlight 4 Beta, is Commanding. With Commanding we can use the MVVM (Model View View Model) Pattern. Commanding is something that WPF has and preview Silverlight doesn’t. Commanding can only be used on ButtonBase controls and Hyperlink control at the moment, and will only be executed by the Click event. In this post I’m going to show how you can use the new Commanding feature and create use the MVVM pattern in Silverlight 4. Here is my simple UI:

I have a TextBox and a Button. The ViewModel will represent this view but in code. The main reason to use a ViewModel is because of separation of concerns. The complex UI logic is moved from the View into a class (the ViewModle). The ViewModel for the View above will look like this:

public class CustomerViewModel : INotifyPropertyChanged
{
     public event PropertyChangedEventHandler PropertyChanged;

     private string _firstName;

     public string FirstName
     {
         get { return _firstName; }
         set
         {
             //Validation code
            _firstName = value;

            //NotifyPropertyChange
         }
     }

     public ICommand Save
     {
        get { return new SaveCommand(this); }
     }
 }

The FirsrtName property represents the TextBox in the View, the Save property is the Command that should be executed when the Save button is clicked. As you can see the Save member is a property which will return a ICommand, in this case the SaveCommand. Here is the SaveCommand class:

public class SaveCommand : ICommand
{
    private CustomerViewModel _view;

    public SaveCommand(CustomerViewModel view)
    {
        _view = view;
    }

    public bool CanExecute(object parameter)
    {
            return true;
    }

    public event EventHandler CanExecuteChanged;

    public void Execute(object parameter)
    {
         //Do something like saving the Customer
     }
}

The SaveCommand implements the ICommand interface which has three members, the CanExecute property, CanExecuteChanged event and the Execute method. The CanExecute return true or false if the command can be executed. The method takes one parameter, this parameter comes from the CommandParamter attribute added to the Button or Hyperlink. The Execute method, is the method that will be executed if the Command can be executed, it’s where you can add your code to perform something when the user clicks the Save button, for example using WCF RIA Services to save the Customer. When the Command and the ViewModel is in place, we can just bind the ViewModel to a DataContext and then use normal Binding to bind to our ViewModel, like this:

<UserControl x:Class="SilverlightApplication3.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:vm="clr-namespace:SilverlightApplication3">
    <UserControl.Resources>
        <vm:CustomerViewModel x:Name="myViewModel"/>
    </UserControl.Resources>
    <Grid x:Name="LayoutRoot" DataContext="{StaticResource myViewModel}">
        <TextBlock  Text="First Name:" ... />
        <TextBox Text="{Binding FirstName, Mode=TwoWay}" .../>
        <Button CommandParameter="test" Command="{Binding Save}" Content="Save"  ..." />
    </Grid>
</UserControl>

As you can see the CustomerViewModel is added to the UserControl’s Resources and then added to the LayoutRoot’s DataContext. The TextBox is bind to the FirstName property of the ViewModel and the Command attribute of the Button is bind to the Save property. I just added the CommandParameter to the code so you can see how it can be used to pass a parameter into the CanExecute and Execute method.

I hope the Silverlight team will also add a way to specify an ViewModel method to any kind of events and where we don’t need to implement the ICommand interface. The Commanding often results in many Command classes.

Is WCF RIA Services ready for the Enterprise?

2009-11-18T20:11:00Z

Today Microsoft released the WCF RIA Services Beta, it’s now on top of WCF and by default uses binary data end points and data contract serialization. By using binary data end points we will get better performance and make the data sent over the wire smaller (The other preview versions uses pure JSON). WCF RIA Services is a great framework for Rapid Application Development (RAD) of 2-tier applications. Based on the new changes to the WCF RIA Services it’s defiantly ready for the Intranet and small applications, but how about the Enterprise. First of all if you uses the Entity Framework or Linq to SQL Domain Services, it’s not ready for the Enterprise and will never be, IMO, because when we use it it distribute DAL types to the client. They are useful for small data driven applications. BUT! WCF RIA Services with the DTO (Data Transfer Object) support will make it closer to be ready for the Enterprise, but is that enough?

It’s complex to build RIA (Rich Internet Application) and require a lot of plumbing. This is something WCF RIA Services is trying to solve. Just remember there is a reason why things are complex, and what every framework developers are trying to do, is to hide the complexity by adding a new level of abstraction. The thing is, the complexity is still there. At first I was skeptic about WCF RIA Services, but it was because the very early previous wasn’t that good, it was ok, good ideas but works had to be done. Now after almost 2 years it starts to look like something promising.

I have notice several of developers using .WCF RIA Services and because it’s so easy to use, they seems to forgot about the network. What the WCF RIA Services Team have struggle with, is to make sure developers should be aware of the network. I know that even how much they try, some developers will use it in a wrong way. That is nothing they can do anything about. But is that so bad? NO! It gives the people that use it in the right way job opportunists ;)

I wrote that WCF RIA Services with its DTO support will make it closer to be ready for the Enterprise and the uses of EF and L2S Domain Services are not a good choose when it comes to build Enterprise RIA. There are actually one advantage of using the EF and L2S DomainServices, and that is the way of passing a query from the client to the server. The query will be used when EF and L2S are querying the database (as far as I know, I hope it does at least ;)). It will results in less data sent from the data source. When using DTO the query will take place after we retrieve all the data from our DomainService query methods. But still on the server. But the good thing is that there is a solution to make sure the query also takes place when we query our data source and that is by overriding the DomainService Query method, it has the description of the query passed from the Client. But we had to interpret it and transform it to a query which can query our domain model.

It looks like developers loves the data annotations added to WCF RIA Services. The validation part is great when it comes to the uses of EF and L2S Domain Services, because the DAL types are generated from the tools (hmm, thinking of the Devils is in the tools ;)), and it’s “hard” to add validation to it. In that case with WCF RIA Services we can use annotation to add validations, which will be available both on the client and the server. Isn’t that great? DTO also support validations buy adding annotations. You have to have in mind, that this validation can’t be tested with Unit Test, it’s the Framework which will execute it. But you also have to remember that DTO is just what is says an object which transfers data. On the client-side we may use a ViewModel which will handle the validation instead.

Back to the main question, is WCF RIA Services ready for the Enterprise? If I say Yes, it may be a lie, if I say No, it’s definitely a lie. I think it’s ready, or at least I would give it a try. I think the team have made a great framework, I will with no doubt recommand it to others.

How to create a Module based Silverlight application (Part 1)

2009-11-16T22:48:04Z

When building RIA (Rich Internet Application) with Silverlight, it’s important to make sure the Silverlight application is loaded as fast as possible. Users don’t like to see a splash screen for several seconds or minutes, they want an application to start directly. One way to make a Silverlight app load fast, is by minimizing the XAP file, this can be done by not adding to much images, videos or other files to the Silverlight application project. If we have a large application, we can also split the application into small “modules”, for example assemblies or .XAP files. We can then load them on demand when they are needed. The base application can be kept small and be the core engine for the other modules. In this first part of my blog post I will add some examples how we can split our Silverlight applications into modules, and load them on demand asynchronous. The next part will be about how to use MEF (Managed Extensibility Framework) to create module bases Silverlight application.

The core components to load assemblies or .XAP on demand is the WebClient class and the AssemblyPart class.The following code will demonstrate how we can use the WebClient and AssemblyPart to load a Silverligth Class Library located in the ClientBin folder of our Silverlight Web host:

var webClient = new WebClient();

webClient.OpenReadCompleted += webClient_OpenReadCompleted;
webClinet.OpenReadAsync(new Uri("Module1.dll", UriKind.Relative));

The Module1 Silverlight Class Library can contains Silverlight User Controls and classes etc.

In this example I have added a Child Window (MyChildWindow) and a Silverlight User control (MyModule) to the Silverlight Class Library. When the project is build, the .xaml will be included into the cliss librarie’s assmebly. The next step is to handle the webClient_OpenReadCompleted event, this event will be trigged when the WebClient have loaded the specified assembly. The following code will demonstrate how the MyModule is added to a Grid dynamically:

void webClient_OpenReadCompleted(object sender, OpenReadCompletedEventArgs e)
{
    AssemblyPart assemblyPart = new AssemblyPart();
    Assembly assembly = assemblyPart.Load(e.Result);

    var userControl = assembly.CreateInstance("Module1.MyModule") as UserControl;

    if (userControl != null)
        LayoutRoot.Children.Add(userControl);
}

The AssemblyPart is used to load an Assembly out from a Stream (the OpenReadCompletedEventArgs’s Result property returns the Stream which the WebClient has loaded, in this case a Stream of the Module1.dll). When an Assembly is loaded the Assembly’s CreateInstance method can be used to create an instance of a type (Namespace.ClassName) located in the assembly. The User Control added to the Silverlight Class Library exists in the namespace Module1 and the User Controls name is MyModule. Because the MyModule inherits from the class UserControl we can simply cast the created instance to a UserControl and then add it to the Grid by using the Children.Add method.

Note: If we have added references to other assemblies within the Silverlight Class Library, we also need to load them, or the main Silverlight application need to have a reference to them. If not, we will get an exception about a missing assembly.

If we want to create a package with all required assemblies for a “module”, we can for example use a .XAP file. The .XAP files contain a AppManifest.xaml file, which contains information of the files inside of an .XAP file. Here is an example of a .XAP files content:

Note: A .XAP file can be explored by changing the .XAP to .ZIP, it’s basically a normal zip file.

The following is the content of the AppManifest.xaml file in the above .xap file:

<Deployment ...>
  <Deployment.Parts>
    <AssemblyPart x:Name="Module1XAP" Source="Module1XAP.dll" />
    <AssemblyPart x:Name="ModuleInfra" Source="ModuleInfra.dll" />
    <AssemblyPart x:Name="System.ComponentModel.DataAnnotations" Source="System.ComponentModel.DataAnnotations.dll" />
    <AssemblyPart x:Name="System.Windows.Controls.Data.DataForm.Toolkit" Source="System.Windows.Controls.Data.DataForm.Toolkit.dll" />
    <AssemblyPart x:Name="System.Windows.Controls.Data.Input" Source="System.Windows.Controls.Data.Input.dll" />
    <AssemblyPart x:Name="System.Windows.Controls" Source="System.Windows.Controls.dll" />
    <AssemblyPart x:Name="System.Windows.Data" Source="System.Windows.Data.dll" />
  </Deployment.Parts>
</Deployment>

We can with the WebClient load the .XAP file and get the AppManifest.xaml from the loaded stream by using the StreamResourceInfo class and the Application’s GetResourceStream method. After that we can get the AssemblyPart from the AppManifest file and load them all. Every assembly we have as an reference will be included in the .XAP file. Here is an example where three Silverlight Application projects are added to a Solution. The Module1XAP and Module2XAP are the modules, and the ModuelBaseSL is the main Silverlight application. The main Silverlight application will load the Modules on demand. When building the solution, the Silverlight applications will be packaged into .XAP file, in this example, Module1XAP.xap, Module2XAP.xap and ModuleBaseSL.xap and will be added to the ClientBin folder.

There is no API yet out of the box which will help us loading a package (not while this post is written), so we need to write code that will do it. In this example I have created a class which will help us load a module.

public class ModuleLoader
{

   public void LoadModule(Uri uri, Action<AsyncCompletedEventArgs, AppModule> moduleDownloadCompleted)
   {
      WebClient webClient = new WebClient();
      webClient.OpenReadCompleted += webClient_OpenReadCompleted;

      webClient.OpenReadAsync(uri, moduleDownloadCompleted);
   }

   void webClient_OpenReadCompleted(object sender, OpenReadCompletedEventArgs e)
   {
      // ...
   }

The LoadModule method will take an Uri to the .XAP file and also a callback method when the module is loaded.

void webClient_OpenReadCompleted(object sender, OpenReadCompletedEventArgs e)
{
    var appModule = GetModule(e.Result);

    var completedCallback = e.UserState as Action<AsyncCompletedEventArgs, AppModule>;

    if (completedCallback != null)
       completedCallback(new AsyncCompletedEventArgs(e.Error, e.Cancelled, null), appModule);

The following code will create a StreamResourceInfo object. By using the Application’s GetResourceStream method, we can easy get a file out from the Stream. The following code “picks” out the AppManifest.xaml. The code will also load all assemblies located in the .XAP file.

private AppModule GetModule(Stream loadedModuleStream)
{
   AppModule appModule = null;

   StreamResourceInfo moduleStreamInfo = new StreamResourceInfo(loadedModuleStream, null);

   StreamResourceInfo manifestStreamInfo = Application.GetResourceStream(
                                                                moduleStreamInfo,
                                                                new Uri("AppManifest.xaml", UriKind.Relative));

   using (XmlReader reader = XmlReader.Create(manifestStreamInfo.Stream))
   {
       if (reader.ReadToFollowing("AssemblyPart"))
       {
          do
          {
             string source = reader.GetAttribute("Source");

             if (source != null)
             {
                StreamResourceInfo sri = Application.GetResourceStream(
                                                                moduleStreamInfo,
                                                                new Uri(source, UriKind.Relative));

                 var assemblyPart = new AssemblyPart();
                 var assembly = assemblyPart.Load(sri.Stream);
                            
                 if (appModule == null)
                     appModule = GetModuleInformation(assembly);
             }
         }
         while (reader.ReadToNextSibling("AssemblyPart"));
     }
  }
  return appModule;
}

The AppModule is a class that will hold all information about a module, such as the Name of the module and the View (UserControl) that should be the startup View for the module. The method GetModuleInformation will check if there is any UserControl inside of the assembly which has a specific Attribute (ModuleViewAttribute), if there is, it will be the startup View for the module. It would be easy to use a Metadata class or file with the information about the Module. But the code in this post is only used to demonstrate how to load modules and kept relative simple.

public class AppModule
{
     private UserControl _mainView;
     private string _name;

     public string Name
     {
        get { return _name; }
        internal set { _name = value; }
     }


     public UserControl View
     {
        get { return _mainView; }
        internal set { _mainView = value; }
     }
}

public class ModuleViewAttribute : Attribute
{
    public ModuleViewAttribute()
    {
    }

    public ModuleViewAttribute(string name)
    {
        this.Name = name;
    }

    public string Name { get; set; }

 }

The following shows a UserContorl with the ModuleViewAttribute:

[ModuleView(Name = "My XAP Module 2")]
 public partial class MainPage : UserControl
{
     public MainPage()
    {
        InitializeComponent();
    }
}

The following code will load two different .XAP files and add TabItems to a Tab control in Silverlight 3:

public partial class MainPage : UserControl
{
     public MainPage()
     {
         InitializeComponent();

         ModuleLoader loader = new ModuleLoader();

         loader.LoadModule(
                           new Uri("Module1XAP.xap", UriKind.Relative),
                           (e, mod) =>
                           {
                              modulesTabContron.Items.Add(
                                              new TabItem() { Content = mod.View, Header = mod.Name });
                           });

         loader.LoadModule(
                           new Uri("Module2XAP.xap", UriKind.Relative),
                           (e, mod) =>
                           {
                             modulesTabContron.Items.Add(
                                             new TabItem() { Content = mod.View, Header = mod.Name });
                           });
     }
}

<UserControl xmlns:controls="clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls"  x:Class="ModuleBaseSL.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
    mc:Ignorable="d" d:DesignWidth="640" d:DesignHeight="480">
  <Grid x:Name="LayoutRoot">
        <Grid.RowDefinitions>
            <RowDefinition Height="100"/>
            <RowDefinition Height="*"/>
        </Grid.RowDefinitions>

        <controls:TabControl Grid.Row="0" x:Name="modulesTabContron"></controls:TabControl>
      
    </Grid>
</UserControl>

Note: The code in this post is only used for a demonstration, some refactoring need to be done etc.

I hope this blog post have given you some ideas about how you can create a module based Silverlight application.

If you want to know when I publish a blog post or other information, you can follow me on twitter: http://www.twitter.com/fredrikn

Fluent-API to add ActionFilters to Controllers – ASP.NET MVC Part 3

2009-11-10T18:04:00Z

The latest source code for my Fluent-API to add Action Filters to Controllers is no available here. If you haven’t read about my test project, you can find the other posts here:

Fluent-API to add ActionFilters to Controller in ASP.NET MVC

Fluent-API to add ActionFilters to Controllers – ASP.NET MVC Part 2

To use the Fluent-API, you only need to change the Default Controller factory to the ActionFilterConfigControllerFactory, then just configure your controller within the Global.asax. Here is an example where the OutputCache is added to two Action methods, and also an example how to add one or many ActionFilters to one Action method. You can also add Action Filters on a Controller level so they will be used on every Action methods. If you also want a specific Action Filter for all Controllers, you can just Configure the Controller type and add the filters to it.

protected void Application_Start()
{
            ControllerBuilder.Current.SetControllerFactory(typeof(ActionFilterConfigControllerFactory));

            RegisterRoutes(RouteTable.Routes);
            RegisterActionFilters();
}

        
private void RegisterActionFilters()
{
            // Add OutputCache to all Action Methods for all Controllers which inherits the Contoller class
            //ConfigActionFilter.ConfigController<Controller>()
            //  .AddFilterToController(new OutputCacheAttribute() { Duration = 10, VaryByParam = "none" });

            ConfigActionFilter.ConfigController<HomeController>()
                            .AddFilterToController(new HandleErrorAttribute())
                            .AddFilterToActions(new OutputCacheAttribute() { Duration = 10, VaryByParam = "none" },
                                                c => c.About(),
                                                c => c.Index());

            ConfigActionFilter.ConfigController<AccountController>()
                              .AddFilterToAction(c => c.LogOn(), 
                                                 new HandleErrorAttribute(), 
                                                 new MyCustomFilterAttribute());
}

This is as I wrote only a test project, and I do like the idea to add cross-cutting concerns by not adding attributes directly to the Controllers source code.

.NET 4.0 is so Lazy

2009-11-10T13:10:00Z

With .NET 4.0 there is a new class added to the System namespace called Lazy<T>. This class is what the name says, lazy. Here is an example where Lazy is used:

var lazy = new Lazy<IList<OrderRow>>(
                                () =>
                                {
                                        var rows = //get order rows;
                                        return rows;
                                });

var rows = lazy.Value;

The Lazy<T>’s constructor can take a Func<T> as an argument, the function passed as an argument to the contractor will first be invoked when the Value property of the Lazy<T> class is used, but not invoked the next time the Value property is used. The code above will first execute the function passed as an argument when the we request the value of the Lazy<T>, the returned value of the function will be cached. The next time Value is used, the function will not be invoked, instead the cached value will be returned. This class can for example be used when we want some kind of Lazy Loading.

I’m on twitter: http://www.twitter.com/fredrikn

Fluent-API to add ActionFilters to Controllers – ASP.NET MVC Part 2

2009-11-07T09:39:00Z

I’m working with my Fluent-API for adding Action Filters to Controllers and Action Methods. In my previous post, I created a new instance of each Action Filter and add it to an Action Method or Controller. Based on how the Action Filters are often implemented they don’t or shouldn’t keep any state, so in that case I don’t need to create a new instance of the same Action Filter with the same configuration for each Action Method I want to add it to. I also want to have an option to have a better overview of which Action Filter is added to which Controllers and Action Methods. I have added to methods, AddFilterToControllers and AddFilterToActions:

            .AddFilterToActions(new HandleErrorAttribute(),
                                c=> c.About(),
                                c=> c.Index());
            .AddFilterToActions(new OutOfMemoryException(),
                                c=> c.About());
             .AddFilterToActions(new HandleErrorAttribute() { ... },
                                c=> c.MyMethod());

The code is not yet available due to some more changes and testing.

Fluent-API to add ActionFilters to Controller in ASP.NET MVC

2009-11-07T00:45:00Z

Note: The name of the classes and the methods are just temporary and may change, I’m so bad when it comes to naming classes and methods. The source code is simple and haven’t done so much refactoring etc. Just wanted to see if I could get it to work, so please have that in mind.

EDIT: Working with new methods to get a better overview of Action Filters added and also reusing AcitonFitlers, you can read about it here.

When we create controllers for our ASP.NET MVC application we can also add Action Filters to handle cross-cutting concerns, like Authorization, Error handling and Caching etc. If we want to have Error handling on every controller we need to add the HandleErrorAttribute to all controllers, like this:

[HandleError] 
public MyController : Controller 
{ 
}

By adding Action Filters by using attributes it can be hard to get a good overview of which controllers that has the HandleErrorAttribute. The same regarding Action methods, for example if we have a lot of Controllers and want to see see all the Action methods that uses for example the OutputCacheAttribute, we need to go through all Controllers and methods, there is no easy way to get a simple overview of them.

Adding Action Filters to Action methods and Controllers also add some sort of “dependency” to action filters (not a big deal, though). I decided to try a way to add Action Filters to Controllers and Action methods in one single file, so I could get a better overview of which Controllers and Action methods uses what ActionFilter etc. Because ActionFitlers contains cross-cutting concerns I also wanted to move it away as attributes from the Controllers and Action methods so developers don’t need to care about the cross-cutting concerns during the creation of Controllers. instead add them later.

I sort of used a Fluent-API for the configuration of ActionFilters, and the configuration is added to the Global.asax’s Application_Start event. Here is an example where I add the ErroHandler Action Filter to all Controllers Action Methods:

ConfigActionFilter.ConfigController<Controller>() 
                  .AddFilterToController(new HandleErrorAttribute());

If I want to add an Action Filters to a specific Controller I just use the type of the Controller:

ConfigActionFilter.ConfigController<HomeController>()
                              .AddFilterToController(new HandleErrorAttribute());

Note: The reason I don’t use XML and a XML meta data provider as a configuration is because I wanted to make the configuration type safe. If we use XML we can only get an exception if we spell something wrong at runtime.

If I want to add Action Filters to Action Methods I can write something like this:

ConfigActionFilter.ConfigController<HomeController>()
                              .AddFilterToController(new HandleErrorAttribute())
                              .AddFilterToAction(c => c.About(),
                                                 new MyActionFilterAttribute(),
                                                 new MyOtherActionFilter() { Metadata=10 })
                              .AddFilterToAction(c => c.Index(),
                                                 new MyActionFilterAttribute());

I didn’t wanted to use a string for the ActionMethod (AddFilterToAction(“About”)) because it would not be type safe. I want to get a warning or error while typing the code, so instead I created an Expression. The AddFilterToAction takes a params of FilterAttributes, so I can easy add several of Action Filters to an Action Method. The AddFilterToController method will add Action Filter to the Controller, just like adding an Action Filter attribute to the class definition, so all Action Methods within the Controller will use the Action Filter.

I created a Custom ControllerFactory so I could add my Custom ControllerActionInvoker to the Controller:

 public class ActionFilterConfigControllerFactory : DefaultControllerFactory
 {
        public override IController CreateController(RequestContext requestContext, string controllerName)
        {
             ...

                controllerInstance.ActionInvoker = new ActionFilerConfigControllerActionInvoker();

            return controller;
        }
 }

The custom ControllerActionInvoker will make sure the Action Filter added by using my solution is added to the FilterInfo class. This is done by overriding the GetFilters method:

public class ActionFilerConfigControllerActionInvoker : ControllerActionInvoker
{
        protected override FilterInfo GetFilters(ControllerContext controllerContext,
                                                 ActionDescriptor actionDescriptor)
        {
            var filters = base.GetFilters(controllerContext, actionDescriptor);

            ...

            if (ConfigActionFilter.Config.ContainsKey(controllerName))
                AddFiltersToFilerList(actionDescriptor, filters, controllerName);

            return filters;
        }

}

This project only a fun thing to do and I like the idea of having different options to add Action Filters, and this solution will make the Controller clean from Attributes and also have one place to add them. When I create my Controller I don’t need to worry or think about the cross-cutting concerns, I just add them later and into the Global.asax.

I want to thanks Mikael Söderström for taking time to discuss this solution with him, and get some feedback and also “host” the source code for me.

You can download the source code with an example here: http://vinkr.net/misc/ActionFilterConfig.zip

Visual Studio 2010 Launch Countdown Sidebar Widget

2009-11-04T10:15:00Z

Here is a sidebar widget that will show the countdown for Visual Studio 2010, launching on March 22, 2010.

div#widget { position: relative; width: 250px; height: 155px; }

body ul#cntdwn { width: 250px; height: 80px; background: transparent url(http://toysfortweets.com/visualstudiowidget/cntdwn-bg.png) no-repeat scroll left top; list-style-type: none; text-align: center; padding: 74px 0 0 0; margin: 0; font-family: "Helvetica Neue", Helvetica, Arial, sans-serif; }

body ul#cntdwn li { float: left; margin: 0 8px 0 0; background: transparent url(http://toysfortweets.com/visualstudiowidget/number-bg.png) no-repeat scroll left top; padding: 0 0 5px 7px; }

body ul#cntdwn li.first { margin-left: 20px; }

body ul#cntdwn li em { display: block; color: #111; font-size: 1.6em; font-style: normal; font-weight: bold; background: transparent url(http://toysfortweets.com/visualstudiowidget/number-cap.png) no-repeat scroll right top; padding: 3px 7px 0 0; height: 35px; margin-bottom: -5px; }

div#widget a#link { display: block; width: 250px; height: 155px; position: absolute; top: 0; left: 0; }

</style>
<script language="javascript" src="http://toysfortweets.com/visualstudiowidget/countdown.js" mce_src="http://toysfortweets.com/visualstudiowidget/countdown.js"> </script>

Introduction to Templates in ASP.NET MVC 2 Screen cast

2009-11-02T20:05:16Z

I have recorded some screen casts during the last week for Microsoft, one is was published today on Channel 9 (The Screen cast is in Swedish, I will eventually try to record screen casts also in English, but when that happens, I don’t now). You can found the screen cast here:

http://channel9.msdn.com/posts/MSDNSweden/Introduktion-till-Template-i-ASPNET-MVC-2/

For those who can’t understand Swedish, here is a short summary of the screen cast.

With ASP.NET MVC version 2.0 we can use templates. It will help us rendering forms etc out form the Model we passed to the View. We can easy modify templates to satisfy our needs. The simples way to use the Template feature is to use the Html’s DisplayForModel method:

<%= Html.DisplayForModel() %>

This method will iterate through the ViewData.ModelMetadata.Properties to render the Model. The ModelMetadata hold information about the model, such as properties etc. The result will remind us about the DetailView control shipped with ASP.NET 2.0, but will put the name of the property at top, and then a new line with the value of the property, like this:

FirstName

John

LastName

Doe

There is also a method to render a editable from, EditorForModel. By default the methods will use a default template, we can easy override the template. We do that by adding a ASP.NET MVC User Control to the ~/Views/ControllerName/DisplayTemplates or EditTemplates folder. If you want to override how a String should be “rendered”, then you simply add a String.ascx file to the Templates folders, here is an example of a DisplayTemplate:

   
<%@ Control Language="C#" Inherits="System.Web.Mvc.ViewUserControl"%>

<i><%= Html.Encode(Model) %></i>

The above template will make the value of the rendered property to use italic:

FirstName

John

LastName

Doe

We can do several more stuffs with template, for more information check out the following blog post from Brad Wilson:

Part 1: Introduction

Part 2: ModelMetadata

Part 3: Default Templates

Part 4: Custom Object Templates

Part 5: Master Page Templates

You can find me on twitter: http://www.twitter.com/fredrikn

Distributing domain entities over the wire

2009-10-31T18:12:46Z

When we design our domain entities we don’t have a presentation layer or database in mind. The domain entities are core business objects located on the server or client side based of what kind of application we are building. Domain entities aren’t designed for distribution. When we realize that we need a distribution, we shouldn’t distribute the entities, instead collect the data we need to distribute and create a data transfer object (DTO) instead. Have the network in mind, a domain entity aren’t designed with a network in mind and of that reason not suitable for distribution. When we create our domain entities, they aren’t designed for presentation purpose, they are designed to fulfill business needs. You should be careful when you start thinking about returning a domain entity to the View when using a patterns like MVC, instead use DTO or a ViewModel, because once again the domain entities aren’t designed with presentation in mind, and aren’t often suitable for presentation purpose. It’s often better to map them to a DTO or ViewModel, objects that are suitable for presentation purpose or passed over the wire.

I often see demos and example codes where models are generated out from a database. Remember it you do that, your application’s design is driven by a relational database schema, do you really want a database to set the limit in your application design? I don’t. Developers are good at one thing, implementing business logic, that is what they do, that is what they are good at, that is what they should focus on (if we live in the perfect world ;)). We should work against our model. We shouldn’t care about how the database schema looks like. A database is a way to store information, and we have database administrator that are experts in the database area, let them handle the database schema and together with developers map the domain model to the database schema, with the use of an ORM, like Entity Framework 4.0 or nHibernate etc.

When it comes to WCF or Web Services, never distribute the domain entities, they aren’t designed for that kind of purpose in the first place(if we don’t use Distributed Domain Driven Design). There is a reason why we call the data sent from a Service as a message. A message is created with network in mind, that is why we use data contracts. When it comes to .NET RIA Services, don’t distribute the Entity Framework generated object or LINQ to SQL, they are generated out from a database schema, and it’s so easy to select whole tables and related tables to get what we want and then we distribute it and forget about the network between the client and server. In some cases we don’t even want to think about the network existence because it adds limit to the information and how we would like to work with objects. But we can’t hide the complexity how much we try, we have to realize that we do have a network, and have that in mind when we design our RIA. We can still on the server-side create our perfect domain model, but we shouldn’t distribute it. Instead transform peace of it into DTOs and only make sure we send the data we are needed. I have seen several examples where developers generate codes from Entity Framework or LINQ to SQL and returns it with .NET RIA Services. When I look at the examples I can see big object graphs passed over the wire and developers are using it as it was local objects, they start to requesting about Lazy Loading support in .NET RIA Services etc. Either they forgot about the network, or they have lack of experience. For intranet, small database driven applications it can be ok to create a model out from a database schema and distribute it with .NET RIA Services, they don’t often even use business logic, and they don’t need a domain model. But when it comes to large application it’s not often an good idea to generate object out from a database schema and distribute it. In that case DTO is much better option. Not only to limit the data passed, but also because of separation of concerns. The best thing with .NET RIA Services is that it does support DTOs :) Microsoft are good at creating frameworks for developers, but sometimes they want to satisfy everyone, and that often leads to people will use the frameworks in a wrong way. WCF is probably one of the better technologies made from Microsoft, they have learned from the fail of DCOM. When we use WCF we have to create a data contract, which force us to think about what we are distributing, they have also add a small limit of how much data we can by default pass over the wire. I know that some developers think WCF is complex to use and not so easy to learn, but sometimes it shouldn’t be easy to create things that are complex, the complexity is there by some reasons, and it can’t be hidden.

VS 2010 Beta 2 and .Net 4.0 is now available for downloading from MSDN Sub.

2009-10-21T11:39:00Z

Oh, I'm late.. but better late then never.. you can now download VS 2010 nad .Net 4.0 Beta 2, if you are a MSDN Subscriber.. You can read more about VS 2010 Beta 2 on Scott Guthrie's blog.

Wow, my shortest blog post ever!

ASP.NET 4.0 Web Form routing

2009-10-14T07:43:26Z

One of hundreds things I like about ASP.NET MVC, is the routing, a way to use clear and friendly URLs like: www.server.com/Customer/List, instead of something like www.server.com/Customers.aspx.

The routing part is now also added to the ASP.NET Web Form 4.0, so we can now use routing to avoid pointing to a .aspx file and ugly query stings. Scott Guthrie have wrote a blog post about it here. I will only write a short post to introduce it.

To define a route, we will use the Application_Start event of the Gloabal.asax file (a file which will be “executed” every time we visit a .aspx page). The Application_Start event will only be executed one time, and that is when the application starts (the first user visit our app). By using the static RouteTable class, we can add routes to the RouteTable’s Routes collection. This is done by using the MapPageRoute method. The MapPageRoute method can take some parameters, for example the name of the Route (to give a route an identifier so we can get and create routes in our code), the new URL where we also can specify parameters and route constraints etc. So for example if we have a URL look like this: www.server.com/Customer.aspx?id=10, we can use the Route feature to use a URL like this instead: www.server.com/Customer/10. The following code will setup this route:

void RegisterRoutes(RouteCollection routes)
{
      routes.MapPageRoute(
          "viewCustomerDetails",
         "Customer/{ID}",
        "~/Customer.aspx");
}

void Application_Start()
{
       RegisterRoutes(RouteTable.Routes);
}

I like this feature and will use it in all of my Web apps, where I need to use Web Forms, I will mostly use the ASP.NET MVC framework ;)

Some features I love in VS 2010

2009-10-08T12:12:00Z

This post will not be so long, I want to write a little about some Visual Studio 2010 features I love. First of all the changes made to C# is great, the default value on parameters rocks! When I implement Frameworks, I often ended up with something like this:

public void Log(string message)

public void Log(string message, string category)

public void Log(string message, string category, .......)

The last method is the one that have the most of the code, the other method with few parameters, only calls the last one, and pass null or an empty string as values to the extra arguments:

Log(message, null, ......)

Note: The code above is not taken from a real example, only used as pseudo code.

Now with C# 4.0, we can instead set a default value on a argument, which will get rid of the extra methods, for example:

public void Log(string message, string category = null, .....)

The dynamic feature in C# is ok, but at the moment I will not use it. When we use the dynamic when we declare a varible, it will be evaluated first at runtime. It's a nice feature when we want C# to use stuff from other dynamic languages.

dynamic something = ....

something.Hello();

Entity Framework 4.

Will be great now when it will support POCO (Plain old clr object):

public class Customer
{
      public string FirstName
      {
             get { ... }
             set { ... }
      }
}

There are so many other features improvements to EF, need a new blog post for that, but the POCO support and the model first approached is better supported than the first version.

ASP.NET AJAX 4.0

I love the client-side binding, I have some blog post about it, so you can read about it here:

http://weblogs.asp.net/fredriknormen/archive/2009/09/16/asp-net-ajax-4-0-preview-5-working-with-converters-and-the-new-cdn.aspx

http://weblogs.asp.net/fredriknormen/archive/2009/09/11/keep-the-first-empty-item-in-a-listbox-when-using-asp-net-ajax-4-0-preview-5-and-observer.aspx

http://weblogs.asp.net/fredriknormen/archive/2009/09/11/asp-net-ajax-4-0-preview-5-available.aspx

Silverlight designer

Visual Studio 2010 have now enabled the Silverlight designer, it was not enabled in the previous Visual Studio, so we can now easier and faster create our Silverlight apps, and no need to run Expression Blend and VS at the same time.

Improvements for web developer

Better Java-script intellisense. Easier to add Server controls to the .aspx file. Something we need to add before was the runat="seerver" attribute, it's now directly added when we add a Server control in the source mode (not talking about to drag a control, it when we write the code).

Code Contract

I like design-by-contract, think everyone should read about it. We can now use code contract in our code. What I have heard, we need the VSTS version for static checking. You can read more avout Code contract here: http://msdn.microsoft.com/en-us/devlabs/dd491992.aspx