Mark Woodhall's Blog

New Home..

Mark — Sat, 19 Dec 2009 21:44:12 +0000

I’m migrating my blog over to here.

Head over there, there will be more code sample available there.

Getting started with Silverlight and MEF, Import and Export

Mark — Fri, 18 Dec 2009 23:53:43 +0000

For this example, I am using Silverlight 3 and the appropriate version of MEF. The example works in Silverlight 4 as well.

The first thing to do is create a new Silverlight application project. I called mine MEFDemo and didnt select the option to create a new website. I then added two new Silverlight controls, Control1 and Control2.

I also modified the MainPage control, here is the xaml.

<UserControl x:Class="MEFDemo.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">
  <Grid x:Name="LayoutRoot">
        <StackPanel Orientation="Vertical">
            <StackPanel Name="Top">

        StackPanel>
        <StackPanel Name="Main">

        StackPanel>
            StackPanel>
    Grid>
UserControl>

I defined StackPanels called Top and Main, these represent areas that we can add controls into later on.

I then added a reference to System.ComponentModel.Composition and System.ComponentModel.Compisition.Initialization.

I then added a new item called Location.cs with the following code.

namespace MEFDemo
{
    public enum Location
    {
        Top,
        Main
    }
}

This is going to be used so that we can configure our controls to appear in a place holder. We are going to use this by defining meta data on our control. We need to define an interface for this meta data, so that MEF can dynamically generate a proxy for us. The interface I have looks like so.

namespace MEFDemo
{
    public interface IMefMetaData
    {
        Location Location { get; }
    }
}

The next thing to do is change our MainPage control to get a collection of controls using the [ImportMany] attribute. The code for MainPage looks like so.

using System;
using System.ComponentModel.Composition;
using System.Windows.Controls;

namespace MEFDemo
{

    public partial class MainPage : UserControl
    {
        [ImportMany]
        public Lazy<UserControl, IMefMetaData>[] Controls { get; set; }

        public MainPage()
        {
            InitializeComponent();
            PartInitializer.SatisfyImports(this);
            foreach (var control in Controls)
            {
                if(control.Metadata.Location == Location.Top)
                    Top.Children.Add(control.Value);

                if (control.Metadata.Location == Location.Main)
                    Main.Children.Add(control.Value);
            }

        }
    }
}

Here we get a list of Controls, call the SatisfyImports method on the PartInitializer and then use our meta data to decide where to add the control.

In order to configure our 2 controls to get picked up by the [ImportMany] attribute we need change their code a little, the example for each is below.

Control1


using System.ComponentModel.Composition;
using System.Windows.Controls;

namespace MEFDemo
{
    [Export(typeof(UserControl))]
    [ExportMetadata("Location", Location.Top)]
    public partial class Control1 : UserControl
    {
        public Control1()
        {
            InitializeComponent();
        }
    }
}

Control2


using System.ComponentModel.Composition;
using System.Windows.Controls;

namespace MEFDemo
{
    [Export(typeof(UserControl))]
    [ExportMetadata("Location", Location.Main)]
    public partial class Control2 : UserControl
    {
        public Control2()
        {
            InitializeComponent();
        }
    }
}

In control 1 we configure the Location property on the meta data to Top, and in control 2 we configure it to Main. If we run this, control 1 will load above control 2. If it doesnt, then my explanation was rubbish and you should go download the code.

Obviously you can be clever with this, you could use Linq on the list of Controls, and filter them based on User Roles or preferences.

RIA Services Examples – Using InvokeOperation

Mark — Thu, 17 Dec 2009 22:19:32 +0000

I’m going to start a list of RIA services examples, keeping them short and sweet.

This one shows how to call a method that returns a Boolean and use InvokeOperation.

Consider the following RIA service.

public class AuthenticationService : DomainService
{
    private readonly IApplicationConfigurationService _appConfigService;
    private readonly IAuthenticationService _authService;

    public AuthenticationService()
    {
        _appConfigService = With.IoC.GetService<IApplicationConfigurationService>();
        _authService = With.IoC.GetService<IAuthenticationService>();
    }

    public Boolean Authenticate(String email, String password)
    {
        var user = With.IoC.GetService<IUser>();

        user.EmailAddress = email;
        user.Password = password.Encrypt(_appConfigService.FindByGroupAndKey(
                                             ApplicationConfigurationGroups.CommonEncryption.ToString(),
                                             ApplicationConfigurationKeys.CommonEncryptionKey.ToString()
                                             )
                                             .Value);

        return _authService.Authenticate(user);
    }
}

You can call the Authenticate method in a Silverlight application like so, using a delegate to capture the InvokeOperation

private readonly AuthenticationContext _authContext = new AuthenticationContext();

 _authContext.Authenticate(
                Username.Text, Password.Password,
                   delegate(InvokeOperation<Boolean> inv)
                   {
                       IsAuthenticated = inv.Value;
                       //do something else
                   },
                null);

Entity framework profiler beta

Mark — Sat, 12 Dec 2009 21:25:15 +0000

I’ve been using NHProf since the beta now, and its become a pretty vital tool to me.

Its great that Ayende has been working on an Entity Framework version, this has just made public beta. If you use Entity Framework then you should really check it out.

Dynamically loading controls in Silverlight

Mark — Sat, 12 Dec 2009 17:24:51 +0000

Recently I found myself wanting to specify at ‘start up’ time which Control loaded by default in a Silverlight application. For those of you that dont know, you can pass initParams into the Silverlight application that are available at Application Start.

An example of this could be like.

<div id="silverlightControlHost">
    <object data="data:application/x-silverlight-2," type="application/x-silverlight-2" width="100%" height="100%">
      <param name="source" value="ClientBin/EMASolutions.CMS.Plugins.Silverlight.xap"/>
      <param name="onError" value="onSilverlightError" />
      <param name="background" value="white" />
      <param name="minRuntimeVersion" value="3.0.40818.0" />
      <param name="autoUpgrade" value="true" />
      <param name="initParams" value="firstControl=EMASolutions.CMS.Plugins.Silverlight.FolderBrowser" />
      <a href="http://go.microsoft.com/fwlink/?LinkID=149156&v=3.0.40818.0" style="text-decoration:none">
          <img src="http://go.microsoft.com/fwlink/?LinkId=108181" alt="Get Microsoft Silverlight" style="border-style:none"/>
      a>
    object>
    <iframe id="_sl_historyFrame" style="visibility:hidden;height:0px;width:0px;border:0px">iframe>
