Archive

Archive for the ‘dotnet 4’ Category

Quartz.Net

November 29, 2013 Leave a comment

In this post I am going to talk about yet another open source project Quartz.net which is simple but powerful way of scheduling jobs in .NET. In any enterprise wide development I am sure you have come across situation where you need to run jobs at specific interval,frequency, at a specific day of the week etc.

Quartz.net API is pretty simple and all it cares about is any class which implements the IJob interface and when you wire that up to the Quartz scheduler class and it will take care of the scheduling.

Lets start cutting some and I am going to create a simple ToDoJob class which implements the IJob interface.

ToDoJob.cs

    using System;
    using Quartz;
    
    public class ToDoJob : IJob
    {
        public void Execute(IJobExecutionContext context)
        {
            Console.WriteLine("Job is executing - {0}.", DateTime.Now);
        }
    }

Now I am going to create my own interface which will encapsulate the Quartz scheduler and decouple the Quartz component.

IJobScheduler.cs

using System;
using Quartz;

public interface IJobScheduler
{

    void ScheduleJob<T>(string groupName, string jobDetails, 
                        string triggerName, TimeSpan repeatInterval)
                        where T : IJob;
}

The implementation of this interface is pretty simple as you can see I am using the Standard Scheduler factory provided by Quartz and from there we can get the scheduler object. After that you just need to create a simple trigger object and wire up a few setting like when it needs to be started, how long the job needs to run for etc.

JobScheduler.cs

using System;
using Quartz;
using Quartz.Impl;
using Quartz.Impl.Triggers;


public class JobScheduler : IJobScheduler
{
    private readonly IScheduler scheduler;
    private readonly ISchedulerFactory schedFact;

    public JobScheduler()
    {
        this.schedFact = new StdSchedulerFactory();

        // get a scheduler
        this.scheduler = this.schedFact.GetScheduler();
        this.scheduler.Start();
    }

    public void ScheduleJob<T>(string groupName, string job, 
                               string triggerName, TimeSpan repeatInterval) 
                                where T : IJob
    {
        var trigger = new SimpleTriggerImpl
        (
            triggerName,
            groupName,
            DateTime.UtcNow, 
            null, 
            SimpleTriggerImpl.RepeatIndefinitely, 
            repeatInterval
        );

        var jobDetail = new JobDetailImpl(job, groupName, typeof(T));
        this.scheduler.ScheduleJob(jobDetail, trigger);
    }
}

As you can see from the above code I am configuring a trigger which start immediately and runs indefinitely at an interval specified in the parameter.

So our Job scheduler class is ready and we have define the schedule job method in such a way that it takes any IJob interface along with necessary scheduling parameters to schedule a job. Now the only thing left is use the class and schedule a job.

Below is the main program where I am asking the ToDoJob class to execute every 10 seconds and this is just for illustration in real life enterprise application this could be inside a config or whatever requirements you have.

Program.cs

using System;

public class Program
{
    public static void Main(string[] args)
    {
        IJobScheduler scheduler = new JobScheduler();
        scheduler.ScheduleJob<ToDoJob>("FileGroup", 
                                        "FilePollingJob", 
                                        "FilePollingTrigger", 
                                        TimeSpan.FromSeconds(10));
    }
}

And here is the output of the ToDoJob.

Quartz Scheduler Running

As you can see this is pretty neat and if you guys remember a long time ago I blog about TopShelf if you haven’t read it or not heard of it then I highly recommend to read about it here. If you wireup the Quartz Scheduler with the TopShelf component then you get a pretty robust scheduling platform for your enterprise.

I just love doing these small project where I integrate various component and see these lego blocks coming up together and have fun with it and I hope you guys will enjoy playing with these lego blocks as much as I do.

Advertisements

Using Output Cache Profile in ASP.NET MVC

September 29, 2013 2 comments

Caching is a quintessential part of any web application, as it improves the performance and load on the web server. The simplest way to add caching to your ASP.NET MVC application is to decorate your action method with the Output Attribute as following :-

 

[OutputCache(Duration=60,VaryByParam="none")]
public ActionResult Index()
{
    var employees = db.Employees;
    return View(employees.ToList());
}

However it is not a good practice to hard code such parameter values and specially when you have to apply different values for different set of caching. For example 60 second for long, 30 seconds for medium and 10 seconds for short caching.First problem with this approach is that you have to be very careful where you are making these changes and second problem is that for some reason if you have to change these values then you have to do search and replace, which is a very bad thing and totally against the DRY ( Don’t Repeat Yourself ) principle.

So overall it is a good practice to use the output cache profile and lets see how we can declare it in our web.config file.

Web.config

