데이터 입력 후 문자열을 자르는 가장 좋은 방법입니다. 커스텀 모델 바인더를 만들어야합니까?

ASP.NET MVC를 사용하고 있으며 모든 사용자가 입력 한 문자열 필드가 데이터베이스에 삽입되기 전에 잘 리기를 원합니다. 그리고 많은 데이터 입력 양식이 있기 때문에 모든 사용자 제공 문자열 값을 명시 적으로 트리밍하는 대신 모든 문자열을 트리밍하는 우아한 방법을 찾고 있습니다. 사람들이 줄을 자르는 방법과시기를 알고 싶습니다.

아마도 사용자 정의 모델 바인더를 만들고 문자열 값을 트리밍하는 방법에 대해 생각했습니다. 그러면 모든 트리밍 로직이 한 곳에 포함됩니다. 이것이 좋은 접근입니까? 이를 수행하는 코드 샘플이 있습니까?

  public class TrimModelBinder : DefaultModelBinder
  {
    protected override void SetProperty(ControllerContext controllerContext, 
      ModelBindingContext bindingContext, 
      System.ComponentModel.PropertyDescriptor propertyDescriptor, object value)
    {
      if (propertyDescriptor.PropertyType == typeof(string))
      {
        var stringValue = (string)value;
        if (!string.IsNullOrWhiteSpace(stringValue))
        {
          value = stringValue.Trim();
        }
        else
        {
          value = null;
        }
      }

      base.SetProperty(controllerContext, bindingContext, 
                          propertyDescriptor, value);
    }
  }

이 코드는 어떻습니까?

ModelBinders.Binders.DefaultBinder = new TrimModelBinder();

global.asax Application_Start 이벤트를 설정하십시오.

이것은 @takepara와 같은 해상도이지만 DefaultModelBinder 대신 IModelBinder와 같이 global.asax에 modelbinder를 추가하는 것이

ModelBinders.Binders.Add(typeof(string),new TrimModelBinder());

클래스:

public class TrimModelBinder : IModelBinder
{
    public object BindModel(ControllerContext controllerContext,
    ModelBindingContext bindingContext)
    {
        ValueProviderResult valueResult = bindingContext.ValueProvider.GetValue(bindingContext.ModelName);
        if (valueResult== null || valueResult.AttemptedValue==null)
           return null;
        else if (valueResult.AttemptedValue == string.Empty)
           return string.Empty;
        return valueResult.AttemptedValue.Trim();
    }
}

@haacked 게시물을 기반으로 : http://haacked.com/archive/2011/03/19/fixing-binding-to-decimals.aspx

@takepara 답변의 한 가지 개선.

프로젝트 중 일부 :

public class NoTrimAttribute : Attribute { }

TrimModelBinder 클래스 변경에서

if (propertyDescriptor.PropertyType == typeof(string))

에

if (propertyDescriptor.PropertyType == typeof(string) && !propertyDescriptor.Attributes.Cast<object>().Any(a => a.GetType() == typeof(NoTrimAttribute)))

[NoTrim] 속성을 사용하여 트리밍에서 제외 할 속성을 표시 할 수 있습니다.

C # 6의 개선으로 이제 모든 문자열 입력을 다듬는 매우 컴팩트 한 모델 바인더를 작성할 수 있습니다.

public class TrimStringModelBinder : IModelBinder
{
    public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
    {
        var value = bindingContext.ValueProvider.GetValue(bindingContext.ModelName);
        var attemptedValue = value?.AttemptedValue;

        return string.IsNullOrWhiteSpace(attemptedValue) ? attemptedValue : attemptedValue.Trim();
    }
}

당신은이 선 곳을 포함 할 필요가 Application_Start()당신에 Global.asax.cs바인딩 할 때 모델 바인더를 사용하는 파일 string들 :

ModelBinders.Binders.Add(typeof(string), new TrimStringModelBinder());

