Jaime Febres - .Net Programming

Heartysoft.com | Anonymous Types are Internal, C# 4.0 Dynamic Beware!

2010-09-17T21:53:00.000-05:00

Just found this interesting article:

Heartysoft.com | Anonymous Types are Internal, C# 4.0 Dynamic Beware!

That explained why my spark templates where failing at runtime because the default dynamic object only works for public and non-internal members.

I implemented the following class in order to use dynamic and non-dynamic models in our spark templates that are used in standalone mode for emailing templating:

public class DynamicViewData : DynamicObject

{

private readonly object _model;

public DynamicViewData(object model)

{

_model = model;

}

public override bool TryGetMember(GetMemberBinder binder, out object result)

{

var member = _model.GetType().GetMember(binder.Name,

BindingFlags.Instance |

BindingFlags.Public |

BindingFlags.NonPublic).FirstOrDefault();

if (member != null)

{

switch (member.MemberType)

{

case MemberTypes.Field:

result = ((FieldInfo)member).GetValue(_model);

return true;

case MemberTypes.Property:

result = ((PropertyInfo)member).GetValue(_model, null);

return true;

}

return base.TryGetMember(binder, out result);

}

And a custom AbstractSparkView which has a dynamic property where I'm passing an instance of this class together with the anonymous model.

Now I don't have to define in my spark templates the model type, and also I don't have to define in my code every single viewmodel.

Logging and Metrics using Gibraltar – A Windows Form Sample App

2010-09-15T02:44:00.002-05:00

Introduction

Hello dear reader, have been such a long time. As usual the amount of work at the office I’ve to do on a daily basis, side projects, the occasional colleague asking for help, and last but not least, family life, made almost impossible to write any post on this blog lately, luckily today I’ve found a bit of spare time to do so and I hope you like this blog post.

So, what’s Gibraltar? To my understanding, Gibraltar is an step forward to create components that are categorized as those that work as cross cutting concerns in an application, in plain English that would mean that those components are part of the application but do not belong to the business domain of it.
A simple example could be Logging, or User Auditing in a CRM application, because the reason of existence of a CRM application is not to perform any of those tasks, but to handle your contacts, calendars, events and so on.
This is one of the keys concepts when doing AOP programming.

what are the MAIN components of gibraltar

Basically Gibraltar is based on two components:

Gibraltar Agent
This is a .Net library that provides the API to perform most of the job needed. It’s the principal component, without this you wouldn’t be able to collect the precious information from your application.
Gibraltar Analyst
This is a user friendly standalone application used to analyze the data sent by your application. Provides several built-in tools to display/filter/sort/group the data generated by the Gibraltar Agent.

There’s a third optional component, the Gibraltar Hub, which is a service to host in a centralized place all the data generated by your applications.

For an in-deep look of what those three components are all about, I recommend you to check the following resources:

Getting Started Guide
Gibraltar Architecture
Gibraltar Hub FAQ
Gibraltar Try It FAQ

The sample app

This is a fictitious application that allows you to manage your contacts from several sources like GMail, Facebook and so on.

As you can see, we’ve a simple IFeature interface that is used by concrete classes to be recognized in the system as a feature of it. This interface has a Execute method which is used by the UI to make the feature to run.
I’ve created a base class (FeatureBase) to simplify the implementation of some of the interface members.
Below I’ll show you the code of this class and of the DisplayContactsFromGMail class, the other two classes are pretty identical and do not make much sense to repeat myself over and over.

    public abstract class FeatureBase : IFeature
  {
      public abstract Guid Id { get; }

      public string Name
      {
          get { return GetType().Name; }
      }

      public abstract string Description { get; }

      public virtual void Execute()
      {
          MessageBox.Show(@"Executing Feature " + Name);
      }
  }

    public class DisplayContactsFromGMail : FeatureBase
  {
      public override Guid Id
      {
          get { return Guid.Parse("614DFAA4-70F7-4F5F-82D4-9598C0F39F60"); }
      }

      public override string Description
      {
          get { return "Display Contacts from your GMail Account"; }
      }
  }

As you can see, very simple classes according with the scope of this post.

The second part of the application is the component in charge of discovering and providing the features. It could be implement in many ways, for instance by using a DI tool like StructureMap or Autofac. I choose a simple reflection approach, that is, look at the IFeature assembly for types implementing this interface.

The FeatureCatalog is implemented as follows:

    public class FeatureCatalog : IFeatureCatalog
  {
      private readonly IEnumerable<IFeature> _features;

      public FeatureCatalog()
      {
          _features = typeof(FeatureCatalog)
              .Assembly
              .GetTypes()
              .Where(x => x.IsPublic)
              .Where(x => x.IsClass)
              .Where(x => !x.IsAbstract)
              .Where(x => typeof(IFeature).IsAssignableFrom(x))
              .Select(Activator.CreateInstance)
              .Cast<IFeature>()
              .ToList();
      }

      public IEnumerable<IFeature> Features
      {
          get { return _features; }
      }
  }

Did I said I really love LINQ? :)

Ok, now we’ve everything in place let’s create a simple UI to use the implemented features; if you think this the worst UI you’ve seen in you whole life, please bear with me, UI design is not one of my strong skills :)

We’ll load the list of features in the listbox control, and the button at the right side will just execute the selected feature.

Let’s take a look at the code used to load the features into the listbox and the code of the button click event.

        private void Form1_Load(object sender, EventArgs e)
      {
          FeaturesList.DataSource = new FeatureCatalog().Features;
      }

      private void ExecuteFeatureButton_Click(object sender, EventArgs e)
      {
          ((IFeature) FeaturesList.SelectedItem).Execute();
      }

Pretty simple uh? Lets see how the app behaves when executing the DisplayContactsFromGMail feature.

Selecting other features and clicking the button at the right side produces the same effect (display a messagebox with a generic description).

Introducing Gibraltar

Now you may be wondering, “WTF? I’ve not seen any Gibraltar usage anywhere!!”.

I know, I know…please be patience.

Well, let’s say your boss tells you that the users are complaining about the large list of items being displayed on the listbox (menu, tabs or any other method you real app would use to show the available features). Your boss ask you to determine which are the most used features from the application and display the top X in your original control (the listbox) and the rest somewhere else.

So, the first thing you’ve to do is to update the app to track the features usage and determine which are the most used in a given period of time and deploy this new version of the app to your clients, after a few days of monitoring you’ll know what to do and what features put apart.

We could use several different options here, like Dynamic Proxy, Postsharp for IL Weaving, and a few more. But what we can’t do is obviously start manually changing one class at a time to do this, that would be a daunting,tedious and error prone task.

The question is…where should we inject this? In the button click handler…for the scope of this article would probably do the trick, but I suppose in a real project a feature X could call to another feature from the catalog.

So if the catalog is the entry point to retrieve features, then the catalog is the place where this new code should be implemented.

What I’m going to do is to create an IFeature implementation that will act as a wrapper of the real implementations. Each IFeature member implemented in this wrapper will simply forward the call to the real feature undercover, excepting the Execute method where I’m going to record the the feature usage and after that the wrapper will continue with the execution flow.

The usage recording will be performed in a helper class where the Gibraltar related code will be dropped.

Gibraltar besides the normal logging of messages it has something called Metrics, that as its name implies, is specially designed to this kind of scenarios where we need to measure certain aspect of our applications, for this scenario, we will sum the number of times a feature is used, another could be determine what’s the average number of emails our users sent per day and so on.

Is time to modify our application to include the required Gibraltar configuration settings and references…but don’t worry, this step is the easiest one (and the most fun of all of them).

First of all, you’ll need to download and install the Gibraltar bits from here.

Once you have everything in place, go and execute the Gibraltar Analyst program. Bellow are the steps required to enable Gibraltar in your app:

Tools / Add Gibraltar to an Application.

Click on the “…” button and navigate and select your project file and click the “Open” button in the window dialog.

A set of options will get enabled on this screen, choose “Add the Gibraltar Agent to this Application”.

The next step will ask you how do you want that the Agent categorize your Application, just pick up the option “Automatically Determine Options”.

In the step “How should session data be reported to you?” we will choose to use the Gibraltar Hub just for fun, you can leave the other options unchecked.

Now in this step it will ask you for an account name or the settings of your private hub service. We will choose to provide an account name for our hub service. You can get a 30 days renewable trial of the hub service from the Gibraltar web page here. Just check the options you see below, follow the instructions and in a matter of minutes you’ll have a hub and the client side tooling required to get your app up and running.

Once you’ve registered your hub service trial, introduce the name of your service in the input box and you’re almost ready to go.

This step is about configuring how do you like to sent your sessions data, I just leave the suggested options checked.

And that’s all.

Once you perform the steps I outlined above, your project will reload itself with the references and all you need to start integrating your application with Gibraltar.

Now that you’ve configured your project to work together with the Gibraltar Agent. It’s time to configure your Gibraltar Analyst to fetch the generated data from the Gibraltar Hub.

Tools/Connect to Hub…

And that’s all folks, you can start fetching data from your hub and view it locally in the Analyst client.

Let’s continue with the implementation of our wrapper.

using System;
using ContactsManager.Metrics;
using Gibraltar.Agent;

namespace ContactsManager.Features
{
  public class FeatureWrapper : IFeature
  {
      private readonly IFeature _feature;

      public FeatureWrapper(IFeature feature)
      {
          _feature = feature;
      }

      public string Name
      {
          get { return _feature.Name; }
      }

      public Guid Id
      {
          get { return _feature.Id; }
      }

      public string Description
      {
          get { return _feature.Description; }
      }

      public void Execute()
      {
          FeatureUsageRecorder.Record(_feature, 1);
          Log.Information("Contacts Manager", "Feature Usage", "Feature {0} executed", _feature.Name);
          try
          {
              _feature.Execute();
          }
          catch (Exception ex)
          {
              Log.Error(ex, "Contacts Manager", "{0} Error {1}", _feature.Name,ex.ToString());
              throw;
          }
      }
  }
}

As you can see, it forwards the calls to the real feature (_feature member), and when it gets the time to call to Execute, it uses the FeatureUsageRecorder static class and records this action, logs entrance to the method, it continues by calling the Execute method of the underlying feature, and it case of failure logs the exception.

Now we need to modify the catalog to wrap the features using this new class.

    public class FeatureCatalog : IFeatureCatalog
  {
      private readonly IEnumerable<IFeature> _features;

      public FeatureCatalog()
      {
          _features = typeof(FeatureCatalog)
              .Assembly
              .GetTypes()
              .Where(x => x.IsPublic)
              .Where(x => x.IsClass)
              .Where(x => !x.IsAbstract)
              .Where(x => typeof(IFeature).IsAssignableFrom(x))
              .Where(x => !typeof(FeatureWrapper).IsAssignableFrom(x))
              .Select(Activator.CreateInstance)
              .Cast<IFeature>()
              .Select(x => new FeatureWrapper(x))
              .ToList();
      }

      public IEnumerable<IFeature> Features
      {
          get { return _features; }
      }
  }

As you can see there, I’m excluding from the assembly scanning to the FeatureWrapper class, and once the IFeature implementations had been instantiated, I’m wrapping them all into the FeatureWrapper class just before calling to ToList in the IEnumerable. This ensure us that the application will still work as usual and that the features are not aware of the fact that we are generating metrics when our clients make use of them.

