public static class LinqToSqlExtensions {
 
    public static TEntity GetById<TEntity>(this Table<TEntity> @this, int id)
        where TEntity : class {
        return @this.SingleOrDefault(x => ((IIdentified)x).ID == id);
    }
 
    public static TEntity Upsert<TEntity>(this Table<TEntity> @this, int id)
        where TEntity : class, new() {
 
        var entity = @this.SingleOrDefault(x => ((IIdentified)x).ID == id);
 
        if (entity == null) {
            entity = new TEntity();
            @this.InsertOnSubmit(entity);
        }
 
        if (entity is IAuditable)
            ((IAuditable) entity).ModifiedDate = DateTime.Now;
        return entity;
    }
 
    public static TEntity Upsert<TEntity>(this Table<TEntity> @this, Func<TEntity, bool> predicate)
        where TEntity : class, new() {
 
        var entity = @this.SingleOrDefault(predicate);
 
        if (entity == null) {
            entity = new TEntity();
            @this.InsertOnSubmit(entity);
        }
 
        if (entity is IAuditable)
            ((IAuditable) entity).ModifiedDate = DateTime.Now;
 
        return entity;
    }
 
    public static void Delete<TEntity>(this Table<TEntity> @this, TEntity entity)
        where TEntity : class {
        @this.DeleteOnSubmit(entity);
    }
 
    public static void DeleteById<TEntity>(this Table<TEntity> @this, int id)
        where TEntity : class {
        var entity = @this.GetById(id);
        @this.Delete(entity);
    }
 
    public static void DeleteAll<TEntity>(this Table<TEntity> @this, 
        IEnumerable<TEntity> entities) where TEntity : class {
        entities.ToList().ForEach(e => @this.Delete(e));
    }
 
    public static void CommitChanges(this DataContext @this, RepositoryContext context) {
 
        var changeSet = @this.GetChangeSet();
 
        for (var i = 0; i < changeSet.Inserts.Count; i++)
            if (changeSet.Inserts[i] is IAuditable) UpdateAuditProperties((IAuditable) changeSet.Inserts[i], context, true);
 
        for (var i = 0; i < changeSet.Updates.Count; i++)
            if (changeSet.Updates[i] is IAuditable) UpdateAuditProperties((IAuditable) changeSet.Updates[i], context, false);
 
        @this.SubmitChanges();
    }
 
    private static void UpdateAuditProperties<TEntity>(TEntity entity, RepositoryContext context, 
        bool isInsert) where TEntity : IAuditable {
 
        entity.ModifiedDate = DateTime.Now;
        entity.ModifiedBy = context.UserID;
 
        if (isInsert) {
            entity.CreatedDate = DateTime.Now;
            entity.CreatedBy = context.UserID;
        }
    }
}

var thing = DataContext.Things.GetById(3);

var thing = DataContext.Things.Upsert(2);
var anotherThing = DataContext.Things.Upsert(x => x.Name == "That Thing");

DataContext.Things.Delete(thing);
DataContext.Things.DeleteById(3);

public interface IAuditable {
    public DateTime CreatedDate { get; set; }
    public DateTime UpdatedDate { get; set; }
    public int CreatedBy { get; set; }
    public int UpdatedBy { get; set; }
}
 
public interface IIdentified {
    public int ID { get; set; }
}
 
partial class Thing : IIdentified, IAuditable { }
public class OtherThing : IIdentified { }
public class LastThing : IAuditable { }

<section name="microsoft.scripting" 
	type="Microsoft.Scripting.Hosting.Configuration.Section, Microsoft.Scripting, 
		Version=0.9.6.20, Culture=neutral, PublicKeyToken=null" 
	requirePermission="false" />

<microsoft.scripting>
    <languages>
        <language names="IronPython;Python;py" 
			extensions=".py" displayName="IronPython 2.6" 
			type="IronPython.Runtime.PythonContext, IronPython, 
				Version=2.6.10920.0, Culture=neutral, PublicKeyToken=null" />
    </languages>
</microsoft.scripting>

[Serializable]
public class ScriptHookAttribute : OnMethodBoundaryAspect {
 
    private readonly ScriptEventTypes _scriptEventType;
 
    public ScriptEventAttribute(ScriptEventTypes scriptEventType) {
        _scriptEventType = scriptEventType;
    }
 
    public override void OnSuccess(MethodExecutionEventArgs eventArgs) {
        var args = eventArgs.GetReadOnlyArgumentArray();
        ScriptRunner.ExecuteEvent(_scriptEventType, args);
    }
}

[ScriptHook(ScriptEventTypes.ThingSaved)]
public void SaveThing(Thing t) { }
 
[ScriptHook(ScriptEventTypes.ThingDeleted)]
public void DeleteThing(Thing t) { }

public static class ScriptRunner {
 