div>

The initParams take the following format, key=value,key1=value1. Notice in this example we passover the fully qualified type name of the control to load on Application Start. This is a simple example, in reality the type name would be driven from user actions and would probably be a persisted value rather than a ‘magic string’.

Anyway, we can access our ‘firstControl’ value like so.

private void Application_Startup(object sender, StartupEventArgs e)
{
    if (!NetworkInterface.GetIsNetworkAvailable()) return;
    if (e.InitParams.Any())
    {
        if (e.InitParams["firstControl"] != null)
            LoadControl(
                (Control)
                Activator.CreateInstance(
                    sender.GetType().Assembly.GetType(e.InitParams["firstControl"])));
    }
    else
    {
        LoadControl(
            (Control)
            Activator.CreateInstance(
                sender.GetType().Assembly.GetType("EMASolutions.CMS.Plugins.Silverlight.FolderBrowser")));
    }
    RootVisual = Container;
}

Notice, if the type was not specified, we can load a default control. Again, this is a simple example and the default control could be a persisted value also.

In this example, I am making use of a variable called Container, defined like so.

public static readonly Master Container = new Master();

Master has the following xaml and the default code behind.

<UserControl x:Class="EMASolutions.CMS.Plugins.Silverlight.Master"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    >
    <Grid x:Name="LayoutRoot">

        <Grid.RowDefinitions>
            <RowDefinition Height="30" />
            <RowDefinition Height="*" />
        Grid.RowDefinitions>

        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="*" />
        Grid.ColumnDefinitions>

        <Grid Name="TopBar" Grid.Column="0"  Grid.Row="0">Grid>
        <Grid Name="Main" Grid.Column="0" Grid.Row="1">Grid>

    Grid>
UserControl>

All that master does, is give us place holders to load our control into, one called Main and one called TopBar. In the Application_Startup method you will also notice the use of a method called LoadControl. This is what loads controls into our container. It is defined like so.

public static void LoadControl(Control control)
{
    if (Container.Main.Children.Any())
        LastControl = (Control)Container.Main.Children.First();
    Container.Main.Children.Clear();
    Container.TopBar.Children.Add(new TopBar());
    Container.Main.Children.Add(control);
}

We set a LastControl value if there was one, so that we can navigate backwards and then we clear the current controls and add our new control and a TopBar control.

We can also make use of the LoadControl method in other controls. For example, if we have an Authenticate control that logs in a user, we may wish to load another control if authentication failed. We could do this like so.

if (OnFailedAuthentication != null)
{
    OnFailedAuthentication(sender,e);
    App.LoadControl(new Unauthorised());
}

Creating a reusable Silverlight login window – part 2

Mark — Sat, 12 Dec 2009 09:52:16 +0000

This is part 2 on how to create a reusable login window for Silverlight, part 1 is here.

The Authenticate.xaml child window created in the last post has evolved a little, instead of using Actions it now uses regular old events.

public partial class Authenticate : ChildWindow
    {

        #region "Properties"
        private readonly AuthenticationContext _authContext = new AuthenticationContext();
        public static String Email { get; set; }
        public static event EventHandler OnBeforeAuthentication;
        public static event EventHandler OnAuthenticated;
        public static event EventHandler OnAfterAuthentication;
        public static event EventHandler OnFailedAuthentication;

        public static Boolean IsAuthenticated { get; set; }
        #endregion

        public Authenticate()
        {
            InitializeComponent();
            if (IsAuthenticated)
                if (OnAuthenticated != null)
                    OnAuthenticated(this, null);
        }

        private void OKButton_Click(object sender, RoutedEventArgs e)
        {
            DialogResult = true;
            if (OnBeforeAuthentication != null) OnBeforeAuthentication(sender,e);
            _authContext.Authenticate(
                Username.Text, Password.Password,
                   delegate(InvokeOperation<Boolean> inv)
                   {
                       IsAuthenticated = inv.Value;
                       if (inv.Value)
                       {
                           Email = Username.Text;
                           IsAuthenticated = true;
                           if (OnAuthenticated != null)
                               OnAuthenticated(sender, e);
                       }
                       else
                       {
                           IsAuthenticated = false;
                           if (OnFailedAuthentication != null)
                           {
                               OnFailedAuthentication(sender,e);
                           }
                       }
                   },
                null);
            if (OnAfterAuthentication != null) OnAfterAuthentication(sender,e);
        }

        private void CancelButton_Click(object sender, RoutedEventArgs e)
        {
            if (OnFailedAuthentication != null)
            {
                OnFailedAuthentication(sender,e);
                App.LoadControl(new Unauthorised());
            }
            DialogResult = false;
        }
    }

I also made the EventHandlers static so that multiple controls can wire up delegates.

I added a new UserControl (AuthenticateControl.xaml) in order to house the Authenticate child window. The xaml for this control only contains the following.

<UserControl x:Class="EMASolutions.CMS.Plugins.Silverlight.Controls.AuthenticateControl"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
              >

UserControl>

The code behind contains the following.

public partial class AuthenticateControl : UserControl
{
    public Boolean RequiresAuthentication { get; set; }
    public Authenticate LoginControl { get; set; }

    public AuthenticateControl()
    {
        InitializeComponent();
        LoginControl = new Authenticate();
        Loaded += Control_Loaded;
    }

    void Control_Loaded(object sender, RoutedEventArgs e)
    {
        if (!RequiresAuthentication) return;
        LoginControl = new Authenticate { Title = "Authenticate" };
        if (!Authenticate.IsAuthenticated)
            LoginControl.Show();

        Authenticate.OnFailedAuthentication += delegate { LoginControl.Show(); };
    }
}

This control is going to become a base control for our others to inherit from. In our other controls we can then set the RequiresAuthentication property to true and if the user has not yet authenticated they will be prompted to do so.

Here is an example of how we can use it in a control.