And what everyone was waiting, the code for the FeatureUsageRecorder class (including imported namespaces):

using ContactsManager.Features;
using Gibraltar.Agent.Metrics;

namespace ContactsManager.Metrics
{
  public static class FeatureUsageRecorder
  {
      private const string MetricKey = "Feature name";
      private const string MetricDataObjectType = "ContactsManager";
      private const string CategoryName = "Features";
      private const string MetricDescription = "Number of times this feature has been used.";
      private const string UnitCaption = "Number of Calls";
      private const string Caption = "Usage";
      private const string CounterName = "Contacts Manager Feature Usage";
      private static readonly EventMetricDefinition _featureUsageMetric;

      static FeatureUsageRecorder ()
      {
          if (!EventMetricDefinition.TryGetValue(MetricDataObjectType, CategoryName, CounterName, out _featureUsageMetric))
          {
              _featureUsageMetric = new EventMetricDefinition(MetricDataObjectType, CategoryName, CounterName);
              _featureUsageMetric.AddValue(MetricKey, typeof(int), SummaryFunction.Sum, UnitCaption, Caption,
                                   MetricDescription);
              EventMetricDefinition.Register(ref _featureUsageMetric);
          }
      }

      public static void Record(IFeature feature, int count)
      {
          var metricEntry = EventMetric.Register(_featureUsageMetric, feature.Name);
          var metricSample = metricEntry.CreateSample();
          metricSample.SetValue(MetricKey, count);
          metricSample.Write();
      }
  }
}

As you can see from the code above, Gibraltar lets you write custom Metrics and defining the fields that this metric will contain.

We are defining a “Contacts Manager Feature Usage” metric under certain category (“Features”), this metric belongs to the “ContactsManager” metric data object type. All of this are arbitrary names, you could choose whatever fits your needs.

Now this metric would be pointless if does not measure anything, so we register a unit that will be keyed with the value of the const MetricKey (“Feature name”), will have a int type, the summary function is defined as a sum of their column, and so on.

In the Record method, we take in a IFeature instance and just store the number of times this feature is used, currently hardcoded to 1, I thought it could be a good idea to call this method each X times a certain feature is used instead of calling it as soon as the feature is used as it is right now.

Now lets execute the application and start clicking the button many times for each feature.
Now close the application and check the Gibraltar Analyst application.
What you will see is something like this:

Clicking on the first row will open the following screen:

That’s an extensible and user friendly view of the log entries generated by our application (remember those Log.Information calls from the FeatureWrapper class??). Also this screen provides with filters in order to remove all the collected data that you don’t want to see.

What about our metrics, after all, that was the whole purpose of using Gibraltar. In this screen click onto the “New View” option at the top. You’ll see a pop-up like this one:

Please choose the “New Chart” option, later you can play with the other options.

That will open the metric reporting designer. From the threeview in the left side, expand the content under Metrics/Feature, drag and drop the item named “Contact Manager Feature Usage”:

After performing that command, you’ll get a dialog to define your report, choose the options I show you in the next screenshot:

Click “Ok” and you’ll get the following report:

Final thoughts

As you can see, it was very easy to introduce Gibraltar into our App and get the benefits from a robust product that has almost all what you may need to trace and get rich information from your application without much effort.

For the record, Gibraltar comes with a set of built-in aspects (Postsharp attributes) that somehow, make even easier to work with it (GTrace, GTraceField, and so on). You can read about them here.

I didn’t use it those aspects because they require Postsharp in place for the IL weaving and that would complicated even more the infrastructure code required to run the sample app, and also my experience tells me that Postsharp will work only if you are in control of the application (that means, the source code)…the approach I used here would work in a environment where the features are loaded using a plugin architecture.

You can download the sample app from here.

See you soon.

Dealing with legacy code when using TDD

2010-07-08T18:24:00.001-05:00

Introduction

You may have heard about TDD lately and how great it is and so on, but most the time we work on projects that have a large code base and we are not allowed to make drastic changes.

Tools

NUnit

Scenarios

In my experience some of the scenarios we face when refactoring legacy code are:

We are free to apply the changes we want, the world is perfect. :)
We can apply the changes we want but only with unit testing purposes, production code should work as usual.
We are not allowed to change any part of the code except infrastructure but remembering that things must work as always did, no breaking changes allowed.

Let’s elaborated on each one of those scenarios and how do we perform our changes to make legacy code more testable.

Concrete Example

    public static class DataBaseHelper
    {
        public static void Persist(object instance)
        {
            Console.WriteLine("Persisting object " + instance);
        }
    }

    public class ProductService
    {
        public void DisableProduct(Product product)
        {
            product.Enabled = false;
            DataBaseHelper.Persist(product);
        }
    }

As you can see, the Persist method from the DataBaseHelper does nothing, but we will assume we’ve some hard dependency with a database, perhaps an sqlconnection here an sqlcommand there and so on.

Now, what’s so bad with this piece of code? Most of us have seen,done and maintained stuffs like that for years and if you’re fine with this, go ahead, I’m not here to tell you what’s wrong and what’s perfect, there’re no perfect solutions. However I would like to show you another way, a better way in my opinion.

I asked what was bad with that piece of code and I’ve not answered that yet…Let’s see:

Can you be really sure that in the following days/weeks/months/years that code will work as expected?

If in the future you found a bug in the system, how would you discard the problem cause is not related to this method? And when checking this fact, do you need to have your debugger/visual studio instance up and running?

I suppose that the answers didn’t were so pleasant at all, but don’t worry, the idea of this article is to help you to find a sane path when developing software by using TDD.

What should our tests cover

Well, there are a couple of things we should ensure in our tests:

The product passed to the service method enters with its Enabled property with a True value, and must exits with a value of False.

The service should persist the updated product instance.

Now lets back to the Scenarios section and supply a workaround for every one of those points.

We are free to apply the changes we want, the world is perfect. :)

This allows us to use a fantastic set of patterns, I’m talking about Inversion Of Control and Dependency Injection.

By using that, we can make the following changes:

    public class ProductService
    {
        private readonly IProductRepository _productRepository;

        public ProductService(IProductRepository productRepository)
        {
            _productRepository = productRepository;
        }

        public void DisableProduct(Product product)
        {
            product.Enabled = false;
            _productRepository.Persist(product);
        }
    }

    public interface IProductRepository
    {
        void Persist(Product product);
    }

    public class ProductRepository : IProductRepository
    {
        public void Persist(Product product)
        {
            DataBaseHelper.Persist(product);
        }
    }

    public static class DataBaseHelper
    {
        public static void Persist(object instance)
        {
            Console.WriteLine("Persisting object " + instance);
        }
    }

And introduce the following tests:

    public class Scenario1Tests
    {
        #region Mocks
        private class NoOpProductRepository : IProductRepository
        {
            public void Persist(Product product)
            {
                // no-op
            }
        }

        private class VerifiableProductRepository : IProductRepository
        {
            public event Action<Product> ProductPersisted;
            public void Persist(Product product)
            {
                var productPersistedEvent = ProductPersisted;
                if (productPersistedEvent != null)
                    productPersistedEvent(product);
            }

        }

        #endregion


        [Test]
        public void when_disabling_a_product_its_enabled_property_is_set_to_false()
        {
            // Arrange
            var product = new Product
                              {
                                  ProductId = 1,
                                  ProductName = "Car",
                                  Enabled = true
                              };
            // here we should use a mocking framework like Moq or Rhino.Mocks.
            IProductRepository mockedRepository = new NoOpProductRepository();

            var service = new ProductService(mockedRepository);

            // Act
            service.DisableProduct(product);

            // Assert
            Assert.AreEqual(false, product.Enabled);
        }

        [Test]
        public void when_disabling_a_product_it_persist_the_changes_using_the_product_repository()
        {
            // Arrange
            var product = new Product
            {
                ProductId = 1,
                ProductName = "Car",
                Enabled = true
            };
            Product productPassedToPersistMethod = null;
            var valueOfProductEnabledPropertyPassedToPersistMethod = false;
            // here we should use a mocking framework like Moq or Rhino.Mocks.
            var mockedRepository = new VerifiableProductRepository();
            mockedRepository.ProductPersisted +=
                instance =>
                    {
                        productPassedToPersistMethod = instance;
                        valueOfProductEnabledPropertyPassedToPersistMethod = instance.Enabled;
                    };

            var service = new ProductService(mockedRepository);

            // Act
            service.DisableProduct(product);

            // Assert
            Assert.IsNotNull(productPassedToPersistMethod);
            Assert.AreSame(product, productPassedToPersistMethod);
            Assert.AreEqual(false, valueOfProductEnabledPropertyPassedToPersistMethod);
        }


    }

As you can see, those are quite drastic changes, in order to use again our ProductService now we have to supply an IProductRepository implementation because its constructor demands one. The usage of the static helper class to access to the database it has been moved our concrete implementation of the ProductRepository which is likely to be used at runtime. This is where the usage of a IoC/DI tool like StructureMap really shines because it will help us to configure such concerns (i.e. connect IProductRepository with ProductRepository) and make it transparent its usage.

Now what do we gain by doing this? Well, now we can test the ProductService.DisableProduct method at our pleasure by mocking its dependencies and ensuring everything works as expected. If someone in the future try to mess with the implementation of such method or if we’ve to introduce changes into our system, we’ll have those two unit tests to cover our backs and they’ll let us sleep tight at night. I think you can figure out what the tests does by just looking at the code, it is fairly simple and it does not take more than 10 minutes to create them.

We can apply the changes we want but only with unit testing purposes, production code should work as usual.

Here we can use something called Poor Man’s Dependency Injection, you can read about it here, and let me tell you something, I agree with the thoughts Jimmy Bogard give us in that article. And I really think dear developer we should strive all the time for option number one, push harder to let management change the infrastructure to use proper architecture and a DI/IoC tool. However, the world is not perfect and management or our work environment isn’t always too kind to accept changes.

So what we do?, we take the code from the first approach and modify the ProductService class and introduce a parameterless constructor which calls to the constructor that takes in an IProductRepository instance and pass to it an instance of the ProductRepository class, thus, removing the need of a DI/IoC tool to build the instances in our regards.

Here is the code to illustrate what I was mumbling in the previous paragraph:

    public class ProductService
    {
        private readonly IProductRepository _productRepository;

        public ProductService()
            : this(new ProductRepository())
        {

        }

        public ProductService(IProductRepository productRepository)
        {
            _productRepository = productRepository;
        }

        public void DisableProduct(Product product)
        {
            product.Enabled = false;
            _productRepository.Persist(product);
        }
    }

The tests and all the other stuff we added remain the same, we still have a testable ProductService class.

We are not allowed to change any part of the code except infrastructure but remembering that things must work as always did, no breaking changes allowed.

This means, no interfaces, no repositories, nothing, thus, no new concepts are allowed to be introduced into the principal code base, you should keep your changes as low as possible.

Well, I must reckon that does not let us with much choices to pick from…but even in such inflexible environment we can do better with simple approaches.

