Joe

ActiveRecord: could not resolve property

Joe — Mon, 02 Jun 2008 17:24:52 GMT

Because this has bitten me in the ass more than once.

When using ActiveRecord to query the database the following error occurs:

Failed: Castle.ActiveRecord.Framework.ActiveRecordException : Could not perform SlicedFindAll for ShoppingCart
  ----> NHibernate.QueryException : could not resolve property: UserId of: MyDomain.Core.ShoppingCart

Problem: The Property values in the criteria are case sensitive.

Where the query looks like this:

        public ShoppingCart LoadCurrentBasket(string userId, Guid customerId)
        {
            DetachedCriteria criteria = DetachedCriteria.For<ShoppingCart>();
            criteria.Add(Expression.Eq("UserId", userId));
            criteria.Add(Expression.Eq("CustomerId", customerId));

            return ActiveRecordMediator<ShoppingCart>.FindFirst(criteria);
        }

And the class looks like this:

    [ActiveRecord(Table = "Basket")]
    public class ShoppingCart
    {
        private IList<ShoppingCartItem> _LineItems = new List<ShoppingCartItem>();

        [PrimaryKey(PrimaryKeyType.Guid)]
        public Guid BasketID { get; set; }

        [Property("CustomerId")]
        public Guid CustomerID { get; set;}

        [Property("UserID")]
        public string UserID { get; set;}

///
///
///

    }

ExecuteList<T> and ExecuteItem<T>

Joe — Thu, 17 Jan 2008 20:08:29 GMT

In a hand coded data-access layer you often end up with some variant of this pattern when translating a datareader to an entity.

public List<ICarrier> LoadList()
{    
    List<ICarrier> items = new List<ICarrier>();
    using (SafeDataReader reader = new AdoHelper().ExecuteDataReader(CommandType.Text, "Select * from _lu_Carrier"))
    {
        while (reader.Read())
        {
            items.Add(MapCarrier(reader));
        }
    }
    return items;
}

where your ADOHelper does whatever it needs to do to connect to the database and run your query. This is generally coupled with "mapping" method (MapCarrier in this instance)

public static ICarrier MapCarrier(SafeDataReader dr)
{
    ICarrier carrier = new Carrier();
    carrier.Name = dr.GetString("Name");
    carrier.Phone = dr.GetString("Phone");
    carrier.SCAC = dr.GetString("SCAC");
    carrier.URL = dr.GetString("URL");

    return carrier;
}

I think this is a fairly standard approach, and it works well. However, it's tedious and can lead to lots of repetition as your DAL grows. Enter the magic of generics and delegates which allow the code in the first block to become something like this:

public List<ICarrier> GetList()
{
    return new AdoHelper().ExecuteList<ICarrier>(CommandType.Text, 
                                                 "Select * from _lu_Carrier", 
                                                 MapCarrier);
}

ExecuteList<T> is overloaded to allow for a few variations which all route to this:

public List<T> ExecuteList<T>(CommandType commandType, string commandText, Func<T, SafeDataReader> mappingCallback, params SqlParameter[] parameters)
{
    List<T> collection = new List<T>();
    using (SafeDataReader reader = ExecuteDataReader(commandType, commandText, parameters))
    {
        while (reader.Read())
        {
            collection.Add(mappingCallback(reader));
        }
    }
    return collection;
}

The "magic" here is the Func<T SafeDataReader> delegate being passed in. This is (lifted directly from Rhino.Commons) and is declared as

public delegate TResult Func<TResult, S>(S s1);

ExecuteItem<T> is similar, but returns a single entity instead of a collection

public T ExecuteItem<T>(CommandType commandType, string commandText, Func<T, SafeDataReader> mappingCallback, params SqlParameter[] parameters)
{
    using (SafeDataReader reader = ExecuteDataReader(commandType, commandText, parameters))
    {
        while (reader.Read())
        {
            return mappingCallback(reader);
        }
    }
    return default(T);
}

Over even a small project this can save a lot of typing and a substantial amount of time.

