在.cshtml文件中,我把这个：

@Html.DropDownListFor(model => model.EntityType.ParentId,Model.ParentTypeList,"")
@Html.ValidationMessageFor(model => model.EntityType.ParentId)

在控制器中进行业务验证

catch (BusinessException e)
{
    ModelState.AddModelError("EntityType.ParentId",Messages.CircularReference);
}

以上工作如预期：如果捕获到异常,该消息将出现在下拉列表旁边.

但是,我觉得这样做不是很优雅.在cshtml中,我使用一种方法生成有关验证的所有必需信息.在控制器中,我必须知道确切的Key字符串并使用它.

是不是有更好的方法呢？

public static class ModelStateExtensions
{
    public static void AddModelError<TModel,TProperty>(
        this ModelStateDictionary modelState,Expression<Func<TModel,TProperty>> ex,string message
    )
    {
        var key = ExpressionHelper.GetExpressionText(ex);
        modelState.AddModelError(key,message);
    }
}

然后使用这种方法：

catch (BusinessException e)
{
    ModelState.AddModelError<Myviewmodel,int>(
        x => x.EntityType.ParentId,Messages.CircularReference
    );
}

private <MType extends ExtendableMessage<MType>,BType extends ExtendableBuilder<MType,BType>> boolean resolveUninterpretedOptions(
    final BType optionsBuilder,final FieldDescriptor uninterpretedField) {
  ensureRegistry();
  boolean anyUninterpetedOptionResolved = false;
  @SuppressWarnings("unchecked")
  final List<UninterpretedOption> options =
      new ArrayList<UninterpretedOption>(
          (List<UninterpretedOption>) optionsBuilder.getField(uninterpretedField));

  for (final Iterator<UninterpretedOption> iterator = options.iterator(); iterator.hasNext();) {
    final UninterpretedOption option = iterator.next();

    if (resolveUninterpretedOption(option,optionsBuilder)) {
      anyUninterpetedOptionResolved = true;
      iterator.remove();
    }
  }

  if (options.isEmpty()) {
    optionsBuilder.clearField(uninterpretedField);
  } else {
    optionsBuilder.setField(uninterpretedField,options);
  }

  return anyUninterpetedOptionResolved;
}

private <MType extends ExtendableMessage<MType>,BType>> boolean resolveUninterpretedOption(
    final UninterpretedOptionorBuilder option,final BType optionsBuilder) {
  if (option.getNameCount() == 0) {
    throw new IllegalArgumentException("custom option cannot be empty");
  }

  if (!option.getName(0).getIsExtension()) {
    throw new IllegalArgumentException("custom option name should start with '('");
  }

  final Map.Entry<FieldDescriptor,Object> fieldValue;

  if (option.getNameCount() == 1) {
    fieldValue = processUninterpretedOptionValue(option,optionsBuilder);
  } else {
    fieldValue = processUninterpretedOptionMessage(option,optionsBuilder);
  }

  if (fieldValue == null) {
    return false;
  }

  final FieldDescriptor field = fieldValue.getKey();
  final Object value = fieldValue.getValue();

  if (field == null || value == null) {
    // the UninterpretedOption is not resolved
    return false;
  }

  if (field.isRepeated()) {
    optionsBuilder.addRepeatedField(field,value);
  } else {
    optionsBuilder.setField(field,value);
  }

  return true;
}

private <MType extends ExtendableMessage<MType>,BType>> boolean buildOptions(
    final BType optionsBuilder) {
  final FieldDescriptor uninterpretedField =
      getFD(optionsBuilder,UNINTERPRETED_OPTION_FIELD_NUMBER);
  final boolean isUninterpretedEmpty =
      optionsBuilder.getRepeatedFieldCount(uninterpretedField) == 0;
  final boolean anyUninterpetedOptionResolved =
      !isUninterpretedEmpty && resolveUninterpretedOptions(optionsBuilder,uninterpretedField);
  final boolean isUnkNownFieldsEmpty = optionsBuilder.getUnkNownFields().asMap().isEmpty();
  Map<FieldDescriptor,Object> allFields = null;

  if (isUninterpretedEmpty && isUnkNownFieldsEmpty) {
    allFields = optionsBuilder.getAllFields();

    if (allFields.isEmpty()) {
      return false;
    }
  }

  if (customOptionsAsExtensions) {
    if (!isUnkNownFieldsEmpty) {
      reparseBuilder(optionsBuilder,ensureRegistry());
    }
  } else {
    boolean anyExtension = anyUninterpetedOptionResolved;

    if (!anyUninterpetedOptionResolved) {
      if (allFields == null) {
        allFields = optionsBuilder.getAllFields();
      }

      for (final FieldDescriptor fd : allFields.keySet()) {
        if (fd.isExtension()) {
          anyExtension = true;
          break;
        }
      }
    }

    if (anyExtension) {
      reparseBuilder(optionsBuilder,ExtensionRegistry.getEmptyRegistry());
    }
  }

  return true;
}