#foobar a { color: black; }

NO – div#foobar
YES  - #foobar

NO – div.foobar
YES - .foobar

NO – ul li a
YES – .list-anchor

NO - #foobar > li > a
YES - .foobar-anchor

Div div div a.myclass {…}

a.myclass * {…}

for (byte i = byte.MinValue; i <= byte.MaxValue; i++)  
{
	Console.Write(i);
}

public static class EnumerableExtension
{
    /// <summary>
    /// Returns all the elements that match the filter.
    /// </summary>
    /// <typeparam name="TEnumerable"></typeparam>
    /// <param name="enumerable"></param>
    /// <param name="filter"></param>
    /// <returns></returns>
    public static IEnumerable<TEnumerable> GRep<TEnumerable>(this IEnumerable<TEnumerable> enumerable, string filter)
    {
        var regex = new Regex(filter);
 
        foreach (TEnumerable item in enumerable)
        {
            if (regex.IsMatch(item.ToString()))
            {
                yield return (item);
            }
        }
    }
 
    /// <summary>
    /// Returns the results of applying the iterator to each element.
    /// </summary>
    /// <typeparam name="TEnumerable"></typeparam>
    /// <typeparam name="T2"></typeparam>
    /// <param name="enumerable"></param>
    /// <param name="func"></param>
    /// <returns></returns>
    public static IEnumerable<T2> Map<TEnumerable, T2>(this IEnumerable<TEnumerable> enumerable, Func<TEnumerable, T2> func)
    {
        foreach (TEnumerable item in enumerable)
        {
            yield return func(item);
        }
    }
 
    /// <summary>
    /// Returns all the elements for which the iterator returned false.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="enumerable"></param>
    /// <param name="match"></param>
    /// <returns></returns>
    public static IEnumerable<T> Reject<T>(this IEnumerable<T> enumerable, Predicate<T> match)
    {
        foreach (T item in enumerable)
        {
            if (!match(item))
            {
                yield return item;
            }
        }
    }
 
    /// <summary>
    /// Incrementally builds a result value based on the successive results of the iterator. This can be used for array construction, numerical sums/averages, etc.
    /// </summary>
    /// <typeparam name="TEnumerable"></typeparam>
    /// <typeparam name="TMemo"></typeparam>
    /// <param name="enumerable"></param>
    /// <param name="accumulator"></param>
    /// <param name="func"></param>
    /// <returns></returns>
    public static TMemo Inject<TEnumerable, TMemo>(this IEnumerable<TEnumerable> enumerable, TMemo accumulator, Func<TMemo, TEnumerable, TMemo> func)
    {
        enumerable.Each(item => accumulator = func(accumulator, item));
 
        return accumulator;
    }
 
    /// <summary>
    /// Incrementally builds a result value based on the successive results of the iterator. This can be used for array construction, numerical sums/averages, etc.
    /// </summary>
    /// <typeparam name="TEnumerable"></typeparam>
    /// <typeparam name="TMemo"></typeparam>
    /// <param name="enumerable"></param>
    /// <param name="accumulator"></param>
    /// <param name="func"></param>
    /// <returns></returns>
    public static TMemo Inject<TEnumerable, TMemo>(this IEnumerable<TEnumerable> enumerable, TMemo accumulator, Func<TMemo, TEnumerable, int, TMemo> func)
    {
        enumerable.Each((item, index) => accumulator = func(accumulator, item, index));
 
        return accumulator;
    }
 
    /// <summary>
    /// It lets you iterate over all the elements in a generic fashion, then returns the Enumerable, thereby allowing chain-calling.
    /// </summary>
    /// <typeparam name="TEnumerable"></typeparam>
    /// <param name="enumerable"></param>
    /// <param name="iterator"></param>
    public static void Each<TEnumerable>(this IEnumerable<TEnumerable> enumerable, Action<TEnumerable> iterator)
    {
        for(var i = 0; i < enumerable.Count(); i++)
        {
            iterator(enumerable.ToArray()[i]);
        }
    }
 
 
    /// <summary>
    /// It lets you iterate over all the elements in a generic fashion, then returns the Enumerable, thereby allowing chain-calling.
    /// </summary>
    /// <typeparam name="TEnumerable"></typeparam>
    /// <param name="enumerable"></param>
    /// <param name="iterator"></param>
    public static void Each<TEnumerable>(this IEnumerable<TEnumerable> enumerable, Action<TEnumerable, int> iterator)
    {
        for (var index = 0; index < enumerable.Count(); index++)
        {
            iterator(enumerable.ToArray()[index], index);
        }
    }
 
    public static string ToJSON<T>(this IEnumerable<T> enumerable)
    {
        var serializer = new JavaScriptSerializer();
        return serializer.Serialize(enumerable);
    }
}