Extension Methods and Fluent Interfaces

Joe — Thu, 10 Jan 2008 13:52:04 GMT

File under stupid semantic tricks.

Extension methods (which seem ripe for abuse and all kinds of bad code) provide some great flexibility when working with fluent interfaces. For example, take the following extensions to the date class

    public static class ExtensionMethods

        public static bool IsBefore(this DateTime dt, DateTime other)

            return other > dt;

This allows us to better express our intent

    public class WorkingWith

        public void Test1()

            DateTime myBirthday = new DateTime(2008, 3, 1);

            DateTime christmans = new DateTime(2008, 12,25);

            if (myBirthday.IsBefore(christmans))

                Console.WriteLine("yes");

Which is nice, but can get better by wiring in a call to a utility class

    public static class ExtensionMethods

...

        public static IsBetweenDateRange IsBetween(this DateTime dt, DateTime lowDate)

            return new IsBetweenDateRange(dt, lowDate);

which allows a readable (as opposed to parse-then-translate-able) statement such as

        public voidTest2()

            DateTime myBirthday = new DateTime(2008, 3, 1);

            DateTime halloween = new DateTime(2008, 10, 31);

            DateTime christmans = new DateTime(2008, 12,25);

            if (halloween.IsBetween(myBirthday).And(christmans))

The utility class in this case being

    public class IsBetweenDateRange

        private DateTime _baseDate;

        private DateTime _lowDate;

        public IsBetweenDateRange(DateTime baseDate, DateTime lowDate)

            _baseDate = baseDate;

            _lowDate = lowDate;

        public bool And(DateTime highDate)

            return _baseDate > _lowDate && _baseDate < highDate;

Using Binsor in an Asp.Net Application

Joe — Tue, 08 Jan 2008 17:40:46 GMT

This tutorial covers using Binsor2 in an asp.net application.

Because of different versions and the dearth of information available about getting started with Binsor, I would recommend getting the files listed later in this article directly from the trunk as the syntax between versions 1 and 2 has changed. There is a readme file covering how to build the trunk, and I would add the following points to that:

1. Run your "Visual Studio Command Line" so that MSBuild is in your path (Start|Programs|Microsoft Visual Studio 200x|Visual Studio Tools)
2. I had to add a folder called "lib" to "C:\Program Files\Microsoft SDKs\Windows\v6.0A" to get the build to run.

Getting Started

Create a new library called BinsorDemo.Domain, and add the following domain entities (fields made public for brevity).

    public class Account
    {
        public string FirstName;
        public string LastName;
        public string State;
        public decimal Balance;
        public List<Purchase> PurchaseHistory;
    }

    public class Purchase
    {
        public DateTime Date;
        public decimal Amount;
        public decimal AmountDue;

        public Purchase(DateTime date, decimal amount, decimal amountDue)
        {
            Date = date;
            Amount = amount;
            AmountDue = amountDue;
        }
    }

Next, add the following interfaces. These are the services that we will "wire-up" using Binsor.

    public interface ICreditService
    {
        decimal GetCreditRemaining(Account c);
    }

    public interface IInterestCalculator
    {
        decimal CalculateInterestOn(Account account);
    }

Finally, add the following concrete implementations of the interfaces.

    public class CreditService : ICreditService
    {
        private decimal _CreditLimit;

        public CreditService(decimal creditLimit)
        {
            _CreditLimit = creditLimit;
        }

        public decimal GetCreditRemaining(Account account)
        {
            decimal totalOutstanding = 0M;
            account.PurchaseHistory.ForEach(delegate (Purchase p){totalOutstanding += p.Amount - p.AmountDue;});
            return _CreditLimit = totalOutstanding;
        }
    }

    public class InterestCalculator : IInterestCalculator
    {
        private readonly decimal _InStateAmount;
        private readonly decimal _OutOfStateAmount;
        private readonly string _ThisState;

        public InterestCalculator(decimal inStateAmount, decimal outOfStateAmount, string thisState)
        {
            _InStateAmount = inStateAmount;
            _OutOfStateAmount = outOfStateAmount;
            _ThisState = thisState;
        }

        private decimal DetermineInterestRateFor(Account account)
        {
            if (account.State.Equals(_ThisState, StringComparison.InvariantCultureIgnoreCase))
                return _InStateAmount;
            else
                return _OutOfStateAmount;
        }

        public decimal CalculateInterestOn(Account account)
        {
            decimal interestRate = DetermineInterestRateFor(account);
            decimal interest = 0M;

            account.PurchaseHistory.ForEach(delegate (Purchase purchase){interest += purchase.AmountDue*interestRate;});
            return interest;
        }
    }

Create the Web Application

Next create a web application called BinsorDemo.Web. Add the following references (as mentioned above, I would pull these directly from the trunk - these will be located in [x:\trunk]\rhino-commons\Rhino.Commons\bin\Debug).

Boo.Lang
Boo.Lang.Compiler
Boo.Lang.Parser
Castle.Core
Castle.Windsor
log4net
Rhino.Commons
BnisorDemo.Domain

Add a new file to the root of the application called "windsor.boo", and add the following to it.

import BinsorDemo.Domain

creditLimitAmount as decimal = 500.0

component 'credit_service', ICreditService, CreditService:
                        creditLimit=creditLimitAmount


inState as decimal = .05
outOfState as decimal = .075
myState = 'MD'

component 'interest_service', IInterestCalculator, InterestCalculator: 
                            inStateAmount = inState
                            outOfStateAmount = outOfState
                            thisState = "MD"

Next add a global code file (global.asax), if it is not already there. Add the following to this file. The Application_Start event is where the magic takes place.

 public class Global : System.Web.HttpApplication
    {
        private static IWindsorContainer container;

        public static IWindsorContainer Container
        {
            get { return container; }
        }

        protected void Application_Start(object sender, EventArgs e)
        {
            XmlConfigurator.Configure();
            string binsorConfigFilePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "windsor.boo");
            container = new WindsorContainer();
            BooReader.Read(container, binsorConfigFilePath);
        }
    }

Finally

Let's run a quick test to see if everything is working OK. Add the following to a WebForm's Page_Load event, and navigate to that page.

    protected void Page_Load(object sender, EventArgs e)
        {
            Account demoAccount = new Account();
            demoAccount.FirstName = "Foo";
            demoAccount.LastName = "Bar";
            demoAccount.Balance = 250;
            demoAccount.State = "MD";

            demoAccount.PurchaseHistory = new List<Purchase>();
            demoAccount.PurchaseHistory.Add(new Purchase(new DateTime(2007, 10, 16), 100M, 15M));
            demoAccount.PurchaseHistory.Add(new Purchase(new DateTime(2007, 11, 16), 10M, 0));
            demoAccount.PurchaseHistory.Add(new Purchase(new DateTime(2007, 12, 16), 250M, 35M));

            Response.Write(Global.Container.Resolve<ICreditService>().GetCreditRemaining(demoAccount));
            Response.Write("<hr/>");
            Response.Write(Global.Container.Resolve<IInterestCalculator>().CalculateInterestOn(demoAccount));
        }

Rhino Mocks Introductory Tutorials

Joe — Thu, 13 Dec 2007 17:17:23 GMT

Another Introduction to Rhino Mocks

Another Introduction to Rhino Mocks - Part II

lsass.exe Crashes During Login

Joe — Thu, 15 Nov 2007 21:14:05 GMT

On HP laptops with the built-in credential manager (fingerprint scanner) running with VMWare (server) running, lsass.exe will crash while logging in telling you that your computer will reboot in 60 seconds. As documented here, there are a couple of workarounds for this

Disable the fingerprint scanner
Set the VMWare services to Manual instead of Automatic (start | run | services.msc)

Because it's almost 2010 and I want Minority Report style eyeball scanning technology, I settled for number 2 and set following services to Manual. (they sounded important, and had a circular dependency on each other)