기본 모델 바인더를 재정의하는 대신 이와 같은 모델 바인더를 사용하는 것이 좋습니다. 그러면 string메서드 인수 또는 모델 클래스의 속성으로 바인딩 여부에 관계 없이을 바인딩 할 때마다 사용되기 때문 입니다. 다른 답변은 여기 제안으로 기본 모델 바인더를 오버라이드 (override)하는 경우 그 것이다 그러나, 단지 모델의 속성을 바인딩 작업을 할 때, 아니 당신이있을 때 string조치 방법에 인수로

편집 : 의견 작성자가 필드의 유효성을 검사하지 않아야 할 상황을 처리하도록 요청했습니다. OP가 제기 한 질문을 처리하기 위해 원래의 대답이 축소되었지만 관심있는 사람들은 다음 확장 모델 바인더를 사용하여 유효성 검사를 처리 할 수 ​​있습니다.

public class TrimStringModelBinder : IModelBinder
{
    public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
    {
        var shouldPerformRequestValidation = controllerContext.Controller.ValidateRequest && bindingContext.ModelMetadata.RequestValidationEnabled;
        var unvalidatedValueProvider = bindingContext.ValueProvider as IUnvalidatedValueProvider;

        var value = unvalidatedValueProvider == null ?
          bindingContext.ValueProvider.GetValue(bindingContext.ModelName) :
          unvalidatedValueProvider.GetValue(bindingContext.ModelName, !shouldPerformRequestValidation);

        var attemptedValue = value?.AttemptedValue;

        return string.IsNullOrWhiteSpace(attemptedValue) ? attemptedValue : attemptedValue.Trim();
    }
}

ASP.Net Core 2 에서는 이것이 효과적 이었습니다. [FromBody]컨트롤러 및 JSON 입력에서 속성을 사용하고 있습니다. JSON 역 직렬화에서 문자열 처리를 재정의하려면 내 JsonConverter를 등록했습니다.

services.AddMvcCore()
    .AddJsonOptions(options =>
        {
            options.SerializerSettings.Converters.Insert(0, new TrimmingStringConverter());
        })

그리고 이것은 변환기입니다.

public class TrimmingStringConverter : JsonConverter
{
    public override bool CanRead => true;
    public override bool CanWrite => false;

    public override bool CanConvert(Type objectType) => objectType == typeof(string);

    public override object ReadJson(JsonReader reader, Type objectType,
        object existingValue, JsonSerializer serializer)
    {
        if (reader.Value is string value)
        {
            return value.Trim();
        }

        return reader.Value;
    }

    public override void WriteJson(JsonWriter writer, object value,
        JsonSerializer serializer)
    {
        throw new NotImplementedException();
    }
}

@takepara의 답변의 또 다른 변형이지만 다른 변형이 있습니다.

1) 옵트 인 "StringTrim"속성 메커니즘 (@Anton의 옵트 아웃 "NoTrim"예제 대신)을 선호합니다.

2) ModelState가 올바르게 채워지고 기본 유효성 검사 / 수락 / 거부 패턴이 정상적으로 사용되도록 (예 : TryUpdateModel (model) 적용 및 ModelState.Clear () 모든 변경 사항을 적용하려면 SetModelValue에 대한 추가 호출이 필요합니다.

이것을 엔티티 / 공유 라이브러리에 넣으십시오.

/// <summary>
/// Denotes a data field that should be trimmed during binding, removing any spaces.
/// </summary>
/// <remarks>
/// <para>
/// Support for trimming is implmented in the model binder, as currently
/// Data Annotations provides no mechanism to coerce the value.
/// </para>
/// <para>
/// This attribute does not imply that empty strings should be converted to null.
/// When that is required you must additionally use the <see cref="System.ComponentModel.DataAnnotations.DisplayFormatAttribute.ConvertEmptyStringToNull"/>
/// option to control what happens to empty strings.
/// </para>
/// </remarks>
[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false)]
public class StringTrimAttribute : Attribute
{
}

그런 다음 MVC 응용 프로그램 / 라이브러리에서 다음을 수행하십시오.