    public static void ExecuteEvent(ScriptEventTypes scriptEventType, object[] eventContext) {
 
    IScriptEvent scriptEvent = null;
 
    switch (scriptEventType) {
        case ScriptEventTypes.ThingSaved:
	    scriptEvent = new ThingSavedScriptEvent();
	    break;
	case ScriptEventTypes.ThingDeleted:
	    scriptEvent = new ThingDeletedScriptEvent;
	    break;
	}
 
	if (scriptEvent != null) {
            try {
                scriptEvent.ExecuteScripts(eventContext);
            } catch {
                throw new ScriptExecutionExecption();
            }
        }
    }
}

public class ThingSavedScriptEvent : IScriptEvent {
 
    private readonly ScriptRuntime _scriptRuntime;
    private readonly IThingRepository _thingRepo;
 
    public ProjectCreatedScriptEvent() {
        _thingRepo = new ThingRepository();
        _scriptRuntime = ScriptRuntime.CreateFromConfiguration();
    }
 
    public void ExecuteScripts(object[] contextValues) {
 
        var thing = (Thing)contextValues.SingleOrDefault(x => x is Thing);
 
		var scriptScope = _scriptRuntime.CreateScope();
        scriptScope.SetVariable("thingRepo", _thingRepo);
        scriptScope.SetVariable("thing", thing);
 
        var script = GetScript();
 
        var scriptEngine = _scriptRuntime.GetEngine("IronPython");
        scriptEngine.Execute(script, scriptScope);
    }
 
    private static string GetScript() {
 
        var script = string.Empty;
        try {
            code = File.ReadAllText(HttpContext.Current.Server.MapPath(
                ConfigSettings.ProjectTemplateStorePath + "ThingSaved.py"));
        } catch (FileNotFoundException) { }
        return script;
    }
}

public interface ITestScope {
    void SetupScope();
    void TeardownScope();
}

public abstract class TestBase {
    public abstract void ScopeSetup();
    public abstract void ScopeTeardown();
}

public static class TestFactory {
    public static TRepository GetRepository<TRepository>() where TRepository : class {}
    public static TController GetController<TController>() where TController : Controller {}
}

public class CustomerTestScope : ITestScope {
 
	private ICustomerRepository _customerRepo;
 
	public Customer TestCustomer { get; private set; }
 
	public CustomerTestScope(ICustomerRepository customerRepo) {
		_customerRepo = customerRepo;
	}
 
	public void SetupScope() {
		TestCustomer = _customerRepo.Create();
                // Other complex test setup logic
	}
 
	public void TeardownScope() {
		_customerRepo.Delete(TestCustomer);
                // The reverse of the complex setup logic
	}
}
 
[TestClass]
public class CustomerRepositoryTests : TestBase {
 
	private CustomerTestScope _customerScope;
	private ICustomerRepository _customerRepo;
 
	[TestInitialize]
	public override void ScopeSetup() {
 
		_customerRepo = TestFactory.GetRepository<ICustomerRepository>();
 
		_customerScope = new CustomerTestScope(_customerRepo);
		_customerScope.SetupScope();
	}
 
	[TestMethod]
	public void SaveCustomer_ShouldRenameCustomer_WhenNewNameGiven() {
 
		_customerScope.TestCustomer.Name = "New Name";
		_customerRepo.Save(_customerScope.TestCustomer);
 
		var customer = _customerRepo.GetById(_customerScope.TestCustomer.ID);
 
		Assert.IsTrue(customer.Name == "New Name", 
			"SaveCustomer failed to update customer name.");
	}
 
	[TestCleanup]
	public override void ScopeTeardown() {
		_customerScope.TeardownScope();
	}
}

protected void Application_Start(object sender, EventArgs e) {
    Config.AddAction<DateAction>("Show/CurrentDate");
}

public class DateAction : ActionBase {
    public override IResponse Get() {
        return Text(string.Format("The current date is {0}.", DateTime.Now));
    }
}

