public void NavProps()
{
var modelBuilder = new ModelBuilder(SqlServerConventionSetBuilder.Build());
modelBuilder.Entity <Order>(e =>
{
e.HasOne(o => o.Customer).WithMany(c => c.Orders).HasForeignKey(o => o.CustomerId);
});
var source = new GraphTypeResolverSource();
var factory = new GraphSchemaFactory(new GraphTypeMapper(), new FieldResolverFactory(new GraphTypeMapper()), source);
var schema = factory.Create(modelBuilder.Model);
Assert.NotNull(schema);
ObjectGraphType <Order> orderType;
Assert.True(source.TryResolve(out orderType));
Assert.Single(orderType.Fields, f => f.Name == "customer" && f.Type == typeof(ObjectGraphType <Customer>));
ObjectGraphType <Customer> customerType;
Assert.True(source.TryResolve(out customerType));
Assert.Single(customerType.Fields, f => f.Name == "orders" && f.Type == typeof(ListGraphType <ObjectGraphType <Order> >));
}
public void CreatesFieldsForEntityTypes()
{
var modelBuilder = new ModelBuilder(SqlServerConventionSetBuilder.Build());
modelBuilder.Entity <Customer>();
modelBuilder.Ignore <Order>();
var factory = new GraphSchemaFactory(new GraphTypeMapper(), new FieldResolverFactory(new GraphTypeMapper()), new GraphTypeResolverSource());
var graph = factory.Create(modelBuilder.Model);
Assert.Collection(graph.Query.Fields,
list =>
{
Assert.Equal("customers", list.Name);
Assert.Equal(typeof(ListGraphType <ObjectGraphType <Customer> >), list.Type);
Assert.NotEmpty(list.Arguments);
Assert.NotNull(list.Resolve);
},
list =>
{
Assert.Equal("customersCount", list.Name);
Assert.Equal(typeof(IntGraphType), list.Type);
//Assert.NotEmpty(list.Arguments);
Assert.NotNull(list.Resolve);
});
}
public void GenerateFluentApi_IIndex_works_with_includes()
{
var generator = new SqlServerAnnotationCodeGenerator(new AnnotationCodeGeneratorDependencies());
var modelBuilder = new ModelBuilder(SqlServerConventionSetBuilder.Build());
modelBuilder.Entity(
"Post",
x =>
{
x.Property <int>("Id");
x.Property <string>("FirstName");
x.Property <string>("LastName");
x.HasIndex("LastName").ForSqlServerInclude("FirstName");
});
var index = modelBuilder.Model.FindEntityType("Post").GetIndexes().Single();
var annotation = index.FindAnnotation(SqlServerAnnotationNames.Include);
var result = generator.GenerateFluentApi(index, annotation);
Assert.Equal("ForSqlServerInclude", result.Method);
Assert.Equal(1, result.Arguments.Count);
var properties = Assert.IsType <string[]>(result.Arguments[0]);
Assert.Equal(new[] { "FirstName" }, properties.AsEnumerable());
}
public static DbContext DbContext()
{
var typeMappingSource = new SqlServerTypeMappingSource(new TypeMappingSourceDependencies(new ValueConverterSelector(new ValueConverterSelectorDependencies())), new RelationalTypeMappingSourceDependencies()); // EF Core 2.1
// From SQL type to C# type.
var type = typeMappingSource.FindMapping("nvarchar(max)").ClrType;
var conventionSet = SqlServerConventionSetBuilder.Build();
var builder = new ModelBuilder(conventionSet);
// My
var entity = builder.Entity(typeof(My));
entity.ToTable("My");
entity.Property("Id");
entity.Property("Id").HasAnnotation(CoreAnnotationNames.TypeMapping, typeMappingSource.FindMapping(typeof(int)));
entity.Property("Text").HasAnnotation(CoreAnnotationNames.TypeMapping, typeMappingSource.FindMapping(typeof(string)));
// MyView
entity = builder.Entity(typeof(MyView));
entity.ToTable("MyView");
entity.Property("Id");
entity.Property("Id").HasAnnotation(CoreAnnotationNames.TypeMapping, typeMappingSource.FindMapping(typeof(int)));
entity.Property("Text").HasAnnotation(CoreAnnotationNames.TypeMapping, typeMappingSource.FindMapping(typeof(string)));
var model = builder.Model;
var options = new DbContextOptionsBuilder();
options.UseSqlServer("Data Source=localhost; Initial Catalog=AdventureWorks2016; Integrated Security=True;").UseModel(model);
var dbContext = new DbContext(options.Options);
return(dbContext);
}
private static IModel BuildDbCompiledModel(DatabaseType dbType)
{
ConventionSet conventionSet = null;
switch (dbType)
{
case DatabaseType.SqlServer: conventionSet = SqlServerConventionSetBuilder.Build(); break;
case DatabaseType.MySql: conventionSet = MySqlConventionSetBuilder.Build(); break;
case DatabaseType.PostgreSql: conventionSet = NpgsqlConventionSetBuilder.Build(); break;
case DatabaseType.Oracle: conventionSet = OracleConventionSetBuilder.Build(); break;
default: throw new Exception("暂不支持该数据库!");
}
ModelBuilder modelBuilder = new ModelBuilder(conventionSet);
_entityTypeMap.Values.ForEach(x =>
{
modelBuilder.Model.AddEntityType(x);
});
return(modelBuilder.FinalizeModel());
}
public void GenerateFluentApi_IProperty_works_with_IsSparse()
{
var generator = CreateGenerator();
var modelBuilder = SqlServerConventionSetBuilder.CreateModelBuilder();
modelBuilder.Entity("SomeEntity", x =>
{
x.Property <string>("Default");
x.Property <string>("Sparse").IsSparse();
x.Property <string>("NonSparse").IsSparse(false);
});
Assert.Null(GenerateFluentApiCall("SomeEntity", "Default"));
var sparseCall = GenerateFluentApiCall("SomeEntity", "Sparse");
Assert.Equal("IsSparse", sparseCall.Method);
Assert.Empty(sparseCall.Arguments);
var nonSparseCall = GenerateFluentApiCall("SomeEntity", "NonSparse");
Assert.Equal("IsSparse", nonSparseCall.Method);
Assert.Collection(nonSparseCall.Arguments, o => Assert.False((bool)o));
MethodCallCodeFragment GenerateFluentApiCall(string entityTypeName, string propertyName)
{
var property = modelBuilder.Model.FindEntityType(entityTypeName).FindProperty(propertyName);
var annotations = property.GetAnnotations().ToDictionary(a => a.Name, a => a);
return(generator.GenerateFluentApiCalls((IProperty)property, annotations).SingleOrDefault());
}
}
public void GenerateFluentApi_IIndex_works_with_includes()
{
var generator = CreateGenerator();
var modelBuilder = SqlServerConventionSetBuilder.CreateModelBuilder();
modelBuilder.Entity(
"Post",
x =>
{
x.Property <int>("Id");
x.Property <string>("FirstName");
x.Property <string>("LastName");
x.HasIndex("LastName").IncludeProperties("FirstName");
});
var index = (IIndex)modelBuilder.Model.FindEntityType("Post").GetIndexes().Single();
var result = generator.GenerateFluentApiCalls(index, index.GetAnnotations().ToDictionary(a => a.Name, a => a))
.Single();
Assert.Equal("IncludeProperties", result.Method);
Assert.Equal(1, result.Arguments.Count);
var properties = Assert.IsType <string[]>(result.Arguments[0]);
Assert.Equal(new[] { "FirstName" }, properties.AsEnumerable());
}
public void GenerateFluentApi_IIndex_works_when_clustered(bool obsolete)
{
var generator = new SqlServerAnnotationCodeGenerator(new AnnotationCodeGeneratorDependencies());
var modelBuilder = new ModelBuilder(SqlServerConventionSetBuilder.Build());
modelBuilder.Entity(
"Post",
x =>
{
x.Property <int>("Id");
x.Property <string>("Name");
if (obsolete)
{
#pragma warning disable 618
x.HasIndex("Name").ForSqlServerIsClustered();
#pragma warning restore 618
}
else
{
x.HasIndex("Name").IsClustered();
}
});
var index = modelBuilder.Model.FindEntityType("Post").GetIndexes().Single();
var annotation = index.FindAnnotation(SqlServerAnnotationNames.Clustered);
var result = generator.GenerateFluentApi(index, annotation);
Assert.Equal("IsClustered", result.Method);
Assert.Equal(0, result.Arguments.Count);
}
public static void BuildModel(LyniconSystem sys)
{
//if (!Collator.Instance.RepositoryBuilt)
// throw new Exception("In CoreDb.OnModelCreating because there was a use of CoreDb before repository was built");
Debug.WriteLine("Building SummaryDb");
var requiredBaseTypes = ContentTypeHierarchy.AllContentTypes
.Select(ct => Collator.Instance.ContainerType(ct))
.Select(crt => sys.Extender.ExtensionTypes().Contains(crt)
? sys.Extender.Base(crt)
: crt)
.Distinct()
.Where(crt => Repository.Instance.Registered(crt).DataSourceFactory is CoreDataSourceFactory)
.ToList();
var builder = new ModelBuilder(SqlServerConventionSetBuilder.Build());
sys.Extender.BaseTypes.Do(t => builder.Ignore(t));
foreach (var sumsType in sys.Extender.BaseTypes.Where(bt => requiredBaseTypes.Contains(bt)))
{
builder.Entity(sys.Extender.Summarised(sumsType)).ToTable(LinqX.GetTableName(sumsType));
}
SummaryModel = builder.Model;
}
private static DbCompiledModelInfo BuildDbCompiledModelInfo(string nameOrConStr, DatabaseType dbType)
{
lock (_buildCompiledModelLock)
{
ConventionSet conventionSet = null;
switch (dbType)
{
case DatabaseType.SqlServer: conventionSet = SqlServerConventionSetBuilder.Build(); break;
case DatabaseType.MySql: conventionSet = MySqlConventionSetBuilder.Build(); break;
case DatabaseType.PostgreSql: conventionSet = NpgsqlConventionSetBuilder.Build(); break;
case DatabaseType.Oracle: conventionSet = OracleConventionSetBuilder.Build(); break;
default: throw new Exception("暂不支持该数据库!");
}
ModelBuilder modelBuilder = new ModelBuilder(conventionSet);
_modelTypeMap.Values.ForEach(x =>
{
modelBuilder.Model.AddEntityType(x);
});
DbCompiledModelInfo newInfo = new DbCompiledModelInfo
{
ConStr = nameOrConStr,
DatabaseType = dbType,
Model = modelBuilder.FinalizeModel()
};
return(newInfo);
}
}
protected static void BuildModel()
{
//if (!Collator.Instance.RepositoryBuilt)
// throw new Exception("In CoreDb.OnModelCreating because there was a use of CoreDb before repository was built");
Debug.WriteLine("Building CoreDb");
var requiredTypes = ContentTypeHierarchy.AllContentTypes
.Select(ct => Collator.Instance.ContainerType(ct))
.Distinct()
.Where(crt => Repository.Instance.Registered(crt).DataSourceFactory is CoreDataSourceFactory)
.ToList();
var builder = new ModelBuilder(SqlServerConventionSetBuilder.Build());
// temp, breaks separability of Lynicon systems
var sys = LyniconSystem.Instance;
foreach (Type baseType in sys.Extender.BaseTypes.Where(t => requiredTypes.Contains(sys.Extender[t])))
{
builder.Entity(sys.Extender[baseType]).ToTable(LinqX.GetTableName(baseType));
}
CoreModel = builder.Model;
}
public IModel ComposeModel(ModelBuilder modelBuilder = null, bool onlyModelVerification = false)
{
modelBuilder = modelBuilder ?? new ModelBuilder(SqlServerConventionSetBuilder.Build());
//modelBuilder.Conventions.Remove<PluralizingTableNameConvention>();
//modelBuilder.Conventions.Remove<OneToManyCascadeDeleteConvention>();
// Für .NET DateTime wird SQL datetime2(7) verwendet
//modelBuilder.Properties<DateTime>()
// .Where(pi => !IsValidPeriodProperty(pi))
// .Configure(pca => pca.HasColumnType(SqlDbType.DateTime2.ToString()).HasPrecision(7));
//modelBuilder.Properties<DateTime>()
// .Where(IsValidPeriodProperty)
// .Configure(pca => pca.HasColumnType("date"));
var moduleModelBuilders = _entityTypeConfigurationFactory.CreateEntityTypeConfigurations();
foreach (var builder in moduleModelBuilders)
{
builder.BuildModel(modelBuilder);
}
//// Reportentities sind von DB-Entities abgeleitet und würde deshalb in die DB generiert werden
//var reportEntities = modelBuilder.Types().Where(typ => typeof(IReportEntity).IsAssignableFrom(typ));
//reportEntities.Configure(typ => typ.Ignore());
return(modelBuilder.Model);
}
public virtual void BuildModel_AdventureWorks()
{
var builder = new ModelBuilder(SqlServerConventionSetBuilder.Build());
AdventureWorksContext.ConfigureModel(builder);
// ReSharper disable once UnusedVariable
var model = builder.Model;
}
public GenericModelBuilder(IConfigurationRoot configuration)
{
var coreConventionSetBuilder = new CoreConventionSetBuilder();
var sqlConventionSetBuilder = new SqlServerConventionSetBuilder(new SqlServerTypeMapper(), null, null);
var conventionSet = sqlConventionSetBuilder.AddConventions(coreConventionSetBuilder.CreateConventionSet());
modelBuilder = new ModelBuilder(conventionSet);
this.configuration = configuration;
}
private void Test(
Action <ModelBuilder> buildModel,
ModelCodeGenerationOptions options,
Action <ScaffoldedModel> assertScaffold,
Action <IModel> assertModel)
{
var modelBuilder = new ModelBuilder(SqlServerConventionSetBuilder.Build());
buildModel(modelBuilder);
modelBuilder.GetInfrastructure().Metadata.Validate();
var model = modelBuilder.Model;
var services = new ServiceCollection()
.AddEntityFrameworkDesignTimeServices();
new SqlServerDesignTimeServices().ConfigureDesignTimeServices(services);
var generator = services
.BuildServiceProvider()
.GetRequiredService <IModelCodeGenerator>();
var scaffoldedModel = generator.GenerateModel(
model,
"TestNamespace",
/*contextDir:*/ string.Empty,
"TestDbContext",
"Initial Catalog=TestDatabase",
options);
assertScaffold(scaffoldedModel);
var build = new BuildSource
{
References =
{
BuildReference.ByName("Microsoft.EntityFrameworkCore"),
BuildReference.ByName("Microsoft.EntityFrameworkCore.Relational"),
BuildReference.ByName("Microsoft.EntityFrameworkCore.SqlServer")
},
Sources = new List <string>(
Enumerable.Concat(
new[] { scaffoldedModel.ContextFile.Code },
scaffoldedModel.AdditionalFiles.Select(f => f.Code)))
};
var assembly = build.BuildInMemory();
var context = (DbContext)assembly.CreateInstance("TestNamespace.TestDbContext");
var compiledModel = context.Model;
assertModel(compiledModel);
}
public void GenerateFluentApi_IModel_works_with_PerformanceLevel()
{
var generator = CreateGenerator();
var modelBuilder = SqlServerConventionSetBuilder.CreateModelBuilder();
modelBuilder.HasPerformanceLevel("foo");
var annotations = modelBuilder.Model.GetAnnotations().ToDictionary(a => a.Name, a => a);
var result = generator.GenerateFluentApiCalls((IModel)modelBuilder.Model, annotations)
.Single(c => c.Method == nameof(SqlServerModelBuilderExtensions.HasPerformanceLevelSql));
Assert.Equal("'foo'", Assert.Single(result.Arguments));
}
public void BuildModel_AdventureWorks(IMetricCollector collector)
{
collector.StartCollection();
var builder = new ModelBuilder(SqlServerConventionSetBuilder.Build());
AdventureWorksContext.ConfigureModel(builder);
var model = builder.Model;
collector.StopCollection();
Assert.Equal(67, model.GetEntityTypes().Count());
}
private IModel BuildDbCompiledModel()
{
if (ModelTypeMap.Count == 0)
{
InitModelType();
}
ConventionSet conventionSet = SqlServerConventionSetBuilder.Build();
ModelBuilder modelBuilder = new ModelBuilder(conventionSet);
ModelTypeMap.Values.ForEach(x =>
{
modelBuilder.Model.AddEntityType(x);
});
return(modelBuilder.FinalizeModel());
}
public void GenerateFluentApi_IModel_works_with_HiLo()
{
var generator = CreateGenerator();
var modelBuilder = SqlServerConventionSetBuilder.CreateModelBuilder();
modelBuilder.UseHiLo("HiLoIndexName", "HiLoIndexSchema");
var annotations = modelBuilder.Model.GetAnnotations().ToDictionary(a => a.Name, a => a);
var result = generator.GenerateFluentApiCalls(modelBuilder.Model, annotations).Single();
Assert.Equal("UseHiLo", result.Method);
Assert.Collection(result.Arguments,
name => Assert.Equal("HiLoIndexName", name),
schema => Assert.Equal("HiLoIndexSchema", schema));
}
public void GenerateFluentApi_IModel_works_with_identity()
{
var generator = CreateGenerator();
var modelBuilder = SqlServerConventionSetBuilder.CreateModelBuilder();
modelBuilder.UseIdentityColumns(seed: 5, increment: 10);
var annotations = modelBuilder.Model.GetAnnotations().ToDictionary(a => a.Name, a => a);
var result = generator.GenerateFluentApiCalls(modelBuilder.Model, annotations).Single();
Assert.Equal("UseIdentityColumns", result.Method);
Assert.Collection(result.Arguments,
seed => Assert.Equal(5, seed),
increment => Assert.Equal(10, increment));
}
public virtual MappingInfo GetMappingInfo()
{
return(_cache.GetOrAdd(GetCacheKey(), a =>
{
var _schema = _schemaProvider.GetSchema();
_mappingResolver = new MappingResolver(_schema);
var conventionSet = SqlServerConventionSetBuilder.Build();
var builder = new ModelBuilder(conventionSet);
OnModelCreating(builder);
builder.FinalizeModel();
return new Lazy <MappingInfo>(
() => new MappingInfo(builder.Model, _schema),
LazyThreadSafetyMode.ExecutionAndPublication);
}).Value);
}
public void GenerateFluentApi_IProperty_works_with_HiLo()
{
var generator = CreateGenerator();
var modelBuilder = SqlServerConventionSetBuilder.CreateModelBuilder();
modelBuilder.Entity("Post", x => x.Property <int>("Id").UseHiLo("HiLoIndexName", "HiLoIndexSchema"));
var property = modelBuilder.Model.FindEntityType("Post").FindProperty("Id");
var annotations = property.GetAnnotations().ToDictionary(a => a.Name, a => a);
var result = generator.GenerateFluentApiCalls(property, annotations).Single();
Assert.Equal("UseHiLo", result.Method);
Assert.Collection(result.Arguments,
name => Assert.Equal("HiLoIndexName", name),
schema => Assert.Equal("HiLoIndexSchema", schema));
}
public void GenerateFluentApi_IProperty_works_with_identity()
{
var generator = CreateGenerator();
var modelBuilder = SqlServerConventionSetBuilder.CreateModelBuilder();
modelBuilder.Entity("Post", x => x.Property <int>("Id").UseIdentityColumn(5, 10));
var property = modelBuilder.Model.FindEntityType("Post").FindProperty("Id");
var annotations = property.GetAnnotations().ToDictionary(a => a.Name, a => a);
var result = generator.GenerateFluentApiCalls(property, annotations).Single();
Assert.Equal("UseIdentityColumn", result.Method);
Assert.Collection(result.Arguments,
seed => Assert.Equal(5, seed),
increment => Assert.Equal(10, increment));
}
public void BuildModel_AdventureWorks(IMetricCollector collector)
{
collector.StartCollection();
var conventions = new SqlServerConventionSetBuilder(new SqlServerTypeMapper())
.AddConventions(new CoreConventionSetBuilder().CreateConventionSet());
var builder = new ModelBuilder(conventions);
AdventureWorksContext.ConfigureModel(builder);
var model = builder.Model;
collector.StopCollection();
Assert.Equal(67, model.GetEntityTypes().Count());
}
private static IMutableModel DbContextModel(Type typeRow)
{
// EF Core 2.1
var typeMappingSource = new SqlServerTypeMappingSource(new TypeMappingSourceDependencies(new ValueConverterSelector(new ValueConverterSelectorDependencies())), new RelationalTypeMappingSourceDependencies());
var conventionSet = SqlServerConventionSetBuilder.Build();
var builder = new ModelBuilder(conventionSet);
// Build model
var entity = builder.Entity(typeRow);
SqlTableAttribute tableAttribute = (SqlTableAttribute)typeRow.GetTypeInfo().GetCustomAttribute(typeof(SqlTableAttribute));
entity.ToTable(tableAttribute.SqlTableName, tableAttribute.SqlSchemaName); // By default EF maps sql table name to class name.
PropertyInfo[] propertyInfoList = TypeRowToPropertyList(typeRow);
bool isPrimaryKey = false; // Sql view
foreach (PropertyInfo propertyInfo in propertyInfoList)
{
SqlFieldAttribute columnAttribute = (SqlFieldAttribute)propertyInfo.GetCustomAttribute(typeof(SqlFieldAttribute));
if (columnAttribute == null || columnAttribute.SqlFieldName == null) // Calculated column. Do not include it in sql select.
{
entity.Ignore(propertyInfo.Name);
}
else
{
if (columnAttribute.IsPrimaryKey)
{
isPrimaryKey = true;
entity.HasKey(propertyInfo.Name); // Prevent null exception if primary key name is not "Id".
}
entity.Property(propertyInfo.PropertyType, propertyInfo.Name).HasColumnName(columnAttribute.SqlFieldName);
CoreTypeMapping coreTypeMapping = typeMappingSource.FindMapping(propertyInfo.PropertyType);
Debug.Assert(coreTypeMapping != null);
entity.Property(propertyInfo.PropertyType, propertyInfo.Name).HasAnnotation(CoreAnnotationNames.TypeMapping, coreTypeMapping);
}
}
if (isPrimaryKey == false)
{
entity.HasKey(propertyInfoList.First().Name); // Prevent null exception if name of first field (of view) is not "Id".
}
var model = builder.Model;
return(model);
}
public void GenerateFluentApi_IKey_works_when_nonclustered()
{
var generator = CreateGenerator();
var modelBuilder = SqlServerConventionSetBuilder.CreateModelBuilder();
modelBuilder.Entity(
"Post",
x =>
{
x.Property<int>("Id");
x.HasKey("Id").IsClustered(false);
});
var key = modelBuilder.Model.FindEntityType("Post").GetKeys().Single();
var result = generator.GenerateFluentApiCalls(key, key.GetAnnotations().ToDictionary(a => a.Name, a => a))
.Single();
Assert.Equal("IsClustered", result.Method);
Assert.Equal(1, result.Arguments.Count);
Assert.Equal(false, result.Arguments[0]);
}
public void GenerateFluentApi_IIndex_works_when_clustered()
{
var generator = CreateGenerator();
var modelBuilder = SqlServerConventionSetBuilder.CreateModelBuilder();
modelBuilder.Entity(
"Post",
x =>
{
x.Property<int>("Id");
x.Property<string>("Name");
x.HasIndex("Name").IsClustered();
});
var index = modelBuilder.Model.FindEntityType("Post").GetIndexes().Single();
var result = generator.GenerateFluentApiCalls(index, index.GetAnnotations().ToDictionary(a => a.Name, a => a))
.Single();
Assert.Equal("IsClustered", result.Method);
Assert.Equal(0, result.Arguments.Count);
}
public void GenerateFluentApi_IKey_works_when_clustered()
{
var generator = new SqlServerAnnotationCodeGenerator(new AnnotationCodeGeneratorDependencies());
var modelBuilder = new ModelBuilder(SqlServerConventionSetBuilder.Build());
modelBuilder.Entity(
"Post",
x =>
{
x.Property <int>("Id");
x.HasKey("Id").ForSqlServerIsClustered();
});
var key = modelBuilder.Model.FindEntityType("Post").GetKeys().Single();
var annotation = key.FindAnnotation(SqlServerAnnotationNames.Clustered);
var result = generator.GenerateFluentApi(key, annotation);
Assert.Equal("ForSqlServerIsClustered", result.Method);
Assert.Equal(0, result.Arguments.Count);
}
public void GenerateFluentApi_IIndex_works_with_fillfactor()
{
var generator = CreateGenerator();
var modelBuilder = new ModelBuilder(SqlServerConventionSetBuilder.Build());
modelBuilder.Entity(
"Post",
x =>
{
x.Property <int>("Id");
x.Property <string>("Name");
x.HasIndex("Name").HasFillFactor(90);
});
var index = modelBuilder.Model.FindEntityType("Post").GetIndexes().Single();
var result = generator.GenerateFluentApiCalls(index, index.GetAnnotations().ToDictionary(a => a.Name, a => a))
.Single();
Assert.Equal("HasFillFactor", result.Method);
Assert.Equal(1, result.Arguments.Count);
Assert.Equal(90, result.Arguments[0]);
}
public void GenerateFluentApi_IEntityType_works_when_IsMemoryOptimized()
{
var generator = CreateGenerator();
var modelBuilder = SqlServerConventionSetBuilder.CreateModelBuilder();
modelBuilder.Entity(
"Post",
x =>
{
x.Property <int>("Id");
x.IsMemoryOptimized();
});
var entityType = (IEntityType)modelBuilder.Model.FindEntityType("Post");
var result = generator.GenerateFluentApiCalls(entityType, entityType.GetAnnotations().ToDictionary(a => a.Name, a => a))
.Single();
Assert.Equal(nameof(SqlServerEntityTypeBuilderExtensions.IsMemoryOptimized), result.Method);
Assert.Equal(0, result.Arguments.Count);
}
