public static ComponentRegistration<S> RegisterTransient<S>(this IWindsorContainer container, ComponentRegistration<S> registration)

{

  container.Register(registration.LifeStyle.Transient);

  return registration;

}

var serviceA = container.RegisterTransient(Component.For<IStaffRepository>()

  .ImplementedBy<StaffRepositoryA>());

var serviceB = container.RegisterTransient(Component.For<IStaffRepository>()

  .ImplementedBy<StaffRepositoryB>());

container.Register(Component.For<IStaffService>().Named("service.staff").ImplementedBy<StaffService>()

  .ServiceOverrides(ServiceOverride.ForKey("Repositories").Eq(serviceB.Name, serviceA.Name)));

var staffService = (StaffService)container.Resolve<IStaffService>();

Assert.IsType<StaffRepositoryB>(staffService.Repositories[0]);

Assert.IsType<StaffRepositoryA>(staffService.Repositories[1]);

<configuration>

    <components>

        <component id="smtp.sender"

            service="Namespace.IEmailSender, AssemblyName"

            type="Namespace.SmtpMailSender, AssemblyName" />

        <component id="sendmail.sender"

            service="Namespace.IEmailSender, AssemblyName"

            type="Namespace.SendMailEmailSender, AssemblyName" />

        <component id="newsletter"

            type="Namespace.NewsLetterSenderService, AssemblyName">

            <parameters>

                <sender>${smtp.sender}</sender>

            </parameters>

        </components>

    </components>

</configuration>

public interface IStaffService

{

}

public class StaffService : IStaffService

{

  public IStaffRepository Repository { get; set; }

}

public interface IStaffRepository

{

}

public class StaffRepositoryA : IStaffRepository

{

}

public class StaffRepositoryB : IStaffRepository

{

}

public class ServiceOverrideTests

{

  private WindsorContainer container;

  public ServiceOverrideTests()

  {

    container = new WindsorContainer();     

    container.Register(Component.For<IStaffRepository>().Named("repository.staff.a").ImplementedBy<StaffRepositoryA>().LifeStyle.Transient);

    container.Register(Component.For<IStaffRepository>().Named("repository.staff.b").ImplementedBy<StaffRepositoryB>().LifeStyle.Transient);

  }

  [Fact]

  public void ByDefaultStaffServiceWiredUpToFirstServiceRegistered()

  {

    container.Register(Component.For<IStaffService>().Named("service.staff").ImplementedBy<StaffService>().LifeStyle.Transient);

    var staffService = (StaffService)container.Resolve<IStaffService>();

    Assert.IsType<StaffRepositoryA>(staffService.Repository);     

  }   

  [Fact]

  public void WithServiceOverrideCanPickImplmentationByKey()

  {

    container.Register(Component.For<IStaffService>().Named("service.staff").ImplementedBy<StaffService>()

                        .ServiceOverrides(ServiceOverride.ForKey("Repository").Eq("repository.staff.b")).LifeStyle.Transient);

    var staffService = (StaffService)container.Resolve<IStaffService>();

    Assert.IsType<StaffRepositoryB>(staffService.Repository); 

  }

}

public class StaffService : IStaffService

{

  public IStaffRepository[] Repositories { get; set; } // <- is now an array of staff repository...

}

[Fact]

public void WithServiceOverrideCanPickImplmentationByKey()

{

  container.Register(Component.For<IStaffService>().Named("service.staff").ImplementedBy<StaffService>()

                      .ServiceOverrides(ServiceOverride.ForKey("Repositories").Eq("repository.staff.b", "repository.staff.a")).LifeStyle.Transient);

  var staffService = (StaffService)container.Resolve<IStaffService>();

  Assert.IsType<StaffRepositoryB>(staffService.Repositories[0]);

  Assert.IsType<StaffRepositoryA>(staffService.Repositories[1]);

}

public interface IRepository<T>

    where T : class, new()

{

    T Get(int id);

}

public class StubRepository<T> : IRepository<T>

    where T : class, new()

{

    public T Get(int id)

    {

        return new T();

    }

}

public class SecurityDecorator<T> : IRepository<T>

    where T : class, new()

{

    private readonly IRepository<T> _inner;

    public SecurityDecorator(IRepository<T> inner)

    {

        _inner = inner;

    }

    public T Get(int id)

    {

        return _inner.Get(id);

    }

}

public class Widget

{

}

public class ContainerTests

{

    private readonly IWindsorContainer container;

    public ContainerTests()

    {

        container = new WindsorContainer();

        container.Register(Component.For(typeof (IRepository<>)).ImplementedBy(typeof (SecurityDecorator<>)));

        container.Register(Component.For(typeof (IRepository<>)).ImplementedBy(typeof (StubRepository<>)));

    }

    [Fact]

    public void GetRepository_ForWidget_ReturnsSecurityDecoratorOfTypeWidget()

    {

        var widgetRepository = container.Resolve<IRepository<Widget>>();

        Assert.True(widgetRepository is SecurityDecorator<Widget>);

    }

}

public interface IUser

{

}

public class SecurityDecorator<T> : IRepository<T>

    where T : class, new()

{

    private readonly IRepository<T> _inner;

    public SecurityDecorator(IRepository<T> inner)

    {

        _inner = inner;

    }

    public T Get(int id)

    {

        return _inner.Get(id);

    }

    public IUser User { get; set; } // <-- the current user

}

public class ContainerTests

{

    private readonly IWindsorContainer container;

    private readonly IUser user = MockRepository.GenerateStub<IUser>();

    public ContainerTests()

    {

        container = new WindsorContainer();

        container.Register(Component.For(typeof (IRepository<>)).ImplementedBy(typeof (SecurityDecorator<>)));

        container.Register(Component.For(typeof (IRepository<>)).ImplementedBy(typeof (StubRepository<>)));           

    }

    [Fact]

    public void GetRepository_ForWidget_ReturnsSecurityDecoratorOfTypeWidget()

    {

        var widgetRepository = container.Resolve<IRepository<Widget>>();

        Assert.True(widgetRepository is SecurityDecorator<Widget>);

    }

    [Fact]

    public void GetRepository_ForWidget_WhenSupplyingUserInjectsUserIntoSecurityRepository()

    {

        var securityDecoratorForWidget = (SecurityDecorator<Widget>) container.Resolve<IRepository<Widget>>(new {User = user});

        Assert.Same(user, securityDecoratorForWidget.User);

    }

}

public interface IRole

{

    bool IsMember(IUser user);

}

    public class SecurityDecorator<T> : IRepository<T>

        where T : class, new()

    {

        private readonly IRepository<T> _inner;

        public SecurityDecorator(IRepository<T> inner)

        {

            _inner = inner;

        }

        public T Get(int id)

        {

            CheckPermission();

            return _inner.Get(id);

        }

        public IUser User { get; set; }

        public IList<IRole> Roles { get; set; } // <-- the roles to check

        private void CheckPermission()

        {

            if (User == null || Roles == null) return;

            if (Roles.Any(role => !role.IsMember(User)))

            {

                throw new Exception("You do not have permission");

            }

        }

    }