<caching>
   <outputCacheSettings>
     <outputCacheProfiles>
       <add name="Long" duration="60" varyByParam="none"/>
       <add name="Medium" duration="60" varyByParam="none"/>
       <add name="Short" duration="10" varyByParam="none"/>
     </outputCacheProfiles>
   </outputCacheSettings>      
 </caching>

And here is how we use the cache profile in our action method.

[OutputCache(CacheProfile="Long")]
public ActionResult Index()
{
    var employees = db.Employees;
    return View(employees.ToList());
}

 

This is very straight forward and nothing unusual but whats the point of blogging about something which hasn’t got any gotchas. And the gotcha is that you can’t use the cache profile on a child action and MVC will through this strange exception “Duration must be positive number.”

 

The above exception is actually misleading and basically output cache profile are not supporting for child action, partial views etc,however the fix for this problem is very easy and all we have to do is just extend the OutputCacheAttribute class. So we will write our own Partial cache attribute class .

PartialCacheAttribute.cs

   1:  public class PartialCacheAttribute : OutputCacheAttribute
   2:  {
   3:      public PartialCacheAttribute(string cacheProfileName)
   4:      {
   5:          var cacheSection = (OutputCacheSettingsSection)WebConfigurationManager
   6:                              .GetSection("system.web/caching/outputCacheSettings");
   7:   
   8:          var cacheProfile = cacheSection.OutputCacheProfiles[cacheProfileName];
   9:   
  10:          Duration = cacheProfile.Duration;
  11:          VaryByParam = cacheProfile.VaryByParam;
  12:      }   
  13:  }

 

As you can see nothing special we are using the GetSection method of WebConfigurationManager class and from that section we are getting the cache profile by its name at line 8. Now our child action method is all set to be decorated with this custom attribute and this is how the action method looks like :-

[ChildActionOnly]
[PartialCache("Short")]
public string GetEmployeesCount()
{
    return db.Employees.Count().ToString();
}

 

This was an issue with MVC 3 and still it’s an issue with MVC 4, but I hope this will get fixed in in MVC 5 πŸ˜‰

Refactoring with LINQ

January 25, 2013 Leave a comment

In this post I am going to talk about a simple refactoring technique using LINQ and I hope it will give you some insight into the power of LINQ.

Recently I came across with a very specific requirement where as soon as we persist our aggregate root (Code First POCO) into the database, the entire object need to be stored in an audit table as a key value pair (property and values).

I know it may sound a bit strange but hey requirements are requirements and if it adds value to the business then why not.

I thought it would be easy as I can use JavaScript Serialzer and store it as a JSON object in SQL Server database but that was not the case as the requirement specifically said it has to be just a key value pair.

Also the JavaScript Serializer solution would not have worked as I had one-to-many and then many-to-many relations in EF Code first POCO objects and JavaScript Serializer was giving exception due to circular objects.I could have tried fixing the seriliazer problem but I didn’t pursue it too hard as this technique was not a fool-proof solution.

So I googled it and found this reflection helper class

ReflectionHelper.cs

 public static class ReflectionHelper
{
    public static string DisplayObjectProperties(Object o)
    {
        StringBuilder sb = new StringBuilder();
        System.Type type = o.GetType();
        foreach (PropertyInfo p in type.GetProperties())
        {
            if (p.CanRead)
            {
                object obj = p.GetValue(o, null);
                if (obj != null)
                {
                    sb.AppendLine(String.Concat("-Property name: ", p.Name ));
                    sb.AppendLine(String.Concat("-Property value:", obj.ToString()));
                    sb.AppendLine();
                }
                else sb.Append(String.Concat(p.Name, " # Value is null"));

            }
        }
        return sb.ToString();
    }
}

The code is pretty slick and does what it is supposed to do and worked in my scenario, no problem at all.

I then decided how can I make this code even better and leverage some of the new language feature. For me foreach loop with lots of if else conditions is a code smell and had to do something about it. So here is the refactored code using LINQ.

ReflectionHelper.cs

public static class ReflectionHelper
{
    public static string DisplayObjectProperties(this Object o)
    {
        var sb = new StringBuilder();
        var type = o.GetType();
        var query = from property in type.GetProperties()
                    where property.CanRead &&
                          property.GetValue(o, null) != null
                    select property;

        foreach (var propertyInfo in query)
        {
            sb.AppendFormat("{0}:{1}\n", propertyInfo.Name,
                                propertyInfo.GetValue(o));
        }
        return sb.ToString();
    }
}

As you can see nothing fancy but all the ifs conditions have been converted into a LINQ query,a simple technique but looks good.

Happy Clean Coding !!! πŸ™‚

Getting Started with TopShelf

