C# ModelStateDictionary.Add方法代码示例

        public void ValidateSum(double sum, double minSum, double maxSum, ModelStateDictionary modelState, bool isInitial = false)
        {
            if (sum < minSum)
            {
                modelState.Add(isInitial ? "request.InitialSum" : "request.Sum",
                    new ModelState() {Errors = {"—умма не может быть меньше минимальной."}});
            }

            if (sum > maxSum)
            {
                modelState.Add(isInitial ? "request.InitialSum" : "request.Sum", new ModelState() { Errors = { "—умма не может быть больше максимальной." } });
                //                throw BankClientException.ThrowSumMoreThanMax();
            }
        }

        public static void AddExcepition(ModelStateDictionary ModelState, Exception ex)
        {
            if (ex is ArgumentException)
            {
                var argEx = (ArgumentException) ex;
                if (!ModelState.ContainsKey(argEx.ParamName)) ModelState.Add(argEx.ParamName, new ModelState());
                var lines = Regex.Split(ex.Message, "\r\n");
                ModelState[argEx.ParamName].Errors.Add(new ModelError(ex, lines[0]));
                return;
            }

            if (!ModelState.ContainsKey("")) ModelState.Add("", new ModelState());

            ModelState[""].Errors.Add(new ModelError(ex, ex.Message));
        }

        private void CopyTempDataToModelState(ModelStateDictionary modelState,
                                              TempDataDictionary tempData)
        {
            if (!tempData.ContainsKey(TempDataKey))
            {
                return;
            }

            ModelStateDictionary fromTempData = tempData[TempDataKey]
                                                    as ModelStateDictionary;
            if (fromTempData == null)
            {
                return;
            }

            foreach (KeyValuePair<string, ModelState> pair in fromTempData)
            {
                if (modelState.ContainsKey(pair.Key))
                {
                    modelState[pair.Key].Value = pair.Value.Value;

                    foreach (ModelError error in pair.Value.Errors)
                    {
                        modelState[pair.Key].Errors.Add(error);
                    }
                }
                else
                {
                    modelState.Add(pair.Key, pair.Value);
                }
            }
        }

        private void CopyTempDataToModelState(ModelStateDictionary modelState, TempDataDictionary tempData)
        {
            if (!tempData.ContainsKey(TempDataKey)) return;

            var fromTempData = tempData[TempDataKey] as ModelStateDictionary;
            if (fromTempData == null) return;

            foreach (var pair in fromTempData)
            {
                if (modelState.ContainsKey(pair.Key))
                {
                    modelState[pair.Key].Value = pair.Value.Value;

                    foreach (var error in pair.Value.Errors)
                    {
                        if (!modelState[pair.Key].Errors.Contains(error))
                            modelState[pair.Key].Errors.Add(error);
                    }
                }
                else
                {
                    modelState.Add(pair.Key, pair.Value);
                }
            }
        }

        public override void OnActionExecuted(ActionExecutedContext filterContext)
        {
            ControllerBase controller = filterContext.Controller as ControllerBase;

              if (controller != null)
              {
            string serializedModelState = controller.TempData[Key] as string;

            if (!string.IsNullOrEmpty(serializedModelState))
            {
              IEnumerable<ModelStateWrapper> modelStateWrappers = JsonConvert.DeserializeObject<IEnumerable<ModelStateWrapper>>(serializedModelState, new JsonSerializerSettings() { Error = DeserializationErrorHandler });

              if (modelStateWrappers != null)
              {
            ModelStateDictionary modelState = new ModelStateDictionary();

            foreach (ModelStateWrapper modelStateWrapper in modelStateWrappers)
            {
              ModelState ms = new ModelState();

              ms.ValidationState = modelStateWrapper.ValidationState;
              ms.Value = new ValueProviderResult(modelStateWrapper.Value, modelStateWrapper.Value, null);
              modelState.Add(modelStateWrapper.Key, ms);
            }

            if (filterContext.Result is ViewResult)
              controller.ViewData.ModelState.Merge(modelState);

            else controller.TempData.Remove(Key);
              }
            }
              }

              base.OnActionExecuted(filterContext);
        }

 public void Should_skip_properties_without_errors()
 {
     var msd = new ModelStateDictionary();
     msd.Add("item.Property1", new ModelState());
     msd.AddModelError("item.Property2", "Error");
     ValidationHelpers.PropertyError pe = ValidationHelpers.MakeHierarchical(msd);
     Assert.That(pe["item"].Properties.Count, Is.EqualTo(1));
 }

        public void DoesNotAddEntries_IfNoErrorsArePresent()
        {
            // Arrange
            var modelState = new ModelStateDictionary();
            modelState.Add(
                "key1",
                new ModelState() { Value = new ValueProviderResult("foo", "foo", CultureInfo.InvariantCulture) });
            modelState.Add(
                "key2",
                new ModelState() { Value = new ValueProviderResult("bar", "bar", CultureInfo.InvariantCulture) });

            // Act
            var serializableError = new SerializableError(modelState);

            // Assert
            Assert.Equal(0, serializableError.Count);
        }

        public void DoesNotAddEntries_IfNoErrorsArePresent()
        {
            // Arrange
            var modelState = new ModelStateDictionary();
            modelState.Add(
                "key1",
                new ModelStateEntry());
            modelState.Add(
                "key2",
                new ModelStateEntry());

            // Act
            var serializableError = new SerializableError(modelState);

            // Assert
            Assert.Equal(0, serializableError.Count);
        }

        public void SimpleModelErrorIntoJson()
        {
            var modelState = new ModelStateDictionary();
            modelState.Add("FirstName", new ModelState { Errors = { "First name is a required field" } });

            var jsonResult = ControllerExtensions.ToJson(modelState);

            var data = jsonResult.Data;
            Assert.That(data, Has.Property("State").Not.Empty);
            Assert.That(data, Has.Property("State").With.Some.Property("Name").EqualTo("FirstName"));
            Assert.That(data, Has.Property("State").With.Some.Property("Errors").With.Some.EqualTo("First name is a required field"));
        }

        public void ModelErrorWithExceptionIntoJson()
        {
            var modelState = new ModelStateDictionary();
            modelState.Add("FirstName", new ModelState { Errors = { new InvalidOperationException("Cannot operate") } });

            var jsonResult = ControllerExtensions.ToJson(modelState);

            var data = jsonResult.Data;
            Assert.That(data, Has.Property("State").Not.Empty);
            Assert.That(data, Has.Property("State").With.Some.Property("Name").EqualTo("FirstName"));
            Assert.That(data, Has.Property("State").With.Some.Property("Errors").With.Some.EqualTo("Cannot operate"));
        }

        public void Does_Not_Overwrite_Any_Existing_ModelState_Value()
        {
            // Arrange
            object rawValue = new object();
            var someValue = new ModelState { Value = new ValueProviderResult(rawValue, null, null)};
            var ex = new RulesException("myProp", "myError");
            var modelState = new ModelStateDictionary();
            modelState.Add("myProp", someValue);

            // Act
            ex.AddModelStateErrors(modelState, null);

            // Assert
            Assert.Equal(1, modelState.Keys.Count());
            Assert.Same(rawValue, modelState["myProp"].Value.RawValue);
        }

        public void ReturnsCorrectly()
        {
            string key = "Key";
            string value = "Value";

            var modelState = new ModelState();
            modelState.Value = new ValueProviderResult( value, value, CultureInfo.InvariantCulture );

            var modelStateDictionary = new ModelStateDictionary();
            modelStateDictionary.Add( key, modelState );

            ModelState modelStateResult;
            var result = modelStateDictionary.GetModelStateValue( key, value.GetType(), out modelStateResult );

            Assert.AreEqual( result, value );
            Assert.AreSame( modelStateResult, modelState );
        }

        public void WithKeyNotFoundReturnsCorrectly()
        {
            string key = "Key";
            string value = "Value";

            var modelState = new ModelState();
            modelState.Value = new ValueProviderResult( value, value, CultureInfo.InvariantCulture );

            var modelStateDictionary = new ModelStateDictionary();
            modelStateDictionary.Add( key, modelState );

            ModelState modelStateResult;
            var result = modelStateDictionary.GetModelStateValue( "KeyNotFound", typeof( string ), out modelStateResult );

            Assert.IsNull( result );
            Assert.IsNull( modelStateResult );
        }

        public void Remove_ForImplicitlyCastedToObjectExpression_RemovesModelStateKey()
        {
            // Arrange
            var dictionary = new ModelStateDictionary();
            dictionary.Add("Child.Value", new ModelStateEntry());

            // Act
            dictionary.Remove<TestModel>(model => model.Child.Value);

            // Assert
            Assert.Empty(dictionary);
        }

        public void ModelStatePropertyGetterWorks()
        {
            // Arrange
            ApiController controller = new Mock<ApiController>().Object;

            // Act
            ModelStateDictionary expected = new ModelStateDictionary();
            expected.Add("a", new ModelState() { Value = new ValueProviders.ValueProviderResult("result", "attempted", CultureInfo.InvariantCulture) });

            controller.ModelState.Add("a", new ModelState() { Value = new ValueProviders.ValueProviderResult("result", "attempted", CultureInfo.InvariantCulture) });

            // Assert
            Assert.Equal(expected.Count, controller.ModelState.Count);
        }