/// <summary>
/// MVC model binder which trims string values decorated with the <see cref="StringTrimAttribute"/>.
/// </summary>
public class StringTrimModelBinder : IModelBinder
{
    /// <summary>
    /// Binds the model, applying trimming when required.
    /// </summary>
    public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
    {
        // Get binding value (return null when not present)
        var propertyName = bindingContext.ModelName;
        var originalValueResult = bindingContext.ValueProvider.GetValue(propertyName);
        if (originalValueResult == null)
            return null;
        var boundValue = originalValueResult.AttemptedValue;

        // Trim when required
        if (!String.IsNullOrEmpty(boundValue))
        {
            // Check for trim attribute
            if (bindingContext.ModelMetadata.ContainerType != null)
            {
                var property = bindingContext.ModelMetadata.ContainerType.GetProperties()
                    .FirstOrDefault(propertyInfo => propertyInfo.Name == bindingContext.ModelMetadata.PropertyName);
                if (property != null && property.GetCustomAttributes(true)
                    .OfType<StringTrimAttribute>().Any())
                {
                    // Trim when attribute set
                    boundValue = boundValue.Trim();
                }
            }
        }

        // Register updated "attempted" value with the model state
        bindingContext.ModelState.SetModelValue(propertyName, new ValueProviderResult(
            originalValueResult.RawValue, boundValue, originalValueResult.Culture));

        // Return bound value
        return boundValue;
    }
}

바인더에서 속성 값을 설정하지 않으면 아무 것도 변경하지 않으려는 경우에도 ModelState에서 해당 속성을 모두 차단합니다! 이것은 모든 문자열 유형을 바인딩하는 것으로 등록되어 있기 때문에 (내 테스트에서) 기본 바인더가 대신하지 않는 것으로 나타납니다.

ASP.NET Core 1.0에서이 작업을 수행하는 방법을 검색하는 사람을위한 추가 정보. 논리는 상당히 많이 바뀌 었습니다.

나는 그것을 수행하는 방법에 대한 블로그 포스트를 작성 , 그것은 약간의 일을 더 자세히 설명

따라서 ASP.NET Core 1.0 솔루션 :

실제 트리밍을 수행하는 모델 바인더

public class TrimmingModelBinder : ComplexTypeModelBinder  
{
    public TrimmingModelBinder(IDictionary propertyBinders) : base(propertyBinders)
    {
    }

    protected override void SetProperty(ModelBindingContext bindingContext, string modelName, ModelMetadata propertyMetadata, ModelBindingResult result)
    {
        if(result.Model is string)
        {
            string resultStr = (result.Model as string).Trim();
            result = ModelBindingResult.Success(resultStr);
        }

        base.SetProperty(bindingContext, modelName, propertyMetadata, result);
    }
}

또한 최신 버전의 Model Binder Provider가 필요합니다.이 모델 에이 바인더를 사용해야한다는 것을 알려줍니다.

public class TrimmingModelBinderProvider : IModelBinderProvider
{
    public IModelBinder GetBinder(ModelBinderProviderContext context)
    {
        if (context == null)
        {
            throw new ArgumentNullException(nameof(context));
        }

        if (context.Metadata.IsComplexType && !context.Metadata.IsCollectionType)
        {
            var propertyBinders = new Dictionary();
            foreach (var property in context.Metadata.Properties)
            {
                propertyBinders.Add(property, context.CreateBinder(property));
            }

            return new TrimmingModelBinder(propertyBinders);
        }

        return null;
    }
}

그런 다음 Startup.cs에 등록해야합니다

 services.AddMvc().AddMvcOptions(options => {  
       options.ModelBinderProviders.Insert(0, new TrimmingModelBinderProvider());
 });

위의 훌륭한 답변과 의견을 읽고 점점 혼란스러워지면서 갑자기 jQuery 솔루션이 있는지 궁금합니다. 따라서 나와 같은 ModelBinders를 조금 당황스럽게 생각하는 다른 사람들을 위해 양식을 제출하기 전에 입력 필드를 자르는 다음 jQuery 스 니펫을 제공합니다.

    $('form').submit(function () {
        $(this).find('input:text').each(function () {
            $(this).val($.trim($(this).val()));
        })
    });