public partial class FolderBrowser : AuthenticateControl
{
    public FolderBrowser()
    {
        _folderContext = new FolderContext();
        _documentContext = new DocumentContext();
        InitializeComponent();
        Loaded += MainPage_Loaded;
    }

    void MainPage_Loaded(object sender, RoutedEventArgs e)
    {
        RequiresAuthentication = true;
        Authenticate.OnBeforeAuthentication +=
            delegate
             {
                 Dispatcher.BeginInvoke(
                     () =>
                     {
                        IsBusy = true;
                     });
             };

        Authenticate.OnAuthenticated +=
            delegate
            {
                _folderContext.Load(
                    _folderContext.GetFoldersQuery(),
                    LoadBehavior.RefreshCurrent,
                    delegate
                        {
                            Dispatcher.BeginInvoke
                                (
                                () =>
                                    {
                                        folders.ItemsSource =
                                            _folderContext.Folders.Where(f => f.ParentId == 0);
                                        IsBusy = false;
                                    }
                                );
                        },
                    null);
            };
    }
}

Notice this control now inherits from AuthenticateControl, the xaml must also be changed to include the AuthenticateControl as its root tag in place of UserControl.

In other controls, that do not require any sort of authentication we dont have to inherit from AuthenticateControl, we can just inherit from UserControl.

We can still make use of the static event handlers in the Authenticate child window, consider the following as an example.

public partial class TopBar : UserControl
{
    public TopBar()
    {
        InitializeComponent();
        Authenticate.OnAuthenticated +=
            delegate
            {
                Email.Text = Authenticate.Email;
            };
    }
}

This simply appends an additional action to the OnAuthenticated event handler, so if a user has Authenticated using a control that required it we can tap in an use the email address they authenticated with to display it on screen.

Using this method we can be flexible in displaying authentication prompts and we can also allow dynamic loading of any control as the RootVisual in our Silverlight application.

This means we can pass a parameter from the server when the Silverlight application launches and define which control we want as our root visual based on something a user did. We dont have to direct them to a login area by default. We just allow our control to handle that.

I hope this makes sense, it seems like a nice way of doing things to me but I’m not sure I’ve explained it well. I’m still learning about the best way of doing things with Silverlight, so take everything with a ‘large’ pinch of salt.

Creating a reusable Silverlight login window – part 1

Mark — Thu, 10 Dec 2009 22:36:00 +0000

This post is an example showing how to create a reusable child window to allow a user to login to a silverlight application.

The first thing to do is add a new child window to your existing Silverlight project and name it Authenticate.xaml

Once we have added this item we can modify the xaml to meet our needs. I added a small message, a text box and a passsword box. I made use of the 2 buttons created in a child window by default. This is the xaml I ended up with.

<controls:ChildWindow xmlns:expressionDark="clr-namespace:System.Windows.Controls.Theming;assembly=System.Windows.Controls.Theming.ExpressionDark"  x:Class="EMASolutions.CMS.Plugins.Silverlight.FolderBrowser.Authenticate"
           xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
           xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
           xmlns:controls="clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls"
    xmlns:themeing="clr-namespace:System.Windows.Controls.Theming;assembly=System.Windows.Controls.Theming.Toolkit"

           Width="400" Height="300"
           Title="Authenticate">
    <Grid x:Name="LayoutRoot" Margin="2">

        <expressionDark:ExpressionDarkTheme>
            <StackPanel>
                <StackPanel Orientation="Vertical">

                    <Border Margin="2,2,2,2" Padding="2,2,2,2" Background="#333333" BorderThickness="1" BorderBrush="#000000" CornerRadius="2,2,2,2" >

                        <TextBlock Height="130" TextWrapping="Wrap" Foreground="#FFFFFF" Text="Please login">
                        TextBlock>

                    Border>

                    <TextBox Margin="2,2,2,2" themeing:ImplicitStyleManager.ApplyMode="Auto" Name="Username" Text="Enter username" />
                    <PasswordBox Margin="2,2,2,2" themeing:ImplicitStyleManager.ApplyMode="Auto"  Name="Password" PasswordChar="*" />
                    <StackPanel  Orientation="Horizontal" HorizontalAlignment="Right">
                        <Button x:Name="CancelButton" HorizontalAlignment="Right"   themeing:ImplicitStyleManager.ApplyMode="Auto" Content="Cancel" Click="CancelButton_Click" Width="75" Height="23" Margin="2,2,2,2" />
                        <Button x:Name="OKButton"  HorizontalAlignment="Right"  themeing:ImplicitStyleManager.ApplyMode="Auto" Content="Login" Click="OKButton_Click" Width="75" Height="23" Margin="2,2,2,2"  />
                    StackPanel>
                StackPanel>
            StackPanel>
        expressionDark:ExpressionDarkTheme>
    Grid>
controls:ChildWindow>

This gives us a child window that looks like the image below.

Next we need to open the code behind for this file. In this file we have added some actions to execute in various scenarios. The code looks like so.

public partial class Authenticate : ChildWindow
{

    #region "Properties"

    private readonly AuthenticationContext _authContext = new AuthenticationContext();

    public Action BeforeAuthentication { get; set; }
    public Action OnAuthenticated { get; set; }
    public Action AfterAuthentication { get; set; }
    public Action OnFailedAuthentication { get; set; }

    public bool IsAuthenticated
    {
        get { return (bool)GetValue(IsAuthenticatedProperty); }
        set { SetValue(IsAuthenticatedProperty, value); }
    }

    public static readonly DependencyProperty IsAuthenticatedProperty =
        DependencyProperty.Register("IsAuthenticated", typeof(bool), typeof(Authenticate), new PropertyMetadata(false));

    #endregion

    public Authenticate()
    {
        InitializeComponent();
    }

    private void OKButton_Click(object sender, RoutedEventArgs e)
    {
        DialogResult = true;
        if (BeforeAuthentication != null) BeforeAuthentication();
        _authContext.Authenticate(
            Username.Text, Password.Password,
               delegate(InvokeOperation<Boolean> inv)
               {
                   IsAuthenticated = inv.Value;
                   if (inv.Value)
                   {
                       IsAuthenticated = true;
                       if (OnAuthenticated != null)
                           OnAuthenticated();
                   }
                   else
                   {
                       if (OnFailedAuthentication != null)
                           OnFailedAuthentication();
                   }
               },
            null);
        if (AfterAuthentication != null) AfterAuthentication();
    }