What we will do is to take our helper and make it flexible enough to allow us check the ProductService will work as expected in the future. Certainly this technique isn’t mine, at the moment I can find the resource where I first time read about it, so, if someone have a link, be my guest.

    public static class DataBaseHelper
    {
        private static Action<object> _persistenceDelegate;

        static DataBaseHelper()
        {
            _persistenceDelegate = instance => Console.WriteLine("Persisting object " + instance);
        }

        public static void SetPersistenceDelegate(Action<object> persistenceDelegate)
        {
            _persistenceDelegate = persistenceDelegate;
        }
        public static Action<object> GetPersistenceDelegate()
        {
            return _persistenceDelegate;
        }

        public static void Persist(object instance)
        {
            _persistenceDelegate(instance);
        }
    }

As you can see, our static helper now can swap the logic used in the Persist method by way of the SetPersistenceDelegate method, the GetPersistenceDelegate is there only to satisfy the unit test needs, we would like to reset the value of the delegate on each test (don’t worry I’ll show this later). Another thing to note is that those two methods are public, well, I suppose we could make them internal and allow only the unit test assembly to use them, is up to the reader to do that too, for the sake of this demo I think it is ok (hint:InternalsVisibleToAttribute).

Now, let’s see how our unit tests look like:

    public class Scenario3Tests
    {
        #region Init, Before and After each test
        private Action<object> _originalDelegate;

        [TestFixtureSetUp]
        protected  void Init()
        {
            _originalDelegate = DataBaseHelper.GetPersistenceDelegate();
        }

        [SetUp]
        protected void BeforeEachTest()
        {
            DataBaseHelper.SetPersistenceDelegate(_originalDelegate);
        }

        [TearDown]
        protected void AfterEachTest()
        {
            DataBaseHelper.SetPersistenceDelegate(_originalDelegate);
        }

        #endregion

        [Test]
        public void when_disabling_a_product_its_enabled_property_is_set_to_false()
        {
            // Arrange
            var product = new Product
                              {
                                  ProductId = 1,
                                  ProductName = "Car",
                                  Enabled = true
                              };
            var service = new ProductService();

            // Act
            service.DisableProduct(product);

            DataBaseHelper.SetPersistenceDelegate(instance =>
                                                      {
                                                          // no-op! 
                                                      });
            // Assert
            Assert.AreEqual(false, product.Enabled);
        }

        [Test]
        public void when_disabling_a_product_it_persist_the_changes_using_the_product_repository()
        {
            // Arrange
            var product = new Product
            {
                ProductId = 1,
                ProductName = "Car",
                Enabled = true
            };
            Product productPassedToPersistMethod = null;
            var valueOfProductEnabledPropertyPassedToPersistMethod = false;
            DataBaseHelper.SetPersistenceDelegate(
                instance =>
                    {
                        productPassedToPersistMethod = (Product) instance;
                        valueOfProductEnabledPropertyPassedToPersistMethod = productPassedToPersistMethod.Enabled;
                    });

            var service = new ProductService();

            // Act
            service.DisableProduct(product);

            // Assert
            Assert.IsNotNull(productPassedToPersistMethod);
            Assert.AreSame(product, productPassedToPersistMethod);
            Assert.AreEqual(false, valueOfProductEnabledPropertyPassedToPersistMethod);
        }
    }

As you can see, the underlying idea of the tests remain the same, instead of using mocked repositories, we are using custom delegates and updating the helper delegate per test run to fit the test needs.

Finale

Well, I hope this article have gave you dear reader an idea of how to unit test legacy code. Please bear with me if I’ve made some silly statement, if so, please let me know so I can learn a few tricks too ;)

Also, I’ve not quite explained very well how a DI/IoC tool should be used to help us to resolve the dependencies at runtime, I’ll try to make another article to explain this, if you can’t wait there’s plenty of articles out there in the net from where you can learn of this subject.

You can download the sample code from here.

A quick look at the Reactive Extensions (Rx) for .Net

2009-12-14T14:21:00.001-05:00

Introduction and some words about what I’ve been doing lately

Hello everyone, first of all, let me tell you that I’ve been very busy at work, we finally released a site for one of our customers and is a pleasure to see our hard work materialized in such a nice website.
We worked pretty hard particularly in the eCommerce module, which lead us to learn a lot of new paradigms and even more tools and frameworks around that module. Also I think the designers made a great work on the look and feel side of things, what can I say? I’m part of a great team. You can visit the site here.

Furthermore, there are a couple of personal projects for the next year which had get me very excited. So stay tuned for further info about this, I know you, dear reader, will really like it :)

Back to the subject, so, ¿what’s Rx?, again, I’m not so good at giving definitions or concepts, and in order to avoid any misunderstanding, here’s an excerpt from the project home page:

Rx is a library for composing asynchronous and event-based programs using observable collections.

…

Rx is a superset of the standard LINQ sequence operators that exposes asynchronous and event-based computations as push-based, observable collections via the new .NET 4.0 interfaces IObservable<T> and IObserver<T>. These are the mathematical dual of the familiar IEnumerable<T> and IEnumerator<T> interfaces for pull-based, enumerable collections in the .NET framework.

The Rx project is a new project from Microsoft and I hope you to play with it and when it becomes an stable library start using it in your projects together with other niceties that Microsoft is lately releasing to the public in general.

You may infer from the excerpt above that this is only available for .Net 4.0, but in fact it is also available for .Net 3.5. Check the downloadable installers and you’ll see there are 3 different versions of Rx: One for .Net 3.5, other for .Net 4.0 Beta 2, and another for Silverlight 3.

The code I’m going to present you today is using the .Net 3.5 bits (to reach a broader audience), but I think it is also applicable to .Net 4.0, I am not sure about Silverlight 3.

There’s a great set of articles which will introduce you into Rx way more articulated that I’m doing it, I’ve read them all and found them very useful:

Also, there’s a wiki with a great amount of information about the Rx API which is updated from time to time, you check it out here.

demonstrating Rx usage

As usual, I tend myself to explain things in code, together with a *common* scenario, well, at least one that could slightly reflect real world issues. However, this is completely relative from developer to developer.

The scenario is as follows, in our company we’ve a website that requires the following notifications:

Register all the visits.
When the user visiting our site is a new one, sent a notification to the webmaster about this.
When the user visiting our site is from USA or UK, sent a notification to the webmaster about this.

Those are roughly what the user tell to us, we as developer, add a couple of niceties that the user is not aware of:

In order to avoid spamming the webmaster email account, we sent those emails by chunks X, and each feature has a way to set the threshold. For our sample we are going to set this value to 4, but in a real app you must provide perhaps a UI with a database or some other way to configure this.

Now, lets define our ISiteVisitorsService interface:

    1 public interface ISiteVisitorsService
    2 {
    3     void StartMonitoring();
    4     IObservable<IEvent<VisitEventArgs>> NewVisitsObservable { get; }
    5     event EventHandler<VisitEventArgs> NewVisitEvent;
    6 }

The VisitEventArgs and its surrounding classes are structured as follows:

    1 public class VisitEventArgs : EventArgs
    2 {
    3     public VisitDetails VisitDetail { get; set; }
    4 }

    1 public class VisitDetails
    2 {
    3     public int VisitId { get; set; }
    4     public string FirstName { get; set; }
    5     public string LastName { get; set; }
    6     public VisitTypes VisitType { get; set; }
    7     public Contries Country { get; set; }
    8     public DateTime VisitDate { get; set; }
    9     public int VisitCount { get; set; }
   10 }

    1 public enum VisitTypes
    2 {
    3     FirstVisitor = 0,
    4     ReturningVisitor = 1,
    5 }

    1 public enum Contries
    2 {
    3     Usa = 0,
    4     Uk = 1,
    5     China = 2,
    6     Other = 3
    7 }

    1 public static class VisitorHandlerHelper
    2 {
    3     public static void LogVisit(IEnumerable<VisitDetails> visitDetails)
    4     {
    5         foreach (var visitDetail in visitDetails)
    6         {
    7             Console.WriteLine();
    8             Console.WriteLine("Registering visit => {0}: {1} {2} {3} {4} {5} {6}", visitDetail.VisitId,
    9                               visitDetail.FirstName, visitDetail.LastName, visitDetail.VisitType,
   10                               visitDetail.Country,
   11                               visitDetail.VisitDate, visitDetail.VisitCount);
   12         }
   13     }
   14 
   15     public static void SendEmailForEnglishSpeakersVisitors(IEnumerable<VisitDetails> visitDetails)
   16     {
   17         foreach (var visitDetail in visitDetails)
   18         {
   19             Console.WriteLine(
   20                 "Sending email to webmaster notifying an english speaker visitor => {0}: {1} {2} - {3}",
   21                 visitDetail.VisitId,
   22                 visitDetail.FirstName,
   23                 visitDetail.LastName,
   24                 visitDetail.Country);
   25         }
   26     }
   27 
   28     public static void SendFirstVisitorMessage(IEnumerable<VisitDetails> visitDetails)
   29     {
   30         foreach (var visitDetail in visitDetails)
   31         {
   32             Console.WriteLine("Sending email to webmaster notifying a new visitor => {0}: {1} {2} {3} {4} {5}",
   33                               visitDetail.VisitId,
   34                               visitDetail.FirstName,
   35                               visitDetail.LastName,
   36                               visitDetail.Country,
   37                               visitDetail.VisitType,
   38                               visitDetail.VisitCount);
   39         }
   40     }
   41 }

I provide two flavors to hook into the scenario where a new visitor arrives, the old fashioned will use the NewVisitEvent, and the others could use the Rx IObservable interface. I’ve added to StartMonitoring method to tell the service to enable firing events when new visitors land to our site. Obviously, I’m have no plans in implement a real monitoring service, rather you’ll see a faked service here. The implementations looks as follows:

    1 public class SiteVisitorsService : ISiteVisitorsService
    2 {
    3     private readonly IObservable<IEvent<VisitEventArgs>> _visitsObservable;
    4     private readonly string[] _names = new[] { "John", "Alex", "Jose", "Frank", "Laura", "Marco", "Mary" };
    5     private readonly string[] _lastNames = new[] { "Cruz", "Smith", "Gonzales", "Garcia", "Williams" };
    6 
    7     public event EventHandler<VisitEventArgs> NewVisitEvent;
    8 
    9     public SiteVisitorsService()
   10     {
   11         _visitsObservable = Observable.FromEvent<VisitEventArgs>(handler => NewVisitEvent += handler,
   12                                                           handler => NewVisitEvent -= handler);
   13     }
   14 
   15     public void StartMonitoring()
   16     {
   17         ThreadPool.QueueUserWorkItem(runSimulation);
   18     }
   19 
   20     public IObservable<IEvent<VisitEventArgs>> NewVisitObservable
   21     {
   22         get { return _visitsObservable; }
   23     }
   24 
   25     private void invokeNewVisitEvent(VisitEventArgs e)
   26     {
   27         var newVisitEvent = NewVisitEvent;
   28         if (newVisitEvent != null)
   29         {
   30             newVisitEvent(this, e);
   31         }
   32     }
   33 
   34     private void runSimulation(object state)
   35     {
   36         var visitId = 0;
   37         while (true)
   38         {
   39             Thread.Sleep(2000);
   40             var rnd = new Random();
   41             var visitType = (VisitTypes) rnd.Next(0, 2);
   42             var visitDetail = new VisitDetails
   43                                   {
   44                                       VisitId = visitId++,
   45                                       Country = (Contries) rnd.Next(0, 4),
   46                                       FirstName = _names[rnd.Next(0, _names.Length)],
   47                                       LastName = _lastNames[rnd.Next(0, _lastNames.Length)],
   48                                       VisitCount = visitType == VisitTypes.FirstVisitor ? 1 : rnd.Next(1, 2000),
   49                                       VisitDate = DateTime.Now.AddMonths(rnd.Next(0, 12)),
   50                                       VisitType = visitType
   51                                   };
   52             invokeNewVisitEvent(new VisitEventArgs()
   53                                     {
   54                                         VisitDetail = visitDetail
   55                                     });
   56         }
   57     }
   58 
   59 }