(function($) {
    $.fn.tablePager = function(options) {
 
        /*
        options = {
        firstBtn: Element,
        prevBtn: Element,
        nextBtn: Element,
        lastBtn: Element,
        indicator: Element,
        sizeSelect: Element,
        pageSize: Number,
        onPageChange: Callback,
        onPageSizeChange: Callback
        };
        */
 
        var tbl = this;
        var defaults = { pageSize: 10 };
        var opts = $.extend(defaults, options);
 
        var pageIndex = 0;
        var pageSize = opts.pageSize;
        var rowCount = getRows().length;
        var pageCount = getPageCount();
 
        function init() {
            bindControlHandlers();
            updatePaging();
            updateIndicator();
        }
 
        function getRows() {
            return tbl.find("tbody tr");
        }
 
        function bindControlHandlers() {
            if (opts.firstBtn) { 
	        opts.firstBtn.unbind().bind("click", 
		    function() { changePage(0); }); 
            }
            if (opts.prevBtn) { 
		opts.prevBtn.unbind().bind("click", 
			function() { changePage(pageIndex - 1); }); 
	    }
            if (opts.nextBtn) { 
		opts.nextBtn.unbind().bind("click", 
			function() { changePage(pageIndex + 1); }); 
	    }
            if (opts.lastBtn) { 
		opts.lastBtn.unbind().bind("click", 
			function() { changePage(pageCount - 1); }); 
	    }
            if (opts.sizeSelect) { 
		opts.sizeSelect.unbind().bind("change", 
                    function() { changePageSize(parseInt($(this).val())); }); 
	    }
        }
 
        function getPageCount() {
            return (rowCount % pageSize) ? 
		Math.floor(rowCount / pageSize) + 1 : (rowCount / pageSize);
        }
 
        function changePage(toIndex) {
            if (toIndex >= 0 && toIndex <= (pageCount - 1)) {
                pageIndex = toIndex;
                updatePaging();
                updateIndicator();
                if (opts.onPageChange) {
                    opts.onPageChange.call(pageIndex);
                }
            }
        }
 
        function changePageSize(toSize) {
            pageSize = toSize;
            pageCount = getPageCount();
            updatePaging();
            updateIndicator();
            if (opts.onPageSizeChange) {
                opts.onPageSizeChange.call(pageSize);
            }
        }
 
        function updateIndicator() {
	    if (opts.indicator) {
            	opts.indicator.val((pageIndex + 1) + "/" + pageCount);
	    }
        }
 
        function updatePaging() {
            var start = pageIndex * pageSize;
            var end = start + pageSize;
            var i = 0;
            var rows = getRows();
            rows.each(function() {
                if (i >= start && i < end) {
                    $(rows[i]).show();
                } else {
                    $(rows[i]).hide();
                }
                i++;
            });
        }
 
        init();
 
        return {
            changePage: function(moveTo) { changePage(moveTo - 1); },
            getPageSize: function() { return pageSize; },
            getPageIndex: function() { return pageIndex; }
        };
    };
})(jQuery);

var pager = $("#testTable").tablePager({
    firstBtn: $(".first"), // The element that pages to the first page
    prevBtn: $(".prev"), // The element that pages to the previous page
    nextBtn: $(".next"), // The element that pages to the next page
    lastBtn: $(".last"), // The element that pages to the last page
    indicator: $(".curpage"), // The input element that stores the current page (i.e. "1/5")
    sizeSelect: $(".pagesize"), // The select element that indicates the current page size
    pageSize: 5, // The initial page size
    onPageChange: function(newIndex) { alert(newIndex); }, // Page change callback
    onPageSizeChange: function(newSize) { alert(newSize); } // Page size change callback
});
 
pager.changePage(2); // Causes the page to change from outside the plugin
var pageIndex = pager.getPageIndex(); // Returns the current page index
var pageSize = pager.getPageSize(); // Returns the current page size

<span class="first">First</span>&nbsp;&nbsp;
<span class="prev">Prev</span>&nbsp;&nbsp;
<span class="next">Next</span>&nbsp;&nbsp;
<span class="last">Last</span>
<br><br>
<input type="text" class="curpage" />&nbsp;&nbsp;
<select class="pagesize">
    <option value="5">5</option>
    <option value="10">10</option>
    <option value="20">20</option>
</select>

public class CompressAttribute : ActionFilterAttribute {
 
        public override void OnActionExecuting(ActionExecutingContext filterContext) {
 
            var encodingsAccepted = filterContext.HttpContext.Request.Headers["Accept-Encoding"];
            if (string.IsNullOrEmpty(encodingsAccepted)) return;
 
            encodingsAccepted = encodingsAccepted.ToLowerInvariant();
            var response = filterContext.HttpContext.Response;
 
            if (encodingsAccepted.Contains("deflate")) {
                response.AppendHeader("Content-encoding", "deflate");
                response.Filter = new DeflateStream(response.Filter, CompressionMode.Compress);
            } else if (encodingsAccepted.Contains("gzip")) {
                response.AppendHeader("Content-encoding", "gzip");
                response.Filter = new GZipStream(response.Filter, CompressionMode.Compress);
            }
        }
    }

[Compress]
public class ThingController : Controller { ... }

public class ThingController: Controller {
 
    [Compress]
    public ActionResult Index() { ... }
}

namespace DI {
 
    internal class InjectionBinder {
        public Type Abstract { get; set; }
        public Type Concrete { get; set; }
        public object[] CtorArgs { get; set; }
    }
 
    /// <summary>
    /// A lightweight dependency injection tool that supports constructor injection and HttpContext.Session caching.
    /// </summary>
    public static class Injector {
 