    private void CancelButton_Click(object sender, RoutedEventArgs e)
    {
        DialogResult = false;
    }
}

In this example I call out to a RIA service to validate the username and password supplied by the user. Obviously this can be replaced to use other methods.

You can then make use of this child window in your xaml user control with code similar to the following.

void MainPage_Loaded(object sender, RoutedEventArgs e)
{
    var login = new Authenticate {Title = "Authenticate"};
    if (!login.IsAuthenticated)
        login.Show();

    login.BeforeAuthentication =
        () =>
         {
             Dispatcher.BeginInvoke(
                 () =>
                 {
                    IsBusy = true;
                 });
         };

    login.OnAuthenticated =
        ()=>
        {
            _folderContext.Load(
                _folderContext.GetFoldersQuery(),
                LoadBehavior.RefreshCurrent,
                delegate
                    {
                        Dispatcher.BeginInvoke
                            (
                            () =>
                                {
                                    folders.ItemsSource =
                                        _folderContext.Folders.Where(f => f.ParentId == 0);
                                    IsBusy = false;
                                }
                            );
                    },
                null);
        };

    login.OnFailedAuthentication = () => { login.Show(); };

}

In this example, we set a busy indicator using the BeforeAuthentication action, then using the OnAuthentication action we load some data and finally we wire up the OnFailedAuthentication to show the login window again.

This example is by no means perfect, but its a start, it only really works well in the context of simple Silverlight projects consisting of 1 user control. In a future post I’m going to expand on this and show it working in a more complex situation.

Taking Amazon S3, RIA Services a step further

Mark — Tue, 08 Dec 2009 12:25:58 +0000

I wrote a post about using silverlight, RIA services and the Amazon S3 SOAP API.

This post aims to take that a little further. The idea is to make our code cloud agnostic and encapsulate the Amazon S3 API and any other cloud based simple storage within a common component.

In the previous post we used a RIA service to distribute calls to an Amazon S3 wrapper class. In this example we will replace this with a call to a common component.

We will still make use of the following wrapper class.

public class AmazonS3Wrapper : IAmazonS3Wrapper
{
    private readonly IApplicationConfigurationService _appConfigService = With.IoC.GetService<IApplicationConfigurationService>();

    internal static String Salt;
    internal static String MainApiKey;
    internal static String SecretApiKey;
    internal static String RootBucket;

    public AmazonS3Wrapper()
    {

        Salt = _appConfigService.FindByGroupAndKey(
                ApplicationConfigurationGroups.CommonEncryption.ToString(),
                ApplicationConfigurationKeys.CommonEncryptionKey.ToString()
            )
            .Value;

        MainApiKey = _appConfigService.FindByGroupAndKey(
                ApplicationConfigurationGroups.CommonAmazonAws.ToString(),
                ApplicationConfigurationKeys.CommonAmazonAwsMainKey.ToString()
            )
            .Value.Decrypt(Salt);

        SecretApiKey = _appConfigService.FindByGroupAndKey(
                ApplicationConfigurationGroups.CommonAmazonAws.ToString(),
                ApplicationConfigurationKeys.CommonAmazonAwsSecretKey.ToString()
            )
            .Value.Decrypt(Salt);

        RootBucket = _appConfigService.FindByGroupAndKey(
                ApplicationConfigurationGroups.CommonAmazonAws.ToString(),
                ApplicationConfigurationKeys.CommonAmazonAwsRootBucket.ToString()
            )
            .Value.Decrypt(Salt);
    }

    public ListAllMyBucketsEntry[] ListAllMyBuckets()
    {
        try
        {
            var s3 = new AmazonS3();
            return s3.ListAllMyBuckets(
                MainApiKey,
               Helper.TimeStamp,
               true,
               Helper.GetSignature(
                    SecretApiKey,
                    Operations.ListAllMyBuckets,
                    Helper.TimeStamp
                    )
                ).Buckets;
        }
        catch (Exception e)
        {
            e.RecursiveLog();
            throw;
        }
    }

    public IList<ListEntry> ListBucket(String bucket)
    {
        try
        {
            var s3 = new AmazonS3();
            return s3.ListBucket(
                bucket,
                null,
                null,
                100,
                true,
                "/",
                MainApiKey,
                Helper.TimeStamp,
                true,
                Helper.GetSignature(
                    SecretApiKey,
                    Operations.ListBucket,
                    Helper.TimeStamp
                    ),
                null
                ).Contents.ToList();
        }
        catch (Exception e)
        {
            e.RecursiveLog();
            throw;
        }
    }

    public List<PutObjectResult> PutObject(String key, Byte[] data)
    {
        try
        {
            var s3 = new AmazonS3();
            var results = new List<PutObjectResult>();
            var metadataEntries = new MetadataEntry[2];

            metadataEntries[0] = new MetadataEntry { Name = "Content-Type", Value = "text/xml" };
            metadataEntries[1] = new MetadataEntry
            { Name= "ContentLength", Value = data.Length.ToString() };

            var result = s3.PutObjectInline(
                RootBucket,
                key,
                metadataEntries,
                data,
                data.Length,
                null,
                StorageClass.STANDARD,
                true,
                MainApiKey,
                Helper.TimeStamp,
                true,
                Helper.GetSignature(
                    SecretApiKey,
                    Operations.PutObjectInline,
                    Helper.TimeStamp
                    ),
                null
                );
            result.FileName = key;

            results.Add(result);
            return results;
        }
        catch (Exception e)
        {
            e.RecursiveLog();
            throw;
        }
    }

    public List<GetObjectResult> GetObject(String key)
    {
        try
        {
            var s3 = new AmazonS3();
            var results = new List<GetObjectResult>();
            results.Add(s3.GetObject(
                RootBucket,
                key,
               true,
               true,
               true,
               MainApiKey,
               Helper.TimeStamp,
               true,
               Helper.GetSignature(
                    SecretApiKey,
                    Operations.GetObject,
                    Helper.TimeStamp
                    ),
                null
                ));
            return results;
        }
        catch (Exception e)
        {
            e.RecursiveLog();
            throw;
        }
    }
}

