C# ModelStateDictionary.Clear方法代码示例

        public void StartRegistrationForFamilyMember(int id, ModelStateDictionary modelState)
        {
            modelState.Clear(); // ensure we pull form fields from our model, not MVC's
            HistoryAdd("Register");
            int index = List.Count - 1;
            var p = LoadExistingPerson(id, index);

            if(p.NeedsToChooseClass())
                return;

            p.ValidateModelForFind(modelState, id, selectFromFamily: true);
            if (!modelState.IsValid)
                return;

            List[index] = p;

            if (p.ManageSubscriptions() && p.Found == true)
                return;

            if (p.org != null && p.Found == true)
            {
                if (!SupportMissionTrip)
                    p.IsFilled = p.org.RegLimitCount(DbUtil.Db) >= p.org.Limit;
                if (p.IsFilled)
                    modelState.AddModelError(this.GetNameFor(mm => mm.List[List.IndexOf(p)].Found),
                        "Sorry, but registration is filled.");
                if (p.Found == true)
                    p.FillPriorInfo();
                return;
            }
            if (p.org == null && p.ComputesOrganizationByAge())
                modelState.AddModelError(this.GetNameFor(mm => mm.List[id].Found), p.NoAppropriateOrgError);
        }

 /// <summary>
 /// 清除全部Error,实际上可以用 modelState.Clear();加在这里只是保持完整性罢了
 /// </summary>
 /// <param name="modelState"></param>
 public static void ClearAllError(ModelStateDictionary modelState)
 {
     modelState.Clear();
     //foreach (var key in modelState.Keys)
     //{
     //    ClearError(modelState, key);
     //}
 }

 public static void ToModelErrors(this ValidationResult validationResult, ModelStateDictionary modelState)
 {
     modelState.Clear();
     foreach (var validationError in validationResult.Errors)
     {
         modelState.AddModelError(validationError.Property, validationError.Message);
     }
 }

 public bool modelStateIsValidAfterReRunValidationOnComplexAttributes(
     ModelStateDictionary modelState, IValidatableObject model)
 {
     modelState.Clear();
     var errors = model.Validate(new ValidationContext(model, null, null));
     foreach(var error in errors)
         foreach(var memberName in error.MemberNames)
             modelState.AddModelError(memberName, error.ErrorMessage);
     return modelState.IsValid;
 }

        private Person SetPerson(PersonEditModel personEditModel, SeminarPerson seminarPerson, ModelStateDictionary modelState, Person person = null, HttpPostedFileBase profilePic = null)
        {
            modelState.Clear();

            person = person ?? personEditModel.Person;

            // copy all the fields
            Mapper.Map(personEditModel, person);

            SetAddresses(person, personEditModel.Addresses, ModelState);
            SetContacts(person, personEditModel.Contacts, ModelState);

            if (seminarPerson != null)
            {
                SetCommodities(seminarPerson, personEditModel.Commodities);

                if (personEditModel.Firm != null || !string.IsNullOrEmpty(personEditModel.FirmName))
                {
                    seminarPerson.Firm = personEditModel.Firm ?? new Firm(personEditModel.FirmName, personEditModel.FirmDescription) { WebAddress = personEditModel.FirmWebAddress };
                }
                if (personEditModel.Title != null) //Not sure what is happening here. This may fix it.
                {
                    seminarPerson.Title = personEditModel.Title;
                }
            }

            // deal with the image))
            if (profilePic != null)
            {
                // blank out existing image files
                person.OriginalPicture = null;
                person.MainProfilePicture = null;
                person.ThumbnailPicture = null;

                // read the file and set the original picture
                var reader = new BinaryReader(profilePic.InputStream);
                person.OriginalPicture = reader.ReadBytes(profilePic.ContentLength);
                person.ContentType = profilePic.ContentType;
            }

            // run the validation
            person.TransferValidationMessagesTo(modelState);

            return person;
        }

        //метод валидации
        public void Validate(ModelStateDictionary state)
        {
            state.Clear();

            //планируемое количество замен
            //должно быть в интервале 0 - общее количество контроллеров автоматики
            DBRepository dataRepo = new DBRepository();
            int contrAmm = dataRepo.ETKAutomControllers.Count();
            int replLvl;
            try
            {
                if (ReplacementLevel != null) //если null, то значит пользователь ничего не ввел в поле (допустимо)
                {
                    replLvl = Int32.Parse(ReplacementLevel); //если ввели не число, то не распарсит
                    if (replLvl < 0)
                    {
                        state.AddModelError("DateError", "Пожалуйста введите достоверный уровень замен контролеров в год!");
                    }
                }
            }
            catch
            {
                //нераспарсил
                state.AddModelError("DateError", "Пожалуйста введите достоверный уровень замен контролеров в год!");
            }

            //валидация выбранных факторов
            //если пользователь выбрал учитывать модификацию, то также должна быть выбрана модель
            if(ModificationFact&&!ModelFact)
                state.AddModelError("DateError", "При выборе \"Учитывать модификацию...\" обязательно должно быть выбрано \"Учитывать модель\"!");

            //валидация типа оборудования: пропускаем только контроллеры, при добавлении возможности обработки новых видов оборудования необходимо внести изменения
            if (EquType!="controllers")
                state.AddModelError("EquTypeError", "Метод для выбранного типа оборудования в настоящее время не реализован!");
        }

        void ValidateEditCRepOrderStatus_VM(EditCRepOrderStatus_VM model, ModelStateDictionary state)
        {
            state.Clear();
            DateTime tempDate;
            float tempFloat;
            string tempString;
            //валидация проходит отдельно для каждого варианта нового статуса
            //1.sended
            if (model.NewStatus=="sended")
            {
                //дата отправки
                //должна быть введена, должна иметь правильный формат, должна быть в интервале дата обнаружения -- текущая дата
                try
                {
                    if (model.SendedDate != null)
                    {
                        tempDate = DateTime.Parse(model.SendedDate); //если ввели некоректные данные, то не распарсит
                        if (tempDate > DateTime.Now)
                        {
                            state.AddModelError("", "Дата направления заявки позже текущей даты!");
                        }
                        else if (tempDate < model.Order.CRO_revealedDate)
                        {
                            //state.AddModelError("", "Заявка не может быть направлена раньше обнаружения неисправности!");
                        }
                    }
                    else
                    {
                        state.AddModelError("", "Пожалуйста введите дату направления заявки!");
                    }
                }
                catch
                {
                    //нераспарсил
                    state.AddModelError("DateError", "Пожалуйста введить дату направления заявки в формате ДД.ММ.ГГГГ");
                }
                //номер заявки - должен быть присвоен, должен быть не более 10 символов
                if (model.No== null)
                    state.AddModelError("NoError", "Пожалуйста укажите номер, присвоенный заявке!");
                else if (model.No.Length>10)
                    state.AddModelError("NoError", "Ошибка: номер заявки должен быть в пределах 10 символов");

            } //sended

            //2. billed
            if (model.NewStatus == "billed")
            {
                //дата предъявления
                //должна быть введена, должна иметь правильный формат, должна быть в интервале дата восстановления -- текущая дата
                //перед приемкой к оплате работ заявка должна быть закрыта
                try
                {
                    if (model.BilledDate != null)
                    {
                        tempDate = DateTime.Parse(model.BilledDate); //если ввели некоректные данные, то не распарсит
                        if (tempDate > DateTime.Now)
                        {
                            state.AddModelError("", "Дата предъявления работ к оплате позже текущей даты!");
                        }

                        if(model.Order.CRO_closedDate==null)
                        {
                            state.AddModelError("", "Ошибка: попытка внесения информации об оплате заявки, которая не закрыта!");
                        }
                        else if (tempDate < model.Order.CRO_closedDate)
                        {
                            state.AddModelError("", "Ошибка. Дата предъявления работ к оплате раньше даты закрытия заявки!");
                        }
                    }
                    else
                    {
                        state.AddModelError("", "Пожалуйста введите дату предъявления работ к оплате!");
                    }
                }
                catch
                {
                    //нераспарсил
                    state.AddModelError("DateError", "Пожалуйста введить дату предъявления работ к оплате в формате ДД.ММ.ГГГГ");
                }

                //подрядная организация
                //должна быть выбрана
                if(model.Contractor==null)
                {
                    state.AddModelError("", "Пожалуйста выберите подрядную организацию!");
                }

                //стоимость ремонта
                // должна быть введена, должна быть в интервале 150 - 150 000,00
                if (model.RepairCost!=null)
                {
                    //на
                    tempString = model.RepairCost.Replace('.', ',');//для того, чтобы пользователь имел возможность вводить и через точку и через запятую
                    try
                    {
                        tempFloat = float.Parse(tempString);
                        //распарсил, продолжаем
                        if (tempFloat<150.00 || tempFloat>150000.00)
                        {
                            state.AddModelError("", "Ошибка: введена недостоверная сумма!");
//.........这里部分代码省略.........

 void ValidateCreporderList_VM(CreporderList_VM model, ModelStateDictionary state)
 {
     state.Clear();
     //введенные даты, должны иметь правильный формат
     DateTime Date;
     try
     {
         if (model.StartRevDate!=null)Date = DateTime.Parse(model.StartRevDate);
         if (model.FinishRevDate!=null)Date = DateTime.Parse(model.FinishRevDate);
     }
     catch
     {
         state.AddModelError("", "Даты необходимо ввести в формате ДД.ММ.ГГГГ");
     }
 }

        void ValidateCreporderDetails_VM(CreporderDetails_VM model, ModelStateDictionary state)
        {
            state.Clear();

            //дата обнаружения неисправности
            //должна быть введена, должна иметь правильный формат, не должна быть позже текущей даты, не должна быть раньше 2-х лет
            DateTime tempDate;
            try
            {
                if (model.RevealedDate != null)
                {
                    tempDate = DateTime.Parse(model.RevealedDate); //если ввели некоректные данные, то не распарсит
                    if (tempDate>DateTime.Now)
                    {
                        state.AddModelError("", "Дата обнаружения неисправности позже текущей даты!");
                    }
                    else if(tempDate<DateTime.Now.AddYears(-2))
                    {
                        state.AddModelError("", "Неисправность не должна быть обнаружена более 2-х лет назад!");
                    }
                }
                else
                {
                    state.AddModelError("", "Пожалуйста введите дату обнаружения неисправности!");
                }
            }
            catch
            {
                //нераспарсил
                state.AddModelError("DateError", "Пожалуйста введить дату обнаружения неисправности в формате ДД.ММ.ГГГГ");
            }

            //описание неисправности: обязательно, не более 1000 символов
            if (model.ReporderDescription==null)
            {
                state.AddModelError("", "Пожалуйста введите описание неисправности!");
            }
            else if (model.ReporderDescription.Length>1000)
            {
                state.AddModelError("", "Описание неисправности слишком длинное!");
            }

            //адрес местонахождения: проверяем только если пользователь снял галку "установлен на тепловом пункте"
            //обязательно должен быть введен, должен быть не более 300 символов
            if(!model.Mounted)
            {
                if (model.EquipLocation==null)
                {
                    state.AddModelError("", "Пожалуйста укажите адрес местонахождения (или выберите 'находится в ТП')!");
                }
                else if(model.EquipLocation.Length>300)
                {
                    state.AddModelError("", "Адрес установки слишком длинный!");
                }
            }

            //срок выполнения работ, если введен, то должен быть не более 200 символов
            if(model.ExpectedRepairTerm!=null && model.ExpectedRepairTerm.Length>200)
            {
                state.AddModelError("", "Срок выполнения работ слишком длинный!");
            }

            //контакт: должен быть отмечен по крайней мере 1 контакт и не более 5;
            int count = 0;
            if(model.ContactsChoice!=null)
            {
                foreach (var contact in model.ContactsChoice)
                {
                    if (contact.Checked == true) count++;
                }
            }

            if (count==0)
            {
                state.AddModelError("", "Пожалуйста выберите контактных лиц!");
            }
            else if (count>5)
            {
                state.AddModelError("", "Пожалуйста выберите не более 5 контактных лиц!");
            }
        }

        void ValidateCreateCRepOrder_Equipment_VM(CreateCRepOrder_Equipment_VM model,ModelStateDictionary state)
        {
            state.Clear();
            //контроллер должен быть выбран
            if (model.CID==null)
            {
                state.AddModelError("", "Пожалуйста выберите контроллер");
            }
            else
            {
                //выбранный контроллер не должен находится в ремонте
                HSA.Domain.BD.Controller controller = dataRepository.Controllers.SingleOrDefault(c => c.C_ID == model.CID);
                if(controller.IsBroken())
                {
                    state.AddModelError("", "Пожалуйста выберите контроллер, который не находится в ремонте");
                }

            }
        }

        //методы добавляют к ModelStateDictionary ошибки валидации для различных моделей
        void ValidateControllerCorrect_VM(ControllerCorrect_VM model, ModelStateDictionary state)
        {
            state.Clear();
            //должен быть введен заводской номер
            if (model.SerNo == null) state.AddModelError("1", "Пожалуйста введите заводской номер!");
            //должен быть введен инвентарный номер
            if (model.InvNo == null) state.AddModelError("2", "Пожалуйста введите инвентарный номер!");
            //проверяем длину инвентарного номера и заводского номера - должны быть меньше 30 символов
            if ((model.InvNo != null && model.InvNo.Length > 30) || (model.SerNo != null && model.SerNo.Length > 30))
            {
                state.AddModelError("DateError", "Ошибка: слишком длинный номер!");
            }
            //проверяем введенный пользователем год
            int intYear = 0;
            try
            {
                if (model.ProdYear != null) //если null, то значит пользователь ничего не ввел в поле (допустимо)
                {
                    intYear = Int32.Parse(model.ProdYear); //если ввели совсем уж хуйню, то не распарсит
                    if (intYear != 0 && !(intYear > 1980 && intYear <= DateTime.Now.Year)) //год должен быть в интервале 1980 - текущий год, если год = 0 то пользователь его не указал просто
                    {
                        state.AddModelError("DateError", "Введен недействительный год производства!");
                    }
                }
                else
                {
                    state.AddModelError("DateError", "Пожалуйста введите год производства!");
                }
            }
            catch
            {
                //нераспарсил
                state.AddModelError("DateError", "Введен недействительный год производства!");
            }

            //Предварительная проверка, что контроллер где то установлен
            if (!dataRepository.Asystems.Where(aS => aS.AS_Controller == model.CID).Any())
            {
                //контроллер нигде не установлен
                state.AddModelError("MountError", "Контроллер не установлен ни на одном объекте!");
            }

            //Примечание должно быть менее 1000 символов
            else if (model.Comment!=null&&model.Comment.Length > 1000)
            {
                state.AddModelError("", "Ошибка: примечание слишком длинное!");
            }
        }

        public void Clear_RemovesAllEntries_IfDictionaryIsEmpty()
        {
            // Arrange
            var dictionary = new ModelStateDictionary();

            // Act
            dictionary.Clear();

            // Assert
            Assert.Equal(0, dictionary.Count);
            Assert.Equal(0, dictionary.ErrorCount);
            Assert.Empty(dictionary);
            Assert.Equal(ModelValidationState.Valid, dictionary.ValidationState);
        }

        public void Clear_RemovesAllEntries()
        {
            // Arrange
            var dictionary = new ModelStateDictionary();
            dictionary.AddModelError("a", "a-error");
            dictionary.AddModelError("b", "b-error");
            dictionary.AddModelError("c", "c-error");

            // Act
            dictionary.Clear();

            // Assert
            Assert.Equal(0, dictionary.Count);
            Assert.Equal(0, dictionary.ErrorCount);
            Assert.Empty(dictionary);
            Assert.Equal(ModelValidationState.Valid, dictionary.ValidationState);
        }