public class ContainerTests

{

    private readonly IWindsorContainer container;

    private readonly IUser user = MockRepository.GenerateStub<IUser>();

    private readonly IRole failingRole = MockRepository.GenerateStub<IRole>();

    private readonly IRole passingRole = MockRepository.GenerateStub<IRole>();

    public ContainerTests()

    {

        container = new WindsorContainer();

        container.Register(Component.For(typeof (IRepository<>)).ImplementedBy(typeof (SecurityDecorator<>)));

        container.Register(Component.For(typeof (IRepository<>)).ImplementedBy(typeof (StubRepository<>)));

        passingRole.Stub(stub => stub.IsMember(user)).Return(true);

    }

    [Fact]

    public void GetRepository_ForWidget_ReturnsSecurityDecoratorOfTypeWidget()

    {

        var widgetRepository = container.Resolve<IRepository<Widget>>();

        Assert.True(widgetRepository is SecurityDecorator<Widget>);

    }

    [Fact]

    public void GetRepository_ForWidget_WhenSupplyingUserInjectsUserIntoSecurityRepository()

    {

        var securityDecoratorForWidget = (SecurityDecorator<Widget>) container.Resolve<IRepository<Widget>>(new {User = user});

        Assert.Same(user, securityDecoratorForWidget.User);

    }

    [Fact]

    public void Get_ForWidgetWhenUserMatchesAllRoles_ReturnsWidget()

    {

        var securityDecoratorForWidget =

            (SecurityDecorator<Widget>) container.Resolve<IRepository<Widget>>(new {User = user, Roles = new List<IRole> {passingRole}});

         Assert.NotNull(securityDecoratorForWidget.Get(1));

    }

    [Fact]

    public void Get_ForWidgetWhenUserDoesNotMatchAllRoles_ThrowsException()

    {

        var securityDecoratorForWidget =

            (SecurityDecorator<Widget>) container.Resolve<IRepository<Widget>>(new {User = user, Roles = new List<IRole> {passingRole, failingRole}});

         var exception = Assert.Throws<Exception>(() => securityDecoratorForWidget.Get(1));

        Assert.Equal("You do not have permission", exception.Message);

    }

}

<runtime>

    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">

        <publisherPolicy apply="no"/>

        <dependentAssembly>

            <assemblyIdentity name="NHibernate" publicKeyToken="aa95f207798dfdb4" culture="neutral" />

            <bindingRedirect oldVersion="1.2.0.4000" newVersion="2.0.0.1001"/>

        </dependentAssembly>

    </assemblyBinding>

</runtime>

/// <summary>

/// Interface for components that wish to be started by the container

/// </summary>

public interface IStartable

{

    /// <summary>

    /// Starts this instance.

    /// </summary>

    void Start();

    /// <summary>

    /// Stops this instance.

    /// </summary>

    void Stop();

}

public class LameHttpFileServer : IStartable

{

    private string _path;

    private HttpListener _listener;

    private Thread _listenerThread;

    private ILogger _logger;

    public LameHttpFileServer(string prefix, string path)

    {

        _path = path;

        _listener = new HttpListener();

        _listener.Prefixes.Add(prefix);

    }

    public ILogger Logger

    {

        get

        {

            if (_logger == null) _logger = NullLogger.Instance;

            return _logger;

        }

        set { _logger = value; }

    }

    public void Start()

    {

        Logger.Debug("Starting LameWebService...");

        _listener.Start();

        _listenerThread = new Thread(RequestWorker);

        _listenerThread.Start();

        Logger.Info("LameWebService Started.");

    }

    public void Stop()

    {

        Logger.Debug("Stopping LameWebService...");

        _listenerThread.Abort();

        _listener.Stop();

        Logger.Info("Stopped LameWebService.");

    }

    private void RequestWorker()

    {

        while (true)

        {

            HttpListenerContext context = null;

            try

            {

                context = _listener.GetContext();

            }

            catch (ObjectDisposedException)

            {

                return;

            }

            ServeContent(context.Response, _path);

        }

    }

    private void ServeContent(HttpListenerResponse response, string path)

    {

        string content = File.ReadAllText(path);

        byte[] buffer = Encoding.UTF8.GetBytes(content);

        response.ContentLength64 = buffer.Length;

        Stream output = response.OutputStream;

        output.Write(buffer, 0, buffer.Length);

        output.Close();

    }

}

<configuration>

  <configSections>

    <section name="castle"

        type="Castle.Windsor.Configuration.AppDomain.CastleSectionHandler, Castle.Windsor" />

  </configSections>

  <castle>

    <facilities>

      <facility id="startable.facility"

        type="Castle.Facilities.Startable.StartableFacility, Castle.MicroKernel" />

      <facility id="logging.facility"

        type="Castle.Facilities.Logging.LoggingFacility, Castle.Facilities.Logging"

        loggingApi="console" />                         

  </facilities>

    <components>

      <component id="serves->lame.html"

                type="IoC.Tutorials.Part14.LameHttpFileServer, IoC.Tutorials.Part14">

        <parameters>

          <prefix>http://*:8089/</prefix>

          <path>lame.html</path>

        </parameters>

      </component>

    </components>

  </castle>

</configuration>

<html>

    <body>

        <h1>Lame.html</h1>

        <h2>Welcome to lame.html file</h2>

        <p>This is the contents of the lame.html file, neat huh?</p>

    </body>

</html>

private static void Main(string[] args)

{

    WindsorContainer container = new WindsorContainer(new XmlInterpreter());

    GetPage();

    container.Dispose();

    GetPage();

    Console.Read();

}

private static void GetPage()

{           

    Console.WriteLine("\r\nClient: requesting http://localhost:8089/ ...");

    try

    {

        WebClient client = new WebClient();

        string content = client.DownloadString("http://localhost:8089/");

        Console.WriteLine("Client: success, content follows.\r\n\r\n {0}", content);

    }

    catch (WebException ex)

    {

        Console.WriteLine("Client: Exception occured, message: {0}", ex.Message);

    }

}

LameHttpFileServer server = container.Resolve<LameHttpFileServer>();

container.Release(server);

[Transient]

public class StartableExperiment : IStartable

{

    private static int _count;

    private int _number;

    public StartableExperiment()

    {

        _number = ++_count;

    }

    public void Start()

    {

        Console.WriteLine("Started #{0}", _number);

    }

    public void Stop()

    {

        Console.WriteLine("Stopped #{0}", _number);

    }

}

WindsorContainer container = new WindsorContainer(new XmlInterpreter());

container.AddComponent("exp", typeof(StartableExperiment));

StartableExperiment exp1 = container.Resolve<StartableExperiment>();

container.Release(exp1);

StartableExperiment exp2 = container.Resolve<StartableExperiment>();

container.Release(exp2);

container.Dispose();

public abstract class AbstractCalculator

{

