C# Language
Annotazione dei dati
Ricerca…
DisplayNameAttribute (attributo di visualizzazione)
DisplayName imposta il nome visualizzato per un metodo property, event o public void con argomenti zero (0).
public class Employee
{
[DisplayName(@"Employee first name")]
public string FirstName { get; set; }
}
Semplice esempio di utilizzo nell'applicazione 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 (attributo di modellazione dati)
EditableAttribute stabilisce se gli utenti devono essere in grado di modificare il valore della proprietà della classe.
public class Employee
{
[Editable(false)]
public string FirstName { get; set; }
}
Semplice esempio di utilizzo nell'applicazione 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();
}
}
}
Attributi di convalida
Gli attributi di convalida vengono utilizzati per applicare varie regole di convalida in modo dichiarativo su classi o membri della classe. Tutti gli attributi di convalida derivano dalla classe base ValidationAttribute .
Esempio: RequiredAttribute
Se convalidato tramite il metodo ValidationAttribute.Validate , questo attributo restituirà un errore se la proprietà Name è null o contiene solo spazi.
public class ContactModel
{
[Required(ErrorMessage = "Please provide a name.")]
public string Name { get; set; }
}
Esempio: StringLengthAttribute
StringLengthAttribute convalida se una stringa è inferiore alla lunghezza massima di una stringa. Può facoltativamente specificare una lunghezza minima. Entrambi i valori sono inclusi.
public class ContactModel
{
[StringLength(20, MinimumLength = 5, ErrorMessage = "A name must be between five and twenty characters.")]
public string Name { get; set; }
}
Esempio: RangeAttribute
RangeAttribute fornisce il valore massimo e minimo per un campo numerico.
public class Model
{
[Range(0.01, 100.00,ErrorMessage = "Price must be between 0.01 and 100.00")]
public decimal Price { get; set; }
}
Esempio: CustomValidationAttribute
La classe CustomValidationAttribute consente di richiamare un metodo static personalizzato per la convalida. Il metodo personalizzato deve essere static ValidationResult [MethodName] (object input) .
public class Model
{
[CustomValidation(typeof(MyCustomValidation), "IsNotAnApple")]
public string FavoriteFruit { get; set; }
}
Dichiarazione del metodo:
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;
}
}
Creazione di un attributo di convalida personalizzato
Gli attributi di convalida personalizzati possono essere creati derivando dalla classe di base ValidationAttribute , quindi sovrascrivendo virtual metodi virtual secondo necessità.
[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;
}
}
Questo attributo può quindi essere usato in questo modo:
public class Model
{
[NotABanana(ErrorMessage = "Bananas are not allowed.")]
public string FavoriteFruit { get; set; }
}
Nozioni di base sull'annotazione dei dati
Le annotazioni dei dati sono un modo per aggiungere più informazioni contestuali alle classi o ai membri di una classe. Esistono tre categorie principali di annotazioni:
- Attributi di convalida: aggiungi criteri di convalida ai dati
- Visualizza attributi: specifica come i dati devono essere visualizzati all'utente
- Attributi di modellazione: aggiungi informazioni sull'utilizzo e sulla relazione con altre classi
uso
Ecco un esempio in cui vengono utilizzati due ValidationAttribute e uno DisplayAttribute :
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; }
}
Le annotazioni dei dati sono utilizzate principalmente in framework come ASP.NET. Ad esempio, in ASP.NET MVC , quando un modello viene ricevuto da un metodo controller, ModelState.IsValid() può essere utilizzato per determinare se il modello ricevuto rispetta tutto il suo ValidationAttribute . DisplayAttribute viene anche utilizzato in ASP.NET MVC per determinare come visualizzare i valori su una pagina Web.
Esegui manualmente gli attributi di convalida
La maggior parte delle volte, gli attributi di convalida sono utilizzati all'interno di framework (come ASP.NET). Questi framework si occupano dell'esecuzione degli attributi di convalida. Ma cosa succede se si desidera eseguire manualmente gli attributi di convalida? Basta usare la classe Validator (nessuna riflessione necessaria).
Contesto di validazione
Qualsiasi convalida necessita di un contesto per fornire alcune informazioni su ciò che viene convalidato. Questo può includere varie informazioni come l'oggetto da convalidare, alcune proprietà, il nome da visualizzare nel messaggio di errore, ecc.
ValidationContext vc = new ValidationContext(objectToValidate); // The simplest form of validation context. It contains only a reference to the object being validated.
Una volta creato il contesto, ci sono molti modi per fare la convalida.
Convalidare un oggetto e tutte le sue proprietà
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
Convalidare una proprietà di un oggetto
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
E altro ancora
Per saperne di più sulla convalida manuale vedi: