// This represents your base data call, 
// perhaps from a repository.
IQueryable<T> data = GetStuff<T>();

// Now we want to only pick out the things we want.
var exclusive = data.Where(x => x.AccessLevel > 2 && 
   x.IsValid && 
   x.Something != 5 && 
   x.SomethingElse > 2);

Now perhaps what this is doing (the above convoluted Where clause) is actually reused a lot throughout your system. Let’s assume that is so, for the sake of the rest of this post, and also that it is the logic for granting access to something, thus giving us and future programmers some contextual meaning.

If the above properties are common across all the types that inherit or implement T, then we can easily create a little extension method to make this much neater.

public static class ext{
	public static IQueryable<T> HasAccess<T>(this IQueryable<T> query) 
           where T : CommonThing {
	   return query.Where(x => x.AccessLevel > 2 && 
              x.IsValid && 
              x.Something != 5 && 
              x.SomethingElse > 2);
	}
}

// Now we can, for all T types, do the very simple, meaningful 
// and hard-to-screw-up:
var exclusive = data.HasAccess();

So, there we have a small example to just wrap a convoluted IQueryable method into a simple reusable one that has an obvious meaning.
Big deal?
Ok, what if not everything can so simply inherit from T?
In relational systems you often get at least a little complexity (or a lot!) of nested entities/tables when trying to relate all of those T things back to whatever we’re trying to grant T access to (these complexities are usually due to the system trying to mimic real life). At this point we can’t say those things inherit from T anymore.

Take the allegory of a Person, a Key, and a Car. It’s natural think of a Person and a Key that both could both have access to a given Car, but the Person technically needs the Key to actually gain access.
Only the Key, in this example, is actually directly linked to a Car (via a foreign key in a table perhaps).
But throughout our code we want to use a function like .HasAccess() if we can, for both the Key and the Person because that makes sense, it could also provide a hint at the least, or a constraint at the most for how Person and Key can be used in the system.
Ok, so to do this let’s draw up a few simple classes to make the code clear.

class Key {
   string KeyCode { get;set; }
}
class Car {
   string KeyCode { get;set; } 
}
class Person {
   Key Key { get;set; }
}

So, with this example and scenario we have a thing we want access to (a Car), and we know how to gain access (with the matching KeyCode from the right Key – but the requirements could be anything of course).
Therefore we can have an extension method like the below, without having a common-class constraint on T:

public static IQueryable<T> HasAccessToCar<T>(this IQueryable<T> query, 
   Car car, 
   Expression<Func<T, string>> keyCode) {
      // ...
}

I will fill in the meat of this function, but first the keyCode parameter requires explanation, especially as it differs from the first param – a plain old Car type.
The fact that it’s an Expression<> signifies that we can hopefully use this method without triggering any LINQ – SQL execution prematurely. Indeed one of the cares that should be taken in the world of LINQ is not to accidentally convert our IQueryables to some other kind of (enumerable) type and therefore cause the SQL to execute.
(Part of what we’re trying to do here still is to just build up the relevant .Where() clauses on our IQueryable expression before it ends up being executed – this is important in situations where you have a potential large amount of data you’re dealing with, you don’t want to pull back more than you really want).
The important part here is that it’s asking for an expression to explain how to get a keycode string from T. If we know the keycode, then we can easily do a compare of it with the Car‘s code, and thus grant or deny access. Therefore the method itself (unlike our initial simple example) doesn’t need to know anything about the T type.

Now, because the car parameter is just a Car, it means that we obviously need an instance of one first. There’s an assumption in the design of this function that you already have one, and you’re going to use this function to find out what other T things can be viewed/listed in relation to the car. (In real world applications, the Car concept would be replaced by some overarching thing that you often want to see data listed against).
Ok, how to use this extension:

// Get the Car from somewhere
var aCar = new Car(...);

// All keys and persons retrieved from somewhere
IQueryable<Key> keys = getKeys();
IQueryable<Person> people = getPeople();

