/// <summary>
/// Sets property value and returns the same container.
/// </summary>
/// <param name="propertyContainer">MutablePropertyContainer.</param>
/// <param name="property">Property to set.</param>
/// <param name="value">Value to set.</param>
/// <param name="valueSource">Value source.</param>
/// <returns>The same container with changed property.</returns>
public static IMutablePropertyContainer WithValueUntyped(this IMutablePropertyContainer propertyContainer, IProperty property, object?value, ValueSource?valueSource = default)
{
propertyContainer.AssertArgumentNotNull(nameof(propertyContainer));
property.AssertArgumentNotNull(nameof(property));
propertyContainer.SetValueUntyped(property, value, valueSource);
return(propertyContainer);
}
/// <summary>
/// Adds untyped validation to property metadata <see cref="IPropertyValidationRules"/>.
/// </summary>
/// <param name="property">Source property.</param>
/// <param name="validationRule">Validation rule.</param>
/// <returns>The same property.</returns>
public static IProperty AddValidation(this IProperty property, IValidationRule validationRule)
{
property.AssertArgumentNotNull(nameof(property));
validationRule.AssertArgumentNotNull(nameof(validationRule));
return(property.ConfigureMetadata <IProperty, IPropertyValidationRules>(
createMetadata: CreatePropertyValidationRules,
configureMetadata: propertyValidation => propertyValidation.AddRule(validationRule)));
}
/// <summary>
/// Sets property value and returns the same container.
/// </summary>
/// <typeparam name="TContainer">Property container type.</typeparam>
/// <typeparam name="T">Property type.</typeparam>
/// <param name="propertyContainer">MutablePropertyContainer.</param>
/// <param name="property">Property to set.</param>
/// <param name="value">Value to set.</param>
/// <param name="valueSource">Value source.</param>
/// <returns>The same container with changed property.</returns>
public static TContainer WithValue <TContainer, T>(this TContainer propertyContainer, IProperty <T> property, T value, ValueSource?valueSource = default)
where TContainer : IMutablePropertyContainer
{
propertyContainer.AssertArgumentNotNull(nameof(propertyContainer));
property.AssertArgumentNotNull(nameof(property));
propertyContainer.SetValue(property, value, valueSource);
return(propertyContainer);
}
/// <summary>
/// Sets value for property.
/// </summary>
/// <typeparam name="T">Property type.</typeparam>
/// <param name="property">Property.</param>
/// <param name="value">Value to store.</param>
/// <param name="valueSource">Value source.</param>
/// <returns><see cref="IPropertyValue{T}"/> that holds value for property.</returns>
public IPropertyValue <T> SetValue <T>(IProperty <T> property, T?value, ValueSource?valueSource = default)
{
property.AssertArgumentNotNull(nameof(property));
var propertyValue = PropertyValueFactory.Default.Create(property, value, valueSource);
SetValue(propertyValue);
return(propertyValue);
}
/// <summary>
/// Sets <see cref="IPropertyValidationRule{T}"/>.
/// Replaces property metadata <see cref="IPropertyValidationRules"/>.
/// </summary>
/// <typeparam name="T">Property value type.</typeparam>
/// <param name="property">Source property.</param>
/// <param name="validation">Property validation.</param>
/// <returns>The same property.</returns>
public static IProperty <T> SetValidation <T>(this IProperty <T> property, Func <IProperty <T>, IPropertyValidationRule <T> > validation)
{
property.AssertArgumentNotNull(nameof(property));
validation.AssertArgumentNotNull(nameof(validation));
IPropertyValidationRule <T> validationRule = validation(property);
IPropertyValidationRules validationRules = new PropertyValidationRules(property, new[] { validationRule });
return(property.SetMetadata <IProperty <T>, IPropertyValidationRules>(validationRules));
}
/// <summary>
/// Sets property value if property is not set.
/// </summary>
/// <typeparam name="T">Property type.</typeparam>
/// <param name="propertyContainer">Property container.</param>
/// <param name="property">Property to set.</param>
/// <param name="value">Value to set.</param>
public static void SetValueIfNotSet <T>(this IMutablePropertyContainer propertyContainer, IProperty <T> property, [AllowNull] T value)
{
propertyContainer.AssertArgumentNotNull(nameof(propertyContainer));
property.AssertArgumentNotNull(nameof(property));
var propertyValue = propertyContainer.GetPropertyValueUntyped(property, SearchOptions.ExistingOnly);
if (propertyValue.IsNullOrNotDefined())
{
propertyContainer.SetValue(property, value !);
}
}
/// <inheritdoc />
public IPropertyValue <T>?RemoveValue <T>(IProperty <T> property)
{
property.AssertArgumentNotNull(nameof(property));
IPropertyValue?propertyValue = this.GetPropertyValueUntyped(property);
if (propertyValue != null)
{
_propertyValues.Remove(propertyValue);
}
return((IPropertyValue <T>?)propertyValue);
}
/// <summary>
/// Adds <see cref="IPropertyValidationRule{T}"/> to metadata <see cref="IPropertyValidationRules"/>.
/// </summary>
/// <typeparam name="T">Property value type.</typeparam>
/// <param name="property">Source property.</param>
/// <param name="validation">Property validation.</param>
/// <returns>The same property.</returns>
public static IProperty <T> AddValidation <T>(this IProperty <T> property, Func <IProperty <T>, IPropertyValidationRule <T> > validation)
{
property.AssertArgumentNotNull(nameof(property));
validation.AssertArgumentNotNull(nameof(validation));
return(property.ConfigureMetadata <IProperty <T>, IPropertyValidationRules>(
createMetadata: CreatePropertyValidationRules,
configureMetadata: propertyValidation =>
{
IPropertyValidationRule <T> validationRule = validation(property);
return propertyValidation.AddRule(validationRule);
}));
}
/// <summary>
/// Gets property and value for untyped property using search conditions.
/// Uses simple untyped search `SearchPropertyValueUntyped` if CanUseSimpleUntypedSearch or `property` has type <see cref="Search.UntypedSearch"/>.
/// Uses full `GetPropertyValue{T}` based on property.Type in other cases.
/// </summary>
/// <param name="propertyContainer">Property container.</param>
/// <param name="property">Property to search.</param>
/// <param name="search">Search conditions.</param>
/// <returns><see cref="IPropertyValue"/> or null.</returns>
public static IPropertyValue?GetPropertyValueUntyped(
this IPropertyContainer propertyContainer,
IProperty property,
SearchOptions?search = default)
{
propertyContainer.AssertArgumentNotNull(nameof(propertyContainer));
property.AssertArgumentNotNull(nameof(property));
if ((search ?? propertyContainer.SearchOptions).CanUseSimpleUntypedSearch() || property.Type == typeof(Search.UntypedSearch))
{
return(propertyContainer.SearchPropertyValueUntyped(property, search));
}
return(GetPropertyValueUntypedFull(propertyContainer, property, search));
/// <summary>
/// Initializes a new instance of the <see cref="Exists{T}"/> class.
/// </summary>
/// <param name="property">Property to check.</param>
public Exists(IProperty <T> property)
{
Property = property.AssertArgumentNotNull(nameof(property));
this.SetDefaultMessageFormat("{propertyName} is not exists.");
}
/// <summary>
/// Initializes a new instance of the <see cref="PropertyValue{T}"/> class.
/// </summary>
/// <param name="property">Source property.</param>
/// <param name="value">Value for property.</param>
/// <param name="source">The source for value.</param>
public PropertyValue(IProperty <T> property, T value, ValueSource source = null)
{
Property = property.AssertArgumentNotNull(nameof(property));
Value = value;
Source = source ?? ValueSource.Defined;
}
/// <summary>
/// Initializes a new instance of the <see cref="PropertyMapper{TSource, TTarget}"/> class.
/// </summary>
/// <param name="sourceProperty">Source property.</param>
/// <param name="targetProperty">Target property.</param>
/// <param name="valueMapper">Value mapper.</param>
public PropertyMapper(IProperty <TSource> sourceProperty, IProperty <TTarget> targetProperty, IValueMapper <TSource, TTarget> valueMapper)
{
SourceProperty = sourceProperty.AssertArgumentNotNull(nameof(sourceProperty));
TargetProperty = targetProperty.AssertArgumentNotNull(nameof(targetProperty));
ValueMapper = valueMapper.AssertArgumentNotNull(nameof(valueMapper));
}
/// <inheritdoc/>
public IPropertyValue CreateUntyped(IProperty property, object?value, ValueSource?valueSource = null)
{
property.AssertArgumentNotNull(nameof(property));
return(_propertyValuesCache.GetOrAdd(new PropertyValueInfo(property, value, valueSource, _propertyValueFactory), propertyValueInfo => CreatePropertyValueUntyped(propertyValueInfo)));
}
/// <summary>
/// Initializes a new instance of the <see cref="Required{T}"/> class.
/// </summary>
/// <param name="property">Property to check.</param>
public Required(IProperty <T> property)
{
Property = property.AssertArgumentNotNull(nameof(property));
}
/// <summary>
/// Initializes a new instance of the <see cref="PropertyValidationRules"/> class.
/// </summary>
/// <param name="property">Property.</param>
/// <param name="validationRules">Validation rules for property.</param>
public PropertyValidationRules(IProperty property, IReadOnlyCollection <IValidationRule>?validationRules = null)
{
Property = property.AssertArgumentNotNull(nameof(property));
Rules = validationRules ?? Array.Empty <IValidationRule>();
}
/// <summary>
/// Gets validation rules attached to property.
/// Rules are stored in <see cref="IPropertyValidationRules"/> metadata.
/// </summary>
/// <param name="property">Source property.</param>
/// <returns>Validation rules.</returns>
public static IEnumerable <IValidationRule> GetValidationRules(this IProperty property)
{
property.AssertArgumentNotNull(nameof(property));
return(property.GetSchemaMetadata <IPropertyValidationRules>()?.Rules ?? Array.Empty <IValidationRule>());
}
/// <summary>
/// Initializes a new instance of the <see cref="PropertyValidationRule{T}"/> class.
/// </summary>
/// <param name="property">Property to check.</param>
/// <param name="defaultMessageFormat">Default message format for validation message.</param>
protected PropertyValidationRule(IProperty <T> property, string?defaultMessageFormat = null)
{
Property = property.AssertArgumentNotNull(nameof(property));
this.SetDefaultMessageFormat(defaultMessageFormat);
}
/// <summary>
/// Initializes a new instance of the <see cref="BasePropertyRule{T}"/> class.
/// </summary>
/// <param name="property">Property to check.</param>
/// <param name="defaultMessageFormat">Default message format for validation message.</param>
protected BasePropertyRule(IProperty <T> property, string defaultMessageFormat)
{
Property = property.AssertArgumentNotNull(nameof(property));
this.SetDefaultMessageFormat(defaultMessageFormat);
}
/// <inheritdoc />
public IPropertyValue <T> Create <T>(IProperty <T> property, T?value, ValueSource?valueSource = null)
{
property.AssertArgumentNotNull(nameof(property));
return((IPropertyValue <T>)_propertyValuesCache.GetOrAdd(new PropertyValueInfo(property, value, valueSource, _propertyValueFactory), propertyValueInfo => CreatePropertyValue <T>(propertyValueInfo)));
}