I think the code is pretty clear on what it does, what’s interesting about the code is the following snippet:

_visitsObservable = Observable.FromEvent<VisitEventArgs>(handler => NewVisitEvent += handler,
                                                  handler => NewVisitEvent -= handler);

What I’m doing there is creating an IObservable (thus, an instance that sent notifications) from our NewVisitEvent.
The FromEvent extension method has the following signature:

public static System.IObservable<IEvent<TEventArgs>> FromEvent<TEventArgs>(System.Action<EventHandler<TEventArgs>> addHandler, System.Action<EventHandler<TEventArgs>> removeHandler)
where TEventArgs : System.EventArgs

As you can see, it’s a generic method which expect an inheritor of EventArgs, that would be our VisitEventArgs class, and also a delegate to add and remove handlers to this event.

Now, lets define our handlers, they should apply to the following interface:

    1 public interface IVisitorHandler
    2 {
    3     void RegisterListeners(ISiteVisitorsService service);
    4 }

The old way of do things

First, our old fashioned handler:

    1 public class OldFashionedVisitorHandler : IVisitorHandler
    2 {
    3     private static readonly List<VisitDetails> VisitsBuffer = new List<VisitDetails>();
    4     private static readonly List<VisitDetails> EnglishSpeakersVisitorsBuffer = new List<VisitDetails>();
    5     private static readonly List<VisitDetails> FirstVisitorBuffer = new List<VisitDetails>();
    6 
    7     public void RegisterListeners(ISiteVisitorsService service)
    8     {
    9         service.NewVisitEvent += serviceNewVisitHandler;
   10     }
   11 
   12     static void serviceNewVisitHandler(object sender, VisitEventArgs e)
   13     {
   14         var visitDetail = e.VisitDetail;
   15         VisitsBuffer.Add(visitDetail);
   16         if (VisitsBuffer.Count == VisitorHandlerHelper.LogVisitThreshold)
   17         {
   18             VisitorHandlerHelper.LogVisit(VisitsBuffer);
   19             VisitsBuffer.Clear();
   20         }
   21         if (visitDetail.Country == Contries.Uk || visitDetail.Country == Contries.Usa)
   22         {
   23             EnglishSpeakersVisitorsBuffer.Add(visitDetail);
   24             if (EnglishSpeakersVisitorsBuffer.Count == VisitorHandlerHelper.SendEmailForEnglishSpeakersVisitorsThreshold)
   25             {
   26                 VisitorHandlerHelper.SendEmailForEnglishSpeakersVisitors(EnglishSpeakersVisitorsBuffer);
   27                 EnglishSpeakersVisitorsBuffer.Clear();
   28             }
   29         }
   30         if (visitDetail.VisitType == VisitTypes.FirstVisitor)
   31         {
   32             FirstVisitorBuffer.Add(visitDetail);
   33             if (FirstVisitorBuffer.Count == VisitorHandlerHelper.SendFirstVisitorMessageThreshold)
   34             {
   35                 VisitorHandlerHelper.SendFirstVisitorMessage(FirstVisitorBuffer);
   36                 FirstVisitorBuffer.Clear();
   37             }
   38         }
   39     }
   40 }

Now, please look at the serviceNewVisitHandler static method, all those if statements, the thing about the three buffers to hold the VisitDetails instances (VisitsBuffer, EnglishSpeakersVisitorsBuffer and FirstVisitorBuffer), a complete mess!, also all that complexity add noises and hides the real purpose of the class. Also one last thing, in the RegisterListeners method we are using the NewVisitEvent event to handle when a new visitor arrives.
To summarize, this is how we’ve been doing this until today (I hope).

Using the Reactive Library

One of the benefits we get by using the RX library is that we can use events in a LINQ fashion, thus, that’s why some people name the Reactive Library as LINQ to Events.
Now, lets take a look to our reactive fashioned visitor handler:

    1 public class ReactiveVisitorHandler : IVisitorHandler
    2 {
    3     const int LogVisitThreshold = VisitorHandlerHelper.LogVisitThreshold;
    4     const int SendEmailForEnglishSpeakersVisitorsThreshold = VisitorHandlerHelper.SendEmailForEnglishSpeakersVisitorsThreshold;
    5     const int SendFirstVisitorMessageThreshold = VisitorHandlerHelper.SendFirstVisitorMessageThreshold;
    6 
    7     public void RegisterListeners(ISiteVisitorsService service)
    8     {
    9         var observerData = service.NewVisitObservable.Select(x => x.EventArgs.VisitDetail);
   10         observerData
   11             .Buffer(LogVisitThreshold, LogVisitThreshold)
   12             .Subscribe(VisitorHandlerHelper.LogVisit);
   13 
   14         observerData
   15             .Where(x => x.Country == Contries.Uk ||
   16                         x.Country == Contries.Usa)
   17             .Buffer(SendEmailForEnglishSpeakersVisitorsThreshold, SendEmailForEnglishSpeakersVisitorsThreshold)
   18             .Subscribe(VisitorHandlerHelper.SendEmailForEnglishSpeakersVisitors);
   19 
   20         observerData
   21             .Where(x => x.VisitType == VisitTypes.FirstVisitor)
   22             .Buffer(SendFirstVisitorMessageThreshold, SendFirstVisitorMessageThreshold)
   23             .Subscribe(VisitorHandlerHelper.SendFirstVisitorMessage);
   24     }
   25 }

The interesting stuffs happen in the RegisterListeners method.
First of all, if you look at the line 9, you’ll see we are projecting the event arguments from the service IObservable to get only the stuff we are interesting in (the VisitDetail property).

Later on, we start subscribing our delegates to the IObservable previously created.

From line 10 to 12, we are buffering the output of the event and after that we are subscribing the resulting IObservable to our VisitorHandlerHelper.LogVisit method. Way more simpler way than in our counterpart from the OldFashionedVisitorHandler.

From line 14 to 17 and from line 20 to 23, first we are filtering the IObservable by certain criteria, the first one will filter those events where the Country property is UK or USA, while the other IObservable is filtered only to be handled when the VisitType is equal to FirstVisitor. Next we are buffering the output as we did for the previous observer. And finally, we just subscribe the observable to its corresponding methods.

I don’t know about you, but I think that our ReactiveVisitorHandler is way more friendly than the OldFashionedVisitorHandler. It removes all that complexity and reduces drastically the amount of code you need to write in order to subscribe to an event and perform some special handling based on a complex requirement.

The output

Both versions will output the same thing, which in a console app may look like :

And one day we get a request for an improvement…

So, days go by, everything seems to work correctly. However we get a request telling us that the notification handling should work as always but now it must work in an async fashion, without blocking the service, thus, improving the performance.

So, what’s required to solve this problem? Let’s change our code to reflect just this:

    1 public void RegisterListeners(ISiteVisitorsService service)
    2 {
    3     var observerData = service.NewVisitObservable.Select(x => x.EventArgs.VisitDetail)
    4         .Asynchronous();
    5     observerData
    6         .Buffer(LogVisitThreshold, LogVisitThreshold)
    7         .Subscribe(VisitorHandlerHelper.LogVisit);
    8 
    9     observerData
   10         .Where(x => x.Country == Contries.Uk ||
   11                     x.Country == Contries.Usa)
   12         .Buffer(SendEmailForEnglishSpeakersVisitorsThreshold, SendEmailForEnglishSpeakersVisitorsThreshold)
   13         .Subscribe(VisitorHandlerHelper.SendEmailForEnglishSpeakersVisitors);
   14 
   15     observerData
   16         .Where(x => x.VisitType == VisitTypes.FirstVisitor)
   17         .Buffer(SendFirstVisitorMessageThreshold, SendFirstVisitorMessageThreshold)
   18         .Subscribe(VisitorHandlerHelper.SendFirstVisitorMessage);
   19 }

Do you note the difference (line 4)? So it took us just one line to achieve such a complex thing in a thread safe fashion.

What’s required to do the same in our OldFashionedVisitorHandler…well, I left that as an exercise to the reader, because from now on, frankly, I don’t care.

Summary

I hope dear reader you’ve noted the great improvement and less amount of code that you’ll get by using the Reactive Library, while it is in its initial stage, it is definitely something you should give a try.

The downloadable bits can be found here.

Bye bye.

Implementing a Dead Simple Licensing Library with PostSharp

2009-09-15T19:19:00.001-05:00

Hello everyone, had been a long time from my last post (as usual, been busy busy busy).

Today I want to talk about something that for most .Net developers is unknown but has been in the development industry a long time ago. I’m talking about Aspect Oriented Programming - AOP.

AOP can help you to remove a lot of boilerplate code and to separate concerns from the code your are implementing. I don’t want to talk much about this because surely there’s far more smarter people than I out there that could explain in more detail what AOP is and how you can improve yourself by using it (like ayende).

I came across PostSharp a couple of months ago and immediately felt that it was such a great tool to use with no effort, it allows you to do AOP in existent code, and even better if you start using it from day zero at a project.

What this post is about? Well, the idea is to introduce licensing features to an existent Windows Form application, you know, that little thing that you see when you are evaluating a product and you get notifications about license renewal or limited use of some features given some condition.

Our little app looks like this:

Every single button just display a MessageBox with its Text property as the message content. Our initial code looks like the following:

private void button_Click(object sender, EventArgs e)
{
    MessageBox.Show("Executing => " + ((Button)(sender)).Text);
}

Every button has its Click event handler pointing to this method.

Here is the unrealistic scenario that our app now has to support:

All the buttons inside the “Unrestricted Methods” groupbox are not handled by the licensing component.
All the buttons inside the “Restricted Methods” groupbox are handled by the licensing component.
For Button1 and Button2, the spec says that if the licensing component deny the use of the application, the method should not be executed, and a message at the status bar should appear notifying this problem.
For Button3, the spec says that if the licensing component deny the use of the application, the method should be executed as always, but this only must be allowed 10 times at max, after that it should cancel the method execution and throw an exception, as with the previous buttons, the user should be notified about such problem.
For Button4, the spec says that if the licensing component deny the use of the application, the method should be executed as always, but the user should be notified that besides this fact the license should be renewed.

Ok, so lets start implementing those updates into our code.

In the attached sample project you’ll find the final solution for this article; the EmiajNet.AOP.Licensing.Foundation is the key of everything, lets examine one by one each class.

LicensingManager.cs