public static class ArrayExtension
{
    /// <summary>
    /// Produces a new version of the array that does not contain any of the specified values.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="array"></param>
    /// <param name="values"></param>
    /// <returns></returns>
    public static T[] Without<T>(this T[] array, params T[] values)
    {
        return array.Reject(t => values.Contains(t)).ToArray();
    }
}

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = false, AllowMultiple = false)]
public sealed class FormatFilterAttribute : FilterAttribute, IActionFilter
{
    /// <summary>
    /// The type of files we can server the requested content in
    /// </summary>
    private enum FileFormat { Html, Json, Xml }
 
    public FormatFilterAttribute()
    {
        Disallow = string.Empty;
        RequestedFormat = FileFormat.Html;
    }
 
    /// <summary>
    /// Formats to disallow can be either Html, Json or Xml. Use comma to seperate multiple formats.
    /// </summary>
    public string Disallow { get; set; }
 
    /// <summary>
    /// The format that has been requested
    /// </summary>
    private FileFormat RequestedFormat { get; set; }
 
    /// <summary>
    /// Occurs before an action is executed
    /// </summary>
    /// <param name="filterContext"></param>
    public void OnActionExecuting(ActionExecutingContext filterContext)
    {
        FileFormat format = GetFileFormat(filterContext.HttpContext.Request.Path);
        if(IsDisallowed(format))
        {
            throw new ArgumentException("Requested format has been disallowed");
        }
 
        RequestedFormat = format;
    }
 
    /// <summary>
    /// Occurs after an action is executed
    /// </summary>
    /// <param name="filterContext"></param>
    public void OnActionExecuted(ActionExecutedContext filterContext)
    {
        if(!(filterContext.Result is ViewResult))
        {
            throw new InvalidOperationException("You need to call the View method, when the FormatFilter attribute is applied");
        }
 
        var view = (ViewResult)(filterContext.Result);            
        filterContext.Result = FormatViewResult(view);
    }
 
    /// <summary>
    /// Verifies if the format has been disallowed
    /// </summary>
    /// <param name="format"></param>
    /// <returns></returns>
    private bool IsDisallowed(FileFormat format)
    {
        return Disallow.Split(',').Any(s => s.ToLower() == format.ToString().ToLower());
    }
 
    /// <summary>
    /// Verifies that the requested format is one that can be servered
    /// </summary>
    /// <param name="ext"></param>
    /// <returns></returns>
    private bool IsValidFileExtension(string ext)
    {
        return Enum.GetNames(typeof(FileFormat)).Any(format => format.ToLower() == ext.Substring(1).ToLower());
    }
 
    /// <summary>
    /// 
    /// </summary>
    /// <param name="path"></param>
    /// <returns></returns>
    private FileFormat GetFileFormat(string path)
    {
        string ext = Path.GetExtension(path);
        if(string.IsNullOrEmpty(ext))
        {
            return FileFormat.Html;
        }
 
        if (!IsValidFileExtension(ext))
        {
            throw new FormatException("Requested format is not available");
        }
 
        return (FileFormat)Enum.Parse(typeof(FileFormat), ext.Substring(1), true);
    }
 
    private ActionResult FormatViewResult(ViewResultBase view)
    {
        switch (RequestedFormat)
        {
            case FileFormat.Html:
                return view;
            case FileFormat.Json:
                return new JsonResult { Data = view.ViewData.Model };
            case FileFormat.Xml:
                return new XmlResult(view.ViewData.Model);
            default:
                throw new FormatException(string.Concat("Cannot server the content in the request format: ", RequestedFormat));
        }
    }
}

[FormatFilter]
public class HomeController : Controller
{      
    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 View(pizzas);
    }
}

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

var i=values.length;
while(i--){
	processData(values[i]);
}

processData(values[0]);
processData(values[1]);
processData(values[2]);
processData(values[3]);
processData(values[4]);

var iterations = Math.ceil(values.length / 8); 
var startAt = values.length % 8; 
var i = 0;  
 
do {     
	switch(startAt){         
		case 0: process(values[i++]);         
		case 7: process(values[i++]);         
		case 6: process(values[i++]);         
		case 5: process(values[i++]);         
		case 4: process(values[i++]);         
		case 3: process(values[i++]);         
		case 2: process(values[i++]);         
		case 1: process(values[i++]);     
	}     
	startAt = 0; 
} while (--iterations > 0);

var iterations = Math.floor(values.length / 8); 
var leftover = values.length % 8; 
var i = 0;  
 
if (leftover > 0){     
	do {         
		process(values[i++]);     
	} while (--leftover > 0); 
}  
 
do {     
	process(values[i++]);     
	process(values[i++]);     
	process(values[i++]);     
	process(values[i++]);     
	process(values[i++]);     
	process(values[i++]);     
	process(values[i++]);     
	process(values[i++]); 
} while (--iterations > 0);

/// <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 = ""}
);