Factory Method, Multitenancy, StructureMap, and Other Stuff

Factory.cs

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using StructureMap;

    class Program
    {
        static void Main(string[] args)
        {
            var container = new Container(t =>
            {
                t.Scan(scan =>
                    {
                        scan.AssemblyContainingType<Program>();
                        scan.WithDefaultConventions();

                        scan.AddAllTypesOf<IEmailContentBuilder>();
                    });
            });

            var tenant1 = new Tenant { TenantId = "abc", CommonName = "ABC Tenant" };
            var tenant2 = new Tenant { TenantId = "zyx", CommonName = "ZYX Tenant" };

            var factory = container.GetInstance<IEmailContentBuilderFactory>();
            var builder1 = factory.GetBuilder(tenant1);
            var builder2 = factory.GetBuilder(tenant2);

            var result1 = builder1.GenerateContent(tenant1);
            var result2 = builder2.GenerateContent(tenant2);

            Console.WriteLine(result1.MessageBody);
            Console.WriteLine(result2.MessageBody);
        }
    }


    public interface ITenant
    {
        string TenantId { get; }
        string CommonName { get; }
    }


    public class Tenant : ITenant 
    {
        public string TenantId { get; set; }
        public string CommonName { get; set; }
    }


    public interface ITenantOverride
    {
        bool IsForThisTenant(ITenant tenant);
    }


    public class EmailContent
    {
        public string MessageBody { get; set; }
    }


    public interface IEmailContentBuilder
    {
        EmailContent GenerateContent(ITenant tenant);
    }


    public interface IDefaultImplementation
    {

    }


    public interface IEmailContentBuilderFactory
    {
        IEmailContentBuilder GetBuilder(ITenant tenant);
    }


    public class EmailContentBuilderFactory : IEmailContentBuilderFactory
    {
        private readonly IEnumerable<IEmailContentBuilder> emailContentBuilders;
        private readonly IEmailContentBuilder defaultEmailContentBuilder;       

        public EmailContentBuilderFactory(IEnumerable<IEmailContentBuilder> emailContentBuilders)
        {
            this.emailContentBuilders = emailContentBuilders;

            this.defaultEmailContentBuilder =
                this.emailContentBuilders
                    .OfType<IDefaultImplementation>()
                    .OfType<IEmailContentBuilder>()
                    .FirstOrDefault();
        }

        IEmailContentBuilder IEmailContentBuilderFactory.GetBuilder(ITenant tenant)
        {
            var result = GetTenantSpecificEmailContentBuilder(tenant);

            if (result == null)
                result = defaultEmailContentBuilder;

            if (result == null)
                result = emailContentBuilders.FirstOrDefault();

            if (result == null)
                throw new ArgumentNullException();

            return result;
        }


        private IEmailContentBuilder GetTenantSpecificEmailContentBuilder(ITenant tenant)
        {
            var result =
                this.emailContentBuilders
                    .OfType<ITenantOverride>()
                    .Where(t => t.IsForThisTenant(tenant))
                    .OfType<IEmailContentBuilder>()
                    .FirstOrDefault();

            return result;
        }
    }


    public class DefaultEmailContentBuilder : IEmailContentBuilder, IDefaultImplementation
    {
        private const string MessageBodyTemplate = "This is default content for {0}.";

        EmailContent IEmailContentBuilder.GenerateContent(ITenant tenant)
        {
            return new EmailContent
            {
                MessageBody =
                    string.Format(MessageBodyTemplate, tenant.CommonName)
            };
        }
    }


    public class CustomEmailContentBuilder : IEmailContentBuilder, ITenantOverride
    {
        private const string MessageBodyTemplate = "This is override content for {0}.";

        EmailContent IEmailContentBuilder.GenerateContent(ITenant tenant)
        {
            return new EmailContent
            {
                MessageBody =
                    string.Format(MessageBodyTemplate, tenant.CommonName)
            };
        }
        bool ITenantOverride.IsForThisTenant(ITenant tenant)
        {
            return tenant != null && tenant.TenantId == "abc";
        }
    }

    public class AnotherCustomEmailContentBuilder : IEmailContentBuilder, ITenantOverride
    {
        private const string MessageBodyTemplate = "This is a special override content for {0}.";

        EmailContent IEmailContentBuilder.GenerateContent(ITenant tenant)
        {
            return new EmailContent
            {
                MessageBody =
                    string.Format(MessageBodyTemplate, tenant.CommonName)
            };
        }
        bool ITenantOverride.IsForThisTenant(ITenant tenant)
        {
            return tenant != null && tenant.TenantId == "xyz";
        }
    }