In the previous post the RIA service made use of this wrapper class like so.

[EnableClientAccess]
public class AmazonS3Service : DomainService
{
    private static readonly IWrapper AmazonS3Wrapper = With.IoC.GetService<IWrapper>();

    public ListAllMyBucketsEntry[] ListAllMyBuckets()
    {
        return AmazonS3Wrapper.ListAllMyBuckets();
    }

    public IList<ListEntry> ListBucket(String bucket)
    {
        return AmazonS3Wrapper.ListBucket(bucket);
    }

    public List<PutObjectResult> PutObject(String key, Byte[] data)
    {
        return AmazonS3Wrapper.PutObject(key, data);
    }

    public List<GetObjectResult> GetObject(String key)
    {
        return AmazonS3Wrapper.GetObject(key);
    }

}

However, we can change this a little, and make it work with multiple storage providers.

To start with, I created the following interface.

public interface IStorageProvider
{
    Boolean PutObject(HttpPostedFileBase file, String key);
    Boolean PutObject(Byte[] data, String key);

    Byte[] GetObject(String key);
}

And a custom implementation of this interface to represent the local file system (I dont have another cloud service to try).

public class LocalStorageProvider : IStorageProvider
{
    public virtual Boolean PutObject(HttpPostedFileBase file, String key)
    {
        With.Guard.Against<ArgumentException>(
            String.IsNullOrEmpty(key)
        );

        With.Guard.Against<ArgumentException>(
            file == null
        );

        try
        {
            file.SaveAs(key);
            return true;
        }
        catch (Exception e)
        {
            e.RecursiveLog();
            throw;
        }
    }

    public virtual Boolean PutObject(Byte[] data, String key)
    {

        With.Guard.Against<ArgumentException>(
            String.IsNullOrEmpty(key)
        );

        With.Guard.Against<ArgumentException>(
            data == null
        );

        try
        {
            using(var stream = new FileStream(key, FileMode.Create))
            {
                stream.Write(data, 0, data.Length);
                return true;
            }
        }
        catch (Exception e)
        {
            e.RecursiveLog();
            throw;
        }

    }

    public virtual Byte[] GetObject(String key)
    {
        With.Guard.Against<ArgumentException>(
            String.IsNullOrEmpty(key)
        ); 

        using(var stream = new FileStream(key, FileMode.Open))
        {
            var data = new Byte[stream.Length];
            stream.Read(data, 0, data.Length);
            return data;
        }
    }
}

And an AmazonS3 implementation, still making use of the wrapper class

public class AmazonS3StorageProvider : IStorageProvider
{
    private readonly IAmazonS3Wrapper _wrapper;

    public AmazonS3StorageProvider(IAmazonS3Wrapper wrapper)
    {
        _wrapper = wrapper;
    }

    public Byte[] GetObject(String key)
    {
        return _wrapper.GetObject(key).First().Data;
    }

    public Boolean PutObject(byte[] data, string key)
    {
        _wrapper.PutObject(key, data);
        return true;
    }

    public Boolean PutObject(HttpPostedFileBase file, string key)
    {
        throw new NotImplementedException();
    }
}

In the RIA service we can do the following

public void CreateDocument(Document document)
{
    var cloudStorage = _appConfigService.FindByGroupAndKey(
        ApplicationConfigurationGroups.CmsDocuments.ToString(),
        ApplicationConfigurationKeys.CmsCloudStorage.ToString()
    ).Value;
    var store = With.IoC.GetService<IStorageProvider>(cloudStorage);
    store.PutObject(document.Data, newDocument.Path);
}

The call to the _appConfigService simply returns a string config key value indicating the required cloud storage provider, LocalStorageProvider or AmazonS3StorageProvider.

For this example, the call to With.IoC uses Castle Windsor behind the scenes. In the Castle config file we have two definitions for our storage providers:

<component id="AmazonS3StorageProvider"
           service="EMASolutions.Common.Web.File.IStorageProvider, EMASolutions.Common"
           type="EMASolutions.CMS.Service.AmazonS3.AmazonS3StorageProvider, EMASolutions.CMS.Service"
           lifestyle="transient">
component>
<component id="LocalStorageProvider"
           service="EMASolutions.Common.Web.File.IStorageProvider, EMASolutions.Common"
           type="EMASolutions.Common.Web.File.LocalStorageProvider, EMASolutions.Common"
           lifestyle="transient">
component>

Using this method we can simply change our config key and use a different cloud service. Obviously this doesnt handle migration to another cloud service, so files would need to be migrated manually.

Using Amazon S3 with Silverlight and RIA services

Mark — Thu, 03 Dec 2009 08:20:28 +0000

I’ve been working on something recently that gave me a chance to try out Amazon S3 services. The first thing to mention is that I am using the SOAP API and not REST. Another thing worth noting is that I used a web reference rather than a service reference to link to the S3 services.

The rest of this post will assume you have an amazon S3 account. You can add a reference to the S3 services by right clicking on your web project and selecting ‘add web reference’. You will then see the dialog below.

After I added the web reference I changed the end point address in my web.config file to match the name of my S3 bucket. The end point will look something like this:

  <applicationSettings>
    <EMASolutions.CMS.Service.Properties.Settings>
      <setting name="EMASolutions_CMS_Service_AWS_AmazonS3" serializeAs="String">
        <value>https://s3.amazonaws.com/soapvalue>
      setting>
    EMASolutions.CMS.Service.Properties.Settings>
  applicationSettings>

I changed it to point to my S3 Bucket by changing the value tag.

  <applicationSettings>
    <EMASolutions.CMS.Service.Properties.Settings>
      <setting name="EMASolutions_CMS_Service_AWS_AmazonS3" serializeAs="String">
        <value>https://hiberlog-storage.s3.amazonaws.com/soapvalue>
      setting>
    EMASolutions.CMS.Service.Properties.Settings>
  applicationSettings>