This is the class which is in charge of evaluate if the license is valid. Well, as you can see from the code, the license is only valid when in the mornings. The silliest condition let me tell you, but for our sample project works just fine. In a real world app, you may want to check some registry key, or to call a webservice to check the user credentials or anything else.

public static class LicensingManager
{
    public static bool IsValid()
    {
        return DateTime.Now.Hour < 12;
    }
}

LicensingCheckOptions.cs

Those are the constraints that are going to be used for our app for the monitored methods.
ContinueInvocation means that it should not cancel the method execution.
EndInvocation means that it should cancel the method execution.
ThrowSecurityCheckOperationException means that it should throw our custom SecurityCheckOperationException error.

public enum LicensingCheckOptions
{
    ContinueInvocation,
    EndInvocation,
    ThrowSecurityCheckOperationException
}

LicensingHandlerParameter.cs

This is a class used to pass information about the method being handled by our licensing component, it has properties to diagnostic where the problem occurs so the client could handled according by inspecting those properties.
Instance is the instance (duh!) of the class on which the method is executed.
Tag is an arbitrary value that is assigned to the LicensingCheckAttribute (more info below) which decorate the intercepted method.
Method is the object that represent to the method being intercepted.
Arguments is the object that represent the original parameters that were used to call to the intercepted method.
CheckOptions is the LicensingCheckOption enum value assigned to the LicensingCheckAttribute (more info below) which decorate the intercepted method.

public class LicensingHandlerParameter
{
    public object Instance { get; protected set; }
    public object Tag { get; protected set; }
    public MethodInfo Method { get; protected set; }
    public object[] Arguments { get; protected set; }
    public LicensingCheckOptions CheckOption { get; protected set; }
 
    public LicensingHandlerParameter(object instance, object tag, MethodInfo method, object[] arguments, LicensingCheckOptions checkOption)
    {
        Instance = instance;
        Tag = tag;
        Method = method;
        Arguments = arguments;
        CheckOption = checkOption;
    }
 
}

ILicensingHandler.cs

This is a key class in our licensing component, when our LicensingCheckAttribute detects that the host instance implements this interface, uses their methods to notify the several stages of the evaluation. The name of the methods indicate their meaning as well.

public interface ILicensingHandler
{
    void BeforePerformSecurityCheck(LicensingHandlerParameter information);
    void AfterPerformSecurityCheck(LicensingHandlerParameter information, bool valid);
    void SecurityCheckFailed(LicensingHandlerParameter information);
    void HandleSecurityCheckOperationException(LicensingHandlerParameter information, ref bool cancel);
}

SecurityCheckOperationException.cs

This is our custom exception to be thrown when the IsValid method of our licensing component (LicensingManager) return false and the intercepted method is marked with our custom attribute indicating that an error must be thrown (by configuring the CheckOption property as ThrowSecurityCheckOperationException).

public class SecurityCheckOperationException : InvalidOperationException
{
}

LicensingCheckAttribute.cs

And finally the most important class in the whole project, this class inherits from PostSharp.Laos.OnMethodInvocationAspect, which allow us to decorate any method and intercept it just before gets executed, and we can do whatever we want at that stage, like cancel the execution or do some other crazy stuff.
The interesting bits occur in the OnInvocation method.

From line 21 to 25 we are just assigning values to variables that are going to be used later with the help of the eventArgs parameter which holds a lot of useful information.

Line 26 to 29 is for notify to the ILicesingHandler implementor (if any) that we are about to perform a validation check.

Line 30 is where we call to the LicensingManager class to check if the license is in a valid state.
Between line 31 to 59 we handle the scenario when the validation check had failed.
From line 33 to 36 we notify to the ILicensingHandler implementor (if any) that the validation check had failed.

From line 37 to 58 we check what is the value of the CheckOption property, and perform the according strategy to represent such option.
If the enum is assigned as ContinueInvocation, then we just execute the original method by calling to base.OnInvocation(eventArgs).
If the enum is assigned as EndInvocation, then we break the switch statement and nothing else is done.
if the enum is assigned as ThrowSecurityCheckOperationException, then we inform about this to the ILicensingHandler implementor (if any) and we pass a boolean variable “by ref”, this boolean variable can be used to abort this action (no exception is throw), if the implementor does not cancel this, then the exception is thrown, if is the opposite, then we do not throw any exception and execute the original method.

From line 60 to 64, we execute the original method because the LicensingManager class returns a valid result for the license evaluation.

And finally from line 65 to 68, we notify to the ILicensingHandler implementor (if any) that the security check had terminated.

    6 [Serializable]
    7 public class LicensingCheckAttribute : OnMethodInvocationAspect
    8 {
    9     public LicensingCheckOptions CheckOption
   10     {
   11         get;
   12         set;
   13     }
   14 
   15     public object Tag { get; set; }
   16 
   17     public override void OnInvocation(MethodInvocationEventArgs eventArgs)
   18     {
   19         // Security check goes here
   20         // DO NOT USE THIS IN PRODUCTION 
   21         var licensingHandler = eventArgs.Instance as ILicensingHandler;
   22         var instance = eventArgs.Instance;
   23         var method = eventArgs.Method;
   24         var arguments = eventArgs.GetArgumentArray();
   25         var licensingHandlerParameter = new LicensingHandlerParameter(instance, Tag, method, arguments, CheckOption);
   26         if (licensingHandler != null)
   27         {
   28             licensingHandler.BeforePerformSecurityCheck(licensingHandlerParameter);
   29         }
   30         var isValid = LicensingManager.IsValid();
   31         if (!isValid)
   32         {
   33             if (licensingHandler != null)
   34             {
   35                 licensingHandler.SecurityCheckFailed(licensingHandlerParameter);
   36             }
   37             switch (CheckOption)
   38             {
   39                 case LicensingCheckOptions.ContinueInvocation:
   40                     base.OnInvocation(eventArgs);
   41                     break;
   42                 case LicensingCheckOptions.EndInvocation:
   43                     break;
   44                 case LicensingCheckOptions.ThrowSecurityCheckOperationException:
   45                     bool cancel = false;
   46                     if (licensingHandler != null)
   47                     {
   48                         licensingHandler.HandleSecurityCheckOperationException(licensingHandlerParameter, ref cancel);
   49                     }
   50                     if (!cancel)
   51                     {
   52                         throw new SecurityCheckOperationException();
   53                     }
   54                     base.OnInvocation(eventArgs);
   55                     return;
   56                 default:
   57                     throw new ArgumentOutOfRangeException();
   58             }
   59         }
   60         else
   61         {
   62             base.OnInvocation(eventArgs);
   63 
   64         }
   65         if (licensingHandler != null)
   66         {
   67             licensingHandler.AfterPerformSecurityCheck(licensingHandlerParameter, isValid);
   68         }
   69     }
   70 }

With all this infrastructure code we can go and change our Winform App to use our licensing component as follows:

    8 public partial class Form1 : Form, ILicensingHandler
    9 {
   10     public Form1()
   11     {
   12         InitializeComponent();
   13     }
   14 
   15     private int _invalidCallsCount;
   16 
   17     [LicensingCheck(CheckOption = LicensingCheckOptions.EndInvocation)]
   18     private void button1_Click(object sender, EventArgs e)
   19     {
   20         MessageBox.Show("Executing => " + button1.Text);
   21     }
   22 
   23     [LicensingCheck(CheckOption = LicensingCheckOptions.EndInvocation)]
   24     private void button2_Click(object sender, EventArgs e)
   25     {
   26         MessageBox.Show("Executing => " + button2.Text);
   27     }
   28 
   29     [LicensingCheck(CheckOption = LicensingCheckOptions.ThrowSecurityCheckOperationException)]
   30     private void button3_Click(object sender, EventArgs e)
   31     {
   32         MessageBox.Show("Executing => " + button3.Text);
   33     }
   34 
   35     [LicensingCheck(CheckOption = LicensingCheckOptions.ContinueInvocation)]
   36     private void button4_Click(object sender, EventArgs e)
   37     {
   38         MessageBox.Show("Executing => " + button4.Text);
   39     }
   40 
   41     private void unrestricted_Click(object sender, EventArgs e)
   42     {
   43         securityCheckStatus.Text = "Unrestricted method";
   44         MessageBox.Show("Executing => " + ((Button)(sender)).Text);
   45     }
   46 
   47     public void BeforePerformSecurityCheck(LicensingHandlerParameter information)
   48     {
   49         securityCheckStatus.Text = "Performing Security Check";
   50     }
   51 
   52     public void AfterPerformSecurityCheck(LicensingHandlerParameter information, bool valid)
   53     {
   54         if (valid)
   55         {
   56             securityCheckStatus.Text = "You have licensing permissions to execute this method " + information.Method.Name;
   57         }
   58         else
   59         {
   60             if (information.CheckOption == LicensingCheckOptions.ContinueInvocation)
   61             {
   62                 securityCheckStatus.Text = "You have temporary permissions to execute this method " +
   63                                            information.Method.Name + "\n please renew your license";
   64             }
   65             else
   66             {
   67                 securityCheckStatus.Text = "You don't have licensing permissions to execute this method " +
   68                                            information.Method.Name + "\n please renew your license";
   69             }
   70         }
   71     }
   72 
   73     public void SecurityCheckFailed(LicensingHandlerParameter information)
   74     {
   75         Debug.WriteLine("Security check failed for " + information.Method.Name);
   76     }
   77 
   78     public void HandleSecurityCheckOperationException(LicensingHandlerParameter information, ref bool cancel)
   79     {
   80         if (_invalidCallsCount < 10)
   81         {
   82             string message =
   83                 string.Format(
   84                     "You only have {0} more chances of use this method, after that, it will throw an exception.",
   85                     10 - _invalidCallsCount);
   86             securityCheckStatus.Text = message;
   87             _invalidCallsCount++;
   88             cancel = true;
   89         }
   90         else
   91         {
   92             securityCheckStatus.Text = "You have run out of chances to execute this method " +
   93                                        information.Method.Name + "\n please renew your license";
   94         }
   95     }
   96 }

You can inspect the solution attached to this article to understand how everything works, and for the lazy programmer out there, here is a small video showcasing how the application behaves after those changes.

You can download the sample project from here.

Happy coding, bye bye.

Official Google Blog: Introducing the Google Chrome OS

2009-07-08T11:10:00.000-05:00

Official Google Blog: Introducing the Google Chrome OS

Refactoring Switch Statements (Take 2)

2009-06-23T22:37:00.001-05:00

Hello to everyone, had been such a long time since my last article. Many interesting things had been going on in Sansir lately that had been taking my entire free time, and also I’m a man with strong family links, so that makes difficult to publish articles fluently. I am not complaining about it, not at all, color me “happy”.

Ok, stop the whining.

In one of our previous articles, I showed you how to refactor a piece of code which was deciding what method to execute based on the evaluation result of a Switch statement, you can read about it here.

As a final note I stated in such article that the presented code could be refactored even further, because if you look careful, we had just moved the maintenance nightmare to another place in the program, but the original problem stills.

What to do then? This is what I would do:

1) Create an specific class for each Sport that is going to be handled, those classes must implement a simple interface and they need to be decorated with an attribute where is specified the target sport that it will handle, those looks like:

public interface INewsDisplayer

{

void Display();

}

