warum ASP.Net MVC-Range-Attribut nehmen eine Art?

Ich fand die Reihe ctor Sie erwähnt fischig. Konnte nicht umhin, zu untersuchen. (So schrieb ich diese Antwort wie ein log während der Untersuchung.)

Vom MSDN

public RangeAttribute(
    Type type,
    string minimum,
    string maximum
)

Hinweis : MSDN sagt der Type sollte IComparable. Und, Ihrem Beispiel die Beschreibung sagt seine für ein date Vergleich, wenn nicht!.

So, da hatte ich meine Produktion asp.net mvc3 app geöffnet, ich habe versucht, diese auf ein mit einem Datum-Zeit wie dieser:

[Range(typeof(DateTime),"1-Jan-1910","1-Jan-2060")]

Wenn ich es laufen lasse passiert das:

Hinweis, wie obwohl ich angegeben das minimum und maximum mit gestrichelten und keine Zeit, es gibt ein anderes format, so dass Ihr wahrscheinlich TryParsing die Saiten richtig? Aber ich bin sicher, es ist nicht möglich, sich ICompare die zwei auf der client-Seite!? Nun, egal welches Datum ich angebe, zeigt immer noch den Fehler. (Das Datum wird eingegeben als 11-Mar-20 (20 in 2020).)

Ich habe versucht, char (unten), da das ein IComparable zu. Gleiche Sache. Es kann nicht wirklich tun, zu verwalten eine Reihe Vergleich auf die client-Seite.

[Range(typeof(char), "a", "g")]

Aber warten...

Entfernen Sie einfach das Client-Validierung! Ich Entfernt und Verweise auf die JQuery-Validierung und Unaufdringlich Validierung und viola! Es funktioniert perfekt. Es Beiträge, dann zeigt den Fehler richtig, wenn die Werte (Sowohl Char und Date) sind NICHT innerhalb des angegebenen Bereichs.

Hinweis: Vielleicht kann jemand erweitern Sie diese Lösung, um die Deaktivierung NUR bestimmte Felder für den client-Validierung.

Ich hoffe, das war hilfreich.

InformationsquelleAutor gideon

Ich landete erstellen einer benutzerdefinierten DateRangeAttribute wie beschrieben hier.
Sie nicht bekommen, client-seitige Validierung, aber Sie können anpassen, um Ihre Bedürfnisse anzupassen und sich nicht mehr mit javascript erforderlich. Hier der code, und wie man es verwendet:

public class Person
{
    [Required]
    public string FirstName { get; set; }

    [DataType(DataType.Date)]
    [DateRange("2010/12/01", "2010/12/16")]
    public DateTime DateOfBirth { get; set; }
}

DateRange ist einfach:

public class DateRangeAttribute : ValidationAttribute
{
    private const string DateFormat = "yyyy/MM/dd";
    private const string DefaultErrorMessage = "'{0}' must be a date between {1:d} and {2:d}.";

    public DateTime MinDate { get; set; }
    public DateTime MaxDate { get; set; }

    public DateRangeAttribute(string minDate, string maxDate)
        : base(DefaultErrorMessage)
    {
        MinDate = ParseDate(minDate);
        MaxDate = ParseDate(maxDate);
    }

    public override bool IsValid(object value)
    {
        if (value == null || !(value is DateTime))
        {
            return true;
        }
        DateTime dateValue = (DateTime)value;
        return MinDate <= dateValue && dateValue <= MaxDate;
    }

    public override string FormatErrorMessage(string name)
    {
        return String.Format(CultureInfo.CurrentCulture, ErrorMessageString,
            name, MinDate, MaxDate);
    }

    private static DateTime ParseDate(string dateValue)
    {
        return DateTime.ParseExact(dateValue, DateFormat, CultureInfo.InvariantCulture);
    }
}

InformationsquelleAutor Alex

Können Sie die unten benutzerdefinierten Datumsbereich Validierung vergleicht den Wert des Datums, sofern min-und max-Datum oder erwähnt abhängige Eigenschaften. Es zeigt auch die client-seitige Validierung Unterstützung und integration.

CustomDateRange

public enum CustomDateRangeType
{
///<summary>
///The direct value of property.
///</summary>
Value,

///<summary>
///The dependent property.
///</summary>
DependentProperty
}