MVC Core의 경우

접합재:

using Microsoft.AspNetCore.Mvc.ModelBinding;
using System;
using System.Threading.Tasks;
public class TrimmingModelBinder
    : IModelBinder
{
    private readonly IModelBinder FallbackBinder;

    public TrimmingModelBinder(IModelBinder fallbackBinder)
    {
        FallbackBinder = fallbackBinder ?? throw new ArgumentNullException(nameof(fallbackBinder));
    }

    public Task BindModelAsync(ModelBindingContext bindingContext)
    {
        if (bindingContext == null)
        {
            throw new ArgumentNullException(nameof(bindingContext));
        }

        var valueProviderResult = bindingContext.ValueProvider.GetValue(bindingContext.ModelName);

        if (valueProviderResult != null &&
            valueProviderResult.FirstValue is string str &&
            !string.IsNullOrEmpty(str))
        {
            bindingContext.Result = ModelBindingResult.Success(str.Trim());
            return Task.CompletedTask;
        }

        return FallbackBinder.BindModelAsync(bindingContext);
    }
}

공급자:

using Microsoft.AspNetCore.Mvc.ModelBinding;
using Microsoft.AspNetCore.Mvc.ModelBinding.Binders;
using System;

public class TrimmingModelBinderProvider
    : IModelBinderProvider
{
    public IModelBinder GetBinder(ModelBinderProviderContext context)
    {
        if (context == null)
        {
            throw new ArgumentNullException(nameof(context));
        }

        if (!context.Metadata.IsComplexType && context.Metadata.ModelType == typeof(string))
        {
            return new TrimmingModelBinder(new SimpleTypeModelBinder(context.Metadata.ModelType));
        }

        return null;
    }
}

등록 기능 :

    public static void AddStringTrimmingProvider(this MvcOptions option)
    {
        var binderToFind = option.ModelBinderProviders
            .FirstOrDefault(x => x.GetType() == typeof(SimpleTypeModelBinderProvider));

        if (binderToFind == null)
        {
            return;
        }

        var index = option.ModelBinderProviders.IndexOf(binderToFind);
        option.ModelBinderProviders.Insert(index, new TrimmingModelBinderProvider());
    }

레지스터:

service.AddMvc(option => option.AddStringTrimmingProvider())

파티에 늦었지만 다음은 빌트인 skipValidation가치 제공 업체 의 요구 사항 을 처리해야하는 경우 MVC 5.2.3에 필요한 조정 사항을 요약 한 것입니다 .

public class TrimStringModelBinder : IModelBinder
{
    public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
    {
        // First check if request validation is required
        var shouldPerformRequestValidation = controllerContext.Controller.ValidateRequest && 
            bindingContext.ModelMetadata.RequestValidationEnabled;

        // determine if the value provider is IUnvalidatedValueProvider, if it is, pass in the 
        // flag to perform request validation (e.g. [AllowHtml] is set on the property)
        var unvalidatedProvider = bindingContext.ValueProvider as IUnvalidatedValueProvider;

        var valueProviderResult = unvalidatedProvider?.GetValue(bindingContext.ModelName, !shouldPerformRequestValidation) ??
            bindingContext.ValueProvider.GetValue(bindingContext.ModelName);

        return valueProviderResult?.AttemptedValue?.Trim();
    }
}

Global.asax

    protected void Application_Start()
    {
        ...
        ModelBinders.Binders.Add(typeof(string), new TrimStringModelBinder());
        ...
    }

나는 해결책에 동의하지 않는다. SetProperty의 데이터를 ModelState로 채울 수도 있으므로 GetPropertyValue를 재정의해야합니다. 입력 요소에서 원시 데이터를 포착하려면 다음을 작성하십시오.

 public class CustomModelBinder : System.Web.Mvc.DefaultModelBinder
{
    protected override object GetPropertyValue(System.Web.Mvc.ControllerContext controllerContext, System.Web.Mvc.ModelBindingContext bindingContext, System.ComponentModel.PropertyDescriptor propertyDescriptor, System.Web.Mvc.IModelBinder propertyBinder)
    {
        object value = base.GetPropertyValue(controllerContext, bindingContext, propertyDescriptor, propertyBinder);

        string retval = value as string;

        return string.IsNullOrWhiteSpace(retval)
                   ? value
                   : retval.Trim();
    }

}

문자열 값에만 관심이 있지만 들어오는 모든 것이 기본적으로 문자열이기 때문에 중요하지 않은 경우 propertyDescriptor PropertyType으로 필터링하십시오.

들어 ASP.NET 코어 의 대체 ComplexTypeModelBinderProvider문자열을 트리밍 공급자와 함께.

시작 코드 ConfigureServices방법에서 다음을 추가하십시오.

services.AddMvc()
    .AddMvcOptions(s => {
        s.ModelBinderProviders[s.ModelBinderProviders.TakeWhile(p => !(p is ComplexTypeModelBinderProvider)).Count()] = new TrimmingModelBinderProvider();
    })

다음 TrimmingModelBinderProvider과 같이 정의하십시오 .

/// <summary>
/// Used in place of <see cref="ComplexTypeModelBinderProvider"/> to trim beginning and ending whitespace from user input.
/// </summary>
class TrimmingModelBinderProvider : IModelBinderProvider
{
    class TrimmingModelBinder : ComplexTypeModelBinder
    {
        public TrimmingModelBinder(IDictionary<ModelMetadata, IModelBinder> propertyBinders) : base(propertyBinders) { }

        protected override void SetProperty(ModelBindingContext bindingContext, string modelName, ModelMetadata propertyMetadata, ModelBindingResult result)
        {
            var value = result.Model as string;
            if (value != null)
                result = ModelBindingResult.Success(value.Trim());
            base.SetProperty(bindingContext, modelName, propertyMetadata, result);
        }
    }

    public IModelBinder GetBinder(ModelBinderProviderContext context)
    {
        if (context.Metadata.IsComplexType && !context.Metadata.IsCollectionType) {
            var propertyBinders = new Dictionary<ModelMetadata, IModelBinder>();
            for (var i = 0; i < context.Metadata.Properties.Count; i++) {
                var property = context.Metadata.Properties[i];
                propertyBinders.Add(property, context.CreateBinder(property));
            }
            return new TrimmingModelBinder(propertyBinders);
        }
        return null;
    }
}

이것의 추악한 부분은의 GetBinder논리를 복사하여 붙여 넣는 ComplexTypeModelBinderProvider것이지만 이것을 피할 수있는 후크는없는 것 같습니다.

쿼리 문자열 매개 변수 값과 양식 값을 자르기 위해 값 공급자를 만들었습니다. 이것은 ASP.NET Core 3으로 테스트되었으며 완벽하게 작동합니다.

public class TrimmedFormValueProvider
    : FormValueProvider
{
    public TrimmedFormValueProvider(IFormCollection values)
        : base(BindingSource.Form, values, CultureInfo.InvariantCulture)
    { }

    public override ValueProviderResult GetValue(string key)
    {
        ValueProviderResult baseResult = base.GetValue(key);
        string[] trimmedValues = baseResult.Values.Select(v => v?.Trim()).ToArray();
        return new ValueProviderResult(new StringValues(trimmedValues));
    }
}

public class TrimmedQueryStringValueProvider
    : QueryStringValueProvider
{
    public TrimmedQueryStringValueProvider(IQueryCollection values)
        : base(BindingSource.Query, values, CultureInfo.InvariantCulture)
    { }

    public override ValueProviderResult GetValue(string key)
    {
        ValueProviderResult baseResult = base.GetValue(key);
        string[] trimmedValues = baseResult.Values.Select(v => v?.Trim()).ToArray();
        return new ValueProviderResult(new StringValues(trimmedValues));
    }
}