    public abstract decimal Calculate(decimal currentTotal, Order order);

}

public class TotalCalculator : AbstractCalculator

{

    private decimal CalculateTotal(Order order)

    {

        decimal total = 0;

        foreach (OrderItem item in order.Items)

        {

            total += (item.Quantity*item.CostPerItem);

        }

        return total;

    }

    public override decimal Calculate(decimal currentTotal, Order order)

    {

        return currentTotal + CalculateTotal(order);

    }

}

public class GstCalculator : AbstractCalculator

{

    private decimal _gstRate = 1.125m;

    public decimal GstRate

    {

        get { return _gstRate; }

        set { _gstRate = value; }

    }

    private bool IsNewZealand(Order order)

    {

        return (order.CountryCode == "NZ");

    }

    public override decimal Calculate(decimal currentTotal, Order order)

    {

        if (IsNewZealand(order))

        {

            return (currentTotal*_gstRate);

        }

        return currentTotal;

    }

}

public class ShippingCalculator : AbstractCalculator

{

    private decimal _shippingCost = 5.0m;

    private decimal _fragileShippingPremium = 1.5m;

    public decimal ShippingCost

    {

        get { return _shippingCost; }

        set { _shippingCost = value; }

    }

    public decimal FragileShippingPremium

    {

        get { return _fragileShippingPremium; }

        set { _fragileShippingPremium = value; }

    }

    private decimal GetShippingTotal(Order order)

    {

        decimal shippingTotal = 0;

        foreach (OrderItem item in order.Items)

        {

            decimal itemShippingCost = ShippingCost*item.Quantity;

            if (item.IsFragile) itemShippingCost *= FragileShippingPremium;

            shippingTotal += itemShippingCost;

        }

        return shippingTotal;

    }

    public override decimal Calculate(decimal currentTotal, Order order)

    {

        return currentTotal + GetShippingTotal(order);

    }

}

public class DefaultCostCalculator : ICostCalculator

{

    private AbstractCalculator[] _calculators;

    public DefaultCostCalculator(AbstractCalculator[] calculators)

    {

        _calculators = calculators;

    }

    public decimal CalculateTotal(Order order)

    {

        decimal currentTotal = 0;

        foreach (AbstractCalculator calculator in _calculators)

        {

            currentTotal = calculator.Calculate(currentTotal, order);

        }

        return currentTotal;

    }

}

<configuration>

  <configSections>

    <section name="castle"

        type="Castle.Windsor.Configuration.AppDomain.CastleSectionHandler, Castle.Windsor" />

  </configSections>

  <castle>

    <components>

      <component id="calc.gst"

                service="IoC.Tutorials.Part13.AbstractCalculator, IoC.Tutorials.Part13"

                type="IoC.Tutorials.Part13.GstCalculator, IoC.Tutorials.Part13">

        <parameters>

          <GstRate>1.20</GstRate>

          <!-- GST is now 20% -->

        </parameters>

      </component>

      <component id="calc.shipping"

          service="IoC.Tutorials.Part13.AbstractCalculator, IoC.Tutorials.Part13"

          type="IoC.Tutorials.Part13.ShippingCalculator, IoC.Tutorials.Part13">

        <parameters>

          <FragileShippingPremium>0.0</FragileShippingPremium>

          <!-- No fragile goods premium any more-->

        </parameters>

      </component>

      <component id="calc.total"

        service="IoC.Tutorials.Part13.AbstractCalculator, IoC.Tutorials.Part13"

          type="IoC.Tutorials.Part13.TotalCalculator, IoC.Tutorials.Part13" />

      <component id="costCalculator.default"

                service="IoC.Tutorials.Part13.ICostCalculator, IoC.Tutorials.Part13"

                type="IoC.Tutorials.Part13.DefaultCostCalculator, IoC.Tutorials.Part13">

        <parameters>

          <calculators>

            <array>

              <value>${calc.total}</value>

              <value>${calc.shipping}</value>

              <value>${calc.gst}</value>

            </array>

          </calculators>

        </parameters>

      </component>

    </components>

  </castle>

</configuration>

private static void Main(string[] args)

{

    WindsorContainer container = new WindsorContainer(new XmlInterpreter());

    Order order1 = new Order();

    order1.CountryCode = "NZ";

    order1.Items.Add(new OrderItem("water", 10, 1.0m, false));

    order1.Items.Add(new OrderItem("glass", 5, 20.0m, true));

    Order order2 = new Order();

    order2.CountryCode = "US";

    order2.Items.Add(new OrderItem("sand", 50, 0.2m, false));

    ICostCalculator costCalculator = container.Resolve<ICostCalculator>();

    Console.WriteLine("Cost to deliver Order 1: {0}", costCalculator.CalculateTotal(order1));

    Console.WriteLine("Cost to deliver Order 2: {0}", costCalculator.CalculateTotal(order2));

    Console.Read();

}

public class Order

{

    private string _countryCode;

    private readonly List<OrderItem> _items = new List<OrderItem>();

    public List<OrderItem> Items

    {

        get { return _items; }

    }

    public string CountryCode

    {

        get { return _countryCode; }

        set { _countryCode = value; }

    }

}

public class OrderItem

{

    private string _name;

    private bool _isFragile;

    private int _quantity;

    private decimal _costPerItem;

    public OrderItem(string name, int quantity, decimal costPerItem, bool isFragile)

    {

        _name = name;

        _quantity = quantity;

        _costPerItem = costPerItem;

        _isFragile = isFragile;

    }

    public bool IsFragile

    {

        get { return _isFragile; }

        set { _isFragile = value; }

    }

    public int Quantity

    {

        get { return _quantity; }

        set { _quantity = value; }

    }

    public decimal CostPerItem

    {

        get { return _costPerItem; }

        set { _costPerItem = value; }

    }

    public string Name

    {

        get { return _name; }

        set { _name = value; }

    }

}

public interface ICostCalculator

{

    decimal CalculateTotal(Order order);

}

public class DefaultCostCalculator : ICostCalculator

{

    public decimal CalculateTotal(Order order)

    {

        decimal total = 0;

        foreach (OrderItem item in order.Items)

        {

            total += (item.Quantity*item.CostPerItem);

        }

        return total;

    }

}

internal class Program

{

    private static void Main(string[] args)

    {

        WindsorContainer container = new WindsorContainer(new XmlInterpreter());

        Order order1 = new Order();

        order1.CountryCode = "NZ";

        order1.Items.Add(new OrderItem("water", 10, 1.0m, false));

        order1.Items.Add(new OrderItem("glass", 5, 20.0m, true));

        Order order2 = new Order();

        order2.CountryCode = "US";

        order2.Items.Add(new OrderItem("sand", 50, 0.2m, false));

        ICostCalculator costCalculator = container.Resolve<ICostCalculator>();

        Console.WriteLine("Cost to deliver Order 1: {0}", costCalculator.CalculateTotal(order1));

        Console.WriteLine("Cost to deliver Order 2: {0}", costCalculator.CalculateTotal(order2));

        Console.Read();

    }

}