///<summary>
///The CustomDateComparAttribute Validator
///</summary>
[AttributeUsage(AttributeTargets.All | AttributeTargets.Property,        AllowMultiple = false, Inherited = true)]
 public sealed class CustomDateRangeAttribute : ValidationAttribute,  IClientValidatable
 {

private const string UniversalDatePattern = "yyyy-M-d";

///<summary>
///The min date.
///</summary>
private string minDate;

///<summary>
///The max date.
///</summary>
private string maxDate;

///<summary>
///The date range type
///</summary>
private CustomDateRangeType dateRangeType;

///<summary>
///Initializes a new instance of the <see cref="CustomDateRangeAttribute"/> class.
///</summary>
///<param name="minDate">
///The min date in <example>yyyy-M-d</example> format. Throws FormatException exception if not provided in specified format.
///</param>
///<param name="maxDate">
///max date in <example>yyyy-M-d</example> format. Throws FormatException exception if not provided in specified format.
///</param>
public CustomDateRangeAttribute(string minDate, string maxDate)
    : this(CustomDateRangeType.Value, minDate, maxDate)
{
}

///<summary>
///Initializes a new instance of the <see cref="CustomDateRangeAttribute" /> class.
///</summary>
///<param name="dateRangeType">Type of the date range.</param>
///<param name="minDate">The minimum date dependent property or value. If value then it should be <example>yyyy-M-d</example> format.</param>
///<param name="maxDate">The maximum date property or value. If value then it should be <example>yyyy-M-d</example> format.</param>
public CustomDateRangeAttribute(CustomDateRangeType dateRangeType, string minDate, string maxDate)
{
    if (dateRangeType == CustomDateRangeType.Value)
    {
        if (!IsValidDate(minDate))
        {
            throw new FormatException(string.Format(CultureInfo.InvariantCulture, "Max date should be in {0} format.", UniversalDatePattern));
        }

        if (!IsValidDate(maxDate))
        {
            throw new FormatException(string.Format(CultureInfo.InvariantCulture, "Min date should be in {0} format.", UniversalDatePattern));
        }
    }

    this.dateRangeType = dateRangeType;
    this.minDate = minDate;
    this.maxDate = maxDate;
}

///<summary>
///Gets the min date.
///</summary>
public string MinDate
{
    get
    {
        return this.minDate;
    }
}

///<summary>
///Gets the max date.
///</summary>
public string MaxDate
{
    get
    {
        return this.maxDate;
    }
}

///<summary>
///Gets the type of the date range.
///</summary>
///<value>
///The type of the date range.
///</value>
public CustomDateRangeType DateRangeType
{
    get
    {
        return this.dateRangeType;
    }
}

///<summary>
///gets client validation rules
///</summary>
///<param name="metadata">
///meta data parameter
///</param>
///<param name="context">
///controller context
///</param>
///<returns>
///client validation rule
///</returns>
public IEnumerable<ModelClientValidationRule> GetClientValidationRules(
    ModelMetadata metadata,
    ControllerContext context)
{
    if (metadata != null)
    {
        return new[]
                   {
                       new ModelClientValidationCustomDateRangeRule(
                           this.ErrorMessageString,
                           this.DateRangeType,
                           this.MinDate,
                           metadata.PropertyName,
                           this.MaxDate)
                   };
    }

    return null;
}

///<summary>
///overridden method
///</summary>
///<param name="value">
///value to be compared
///</param>
///<param name="validationContext">
///validation context
///</param>
///<returns>
///validation result
///</returns>
protected override ValidationResult IsValid(object value, ValidationContext validationContext)
{
    var result = ValidationResult.Success;
    var errorResult = new ValidationResult(this.ErrorMessageString);
    if (value == null)
    {
        return result;
    }

    DateTime dateValue = (DateTime)value;

    if (this.DateRangeType == CustomDateRangeType.Value)
    {
        if (ParseDate(this.MinDate) <= dateValue && dateValue <= ParseDate(this.MaxDate))
        {
            return result;
        }
    }
    else
    {
        if (validationContext == null || string.IsNullOrEmpty(this.MinDate) || string.IsNullOrEmpty(this.MaxDate))
        {
            return errorResult;
        }

        var minDatePropertyInfo = validationContext.ObjectType.GetProperty(this.MinDate);
        var maxDatePropertyInfo = validationContext.ObjectType.GetProperty(this.MaxDate);
        if (minDatePropertyInfo == null || maxDatePropertyInfo == null)
        {
            return errorResult;
        }

        var minDateValue = Convert.ToDateTime(
            minDatePropertyInfo.GetValue(validationContext.ObjectInstance, null), 
            CultureInfo.CurrentCulture);
        var maxDateValue = Convert.ToDateTime(maxDatePropertyInfo.GetValue(validationContext.ObjectInstance, null), 
            CultureInfo.CurrentCulture);

        if (minDateValue <= dateValue && dateValue <= maxDateValue)
        {
            return result;
        }
    }

    return errorResult;
}

///<summary>
///The parse date.
///</summary>
///<param name="dateValue">
///The date value.
///</param>
///<returns>
///The <see cref="DateTime"/>.
///</returns>
private static DateTime ParseDate(string dateValue)
{
    return DateTime.ParseExact(
        dateValue, UniversalDatePattern, 
        CultureInfo.InvariantCulture);
}

///<summary>
///The is valid date.
///</summary>
///<param name="dateValue">
///The date value.
///</param>
///<returns>
///A value indicating whether the provided dateValue is a valid date.
///</returns>
private static bool IsValidDate(string dateValue)
{
    DateTime? date = null;
    var regex = new Regex(@"\d{4}-\d{1,2}-\d{1,2}");
    if (regex.IsMatch(dateValue))
    {
        var dateParts = dateValue.Split('-');
        if (dateParts.Length == 3)
        {
            date = new DateTime(
                Convert.ToInt32(dateParts[0], CultureInfo.InvariantCulture),
                Convert.ToInt32(dateParts[1], CultureInfo.InvariantCulture),
                Convert.ToInt32(dateParts[2], CultureInfo.InvariantCulture));
        }
    }

    return date != null;
}

///<summary>
///    ModelClientValidationCustomCompareRule class
///</summary>
private class ModelClientValidationCustomDateRangeRule : ModelClientValidationRule
{
    ///<summary>
    ///Initializes a new instance of the <see cref="ModelClientValidationCustomDateRangeRule"/> class.
    ///</summary>
    ///<param name="errorMessage">error message</param>
    ///<param name="dateRangeType">Type of the date range.</param>
    ///<param name="minDateProperty">The minimum date property.</param>
    ///<param name="currentProperty">The current property.</param>
    ///<param name="maxDateProperty">The maximum date property.</param>
    public ModelClientValidationCustomDateRangeRule(
        string errorMessage,
        CustomDateRangeType dateRangeType,
        string minDateProperty,
        string currentProperty,
        string maxDateProperty)
    {
        this.ErrorMessage = errorMessage;
        this.ValidationType = "customdaterange";
        this.ValidationParameters.Add("daterangetypeproperty", dateRangeType.ToString());
        this.ValidationParameters.Add("mindateproperty", minDateProperty);
        this.ValidationParameters.Add("currentproperty", currentProperty);
        this.ValidationParameters.Add("maxdateproperty", maxDateProperty);
    }
}
}