The common code required to generate a signature to pass to S3 services was pretty small and not really a maintenance headache but I didn’t want to include it in the silverlight app and the server side web app. I wanted to keep it common between the two platforms. Below is an example of the helper class I used, it is only concerned with generating timestamps in the correct format and an S3 signature.

public enum Operations
{
    ListAllMyBuckets = 0,
    ListBucket = 1,
    GetObject = 2,
    GetObjectInline = 3,
    PutObject = 4,
    PutObjectInline = 5,
}

public class Helper
{
    private const String AwsTsFormat = "yyyy-MM-ddTHH:mm:ss.fffZ";
    private const String AwsAction = "AmazonS3";

    public static DateTime TimeStamp
    {
        get
        {
            var currentDateTime = DateTime.Now;
            return new DateTime(
                currentDateTime.Year,
                currentDateTime.Month,
                currentDateTime.Day,
                currentDateTime.Hour,
                currentDateTime.Minute,
                currentDateTime.Second,
                currentDateTime.Millisecond,
                DateTimeKind.Local
                );
        }
    }

    public static String GetSignature(String secret, Operations operation, DateTime timestamp)
    {
        var enc = new UTF8Encoding();
        var hash = new HMACSHA1(enc.GetBytes(secret));

        var sig = AwsAction + operation + timestamp
            .ToUniversalTime()
            .ToString(AwsTsFormat);
        return Convert.ToBase64String(
                hash.ComputeHash(enc.GetBytes(sig.ToCharArray()))
            );
    }
}

I couldn’t really see a nice way of not duplicating this code but in the end I settled with exposing the S3 methods in a RIA service and storing the common code on the server.

For example, the ListAllMyBuckets method on S3 returns a ListAllMyBucketsResult which has a property Buckets of type ListAllMyBucketsEntry, in order to expose this type to the client we need to define a key on the ListAllMyBucketsEntry class. Luckily the generated class from the web reference uses a partial class. This allows us to implement some Metadata, as follows:

[MetadataTypeAttribute(typeof(ListAllMyBucketsEntryMetadata))]
public partial class ListAllMyBucketsEntry
{
    public Guid Id
    {
        get { return Guid.NewGuid(); }
        set { throw new InvalidOperationException("The Id field on ListAllMyBucketsEntryMetadata is not meant to be set"); }
    }
    internal sealed class ListAllMyBucketsEntryMetadata
    {
        // Metadata classes are not meant to be instantiated.
        private ListAllMyBucketsEntryMetadata()
        {
        }

        [Key]
        [Display(AutoGenerateField = false)]
        public Guid Id;
    }
}

This metadata defines a new property called Id that we can use to allow ListAllMyBucketsEntry to be projected to the client.

We can now call the RIA services as we would normally which would call the S3 services to get a list of ListAllMyBucketsEntry and bind to it as we wish.

In my example the RIA service was getting rather chunky so I refactored the common S3 stuff away into another class.

public class Wrapper : IWrapper
    {
       internal static IRepository<IApplicationConfiguration> AppSettings =
            With.IoC.GetService<IRepository<IApplicationConfiguration>>();

        internal static String Salt;
        internal static String MainApiKey;
        internal static String SecretApiKey;
        internal static String RootBucket;

        public Wrapper()
        {

            Salt = AppSettings
                .Matching("Key", "common.encryptionkey")
                .First().Value;

            MainApiKey = AppSettings
                .Matching("Key", "common.amazonaws.mainkey")
                .First().Value.Decrypt(Salt);

            SecretApiKey = AppSettings
                .Matching("Key", "common.amazonaws.secretkey")
                .First().Value.Decrypt(Salt);

            RootBucket = AppSettings
                .Matching("Key", "common.amazonaws.rootbucket")
                .First().Value.Decrypt(Salt);
        }

        public ListAllMyBucketsEntry[] ListAllMyBuckets()
        {
            try
            {
                var s3 = new AmazonS3();
                return s3.ListAllMyBuckets(
                    MainApiKey,
                   Helper.TimeStamp,
                   true,
                   Helper.GetSignature(
                        SecretApiKey,
                        Operations.ListAllMyBuckets,
                        Helper.TimeStamp
                        )
                    ).Buckets;
            }
            catch (Exception e)
            {
                With.Logger.Get("application");
                With.Logger.Log(e.Message, e, LogInformationType.Error);
                throw;
            }
        }

        public IList<ListEntry> ListBucket(String bucket)
        {
            try
            {
                var s3 = new AmazonS3();
                return s3.ListBucket(
                    bucket,
                    null,
                    null,
                    100,
                    true,
                    "/",
                    MainApiKey,
                    Helper.TimeStamp,
                    true,
                    Helper.GetSignature(
                        SecretApiKey,
                        Operations.ListBucket,
                        Helper.TimeStamp
                        ),
                    null
                    ).Contents.ToList();
            }
            catch (Exception e)
            {
                With.Logger.Get("application");
                With.Logger.Log(e.Message, e, LogInformationType.Error);
                throw;
            }
        }

        public List<PutObjectResult> PutObject(String key, Byte[] data)
        {
            try
            {
                var s3 = new AmazonS3();
                var results = new List<PutObjectResult>();
                var metadataEntries = new MetadataEntry[2];

                metadataEntries[0] = new MetadataEntry { Name = "Content-Type", Value = "text/xml" };
                metadataEntries[1] = new MetadataEntry
                { Name= "ContentLength", Value = data.Length.ToString() };

                results.Add(s3.PutObjectInline(
                    RootBucket,
                     key,
                     metadataEntries,
                    data,
                    data.Length,
                    null,
                    StorageClass.STANDARD,
                    true,
                    MainApiKey,
                    Helper.TimeStamp,
                    true,
                    Helper.GetSignature(
                        SecretApiKey,
                        Operations.PutObjectInline,
                        Helper.TimeStamp
                        ),
                    null
                    ));
                return results;
            }
            catch (Exception e)
            {
                With.Logger.Get("application");
                With.Logger.Log(e.Message, e, LogInformationType.Error);
                throw;
            }
        }

        public List<GetObjectResult> GetObject(String key)
        {
            try
            {
                var s3 = new AmazonS3();
                var results = new List<GetObjectResult>();
                results.Add(s3.GetObject(
                    RootBucket,
                    key,
                   true,
                   true,
                   true,
                   MainApiKey,
                   Helper.TimeStamp,
                   true,
                   Helper.GetSignature(
                        SecretApiKey,
                        Operations.GetObject,
                        Helper.TimeStamp
                        ),
                    null
                    ));
                return results;
            }
            catch (Exception e)
            {
                With.Logger.Get("application");
                With.Logger.Log(e.Message, e, LogInformationType.Error);
                throw;
            }
        }
    }