December 31, 2012 3 comments

I am a huge fan and follower of open source project and there have been so many great open source projects which tend to solve our complex problem with such an ease. In fact I love the way open source is becoming main stream and even Microsoft has come to the party. However I have notice not every .net developer is across it at least in Canberra.

Today I am going to talk about an underrated open source project called TopShelf which in my opinion deserve a lot of more recognition in the community and decided to blog about it

So TopShelf is a windows service framework which allows to build windows services with out the pain of what .net/visual studio provides. The project is hosted at Github and can be found here.

In fact if you remember in April of this year I blogged “NServiceBus: The Magic of Generic Host” and showed you how NService Bus installs your handler as a windows service, but the real magic behing Generic host is TopShelf and Enterprise Service Bus like NServiceBus and Mass Transit both use TopShelf internally to install handlers as windows service.

Lets get stated and write some code to use TopShelf. Create a new console application and type the following NuGet Command.

PM> Install-Package TopShelf

NuGet will install ‘TopShelf 3.1.0’. Lets create an interface which will encapsulate the windows service start and stop method and TopShelf itself requires a start method and stop method

IService.cs

public interface IService
{
    void Start();
    void Stop();
}

For a real life example lets pretend we are writing an Email service which polls database every 10 seconds and based on some domain logic processes and sends the email. I am not going to go into the details of polling and threading etc and this is just a demo code for the Email Service.


EmailService.cs

public class EmailService : IService
{
    public void Start()
    {
        Console.WriteLine("Starting Service ...");
    }

    public void Stop()
    {
        Console.WriteLine("Stopping the service ...");
    }
}

Now in our main program we just have to wireup the TopShelf Host factory.

Program.cs

class Program
{
    static void Main(string[] args)
    {
        HostFactory.Run(x =>                                 
        {
            x.Service<IService>(s =>                        
            {
                s.ConstructUsing(name => new EmailService());   
                s.WhenStarted(tc => tc.Start());             
                s.WhenStopped(tc => tc.Stop());              
            });
            x.RunAsLocalSystem();

            x.SetDescription("Email Service to send emails 
                              and proudly hosted by TopShelf"); 
            x.SetDisplayName("Email Service to send emails");                       
            x.SetServiceName("EmailService");                       
        });               

    }
}

 

and that’s it there are no other moving parts or special type of projects or files to include. There are many other useful settings like under which account the windows service should run and on what other services it depends on etc can be easily configured using the fluent apis.The best thing about TopShelf is that as part of your development and debugging you can run it as a normal console application and when you are ready you can just install it as a windows service.

Lets look into installing it as windows service. Launch command prompt as Administrator

and type the following command :-

Topshelf will install the service and will output the following result and which means you have successfully installed your application as a windows service.

Now to verify it open up windows services snap in MMC and you will see your service installed properly with the service name and description. Remember that the display name and description can be anything you want however the windows service name cannot have any spaces as you can see in the above code.

Now you can go ahead and start the windows service. To uninstall it’s again the name of your executable with uninstall option.So for our demo app it will be

TopShelfDemo.exe uninstall

That’s it folks and have a happy coding new year !!!

Entity Framework: Viewing SQL

July 16, 2012 1 comment

In this post I am going to show you a cool trick I learned regarding ObjectQuery class and how it can be useful when working with Entity Framework.

In order to see what SQL statement Entity Framework is executing we generally tend to run the SQL profiler and set custom filters like the database name or id, the current user under which our code is going to execute the linq query etc so that we can isolate our query execution.

I find this approach very ugly as you have to start-stop your profiler trace in order to capture the exact time when the SQL is executed and in multi developer environment when everyone is developing against the same database it becomes quite challenging.

Well it’s not painful if we use a better approach using the ObjectQuery class and an extension method which extends the IQueryable interface. So here is the code for the ObjectQuery Extension class.

ObjectQueryExtension.cs

public static class ObjectQueryExtension
{
    public static string ToTraceString(this IQueryable t)
    {
        var objectQuery = t as ObjectQuery;
        return objectQuery != null ? objectQuery.ToTraceString() : 
                                     String.Empty;
    }
}

So now I’ll generate the EF Model from the publisher database and the entities I am interested in are Author and Title as shown below.

EF Publisher Data Model

and the following code to display the SQL statement in the console window.

Program.cs

class Program
{
    static void Main(string[] args)
    {
        using (var context = new PublisherContext())
        {
            var authorId = "998-72-3567";
            var query = context.Author
                            .Where(x=>x.au_id == authorId)
                            .SelectMany(ta=> ta.titleauthors,(au,ti)
                            => new {
                                    au.au_id,
                                    au.au_fname,
                                    au.au_lname,
                                    ti.title
                                    });

            var sql = query.ToTraceString();
            Console.WriteLine("Generated SQL is :");
            Console.WriteLine(sql);
            Console.ReadKey();
        }
    }
}

and this is how the output looks like.

SQL Output to Console Window

As you can see this small extension methods has lots of potential as you can use it along with logging frameworks like log4net and output the SQL to a file.

Just Decompile

In this post I am going to talk about a free tool called JustDecompile by Telerik and I have been using it for sometime. I know a lot of people were upset when .NET Reflector tool was not free anymore and In my opinion it is a good and inexpensive replacement for .NET reflector.

The download link for JustDecompile is here.

Setup is a very easy 4 step process.

Just Decompile Setup

You can load different version of .Net framework as shown below.

Just Decompile UI
This is how the view looks when you open a .Net assembly.
Viewing an assembly

It has a nice search functionality

Searching assemblies using Just Decompile

One thing I use the most is language conversion between C# and VB.NET. I often have to work with legacy systems or other old projects where I have to either read VB.NET Code to understand the logic or write some code in VB.NET.And at times it is hard to switch gears between the two languages specially with each version of .NET adding complex language features like lambda expression etc.

I don’t know about you guys but this is how my brains works and I am not good at instantly switching between different languages and I find JustDecompile so productive as it allows you view the code in C#,VB.NET or IL Code.

Switching between VB.NET and C# Code

That’s it folks and Happy De Compiling !!!

Layer Supertype Pattern

October 25, 2011 11 comments

In this post i am going to show another of my favorite pattern called the Layer Supertype Pattern. It’s again a very simple but very useful pattern and was described by Martin Fowler in his famous book Patterns of Enterprise Application Architecture. If you haven’t read this book I strongly recommend you to read this as it will help you in building better Enterprise Applications.

Anyway this is what the definition in the book is :-

It’s not uncommon for all the objects in a layer to have methods you don’t want to have duplicated throughout the system. You can move all of this behavior into a common Layer Supertype.

 

In the past I have implemented various different implementation of this pattern but the common design pattern is that for a layer or suite of component with specialized behaviour we can abstract some behaviour or attribute to a base class so that we can remove some of the duplications.

For example say we are designing a business layer and we have set of business objects the purpose of this layer is to validate domain objects before it can be persisted in a data store. As we can see these business object will encapsulate this functionality from other layers, and its main functionality will be indicate whether the business object itself is valid or not and what the different violation it has from a business rules.

Well that’s a good starting point and things we have identified using our Object Oriented Analysis and Design ( OOAD ) are :-