// Limit our access with the same function for 
// different generic T types.
IQueryable<Key> keysWithAccess = 
   keys.HasAccessToCar(aCar, x => x.KeyCode);
IQueryable<Person> peopleWithAccess = 
    people.HasAccessToCar(aCar, x => x.Key.KeyCode);

So, we have achieved a structured way to filter stuff by whether it has access to a Car or not (as long as it can be linked up to a Key instance’s KeyCode somehow via an expression), and the generic T type can be anything. Cool :).

Now back to the last thing, how do we take an Expression<Func<T, string>> type and apply that to an existing IQueryable ?

public static IQueryable<T> HasAccessToCar<T>(this IQueryable<T> query, 
   Car car, 
   Expression<Func<T, string>> keyCode) {
      
      var codeConst = Expression.Constant(car.KeyCode, typeof(string));

      // This will generate an expression predicate 
      // that will do an equality comparison between the car's
      // KeyCode and what the supplied keyCode would give us.
      Expression<Func<T, bool>> hasAccess = 
         Expression.Lambda<Func<T, bool>>(
            Expression.Equal(keyCode.Body, codeConst),
            keyCode.Parameters);

      // Finally just do this.
      return query.Where(hasAccess);
}

So, at the end of the day, what we've done could be called business logic, where it would not be unusual to have verbose descriptive meaningful function names (like I've tried to have here) . Although these extension methods could just be ordinary methods placed at your DAL/repository level (or whatever you want to call it) should you wish to implement it like that.

However this idea is implemented, the trick is in the dynamic expression building. It is because of this that we can maintain our unexecuted expression tree and also create meaningful function names without upsetting the LINQ-SQL conversion.

public abstract class BaseController : ApiController {
    protected async Task<T> TimeoutAsyncTask<T>(Func<T> task, Func<T> timeOutTask, int timeoutMilliseconds) 
    {
        Task timeout = TimeoutTask(timeoutMilliseconds);
        T result = default(T);
        CancellationTokenSource cts = new CancellationTokenSource();
        HttpContext current = HttpContext.Current; //preserve context
        Task real = Task.Run(() => {
            HttpContext.Current = current;
            result = task.Invoke();
        }, cts.Token);
        Task finishedTask = await Task.WhenAny(timeout, real); 
        if (finishedTask == timeout){
            //timeout 
            HttpContext.Current = current;
            cts.Cancel();
            result = timeOutTask.Invoke();
        }
        return result;
    }

    private async Task TimeoutTask(int timeoutValue)
    {
        await Task.Delay(timeoutValue);
    }
}

So, to use this you could create a controller based from this (or just take the methods), and then call TimeoutAsyncTask(..) supplying two lambda functions to run. The first being the thing that you expect may take some time, and the 2nd being the callback function to run should the quantity of milliseconds pass before your task is complete. Either way, this async function will wait until either the supplied task is finished, or the timeout occurs (if called with await of course).

var anon = new { ymous="yep", class="ok" };
Dictionary<string, object> dictionary = new Dictionary<string, object>();
anon.GetType().GetProperties().ToList().ForEach(x => dictionary.Add(x.Name, x.GetValue(anon)));

http://www.webtoolkit.info/javascript-base64.html

But you cannot use the result reliably as part of a url, should you wish to do so.
In .net you have

HttpServerUtility.UrlTokenEncode

which just does a base64 and then swaps out certain characters so you can.
Here are two small mods to the above javascript to do the same:

encodeUrlToken: function (input) {
    var ret = Base64.encode(input).replace(/\+/g, "-").replace(/\//g, "_");
    if (ret.length == 0)
        return "";
    var noPadding = ret.replace(/=+$/, ""); 
    return noPadding + (ret.length - noPadding.length).toString();
},

decodeUrlToken: function (input) {
    var ec = parseInt(input.substring(input.length - 1));
    var temp = input.replace(/\-/g, "+").replace(/\_/g, "/");
    temp = temp.substring(0, temp.length - 1); 
    return Base64.decode(temp + "===".substring(0, ec));
},

public class YuiCompressor : IHttpHandler
{
    private readonly TimeSpan _cacheDuration = TimeSpan.FromHours(12); 
    private const string CSS = ".css";
    private const string JS = ".js";

    public class YuiCompressorCache
    { 
        public YuiCompressorCache(string data, string contentType, int code)
        {
            Data = data;
            ContentType = contentType;
            Code = code;
        }
        public string Data { get; set; }
        public string ContentType { get; set; }
        public int Code { get; set; }
    }

    public YuiCompressor(){ }


    public void ProcessRequest(HttpContext context)
    {  
        context.Response.ContentEncoding = System.Text.Encoding.Default;         
        string raw = context.Request.RawUrl.ToLower();
        writeCompressedFile(context, raw);
    }

    public bool IsReusable
    {
        get
        {
            return true;
        }
    }

    private void writeCompressedFile(HttpContext context, string rawUrl)
    { 
        string cn = "YuiCompressor_" + rawUrl;
        YuiCompressorCache ycc = (YuiCompressorCache)context.Cache[cn];
        if (ycc == null)
        {
            string filePath = context.Server.MapPath(rawUrl);
            string output = string.Empty;
            string contentType = "text/plan";
            int responseCode = 200;
            CacheDependency cd = null;
            try
            {
                output = File.ReadAllText(filePath);
                cd = new CacheDependency(filePath);
                if (rawUrl.IndexOf(CSS, 0, StringComparison.CurrentCultureIgnoreCase) == rawUrl.Length - CSS.Length)
                {
                    CssCompressor cssc = new CssCompressor();
                    output = cssc.Compress(output) + Environment.NewLine;
                    contentType = "text/css";
                }
                else if (rawUrl.IndexOf(JS, 0, StringComparison.CurrentCultureIgnoreCase) == rawUrl.Length - JS.Length)
                {
                    JavaScriptCompressor jsc = new JavaScriptCompressor();
                    output = jsc.Compress(output) + Environment.NewLine;
                    contentType = "application/x-javascript";
                }
                else
                {
                    throw new Exception("Bad Extension");
                }
                //successfully compressed 
            }
            catch (System.IO.FileNotFoundException fnfe) //iis prevents this anyway
            {
                responseCode = 404;
                contentType = "text/html";
                output = string.Empty; 
            }
            catch (EcmaScript.NET.EcmaScriptRuntimeException esre)
            {
                //failure to deal with compression, output plain text
                contentType = "text/plain";   
            } 
            finally
            {
                ycc = new YuiCompressorCache(output, contentType, responseCode);

                Random r = new Random();
                context.Cache.Insert(cn, ycc, cd, Cache.NoAbsoluteExpiration, _cacheDuration.Add(TimeSpan.FromMinutes(r.Next(10)))); 
                //so it doesn't happen all at once
            }
        }
        context.Response.StatusCode = ycc.Code;
        context.Response.ContentType = ycc.ContentType;
        context.Response.Write(ycc.Data); 
    }
}

The above code will load each .js or .css file as it is requested and parse it through the compiler before it returns the compressed string, but not before it is cached for next use.
Should it fail to compress something, it will respond with the original content.
For this to work you also need to add this to your webconfig:

<handlers>
  <add name="YuiCompressorJS" verb="*" path="*.js" type="YuiCompressor" />
  <add name="YuiCompressorCSS" verb="*" path="*.css" type="YuiCompressor" />
</handlers>

Care should be taken with the ‘path’ parameters of these handlers as anything that passes through this will end up stored in memory as cache.

Edit:
http://blogs.msdn.com/b/rickandy/archive/2012/08/14/adding-bundling-and-minification-to-web-forms.aspx

This is what that looks like.