This leaves the RIA service looking like so.

[EnableClientAccess]
public class AmazonS3Service : DomainService
{
    private static readonly IWrapper AmazonS3Wrapper = With.IoC.GetService<IWrapper>();

    public ListAllMyBucketsEntry[] ListAllMyBuckets()
    {
        return AmazonS3Wrapper.ListAllMyBuckets();
    }

    public IList<ListEntry> ListBucket(String bucket)
    {
        return AmazonS3Wrapper.ListBucket(bucket);
    }

    public List<PutObjectResult> PutObject(String key, Byte[] data)
    {
        return AmazonS3Wrapper.PutObject(key, data);
    }

    public List<GetObjectResult> GetObject(String key)
    {
        return AmazonS3Wrapper.GetObject(key);
    }

}

This works fine but I’m not sure about the hoping, we have to hit the RIA service and then the S3 service.

So, I figure it would be prudent to implement some kind of caching. If we take an online storage system as an example and assume a user has requested a file, there is nothing to stop us holding onto this file in a cache and releasing it at a later date. This minimises the number of calls made to the S3 services.

Anyway, we can call the RIA service from our silverlight app as follows. (Keep in mind this is just an example). _context is defined as private readonly AmazonS3Context _context2;

private void StackPanel_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
    if (sfd.ShowDialog() == false) return;

    _context2.Load(
              _context2.GetObjectQuery("test0.txt"),
              LoadBehavior.RefreshCurrent, delegate
              {
                  Dispatcher.BeginInvoke(
                     delegate
                     {
                         var test = _context2.GetObjectResults.First().Data;
                         using (var fs = sfd.OpenFile())
                         {
                             fs.Write(test, 0, test.Length);
                             fs.Close();
                         }
                     }
                 );
              },
          null);
}

Another example for uploading files is below, again its just an example.

ofd.Filter = "Text Files|*.txt|Xml Files|*.xml|All Files|*.*";
ofd.FilterIndex = 1;
ofd.Multiselect = true;

if (ofd.ShowDialog() == false) return;

foreach(var file in ofd.Files)
{
    Byte[] data = new Byte[file.Length];
    file.OpenRead().Read(data, 0, data.Length);
    _context2.Load(
         _context2.PutObjectQuery(file.Name, data),
         LoadBehavior.RefreshCurrent, delegate
         {
             Dispatcher.BeginInvoke(
                delegate
                {
                    MessageBox.Show("Uploaded");
                }
            );
         },
     null);
}

RIA Services, Silverlight, Metadata and shared code

Mark — Wed, 02 Dec 2009 09:26:23 +0000

In a previous post I tried to show a simple example of using shared code within the RIA Services, Silverlight space.

I had a comment on the last post that said..

“Why would you go to all of this trouble and risk a breakdown in code generation when, based on what you ask of the Folder class here, you can simply link to Folder.cs from your Silverlight project?

Dont see a benefit from the Metadata file hack either; you wrote Folder, you can (and should) put the validation attributes in the Folder.cs class itself.

This approach is confusing. It suggests that BreadCrumbs is the “shared code” when in fact you’re using Folder.shared.cs to trick RIAS into projecting the class.

You’re asking the dev to maintain the code for a single simple class over three seperate files. Yuck.

Where is the RIA services added value to make this worthwhile. I’m missing something”

I felt the need to try and answer some of these points.

1. Why would you go to all of this trouble and risk a breakdown in code generation when, based on what you ask of the Folder class here, you can simply link to Folder.cs from your Silverlight project?

I’m not sure I really understand this point to be honest, if we feel that code generation is a risk then we would not be using RIA Services at all, the whole point is that it projects/generates code to be used by the client. I also dont understand ‘link to Folder.cs from your Silverlight project?’. If we could do that in a way that made entities useable across Silverlight and other platforms then obviously we wouldnt use RIA services to project the entity.

2. Dont see a benefit from the Metadata file hack either; you wrote Folder, you can (and should) put the validation attributes in the Folder.cs class itself.

I dont think I would class the Metadata file as a hack, its the suggested way in the RIA services documentation. Also, there is a good chance that I didnt actually write the Folder class, it may well have been generated from NHibernate, LinqToSQL or another ORM. so we have no choice but to seperate the Metadata into a seperate class.

3. This approach is confusing. It suggests that BreadCrumbs is the “shared code” when in fact you’re using Folder.shared.cs to trick RIAS into projecting the class.

Folder.shared.cs

public partial class Folder

{

    public String BreadCrumbs()

    {

        var breadCrumbs = "";

        var currentFolder = this;

        while (currentFolder != null)

        {

            breadCrumbs = String.Format(@"{0}\{1}", currentFolder.Name, breadCrumbs);

            currentFolder = currentFolder.Parent;

        }

        return breadCrumbs;

    }

}

I dont really see it as being confusing, perhaps it was just the example. The suggestion that BreadCrumbs is the shared code is correct, it is. It is not being used to trick RIA services into projecting the folder class, this happens regardless of the shared code.

If we tried to implement the above BreadCrumbs method in Folder.cs like the example below, then the BreadCrumbs method would not get projected onto the client.

public partial class Folder : IEditableObject

{

    public Int32 Id { get; set; }

    public String Name { get; set; }

    public String Description { get; set; }

    public Int32 ParentId { get; set; }

    public IList<Document> Documents { get; set; }

    public IList<Folder> SubFolders { get; set; }

    public IList<Tag> Tags { get; set; }

    public Folder Parent { get; set; }

    public String BreadCrumbs()

