@@ -0,0 +1,57 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using uhttpsharp;
+using uhttpsharp.Handlers;
+
+namespace uhttpsharpdemo.Controllers
+{
+    public class JsonController
+    {
+        public class Question
+        {
+            public string TheQuestion { get; set; }
+        }
+        public JsonController(int id)
+        {
+        }
+
+        [HttpMethod(HttpMethods.Post)]
+        public Task<IControllerResponse> Post([FromBody] Question question)
+        {
+            return Response.Render(HttpResponseCode.Ok, question);
+        }
+    }
+    public class MyController
+    {
+        private readonly int _id;
+        public MyController(int id)
+        {
+            _id = id;
+        }
+        public MyController()
+        {
+        }
+
+        [HttpMethod(HttpMethods.Post)]
+        public Task<IControllerResponse> Post([FromPost("a")] MyRequest request, [FromHeaders("header")]string hello, [FromQuery("query")]string world)
+        {
+            return Response.Render(HttpResponseCode.Ok, null);
+        }
+
+        [Indexer]
+        public async Task<object> Get(IHttpContext context, int id)
+        {
+            return new MyController(id);
+        }
+    }
+    public class MyRequest
+    {
+        public int A { get; set; }
+    }
+    class DemoController
+    {
+    }
+}
@@ -52,6 +52,7 @@ private static void Main()
                 //httpServer.Use(new ListenerSslDecorator(new TcpListenerAdapter(new TcpListener(IPAddress.Loopback, 443)), serverCertificate));
 
                 //httpServer.Use(new SessionHandler<DateTime>(() => DateTime.Now));
+                httpServer.Use(new ControllerHandler(new JsonController(0), new JsonModelBinder(), new JsonView()));
                 httpServer.Use(new ExceptionHandler());
                 httpServer.Use(new ClassRouter(new MySuperHandler()));
                 httpServer.Use(new TimingHandler());
 
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
   <package id="log4net" version="2.0.3" targetFramework="net45" />
-  <package id="Newtonsoft.Json" version="5.0.8" targetFramework="net45" />
+  <package id="Newtonsoft.Json" version="6.0.3" targetFramework="net45" />
 </packages>
@@ -42,8 +42,9 @@
     <Reference Include="log4net">
       <HintPath>..\packages\log4net.2.0.3\lib\net40-full\log4net.dll</HintPath>
     </Reference>
-    <Reference Include="Newtonsoft.Json">
-      <HintPath>..\packages\Newtonsoft.Json.5.0.8\lib\net45\Newtonsoft.Json.dll</HintPath>
+    <Reference Include="Newtonsoft.Json, Version=6.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\packages\Newtonsoft.Json.6.0.3\lib\net45\Newtonsoft.Json.dll</HintPath>
     </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
 
@@ -0,0 +1,18 @@
+using System;
+
+namespace uhttpsharp.Attributes
+{
+    public class HttpMethodAttribute : Attribute
+    {
+        private readonly HttpMethods _httpMethod;
+        public HttpMethodAttribute(HttpMethods httpMethod)
+        {
+            _httpMethod = httpMethod;
+        }
+
+        public HttpMethods HttpMethod
+        {
+            get { return _httpMethod; }
+        }
+    }
+}
@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using uhttpsharp.ModelBinders;
+
+namespace uhttpsharp.Attributes
+{
+    internal interface IModelBinding
+    {
+        T Get<T>(IHttpContext context, IModelBinder binder);
+    }
+
+    internal class FromBodyAttribute : Attribute, IModelBinding
+    {
+        public T Get<T>(IHttpContext context, IModelBinder binder)
+        {
+            return binder.Get<T>(context.Request.Post.Raw);
+        }
+    }
+
+    public class FromPostAttribute : PrefixAttribute
+    {
+        public FromPostAttribute(string prefix = null)
+            : base(prefix)
+        {
+        }
+        public override T Get<T>(IHttpContext context, IModelBinder binder)
+        {
+            return binder.Get<T>(context.Request.Post.Parsed, Prefix);
+        }
+    }
+
+    public class FromQueryAttribute : PrefixAttribute
+    {
+        public FromQueryAttribute(string prefix)
+            : base(prefix)
+        {
+        }
+        public override T Get<T>(IHttpContext context, IModelBinder binder)
+        {
+            return binder.Get<T>(context.Request.QueryString, Prefix);
+        }
+    }
+
+    public class FromHeadersAttribute : PrefixAttribute
+    {
+        public FromHeadersAttribute(string prefix)
+            : base(prefix)
+        {
+        }
+
+        public override T Get<T>(IHttpContext context, IModelBinder binder)
+        {
+            return binder.Get<T>(context.Request.Headers, Prefix);
+        }
+    }
+
+    public abstract class PrefixAttribute : Attribute, IModelBinding
+    {
+        private readonly string _prefix;
+
+        public PrefixAttribute(string prefix)
+        {
+            _prefix = prefix;
+        }
+
+        public bool HasPrefix
+        {
+            get { return !string.IsNullOrEmpty(_prefix); }
+        }
+
+        public string Prefix
+        {
+            get { return _prefix; }
+        }
+
+        public abstract T Get<T>(IHttpContext context, IModelBinder binder);
+    }
+}
@@ -115,13 +115,17 @@ private Func<IHttpContext, IHttpRequestHandler, string, Task<IHttpRequestHandler
             {
                 return null;
             }