        private const string SessionBindingKey = "__InjectorBindings__";
        private const string SessionCacheKey = "__InjectorCache__";
 
        private static List<InjectionBinder> _bindings {
            get {
                if (HttpContext.Current.Session[SessionBindingKey] == null)
                    HttpContext.Current.Session[SessionBindingKey] = new List<InjectionBinder>();
                return (List<InjectionBinder>)HttpContext.Current.Session[SessionBindingKey];
            }
            set { HttpContext.Current.Session[SessionBindingKey] = value; }
        }
 
        private static List<KeyValuePair<Type, object>> _cache {
            get {
                if (HttpContext.Current.Session[SessionCacheKey] == null)
                    HttpContext.Current.Session[SessionCacheKey] = new List<KeyValuePair<Type, object>>();
                return (List<KeyValuePair<Type, object>>)HttpContext.Current.Session[SessionCacheKey];
            }
            set { HttpContext.Current.Session[SessionCacheKey] = value; }
        }
 
        /// <summary>
        /// Returns a concrete instance of the specified abstract type using the provided bindings and 
        /// attempts to satisfy that type's constructor arguments.
        /// </summary>
        /// <param name="abstractType">The abstract type of the object to initialize.</param>
        /// <returns></returns>
        public static object GetInstance(Type abstractType) {
 
            // Return the item from the cache if it's in there
            var cache = _cache.ToDictionary(o => o.Key, o => o.Value);
            if (cache.ContainsKey(abstractType))
                return cache[abstractType];
 
            // If the type is in the bindings, return the concrete
            var foundBinding = _bindings.Find(b => b.Abstract == abstractType);
            if (foundBinding != null)
                return Activator.CreateInstance(foundBinding.Concrete, foundBinding.CtorArgs);
 
            object obj = null;
            var ctors = abstractType.GetConstructors().ToList();
 
            // If the type has no constructor, then just create one
            if (ctors.Count == 0)
                return Activator.CreateInstance(abstractType);
 
            // If there are constructors, find one which takes arguments of the types we have binders for
            ctors.ForEach(c => {
                var prms = c.GetParameters().ToList();
                var args = new List<object>();
                var haveBindings = true;
                prms.ForEach(p => {
                    var binding = _bindings.Find(b => b.Abstract == p.ParameterType);
                    if (binding == null) { haveBindings = false; }
                    else { args.Add(Activator.CreateInstance(binding.Concrete, binding.CtorArgs)); }
                });
                if (haveBindings) { obj = Activator.CreateInstance(abstractType, args.ToArray()); }
            });
 
            return obj;
        }
 
        /// <summary>
        /// Returns a concrete instance of the specified abstract type using the provided bindings and 
        /// attempts to satisfy that type's constructor arguments.
        /// </summary>
        /// <typeparam name="TAbstract">The abstract type of the object to initialize.</typeparam>
        /// <returns></returns>
        public static TAbstract GetInstance<TAbstract>() where TAbstract : class {
            return GetInstance(typeof (TAbstract)) as TAbstract;
        }
 
        /// <summary>
        /// Creates a binding rule between an abstract type and a concrete type.
        /// </summary>
        /// <typeparam name="TAbstract">The abstract type for the binding.</typeparam>
        /// <typeparam name="TConcrete">The concrete type for the binding</typeparam>
        /// <param name="ctorArgs">The list of constructor arguments to use when initializing the instance of the concrete type.</param>
        public static void Bind<TAbstract, TConcrete>(object[] ctorArgs) {
            var binding = _bindings.Find(b => b.Abstract == typeof(TAbstract));
            if (binding != null) {
                binding.Concrete = typeof(TConcrete);
                binding.CtorArgs = ctorArgs;
            } else {
                _bindings.Add(new InjectionBinder {
                    Abstract = typeof(TAbstract),
                    Concrete = typeof(TConcrete),
                    CtorArgs = ctorArgs
                });
            }
        }
 
        /// <summary>
        /// Clears all Injector binding rules and empties the internal cache.
        /// </summary>
        public static void Kill() {
            HttpContext.Current.Session[SessionBindingKey] = null;
            HttpContext.Current.Session[SessionCacheKey] = null;
        }
    }
}

private static void BindInjectionContainer() {
    Injector.Kill(); // Clears out previously created bindings and empties the cache
 
    var currentClient = new Client(); // Doesn't matter...just an example
    var currentUser = new User();
    var currentCulture = "en-US";
 
    Injector.Bind<IClientRepository, ClientRepository>(new object[] { currentClient, currentCulture });
    Injector.Bind<IUserRepository, UserRepository>(new object[] { currentClient, currentCulture, currentUser });
    Injector.Bind<ISecurityRepository, SecurityRepository>(new object[] {});
}

var secRepo = Injector.GetInstance<ISecurityRepository>();