VMWare Authorization Service [VMAuthdService]
VMWare Registration Service [VMServerdWin32, RPC Service]

I left the other 3 services alone as they seemed innocent enough, and had no dependencies. They were

VMWare DHCP Service [VMNetDHCP]
VMWare NAT Service [VMWare NAT Service]
VMWare Virtual Mount Manager Extended [vmount2]

Obviously, the services I stopped need to be running for the VMWare application to run, and they do not start without being told to (I was hoping that launching the application would trigger the loading of these). After verifying that I could start and stop these services from the command line, I added a batch file named VMWareServices to my "Startup" folder with the following commands:

net start vmauthdservice
net start vmserverdwin32

AND IT STILL FAILED

Next I tried reversing the order these were called in. This stopped the crash, but for whatever reason vmserverdwin32 did not start.

I then added a ping delay delay of 60 seconds. Still no good. I could get to the command prompt and type the net start command, and I received the message that the service didn't start in a timely fashion. Immediately try again and it fires up. Same results as 120 and 180 seconds.

@#$*&($*!#^)&%^*^#$^@

Out of frustration more than anything else, I set the services back to the original order with a 120 second delay and it worked. Knocked it down to 60 seconds, and it's still good.

SOLUTION

It's irritating, and it's far from optimal, and I'm not sure why I need the delay, but it does the job.

ping 127.0.0.1 -n 60
net start vmauthdservice
net start vmserverdwin32

Refactoring: From Disaster to Decorator

Joe — Wed, 31 Oct 2007 20:01:09 GMT

In Working Effectively with Legacy Code Michael Feathers describes legacy code as "code without tests". I describe it as the crap I wrote 4 years ago.

The code block that I was working with looked like the image to the left. It was a single method that was 278 lines long, had a cyclomatic complexity of 80 and (according to DevExpress' DXCore) a horrific maintenance complexity of 1766. The method was used to validate warranty claims and had conditional branching for "Save", "Get Price Details", and "Place". In addition, the "Get Price Details" and "Place" blocks had conditional statements to handle cases for specific countries.

The first step in refactoring this to something resembling a maintainable state was to extract the method in to it's own WarrantyValidator class. This meant creating a constructor that accepted all of the variables and fields from the original object that would be required to do the validation. In this case I needed the Warranty Claim being validated, the user's country, a list to store the failure messages in (a discussion for another day) and the number of items on the claim.

The end result is a class that looked like this (this is "blog" code)

    public class ValidateClaim
    {
        private readonly WarrantyClaim ClaimToValidate;
        private int NumberOfItemsOnClaim;
        private readonly string CountryCode;
        private readonly List<string> ErrorCodes;


        public ValidateClaim(WarrantyClaim claimToValidate, int numberOfItemsOnClaim, string countryCode, List<string> errorCodes)
        {
            ClaimToValidate = claimToValidate;
            NumberOfItemsOnClaim = numberOfItemsOnClaim;
            CountryCode = countryCode;
            ErrorCodes = errorCodes;
        }


        public bool Validate(string ActionName)
        {
            if (ActionName == "SAVE")
            {
                //save-specific validation for example
                if (string.IsNullOrEmpty(ClaimToValidate.AuthorizationNumber))
                {
                    ErrorCodes.Add("12345678-1234-1234-123456789012");
                }
            }
            else if (ActionName == "PRICE")
            {
                //pricing-specifi validation
                
                if (CountryCode == "US")
                {
                    //us specific validation
                }
                else if (CountryCode == "GB")
                {
                    //gb specific valudation
                }
            }
            else if (ActionName == "PLACE")
            {
                if (CountryCode == "US")
                {
                    //us specific validation
                }
                else if (CountryCode == "GB")
                {
                    //gb specific valudation
                }
            }

            /*
             * lots of validation no matter what the action is
             * ...
             * ...
             * ...
             */

            return ErrorCodes.Count == 0;
        }
    }

The next step (which I guess probably should have been the first) was generate tests to cover as much code as possible. In doing this I found that I needed a couple of additional parameters in my constructor as data that was exposed through the properties of the WarrantyClaim wasn't available without banging against the database. At the end of this phase, I had managed to get about 95% test coverage, and some analysis of the WarrantyClaim suggested that a couple of cases for which validation code existed were no longer possible. With 76 "green" tests I began breaking up the object and re-running the tests for verification after every change.

The first change was to create the WarrantyValidatorBase. This abstract class contained a constructor identical to my WarrantyValidator class and an abstract method called Validate.

public abstract class WarrantyValidatorBase
{
    protected readonly WarrantyClaim ClaimToValidate;
    protected int NumberOfItemsOnClaim;
    protected readonly string CountryCode;
    protected readonly List<string> ErrorCodes;

    public WarrantyValidatorBase(WarrantyClaim claimToValidate, int numberOfItemsOnClaim, string countryCode, List<string> errorCodes)
    {
        ClaimToValidate = claimToValidate;
        NumberOfItemsOnClaim = numberOfItemsOnClaim;
        CountryCode = countryCode;
        ErrorCodes = errorCodes;
    }

    public abstract void Validate();
}

From here I moved all of the Save validation to it's own class, and repeated this with the Price Details and Place validation. Next, I extracted the country specific validation into separate classes - WarrantyPlaceValidationUS, WarrantyPlaceValidationGB, etc.

    public class WarrantyPlaceValidator : WarrantyValidatorBase
    {
        public WarrantyPlaceValidator(WarrantyClaimWarrantyClaim claimToValidate, int numberOfItemsOnClaim, 
                                        string countryCode, List<string> errorCodes) 
            : base(claimToValidate, numberOfItemsOnClaim, countryCode, errorCodes)
        {
        }


        public override void Validate()
        {
            //place specific validation

            if (CountryCode == "US")
            {
                new WarrantyPlaceValidatorUS(ClaimToValidate, NumberOfItemsOnClaim, CountryCode, ErrorCodes).Validate();
            }
            else if (CountryCode == "GB")
            {
                //gb specific valudation
                new WarrantyPlaceValidatorGB(ClaimToValidate, NumberOfItemsOnClaim, CountryCode, ErrorCodes).Validate();
            }
        }
    }


    public class WarrantyPlaceValidatorUS : WarrantyValidatorBase
    {
        public WarrantyPlaceValidatorUS(WarrantyClaim claimToValidate, int numberOfItemsOnClaim,
                                        string countryCode, List<string> errorCodes)
            : base(claimToValidate, numberOfItemsOnClaim, countryCode, errorCodes)
        {
        }


        public override void Validate()
        {
            //us specific validation
        }
    }


    public class WarrantyPlaceValidatorGB : WarrantyValidatorBase
    {
        public WarrantyPlaceValidatorGB(WarrantyClaimclaimToValidate, int numberOfItemsOnClaim,
                                        string countryCode, List<string> errorCodes)
            : base(claimToValidate, numberOfItemsOnClaim, countryCode, errorCodes)
        {
        }


        public override void Validate()
        {
            //GB specific validation
        }
    }

After this refactoring, my original diagram looked a little like this:

Again, after each change, I re-ran my tests and made sure that everything was still ok.

So far, so good. The new code was a far easier to maintain than the previous approach. I now had small testable classes, which were easy to read and instantly understandable. They all had very specific purposes and were very loosely coupled. However, there was still an awful lot of duplication in the constructors, and I was not happy with the country specific cases being handled this way.

I knew this needed to be resolved, but I was a little stuck. I am pretty clueless when it comes to design patterns and to be perfectly honest, the GoF book makes me want to gouge my eyes out. Fortunately, the Head First book and Alex Henderson's Windsor tutorial gave me a little insight into the Decorator pattern. Time for some more refactoring...

The WarrantyValidatorBase ended up looking like this.

public abstract class WarrantyValidatorBase
    {

        private List<string> _ErrorPhrases;
        private WarrantyClaim _WarrantyClaim;
        private WarrantyValidatorBase _ChildValidator;
        private int _NumberOfPartsInBasket;

        public WarrantyValidatorBase()
        {
        }

        public WarrantyValidatorBase(WarrantyValidatorBase decorateWith)
        {
            _ChildValidator = decorateWith;
        }

        protected void AddErrorId(string errorGuid)
        {
            _ErrorPhrases.Add(errorGuid);
        }

        internal ToolCommerce.Warranty WarrantyClaim
        {
            get { return _WarrantyClaim; }
            set { _WarrantyClaim = value; }
        }

        internal List<string> Phrases
        {
            get { return _ErrorPhrases; }
            set { _ErrorPhrases = value; }
        }

        internal int NumberOfPartsInBasket
        {
            get { return _NumberOfPartsInBasket; }
            set { _NumberOfPartsInBasket = value; }
        }

        internal WarrantyValidatorBase ChildValidator
        {
            get { return _ChildValidator; }
            set { _ChildValidator = value; }
        }


        public abstract void Validate();

        protected virtual void ValidateChild()
        {

            if (_ChildValidator!=null)
            {
                _ChildValidator.Phrases = _ErrorPhrases;
                _ChildValidator.WarrantyClaim = _WarrantyClaim;
                _ChildValidator.NumberOfPartsInBasket = _NumberOfPartsInBasket;
                _ChildValidator.Validate();
            }
        }

    }

Note the addition of the _ChildValidator field and the constructor changes to accept another object deriving from WarrantyValidatorBase. I also moved the arguments from the constructor to properties - this just seemed a little cleaner to me. The ValidateChild method is key here. It passes the validation request down the "decorator chain" to its ChildValidator, and its ChildValidator to its ChildValidator and so on. This approach allowed me to change my WarrantyPlaceValidator to this:

public class WarrantyPlaceValidator : WarrantyValidatorBase
{
    public WarrantyPlaceValidator(WarrantyValidatorBase childValidation)
    {
        ChildValidator = childValidation;
    }

    public override void Validate()
    {
        //place specific validation
        //notice that there is nothing specific to countries in here any more
        ValidateChild();
    }
}

End Result

The awesomeness of the decorator is that I can chain these together and add functionality without having to clutter up my classes with conditionals and branching logic.

public void ValidateForPlace(Warranty claimToValidate, int numberOfItemsOnClaim, string countryCode, List<string> errorCodes)
{
    WarrantyValidatorBase validator = null;

    if (countryCode == "US")
    {
        validator = new WarrantyValidator(new WarrantyPlaceValidator(new WarrantyPlaceValidatorUS()));
    }
    else if (countryCode == "GB")
    {
        validator = new WarrantyValidator(new WarrantyPlaceValidator(new WarrantyPlaceValidatorGB()));
    }
    else
    {
        //no country specific validation
        validator = new WarrantyValidator(new WarrantyPlaceValidator());
    }

    validator.NumberOfPartsInBasket = numberOfItemsOnClaim;
    validator.Phrases = errorCodes;
    validator.WarrantyClaim = claimToValidate;
    validator.Validate();
}

If new functionality is required, it can be encapsulated and then "chained" in.

Unable to create a manifest resource name for ...

Joe — Mon, 15 Oct 2007 20:20:13 GMT

In case I run into this again...

During a build for a .net solution using Team Foundation Server, we got an error that said.

error MSB3041: Unable to create a manifest resource name for "NewService\WarrantyUpload.aspx.resx". Could not find a part of the path 'E:\Builds\My App\Source\Code\MyApp.WebApp\Folder\File.aspx.vb'.

What had happened was that \Folder had been accidentally dragged and dropped into another folder.

Fluent Interface Take 2

Joe — Fri, 21 Sep 2007 01:42:30 GMT

Where this is code that is duplicated all over the place with only minor alterations for the data source and the default value:

DropDownList cbo = new DropDownList();
cbo.DataSource = PersonMotherObject.GetPersons();
cbo.DataTextField = "FirstName";
cbo.DataValueField = "LastCommaFirst";
cbo.DataBind();

cbo.Items.Insert(0, new ListItem("", "----- SELECT -----"));

foreach (ListItem listItem in cbo.Items)
{
    listItem.Selected = listItem.Value == "Flanders, Ned";
}

This reads a lot easier, and gets us a little more DRY:

new ComboBoxSetter<Person>()
                .WithListControl(ddl)
                .WithDataSourceOf(PersonMotherObject.GetPersons())
                .SetSelectedWhereTextIs("Ned")
                .AddLeadingItemOf("", "-----Select------")
                .TheDataTextFieldIs("FirstName")
                .TheDataValueFieldIs("LastCommaFirst")
                .Bind();

The class that does the grunt work (reformatted for brevity)

/// <summary>
/// Provides a fluent interface for setting a combo box
/// </summary>
public class ComboBoxSetter<T>
{
    private ListControl Control;
    private IList<T> DataSource;
    private string DefaultValue;
    private ListItem ListItemToAdd;
    private string DataValueField;
    private string DataTextField;

    public void Bind()
    {
        Control.DataSource = DataSource;
        Control.DataTextField = DataTextField;
        Control.DataValueField = DataValueField;
        Control.DataBind();

        if (ListItemToAdd != null)
            Control.Items.Insert(0, ListItemToAdd);

        if (!string.IsNullOrEmpty(DefaultValue))
            foreach (ListItem listItem in Control.Items)
                listItem.Selected = listItem.Text == DefaultValue;
    }


    public ComboBoxSetter<T> WithListControl(ListControl ddl)
    {
        Control = ddl;
        return this;
    }

    public ComboBoxSetter<T> WithDataSourceOf(IList<T> people)
    {
        DataSource = people;
        return this;
    }

    public ComboBoxSetter<T> SetSelectedWhereTextIs(string defaultSelection)
    {
        DefaultValue = defaultSelection;
        return this;
    }

    public ComboBoxSetter<T> AddLeadingItemOf(string value, string display)
    {
        ListItemToAdd = new ListItem(display, value);
        return this;
    }

    public ComboBoxSetter<T> AddLeadingItemOf(ListItem leadingItem)
    {
        ListItemToAdd = leadingItem;
        return this;
    }

    public ComboBoxSetter<T> TheDataValueFieldIs(string dataValueField)
    {
        DataValueField = dataValueField;
        return this;
        
    }

    public ComboBoxSetter<T> TheDataTextFieldIs(string dataTextField)
    {
        DataTextField = dataTextField;
        return this;
    }

HTTP Cache Helper With a Fluent Interface

Joe — Fri, 14 Sep 2007 03:43:29 GMT

After writing the same 20 lines of boilerplate code for the 1000th time, I decided to encapsulate it in a class and add some syntactic sweetness to it in the form of a fluent interface as recently demonstrated by Joey Beninghove.

What I had been doing was something like the following pseudocode (or a slight variation) in every place I wanted to cache something.

declare returnObject as null

if the HTTPCache available
    if the object is available in the cache
        set returnObject
    else
        set returnObject to whatever code is needed to get the object
        add returnObject to the cache
else
  set returnObject to whatever code is needed to get the object

return returnObject

Here is the class I ended up with.

public class HTTPCacheHelper<T>
 {
     private DateTime? _AbsoluteExpiration;
     private TimeSpan? _SlidingExpiration;
     private CacheItemPriority _Priority = CacheItemPriority.Default;
     private string _Key;

     /// <summary>
     /// Key of item stored in the cache.
     /// </summary>
     public HTTPCacheHelper<T> WithKeyOf(string key)
     {
         _Key = key;
         return this;
     }

     /// <summary>
     /// Absolute date to expire on
     /// </summary>
     /// <remarks>
     /// Optional, but either this or WithSlidingExpiration must be called
     /// </remarks>
     public HTTPCacheHelper<T> WithExpirationDateOf(DateTime expires)
     {
         _AbsoluteExpiration = expires;
         return this;
     }

     /// <summary>
     /// Sliding timespan to expire on.
     /// </summary>
     /// <remarks>
     /// Optional, but either this or WithExpirationDateOf must be called
     /// </remarks>
     public HTTPCacheHelper<T> WithSlidingExpiration(TimeSpan ts)
     {
         _SlidingExpiration = ts;
         return this;
     }

     /// <summary>
     /// Priority
     /// </summary>
     public HTTPCacheHelper<T> WithPriorityOf(CacheItemPriority priority)
     {
         _Priority = priority;
         return this;
     }

     /// <summary>
     /// Adds the item to the cache based data passed in in previous methods.  
     /// This will the last method call in the chain, and must
     /// be called in order to for the item to be cached.
     /// </summary>
     public void Commit(T item)
     {
         Debug.Assert(!item.Equals(default(T)));
         Debug.Assert(!_AbsoluteExpiration.HasValue ^ _SlidingExpiration.HasValue);
         Debug.Assert(!string.IsNullOrEmpty(_Key));

         if (!_AbsoluteExpiration.HasValue) _AbsoluteExpiration = Cache.NoAbsoluteExpiration;
         if (!_SlidingExpiration.HasValue) _SlidingExpiration = Cache.NoSlidingExpiration;

         lock (HttpRuntime.Cache)
         {
             HttpRuntime.Cache.Add(_Key, item, null, _AbsoluteExpiration.Value, _SlidingExpiration.Value, _Priority, null);
         }
     }


     public  T GetItem(string key)
     {
         if (HttpRuntime.Cache != null)
         {
             object check = HttpRuntime.Cache[key];

             if (check != null)
             {
                 return (T)check;
             }
         }

         return default(T);
     }

     private bool IsNull(T item)
     {
         if (typeof(T).IsValueType)
         {
             return default(T).Equals(item);
         }
         else
         {
             return item == null;
         }

     }


     public  T GetItem(string key, Func<T> itemSourceOnDoesNotExist)
     {
         T check = GetItem(key);

         if (IsNull(check))
         {
             check = itemSourceOnDoesNotExist();
         }

         return check;
     }

     public  T GetItem(string key, Func<T> itemSourceOnDoesNotExist, Proc<T> addToCache)
     {
         T check = GetItem(key);

         if (IsNull(check))
         {
             check = itemSourceOnDoesNotExist();
             addToCache(check);
         }
         return check;
     }
     
 }

The methods prior to Commit() make up the fluent interface, and I stole a little code from Ayende's Rhino Commons for the delegates in the GetItem methods. As a side note, the GetItems methods were originally static, which allowed me to do the following:

private string ItemToCache()
{
    return "expected value";
}


[Test]
public void FluentSyntaxText()
{
    HTTPCacheHelper<string> cache = new HTTPCacheHelper<string>();

    cache
        .WithExpirationDateOf(DateTime.Now.AddDays(1))
        .WithKeyOf("TestKey")
        .WithPriorityOf(CacheItemPriority.Low)
        .Commit(ItemToCache());

    string actualValue = HTTPCacheHelper<string>.GetItem("TestKey", ItemToCache, cache.Commit);

    Assert.AreEqual("expected value", actualValue);

}

But it dawned on me a little later that by making them instance methods I could accomplish the same thing in a single statement

[Test] 
public void FluentSyntaxTest2()
{
    HTTPCacheHelper<string> cache = new HTTPCacheHelper<string>();

    string actualValue = cache
        .WithExpirationDateOf(DateTime.Now.AddDays(1))
        .WithKeyOf("TestKey")
        .WithPriorityOf(CacheItemPriority.Low)
        .GetItem("TestKey", ItemToCache, cache.Commit);

    Assert.AreEqual("expected value", actualValue);

}

Which is pretty friggin' sweet.