+            return CreateIndexerFunction<IHttpRequestHandler>(arg, indexer);
+        }
+        internal static Func<IHttpContext, T, string, Task<T>> CreateIndexerFunction<T>(Type arg, MethodInfo indexer)
+        {
             var parameterType = indexer.GetParameters()[1].ParameterType;
 
             var httpContext = Expression.Parameter(typeof(IHttpContext));
-            var inputHandler = Expression.Parameter(typeof(IHttpRequestHandler));
+            var inputHandler = Expression.Parameter(typeof(T));
             var inputObject = Expression.Parameter(typeof(string));
 
-            var tryParseMethod = parameterType.GetMethod("TryParse", new[] { typeof(string), parameterType.MakeByRefType() });
+            var tryParseMethod = parameterType.GetMethod("TryParse", new[] {typeof(string), parameterType.MakeByRefType()});
 
             Expression body;
 
@@ -130,11 +134,11 @@ private Func<IHttpContext, IHttpRequestHandler, string, Task<IHttpRequestHandler
                 var handlerConverted = Expression.Convert(inputHandler, arg);
                 var objectConverted =
                     Expression.Convert(
-                        Expression.Call(typeof(Convert).GetMethod("ChangeType", new[] { typeof(object), typeof(Type) }), inputObject,
+                        Expression.Call(typeof(Convert).GetMethod("ChangeType", new[] {typeof(object), typeof(Type)}), inputObject,
                             Expression.Constant(parameterType)), parameterType);
 
                 var indexerExpression = Expression.Call(handlerConverted, indexer, httpContext, objectConverted);
-                var returnValue = Expression.Convert(indexerExpression, typeof(IHttpRequestHandler));
+                var returnValue = Expression.Convert(indexerExpression, typeof(T));
 
                 body = returnValue;
             }
@@ -146,23 +150,25 @@ private Func<IHttpContext, IHttpRequestHandler, string, Task<IHttpRequestHandler
                 var objectConverted = inputConvertedVar;
 
                 var indexerExpression = Expression.Call(handlerConverted, indexer, httpContext, objectConverted);
-                var returnValue = Expression.Convert(indexerExpression, typeof(Task<IHttpRequestHandler>));
-                var returnTarget = Expression.Label(typeof(Task<IHttpRequestHandler>));
-                var returnLabel = Expression.Label(returnTarget, Expression.Convert(Expression.Constant(null), typeof(Task<IHttpRequestHandler>)));
+                var returnValue = Expression.Convert(indexerExpression, typeof(Task<T>));
+                var returnTarget = Expression.Label(typeof(Task<T>));
+                var returnLabel = Expression.Label(returnTarget,
+                    Expression.Convert(Expression.Constant(null), typeof(Task<T>)));
                 body =
                     Expression.Block(
-                    new[] { inputConvertedVar },
+                        new[] {inputConvertedVar},
                         Expression.IfThen(
-                        Expression.Call(tryParseMethod, inputObject,
-                            inputConvertedVar),
-                        Expression.Return(returnTarget, returnValue)
-                        ),
+                            Expression.Call(tryParseMethod, inputObject,
+                                inputConvertedVar),
+                            Expression.Return(returnTarget, returnValue)
+                            ),
                         returnLabel);
             }
 
-
-            return Expression.Lambda<Func<IHttpContext, IHttpRequestHandler, string, Task<IHttpRequestHandler>>>(body, httpContext, inputHandler,
-                inputObject).Compile();
+            return
+                Expression.Lambda<Func<IHttpContext, T, string, Task<T>>>(body, httpContext,
+                    inputHandler,
+                    inputObject).Compile();
         }
         private MethodInfo GetIndexer(Type arg)
         {