public virtual void AddDefaultValueConfiguration(
[NotNull] PropertyConfiguration propertyConfiguration)
{
Check.NotNull(propertyConfiguration, nameof(propertyConfiguration));
if (ExtensionsProvider.For(propertyConfiguration.Property).DefaultValue != null)
{
propertyConfiguration.FluentApiConfigurations.Add(
new FluentApiConfiguration(
nameof(RelationalPropertyBuilderExtensions.HasDefaultValue),
CSharpUtilities.GenerateLiteral(
(dynamic)ExtensionsProvider.For(propertyConfiguration.Property).DefaultValue)));
}
}
/// <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 void AddDefaultValueConfiguration(
[NotNull] PropertyConfiguration propertyConfiguration)
{
Check.NotNull(propertyConfiguration, nameof(propertyConfiguration));
if (AnnotationProvider.For(propertyConfiguration.Property).DefaultValue != null)
{
propertyConfiguration.FluentApiConfigurations.Add(
_configurationFactory.CreateFluentApiConfiguration(
/* hasAttributeEquivalent */ false,
nameof(RelationalPropertyBuilderExtensions.HasDefaultValue),
CSharpUtilities.GenerateLiteral(
(dynamic)AnnotationProvider.For(propertyConfiguration.Property).DefaultValue)));
}
}
public virtual void AddMaxLengthConfiguration(
[NotNull] PropertyConfiguration propertyConfiguration)
{
Check.NotNull(propertyConfiguration, nameof(propertyConfiguration));
if (((Property)propertyConfiguration.Property).GetMaxLength().HasValue)
{
var maxLengthLiteral =
CSharpUtilities.GenerateLiteral(
((Property)propertyConfiguration.Property).GetMaxLength().Value);
propertyConfiguration.FluentApiConfigurations.Add(
_configurationFactory.CreateFluentApiConfiguration(
/* hasAttributeEquivalent */ true,
nameof(PropertyBuilder.HasMaxLength), maxLengthLiteral));
propertyConfiguration.AttributeConfigurations.Add(
_configurationFactory.CreateAttributeConfiguration(nameof(MaxLengthAttribute), maxLengthLiteral));
}
}
private void GenerateMaxLengthAttribute(IProperty property)
{
var maxLength = property.GetMaxLength();
if (maxLength.HasValue)
{
var lengthAttribute = new AttributeWriter(
property.ClrType == typeof(string)
? nameof(StringLengthAttribute)
: nameof(MaxLengthAttribute));
lengthAttribute.AddParameter(CSharpUtilities.GenerateLiteral(maxLength.Value));
_propertyAnnotations.Add(new Dictionary <string, object>
{
{ "property-annotation", lengthAttribute.ToString() },
});
}
}
private string GenerateAnnotation(IAnnotation annotation)
{
return($".HasAnnotation({CSharpUtilities.DelimitString(annotation.Name)}, {CSharpUtilities.GenerateLiteral((dynamic)annotation.Value)})");
}
private void GenerateRelationship(IForeignKey foreignKey, bool useDataAnnotations,
IndentedStringBuilder sb)
{
var canUseDataAnnotations = true;
var annotations = foreignKey.GetAnnotations().ToList();
var lines = new List <string>
{
$".{nameof(EntityTypeBuilder.HasOne)}(d => d.{foreignKey.DependentToPrincipal.Name})",
$".{(foreignKey.IsUnique ? nameof(ReferenceNavigationBuilder.WithOne) : nameof(ReferenceNavigationBuilder.WithMany))}"
+ $"(p => p.{foreignKey.PrincipalToDependent.Name})"
};
if (!foreignKey.PrincipalKey.IsPrimaryKey())
{
canUseDataAnnotations = false;
lines.Add(
$".{nameof(ReferenceReferenceBuilder.HasPrincipalKey)}"
+ $"{(foreignKey.IsUnique ? $"<{foreignKey.PrincipalEntityType.DisplayName()}>" : "")}"
+ $"(p => {GenerateLambdaToKey(foreignKey.PrincipalKey.Properties, "p")})");
}
lines.Add(
$".{nameof(ReferenceReferenceBuilder.HasForeignKey)}"
+ $"{(foreignKey.IsUnique ? $"<{foreignKey.DeclaringEntityType.DisplayName()}>" : "")}"
+ $"(d => {GenerateLambdaToKey(foreignKey.Properties, "d")})");
var defaultOnDeleteAction = foreignKey.IsRequired
? DeleteBehavior.Cascade
: DeleteBehavior.ClientSetNull;
if (foreignKey.DeleteBehavior != defaultOnDeleteAction)
{
canUseDataAnnotations = false;
lines.Add($".{nameof(ReferenceReferenceBuilder.OnDelete)}({CSharpUtilities.GenerateLiteral(foreignKey.DeleteBehavior)})");
}
if (!string.IsNullOrEmpty((string)foreignKey[RelationalAnnotationNames.Name]))
{
canUseDataAnnotations = false;
lines.Add($".{nameof(RelationalReferenceReferenceBuilderExtensions.HasConstraintName)}({CSharpUtilities.DelimitString(foreignKey.Relational().Name)})");
RemoveAnnotation(ref annotations, RelationalAnnotationNames.Name);
}
var annotationsToRemove = new List <IAnnotation>();
foreach (var annotation in annotations)
{
if (_annotationCodeGenerator.IsHandledByConvention(foreignKey, annotation))
{
annotationsToRemove.Add(annotation);
}
else
{
var line = _annotationCodeGenerator.GenerateFluentApi(foreignKey, annotation, Language);
if (line != null)
{
canUseDataAnnotations = false;
lines.Add(line);
annotationsToRemove.Add(annotation);
}
}
}
lines.AddRange(GenerateAnnotations(annotations.Except(annotationsToRemove)));
if (!useDataAnnotations ||
!canUseDataAnnotations)
{
AppendMultiLineFluentApi(foreignKey.DeclaringEntityType, lines, sb);
}
}
private void GenerateProperty(IProperty property, bool useDataAnnotations,
IndentedStringBuilder sb)
{
var lines = new List <string>
{
$".{nameof(EntityTypeBuilder.Property)}(e => e.{property.Name})"
};
var annotations = property.GetAnnotations().ToList();
RemoveAnnotation(ref annotations, RelationalAnnotationNames.ColumnName);
RemoveAnnotation(ref annotations, RelationalAnnotationNames.ColumnType);
RemoveAnnotation(ref annotations, CoreAnnotationNames.MaxLengthAnnotation);
RemoveAnnotation(ref annotations, CoreAnnotationNames.UnicodeAnnotation);
RemoveAnnotation(ref annotations, RelationalAnnotationNames.DefaultValue);
RemoveAnnotation(ref annotations, RelationalAnnotationNames.DefaultValueSql);
RemoveAnnotation(ref annotations, RelationalAnnotationNames.ComputedColumnSql);
RemoveAnnotation(ref annotations, ScaffoldingAnnotationNames.ColumnOrdinal);
if (!useDataAnnotations)
{
if (!property.IsNullable &&
property.ClrType.IsNullableType() &&
!property.IsPrimaryKey())
{
lines.Add($".{nameof(PropertyBuilder.IsRequired)}()");
}
var columnName = property.Relational().ColumnName;
if (columnName != null &&
columnName != property.Name)
{
lines.Add($".{nameof(RelationalPropertyBuilderExtensions.HasColumnName)}({CSharpUtilities.DelimitString(columnName)})");
}
var columnType = property.GetConfiguredColumnType();
if (columnType != null)
{
lines.Add($".{nameof(RelationalPropertyBuilderExtensions.HasColumnType)}({CSharpUtilities.DelimitString(columnType)})");
}
var maxLength = property.GetMaxLength();
if (maxLength.HasValue)
{
lines.Add($".{nameof(PropertyBuilder.HasMaxLength)}({CSharpUtilities.GenerateLiteral(maxLength.Value)})");
}
}
if (property.IsUnicode() != null)
{
lines.Add($".{nameof(PropertyBuilder.IsUnicode)}({(property.IsUnicode() == false ? CSharpUtilities.GenerateLiteral(false) : "")})");
}
if (property.Relational().DefaultValue != null)
{
lines.Add($".{nameof(RelationalPropertyBuilderExtensions.HasDefaultValue)}({CSharpUtilities.GenerateLiteral((dynamic)property.Relational().DefaultValue)})");
}
if (property.Relational().DefaultValueSql != null)
{
lines.Add($".{nameof(RelationalPropertyBuilderExtensions.HasDefaultValueSql)}({CSharpUtilities.DelimitString(property.Relational().DefaultValueSql)})");
}
if (property.Relational().ComputedColumnSql != null)
{
lines.Add($".{nameof(RelationalPropertyBuilderExtensions.HasComputedColumnSql)}({CSharpUtilities.DelimitString(property.Relational().ComputedColumnSql)})");
}
var valueGenerated = property.ValueGenerated;
var isRowVersion = false;
if (((Property)property).GetValueGeneratedConfigurationSource().HasValue &&
new RelationalValueGeneratorConvention().GetValueGenerated((Property)property) != valueGenerated)
{
string methodName;
switch (valueGenerated)
{
case ValueGenerated.OnAdd:
methodName = nameof(PropertyBuilder.ValueGeneratedOnAdd);
break;
case ValueGenerated.OnAddOrUpdate:
isRowVersion = property.IsConcurrencyToken;
methodName = isRowVersion
? nameof(PropertyBuilder.IsRowVersion)
: nameof(PropertyBuilder.ValueGeneratedOnAddOrUpdate);
break;
case ValueGenerated.Never:
methodName = nameof(PropertyBuilder.ValueGeneratedNever);
break;
default:
methodName = "";
break;
}
lines.Add($".{methodName}()");
}
if (property.IsConcurrencyToken &&
!isRowVersion)
{
lines.Add($".{nameof(PropertyBuilder.IsConcurrencyToken)}()");
}
var annotationsToRemove = new List <IAnnotation>();
foreach (var annotation in annotations)
{
if (_annotationCodeGenerator.IsHandledByConvention(property, annotation))
{
annotationsToRemove.Add(annotation);
}
else
{
var line = _annotationCodeGenerator.GenerateFluentApi(property, annotation, Language);
if (line != null)
{
lines.Add(line);
annotationsToRemove.Add(annotation);
}
}
}
lines.AddRange(GenerateAnnotations(annotations.Except(annotationsToRemove)));
switch (lines.Count)
{
case 1:
return;
case 2:
lines = new List <string>
{
lines[0] + lines[1]
};
break;
}
AppendMultiLineFluentApi(property.DeclaringEntityType, lines, sb);
}