internal static object GetModelValue(ValueProviderResult result, Type memberType)
 {
     var memberMapping = ModelMappingManager.MappingFor(memberType);
     var descriptor = new ModelDescriptor(memberMapping);
     var value = result.ConvertTo(descriptor.KeyProperty.PropertyType);
     return memberMapping.Configuration.Repository().Find(value);
 }

 public ValueProviderResult GetValue(string key)
 {
     ValueProviderResult result;
     result = new ValueProviderResult(data,
         "Id", CultureInfo.CurrentCulture);
     return result;
 }

        public static DateTime ParseDate(ValueProviderResult value)
        {
            // Create an array of all supported standard date and time format specifiers.
            string[] formats = {"d", "D", "f", "F", "g", "G", "m", "o", "r",
                          "s", "t", "T", "u", "U", "Y", "dd/MM/yyyy hh:mm:ss", "MM/dd/yyyy hh:mm:ss"};

            //
            CultureInfo[] cultures = {CultureInfo.CreateSpecificCulture("de-DE"),
                                CultureInfo.CreateSpecificCulture("en-US"),
                                CultureInfo.CreateSpecificCulture("he-IL"),
                                CultureInfo.CreateSpecificCulture("es-ES"),
                                CultureInfo.CreateSpecificCulture("fr-FR")};

            var parsedSuccesfuly = false;
            int cultureIndex = 0;
            DateTime foundDateTime = DateTime.MinValue;
            while (!parsedSuccesfuly && cultureIndex < cultures.Length)
            {
                parsedSuccesfuly = DateTime.TryParseExact(value.AttemptedValue, formats, cultures[cultureIndex], DateTimeStyles.None, out foundDateTime);
                cultureIndex++;
            }

            if (parsedSuccesfuly)
            {
                return foundDateTime;
            }
            throw new FormatException("Could not parse the specified date, culture is not supported");
        }

 protected virtual ValueProviderResult GetValue(string key)
 {
     ValueProviderResult res = null;
     string val = this._context.HttpContext.Request.Form[key.Replace('.', '[')+']'] as string;
     if (val != null)
         res = new ValueProviderResult(val, val, CultureInfo.CurrentCulture);
     return res;
 }

 /// <summary>
 /// </summary>
 /// <param name="result"></param>
 /// <param name="sessionWrapper"></param>
 /// <exception cref="ArgumentNullException"></exception>
 public NHValueProviderResult(ValueProviderResult result, SessionWrapper sessionWrapper)
 {
     _result = result;
     _sessionWrapper = sessionWrapper;
     AttemptedValue = result.AttemptedValue;
     Culture = result.Culture;
     RawValue = result.RawValue;
 }

 private void SetModelState(ModelBindingContext bindingContext, ValueProviderResult valueProviderResult)
 {
     ModelState modelState;
     if (!bindingContext.ModelState.TryGetValue(bindingContext.ModelName, out modelState))
     {
         bindingContext.ModelState.Add(bindingContext.ModelName, modelState = new ModelState());
     }
     modelState.Value = valueProviderResult;
 }

        public void ConvertToCanConvertArraysToSingleElements() {
            // Arrange
            ValueProviderResult vpr = new ValueProviderResult(new int[] { 1, 20, 42 }, "", CultureInfo.InvariantCulture);

            // Act
            string converted = (string)vpr.ConvertTo(typeof(string));

            // Assert
            Assert.AreEqual("1", converted);
        }

        public void ConvertToCanConvertSingleElementsToSingleElements() {
            // Arrange
            ValueProviderResult vpr = new ValueProviderResult(42, "", CultureInfo.InvariantCulture);

            // Act
            string converted = (string)vpr.ConvertTo(typeof(string));

            // Assert
            Assert.IsNotNull(converted);
            Assert.AreEqual("42", converted);
        }

        public void ConvertToChecksTypeConverterCanConvertFrom() {
            // Arrange
            object original = "someValue";
            ValueProviderResult vpr = new ValueProviderResult(original, null, CultureInfo.GetCultureInfo("fr-FR"));

            // Act
            DefaultModelBinderTest.StringContainer returned = (DefaultModelBinderTest.StringContainer)vpr.ConvertTo(typeof(DefaultModelBinderTest.StringContainer));

            // Assert
            Assert.AreEqual(returned.Value, "someValue (fr-FR)");
        }

        public ValueProviderResult GetValue(string key)
        {
            ValueProviderResult result=null;
            if (this.dictionary.ContainsKey(key))
            {
                result = new ValueProviderResult(this.dictionary[key],
                this.dictionary[key], CultureInfo.CurrentCulture);
            }

            return result;
        }

        /// <summary>
        /// Creates the list of ministries selected by the system users
        /// </summary>
        /// <param name="result"></param>
        /// <returns></returns>
        private static List<MinistryModel> BindMinistryModels(ValueProviderResult result)
        {
            var rawValue = result.RawValue as string[];
            if (rawValue == null || rawValue.Length == 0)
            {
                return null;
            }

            List<MinistryModel> models = ManageMinistryModelHelper.GetMinistryModels(rawValue);
            return models;
        }

        internal static object GetNonModelValue(ValueProviderResult result, Type memberType)
        {
            var innerType = Nullable.GetUnderlyingType(memberType) ?? memberType;

            if (innerType.IsEnum)
                return Enum.Parse(innerType, result.AttemptedValue);

            var value = innerType == typeof(Boolean)
                            ? result.AttemptedValue.Split(',')[0]
                            : result.AttemptedValue;

            return TypeDescriptor.GetConverter(innerType).ConvertFrom(null, CultureInfo.CurrentCulture, value);
        }

        public void GetValue_should_not_throw_exception_when_try_to_convert_value_from_ModelState()
        {
            result = new ValueProviderResult("11/22/2000", "11/22/2000", new CultureInfo("en-US"));
            state = new ModelState();
            state.Value = result;

            viewContext.ViewData.ModelState.Remove("DatePicker1");
            viewContext.ViewData.ModelState.Add("DatePicker1", state);

            System.Threading.Thread.CurrentThread.CurrentCulture = new CultureInfo("de-DE");

            Assert.DoesNotThrow(() => datepicker.GetValue(o => (DateTime?)o));
        }

        public InputComponentExtensionsTests()
        {
            viewContext = TestHelper.CreateViewContext();
            datepicker = DatePickerTestHelper.CreateDatePicker(null, viewContext);
            datepicker.Name = "DatePicker1";

            result = new ValueProviderResult("s", "s", System.Threading.Thread.CurrentThread.CurrentCulture);
            state = new ModelState();
            state.Value = result;

            viewContext.ViewData.ModelState.Add("DatePicker1", state);
            currentCulture = CultureInfo.CurrentCulture;
        }

 public static bool TryGetValue(this IValueProvider valueProvider, string key, out ValueProviderResult result)
 {
     try
     {
         result = valueProvider.GetValue(key);
         return true;
     }
     catch
     {
         result = null;
         return false;
     }
 }

        public override bool IsValidName(ControllerContext controllerContext, string actionName, MethodInfo methodInfo)
        {
            bool isValidName = false;
            string keyValue = string.Format("{0}:{1}", Name, Argument);
            var value = controllerContext.Controller.ValueProvider.GetValue(keyValue);
            if (value != null) {
                value = new ValueProviderResult(Argument, Argument, null);
                controllerContext.Controller.ControllerContext.RouteData.Values[Name] = Argument;
                isValidName = true;
            }

            return isValidName;
        }

        private static string BindStartEndTime(ValueProviderResult result)
        {
            var rawValue = result.RawValue as string;
            if (string.IsNullOrEmpty(rawValue))
            {
                return null;
            }

            // Is time valid?
            Convert.ToDateTime(string.Format("1/1/2012 {0}", rawValue));

            return rawValue.Trim();
        }

        public IDictionary<string, ValueProviderResult> ToValueProvider() {
            CultureInfo currentCulture = CultureInfo.CurrentCulture;

            Dictionary<string, ValueProviderResult> dict = new Dictionary<string, ValueProviderResult>(StringComparer.OrdinalIgnoreCase);
            string[] keys = AllKeys;
            foreach (string key in keys) {
                string[] rawValue = GetValues(key);
                string attemptedValue = this[key];
                ValueProviderResult vpResult = new ValueProviderResult(rawValue, attemptedValue, currentCulture);
                dict[key] = vpResult;
            }

            return dict;
        }

        public override object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
        {
            ValueProviderResult valueResultHours = bindingContext.ValueProvider
                                           .GetValue(bindingContext.ModelName + ".Hours");
            ValueProviderResult valueResultMinutes = bindingContext.ValueProvider
               .GetValue(bindingContext.ModelName + ".Minutes");
            ValueProviderResult valueResultSeconds = bindingContext.ValueProvider
               .GetValue(bindingContext.ModelName + ".Seconds");

            if (valueResultHours != null || valueResultMinutes != null | valueResultSeconds != null)
            {
                int hours = 0;
                int minutes = 0;
                int seconds = 0;
                TimeSpan? actualValue = null;
                var valueResult = new ValueProviderResult(null, string.Empty, System.Globalization.CultureInfo.CurrentCulture);
                
                var modelState = new ModelState { Value = valueResult };
                try
                {
                    if (valueResultHours != null)
                    {
                        hours = int.Parse(valueResultHours.AttemptedValue);
                    }

                    if (valueResultMinutes != null)
                    {
                        minutes = int.Parse(valueResultMinutes.AttemptedValue);
                    }

                    if (valueResultSeconds != null)
                    {
                        seconds = int.Parse(valueResultSeconds.AttemptedValue);
                    }
                    actualValue = new TimeSpan(hours, minutes, seconds);                    
                }
                catch (FormatException e)
                {
                    modelState.Errors.Add(e);
                }

                bindingContext.ModelState.Add(bindingContext.ModelName, modelState);

                return actualValue;
            }
            else
            {
                return base.BindModel(controllerContext, bindingContext);
            }
        }

        public void ConvertToCanConvertArraysToArrays() {
            // Arrange
            ValueProviderResult vpr = new ValueProviderResult(new int[] { 1, 20, 42 }, "", CultureInfo.InvariantCulture);

            // Act
            string[] converted = (string[])vpr.ConvertTo(typeof(string[]));

            // Assert
            Assert.IsNotNull(converted);
            Assert.AreEqual(3, converted.Length);
            Assert.AreEqual("1", converted[0]);
            Assert.AreEqual("20", converted[1]);
            Assert.AreEqual("42", converted[2]);
        }