    {

        var breadCrumbs = "";

        var currentFolder = this;

        while (currentFolder != null)

        {

            breadCrumbs = String.Format(@"{0}\{1}", currentFolder.Name, breadCrumbs);

            currentFolder = currentFolder.Parent;

        }

        return breadCrumbs;

    }

    #region IEditableObject implementation

    public void BeginEdit()

    {  

    }

    public void CancelEdit()

    {

    }

    public void EndEdit()

    {

    }

    #endregion

}

The use of the above entity would project the following class from RIA services



    public sealed partial class Folder : Entity

    {

        private string _description;

        private EntityCollection<Document> _documents;

        private int _id;

        private string _name;

        private EntityRef<Folder> _parent;

        private int _parentId;

        private EntityCollection<Folder> _subFolders;

        private EntityCollection<Tag> _tags;

        #region Extensibility Method Definitions

        /// 

        /// This method is invoked from the constructor once initialization is complete and

        /// can be used for further object setup.

        /// 

        partial void OnCreated();

        partial void OnDescriptionChanging(string value);

        partial void OnDescriptionChanged();

        partial void OnIdChanging(int value);

        partial void OnIdChanged();

        partial void OnNameChanging(string value);

        partial void OnNameChanged();

        partial void OnParentIdChanging(int value);

        partial void OnParentIdChanged();

        #endregion

        /// 

        /// Default constructor.

        /// 

        public Folder()

        {

            this.OnCreated();

        }

        [DataMember()]

        [Editable(true)]

        [Required()]

        public string Description

        {

            get

            {

                return this._description;

            }

            set

            {

                if ((this._description != value))

                {

                    this.ValidateProperty("Description", value);

                    this.OnDescriptionChanging(value);

                    this.RaiseDataMemberChanging("Description");

                    this._description = value;

                    this.RaiseDataMemberChanged("Description");

                    this.OnDescriptionChanged();

                }

            }

        }

        [Association("tbl_Document", "Id", "ParentId")]

        [Display(AutoGenerateField=false)]

        public EntityCollection<Document> Documents

        {

            get

            {

                if ((this._documents == null))

                {

                    this._documents = new EntityCollection<Document>(this, "Documents", this.FilterDocuments);

                }

                return this._documents;

            }

        }

        [DataMember()]

        [Display(AutoGenerateField=false)]

        [Key()]

        public int Id

        {

            get

            {

                return this._id;

            }

            set

            {

                if ((this._id != value))

                {

                    this.ValidateProperty("Id", value);

                    this.OnIdChanging(value);

                    this.RaiseDataMemberChanging("Id");

                    this._id = value;

                    this.RaiseDataMemberChanged("Id");

                    this.OnIdChanged();

                }

            }

        }

        [DataMember()]

        [Editable(true)]

        [Required()]

        public string Name

        {

            get

            {

                return this._name;

            }

            set

            {

                if ((this._name != value))

                {

                    this.ValidateProperty("Name", value);

                    this.OnNameChanging(value);

                    this.RaiseDataMemberChanging("Name");

                    this._name = value;

                    this.RaiseDataMemberChanged("Name");

                    this.OnNameChanged();

                }

            }

        }

        [Association("tbl_Folder", "ParentId", "Id", IsForeignKey=true)]

        [Display(AutoGenerateField=false)]

        [ReadOnly(true)]

        public Folder Parent

        {

            get

            {

                if ((this._parent == null))

                {

                    this._parent = new EntityRef<Folder>(this, "Parent", this.FilterParent);

                }

                return this._parent.Entity;

            }

            set

            {

                Folder previous = this.Parent;

                if ((previous != value))

                {

                    this.ValidateProperty("Parent", value);

                    if ((previous != null))

                    {

                        this._parent.Entity = null;

                        previous.SubFolders.Remove(this);

                    }

                    if ((value != null))

                    {

                        this.ParentId = value.Id;

                    }

                    else

                    {

                        this.ParentId = default(int);

                    }

                    this._parent.Entity = value;

                    if ((value != null))

                    {

                        value.SubFolders.Add(this);

                    }

                    this.RaisePropertyChanged("Parent");

                }

            }

        }

        [DataMember()]

        [Display(AutoGenerateField=false)]

        [Editable(false)]

        [ReadOnly(true)]

        public int ParentId

        {

            get

            {

                return this._parentId;

            }

            set

            {

                if ((this._parentId != value))

                {

                    this.ValidateProperty("ParentId", value);

                    this.OnParentIdChanging(value);

                    this._parentId = value;

                    this.RaisePropertyChanged("ParentId");

                    this.OnParentIdChanged();

                }

            }

        }

        [Association("tbl_Folder", "Id", "ParentId")]

        [Display(AutoGenerateField=false)]

        public EntityCollection<Folder> SubFolders

        {

            get

            {

                if ((this._subFolders == null))

                {

                    this._subFolders = new EntityCollection<Folder>(this, "SubFolders", this.FilterSubFolders, this.AttachSubFolders, this.DetachSubFolders);

                }

                return this._subFolders;

            }

        }

        [Association("tbl_FolderTag", "Id", "ParentId")]

        [Display(AutoGenerateField=false)]

        public EntityCollection<Tag> Tags

        {

            get

            {

                if ((this._tags == null))

                {

                    this._tags = new EntityCollection<Tag>(this, "Tags", this.FilterTags);

                }

                return this._tags;

            }

        }

        private bool FilterDocuments(Document entity)

        {

            return (entity.ParentId == this.Id);

        }

        private bool FilterParent(Folder entity)

        {

            return (entity.Id == this.ParentId);

        }

        private void AttachSubFolders(Folder entity)

        {

            entity.Parent = this;

        }

        private void DetachSubFolders(Folder entity)

        {

            entity.Parent = null;

        }
        private bool FilterSubFolders(Folder entity)

        {
            return (entity.ParentId == this.Id);

        }
        private bool FilterTags(Tag entity)
        {
            return (entity.ParentId == this.Id);
        }

        public override object GetIdentity()

        {
            return this._id;
        }

    }

Notice, there is no reference to the BreadCrumbs method, it was simply not projected. This is resolved by including it in Folder.shared.cs which will also get projected to the client ‘as is’.