Clientseitiger Integration

(function ($) {
jQuery.validator.addMethod('customdaterange', function (value, element, param) {
    if (value == '' || value == undefined) {
        return true;
    }

    var minValue;
    var maxValue;

    if (param.daterangetypeproperty == "DependentProperty") {
        var minDateValue = $('#' + param.mindateproperty).val();
        var maxDateValue = $('#' + param.maxdateproperty).val();
        minValue = new Date(minDateValue);
        maxValue = new Date(maxDateValue);
    } else {
        minValue = new Date(param.mindateproperty);
        maxValue = new Date(param.maxdateproperty);
    }

    var currentValue = new Date(value);
    if (minValue <= currentValue && currentValue <= maxValue) {
        return true;
    }

    return false;
});

jQuery.validator.unobtrusive.adapters.add('customdaterange', ['daterangetypeproperty', 'mindateproperty', 'currentproperty', 'maxdateproperty'], function (options) {
    var params = {
        daterangetypeproperty: options.params.daterangetypeproperty,
        mindateproperty: options.params.mindateproperty,
        currentproperty: options.params.currentproperty,
        maxdateproperty: options.params.maxdateproperty
    };

    options.rules['customdaterange'] = params;
    if (options.message) {
        options.messages['customdaterange'] = options.message;
    }
});
}(jQuery));

Demo

Modell

public class DateRangeModel
{
public DateRangeModel()
{
    this.MinDateDependentProperty = new DateTime(DateTime.Today.Year, DateTime.Today.Month, 1);
    this.MaxDateDependentProperty = DateTime.Today.AddDays(1 - DateTime.Today.Day).AddMonths(1);
}

[Required]
[CustomDateRange("2015-10-01", "2015-10-15", ErrorMessage = "Date value is not in range.")]
[DataType(DataType.Date)]
public DateTime DateCompareWithMinMaxValue { get; set; }

[Required]
[CustomDateRange(CustomDateRangeType.DependentProperty, "MinDateDependentProperty", "MaxDateDependentProperty", 
    ErrorMessage = "Date to select value is not in range.")]
[DataType(DataType.Date)]
public DateTime DateCompareWithMinMaxDependentProperty { get; set; }

[Required]
[DataType(DataType.Date)]
public DateTime MinDateDependentProperty { get; set; }

[Required]
[DataType(DataType.Date)]
public DateTime MaxDateDependentProperty { get; set; }
}

Datum steuert mit Validierungen

Laden Sie die komplette Umsetzung von hier.

InformationsquelleAutor Amit Gupta