public class TrimmedFormValueProviderFactory
    : IValueProviderFactory
{
    public Task CreateValueProviderAsync(ValueProviderFactoryContext context)
    {
        if (context.ActionContext.HttpContext.Request.HasFormContentType)
            context.ValueProviders.Add(new TrimmedFormValueProvider(context.ActionContext.HttpContext.Request.Form));
        return Task.CompletedTask;
    }
}

public class TrimmedQueryStringValueProviderFactory
    : IValueProviderFactory
{
    public Task CreateValueProviderAsync(ValueProviderFactoryContext context)
    {
        context.ValueProviders.Add(new TrimmedQueryStringValueProvider(context.ActionContext.HttpContext.Request.Query));
        return Task.CompletedTask;
    }
}

그런 다음 ConfigureServices()Startup.cs 의 함수에 값 공급자 팩토리를 등록하십시오.

services.AddControllersWithViews(options =>
{
    int formValueProviderFactoryIndex = options.ValueProviderFactories.IndexOf(options.ValueProviderFactories.OfType<FormValueProviderFactory>().Single());
    options.ValueProviderFactories[formValueProviderFactoryIndex] = new TrimmedFormValueProviderFactory();

    int queryStringValueProviderFactoryIndex = options.ValueProviderFactories.IndexOf(options.ValueProviderFactories.OfType<QueryStringValueProviderFactory>().Single());
    options.ValueProviderFactories[queryStringValueProviderFactoryIndex] = new TrimmedQueryStringValueProviderFactory();
});

속성 접근법을 제안하는 많은 게시물이 있습니다. 다음은 이미 다듬기 속성이있는 패키지입니다. Dado.ComponentModel.Mutations 또는 NuGet

public partial class ApplicationUser
{
    [Trim, ToLower]
    public virtual string UserName { get; set; }
}

// Then to preform mutation
var user = new ApplicationUser() {
    UserName = "   M@X_speed.01! "
}

new MutationContext<ApplicationUser>(user).Mutate();

Mutate ()를 호출 한 후 user.UserName이로 변경됩니다 m@x_speed.01!.

이 예제는 공백을 자르고 문자열을 소문자로 만듭니다. 유효성 검사를 도입하지는 System.ComponentModel.Annotations않지만와 함께 사용할 수 있습니다 Dado.ComponentModel.Mutations.

나는 이것을 다른 스레드에 게시했습니다. asp.net core 2에서는 다른 방향으로갔습니다. 대신 액션 필터를 사용했습니다. 이 경우 개발자는 전역으로 설정하거나 문자열 트리밍을 적용하려는 작업의 속성으로 사용할 수 있습니다. 이 코드는 모델 바인딩이 실행 된 후에 실행되며 모델 객체의 값을 업데이트 할 수 있습니다.

내 코드는 다음과 같습니다. 먼저 액션 필터를 만듭니다.

public class TrimInputStringsAttribute : ActionFilterAttribute
{
    public override void OnActionExecuting(ActionExecutingContext context)
    {
        foreach (var arg in context.ActionArguments)
        {
            if (arg.Value is string)
            {
                string val = arg.Value as string;
                if (!string.IsNullOrEmpty(val))
                {
                    context.ActionArguments[arg.Key] = val.Trim();
                }

                continue;
            }

            Type argType = arg.Value.GetType();
            if (!argType.IsClass)
            {
                continue;
            }

            TrimAllStringsInObject(arg.Value, argType);
        }
    }

    private void TrimAllStringsInObject(object arg, Type argType)
    {
        var stringProperties = argType.GetProperties()
                                      .Where(p => p.PropertyType == typeof(string));

        foreach (var stringProperty in stringProperties)
        {
            string currentValue = stringProperty.GetValue(arg, null) as string;
            if (!string.IsNullOrEmpty(currentValue))
            {
                stringProperty.SetValue(arg, currentValue.Trim(), null);
            }
        }
    }
}

이를 사용하려면 전역 필터로 등록하거나 TrimInputStrings 속성으로 작업을 장식하십시오.

[TrimInputStrings]
public IActionResult Register(RegisterViewModel registerModel)
{
    // Some business logic...
    return Ok();
}