C# Language
Adnotacja danych
Szukaj…
DisplayNameAttribute (atrybut display)
DisplayName ustawia nazwę wyświetlaną dla właściwości, zdarzenia lub metody void publicznej z zerowymi (0) argumentami.
public class Employee
{
[DisplayName(@"Employee first name")]
public string FirstName { get; set; }
}
Prosty przykład użycia w aplikacji 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 (atrybut modelowania danych)
EditableAttribute określa, czy użytkownicy powinni mieć możliwość zmiany wartości właściwości class.
public class Employee
{
[Editable(false)]
public string FirstName { get; set; }
}
Prosty przykład użycia w aplikacji 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();
}
}
}
Atrybuty walidacji
Atrybuty sprawdzania poprawności są używane do wymuszania różnych reguł sprawdzania poprawności w sposób deklaratywny dla klas lub członków klasy. Wszystkie atrybuty sprawdzania poprawności pochodzą z podstawowej klasy ValidationAttribute .
Przykład: RequiredAttribute
Po sprawdzeniu poprawności za pomocą metody ValidationAttribute.Validate ten atrybut zwróci błąd, jeśli właściwość Name ma wartość NULL lub zawiera tylko białe znaki.
public class ContactModel
{
[Required(ErrorMessage = "Please provide a name.")]
public string Name { get; set; }
}
Przykład: StringLengthAttribute
StringLengthAttribute sprawdza, czy łańcuch jest mniejszy niż maksymalna długość łańcucha. Opcjonalnie może określić minimalną długość. Obie wartości są włączone.
public class ContactModel
{
[StringLength(20, MinimumLength = 5, ErrorMessage = "A name must be between five and twenty characters.")]
public string Name { get; set; }
}
Przykład: RangeAttribute
RangeAttribute podaje maksymalną i minimalną wartość dla pola numerycznego.
public class Model
{
[Range(0.01, 100.00,ErrorMessage = "Price must be between 0.01 and 100.00")]
public decimal Price { get; set; }
}
Przykład: CustomValidationAttribute
Klasa CustomValidationAttribute umożliwia wywołanie niestandardowej metody static w celu sprawdzenia poprawności. Metodą niestandardową musi być static ValidationResult [MethodName] (object input) .
public class Model
{
[CustomValidation(typeof(MyCustomValidation), "IsNotAnApple")]
public string FavoriteFruit { get; set; }
}
Deklaracja metody:
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;
}
}
Tworzenie niestandardowego atrybutu sprawdzania poprawności
Niestandardowe atrybuty sprawdzania poprawności można utworzyć, wywodząc się z podstawowej klasy ValidationAttribute , a następnie zastępując w razie potrzeby metody virtual .
[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;
}
}
Tego atrybutu można następnie użyć w następujący sposób:
public class Model
{
[NotABanana(ErrorMessage = "Bananas are not allowed.")]
public string FavoriteFruit { get; set; }
}
Podstawy adnotacji danych
Adnotacje danych to sposób dodawania bardziej kontekstowych informacji do klas lub członków klasy. Istnieją trzy główne kategorie adnotacji:
- Atrybuty walidacji: dodaj kryteria walidacji do danych
- Wyświetl atrybuty: określ, w jaki sposób dane powinny być wyświetlane użytkownikowi
- Modelowanie atrybutów: dodaj informacje o użyciu i relacjach z innymi klasami
Stosowanie
Oto przykład, w którym zastosowano dwa ValidationAttribute i jeden 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; }
}
Adnotacje danych są najczęściej używane w ramach takich jak ASP.NET. Na przykład w ASP.NET MVC , gdy model jest odbierany metodą kontrolera, można użyć ModelState.IsValid() aby stwierdzić, czy otrzymany model przestrzega wszystkich swoich ValidationAttribute . DisplayAttribute jest także używany w ASP.NET MVC do określania sposobu wyświetlania wartości na stronie internetowej.
Ręcznie wykonaj atrybuty sprawdzania poprawności
W większości przypadków atrybuty sprawdzania poprawności są używane w ramach (np. ASP.NET). Ramy te wykonują atrybuty sprawdzania poprawności. Ale co, jeśli chcesz ręcznie wykonać atrybuty sprawdzania poprawności? Wystarczy użyć klasy Validator (nie wymaga odbicia).
Kontekst walidacji
Każda walidacja wymaga kontekstu, aby podać informacje o tym, co jest sprawdzane. Może to obejmować różne informacje, takie jak sprawdzany obiekt, niektóre właściwości, nazwę wyświetlaną w komunikacie o błędzie itp.
ValidationContext vc = new ValidationContext(objectToValidate); // The simplest form of validation context. It contains only a reference to the object being validated.
Po utworzeniu kontekstu istnieje wiele sposobów sprawdzania poprawności.
Sprawdź poprawność obiektu i wszystkich jego właściwości
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
Sprawdź poprawność właściwości obiektu
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
I więcej
Aby dowiedzieć się więcej na temat ręcznej weryfikacji, zobacz: