/// <summary> /// <para> /// Sets the <see cref="PropertyAccessMode" /> to use for all properties of this entity type. /// </para> /// <para> /// By default, the backing field, if one is found by convention or has been specified, is used when /// new objects are constructed, typically when entities are queried from the database. /// Properties are used for all other accesses. Calling this method will change that behavior /// for all properties of this entity type as described in the <see cref="PropertyAccessMode" /> enum. /// </para> /// <para> /// Calling this method overrides for all properties of this entity type any access mode that was /// set on the model. /// </para> /// </summary> /// <param name="propertyAccessMode"> The <see cref="PropertyAccessMode" /> to use for properties of this entity type. </param> /// <returns> The same builder instance so that multiple configuration calls can be chained. </returns> public new virtual OwnedNavigationBuilder <TEntity, TDependentEntity> UsePropertyAccessMode(PropertyAccessMode propertyAccessMode) => (OwnedNavigationBuilder <TEntity, TDependentEntity>)base.UsePropertyAccessMode(propertyAccessMode);
/// <summary>
/// <para>
/// Sets the <see cref="PropertyAccessMode" /> to use for all properties of this entity type.
/// </para>
/// <para>
/// By default, the backing field, if one is found by convention or has been specified, is used when
/// new objects are constructed, typically when entities are queried from the database.
/// Properties are used for all other accesses. Calling this method will change that behavior
/// for all properties in the model as described in the <see cref="PropertyAccessMode" /> enum.
/// </para>
/// </summary>
/// <param name="propertyAccessMode"> The <see cref="PropertyAccessMode" /> to use for properties of this model. </param>
/// <returns>
/// The same <see cref="ModelBuilder" /> instance so that additional configuration calls can be chained.
/// </returns>
public virtual ModelBuilder UsePropertyAccessMode(PropertyAccessMode propertyAccessMode)
{
Builder.UsePropertyAccessMode(propertyAccessMode, ConfigurationSource.Explicit);
return(this);
}
public override TestEntityTypeBuilder <TEntity> UsePropertyAccessMode(PropertyAccessMode propertyAccessMode) => Wrap(EntityTypeBuilder.UsePropertyAccessMode(propertyAccessMode));
public override TestReferenceOwnershipBuilder <TEntity, TRelatedEntity> UsePropertyAccessMode(
PropertyAccessMode propertyAccessMode)
=> Wrap(ReferenceOwnershipBuilder.UsePropertyAccessMode(propertyAccessMode));
/// <summary>
/// <para>
/// Sets the <see cref="PropertyAccessMode" /> to use for all properties of this entity type.
/// </para>
/// <para>
/// By default, the backing field, if one is found by convention or has been specified, is used when
/// new objects are constructed, typically when entities are queried from the database.
/// Properties are used for all other accesses. Calling this method witll change that behavior
/// for all properties of this entity type as described in the <see cref="PropertyAccessMode" /> enum.
/// </para>
/// <para>
/// Calling this method overrrides for all properties of this entity type any access mode that was
/// set on the model.
/// </para>
/// </summary>
/// <param name="propertyAccessMode"> The <see cref="PropertyAccessMode" /> to use for properties of this entity type. </param>
/// <returns> The same builder instance so that multiple configuration calls can be chained. </returns>
public virtual ReferenceOwnershipBuilder UsePropertyAccessMode(PropertyAccessMode propertyAccessMode)
{
RelatedEntityType.Builder.UsePropertyAccessMode(propertyAccessMode, ConfigurationSource.Explicit);
return(this);
}
public override TestNavigationBuilder UsePropertyAccessMode(PropertyAccessMode propertyAccessMode) => new NonGenericTestNavigationBuilder(NavigationBuilder.UsePropertyAccessMode(propertyAccessMode));
/// <summary> /// <para> /// Sets the <see cref="PropertyAccessMode" /> to use for this property. /// </para> /// <para> /// By default, the backing field, if one is found by convention or has been specified, is used when /// new objects are constructed, typically when entities are queried from the database. /// Properties are used for all other accesses. Calling this method will change that behavior /// for this property as described in the <see cref="PropertyAccessMode" /> enum. /// </para> /// <para> /// Calling this method overrides for this property any access mode that was set on the /// entity type or model. /// </para> /// </summary> /// <param name="propertyAccessMode"> The <see cref="PropertyAccessMode" /> to use for this property. </param> /// <returns> The same builder instance so that multiple configuration calls can be chained. </returns> public new virtual NavigationBuilder <TSource, TTarget> UsePropertyAccessMode(PropertyAccessMode propertyAccessMode) => (NavigationBuilder <TSource, TTarget>)base.UsePropertyAccessMode(propertyAccessMode);
public abstract TestOwnedNavigationBuilder <TEntity, TDependentEntity> UsePropertyAccessMode(
PropertyAccessMode propertyAccessMode);
public abstract TestCollectionOwnershipBuilder <TEntity, TDependentEntity> UsePropertyAccessMode(
PropertyAccessMode propertyAccessMode);
public override TestQueryTypeBuilder <TQuery> UsePropertyAccessMode(PropertyAccessMode propertyAccessMode) => Wrap(QueryTypeBuilder.UsePropertyAccessMode(propertyAccessMode));
/// <summary> /// <para> /// Sets the <see cref="PropertyAccessMode" /> to use for all properties of this query type. /// </para> /// <para> /// By default, the backing field, if one is found by convention or has been specified, is used when /// new objects are constructed, typically when entities are queried from the database. /// Properties are used for all other accesses. Calling this method will change that behavior /// for all properties of this query type as described in the <see cref="PropertyAccessMode" /> enum. /// </para> /// <para> /// Calling this method overrides for all properties of this query type any access mode that was /// set on the model. /// </para> /// </summary> /// <param name="propertyAccessMode"> The <see cref="PropertyAccessMode" /> to use for properties of this query type. </param> /// <returns> The same builder instance so that multiple configuration calls can be chained. </returns> public new virtual QueryTypeBuilder <TQuery> UsePropertyAccessMode(PropertyAccessMode propertyAccessMode) => (QueryTypeBuilder <TQuery>)base.UsePropertyAccessMode(propertyAccessMode);
/// <summary>
/// コンストラクタ
/// </summary>
/// <param name="name">属性名</param>
/// <param name="mode">属性へのアクセス</param>
public PropertyNotFoundException(string name, PropertyAccessMode mode)
{
Contract.Requires <ArgumentException>(!String.IsNullOrWhiteSpace(name));
this.Name = name;
this.Mode = mode;
}
public RuntimeProperty(
string name,
Type clrType,
PropertyInfo?propertyInfo,
FieldInfo?fieldInfo,
RuntimeEntityType declaringEntityType,
PropertyAccessMode propertyAccessMode,
bool nullable,
bool concurrencyToken,
ValueGenerated valueGenerated,
PropertySaveBehavior beforeSaveBehavior,
PropertySaveBehavior afterSaveBehavior,
int?maxLength,
bool?unicode,
int?precision,
int?scale,
Type?providerClrType,
Func <IProperty, IEntityType, ValueGenerator>?valueGeneratorFactory,
ValueConverter?valueConverter,
ValueComparer?valueComparer,
ValueComparer?keyValueComparer,
CoreTypeMapping?typeMapping)
: base(name, propertyInfo, fieldInfo, propertyAccessMode)
{
DeclaringEntityType = declaringEntityType;
ClrType = clrType;
_isNullable = nullable;
_isConcurrencyToken = concurrencyToken;
_valueGenerated = valueGenerated;
_beforeSaveBehavior = beforeSaveBehavior;
_afterSaveBehavior = afterSaveBehavior;
_valueGeneratorFactory = valueGeneratorFactory;
_valueConverter = valueConverter;
if (maxLength != null)
{
SetAnnotation(CoreAnnotationNames.MaxLength, maxLength);
}
if (unicode != null)
{
SetAnnotation(CoreAnnotationNames.Unicode, unicode);
}
if (precision != null)
{
SetAnnotation(CoreAnnotationNames.Precision, precision);
}
if (scale != null)
{
SetAnnotation(CoreAnnotationNames.Scale, scale);
}
if (providerClrType != null)
{
SetAnnotation(CoreAnnotationNames.ProviderClrType, providerClrType);
}
_typeMapping = typeMapping;
_valueComparer = valueComparer;
_keyValueComparer = keyValueComparer ?? valueComparer;
}
protected PropertyAccessor(PropertyAccessMode propetyAccessMode)
{
_propetyAccessMode = propetyAccessMode;
}
public override TestCollectionOwnershipBuilder <TEntity, TDependentEntity> UsePropertyAccessMode(
PropertyAccessMode propertyAccessMode)
=> Wrap <TEntity, TDependentEntity>(CollectionOwnershipBuilder.UsePropertyAccessMode(propertyAccessMode));
public abstract TestPropertyBuilder <TProperty> UsePropertyAccessMode(PropertyAccessMode propertyAccessMode);
public abstract TestNavigationBuilder UsePropertyAccessMode(PropertyAccessMode propertyAccessMode);
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public virtual InternalServicePropertyBuilder UsePropertyAccessMode(
PropertyAccessMode propertyAccessMode, ConfigurationSource configurationSource)
=> (InternalServicePropertyBuilder)HasAnnotation(
CoreAnnotationNames.PropertyAccessMode, propertyAccessMode, configurationSource);
/// <summary> /// <para> /// Sets the <see cref="PropertyAccessMode" /> to use for all properties of this entity type. /// </para> /// <para> /// By default, the backing field, if one is found by convention or has been specified, is used when /// new objects are constructed, typically when entities are queried from the database. /// Properties are used for all other accesses. Calling this method will change that behavior /// for all properties of this entity type as described in the <see cref="PropertyAccessMode" /> enum. /// </para> /// <para> /// Calling this method overrides for all properties of this entity type any access mode that was /// set on the model. /// </para> /// </summary> /// <param name="propertyAccessMode"> The <see cref="PropertyAccessMode" /> to use for properties of this entity type. </param> /// <returns> The same builder instance so that multiple configuration calls can be chained. </returns> public new virtual ReferenceOwnershipBuilder <TEntity, TRelatedEntity> UsePropertyAccessMode(PropertyAccessMode propertyAccessMode) => (ReferenceOwnershipBuilder <TEntity, TRelatedEntity>)base.UsePropertyAccessMode(propertyAccessMode);
/// <summary> /// <para> /// Sets the <see cref="PropertyAccessMode" /> to use for all properties of this entity type. /// </para> /// <para> /// By default, the backing field, if one is found by convention or has been specified, is used when /// new objects are constructed, typically when entities are queried from the database. /// Properties are used for all other accesses. Calling this method will change that behavior /// for all properties of this entity type as described in the <see cref="PropertyAccessMode" /> enum. /// </para> /// <para> /// Calling this method overrides for all properties of this entity type any access mode that was /// set on the model. /// </para> /// </summary> /// <param name="propertyAccessMode"> The <see cref="PropertyAccessMode" /> to use for properties of this entity type. </param> /// <returns> The same builder instance so that multiple configuration calls can be chained. </returns> public new virtual EntityTypeBuilder <TEntity> UsePropertyAccessMode(PropertyAccessMode propertyAccessMode) => (EntityTypeBuilder <TEntity>)base.UsePropertyAccessMode(propertyAccessMode);
/// <summary>
/// コンストラクタ
/// </summary>
/// <param name="name">属性名</param>
/// <param name="mode">属性へのアクセス</param>
public PropertyNotFoundException(string name, PropertyAccessMode mode)
{
Contract.Requires<ArgumentException>(!String.IsNullOrWhiteSpace(name));
this.Name = name;
this.Mode = mode;
}
public override TestOwnedNavigationBuilder <TEntity, TDependentEntity> UsePropertyAccessMode(
PropertyAccessMode propertyAccessMode)
=> Wrap <TEntity, TDependentEntity>(OwnedNavigationBuilder.UsePropertyAccessMode(propertyAccessMode));
public virtual ModelBuilder UsePropertyAccessMode(PropertyAccessMode propertyAccessMode) => ModelBuilder.UsePropertyAccessMode(propertyAccessMode);
public override TestPropertyBuilder <TProperty> UsePropertyAccessMode(PropertyAccessMode propertyAccessMode) => new GenericTestPropertyBuilder <TProperty>(PropertyBuilder.UsePropertyAccessMode(propertyAccessMode));
public abstract TestReferenceOwnershipBuilder <TEntity, TRelatedEntity> UsePropertyAccessMode(PropertyAccessMode propertyAccessMode);
/// <summary> /// <para> /// Sets the <see cref="PropertyAccessMode" /> to use for this property. /// </para> /// <para> /// By default, the backing field, if one is found by convention or has been specified, is used when /// new objects are constructed, typically when entities are queried from the database. /// Properties are used for all other accesses. Calling this method will change that behavior /// for this property as described in the <see cref="PropertyAccessMode" /> enum. /// </para> /// <para> /// Calling this method overrides for this property any access mode that was set on the /// entity type or model. /// </para> /// </summary> /// <param name="propertyAccessMode"> The <see cref="PropertyAccessMode" /> to use for this property. </param> /// <returns> The same builder instance so that multiple configuration calls can be chained. </returns> public new virtual PropertyBuilder <TProperty> UsePropertyAccessMode(PropertyAccessMode propertyAccessMode) => (PropertyBuilder <TProperty>)base.UsePropertyAccessMode(propertyAccessMode);
public virtual TestModelBuilder UsePropertyAccessMode(PropertyAccessMode propertyAccessMode)
{
ModelBuilder.UsePropertyAccessMode(propertyAccessMode);
return(this);
}
/// <summary> /// <para> /// Sets the <see cref="PropertyAccessMode" /> to use for all properties of this entity type. /// </para> /// <para> /// By default, the backing field, if one is found by convention or has been specified, is used when /// new objects are constructed, typically when entities are queried from the database. /// Properties are used for all other accesses. Calling this method will change that behavior /// for all properties of this entity type as described in the <see cref="PropertyAccessMode" /> enum. /// </para> /// <para> /// Calling this method overrides for all properties of this entity type any access mode that was /// set on the model. /// </para> /// </summary> /// <param name="propertyAccessMode"> The <see cref="PropertyAccessMode" /> to use for properties of this entity type. </param> /// <returns> The same builder instance so that multiple configuration calls can be chained. </returns> public new virtual CollectionOwnershipBuilder <TEntity, TDependentEntity> UsePropertyAccessMode(PropertyAccessMode propertyAccessMode) => (CollectionOwnershipBuilder <TEntity, TDependentEntity>)base.UsePropertyAccessMode(propertyAccessMode);
public abstract TestEntityTypeBuilder <TEntity> UsePropertyAccessMode(PropertyAccessMode propertyAccessMode);
/// <summary> /// This API supports the Entity Framework Core infrastructure and is not intended to be used /// directly from your code. This API may change or be removed in future releases. /// </summary> public virtual bool UsePropertyAccessMode(PropertyAccessMode propertyAccessMode, ConfigurationSource configurationSource) => HasAnnotation(CoreAnnotationNames.PropertyAccessModeAnnotation, propertyAccessMode, configurationSource);
public override ModelBuilder UsePropertyAccessMode(PropertyAccessMode propertyAccessMode)
{
Instance.UsePropertyAccessMode(propertyAccessMode, ConfigurationSource.Explicit);
return(this);
}