public class NewsDisplayerDefinitionAttribute : Attribute

{

public NewsDisplayerDefinitionAttribute(Sports sport)

{

Sport = sport;

}

public Sports Sport { get; private set; }

}

An implementation of this convention would look like:

[NewsDisplayerDefinition(Sports.Soccer)]
public class SoccerNewsDisplayer : INewsDisplayer

{

#region INewsDisplayer Members

public void Display()

{

Console.WriteLine("Displaying News for Soccer");

// Real implementation below

// Do something

}

#endregion

}

2) Using the Factory Pattern, create a class that takes an Sport parameter and return an IEnumerable<INewsDisplayer> instance.
One difference with our previous attempt is that we are going to be able to define more than one implementation for a given Sport.
This factory class, will scan all the assemblies for the current App Domain and if it finds a type which follows the pattern that I have described in the previous point, it will read the metadata and append an instance of this type to a dictionary that will serve us as our lookup table to return the correct instances for the requested Sport. This factory class looks like:

public static class NewsDisplayerFactory

{

private static readonly IDictionary<Sports, IEnumerable<INewsDisplayer>> lookupTable =

new Dictionary<Sports, IEnumerable<INewsDisplayer>>();

static NewsDisplayerFactory()

{

BootStrap();

}

private static void BootStrap()

{

// Find all types in all the assemblies from the current appdomain

// that have a correct implementation of

// News Displayer (NewsDisplayerDefinitionAttribute + INewsDisplayer)

var interfaceFullName = typeof (INewsDisplayer).FullName;

var newsDisplayerAttributeType = typeof (NewsDisplayerDefinitionAttribute);

var result = from

assembly in AppDomain.CurrentDomain.GetAssemblies()

from

type in assembly.GetTypes()

let

definition = type

.GetCustomAttributes(newsDisplayerAttributeType, true)

.Cast<NewsDisplayerDefinitionAttribute>()

.FirstOrDefault()

where

type.GetInterface(interfaceFullName) != null && definition != null

group

(INewsDisplayer) Activator.CreateInstance(type)

by definition.Sport;

// Filling the dictionary

foreach (var item in result)

{

lookupTable.Add(item.Key, item.ToList());

}

public static IEnumerable<INewsDisplayer> GetInstance(Sports sport)

{

IEnumerable<INewsDisplayer> newsDisplayer;

if (lookupTable.TryGetValue(sport, out newsDisplayer))

{

return newsDisplayer;

}

else

{

throw new NotImplementedException(string.Format("The method for the sport {0} is not implemented", sport));

}

3) Using the Strategy Pattern, we are going to change our SportNews class to change its context by passing to it the kind of Sport that is going to handle.
Such class now it will look like:

public class SportNews

{

private IEnumerable<INewsDisplayer> newsDisplayer;

public void SetContext(Sports sport)

{

newsDisplayer = NewsDisplayerFactory.GetInstance(sport);

}

public void DisplayNews()

{

foreach (var displayer in newsDisplayer)

{

displayer.Display();

}

That’s it, with our new approach we can continue adding NewsDisplayers and use those in our program without touching other parts of our developed program, doing it by adding more classes to our assembly or dropping assemblies into the bin directory (isn’t this named a Plugin model?).

Finally, I’ll like to show our Program class where every components is used to perform the original idea for this program:

class Program

{

private static string options = null;

private static readonly Type sportsEnumType = typeof(Sports);

static void Main(string[] args)

{

var news = new SportNews();

while (true)

{

Console.WriteLine();

DisplayOptions();

var key = Console.ReadKey().KeyChar.ToString();

Console.WriteLine();

try

{

var sport = (Sports)(Enum.Parse(sportsEnumType, key));

news.SetContext(sport);

news.DisplayNews();

}

catch (Exception ex)

{

Console.WriteLine(ex);

Console.ReadLine();

return;

}

private static void DisplayOptions()

{

if (options == null)

{

StringBuilder optionsBuilder = new StringBuilder();

FieldInfo[] enumFields = sportsEnumType.UnderlyingSystemType.GetFields(BindingFlags.Public | BindingFlags.Static);

foreach (FieldInfo enumField in enumFields)

{

object enumValue = enumField.GetRawConstantValue();

Sports sport = (Sports)(enumValue);

optionsBuilder.AppendFormat("To display the news for {0} press {1}\n", sport, enumValue);

}

options = optionsBuilder.ToString();

}

Console.WriteLine(options);

}

You can download the working sample from here.

Happy coding, see you soon.

Etiquetas de Technorati: .Net,C#,Refactoring

Getting Fun with .Net Static Reflection

2009-05-07T16:54:00.001-05:00

Hi there to everyone. Today I want to talk about a fantastic technique that I think it will help you dear reader a lot in your daily programming task.
This technique is called Static Reflection, here is a nice explanation about what it does from http://www.lostechies.com/blogs/gabrielschenker/archive/2009/02/03/dynamic-reflection-versus-static-reflection.aspx:

Static Reflection gathers meta information through the inspection of the Expression Tree.

Thanks to this, you do not need any magic string to interrogate a given type for their properties or methods (like with Dynamic Reflection happens).

One of the benefits that you could get from this technique is to create highly “refactorable” (is that a word?) projects due to the elimination of magic strings.

Let me show you an example about this scenario:

Lets say that we have a junior programmer who does have a very bad way of name things in code, he likes a lot to use TXTSpeak while writes code.
So one day we ask him to write a tiny windows app which should load in a dropdown a list of persons, and he goes ahead and write the following data structure:

public class PRSN //"Person" = PRSN in TXTSpeak

{

public int PRSNID { get; set; } //"PersonID" = PRSNID in TXTSpeak

public string PRSNNM { get; set; } //"PersonName" = PRSNNM in TXTSpeak

}

And his winform client would look like:

public partial class Form1 : Form

{

public Form1()

{

fillList();

InitializeComponent();

}

private List<PRSN> dropdownDataSource = new List<PRSN>();

private void fillList()

{

// in the real world here you should call to the database to retrieve this data

// for the sake of the demo just use the following

dropdownDataSource.Add(new PRSN()

{

PRSNID = 1,

PRSNNM = "Jaime"

});

dropdownDataSource.Add(new PRSN()

{

PRSNID = 2,

PRSNNM = "John"

});

dropdownDataSource.Add(new PRSN()

{

PRSNID = 3,

PRSNNM = "Charles"

});

dropdownDataSource.Add(new PRSN()

{

PRSNID = 3,

PRSNNM = "Mark"

});

}

private void Form1_Load(object sender, EventArgs e)

{

cboPersons.ValueMember = "PRSNID";

cboPersons.DisplayMember = "PRSNNM";

cboPersons.DataSource = dropdownDataSource;

}

Here is the thing, please take a look at how the ValueMember and DisplayMember properties are being configured, the original programmer used just simple string to point to the name of the properties in his data structure. Now, your manager assigns you a task to clean up this mess and replace all that TXTSpeak with proper names, what is worst is that this kind of code is all over the place and you would have to go with the pain process of “search/replace” all over your code.

Is there a better way? Sure it is, here is when it comes Static Reflection.

With Static Reflection all you have to do is to pass an Expression indicating which property do you want to inspect and that will give you a PropertyInfo object from where you can ask for the Name property of such instance and do the very same thing… but better :).

First of all let me explain how this works. In the project attached to this article you’ll find the following structure:

The project where all the interesting happens are is the EmiajNet.StaticReflection.Library, in there you are going to find the ReflectionHelper and StaticReflector static classes. Both of them have methods related to static reflection, but why two?, well, the ReflectionHelper class it has been borrowed from another library (FluentNHibernate) so I think is better to have it in a separated class, and the StaticReflector class it has been created by me to fill some functionality that the ReflectionHelper class does not provide (static reflection over methods that return void).

Here is a class diagram to illustrate how those classes look like:

The basic idea of all of them is to inspect the expression being passed and extract the object that is related to the signature of the method. So the GetMethod method returns a MethodInfo, the GetProperty method returns a PropertyInfo and so on.

This is how some of those methods look like:

ReflectionHelper:

public static MethodInfo GetMethod<T>(Expression<Func<T, object>> expression)

{

MethodCallExpression methodCall = (MethodCallExpression) expression.Body;

return methodCall.Method;

}

public static PropertyInfo GetProperty<MODEL>(Expression<Func<MODEL, object>> expression)

{

return (PropertyInfo) GetMember(expression);

}

public static MemberInfo GetMember<MODEL>(Expression<Func<MODEL, object>> expression)

{

MemberExpression memberExpression = getMemberExpression(expression);

return memberExpression.Member;

}

public static FieldInfo GetField<MODEL>(Expression<Func<MODEL, object>> expression)

{

return (FieldInfo)GetMember(expression);

}

StaticReflector:

public static MethodInfo GetMethod<MODEL>(Expression<Func<MODEL, Action>> exp)

{

return GetMethodFromLambda(exp);

}

private static MethodInfo GetMethodFromLambda(LambdaExpression exp)

{

var unaryExp = (UnaryExpression)exp.Body;

var methodCallExp = (MethodCallExpression)unaryExp.Operand;

var constantExp = (ConstantExpression)methodCallExp.Arguments[2];

MethodInfo output = (MethodInfo)constantExp.Value;

return output;

}

As you can see, is very straightforward, you can dig more into the library to give a more detailed idea.

Here are some examples from the EmiajNet.StaticReflection.Test project that I want to show you so you could realize how this thing works :

We have the following class that is subject of inspection:

private class TestClass

{

public int SomeIntMember;

public string SomeStringMember;

public TestClass SomeComplexMember;

public string SomeStringProperty { get; set; }

public int SomeIntProperty { get; set; }

//indexed property

public object this[int index]

{

get

{

return null;

}

public TestClass SomeComplexProperty { get; set; }

public void SomeParameterlessMethod()

{

}

public void SomeMethod(object x)

{

}

public TestClass SomeParameterlessMethodWithReturnValue()

{

return null;

}

public TestClass SomeMethodWithReturnValue(object x)

{

return null;

}

And here are a some test that I throw at it:

[Fact()]

public void TestStringProperty()

{

string expected = "SomeStringProperty";

string propertyName = ReflectionHelper.GetProperty<TestClass>(x => x.SomeStringProperty).Name;

Assert.Equal(expected, propertyName);

}

[Fact()]

public void TestFunction()

{

string expected = "SomeMethodWithReturnValue";

string methodName = ReflectionHelper.GetMethod<TestClass>(x => x.SomeMethodWithReturnValue(null)).Name;

Assert.Equal(expected, methodName);

}

[Fact()]

public void TestMethod()

{

string expected = "SomeMethod";

string methodName = StaticReflector.GetMethod<TestClass, object>(x => x.SomeMethod).Name;

Assert.Equal(expected, methodName);

}

As you can see, those test verify that the name of the expressions being evaluated are correct. Remember all of this is only to obtain information about the expression being inspected.

Now, continuing with the scenario that we talk about earlier, here is how this sample look like using Static Reflection:

private void Form1_Load(object sender, EventArgs e)

{

cboPersons.ValueMember = ReflectionHelper.GetProperty<PRSN>(x => x.PRSNID).Name;

cboPersons.DisplayMember = ReflectionHelper.GetProperty<PRSN>(x => x.PRSNNM).Name;

cboPersons.DataSource = dropdownDataSource;

}

Isn’t this something more refactor friendly?, I mean, now you just should go and rename the class and its properties correctly and with the help of Visual Studio every occurrence of the affected properties is going to be changed automatically.

If we accept this action, our code it will be updated automatically and the application will continue working as usual:

private void Form1_Load(object sender, EventArgs e)

{

cboPersons.ValueMember = ReflectionHelper.GetProperty<PRSN>(x => x.PersonID).Name;

cboPersons.DisplayMember = ReflectionHelper.GetProperty<PRSN>(x => x.PRSNNM).Name;

cboPersons.DataSource = dropdownDataSource;

}

Now you could continue refactoring the class name to Person and the other property to PersonName.

You can download the sample code to play around from here. There is a serie of unit tests so you could check in more deep how this works, to run them all from inside Visual Studio you will need to have installed TestDriven .Net and configure XUnit as you test suite.

Hope you liked the article.

Bye bye.

Etiquetas de Technorati: C#,.Net,Refactoring

Fluent NHibernate and Linq to NHibernate Demo Project

2009-04-17T20:42:00.003-05:00

Introduction

This is my so long waited demo project showcasing the use of Fluent NHibernate and Linq to NHibernate (and some other interesting bits).

First of all, I you are completely new to NHibernate I encourage you to take a look at my previous introductory article here.

Disclaimer

Before commencing, I want to make a disclaimer about this project, as you may expect, this is just demo code, not intended to be take too serious, please use it just a *soft* guide of how very basic things can be done using NHibernate. However, I’ve tried to make my best implementing the code for this article, with time limitations and all the related issues that an active developer have.

Prerequisites

.Net Framework 3.5 SP1

Visual Studio 2008

To run the test from inside Visual Studio : TestDriven.Net

MSSQL Server 2005 with the AdventureWorks database installed.

All other dependencies (assemblies) are included within the solution.

Lets go

What is this about? Take a look at the solution structure:

I’m going to explain what’s the purpose of each of those projects:

NHibernateSample.Model:

This is the simplest one, here I’ve created the classes that are going to be mapped against our database, those are just POCO classes that represent a view of the real database. Take a look at this image:

Each class must overrides its GetHashCode method (which should be implement in a way that that returns unique results for each unique entity) and its Equals method in order to allow to NHibernate to handle the loading and session caching process of entities. Those methods look similar in almost all the cases, except when we are handling entities that have composite ids.
Lets take a look at how this is being done in the AddressType class that has its AddressTypeID property as primary key:

public override int GetHashCode()

{

return HashCodeGenerator.GenerateHashCode(AddressTypeID);

}

public override bool Equals(object obj)

{

return this.IsEqual(obj);

}

The GenerateHashCode method from the HashCodeGenerator class (NHibernateSample.Model/Helper/HashCodeGenerator.cs) and it looks like:

public static class HashCodeGenerator

{

public static int GenerateHashCode(params object[] keys)

{

int hash = 17;

foreach (var item in keys)

{

int itemHashCode;

if (item == null)

{

itemHashCode = 1;

}

else

{

itemHashCode = item.GetHashCode();

}

hash = hash * 23 + itemHashCode;

}

return hash;

}

As you can see, nothing glamorous, I’m just assuring that the result of the method is unique.

The override of the Equals method is using the IsEqual extension method from the EqualityHelper class (NHibernateSample.Model/Helper/EqualityHelper.cs) and it looks like:

public static class EqualityHelper

{

public static bool IsEqual<T>(this T source, object obj) where T : class

{

var target = obj as T;

if (obj == null)

{

return false;

}

return target.GetHashCode().Equals(source.GetHashCode());

}

As you can see, it only checks the equality of the method GetHashCode of the instances being passed to the method, simple enough.

NHibernateSample.ModelMapper:

This is a very important project, here is where I’m using the Fluent NHibernate API to map our NHibernateSample.Model assembly against our database.
One of the cool things that the Fluent API provides to us is the use of conventions (following the “convention over configuration” spirit) that helps us to save a lot of time in the mapping process, for example, you may have a guideline for your database with regards to naming the primary key column of a given table, something like <Table_Name>ID, so, for the Product table you have ProductID table.
Using plain NHibernate mapping files you would have to go into the tedious work of map each of one entity, throwing away your convention.
Hopefully we are using Fluent NHibernate and this is easy cake.

This project has little classes that inherit from FluentNHibernate.Mapping.ClassMap which gives us all the facilities to configure our entities.
Lets take a look at our StateProvinceMapper class:

public class StateProvinceMapper : ClassMap<StateProvince>

{

private const string schema = "Person";

public StateProvinceMapper()

{

SchemaIs(schema);

Id(x => x.StateProvinceID);

Map(x => x.Name)

.WithLengthOf(50)

.ReadOnly();

References(x => x.TerritoryID)

.LazyLoad()

.Not.Nullable();

}

As you can see is pretty straightforward.
1) We set the schema of this entity, which is the “Person” schema in the AdventureWorks database.
2) We set the Id of this entity, which is the StateProvinceID property that maps directly to the same column in the database table.
3) We map our Name property against the Name column in the database table, also, we set some attributes as its MaxLenght and also we say that this is a readonly property.
4) We set a reference with another entity using our TerritoryID property (of StateProvince type, which also maps to its corresponding table), also we set the LazyLoad attribute that says to NHibernate to do not retrieve it from the database until an explicit request is performed (stateProvinceInstance.TerritoryID.Name would fire a database query) and lastly we mark this property as Not-Nullable so in Update and Insert operations an attempt to store an StateProvince entity with a null value for its TerritoryID property will throw an exception.

The place in charge of build the mapping from our Model against the database is the ModelBuilder class (NHibernateSample.ModelMapper/ModelBuilder.cs), in there we are doing all the heavy work to create our mapping:

private static void buildModel()

{

// initialize persistance configurer

IPersistenceConfigurer persistenceConfigurer = getPersistenceConfigurer();

// initialize nhibernate with persistance configurer properties

cfg = persistenceConfigurer.ConfigureProperties(new Configuration());

// add mappings definition to nhibernate configuration

var persistenceModel = new PersistenceModel();

persistenceModel.addMappingsFromAssembly(typeof(ModelBuilder).Assembly);

persistenceModel.Conventions.GetPrimaryKeyName = x => x.Name;

persistenceModel.Conventions.GetForeignKeyName = x => x.Name;

persistenceModel.Configure(cfg);

//Mix mode, this line allows us to append config settings to our configuration

//instance from .config files (web.config,app.config)

// or any other "traditional" (xml based) approach.

//NOTE: If you are going to go with full Fluent configuration, you should remove the line below

cfg.Configure();

}

Look how we are saying that the GetPrimaryKeyName should be inferred directly from the property name and the same for the GetForeignName method, so, if we have a class Product, and we say that its ID is ProductID, its primary key should be mapped to the column ProductID as well, and the same for its references.

You can look deeper into the project to get a more detailed view of what is going on there.

NHibernateSample.LINQModel:

In this project we are using the NHibernate.Linq assembly to create a NHibernateContext which has implemented a LINQ provider (not as good as LINQ to SQL) that allow us to create queries in a LINQ to SQL fashion.
The main class there is the ModelContext class, which takes our entities and expose them as IOrderedQueryable implementations.
Is very simple, here is how it looks:

public class ModelContext : NHibernateContext

{

public ModelContext(ISession session)

: base(session)

{

}

public IOrderedQueryable<Customer> Customers

{

get

{

return Session.Linq<Customer>();

}

public IOrderedQueryable<Address> Addresses

{

get

{

return Session.Linq<Address>();

}

public IOrderedQueryable<AddressType> AddressTypes

{

get

{

return Session.Linq<AddressType>();

}

public IOrderedQueryable<CustomerAddress> CustomerAddresses

{

get

{

return Session.Linq<CustomerAddress>();

}

public IOrderedQueryable<SalesTerritory> SalesTerritories

{

get

{

return Session.Linq<SalesTerritory>();

}

public IOrderedQueryable<StateProvince> StateProvincies

{

get

{

return Session.Linq<StateProvince>();

}

As you can see, it takes an ISession (which is our NHibernate instance to handle the database management) and for each entity I’ve created a wrapper that returns the IOrderedQueryable that are going to allow us to work with them easily.

NHibernateSample.Tests:

As its name says, there are just a bunch of tests ( I’m using XUnit as my unit test suite) that I’ve build to show how our ModelContext class can be used to perform simple operations as projections or to create aggregates. I reckon that the tests in there sucks, I’m on the process of learning how to write proper tests, so this is not a good example of how a set of unit tests should be written.
Lets move on and take a look at the AddressTests class, there I’ve the following test:

[Fact]

public override void Test_Retrieve_Entity_With_EntityID_Equals_To_X_Should_Return_Null()

{

int addressID = 0;

using (var context = new ModelContext(Session))

{

var result = (from address in context.Addresses

where address.AddressID == addressID

select address).SingleOrDefault();

Assert.Null(result);

}

As you can see, it’s very similar to what you can do using LINQ to SQL, but with NHibernate :)
This is another test from the same class:

[Fact]

public override void Test_Sorting_Descending()

{

using (var context = new ModelContext(Session))

{

var result = (from address in context.Addresses

where address.City == "Bothell"

orderby address.AddressID descending

select address).ToList();

Assert.False(result.Last().AddressID > result.First().AddressID);

foreach (var item in result)

{

Console.WriteLine(item.AddressID);

}

Very self-explanatory. You can check the other test to have some fun with the power (and several limitations) of the LINQ provider for NHibernate.

NHibernateSample.BusinessLayer:

This project is intended to be used for our web applications. I think that the interesting bits are related to the session management (NHibernateSample.BusinessLayer/SessionManagement/SessionManager.cs) and the use of StructureMap to configure our dependencies (NHibernateSample.BusinessLayer/Bootstrapper.cs, NHibernateSample.BusinessLayer/Repositories/ICustomerRepository.cs and NHibernateSample.BusinessLayer/Repositories/Implementations/CustomerRepository.cs).

NHibernateSample.CustomerWebSite:

This project shows how you can use NHibernate to perform a basic CRUD operation over our Customer entity, I’ll try to find the time to create a more complex example (I can’t assure this :D), but with that simple aspx page you should be able to go on your own and make a nicer web app.
Some interesting things are happen in the global.asax file, and also it will help in the process to integrate asp .net controls with NHibernate (GridView, ObjectDataSource).

Finally, please don’t forget to update your database connection in order to run the samples. The file that you need to update is located in the Solution Items folder in the solution tree, is named hibernate.cfg.xml, you should change the value for the property connection.connection_string with one that match your environment.

<hibernate-configuration xmlns="urn:nhibernate-configuration-2.2">

<session-factory>

managed_web

</property>

Data Source=YOUR_DATABASE_SERVER_GOES_HERE;Initial Catalog=AdventureWorks;Integrated Security=True

</property>

</session-factory>

</hibernate-configuration>

Please, if you find a WTF in the source code, don’t hesitate to send your feedback, I’ll be very thankful.

You can download the full demo here.

Bye bye.

Etiquetas de Technorati: NET,C#,CODEPROJECT,FLUENT NHIBERNATE,LINQ TO NHIBERNATE,NHIBERNATE

Fluent NHibernate and Linq to NHibernate

2009-02-02T10:16:00.003-05:00

Probably most of you are aware of LINQ and also have done some kind of work using LINQ to SQL which is the ORM product from Microsoft for its .Net platform (don't forget about LINQ to Entities, which is the Enterprise version of LINQ to SQL).

Well, let me tell you, if you don't already know, that exists an Open Source project which has some years out there, this project is NHibernate which is a port from the java version Hibernate, NHibernate is a powerful fully tested ORM tool that has proved over the years to be a great alternative to handle the data management in your applications. It has a learning curve that may scare you, but after a few days using it you'll never go back to the old ADO .Net API.

For further reading, you can check this post from Ayende which I'm sure is going to convince you to get involve and start using NHibernate in your applications.

If you haven't used NHibernate before, well, I recommend you to stop to read right now and go and start playing with it, then you can go back here and continue reading :).

---A couple of days later---

Hi again, how did you went with NHibernate? Is a great tool, isn't?

Now I have a couple of questions for you:

What are the most difficult parts in NHibernate?, if your answer is "Configuration, Mapping and Querying" then this post will help you to get ride of those problems.

For the configuration and mapping problems, there is a project named Fluent NHibernate, which is an API based configuration and entities mapper tool which eliminate the need for all those XML files.

For the querying problem, there is another project from the NHibernate Contrib Project named LINQ to NHibernate which can be downloaded from here, this allows you to start using NHibernate in the same fashion as with LINQ to SQL making a lot of easier and fun to work with it.

For further reading of the Fluent NHibernate project you could check:

http://nhforge.org/blogs/nhibernate/archive/2008/09/02/a-fluent-interface-to-nhibernate-part-1.aspx

http://nhforge.org/blogs/nhibernate/archive/2008/09/06/a-fluent-interface-to-nhibernate-part-2-value-objects.aspx

http://nhforge.org/blogs/nhibernate/archive/2008/09/06/a-fluent-interface-to-nhibernate-part-3-mapping-relations.aspx

http://nhforge.org/blogs/nhibernate/archive/2008/09/06/a-fluent-interface-to-nhibernate-part-4-configuration.aspx

For further reading of the LINQ to NHibernate project you could check:

http://blogs.hibernatingrhinos.com/nhibernate/archive/2008/11/26/linq-to-nhibernate.aspx

In my next article I'll show you an example of how you can combine both tools and get a nice app running.

Bye bye.

Etiquetas de Technorati: .Net,C#,Fluent NHibernate,LINQ to NHibernate,NHibernate

Refactoring "switch cases".

2009-01-14T12:24:00.001-05:00

Hello to everyone, I want to show you how to apply a simple refactoring trick to a common pattern, the "switch case" statement.

Please take a look at the following program (a console app) :

class Program
    {
        private static string options = null;
        private static readonly Type sportsEnumType = typeof(SportNews.Sports);
        static void Main(string[] args)
        {
            SportNews news = new SportNews();
            while (true)
            {
                Console.WriteLine();
                DisplayOptions();
                string key = Console.ReadKey().KeyChar.ToString();
                Console.WriteLine();
                try
                {
                    SportNews.Sports sport = (SportNews.Sports)(Enum.Parse(sportsEnumType, key));
                    news.DisplayNews(sport);
                }
                catch(Exception ex)
                {
                    Console.WriteLine(ex);
                    Console.ReadLine();
                    return;
                }
 
            }
        }
        private static void DisplayOptions()
        {
            if (options == null)
            {
                StringBuilder optionsBuilder = new StringBuilder();
                FieldInfo[] enumFields = sportsEnumType.UnderlyingSystemType.GetFields(BindingFlags.Public | BindingFlags.Static);
                foreach (FieldInfo enumField in enumFields)
                {
                    object enumValue = enumField.GetRawConstantValue();
                    SportNews.Sports sport = (SportNews.Sports)(enumValue);
                    optionsBuilder.AppendFormat("To display the news for {0} press {1}\n", sport, enumValue);
                }
                options = optionsBuilder.ToString();
            }
            Console.WriteLine(options);
        }
    }
 
    public class SportNews
    {
        public enum Sports
        {
            Soccer = 0,
            BasketBall = 1,
            Rugby = 2,
            VolleyBall = 3
        }
        public void DisplayNews(Sports sport)
        {
            switch (sport)
            {
                case Sports.Soccer:
                    DisplayNewsForSoccer();
                    break;
                case Sports.BasketBall:
                    DisplayNewsForBasketBall();
                    break;
                case Sports.Rugby:
                    DisplayNewsForRugby();
                    break;
                case Sports.VolleyBall:
                    DisplayNewsForVolleyBall();
                    break;
                default:
                    throw new NotImplementedException(string.Format("The method for the sport {0} is not implemented", sport));
            }
        }
 
        private void DisplayNewsForSoccer()
        {
            Console.WriteLine("Displaying News for Soccer");
            // Real implementation below
            // Do something
        }
        private void DisplayNewsForBasketBall()
        {
            Console.WriteLine("Displaying News for BasketBall");
            // Real implementation below
            // Do something
        }
 
        private void DisplayNewsForRugby()
        {
            Console.WriteLine("Displaying News for Rugby");
            // Real implementation below
            // Do something
        }
 
        private void DisplayNewsForVolleyBall()
        {
            Console.WriteLine("Displaying News for VolleyBall");
            // Real implementation below
            // Do something
        }
 
    }

What this does?, well, simply ask to the user to press a given key to execute a determined action.

The running program looks like this:

Very simple isn't?

This is fine for the number of alternatives that we are going to handle, but,what about if you add more items (+10) to the enum, you would need to add more cases to the switch statement, and so on. This is a very error prone process and also a maintenance nightmare.

What to do then? Well, the solution is very simple, you would need to change the switch statement by a lookup table, a Dictionary object is a good candidate to do this.

SHOW ME THE CODE!!. Here it is:

First lets create our Dictionary instance in the SportNews class constructor :

        private Dictionary<Sports, Action> lookupTable;
        public SportNews()
        {
            lookupTable = new Dictionary<Sports, Action>()
            {
                { Sports.Soccer, DisplayNewsForSoccer },
                { Sports.BasketBall, DisplayNewsForBasketBall },
                { Sports.Rugby, DisplayNewsForRugby },
                { Sports.VolleyBall, DisplayNewsForVolleyBall }
            };
        }

Now lets change the DiplayNews method to get ride of the switch statement, it will end up as:

        public void DisplayNews(Sports sport)
        {
            Action displayMethod;
            if (lookupTable.TryGetValue(sport, out displayMethod))
            {
                displayMethod.Invoke();
            }
            else
            {
                throw new NotImplementedException(string.Format("The method for the sport {0} is not implemented", sport));
            }
        }

Isn't this more simple and clean?

Obviously, this code could be refactored even more, but for the purpose of the article I think is fine.

The final working demo can be found here.

Bye bye.

Etiquetas de Technorati: .Net,C#,Refactoring

What .Net coding standards do I use?

2008-12-15T09:49:00.002-05:00

Hi there, today I want to speak about something that had help me a lot in the companies that I'd worked.
Those are the coding standards that I follow in a daily basics, they allow me to integrate myself with other teams which, is some way or others, share some of the points that those standards have.
The document had been written by IDesign and I think is one of the greatest guidelines that is available online, also is being updated from time to time.
Please go ahead and take a look.
You can download it from here.

Technorati Tags: .Net,Best Practices,C#,Coding Standards

Optimize your Pages using CSS Sprites

2008-12-05T18:57:00.002-05:00

Lets say that you boss calls you telling that the shiny new page of the company in the production server is having a very bad user experience, the load process takes a lot of time and the users have to wait to start using it.

You, as a good developer/designer found after a trace of the web requests/responses that the main issue is related to the downloading process of the images that are being used for several elements in the main page screen...lets say 100 images (pretty large, isn't?).

You check the size of those images and none of them is too large (1kb - 10kb max), then your boss look at you and you simply don't have an answer for such thing... what to do then? start blaming to the user's computers ("is their fault, they should upgrade to a better Internet connection, no less than T1"), or start blaming to the framework? ("is PHP/.net/java fault, I told you so, the decision to go with PHP/.net/java was a really bad idea"), or something else that saves your soul from hell :) .

Here is when a technique named CSS Sprites comes to the rescue. This is an idea ported from the gaming industry and it can be applied to the web too. The main idea is to take all your images (in these case the 100 images) and put them all in a big image, and finally, using CSS move the coordinates around this newly image to show the correct image for a given element.

Lets create an small demo showing this technique:

The final result should look like this:

This is our basic markup:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
    <style type="text/css">
        .container div
        {
            border: 1px solid;
            float: left;
            height: 100px;
            left: 20px;
            margin-left: 12px;
            margin-top: 50px;
            position: relative;
            width: 100px;
        }
        .blue
        {
        }
        .red
        {
        }
        .yellow
        {
        }
    </style>
</head>
<body>
    <div class="container">
        <div class="blue">
        </div>
        <div class="red">
        </div>
        <div class="yellow">
        </div>
    </div>
</body>
</html>

And these are our images:


blue.jpg	yellow.jpg	red.jpg

Now, the traditional way to do this is just to set the background-image for each selector to target the correct image, something like:

        .blue
        {
        background-image:url('blue.jpg');
        }
        .red
        {
        background-image:url('red.jpg');
        }
        .yellow
        {
        background-image:url('yellow.jpg');
        }

And effectively, it does work. But the problem is that you are hitting 3 times the server to retrieve those images. You can get the same result using CSS Sprites, first using your favorite image editing software (Photoshop) we are going to merge those images, the end result should be something like these:

sprite.jpg

And here the magic happens, lets change our selectors to use this big image and move the coordinates for each square until we get the desired result:

        .container div
        {
            border: 1px solid;
            float: left;
            height: 100px;
            left: 20px;
            margin-left: 12px;
            margin-top: 50px;
            position: relative;
            width: 100px;
            background-image: url('sprite.jpg');
        }
        .blue
        {
            background-position: -100px 0px;
        }
        .red
        {
            background-position: -200px 0px;
        }
        .yellow
        {
            background-position: -0px 0px;
        }

And that is all, what I'm doing there is assigning the background-image attribute of all the div's inside the container to our sprite.jpg image, later, I'm assigning a background-position to display the correct portion of the whole image. Furthermore, you are getting the same result but saving some hits to your server, isn't that cool enough?

Well, that is all folks, hope you like my first article.

You can download the sample code from here.

Etiquetas de Technorati: CSS,HTML

Bye bye.

Lets start by something simple...

2008-12-05T17:58:00.001-05:00

Hi there to everyone,

I have decide for once to start to write something in this dammed blog, I did setup this blog some years ago and frankly never found the time to write something that could be useful to someone.

Please, bear with me if you find some typos on the articles that I may write, English is not my primary language and this is going to be a great experience in my learning process about this language.

I am by no means an expert about anything, do not take this blog too serious, your feedback (good or bad) is always welcome.

So, here we go, lets see how far it goes.