public void Serialize(DbDatabaseMapping databaseMapping, DbProviderInfo providerInfo, XmlWriter xmlWriter) { DebugCheck.NotNull(xmlWriter); DebugCheck.NotNull(databaseMapping); DebugCheck.NotNull(providerInfo); Debug.Assert(databaseMapping.Model != null); Debug.Assert(databaseMapping.Database != null); _xmlWriter = xmlWriter; _databaseMapping = databaseMapping; _version = databaseMapping.Model.SchemaVersion; _providerInfo = providerInfo; _namespace = Equals(_version, XmlConstants.EdmVersionForV3) ? EdmXmlNamespaceV3 : (Equals(_version, XmlConstants.EdmVersionForV2) ? EdmXmlNamespaceV2 : EdmXmlNamespaceV1); _xmlWriter.WriteStartDocument(); using (Element("Edmx", "Version", string.Format(CultureInfo.InvariantCulture, "{0:F1}", _version))) { WriteEdmxRuntime(); WriteEdmxDesigner(); } _xmlWriter.WriteEndDocument(); _xmlWriter.Flush(); }
public void Invariant_name_and_manifest_token_properties_return_set_values() { var key = new DbProviderInfo("Bill", "Ben"); Assert.Equal("Bill", key.ProviderInvariantName); Assert.Equal("Ben", key.ProviderManifestToken); }
public static StorageMappingItemCollection GetStorageMappingItemCollection( this XDocument model, out DbProviderInfo providerInfo) { DebugCheck.NotNull(model); var edmItemCollection = new EdmItemCollection( new[] { model.Descendants(EdmXNames.Csdl.SchemaNames).Single().CreateReader() }); var ssdlSchemaElement = model.Descendants(EdmXNames.Ssdl.SchemaNames).Single(); providerInfo = new DbProviderInfo( ssdlSchemaElement.ProviderAttribute(), ssdlSchemaElement.ProviderManifestTokenAttribute()); var storeItemCollection = new StoreItemCollection( new[] { ssdlSchemaElement.CreateReader() }); return new StorageMappingItemCollection( edmItemCollection, storeItemCollection, new[] { new XElement(model.Descendants(EdmXNames.Msl.MappingNames).Single()).CreateReader() }); }
public void Serialize(DbDatabaseMapping databaseMapping, DbProviderInfo providerInfo, XmlWriter xmlWriter) { //Contract.Requires(xmlWriter != null); //Contract.Requires(databaseMapping != null); //Contract.Requires(providerInfo != null); Contract.Assert(databaseMapping.Model != null); Contract.Assert(databaseMapping.Database != null); _xmlWriter = xmlWriter; _databaseMapping = databaseMapping; _version = databaseMapping.Model.Version; _providerInfo = providerInfo; _namespace = _version == DataModelVersions.Version3 ? EdmXmlNamespaceV3 : EdmXmlNamespaceV2; _xmlWriter.WriteStartDocument(); using (Element("Edmx", "Version", string.Format(CultureInfo.InvariantCulture, "{0:F1}", _version))) { WriteEdmxRuntime(); WriteEdmxDesigner(); } _xmlWriter.WriteEndDocument(); _xmlWriter.Flush(); }
public static void SetProviderInfo(this EdmModel model, DbProviderInfo providerInfo) { //Contract.Requires(model != null); //Contract.Requires(providerInfo != null); model.Annotations.SetAnnotation(ProviderInfoAnnotation, providerInfo); }
private CodeFirstCachedMetadataWorkspace(MetadataWorkspace metadataWorkspace, IEnumerable<Assembly> assemblies, DbProviderInfo providerInfo, string defaultContainerName) { _metadataWorkspace = metadataWorkspace; _assemblies = assemblies; _providerInfo = providerInfo; _defaultContainerName = defaultContainerName; }
public DatabaseMappingGenerator(DbProviderInfo providerInfo, DbProviderManifest providerManifest) { DebugCheck.NotNull(providerInfo); DebugCheck.NotNull(providerManifest); _providerInfo = providerInfo; _providerManifest = providerManifest; }
static DbCompiledModel CreateModel(Action<DbModelBuilder> configure) { var builder = new DbModelBuilder(); //builder.Conventions.Remove<PluralizingEntitySetNameConvention>(); configure(builder); var providerInfo = new DbProviderInfo(SqlCeProviderServices.ProviderInvariantName, "4.0"); return builder.Build(providerInfo).Compile(); }
internal DbModel(DbProviderInfo providerInfo, DbProviderManifest providerManifest) { DebugCheck.NotNull(providerInfo); DebugCheck.NotNull(providerManifest); _databaseMapping = new DbDatabaseMapping().Initialize( EdmModel.CreateConceptualModel(), EdmModel.CreateStoreModel(providerInfo, providerManifest)); }
public void Can_get_and_set_provider_annotation() { var database = new DbDatabaseMetadata().Initialize(); var providerInfo = new DbProviderInfo("Foo", "Bar"); database.SetProviderInfo(providerInfo); Assert.Same(providerInfo, database.GetProviderInfo()); }
public void Can_get_and_set_provider_annotation() { var database = new EdmModel(DataSpace.CSpace); var providerInfo = new DbProviderInfo("Foo", "Bar"); database.ProviderInfo = providerInfo; Assert.Same(providerInfo, database.ProviderInfo); }
internal DbDatabaseMapping BuildAndValidate(DbProviderInfo providerInfo) { var databaseMapping = base.Build(providerInfo).DatabaseMapping; //databaseMapping.ShellEdmx(); databaseMapping.AssertValid(); return databaseMapping; }
public void GetProviderManifest_resolves_manifest() { var modelBuilder = new DbModelBuilder(); var providerInfo = new DbProviderInfo("System.Data.SqlClient", "2012"); var model = modelBuilder.Build(providerInfo); var providerServices = model.GetProviderManifest(DbConfiguration.DependencyResolver); Assert.NotNull(providerServices); Assert.Equal("SqlServer", providerServices.NamespaceName); }
static DbCompiledModel CreateModel() { var builder = new DbModelBuilder(); builder.Conventions.Remove<PluralizingTableNameConvention>(); builder.Entity<Language>().HasKey(m => m.Name); builder.Entity<EntityTranslationDbEntry>(); var providerInfo = new DbProviderInfo(SqlCeProviderServices.ProviderInvariantName, "4.0"); return builder.Build(providerInfo).Compile(); }
public void Equals_correctly_determines_equality() { var key = new DbProviderInfo("Bill", "Ben"); Assert.True(key.Equals(key)); Assert.True(key.Equals(new DbProviderInfo("Bill", "Ben"))); Assert.False(key.Equals(new DbProviderInfo("Bill", "Men"))); Assert.False(key.Equals(new DbProviderInfo("FlowerPot", "Ben"))); Assert.False(key.Equals(null)); Assert.False(key.Equals("Bill.And.Ben")); }
public void CanBuildCompiledDbModelProgrammatically() { var modelBuilder = new DbModelBuilder(); modelBuilder.Entity<HR1.EntityObject_Product>().HasEntitySetName("Product"); modelBuilder.Entity<HR1.EntityObject_Order>().HasEntitySetName("Order"); modelBuilder.Entity<HR1.EntityObject_OrderLine>().HasEntitySetName("OrderLine"); var providerInfo = new DbProviderInfo(providerInvariantName: "System.Data.SqlClient", providerManifestToken: "2012"); var model = modelBuilder.Build(providerInfo); var compiledModel = model.Compile(); }
public static StoreItemCollection GetStoreItemCollection(this XDocument model, out DbProviderInfo providerInfo) { Contract.Requires(model != null); var schemaElement = model.Descendants(EdmXNames.Ssdl.SchemaNames).Single(); providerInfo = new DbProviderInfo( schemaElement.ProviderAttribute(), schemaElement.ProviderManifestTokenAttribute()); return new StoreItemCollection(new[] { schemaElement.CreateReader() }); }
// <summary> // Builds and stores the workspace based on the given code first configuration. // </summary> // <param name="databaseMapping"> The code first EDM model. </param> public CodeFirstCachedMetadataWorkspace(DbDatabaseMapping databaseMapping) { DebugCheck.NotNull(databaseMapping); _providerInfo = databaseMapping.ProviderInfo; _metadataWorkspace = databaseMapping.ToMetadataWorkspace(); _assemblies = databaseMapping.Model.GetClrTypes().Select(t => t.Assembly()).Distinct().ToList(); Debug.Assert(databaseMapping.Model.Containers.Count() == 1, "Expecting Code First to create only one container."); _defaultContainerName = databaseMapping.Model.Containers.First().Name; }
public static DbProviderInfo GetProviderInfo( this DbConnection connection, out DbProviderManifest providerManifest) { //Contract.Requires(connection != null); var providerServices = DbProviderServices.GetProviderServices(connection); var providerManifestToken = providerServices.GetProviderManifestTokenChecked(connection); var providerInfo = new DbProviderInfo(connection.GetProviderInvariantName(), providerManifestToken); providerManifest = providerServices.GetProviderManifest(providerManifestToken); return providerInfo; }
/// <summary> /// Builds and stores the workspace based on the given code first configuration. /// </summary> /// <param name = "databaseMapping">The code first EDM model.</param> public CodeFirstCachedMetadataWorkspace(DbDatabaseMapping databaseMapping) { Contract.Requires(databaseMapping != null); _providerInfo = databaseMapping.Database.GetProviderInfo(); _metadataWorkspace = databaseMapping.ToMetadataWorkspace(); _assemblies = databaseMapping.Model.GetClrTypes().Select(t => t.Assembly).Distinct().ToList(); Contract.Assert( databaseMapping.Model.Containers.Count() == 1, "Expecting Code First to create only one container."); _defaultContainerName = databaseMapping.Model.Containers.First().Name; }
internal static CommerceDbContext Create(CommerceInstanceSettings metadata, ICommerceDbProvider dbProvider) { var dbProviderInfo = new DbProviderInfo(metadata.DbProviderInvariantName, metadata.DbProviderManifestToken); var model = _modelCache.GetOrAdd(new ModelCacheKey(metadata.DbSchema, dbProviderInfo), key => { return CreateModel(key.Schema, key.DbProviderInfo); }); var dbProviderFactory = DbConfiguration.DependencyResolver.GetService(typeof(DbProviderFactory), dbProvider.InvariantName) as DbProviderFactory; var conn = dbProviderFactory.CreateConnection(); conn.ConnectionString = dbProvider.GetConnectionString(metadata); return new CommerceDbContext(metadata, conn, model); }
public static DbProviderInfo GetProviderInfo( this DbConnection connection, out DbProviderManifest providerManifest) { DebugCheck.NotNull(connection); var providerManifestToken = DbConfiguration .GetService<IManifestTokenService>() .GetProviderManifestToken(connection); var providerInfo = new DbProviderInfo(connection.GetProviderInvariantName(), providerManifestToken); providerManifest = DbProviderServices.GetProviderServices(connection).GetProviderManifest(providerManifestToken); return providerInfo; }
internal DbDatabaseMapping BuildAndValidate(DbProviderInfo providerInfo, bool throwOnError, params Type[] unignoredTypes) { IgnoreAll(unignoredTypes); // Build and clone multiple times to check for idempotency issues. Build(providerInfo); var cloned = Clone(); var databaseMapping = cloned.Build(providerInfo).DatabaseMapping; databaseMapping.AssertValid(throwOnError); return databaseMapping; }
private DbContextInfo( Type contextType, DbProviderInfo modelProviderInfo, AppConfig config, DbConnectionInfo connectionInfo) { if (!typeof(DbContext).IsAssignableFrom(contextType)) { throw new ArgumentOutOfRangeException("contextType"); } _contextType = contextType; _modelProviderInfo = modelProviderInfo; _appConfig = config; _connectionInfo = connectionInfo; _activator = CreateActivator(); if (_activator != null) { DatabaseInitializerSuppressor.Instance.Suppress(_contextType); var context = _activator(); if (context != null) { context.InternalContext.OnDisposing += (_, __) => DatabaseInitializerSuppressor.Instance.Unsuppress(_contextType); _isConstructible = true; PushConfiguration(context); using (context) { ConfigureContext(context); _connectionString = context.InternalContext.Connection.ConnectionString; _connectionStringName = context.InternalContext.ConnectionStringName; _connectionProviderName = context.InternalContext.ProviderName; _connectionStringOrigin = context.InternalContext.ConnectionStringOrigin; } } } }
private DbContextInfo( Type contextType, DbProviderInfo modelProviderInfo, AppConfig config, DbConnectionInfo connectionInfo, Func <IDbDependencyResolver> resolver = null) { if (!typeof(DbContext).IsAssignableFrom(contextType)) { throw new ArgumentOutOfRangeException("contextType"); } _resolver = resolver ?? (() => DbConfiguration.DependencyResolver); _contextType = contextType; _modelProviderInfo = modelProviderInfo; _appConfig = config; _connectionInfo = connectionInfo; _activator = CreateActivator(); if (_activator != null) { var context = CreateInstance(); if (context != null) { _isConstructible = true; using (context) { _connectionString = DbInterception.Dispatch.Connection.GetConnectionString( context.InternalContext.Connection, new DbInterceptionContext().WithDbContext(context)); _connectionStringName = context.InternalContext.ConnectionStringName; _connectionProviderName = context.InternalContext.ProviderName; _connectionStringOrigin = context.InternalContext.ConnectionStringOrigin; } } } }
public static DbModel CreateModel(DbProviderInfo provider) { if (_chinookModel == null) { var builder = new DbModelBuilder(); builder.Entity<Genre>(); builder.Entity<MediaType>(); builder.Entity<Artist>(); builder.Entity<Album>(); builder.Entity<Track>(); builder.Entity<Employee>(); builder.Entity<Customer>(); builder.Entity<Invoice>(); builder.Entity<InvoiceLine>(); builder.Entity<Playlist>(); builder.Entity<PlaylistTrack>(); _chinookModel = builder.Build(provider); } return _chinookModel; }
private DbContextInfo( Type contextType, DbProviderInfo modelProviderInfo, AppConfig config, DbConnectionInfo connectionInfo) { if (!typeof(DbContext).IsAssignableFrom(contextType)) { throw new ArgumentOutOfRangeException("contextType"); } _contextType = contextType; _modelProviderInfo = modelProviderInfo; _appConfig = config; _connectionInfo = connectionInfo; _activator = CreateActivator(); if (_activator != null) { var context = _activator(); if (context != null) { _isConstructible = true; PushConfiguration(context); using (context) { ConfigureContext(context); _connectionString = context.InternalContext.Connection.ConnectionString; _connectionStringName = context.InternalContext.ConnectionStringName; _connectionProviderName = context.InternalContext.ProviderName; _connectionStringOrigin = context.InternalContext.ConnectionStringOrigin; } } } }
private DbContextInfo( Type contextType, DbProviderInfo modelProviderInfo, AppConfig config, DbConnectionInfo connectionInfo, Func <IDbDependencyResolver> resolver = null) { if (!typeof(DbContext).IsAssignableFrom(contextType)) { throw new ArgumentOutOfRangeException(nameof(contextType)); } this._resolver = resolver ?? (Func <IDbDependencyResolver>)(() => DbConfiguration.DependencyResolver); this._contextType = contextType; this._modelProviderInfo = modelProviderInfo; this._appConfig = config; this._connectionInfo = connectionInfo; this._activator = this.CreateActivator(); if (this._activator == null) { return; } DbContext instance = this.CreateInstance(); if (instance == null) { return; } this._isConstructible = true; using (instance) { this._connectionString = DbInterception.Dispatch.Connection.GetConnectionString(instance.InternalContext.Connection, new DbInterceptionContext().WithDbContext(instance)); this._connectionStringName = instance.InternalContext.ConnectionStringName; this._connectionProviderName = instance.InternalContext.ProviderName; this._connectionStringOrigin = instance.InternalContext.ConnectionStringOrigin; } }
public static DbModel GetDynamicUpdateModel(this DbContext context, DbProviderInfo providerInfo) { DebugCheck.NotNull(context); DebugCheck.NotNull(providerInfo); var model = context .InternalContext .CodeFirstModel .CachedModelBuilder .Build(providerInfo); var entityContainerMapping = model.DatabaseMapping.EntityContainerMappings.Single(); entityContainerMapping .EntitySetMappings .Each(esm => esm.ClearModificationFunctionMappings()); entityContainerMapping .AssociationSetMappings .Each(asm => asm.ModificationFunctionMapping = null); return model; }
/// <summary> /// Creates a new instance representing a given <see cref="T:System.Data.Entity.DbContext" /> type. A <see cref="T:System.Data.Entity.Infrastructure.DbProviderInfo" /> /// can be supplied in order to override the default determined provider used when constructing /// the underlying EDM model. /// </summary> /// <param name="contextType"> /// The type deriving from <see cref="T:System.Data.Entity.DbContext" />. /// </param> /// <param name="modelProviderInfo"> /// A <see cref="T:System.Data.Entity.Infrastructure.DbProviderInfo" /> specifying the underlying ADO.NET provider to target. /// </param> public DbContextInfo(Type contextType, DbProviderInfo modelProviderInfo) : this(Check.NotNull <Type>(contextType, nameof(contextType)), Check.NotNull <DbProviderInfo>(modelProviderInfo, nameof(modelProviderInfo)), AppConfig.DefaultInstance, (DbConnectionInfo)null, (Func <IDbDependencyResolver>)null) { }
private static DbProviderManifest GetProviderManifest(DbProviderInfo providerInfo) { return DbConfiguration.DependencyResolver.GetService<DbProviderFactory>(providerInfo.ProviderInvariantName) .GetProviderServices() .GetProviderManifest(providerInfo.ProviderManifestToken); }
private bool Equals(DbProviderInfo other) { return(string.Equals(_providerInvariantName, other._providerInvariantName) && string.Equals(_providerManifestToken, other._providerManifestToken)); }
/// <summary> /// Creates a new instance representing a given <see cref="T:System.Data.Entity.DbContext" /> type. An external config /// object (e.g. app.config or web.config) can be supplied and will be used during connection string /// resolution. This includes looking for connection strings and DefaultConnectionFactory entries. /// A <see cref="T:System.Data.Entity.Infrastructure.DbProviderInfo" /> can be supplied in order to override the default determined /// provider used when constructing the underlying EDM model. This can be useful to prevent EF from /// connecting to discover a manifest token. /// </summary> /// <param name="contextType"> /// The type deriving from <see cref="T:System.Data.Entity.DbContext" />. /// </param> /// <param name="config"> An object representing the config file. </param> /// <param name="modelProviderInfo"> /// A <see cref="T:System.Data.Entity.Infrastructure.DbProviderInfo" /> specifying the underlying ADO.NET provider to target. /// </param> public DbContextInfo(Type contextType, System.Configuration.Configuration config, DbProviderInfo modelProviderInfo) : this(Check.NotNull <Type>(contextType, nameof(contextType)), Check.NotNull <DbProviderInfo>(modelProviderInfo, nameof(modelProviderInfo)), new AppConfig(Check.NotNull <System.Configuration.Configuration>(config, nameof(config))), (DbConnectionInfo)null, (Func <IDbDependencyResolver>)null) { }
/// <summary> /// Creates a new instance representing a given <see cref="DbContext" /> type. An external config /// object (e.g. app.config or web.config) can be supplied and will be used during connection string /// resolution. This includes looking for connection strings and DefaultConnectionFactory entries. /// A <see cref="DbProviderInfo" /> can be supplied in order to override the default determined /// provider used when constructing the underlying EDM model. This can be useful to prevent EF from /// connecting to discover a manifest token. /// </summary> /// <param name="contextType"> /// The type deriving from <see cref="DbContext" />. /// </param> /// <param name="config"> An object representing the config file. </param> /// <param name="modelProviderInfo"> /// A <see cref="DbProviderInfo" /> specifying the underlying ADO.NET provider to target. /// </param> public DbContextInfo(Type contextType, Configuration config, DbProviderInfo modelProviderInfo) : this( Check.NotNull(contextType, "contextType"), Check.NotNull(modelProviderInfo, "modelProviderInfo"), new AppConfig(Check.NotNull(config, "config")), null) { }
internal DbModel(DbProviderInfo providerInfo, DbProviderManifest providerManifest) { this._databaseMapping = new DbDatabaseMapping().Initialize(EdmModel.CreateConceptualModel(3.0), EdmModel.CreateStoreModel(providerInfo, providerManifest, 3.0)); }
/// <summary> /// Creates a new instance representing a given <see cref="DbContext" /> type. A <see cref="DbProviderInfo" /> /// can be supplied in order to override the default determined provider used when constructing /// the underlying EDM model. /// </summary> /// <param name="contextType"> /// The type deriving from <see cref="DbContext" />. /// </param> /// <param name="modelProviderInfo"> /// A <see cref="DbProviderInfo" /> specifying the underlying ADO.NET provider to target. /// </param> public DbContextInfo(Type contextType, DbProviderInfo modelProviderInfo) : this( Check.NotNull(contextType, "contextType"), Check.NotNull(modelProviderInfo, "modelProviderInfo"), AppConfig.DefaultInstance, null) { }
internal static DbSpatialServices GetSpatialServices(IDbDependencyResolver resolver, EntityConnection connection) { DebugCheck.NotNull(resolver); DebugCheck.NotNull(connection); var storeItemCollection = (StoreItemCollection)connection.GetMetadataWorkspace().GetItemCollection(DataSpace.SSpace); var key = new DbProviderInfo( storeItemCollection.StoreProviderInvariantName, storeItemCollection.StoreProviderManifestToken); return GetSpatialServices(resolver, key, () => GetProviderServices(connection.StoreConnection)); }
public DbSpatialServices GetSpatialServices(DbProviderInfo key) { DebugCheck.NotNull(key); return GetSpatialServices(_resolver.Value, key, () => this); }
private static DbSpatialServices GetSpatialServices( IDbDependencyResolver resolver, DbProviderInfo key, Func<DbProviderServices> providerServices) // Delegate use to avoid lookup when not needed { DebugCheck.NotNull(resolver); DebugCheck.NotNull(key); DebugCheck.NotNull(providerServices); var services = _spatialServices.GetOrAdd( key, k => resolver.GetService<DbSpatialServices>(k) ?? providerServices().GetSpatialServicesInternal(k.ProviderManifestToken, throwIfNotImplemented: false) ?? resolver.GetService<DbSpatialServices>()); if (services == null) { throw new ProviderIncompatibleException(Strings.ProviderDidNotReturnSpatialServices); } return services; }
internal DbMigrator(DbMigrationsConfiguration configuration, DbContext usersContext) : base(null) { Contract.Requires(configuration != null); Contract.Requires(configuration.ContextType != null); _configuration = configuration; _calledByCreateDatabase = usersContext != null; // If DbContext CreateDatabase is using Migrations then the user has not opted out of initializers // and if we disable the initializer here then future calls to Initialize the database (for this or // a different connection) will fail. So only disable the initializer if Migrations are being used // explicitly. if (usersContext == null) { DisableInitializer(_configuration.ContextType); } if (_calledByCreateDatabase) { _usersContextInfo = new DbContextInfo(usersContext); } else { _usersContextInfo = configuration.TargetDatabase == null ? new DbContextInfo(configuration.ContextType) : new DbContextInfo(configuration.ContextType, configuration.TargetDatabase); if (!_usersContextInfo.IsConstructible) { throw Error.ContextNotConstructible(configuration.ContextType); } } _modelDiffer = _configuration.ModelDiffer; var context = usersContext ?? _usersContextInfo.CreateInstance(); try { _migrationAssembly = new MigrationAssembly(_configuration.MigrationsAssembly, _configuration.MigrationsNamespace); _currentModel = context.GetModel(); var connection = context.Database.Connection; _providerFactory = DbProviderServices.GetProviderFactory(connection); _defaultSchema = context.InternalContext.DefaultSchema; var historySchemas = GetHistorySchemas(); if (!string.IsNullOrWhiteSpace(_defaultSchema)) { historySchemas = historySchemas.Concat(new[] { _defaultSchema }); } _historyRepository = new HistoryRepository(_usersContextInfo.ConnectionString, _providerFactory, historySchemas); _providerManifestToken = context.InternalContext.ModelProviderInfo != null ? context.InternalContext.ModelProviderInfo.ProviderManifestToken : DbProviderServices.GetProviderServices(connection). GetProviderManifestTokenChecked(connection); _targetDatabase = Strings.LoggingTargetDatabaseFormat( connection.DataSource, connection.Database, _usersContextInfo.ConnectionProviderName, _usersContextInfo.ConnectionStringOrigin == DbConnectionStringOrigin.DbContextInfo ? Strings.LoggingExplicit : _usersContextInfo.ConnectionStringOrigin.ToString()); } finally { if (usersContext == null) { context.Dispose(); } } var providerInfo = new DbProviderInfo(_usersContextInfo.ConnectionProviderName, _providerManifestToken); _emptyModel = new Lazy<XDocument>(() => new DbModelBuilder().Build(providerInfo).GetModel()); _historyRepository.AppendHistoryModel(_currentModel, providerInfo); }