C# Language
Annotation des données
Recherche…
DisplayNameAttribute (attribut d'affichage)
DisplayName définit le nom d'affichage d'une propriété, d'un événement ou d'une méthode vide publique contenant 0 (0) arguments.
public class Employee
{
[DisplayName(@"Employee first name")]
public string FirstName { get; set; }
}
Exemple d'utilisation simple dans l'application XAML
<Window x:Class="WpfApplication.MainWindow"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:wpfApplication="clr-namespace:WpfApplication"
Height="100" Width="360" Title="Display name example">
<Window.Resources>
<wpfApplication:DisplayNameConverter x:Key="DisplayNameConverter"/>
</Window.Resources>
<StackPanel Margin="5">
<!-- Label (DisplayName attribute) -->
<Label Content="{Binding Employee, Converter={StaticResource DisplayNameConverter}, ConverterParameter=FirstName}" />
<!-- TextBox (FirstName property value) -->
<TextBox Text="{Binding Employee.FirstName, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" />
</StackPanel>
</Window>
namespace WpfApplication
{
/// <summary>
/// Interaction logic for MainWindow.xaml
/// </summary>
public partial class MainWindow : Window
{
private Employee _employee = new Employee();
public MainWindow()
{
InitializeComponent();
DataContext = this;
}
public Employee Employee
{
get { return _employee; }
set { _employee = value; }
}
}
}
namespace WpfApplication
{
public class DisplayNameConverter : IValueConverter
{
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
// Get display name for given instance type and property name
var attribute = value.GetType()
.GetProperty(parameter.ToString())
.GetCustomAttributes(false)
.OfType<DisplayNameAttribute>()
.FirstOrDefault();
return attribute != null ? attribute.DisplayName : string.Empty;
}
public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
{
throw new NotImplementedException();
}
}
}
EditableAttribute (attribut de modélisation de données)
EditableAttribute définit si les utilisateurs doivent pouvoir modifier la valeur de la propriété de classe.
public class Employee
{
[Editable(false)]
public string FirstName { get; set; }
}
Exemple d'utilisation simple dans l'application XAML
<Window x:Class="WpfApplication.MainWindow"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:wpfApplication="clr-namespace:WpfApplication"
Height="70" Width="360" Title="Display name example">
<Window.Resources>
<wpfApplication:EditableConverter x:Key="EditableConverter"/>
</Window.Resources>
<StackPanel Margin="5">
<!-- TextBox Text (FirstName property value) -->
<!-- TextBox IsEnabled (Editable attribute) -->
<TextBox Text="{Binding Employee.FirstName, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
IsEnabled="{Binding Employee, Converter={StaticResource EditableConverter}, ConverterParameter=FirstName}"/>
</StackPanel>
</Window>
namespace WpfApplication
{
/// <summary>
/// Interaction logic for MainWindow.xaml
/// </summary>
public partial class MainWindow : Window
{
private Employee _employee = new Employee() { FirstName = "This is not editable"};
public MainWindow()
{
InitializeComponent();
DataContext = this;
}
public Employee Employee
{
get { return _employee; }
set { _employee = value; }
}
}
}
namespace WpfApplication
{
public class EditableConverter : IValueConverter
{
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
// return editable attribute's value for given instance property,
// defaults to true if not found
var attribute = value.GetType()
.GetProperty(parameter.ToString())
.GetCustomAttributes(false)
.OfType<EditableAttribute>()
.FirstOrDefault();
return attribute != null ? attribute.AllowEdit : true;
}
public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
{
throw new NotImplementedException();
}
}
}
Attributs de validation
Les attributs de validation sont utilisés pour appliquer diverses règles de validation de manière déclarative aux classes ou aux membres de classe. Tous les attributs de validation proviennent de la classe de base ValidationAttribute .
Exemple: RequiredAttribute
Une fois validé via la méthode ValidationAttribute.Validate , cet attribut renvoie une erreur si la propriété Name est null ou ne contient que des espaces.
public class ContactModel
{
[Required(ErrorMessage = "Please provide a name.")]
public string Name { get; set; }
}
Exemple: StringLengthAttribute
StringLengthAttribute valide si une chaîne est inférieure à la longueur maximale d'une chaîne. Il peut éventuellement spécifier une longueur minimale. Les deux valeurs sont inclusives.
public class ContactModel
{
[StringLength(20, MinimumLength = 5, ErrorMessage = "A name must be between five and twenty characters.")]
public string Name { get; set; }
}
Exemple: RangeAttribute
Le RangeAttribute donne la valeur maximale et minimale pour un champ numérique.
public class Model
{
[Range(0.01, 100.00,ErrorMessage = "Price must be between 0.01 and 100.00")]
public decimal Price { get; set; }
}
Exemple: CustomValidationAttribute
La classe CustomValidationAttribute permet d' CustomValidationAttribute une méthode static personnalisée pour la validation. La méthode personnalisée doit être static ValidationResult [MethodName] (object input) .
public class Model
{
[CustomValidation(typeof(MyCustomValidation), "IsNotAnApple")]
public string FavoriteFruit { get; set; }
}
Déclaration de méthode:
public static class MyCustomValidation
{
public static ValidationResult IsNotAnApple(object input)
{
var result = ValidationResult.Success;
if (input?.ToString()?.ToUpperInvariant() == "APPLE")
{
result = new ValidationResult("Apples are not allowed.");
}
return result;
}
}
Création d'un attribut de validation personnalisé
Des attributs de validation personnalisés peuvent être créés en dérivant de la classe de base ValidationAttribute , puis en remplaçant virtual méthodes virtual si nécessaire.
[AttributeUsage(AttributeTargets.Property, AllowMultiple = false, Inherited = false)]
public class NotABananaAttribute : ValidationAttribute
{
public override bool IsValid(object value)
{
var inputValue = value as string;
var isValid = true;
if (!string.IsNullOrEmpty(inputValue))
{
isValid = inputValue.ToUpperInvariant() != "BANANA";
}
return isValid;
}
}
Cet attribut peut alors être utilisé comme ceci:
public class Model
{
[NotABanana(ErrorMessage = "Bananas are not allowed.")]
public string FavoriteFruit { get; set; }
}
Bases d'annotation des données
Les annotations de données permettent d'ajouter plus d'informations contextuelles aux classes ou aux membres d'une classe. Il existe trois grandes catégories d’annotations:
- Attributs de validation: ajout de critères de validation aux données
- Attributs d'affichage: spécifiez comment les données doivent être affichées à l'utilisateur
- Attributs de modélisation: ajoute des informations sur l'utilisation et la relation avec d'autres classes
Usage
Voici un exemple où deux ValidationAttribute et un DisplayAttribute sont utilisés:
class Kid
{
[Range(0, 18)] // The age cannot be over 18 and cannot be negative
public int Age { get; set; }
[StringLength(MaximumLength = 50, MinimumLength = 3)] // The name cannot be under 3 chars or more than 50 chars
public string Name { get; set; }
[DataType(DataType.Date)] // The birthday will be displayed as a date only (without the time)
public DateTime Birthday { get; set; }
}
Les annotations de données sont principalement utilisées dans des structures telles que ASP.NET. Par exemple, dans ASP.NET MVC , lorsqu'un modèle est reçu par une méthode de contrôleur, ModelState.IsValid() peut être utilisé pour indiquer si le modèle reçu respecte tous ses ValidationAttribute . DisplayAttribute est également utilisé dans ASP.NET MVC pour déterminer comment afficher les valeurs sur une page Web.
Exécuter manuellement les attributs de validation
La plupart du temps, les attributs de validation sont utilisés dans des frameworks (tels que ASP.NET). Ces frameworks prennent en charge l'exécution des attributs de validation. Mais que faire si vous voulez exécuter les attributs de validation manuellement? Utilisez simplement la classe Validator (pas de réflexion nécessaire).
Contexte de validation
Toute validation nécessite un contexte pour donner des informations sur ce qui est en cours de validation. Cela peut inclure diverses informations telles que l'objet à valider, certaines propriétés, le nom à afficher dans le message d'erreur, etc.
ValidationContext vc = new ValidationContext(objectToValidate); // The simplest form of validation context. It contains only a reference to the object being validated.
Une fois le contexte créé, il existe plusieurs façons de procéder à la validation.
Valider un objet et toutes ses propriétés
ICollection<ValidationResult> results = new List<ValidationResult>(); // Will contain the results of the validation
bool isValid = Validator.TryValidateObject(objectToValidate, vc, results, true); // Validates the object and its properties using the previously created context.
// The variable isValid will be true if everything is valid
// The results variable contains the results of the validation
Valider une propriété d'un objet
ICollection<ValidationResult> results = new List<ValidationResult>(); // Will contain the results of the validation
bool isValid = Validator.TryValidatePropery(objectToValidate.PropertyToValidate, vc, results, true); // Validates the property using the previously created context.
// The variable isValid will be true if everything is valid
// The results variable contains the results of the validation
Et plus
Pour en savoir plus sur la validation manuelle, voir: