Fat Agnus

/// <summary>
/// A base controller that will enable you to serve your data in either Json, Xml, Html
/// </summary>
public abstract class FormatController : Controller
{
	/// <summary>
	/// The Key to extract the format from Route Data
	/// </summary>
	private const string FORMAT_KEY = "Format";
 
	/// <summary>
	/// The type of files we can server the requested content in
	/// </summary>
	public enum FileFormat { Html, Json, Xml }
 
	protected FormatController()
	{
		// Our Default format
		RequestedFormat = FileFormat.Html;
	}
 
	/// <summary>
	/// The format that has been requested
	/// </summary>
	protected FileFormat RequestedFormat { get; private set; }
 
	/// <summary>
	/// Occurs before an action is executed
	/// </summary>
	/// <param name="filterContext"></param>
	protected override void OnActionExecuting(ActionExecutingContext filterContext)
	{
		base.OnActionExecuting(filterContext);
 
		var routeValues = filterContext.RouteData.Values;
		if (routeValues.ContainsKey(FORMAT_KEY))
		{
			var requestedFormat = routeValues[FORMAT_KEY].ToString();
			if (IsValidFormat(requestedFormat))
			{
				RequestedFormat = (FileFormat)Enum.Parse(typeof(FileFormat), requestedFormat, true);
			}
		}
	}
 
	/// <summary>
	/// Verifies that the requested format is one that can be servered
	/// </summary>
	/// <param name="requestedFormat"></param>
	/// <returns></returns>
	private bool IsValidFormat(string requestedFormat)
	{
		return Enum.GetNames(typeof(FileFormat)).Any(format => format.ToLower() == requestedFormat.ToLower());
	}
 
	/// <summary>
	/// Returns the content in the requested format
	/// </summary>
	/// <param name="viewModel">Viewmodel</param>
	/// <returns>ActionResult</returns>
	protected ActionResult FormatView(object viewModel)
	{
		switch (RequestedFormat)
		{
			case FileFormat.Html:
				return View(viewModel);
			case FileFormat.Json:
				return Json(viewModel);
			case FileFormat.Xml:
				return new XmlResult(viewModel);
			default:
				throw new FormatException(string.Concat("Cannot server the content in the request format: ", RequestedFormat));
		}
	}
}

public class Pizza
{
	public int Number { get; set; }
	public string Name { get; set; }
	public string Price { get; set; }
}
 
public class HomeController : FormatController
{
	public ActionResult Index()
	{
		var pizzas = new[]
			{
				new Pizza {Number = 1, Name = "Pizza 1", Price = "$10"},
				new Pizza {Number = 2, Name = "Pizza 2", Price = "$13"},
				new Pizza {Number = 3, Name = "Pizza 3", Price = "$20"}
			};
 
		return FormatView(pizzas);
	}
}

// Add this to Global.asax
routes.MapRoute(
	"Format",
	"{controller}/{action}.{format}/{id}",
	new {id = ""}
);

public interface ISubject
{
	void RegisterObserver(IObserver o);
 
	void RemoveObserver(IObserver o);
 
	void NotifyObservers();
}
 
public interface IObserver
{
	void Update(string story);
}
 
public class NewsPublisher : ISubject
{
	private List<IObserver> observers = new List<IObserver>();
 
	private List<string> archive = new List<string>();
 
	public void RegisterObserver(IObserver o)
	{
		observers.Add(o);
	}
 
	public void RemoveObserver(IObserver o)
	{
		observers.Remove(o);
	}
 
	public void NotifyObservers()
	{
		foreach(IObserver o in observers)
		{
			o.Update(archive[archive.Count - 1]);
		}
	}
 
	public void PublishBreakingNews(string story)
	{
		archive.Add(story);
		ArchiveChanged();
	}
 
	private void ArchiveChanged()
	{
		NotifyObservers();
	}
}
 
public class NewsSubscriber : IObserver
{
	public void Update(string story)
	{
        Console.WriteLine("--------------------- Breaking News ---------------------");
        Console.Write(story);
        Console.WriteLine();
	}
}
 
class Program
{
	static void Main(string[] args)
	{
		NewsSubscriber me = new NewsSubscriber();
 
		NewsPublisher publisher = new NewsPublisher();
 
		publisher.RegisterObserver(me);
 
		publisher.PublishBreakingNews("hello world");
	}
}

/// <summary>
/// Observer
/// </summary>
public class NewsSubscriber
{
	public void Update(string story)
	{
		Console.WriteLine("--------------------- Breaking News ---------------------");
		Console.Write(story);
		Console.WriteLine();
	}
}
 
/// <summary>
/// Subject
/// </summary>
public class NewsPublisher
{
	private readonly List<string> archive = new List<string>();
 
	public delegate void NotifyObserversHandler(string story);
 
	public event NotifyObserversHandler ArchiveChanged;
 
	public void PublishBreakingNews(string story)
	{
		archive.Add(story);
 
		// Notify observers
		ArchiveChanged(archive[archive.Count - 1]);
	}
}
 
class Program
{
	static void Main(string[] args)
	{
		NewsSubscriber me = new NewsSubscriber();
		NewsPublisher publisher = new NewsPublisher();
 
		//add the delegate to the event (register observer)
		publisher.ArchiveChanged += me.Update;
 
		publisher.PublishBreakingNews("Hello world");
	}
}

public class MyServiceLocatorAdapter : ServiceLocatorImplBase
{
    private IMyContainer container;
 
    public MyServiceLocatorAdapter(IMyContainer container)
    {
        this.container = container;
    }
 
    protected override object DoGetInstance(Type serviceType, string key)
    {
        return container.Resolve(serviceType, key);
    }
 
    protected override IEnumerable<object> DoGetAllInstances(Type serviceType)
    {
        return container.ResolveAll(serviceType);
    }
}

IUnityContainer container = new UnityContainer();
container.RegisterType<ISomeRepository, SomeRepository>();
 
MyServiceLocatorAdapter locator = new MyServiceLocatorAdapter(container);
 
ServiceLocator.SetLocatorProvider(() => locator);
 
ISomeRepository repository = ServiceLocator.Current.GetInstance<ISomeRepository>();;