public object Bind(Type type, IBindingContext context)
        {
            var model = Activator.CreateInstance(type);
            Bind(type, model, context);

            return model;
        }

        public BoundExpression GetOrCreateBoundExpression(IBindingContext binder, BoundExpressionOptions options)
        {
            Require.NotNull(binder, "binder");
            Require.NotNull(options, "options");

            var key = new CacheKey(
                _dynamicExpression.ParseResult.Identifiers,
                !DynamicExpression.IsLanguageCaseSensitive(_dynamicExpression.Language),
                binder,
                options
            );

            lock (_syncRoot)
            {
                BoundExpression boundExpression;

                if (!_cache.TryGetValue(key, out boundExpression))
                {
                    boundExpression = new BoundExpression(
                        _dynamicExpression,
                        key.OwnerType,
                        key.Imports,
                        key.IdentifierTypes,
                        key.Options
                    );

                    _cache.Add(key, boundExpression);
                }

                return boundExpression;
            }
        }

        public object Bind(Type type, IBindingContext context)
        {
            var instance = Activator.CreateInstance(type);
            Bind(type, instance, context);

            return instance;
        }

        public static object GetViewForViewModel(this IDataTemplate template, IBindingContext context, object viewModel, Func<object, object> getConvertView, params object[] args)
        {
            if (template != null)
            {
                var cell = getConvertView(template.Id);
                if (cell != null && template.ViewType != null)
                {
                    if (!template.ViewType.IsAssignableFrom(cell.GetType()))
                    {
                        cell = null;
                    }
                }

                if (cell == null)
                {
                    cell = template.CreateView(args);
                }

                template.InitializeView(cell);
                context.Bindings.ClearBindings(cell);
                template.BindViewModel(context, viewModel, cell);
                return cell;
            }

            return null;
        }

        public object Bind(Type inputModelType, IBindingContext context)
        {
            //we determine the type by sniffing the ctor arg
            var entityType = inputModelType
                .GetConstructors()
                .Single(x => x.GetParameters().Count() == 1)
                .GetParameters()
                .Single()
                .ParameterType;

            var entity = tryFindExistingEntity(entityType, context)
                ?? createNewEntity(entityType, context);

            var model = (EditEntityModel)Activator.CreateInstance(inputModelType, entity);

            context.BindProperties(model);

            // Get the binding errors from conversion of the EditEntityModel
            context.Problems.Each(x =>
            {
                model.Notification.RegisterMessage(x.Property, FastPackKeys.PARSE_VALUE);
            });

            return model;
        }

 private void populate(Type type, IBindingContext context)
 {
     _typeCache.ForEachProperty(type, prop =>
     {
         _propertyBinders.BinderFor(prop).Bind(prop, context);
     });
 }

	public static Game NewGame(IBindingContext context)
	{
		WorldLogicCoordinateTransform transformer = new WorldLogicCoordinateTransform(0.32f,10,10);
		var boardView = context.Get<BoardView> (InnerBindingNames.Empty,10,10,transformer);

		return new Game(boardView);
	}

        public void Bind(PropertyInfo property, IBindingContext context)
        {
            var type = property.PropertyType;
            var itemType = type.GetGenericArguments()[0];
            if (type.IsInterface)
            {
                type = _collectionTypeProvider.GetCollectionType(type, itemType);
            }

            object collection = Activator.CreateInstance(type);
            var collectionType = collection.GetType();

            Func<object, bool> addToCollection = obj =>
                {
                    if (obj != null)
                    {
                        var addMethod = _addMethods[collectionType];
                        addMethod.Invoke(collection, new[] {obj});
                        return true;
                    }
                    return false;
                };

            var formatString = property.Name + "[{0}]";

            int index = 0;
            string prefix;
            do
            {
                prefix = formatString.ToFormat(index);
                index++;
            } while (addToCollection(context.BindObject(prefix, itemType)));

            property.SetValue(context.Object, collection, null);
        }

 public override void Bind(PropertyInfo property, IBindingContext context)
 {
     context.Service<IRequestHeaders>().Value<string>(_headerName, val =>
     {
         property.SetValue(context.Object, val, null);
     });
 }

        public object Bind(Type type, IBindingContext context)
        {
            var entityType = type.GetConstructors().Single(x => x.GetParameters().Count() == 1).GetParameters().Single().ParameterType;

            // This is our convention.
            var prefix = entityType.Name;
            var prefixedContext = context.PrefixWith(prefix);

            DomainEntity entity = tryFindExistingEntity(context, prefixedContext, entityType) ?? createNewEntity(entityType, prefixedContext);

            var model = (EditEntityModel)Activator.CreateInstance(type, entity);

            // Get the binding errors from conversion of the Entity
            prefixedContext.Problems.Each(x =>
            {
                model.Notification.RegisterMessage(x.Properties.Last(), FastPackKeys.PARSE_VALUE);
            });

            _innerBinder.Bind(type, model, context);

            // Get the binding errors from conversion of the EditEntityModel
            context.Problems.Each(x =>
            {
                model.Notification.RegisterMessage(x.Properties.Last(), FastPackKeys.PARSE_VALUE);
            });

            return model;
        }

 public void Bind(PropertyInfo property, IBindingContext context)
 {
     property.ForAttribute<BindingAttribute>(att =>
     {
         att.Bind(property, context);
     });
 }

        private DomainEntity createNewEntity(Type entityType, IBindingContext prefixedContext)
        {
            var entity = (DomainEntity)_innerBinder.Bind(entityType, prefixedContext);
            entity.Id = Guid.Empty;
            _entityDefaults.ApplyDefaultsToNewEntity(entity);

            return entity;
        }

        public object Bind(Type type, IBindingContext context)
        {
            var contentType = context.Data.ValueAs<string>("Content-Type");
            var acceptType = context.Data.ValueAs<string>("Accept");
            var currentMimeType = new CurrentMimeType(contentType, acceptType);

            return currentMimeType;
        }

        public EmbeddedPipelineBindingContext(IBindingContext parent)
        {
            _parent = Ensure.IsNotNull(parent, nameof(parent));

            _correlationMapping = new Dictionary<Expression, Guid>();
            _expressionMapping = new Dictionary<Expression, Expression>();
            _memberMapping = new Dictionary<MemberInfo, Expression>();
        }

 public void Bind(PropertyInfo property, IBindingContext context)
 {
     var fubuRequest = context.Service<IFubuRequest>();
     var modelType = property.PropertyType;
     if (fubuRequest.Has(modelType))
     {
         property.SetValue(context.Object, fubuRequest.Get(modelType), null);
     }
 }

        public void Bind(PropertyInfo property, IBindingContext context)
        {
            var httpContext = context.Service<HttpContextBase>();
            var ipAddress = httpContext.Request.ServerVariables["HTTP_X_FORWARDED_FOR"];
            if (string.IsNullOrWhiteSpace(ipAddress)) ipAddress = httpContext.Request.ServerVariables["HTTP_X_FORWARDED"];
            if (string.IsNullOrWhiteSpace(ipAddress)) ipAddress = httpContext.Request.UserHostAddress;

            property.SetValue(context.Object, ipAddress, null);
        }

 public object Bind(Type type, IBindingContext context)
 {
     var jsonModel = context
                         .Service<IFubuRequest>()
                         .Get<JsonModel>();
     return context
             .Service<IJsonService>()
             .Deserialize(type, jsonModel.Body);
 }

 public void Bind(PropertyInfo property, IBindingContext context)
 {
     context.ForProperty(property, () =>
     {
         ValueConverter converter = _converters.FindConverter(property);
         object value = converter(context);
         property.SetValue(context.Object, value, null);
     });
 }

 public static void PopulatePropertyWithBinder(PropertyInfo property, IBindingContext context,
                                               IPropertyBinder propertyBinder)
 {
     context.Logger.Chose(property, propertyBinder);
     context.ForProperty(property, propertyContext =>
     {
         propertyBinder.Bind(property, context);
     });
 }

        public bool Bind(object instance, PropertyInfo propertyInfo, IBindingContext bindingContext)
        {
            if (!bindingSourceCollection.ContainsKey(bindingContext.GetKey(propertyInfo.Name)))
                return false;

            propertyInfo.SetValue(instance, valueConverterCollection.Convert(propertyInfo.PropertyType,
                                                                             bindingSourceCollection.Get(bindingContext.GetKey(propertyInfo.Name))), new object[0]);

            return true;
        }