CSS Border Radius Generator

The solution I went for was in three parts: a web.config transform, routing and the controller itself.

The web config transform for my live site looks like this:

<?xml version="1.0"?>
<configuration xmlns:xdt="http://schemas.microsoft.com/XML-Document-Transform">
    <appSettings>
        <add key="SiteStatus" value="live" xdt:Transform="SetAttributes" xdt:Locator="Match(key)"/>
    </appSettings>
</configuration>

The route is equally simple:

routes.MapRoute(
    "Robots.txt",
    "Robots.txt",
    new 
    { 
        controller = "Robots", 
        action = "RobotsText" 
    }
);

And finally the actual controller:

public class RobotsController : Controller
{
    public FileContentResult RobotsText()
    {
        var content = "User-agent: *" + Environment.NewLine;

        if (string.Equals(ConfigurationManager.AppSettings["SiteStatus"], "live", StringComparison.InvariantCultureIgnoreCase))
        {
            content += "Disallow: /elmah.axd" + Environment.NewLine;
            content += "Sitemap: http://www.jacquelinewhite.co.uk/sitemap.xml";
        }
        else
        {
            content += "Disallow: /" + Environment.NewLine; 
        }

        return File(
                Encoding.UTF8.GetBytes(content),
                "text/plain"); 
    }
}

And there we have it, my robots.txt file now is customised on a per deployment basis.

One bit of code that I kept seeing really bothered me. It was a guard class that I kept seeing. I think it was a clone of a class from the here. The reason it bothered me was simply that it didn’t read well, I kept thinking that it was guarding against an exception. In reality it was guarding against an error condition and would throw an exception if the condition happened. For example:

Guard.Against<InvalidOperationException>(string.IsNullOrEmpty(serverName), "Server name must be provided")

I would much rather something that reads like this:

Throw<InvalidOperationException>
    .WithMessage("Server name must be provided")
    .When(string.IsNullOrEmpty(serverName));

Here’s my implementation of the class, thoughts?

public static class Throw<T> where T : Exception
{
    public static Thrower WithMessage(string message)
    {
        return new Thrower(message);
    }

    public class Thrower
    {
        private readonly string message;
        public Thrower(string message)
        {
            this.message = message;
        }

        public void When(Func<bool> predicate)
        {
            if (predicate())
            {
                throw (T)Activator.CreateInstance(typeof(T), message);
            }
        }

        public void When(bool condition)
        {
            if (condition)
            {
                throw (T)Activator.CreateInstance(typeof(T), message);
            }
        }
    }
}

Well, now you can and it’s really simple.

The following extension method will let your controller know if it’s a full request or simply a user busy typing:

public static class RequestExtensions
{
    public static bool IsPreview(this HttpRequestBase request)
    {
        var purpose = request.Headers["X-Purpose"] ?? string.Empty;
        return string.Equals(": preview", purpose, StringComparison.InvariantCultureIgnoreCase);
    }
}

A very simple use of it would be something like this:

public virtual ActionResult Error404()
{
    Response.StatusCode = (int)HttpStatusCode.NotFound;
    if (Request.IsPreview())
    {
        ViewBag.Message = "Nope, I've haven't go that, keep typing.";
    }
    else
    {
        ViewBag.Message = "Sorry, but the file you requested was not found on the server.";
    }

    return View();
}

Let me know if you use this is a more creative way.

Which I happen to think is rather nice.

One problem I keep finding is code that repeatedly calls the backing stores with the same query. If I don’t have the time to refactor the code to work properly I sometimes cheat and use a cache that’s specific to the HttpContext. It’s not nice, but it does get me out of a hole every once in a while.

public static class ContextCache
{
	public static T Get(string key)
	{
		var value = HttpContext.Current.Items[key];
		return value is T ? (T)value : default(T);
	}

	public static void Put(string key, object value)
	{
		HttpContext.Current.Items[key] = value;
	}
}

It’s pretty simple to use:

var entity = ContextCache.Get("Entity_123");
if (entity == null)
{
    entity = GetFromBackingStore(123);
    ContextCache.Put("Entity_123", entity);
}

return entity;

This is definitely one of those bits of ugly code that can get you out of a hole in a rush. It aint pretty, but it works.

If you use this and it breaks your servers, steals your wallet and then runs off with your wife, consider it your fault for using code from some random blog post you found. Caveat emptor applies.

You can download a working sample here: WCFCulture

First up we need to create a message inspector to hook in and mush about with our messages:

public class CultureMessageInspector : IDispatchMessageInspector
{
	private readonly string _culture;
	public CultureMessageInspector(string culture)
	{
		_culture = culture;
	}

	public object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext)
	{
		Thread.CurrentThread.CurrentCulture = new CultureInfo(_culture);
		return null;
	}

	public void BeforeSendReply(ref Message reply, object correlationState)
	{
	}
}

Then we need to hook this into an endpoint behaviour:

public class CultureBehavior : IEndpointBehavior
{
	private readonly string _culture;
	public CultureBehavior(string culture)
	{
		_culture = culture;
	}

	public void AddBindingParameters(ServiceEndpoint endpoint, BindingParameterCollection bindingParameters)
	{
	}

	public void ApplyClientBehavior(ServiceEndpoint endpoint, ClientRuntime clientRuntime)
	{

	}

	public void ApplyDispatchBehavior(ServiceEndpoint endpoint, EndpointDispatcher endpointDispatcher)
	{
		var inspector = new CultureMessageInspector(_culture);
		endpointDispatcher.DispatchRuntime.MessageInspectors.Add(inspector);
	}

	public void Validate(ServiceEndpoint endpoint)
	{
	}
}

And because we want to configure the culture we end up using, we need a custom extension element:

public class CultureExtensionElement : BehaviorExtensionElement
{
	[ConfigurationProperty("Culture", DefaultValue = "en-GB")]
	public string Culture
	{
		get { return (string)base["Culture"]; }
		set { base["Culture"] = value; }
	}

	protected override object CreateBehavior()
	{
		return new CultureBehavior(Culture);
	}

	public override Type BehaviorType
	{
		get { return typeof(CultureBehavior); }
	}
}

Ok, so assuming that you can get that pretty lot to compile all we need to do is hook it in via the web.config in the services project.

First register the extension:

Then to your behaviour simply add:

Your resulting config should look a bit like this:

So now, it won’t matter what your client wants the culture to be, you can override it in config.