.Nettuce

public static class QueryableExtensions
    {
        public static IQueryable<T> Filter<T>(this IQueryable<T> queryable, IEnumerable<KeyValuePair<string, string>> filters) where T : class
        {
            foreach (var filter in filters)
            {
                var propertyName = typeof(T).GetProperties().Select(x => x.Name).SingleOrDefault(x => x.ToLower() == filter.Key.ToLower());
                if (propertyName.IsNullOrWhiteSpace()) continue;
                var parameterExpression = Expression.Parameter(typeof(T));
                var propertyExpression = Expression.Property(parameterExpression, propertyName);
                var toStringCallExpression = Expression.Call(propertyExpression, typeof(T).GetMethod("ToString"));
                var toLowerCallExpression = Expression.Call(toStringCallExpression, typeof(string).GetMethod("ToLower", Type.EmptyTypes));
                var constantExpression = Expression.Constant(filter.Value.ToLower());
                var equalExpression = Expression.Equal(toLowerCallExpression, constantExpression);
                var methodCallExpression = Expression.Call(typeof(Queryable), "Where", new[] { typeof(T) }, queryable.Expression, Expression.Lambda<Func<T, bool>>(equalExpression, new[] { parameterExpression }));
                queryable = queryable.Provider.CreateQuery(methodCallExpression) as IQueryable<T>;
            }
            return queryable;
        }
    }

        void UploadStream(string fileName, Stream stream, string uri, string authorizationHeader)
        {
            var webRequest = WebRequest.Create(uri);
            var boundary = DateTime.Now.Ticks.ToString();
            webRequest.ContentType = "multipart/form-data; boundary=" + boundary;
            webRequest.Method = HttpMethod.Post;
            webRequest.Headers["Authorization"] = authorizationHeader;
            var memoryStream = new MemoryStream();
            stream.CopyTo(memoryStream);
            var byteArray = memoryStream.ToArray();
            var postData = new MemoryStream();
            const string newLine = "\r\n";
            var sw = new StreamWriter(postData);
            sw.Write("--" + boundary + newLine);
            sw.Write("Content-Disposition: form-data;name=\"{0}\";filename=\"{1}\"{2}", "upload", fileName, newLine + newLine);
            sw.Flush();
            postData.Write(byteArray, 0, byteArray.Length);
            sw.Write(newLine);
            sw.Write("--{0}--{1}", boundary, newLine);
            sw.Flush();
            webRequest.ContentLength = postData.Length;
            using (var requestStream = webRequest.GetRequestStream()) postData.WriteTo(requestStream);
            postData.Close();
        }

 Create the validation behavior

    public class ValidationBehaviour<T> : BasicBehavior where T : class
    {
        private readonly IContinuationDirector continuationDirector;
        private readonly BehaviorGraph behaviorGraph;
        private readonly IFubuRequest fubuRequest;
        private readonly IValidator<T> validator;
 
        public ValidationBehaviour(IContinuationDirector continuationDirector, BehaviorGraph behaviorGraph, IFubuRequest fubuRequest, IValidator<T> validator)
            : base(PartialBehavior.Ignored)
        {
            this.continuationDirector = continuationDirector;
            this.behaviorGraph = behaviorGraph;
            this.fubuRequest = fubuRequest;
            this.validator = validator;
        }
 
        protected override DoNext performInvoke()
        {
            var inputModel = fubuRequest.Get<T>();
            var validationResult = validator.Validate(inputModel);
            if (validationResult.IsValid)
            {
                return DoNext.Continue;
            }
            fubuRequest.Set(validationResult);
            var actionCall = GetActionCallFromBehaviorGraph();
            continuationDirector.TransferToCall(actionCall);
            return DoNext.Stop;
        }
 
        private ActionCall GetActionCallFromBehaviorGraph()
        {
            return behaviorGraph
                .Behaviors
                .Where(chain => chain.FirstCall().HandlerType.Namespace == typeof(T).Namespace && chain.Route.AllowedHttpMethods.Contains(WebRequestMethods.Http.Get))
                .Select(chain => chain.FirstCall())
                .First();
        }
    }

Tell FubuMvc when to use the validation behavior

    public class ValidationConfiguration : IConfigurationAction
    {
        public void Configure(BehaviorGraph graph)
        {
            graph.Actions()
            .Where(x => x.HasInput && ObjectFactory.Model.HasDefaultImplementationFor(typeof(IValidator<>).MakeGenericType(x.InputType())))
            .Each(x => x.AddBefore(new Wrapper(typeof(ValidationBehaviour<>).MakeGenericType(x.InputType()))));
        }
    }