<component id="costCalculator.default"

          service="IoC.Tutorials.Part12.ICostCalculator, IoC.Tutorials.Part12"

          type="IoC.Tutorials.Part12.DefaultCostCalculator, IoC.Tutorials.Part12" />

public class GstCostCalcualtorDecoarator : ICostCalculator

{

    private readonly ICostCalculator _innerCalculator;

    private decimal _gstRate = 1.125m;

    public GstCostCalcualtorDecoarator(ICostCalculator innerCalculator)

    {

        _innerCalculator = innerCalculator;

    }

    public decimal GstRate

    {

        get { return _gstRate; }

        set { _gstRate = value; }

    }

    private bool IsNewZealand(Order order)

    {

        return (order.CountryCode == "NZ");

    }

    public decimal CalculateTotal(Order order)

    {

        decimal innerTotal = _innerCalculator.CalculateTotal(order);

        if (IsNewZealand(order))

        {

            innerTotal = (innerTotal*_gstRate);

        }

        return innerTotal;

    }

}

<configuration>

  <configSections>

    <section name="castle"

        type="Castle.Windsor.Configuration.AppDomain.CastleSectionHandler, Castle.Windsor" />

  </configSections>

  <castle>

    <components>

      <component id="costCalculator.gstDecorator"

                service="IoC.Tutorials.Part12.ICostCalculator, IoC.Tutorials.Part12"

                type="IoC.Tutorials.Part12.GstCostCalcualtorDecoarator, IoC.Tutorials.Part12">

        <parameters>

          <innerCalculator>${costCalculator.default}</innerCalculator>

        </parameters>

      </component>

      <component id="costCalculator.default"

                service="IoC.Tutorials.Part12.ICostCalculator, IoC.Tutorials.Part12"

                type="IoC.Tutorials.Part12.DefaultCostCalculator, IoC.Tutorials.Part12" />

    </components>

  </castle>

</configuration>

public class ShippingCostCalculatorDecorator : ICostCalculator

{

    private readonly ICostCalculator _innerCalculator;

    private decimal _shippingCost = 5.0m;

    private decimal _fragileShippingPremium = 1.5m;

    public ShippingCostCalculatorDecorator(ICostCalculator innerCalculator)

    {

        _innerCalculator = innerCalculator;

    }

    public decimal ShippingCost

    {

        get { return _shippingCost; }

        set { _shippingCost = value; }

    }

    public decimal FragileShippingPremium

    {

        get { return _fragileShippingPremium; }

        set { _fragileShippingPremium = value; }

    }

    public decimal CalculateTotal(Order order)

    {

        decimal innerTotal = _innerCalculator.CalculateTotal(order);

        return innerTotal + GetShippingTotal(order);

    }

    private decimal GetShippingTotal(Order order)

    {

        decimal shippingTotal = 0;

        foreach (OrderItem item in order.Items)

        {

            decimal itemShippingCost = ShippingCost*item.Quantity;

            if (item.IsFragile) itemShippingCost *= FragileShippingPremium;

            shippingTotal += itemShippingCost;

        }

        return shippingTotal;

    }

}

<configuration>

  <configSections>

    <section name="castle"

        type="Castle.Windsor.Configuration.AppDomain.CastleSectionHandler, Castle.Windsor" />

  </configSections>

  <castle>

    <components>

      <component id="costCalculator.shippingDecorator"

          service="IoC.Tutorials.Part12.ICostCalculator, IoC.Tutorials.Part12"

          type="IoC.Tutorials.Part12.ShippingCostCalculatorDecorator, IoC.Tutorials.Part12">

        <parameters>

          <innerCalculator>${costCalculator.gstDecorator}</innerCalculator>

        </parameters>

      </component>

      <component id="costCalculator.gstDecorator"

                service="IoC.Tutorials.Part12.ICostCalculator, IoC.Tutorials.Part12"

                type="IoC.Tutorials.Part12.GstCostCalcualtorDecoarator, IoC.Tutorials.Part12">

        <parameters>

          <innerCalculator>${costCalculator.default}</innerCalculator>

        </parameters>

      </component>

      <component id="costCalculator.default"

                service="IoC.Tutorials.Part12.ICostCalculator, IoC.Tutorials.Part12"

                type="IoC.Tutorials.Part12.DefaultCostCalculator, IoC.Tutorials.Part12" />

    </components>

  </castle>

</configuration>

<components>

  <component id="costCalculator.gstDecorator"

            service="IoC.Tutorials.Part12.ICostCalculator, IoC.Tutorials.Part12"

            type="IoC.Tutorials.Part12.GstCostCalcualtorDecoarator, IoC.Tutorials.Part12">

    <parameters>

      <innerCalculator>${costCalculator.shippingDecorator}</innerCalculator>

      <GstRate>1.20</GstRate> <!-- GST is now 20% -->

    </parameters>

  </component>

  <component id="costCalculator.shippingDecorator"

      service="IoC.Tutorials.Part12.ICostCalculator, IoC.Tutorials.Part12"

      type="IoC.Tutorials.Part12.ShippingCostCalculatorDecorator, IoC.Tutorials.Part12">

    <parameters>

      <innerCalculator>${costCalculator.default}</innerCalculator>         

      <FragileShippingPremium>0.0</FragileShippingPremium> <!-- No fragile goods premium any more-->

    </parameters>

  </component>

  <component id="costCalculator.default"

            service="IoC.Tutorials.Part12.ICostCalculator, IoC.Tutorials.Part12"

            type="IoC.Tutorials.Part12.DefaultCostCalculator, IoC.Tutorials.Part12" />

</components>

public class SmsService : ISmsService

{

    private SmsConfig _config;

    public void SetConfig(SmsConfig config)

    {

        _config = config;

    }

    public void SendMessage(string number, string message)

    {

        Console.WriteLine("SMS message: {0} sent to: {1} with account: {2}", message, number, _config.UserName);

    }

    public class SmsConfig

    {

        private string _userName;

        private string _password;

        private int _retryAttempts;

        internal string UserName

        {

            get { return _userName; }

        }

        internal string Password

        {

            get { return _password; }

        }

        public int RetryAttempts

        {

            get { return _retryAttempts; }

            set { _retryAttempts = value; }

        }

        public void SetCredentials(string userName, string password)

        {

            _userName = userName;

            _password = password;

        }

    }

}

public interface ISmsService

{

    void SendMessage(string number, string message);

}

SmsService service = new SmsService();

SmsService.SmsConfig config = new SmsService.SmsConfig();

config.SetCredentials("joe", "secret");

config.RetryAttempts = 3;

service.SetConfig(config);

public class SmsServiceFactory

{

    public ISmsService CreateService()

    {

        SmsService service = new SmsService();

        SmsService.SmsConfig config = new SmsService.SmsConfig();

        config.SetCredentials("joe", "secret");

        config.RetryAttempts = 3;

        service.SetConfig(config);

        return service;

    }

}