  • Business Rule (holds the rule definition)
  • A base entity (to state whether the object is valid and what are the violations
  • Business Object ( will implement the Entity Base )

Lets start writing some code :-

BusinessRule.cs

public class BusinessRule
{
   public string Property { get; set; }

   public string Rule { get; set; }

   public BusinessRule(string property, string rule)
   {
      Property = property;
      Rule = rule;
   }
}

EntityBase.cs

public abstract class EntityBase<T>
{
   private readonly List<BusinessRule> _brokenRules = new List<BusinessRule>();
   protected abstract void Validate();

   public IEnumerable<BusinessRule> GetBrokenRules()
   {
      _brokenRules.Clear();
      Validate();
      return _brokenRules;
   }

   protected void AddBrokenRule(BusinessRule businessRule)
   {
      _brokenRules.Add(businessRule);
   }
}

Lets implement a customer class which inherits from the EntityBase class.

Customer.cs

public class Customer : EntityBase<Int32>
{
   public Int32 Id { get; set; }
   public string FirstName { get; set; }
   public string LastName { get; set; }
   public DateTime DOB { get; set; }

   protected override void Validate()
   {
      if (string.IsNullOrEmpty(FirstName))
      {
         AddBrokenRule(new BusinessRule("FirstName","First name cannot be empty"));
      }

      if (string.IsNullOrEmpty(LastName))
      {
         AddBrokenRule(new BusinessRule("LastName", "Last name cannot be empty"));
      }

   }
}

And to complete the task lets write a unit test to check whether we get the desired result or not.

UnitTest.cs

[TestClass]
public class When_using_customer
{
   [TestMethod]
   public void Should_ab_able_to_validate_customer()
   {
      //Arrange
      var customer = new Customer();

      //Act
      var brokenRules = customer.GetBrokenRules().ToList();

      //Assert
      Assert.IsTrue(brokenRules.Count > 0);
   }
}

And now when we run our unit test we get the two broken rules for customer,also if you look at the EntityBase class closely we are using Template method pattern in the GetBrokenRules method which I blogged last year and can be found here.