Add an HtmlConvention to display the error messages

            HtmlConvention(x => x.Editors.Always.Modify((request, tag) =>
                   {
                       var fubuRequest = request.Get<IFubuRequest>();
                       var validationResult = fubuRequest.Get<ValidationResult>();
                       if (validationResult.IsValid) return;
                       var ul = new HtmlTag("ul");
                       var liTags = validationResult.Errors.Where(error => error.PropertyName == request.Accessor.InnerProperty.Name).Select(vf => new HtmlTag("li", li => li.Text(vf.ErrorMessage)));
                       ul.Append(liTags);
                       tag.Append(ul);
                   }));

Apply the Validation Configuration

ApplyConvention<ValidationConfiguration>();

Wire up the IContinuationDirector and Validators

            FubuApplication.For<ConfigureFubuMvc>().StructureMapObjectFactory(container =>
                                           {
                                               container.Scan(scanner =>
                                                      {
                                                          scanner.TheCallingAssembly();
                                                          scanner.WithDefaultConventions();
                                                          scanner.ConnectImplementationsToTypesClosing(typeof(IValidator<>));
                                                      });
                                               container.For<IContinuationDirector>().Use<ContinuationHandler>();
                                           })
                .Bootstrap(RouteTable.Routes);

Download the NuGet command line from here:

http://nuget.codeplex.com/releases/view/58939

Then run from the folder that contains the Packages folder:

for /f "delims=" %i in ('dir /s /b packages.config') do nuget i "%i" -o Packages

    public class OAuthSignatureGenerator
    {
        private const string OAuthConsumerKey = "oauth_consumer_key";
        private const string OAuthNonce = "oauth_nonce";
        private const string OAuthSignatureMethod = "oauth_signature_method";
        private const string OAuthTimestamp = "oauth_timestamp";
        private const string OAuthToken = "oauth_token";
        private const string OAuthVersion = "oauth_version";
 
        public enum SignatureMethod
        {
            Plaintext,
            HmacSha1
        }
 
        public static string GenerateSignature(Uri uri, string httpMethod, string consumerKey, string consumerSecret, string nonce, string timestamp, SignatureMethod signatureMethod, string token = null, string tokenSecret = null, string version = null)
        {
            if (signatureMethod == SignatureMethod.Plaintext) return HttpUtility.UrlEncode(string.Format("{0}&{1}", consumerSecret, tokenSecret));
            var parameters = ConvertQueryStringToListOfKvp(uri.Query);
            AddParameter(parameters, OAuthConsumerKey, consumerKey);
            AddParameter(parameters, OAuthNonce, nonce);
            AddParameter(parameters, OAuthSignatureMethod, "HMAC-SHA1");
            AddParameter(parameters, OAuthTimestamp, timestamp);
            if (!string.IsNullOrEmpty(token)) AddParameter(parameters, OAuthToken, token);
            if (!string.IsNullOrWhiteSpace(version)) AddParameter(parameters, OAuthVersion, version);
            parameters.Sort((x, y) => x.Key == y.Key ? string.Compare(x.Value, y.Value) : string.Compare(x.Key, y.Key));
 
            var normalizedUrl = string.Format("{0}://{1}{2}{3}", uri.Scheme, uri.Host, (uri.Scheme == "http" && uri.Port == 80) || (uri.Scheme == "https" && uri.Port == 443) ? null : ":" + uri.Port, uri.AbsolutePath);
            var normalizedRequestParameters = string.Join(null, parameters.Select(x => "&" + x.Key + "=" + x.Value)).TrimStart('&');
 
            var signatureData = string.Format("{0}&{1}&{2}", httpMethod.ToUpper(), UrlEncode(normalizedUrl), UrlEncode(normalizedRequestParameters));
 
            return ComputeHash(consumerSecret, tokenSecret, signatureData);
        }
 
        private static List<KeyValuePair<string, string>> ConvertQueryStringToListOfKvp(string queryString)
        {
            return Regex.Matches(queryString, @"(\w+)=.*?(?:&|$)").Cast<Match>().Select(x => x.Value.TrimEnd('&').Split('=')).Select(x => new KeyValuePair<string, string>(x[0], x[1])).ToList();
        }
 
        private static void AddParameter(ICollection<KeyValuePair<string, string>> parameters, string key, string value)
        {
            parameters.Add(new KeyValuePair<string, string>(key, value));
        }
 
        private static string ComputeHash(string consumerSecret, string tokenSecret, string signatureData)
        {
            var hash = new HMACSHA1 { Key = Encoding.ASCII.GetBytes(string.Format("{0}&{1}", UrlEncode(consumerSecret), string.IsNullOrEmpty(tokenSecret) ? string.Empty : UrlEncode(tokenSecret))) }.ComputeHash(Encoding.ASCII.GetBytes(signatureData));
            return Convert.ToBase64String(hash);
        }
 
        private static string UrlEncode(string value)
        {
            if (string.IsNullOrWhiteSpace(value)) return string.Empty;
            const string unreservedChars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_.~";
            return value.Select(x => x.ToString()).Aggregate((x, y) => x + (unreservedChars.Contains(y.ToString()) ? y : HttpUtility.UrlEncode(y).ToUpper()));
        }
    }

        public static NameValueCollection HeaderNameValueCollection(this string header)
        {
            var nameValueCollection = new NameValueCollection();
            Regex.Matches(header, @"(\w+)="".*?""").Cast<Match>().Select(x => x.Value.TrimEnd('"').Split(new[] { "=\"" }, StringSplitOptions.None)).ForEach(x => nameValueCollection.Add(x[0], x.Length == 2 ? x[1] : string.Empty));
            return nameValueCollection;
        }

    public static class NameValueCollectionExtension
    {
        public static bool CollectionEquals(this NameValueCollection nameValueCollection1, NameValueCollection nameValueCollection2)
        {
            return nameValueCollection1.ToKeyValue().SequenceEqual(nameValueCollection2.ToKeyValue());
        }
 
        private static IEnumerable<object> ToKeyValue(this NameValueCollection nameValueCollection)
        {
            return nameValueCollection.AllKeys.OrderBy(x => x).Select(x => new {Key = x, Value = nameValueCollection[x]});
        }
    }