public class SmsServiceFactory

{

    private string _userName;

    private string _password;

    private int _retryAttempts = 3;

    public SmsServiceFactory(string userName, string password)

    {

        _userName = userName;

        _password = password;

    }

    public int RetryAttempts

    {

        get { return _retryAttempts; }

        set { _retryAttempts = value; }

    }

    public ISmsService CreateService()

    {

        SmsService service = new SmsService();

        SmsService.SmsConfig config = new SmsService.SmsConfig();

        config.SetCredentials(_userName, _password);

        config.RetryAttempts = _retryAttempts;

        service.SetConfig(config);

        return service;

    }

}

<configuration>

  <configSections>

    <section name="castle"

        type="Castle.Windsor.Configuration.AppDomain.CastleSectionHandler, Castle.Windsor" />

  </configSections>

  <castle>

    <facilities>

      <facility

        id="factorysupport"

        type="Castle.Facilities.FactorySupport.FactorySupportFacility, Castle.MicroKernel" />

    </facilities>

<configuration>

  <configSections>

    <section name="castle"

        type="Castle.Windsor.Configuration.AppDomain.CastleSectionHandler, Castle.Windsor" />

  </configSections>

  <castle>

    <facilities>

      <facility

        id="factorysupport"

        type="Castle.Facilities.FactorySupport.FactorySupportFacility, Castle.MicroKernel" />

    </facilities>

    <components>

      <component id="smsService.Factory"

                type="IoC.Tutorials.Part11.SmsServiceFactory, IoC.Tutorials.Part11">

        <parameters>

          <userName>joe</userName>

          <password>secret</password>         

        </parameters>

      </component>

      <component id="smsService.default"

                type="IoC.Tutorials.Part11.ISmsService, IoC.Tutorials.Part11"

                factoryId="smsService.Factory"

                factoryCreate="CreateService" />

    </components>

  </castle>

</configuration>

static void Main(string[] args)

{

    WindsorContainer container = new WindsorContainer(new XmlInterpreter());

    ISmsService smsService = container.Resolve<ISmsService>();

    smsService.SendMessage("+465556555", "testing testing...1.2.3");

    Console.Read();

}

public interface IMessageFormatter

{

    string FormatMessage(string from, string to, string body);

}

public void SendMessage(string to, string body)

{

    Console.WriteLine("to: {0}\r\nfrom: {1}\r\n\r\n{2}", to, _from, _encoder.Encode(body));

}

public class DefaultFormatter : IMessageFormatter

{

    public string FormatMessage(string from, string to, string body)

    {

        return string.Format("to: {0}\r\nfrom: {1}\r\n\r\n{2}", to, from, body);

    }

}

public class SecretMessageSender

{

    private readonly IEncoder _encoder;

    private readonly string _from;

    private IMessageFormatter _formatter = new DefaultFormatter();

    public SecretMessageSender(string from, IEncoder encoder)

    {

        _from = from;

        _encoder = encoder;

    }

    public IMessageFormatter Formatter

    {

        get { return _formatter; }

        set { _formatter = value; }

    }

    public void SendMessage(string to, string body)

    {

        string encodedBody = _encoder.Encode(body);

        Console.WriteLine(_formatter.FormatMessage(_from, to, encodedBody));

    }

}

public class NVelocityMessageFormatter : IMessageFormatter

{

    private readonly VelocityEngine _velocity;

    private readonly Template _template;

    public NVelocityMessageFormatter(string templateFile)

    {

        _velocity = new VelocityEngine();

        ExtendedProperties props = new ExtendedProperties();

        _velocity.Init(props);

        _template = _velocity.GetTemplate(templateFile);

    }

    public string FormatMessage(string from, string to, string body)

    {

        VelocityContext context = new VelocityContext();

        context.Put("from", from);

        context.Put("to", to);

        context.Put("body", body);

        context.Put("today", DateTime.Now);

        StringWriter writer = new StringWriter();

        _template.Merge(context, writer);

        return writer.ToString();

    }

}

 To:   $to

 From: $from

 Sent: $today

 ----------------------

 $body

 ----------------------

<configuration>

  <configSections>

    <section name="castle"

        type="Castle.Windsor.Configuration.AppDomain.CastleSectionHandler, Castle.Windsor" />

  </configSections>

  <castle>

    <components>

      <component id="encoder.silly"

                service="IoC.Tutorials.Part10.IEncoder, IoC.Tutorials.Part10"

                type="IoC.Tutorials.Part10.SillyEncoder, IoC.Tutorials.Part10" />

      <component id="encoder.null"

                service="IoC.Tutorials.Part10.IEncoder, IoC.Tutorials.Part10"

                type="IoC.Tutorials.Part10.NullEncoder, IoC.Tutorials.Part10" />

      <component id="messageSender"

                type="IoC.Tutorials.Part10.SecretMessageSender, IoC.Tutorials.Part10">

        <parameters>SecretMessageSender

          <from>alex@bittercoder.com</from>

          <encoder>${encoder.null}</encoder>         

        </parameters>

      </component>

      <component id="fancyMessageFormatter"

                service="IoC.Tutorials.Part10.IMessageFormatter, IoC.Tutorials.Part10"

                type="IoC.Tutorials.Part10.NVelocityMessageFormatter, IoC.Tutorials.Part10">

        <parameters>

          <templateFile>message.vm</templateFile>

        </parameters>

      </component>

    </components>

  </castle>

</configuration>

<component id="messageSender"

          type="IoC.Tutorials.Part10.SecretMessageSender, IoC.Tutorials.Part10">

  <parameters>SecretMessageSender

    <from>alex@bittercoder.com</from>

    <encoder>${encoder.null}</encoder>

    <Formatter>${fancyMessageFormatter}</Formatter>

  </parameters>

</component>

<component id="defualtMessageFormatter"

    service="IoC.Tutorials.Part10.IMessageFormatter, IoC.Tutorials.Part10"

    type="IoC.Tutorials.Part10.DefaultFormatter, IoC.Tutorials.Part10" />       

<component id="fancyMessageFormatter"

          service="IoC.Tutorials.Part10.IMessageFormatter, IoC.Tutorials.Part10"

          type="IoC.Tutorials.Part10.NVelocityMessageFormatter, IoC.Tutorials.Part10">

  <parameters>

    <templateFile>message.vm</templateFile>

  </parameters>

</component>

public interface IEncoder

{

    string Encode(string source);

}

public class NullEncoder : IEncoder

{

    public string Encode(string source)

    {

        return source;

    }

}

public class SillyEncoder : IEncoder

{

    private char[] _mixedUp = "YACBDFEGIHJLKMONPRSQTUWVXZ".ToCharArray();

    public string Encode(string source)

    {

        string upperSource = source.ToUpper();

        char[] encoded = new char[source.Length];

        for (int i = 0; i < encoded.Length; i++)

        {

            encoded[i] = MapCharacter(upperSource[i]);

        }

        return new string(encoded);

    }

    private char MapCharacter(char ch)

    {

        if ((ch >= 'A') && (ch <= 'Z'))

        {

            return _mixedUp[ch - 'A'];

        }

        return ch;

    }

}

public class SecretMessageSender

{

    private readonly IEncoder _encoder;

    private readonly string _from;

    public SecretMessageSender(string from, IEncoder encoder)

    {

        _from = from;

        _encoder = encoder;

    }

    public void SendMessage(string to, string body)

    {

        Console.WriteLine("to: {0}\r\nfrom: {1}\r\n\r\n{2}", to, _from, _encoder.Encode(body));

    }

}

static void Main(string[] args)

{

    WindsorContainer container = new WindsorContainer(new XmlInterpreter());

    SecretMessageSender sender = container.Resolve<SecretMessageSender>();

    sender.SendMessage("hammet", "castle is great!");

    Console.Read();

}

<configuration>

  <configSections>

    <section name="castle"

        type="Castle.Windsor.Configuration.AppDomain.CastleSectionHandler, Castle.Windsor" />

  </configSections>

  <castle>

    <components>

      <component id="encoder.silly"

                service="IoC.Tutorials.Part9.IEncoder, IoC.Tutorials.Part9"

                type="IoC.Tutorials.Part9.SillyEncoder, IoC.Tutorials.Part9" />

      <component id="encoder.null"

                service="IoC.Tutorials.Part9.IEncoder, IoC.Tutorials.Part9"

                type="IoC.Tutorials.Part9.NullEncoder, IoC.Tutorials.Part9" />

      <component id="messageSender"

                type="IoC.Tutorials.Part9.SecretMessageSender, IoC.Tutorials.Part9">

        <parameters>SecretMessageSender

          <from>alex@bittercoder.com</from>

        </parameters>

      </component>

    </components>

  </castle>

</configuration>

<configuration>

  <configSections>

    <section name="castle"

        type="Castle.Windsor.Configuration.AppDomain.CastleSectionHandler, Castle.Windsor" />

  </configSections>

  <castle>

    <components>

      <component id="encoder.silly"

                service="IoC.Tutorials.Part9.IEncoder, IoC.Tutorials.Part9"

                type="IoC.Tutorials.Part9.SillyEncoder, IoC.Tutorials.Part9" />

      <component id="encoder.null"

                service="IoC.Tutorials.Part9.IEncoder, IoC.Tutorials.Part9"

                type="IoC.Tutorials.Part9.NullEncoder, IoC.Tutorials.Part9" />

      <component id="messageSender"

                type="IoC.Tutorials.Part9.SecretMessageSender, IoC.Tutorials.Part9">

        <parameters>SecretMessageSender

          <from>alex@bittercoder.com</from>

          <encoder>${encoder.null}</encoder>

        </parameters>

      </component>

    </components>

  </castle>

</configuration>

public class FileReader

{

    private string _fileName;

    public string FileName

    {

        get { return _fileName; }

        set { _fileName = value; }

    }

    public string ReadToEnd()

    {

        return File.ReadAllText(_fileName);

    }

}

<configuration>

  <configSections>

    <section name="castle"

        type="Castle.Windsor.Configuration.AppDomain.CastleSectionHandler, Castle.Windsor" />

  </configSections>

  <castle>

    <components>

      <component id="reader.file1" type="IoC.Tutorials.Part8.FileReader, IoC.Tutorials.Part8">

        <parameters>

          <FileName>file1.txt</FileName>

        </parameters>

      </component>

      <component id="reader.file2" type="IoC.Tutorials.Part8.FileReader, IoC.Tutorials.Part8">

        <parameters>

          <FileName>file2.txt</FileName>

        </parameters>

      </component>

    </components>     

  </castle>

</configuration>

static void Main(string[] args)

{

    WindsorContainer container = new WindsorContainer(new XmlInterpreter());

    FileReader defaultReader = container.Resolve<FileReader>();

    FileReader file1Reader = container.Resolve<FileReader>("reader.file1");

    FileReader file2Reader = container.Resolve<FileReader>("reader.file2");

    Console.WriteLine("Default contents: {0}", defaultReader.ReadToEnd());

    Console.WriteLine("File1 contents: {0}", file1Reader.ReadToEnd());

    Console.WriteLine("File2 contents: {0}", file2Reader.ReadToEnd());

    Console.Read();

}

Uri uri;

// blah blah blah

string key = "messageSender."+ uri.Scheme;

if (container.Kernel.HasComponent(key))

{

    ISender sender = container.Resolve<ISender>(key);

    // send the message at this point...

    sender.SendMessage("hi there");

}

else

{

    // no implementation registered...

    throw new NotImplementedException("no sender registered for scheme: " + uri.Scheme);

}

public interface IMessageOfTheDay

{

    string GetMessageOfTheDay();

}

public class StaticMessageOfTheDay : IMessageOfTheDay

{

    private string _message;

    public string Message

    {

        set { _message = value; }

    }

    public string GetMessageOfTheDay()

    {

        return _message;

    }

}

public class WikiQuotesMessageOfTheDay : IMessageOfTheDay

{

    public string GetMessageOfTheDay()

    {

        WebClient client = new WebClient();

        string content = client.DownloadString("http://en.wikiquote.org/wiki/Main_Page");

        string toFind = "<div style=\"background: #fff5f5\">";

        int start = content.IndexOf(toFind) + toFind.Length;

        int length = content.IndexOf("<a", start) - start;

        return content.Substring(start, length);

    }

}

private static void Main(string[] args)

{

    WindsorContainer container = new WindsorContainer(new XmlInterpreter());

    IMessageOfTheDay motd = container.Resolve<IMessageOfTheDay>();

    Console.WriteLine("MOTD: {0}", motd.GetMessageOfTheDay());

    Console.Read();

}

<configuration>

  <configSections>

    <section name="castle"

        type="Castle.Windsor.Configuration.AppDomain.CastleSectionHandler, Castle.Windsor" />

  </configSections>

  <castle>

    <components>

      <component id="motd.service"

                service="IoC.Tutorials.Part7.IMessageOfTheDay, IoC.Tutorials.Part7"

                type="IoC.Tutorials.Part7.StaticMessageOfTheDay, IoC.Tutorials.Part7">

        <parameters>

          <message>Welcome to my container tutorials</message>

        </parameters>

      </component>

    </components>

  </castle>

</configuration>

<configuration>

  <configSections>

    <section name="castle"

        type="Castle.Windsor.Configuration.AppDomain.CastleSectionHandler, Castle.Windsor" />

  </configSections>

  <castle>

    <components>

      <component id="motd.service"

          service="IoC.Tutorials.Part7.IMessageOfTheDay, IoC.Tutorials.Part7"

          type="IoC.Tutorials.Part7.WikiQuotesMessageOfTheDay, IoC.Tutorials.Part7" />

    </components>

  </castle>

</configuration>

public class AddingService

{

    private int _total = 0;

    public void AddAmmount(int ammount)

    {

        _total += ammount;

    }

