C# Mvc.ValueProviderResult類代碼示例

 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;
     }
 }