A .NET implementation of the RealEx remote integration API

https://github.com/JonCanning/RealEx.NET

This has been done a few times, here's my attempt:

         public static MvcHtmlString CheckBoxListFor<TModel, TValue>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TValue>> expression) where TValue : IEnumerable<object>
        {
            var name = expression.Body is ParameterExpression ? ((ParameterExpression)expression.Body).Name : ((MemberExpression)expression.Body).Member.Name;
            var sb = new StringBuilder("<ul class='checkboxlist'>");
            var values = ((IEnumerable<object>)expression.Compile().Invoke(htmlHelper.ViewData.Model)).Select(x => x.ToString());
            foreach (var value in values)
            {
                sb.Append(string.Format("<li>{0} <input type='checkbox' name='{1}' value='{2}' /></li>", value, name, value));
            }
            return new MvcHtmlString(sb.Append("</ul>").ToString());
        }

I included a ParameterExpression just in case the model is an IEnumerable<T> so if your view looks like this:

@model IEnumerable<string>
@using (Html.BeginForm())
{
    @Html.CheckBoxListFor(items => items)
    <input type="submit" value="submit" />
}

Your action can do this:

        [HttpPost]
        public ActionResult Index(IEnumerable<string> items)
        {
            return View("Result", items);
        }

There's more! Needed to adapt this today to allow for a separate name and value:

  public static MvcHtmlString CheckBoxListFor<TModel, TItem>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, IEnumerable<TItem>>> listExpression, Func<TItem, object> checkboxName, Func<TItem, object> checkboxValue)
        {
            var listName = listExpression.Body is ParameterExpression ? ((ParameterExpression)listExpression.Body).Name : ((MemberExpression)listExpression.Body).Member.Name;
            var sb = new StringBuilder("<ul class='checkboxlist'>");
            foreach (var value in listExpression.Compile().Invoke(htmlHelper.ViewData.Model))
            {
                sb.Append(string.Format("<li>{0} <input type='checkbox' name='{1}' value='{2}' /></li>", checkboxName.Invoke(value), listName, checkboxValue.Invoke(value)));
            }
            return new MvcHtmlString(sb.Append("</ul>").ToString());
        }

Just so I don't forget, again, it's as simple as this:

Controller:

public class HomeController : Controller
    {
        public ActionResult Index()
        {
            return View(new []{"one", "two", "three"});
        }
 
        [HttpPost]
        public ActionResult Index(IEnumerable<string> items)
        {
            return View("Result", items);
        }
    }

View:

@model IEnumerable<string>
@using (Html.BeginForm())
{
    foreach (var item in Model)
    {
    @item <input type="checkbox" name="items" value="@item" />
    }
    <input type="submit" value="submit" />
}