private void eventModelCreating(ModelBuilder modelBuilder)
{
var builder = modelBuilder.Entity <Event>();
var converter = new BoolToZeroOneConverter <int>();
modelBuilder.Entity <Event>(t =>
{
t.HasKey(o => o.id);
t.Property(o => o.complete).HasConversion(converter);
// t.Property(o => o.important).HasConversion(converter);
// t.Property(o => o.reoccuringType).HasColumnName("reoccuring_type");
// t.Property(o => o.EventUserId).HasColumnName("event_user_id");
});
builder.ToTable("Events");
modelBuilder.Entity <Event>()
.Property <int>("EventUserId").HasColumnName("event_user_id");
modelBuilder.Entity <Event>()
.HasOne <EventUser>(s => s.eventUser)
.WithMany()
.HasForeignKey("EventUserId")
.HasPrincipalKey(u => u.id);
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
var converter = new BoolToZeroOneConverter <Int16>();
modelBuilder
.Entity <AppUser>()
.Property(user => user.LockoutEnabled)
.HasConversion(converter);
modelBuilder
.Entity <AppUser>()
.Property(user => user.TwoFactorEnabled)
.HasConversion(converter);
modelBuilder
.Entity <AppUser>()
.Property(user => user.EmailConfirmed)
.HasConversion(converter);
modelBuilder
.Entity <AppUser>()
.Property(user => user.PhoneNumberConfirmed)
.HasConversion(converter);
base.OnModelCreating(modelBuilder);
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
var converter = new BoolToZeroOneConverter <int>();
modelBuilder
.Entity <User>()
.Property(e => e.IsActive)
.HasConversion(converter);
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
var converter = new BoolToZeroOneConverter <Int16>();
base.OnModelCreating(modelBuilder);
modelBuilder.Entity <UserDB>().HasAlternateKey(e => e.Email);
modelBuilder.Entity <UserDB>().Property(e => e.ActiveAccount).HasConversion(converter);
}
private static void GenericConvertTest <TStore>(TStore zero, TStore one)
{
var converter = new BoolToZeroOneConverter <TStore>();
var toStore = converter.ConvertToStoreExpression.Compile();
Assert.Equal(one, toStore(true));
Assert.Equal(zero, toStore(false));
var fromStore = converter.ConvertFromStoreExpression.Compile();
Assert.True(fromStore(one));
Assert.False(fromStore(zero));
}
private static void GenericConvertTest <TProvider>(TProvider zero, TProvider one)
{
var converter = new BoolToZeroOneConverter <TProvider>();
var toProvider = converter.ConvertToProviderExpression.Compile();
Assert.Equal(one, toProvider(true));
Assert.Equal(zero, toProvider(false));
var fromProvider = converter.ConvertFromProviderExpression.Compile();
Assert.True(fromProvider(one));
Assert.False(fromProvider(zero));
}
public override void Map(EntityTypeBuilder <Genero> builder)
{
var boolTobit = new BoolToZeroOneConverter <int>();
builder.ToTable("Genero");
builder.HasKey(s => s.Id);
builder.Property(s => s.Nome)
.HasColumnType("nvarchar(200)")
.IsRequired();
builder.Property(s => s.DataCriacao)
.HasColumnType("datetime2");
builder.Property(s => s.Ativo)
.HasColumnType("bit");
builder.Ignore(e => e.ValidationResult);
builder.Ignore(e => e.ValidationErrors);
builder.Ignore(s => s.CascadeMode);
}
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
//Conversions can be configured in OnModelCreating to store the enum values as strings such as "Donkey", "Mule", etc.
//in the database; you simply need to provide one function which converts from the ModelClrType to the ProviderClrType, and another for the opposite conversion:
modelBuilder
.Entity <Rider>()
.Property(e => e.Mount)
.HasConversion(
v => v.ToString(),
v => (EquineBeast)Enum.Parse(typeof(EquineBeast), v)
);
//Some database types have facets that modify how the data is stored.These include:
// - Precision and scale for decimals and date / time columns
// - Size / length for binary and string columns
// - Unicode for string columns
//---------------------------------
//- Pre-defined conversions
//---------------------------------
//For example, enum to string conversions are used as an example above,
//but EF Core will actually do this automatically when the provider type is configured as string using the generic type of HasConversion:
modelBuilder
.Entity <Rider1>()
.Property(e => e.Mount)
.HasConversion <string>()
.HasMaxLength(20)
.IsUnicode(false);
//The same thing can be achieved by explicitly specifying the database column type. For example, if the entity type is defined like so:
modelBuilder
.Entity <Rider2>()
.Property(e => e.Mount)
.HasColumnType("nvarchar(24)");
//---------------------------------
//- The ValueConverter class
//---------------------------------
var converter = new ValueConverter <EquineBeast, string>(
v => v.ToString(),
v => (EquineBeast)Enum.Parse(typeof(EquineBeast), v));
modelBuilder
.Entity <Rider3>()
.Property(e => e.Mount)
.HasConversion(converter)
.HasMaxLength(20)
.IsUnicode(false);;
//---------------------------------
//- Built-in converters
//---------------------------------
modelBuilder
.Entity <Rider>()
.Property(e => e.IsActive)
.HasConversion <int>();
var converter1 = new BoolToZeroOneConverter <int>();
modelBuilder
.Entity <Rider1>()
.Property(e => e.IsActive)
.HasConversion(converter1);
//---------------------------------
//- Column facets and mapping hints
//---------------------------------
//However, if by default all EquineBeast columns should be varchar(20), then this information can be given to the value converter as a ConverterMappingHints. For example:
/*var converter2 = new ValueConverter<EquineBeast, string>(
* v => v.ToString(),
* v => (EquineBeast)Enum.Parse(typeof(EquineBeast), v),
* new ConverterMappingHints(size: 20, unicode: false));
*
* modelBuilder
* .Entity<Rider>()
* .Property(e => e.Mount)
* .HasConversion(converter1);*/
//---------------------------------
//- Simple value objects
//---------------------------------
modelBuilder
.Entity <Order>()
.Property(e => e.Price)
.HasConversion(
v => v.Amount,
v => new Dollars(v)
);
//---------------------------------
//- Composite value objects
//---------------------------------
modelBuilder
.Entity <OrderDetail>()
.Property(e => e.Price)
.HasConversion(
v => System.Text.Json.JsonSerializer.Serialize(v, null),
v => System.Text.Json.JsonSerializer.Deserialize <Money>(v, null));
//---------------------------------
//- Collections of value objects
//---------------------------------
//Using System.Text.Json again:
//ICollection<string> represents a mutable reference type. This means that a ValueComparer<T> is needed so that EF Core can track and detect changes correctly. See Value Comparers for more information.
modelBuilder.Entity <Post>()
.Property(e => e.Tags)
.HasConversion(
v => System.Text.Json.JsonSerializer.Serialize(v, null),
v => System.Text.Json.JsonSerializer.Deserialize <List <string> >(v, null),
new ValueComparer <ICollection <string> >(
(c1, c2) => c1.SequenceEqual(c2),
c => c.Aggregate(0, (a, v) => HashCode.Combine(a, v.GetHashCode())),
c => (ICollection <string>)c.ToList()));
}