    public int Total

    {

        get { return _total; }

    }

}

private static void Main(string[] args)

{

    WindsorContainer container = new WindsorContainer(new XmlInterpreter());

    AddingService sheepCounted = container.Resolve<AddingService>();

    AddingService catsHerded = container.Resolve<AddingService>();

    sheepCounted.AddAmmount(10);

    sheepCounted.AddAmmount(50);

    catsHerded.AddAmmount(3);

    catsHerded.AddAmmount(12);

    Console.WriteLine("You have counted {0} sheep and herded {1} angry cats", sheepCounted.Total,

                      catsHerded.Total);

    Console.Read();

}

<configuration>

  <configSections>

    <section name="castle"

        type="Castle.Windsor.Configuration.AppDomain.CastleSectionHandler, Castle.Windsor" />

  </configSections>

  <castle>

    <components>

      <component id="adding.service" type="IoC.Tutorials.Part6.AddingService, IoC.Tutorials.Part6" lifestyle="transient" />

    </components>

  </castle>

</configuration>

[Transient]

public class AddingService

{

    private int _total = 0;

    public void AddAmmount(int ammount)

    {

        _total += ammount;

    }

    public int Total

    {

        get { return _total; }

    }

}

<configuration>

  <properties>

    <configName>Debug</configName>

  </properties>

</configuration>

<configuration>

  <properties>

    <configName>Live</configName>

  </properties>

</configuration>

<configuration>

  <configSections>

    <section name="castle"

        type="Castle.Windsor.Configuration.AppDomain.CastleSectionHandler, Castle.Windsor" />

  </configSections>

  <castle> 

    <components>

      <include uri="file://properties-debug.config" />

      <!--<include uri="file://properties-live.config" />-->

      <component id="whatConfig.service" type="IoC.Tutorials.Part5.WhatConfigurationService, IoC.Tutorials.Part5">

        <parameters>

          <Configuration>#{configName}</Configuration>

        </parameters>

      </component>

    </components>

  </castle>

</configuration>

public class WhatConfigurationService

{

    private string _configuration;

    public string Configuration

    {

        get { return _configuration; }

        set { _configuration = value; }

    }

}

private static void Main(string[] args)

{

    WindsorContainer container = new WindsorContainer(new XmlInterpreter());

    WhatConfigurationService whatConfiguration = container.Resolve<WhatConfigurationService>();

    Console.WriteLine("Configuration: {0}", whatConfiguration.Configuration);

    Console.Read();

}

<configuration>

    <components>

      <component id="whatConfig.service" type="IoC.Tutorials.Part4.WhatConfigurationService, IoC.Tutorials.Part4">

        <parameters>

          <Configuration>Debug</Configuration>

        </parameters>

      </component>

    </components>

</configuration>

<configuration>

  <components>

    <component id="whatConfig.service" type="IoC.Tutorials.Part4.WhatConfigurationService, IoC.Tutorials.Part4">

      <parameters>

        <Configuration>Live</Configuration>

      </parameters>

    </component>

  </components>

</configuration>

<configuration>

  <configSections>

    <section name="castle"

        type="Castle.Windsor.Configuration.AppDomain.CastleSectionHandler, Castle.Windsor" />

  </configSections>

  <castle>

    <!--<include uri="file://container-debug.config" />-->

    <include uri="file://container-live.config" />

  </castle>

</configuration>

public class AliasService

{

    private Dictionary<string, string> _aliases;

    public Dictionary<string, string> Aliases

    {

        get { return _aliases; }

        set { _aliases = value; }

    }

    public string Evaluate(string term)

    {

        if (_aliases == null) return term;

        while (_aliases.ContainsKey(term))

        {

            term = _aliases[term];

        }

        return term;

    }

}

static void Main(string[] args)

{

    WindsorContainer container = new WindsorContainer(new XmlInterpreter());

    AliasService aliasService = container.Resolve<AliasService>();

    string sentence = "a dog ate my homework";

    foreach (string word in sentence.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries))

    {

        Console.Write("{0} ", aliasService.Evaluate(word));

    }

    Console.Read();

}

<configuration>

  <configSections>

    <section name="castle"

        type="Castle.Windsor.Configuration.AppDomain.CastleSectionHandler, Castle.Windsor" />

  </configSections>

  <castle>

    <components>

      <component id="aliases.service" type="IoC.Tutorials.Part3.AliasService, IoC.Tutorials.Part3">

        <parameters>

          <Aliases>

            <dictionary>

              <entry key="dog">duck</entry>

              <entry key="ate">broke</entry>

              <entry key="homework">code</entry>

            </dictionary>

          </Aliases>

        </parameters>

      </component>

    </components>

  </castle>

</configuration>

public class HolidayService

{

    private DateTime[] _holidays;

    public DateTime[] Holidays

    {

        get

        {               

            return _holidays;

        }

        set { _holidays = value; }

    }

    public bool IsHoliday(DateTime date)

    {

        if (_holidays != null)

        {

            DateTime matchDate = date.Date;

            foreach (DateTime test in Holidays)

            {

                if (test.Date.Equals(matchDate))

                {

                    return true;

                }

            }

        }

        return false;

    }

}

internal class Program

{

    private static void Main(string[] args)

    {

        WindsorContainer container = new WindsorContainer(new XmlInterpreter());

        HolidayService holidayService = container.Resolve<HolidayService>();

        DateTime xmas = new DateTime(2007, 12, 25);

        DateTime newYears = new DateTime(2008, 1, 1);

        if (holidayService.IsHoliday(xmas))

            Console.WriteLine("merry xmas!");

        else

            Console.WriteLine("xmas is only for management!");

        if (holidayService.IsHoliday(newYears))

            Console.WriteLine("happy new year");

        else

            Console.WriteLine("new year, you haven't done all the work for last year!");

        Console.Read();

    }

}

<configuration>

  <configSections>

    <section name="castle"

        type="Castle.Windsor.Configuration.AppDomain.CastleSectionHandler, Castle.Windsor" />

  </configSections>

  <castle>

    <components>

      <component id="holidays.service" type="IoC.Tutorials.Part2.HolidayService, IoC.Tutorials.Part2" >

        <parameters>

          <Holidays>

            <array>

              <item>2007-12-24</item>

              <item>2007-12-25</item>

              <item>2008-1-1</item>

            </array>

          </Holidays>

        </parameters>

      </component>

    </components>

  </castle>

</configuration>

public class TaxCalculator

{

    private decimal _rate = 0.125m;

    public decimal Rate

    {

        set { _rate = value; }

        get { return _rate; }

    }

    public decimal CalculateTax(decimal gross)

    {

        return Math.Round(_rate*gross, 2);

    }

}

private static void Main(string[] args)

{

    WindsorContainer container = new WindsorContainer(new XmlInterpreter());

    TaxCalculator calculator = container.Resolve<TaxCalculator>();

    decimal gross = 100;

    decimal tax = calculator.CalculateTax(gross);

    Console.WriteLine("Gross: {0}, Tax: {1}", gross, tax);

    Console.Read();

}

<configuration>

  <configSections>

    <section name="castle"

        type="Castle.Windsor.Configuration.AppDomain.CastleSectionHandler, Castle.Windsor" />

  </configSections>

  <castle>

    <components>

      <component id="taxcalc.service" type="IoC.Tutorials.Part1.TaxCalculator, IoC.Tutorials.Part1" />

    </components>

  </castle>

</configuration>

<configuration>

  <configSections>

    <section name="castle"

        type="Castle.Windsor.Configuration.AppDomain.CastleSectionHandler, Castle.Windsor" />

  </configSections>

  <castle>

    <components>

      <component id="taxcalc.service" type="IoC.Tutorials.Part1.TaxCalculator, IoC.Tutorials.Part1">

        <parameters>

          <Rate>0.25</Rate>

        </parameters>

      </component>

    </components>

  </castle>

</configuration>

private DateTime _trialExpirey;

private int _maxExecutions;

private TimeSpan _trialDuration;

private Func<DateTime> _nowFunction;

public TrialUpdater(DateTime trialExpirey, int maxExecutions, TimeSpan trialDuration)

    : this(delegate { return DateTime.Now; }, trialExpirey, maxExecutions, trialDuration)

{

}

public TrialUpdater(Func<DateTime> nowFunction, DateTime trialExpirey, int maxExecutions, TimeSpan trialDuration)

{

    if (nowFunction == null) throw new ArgumentNullException("nowFunction");

    _nowFunction = nowFunction;

    _trialExpirey = trialExpirey;

    _maxExecutions = maxExecutions;

    _trialDuration = trialDuration;           

}

<component id="trialUpdater" type="MyLib.TrialUpdater, MyLib" >

  <parameters>

    <nowFunction>

      <method service="clockService" method="GetCurrentTime" />

    </nowFunction>

  </parameters>

</component>

IRepository<Order> orderRepository = IoC.Resolve<IRepository<Order>>();                       

Order orderForApples = new Order();

OrderLine greenOnes = new OrderLine();

OrderLine redOnes = new OrderLine();

orderForApples.OrderLines.Add(greenOnes);

orderForApples.OrderLines.Add(redOnes);

orderRepository.Save(orderForApples);

{

    public CatalogueService(IRepository<Track> trackRepository, IRepository<Release> releaseRepository,

                            IRepository<Artist> artistRepository, IRepository<Genre> genreRepository)

    {

        if (trackRepository == null) throw new ArgumentNullException("trackRepository");

        if (releaseRepository == null) throw new ArgumentNullException("releaseRepository");

        if (artistRepository == null) throw new ArgumentNullException("artistRepository");

        if (genreRepository == null) throw new ArgumentNullException("genreRepository");

        _trackRepository = trackRepository;

        _releaseRepository = releaseRepository;

        _artistRepository = artistRepository;

        _genreRepository = genreRepository;

    }

public PagedItemList<Track> ListTracksForArtist(Artist artist, int pageSize, int pageNumber)

{

    ObjectQuery query = new ObjectQuery(typeof (Track));

    query.Scope.Add("Release");

    query.Scope.Add("Release.Artist");

    query.Path = (Track.Fields.Release.Artist.ID == artist.ID);

    query.Path.AddOrderBy("Name", OrderByDirection.Ascending);

    return _trackRepository.Find(query, pageSize, pageNumber);

}

public void ListReleasesForArtist()

{           

    Artist artist = new Artist();

    PagedItemList<Release> releases = new PagedItemList<Release>(new ItemList<Release>(), 1, 10, 20);

    Func<bool, ObjectQuery, int, int> callback

        = delegate(ObjectQuery query, int pageNumber, int pageSize)

        {

            ObjectPath path = Release.Fields.Artist.ID == artist.ID;

            path.AddOrderBy("Name");

            Base4Assert.ArePathsEqual(path, query.Path);

            Base4Assert.AreScopesEqual(new string[] { "Artist" }, query.Scope);

            Assert.AreEqual(1, pageNumber, "pageNumber");

            Assert.AreEqual(10, pageSize, "pageSize");

            return true;

        };

    Expect.Call(_releaseRepository.Find(null, 1, 10)).Callback(callback).Return(releases);

    _mockRepository.ReplayAll();

    ICatalogueService service =

        new CatalogueService(_trackRepository, _releaseRepository, _artistRepository, _genreRepository);

    PagedItemList<Release> results = service.ListReleasesForArtist(artist, 1, 10);

    Assert.AreSame(releases, results);

    _mockRepository.VerifyAll();

}

public void SetUp()

{

    _mockRepository = new MockRepository();

    _trackRepository = _mockRepository.CreateMock<IRepository<Track>>();

    _releaseRepository = _mockRepository.CreateMock<IRepository<Release>>();

    _artistRepository = _mockRepository.CreateMock<IRepository<Artist>>();

    _genreRepository = _mockRepository.CreateMock<IRepository<Genre>>();

}

[ServiceContract(Namespace="http://localhost/schemas/testrunner/", SessionMode=SessionMode.Required)]

public interface ITestRunner

{

    [OperationContract]

    Guid StartTestRun(Guid testSuiteId);

    [OperationContract]

    TestRunStatus GetRunStatus(Guid testRunId);

}

public class TestRunner : ITestRunner

{

    where T: class

{

    private ServiceHost _host;

    private T _service;

    private ILogger _log;

    public HostingWrapper(ILogger log, T service)

    {

        if (log == null) throw new ArgumentNullException("log");

        if (service == null) throw new ArgumentNullException("service");

        _log = log;

        _service = service;       

    }

    public void Start()

    {

        _host = new ServiceHost(_service);

        if (_log.IsDebugEnabled) _log.Debug("Opening ServiceHost for service: {0}", _service.GetType());

        _host.Open();

        if (_log.IsInfoEnabled) _log.Info("Opened ServiceHost for service: {0}", _service.GetType());

    }

    public void Stop()

    {

        if (_log.IsDebugEnabled) _log.Debug("Closing ServiceHost for service: {0}", _service.GetType());

        _host.Close();

        ((IDisposable)_host).Dispose();

        if (_log.IsInfoEnabled) _log.Info("Closed ServiceHost for service: {0}", _service.GetType());

        _host = null;

    }

}

<components>

    <component id="testRunnerService.default"

        service="BoatsForGoats.Services.Testing.ITestRunner, BoatsForGoats.Services"

        type="BoatsForGoats.Services.Testing.TestRunner, BoatsForGoats.Services" />

    <component id="testRunnerHost.default"

        type="BoatsForGoats.Services.HostingWrapper`1[[BoatsForGoats.Services.Testing.ITestRunner, BoatsForGoats.Services]], BoatsForGoats.Services" />

• Components dependencies
• Constructor candidates
  
• Parameters (sounds like us...)
• Name, implementation type and service type.
• Lifecycle, Lifestyle...
• And some other stuff you can discover for yourself.