Elastische Database-clientbibliotheek met Entity FrameworkElastic Database client library with Entity Framework

Dit document bevat de wijzigingen in een Entity Framework-toepassing die nodig zijn om te integreren met de hulpmiddelen voor Elastic Database.This document shows the changes in an Entity Framework application that are needed to integrate with the Elastic Database tools. De focus ligt op het samenstellen van shard-Toewijzingsbeheer en gegevensafhankelijke routering met het Entity Framework Code First benadering.The focus is on composing shard map management and data-dependent routing with the Entity Framework Code First approach. De Code-: nieuwe Database zelfstudie voor EF fungeert als de actieve voorbeeld in dit document.The Code First - New Database tutorial for EF serves as the running example throughout this document. De voorbeeldcode bij dit document is onderdeel van de hulpmiddelen voor elastic database stellen van de voorbeelden in de Visual Studio-codevoorbeelden.The sample code accompanying this document is part of elastic database tools' set of samples in the Visual Studio Code Samples.

Downloaden en uitvoeren van de voorbeeldcodeDownloading and Running the Sample Code

Voor het downloaden van de code voor dit artikel:To download the code for this article:

  • Visual Studio 2012 of hoger is vereist.Visual Studio 2012 or later is required.
  • Download de elastische DB-hulpprogramma's voor Azure SQL - integratie met Entity Framework voorbeeld van MSDN.Download the Elastic DB Tools for Azure SQL - Entity Framework Integration sample from MSDN. Pak deze uit het voorbeeld naar een locatie van uw keuze.Unzip the sample to a location of your choosing.
  • Start Visual Studio.Start Visual Studio.
  • In Visual Studio, selecteer Bestand -> Open Project/oplossing.In Visual Studio, select File -> Open Project/Solution.
  • In de Open Project dialoogvenster, navigeer naar het voorbeeld dat u hebt gedownload en selecteer EntityFrameworkCodeFirst.sln te openen in het voorbeeld.In the Open Project dialog, navigate to the sample you downloaded and select EntityFrameworkCodeFirst.sln to open the sample.

De als voorbeeld wilt uitvoeren, moet u drie lege databases maken in Azure SQL Database:To run the sample, you need to create three empty databases in Azure SQL Database:

  • Database voor shard-ToewijzingsbeheerShard Map Manager database
  • Database voor shard 1Shard 1 database
  • Database voor shard 2Shard 2 database

Als u deze databases hebt gemaakt, vult u de tijdelijke aanduidingen in Program.cs met de naam van uw Azure SQL-database-server, de databasenamen van de en uw referenties verbinding maken met de databases.Once you have created these databases, fill in the place holders in Program.cs with your Azure SQL DB server name, the database names, and your credentials to connect to the databases. Maak de oplossing in Visual Studio.Build the solution in Visual Studio. Visual Studio downloadt de vereiste NuGet-pakketten voor de elastische database-clientbibliotheek, Entity Framework en tijdelijke fouten afhandelen als onderdeel van het bouwproces.Visual Studio downloads the required NuGet packages for the elastic database client library, Entity Framework, and Transient Fault handling as part of the build process. Zorg ervoor dat het herstellen van NuGet-pakketten is ingeschakeld voor uw oplossing.Make sure that restoring NuGet packages is enabled for your solution. U kunt deze instelling inschakelen met de rechtermuisknop op het oplossingsbestand in Visual Studio Solution Explorer.You can enable this setting by right-clicking on the solution file in the Visual Studio Solution Explorer.

Entity Framework-werkstromenEntity Framework workflows

Entity Framework ontwikkelaars afhankelijk zijn van een van de volgende vier werkstromen om toepassingen te bouwen en om ervoor te zorgen persistentie van de objecten voor toepassingen:Entity Framework developers rely on one of the following four workflows to build applications and to ensure persistence for application objects:

  • Code First (nieuwe Database) : De ontwikkelaar EF maakt het model in de toepassingscode en EF genereert vervolgens de database uit.Code First (New Database): The EF developer creates the model in the application code and then EF generates the database from it.
  • Code First (bestaande Database) : De ontwikkelaar kunt EF de toepassingscode voor het model genereren vanuit een bestaande database.Code First (Existing Database): The developer lets EF generate the application code for the model from an existing database.
  • Eerste model: De ontwikkelaar maakt het model in de ontwerpfunctie voor EF en EF maakt vervolgens de database uit het model.Model First: The developer creates the model in the EF designer and then EF creates the database from the model.
  • Eerste database: De ontwikkelaar gebruikt EF hulpprogramma's voor het afleiden van het model van een bestaande database.Database First: The developer uses EF tooling to infer the model from an existing database.

Alle deze methoden zijn afhankelijk van de DbContext-klasse voor het beheren van databaseverbindingen en database-schema voor een toepassing met transparant.All these approaches rely on the DbContext class to transparently manage database connections and database schema for an application. Verschillende constructors op de basis DbContext-klasse kunnen verschillende niveaus van controle over verbinding maken, uitvoeren van de database bootstrap en schema's.Different constructors on the DbContext base class allow for different levels of control over connection creation, database bootstrapping, and schema creation. Uitdagingen ontstaan voornamelijk uit het feit dat de database verbinding management via EF met de mogelijkheden voor verbinding van de gegevensafhankelijke routering interfaces opgegeven samen door de client-bibliotheek elastische database.Challenges arise primarily from the fact that the database connection management provided by EF intersects with the connection management capabilities of the data-dependent routing interfaces provided by the elastic database client library.

Veronderstellingen voor elastische database-hulpprogramma 'sElastic database tools assumptions

Zie voor definities van de termijn woordenlijst voor hulpprogramma's elastische Database.For term definitions, see Elastic Database tools glossary.

Met de clientbibliotheek voor elastic database definieert u partities van de gegevens van uw toepassing met de naam shardlets.With elastic database client library, you define partitions of your application data called shardlets. Shardlets worden aangeduid met een sharding-sleutel en zijn toegewezen aan specifieke databases.Shardlets are identified by a sharding key and are mapped to specific databases. Een toepassing kan zoveel databases als nodig hebt en distribueren van de shardlets voor voldoende capaciteit of prestaties gegeven van de huidige zakelijke vereisten.An application may have as many databases as needed and distribute the shardlets to provide enough capacity or performance given current business requirements. De toewijzing van sharding-sleutelwaarden op de databases wordt opgeslagen in een shard-toewijzing geleverd door de client-API's voor de elastische database.The mapping of sharding key values to the databases is stored by a shard map provided by the elastic database client APIs. Deze mogelijkheid wordt genoemd Shard-Toewijzingsbeheer, of SMM kortweg.This capability is called Shard Map Management, or SMM for short. De shard-toewijzing fungeert ook als de broker van databaseverbindingen voor aanvragen die een sharding-sleutel bevatten.The shard map also serves as the broker of database connections for requests that carry a sharding key. Deze mogelijkheid wordt ook wel gegevensafhankelijke routering.This capability is known as data-dependent routing.

De shard-Toewijzingsbeheer beveiligt gebruikers tegen inconsistent weergaven in shardlet-gegevens die optreden kunnen wanneer gelijktijdige shardlet management-bewerkingen (zoals het verplaatsen van gegevens uit één shard naar een andere) plaatsvinden.The shard map manager protects users from inconsistent views into shardlet data that can occur when concurrent shardlet management operations (such as relocating data from one shard to another) are happening. Om dit te doen, beheerd de shard-toewijzingen door de client-bibliotheek broker de databaseverbindingen voor een toepassing.To do so, the shard maps managed by the client library broker the database connections for an application. Hiermee wordt de functionaliteit van de kaart shard automatisch afsluiten van een databaseverbinding wanneer shard management-bewerkingen kunnen invloed hebben op de shardlet die voor de verbinding is gemaakt.This allows the shard map functionality to automatically kill a database connection when shard management operations could impact the shardlet that the connection has been created for. Deze aanpak nodig heeft om te integreren met een aantal van de EF-functionaliteit, zoals het maken van nieuwe verbindingen van een bestaande om te controleren op aanwezigheid database.This approach needs to integrate with some of EF’s functionality, such as creating new connections from an existing one to check for database existence. In het algemeen is onze waarneming dat de standaard alleen werken op betrouwbare wijze voor gesloten databaseverbindingen die veilig kunnen worden gekloond voor EF DbContext-constructors werken.In general, our observation has been that the standard DbContext constructors only work reliably for closed database connections that can safely be cloned for EF work. In plaats daarvan is het ontwerpprincipe van elastische database alleen broker geopende verbindingen.The design principle of elastic database instead is to only broker opened connections. Een denkt dat het sluiten van een verbinding met de clientbibliotheek voor overdracht naar de DbContext EF brokered dit probleem kan oplossen.One might think that closing a connection brokered by the client library before handing it over to the EF DbContext may solve this issue. Door de verbinding wordt gesloten en vertrouwen op EF te openen, foregoes een echter de validatie en consistentie controles uitgevoerd door de bibliotheek.However, by closing the connection and relying on EF to reopen it, one foregoes the validation and consistency checks performed by the library. De functionaliteit voor migraties in EF, gebruikt echter deze verbindingen voor het beheren van het schema van de onderliggende database op een manier die is transparant voor de toepassing.The migrations functionality in EF, however, uses these connections to manage the underlying database schema in a way that is transparent to the application. In het ideale geval u behouden en alle deze mogelijkheden van de clientbibliotheek voor elastic database en de EF in dezelfde toepassing combineren.Ideally, you will retain and combine all these capabilities from both the elastic database client library and EF in the same application. De volgende sectie worden deze eigenschappen en de vereisten in meer detail beschreven.The following section discusses these properties and requirements in more detail.

VereistenRequirements

Als u werkt met de clientbibliotheek voor elastic database- en Entity Framework-API's, die u wilt behouden van de volgende eigenschappen:When working with both the elastic database client library and Entity Framework APIs, you want to retain the following properties:

  • Scale-out: Toevoegen of verwijderen van databases van de gegevenslaag van de shard-toepassing die nodig zijn voor de behoeften van de capaciteit van de toepassing.Scale-out: To add or remove databases from the data tier of the sharded application as necessary for the capacity demands of the application. Dit betekent dat de controle over het maken en verwijderen van databases en het gebruik van de elastische database shard-Toewijzingsbeheer API's voor het beheren van databases en -toewijzingen van shardlets.This means control over the creation and deletion of databases and using the elastic database shard map manager APIs to manage databases, and mappings of shardlets.
  • Consistentie: De toepassing de veiligheidsmaatregelen voor sharding en de gegevensafhankelijke routering mogelijkheden van de clientbibliotheek gebruikt.Consistency: The application employs sharding, and uses the data-dependent routing capabilities of the client library. Om te voorkomen beschadigd of verkeerd queryresultaten, worden verbindingen geleverd door de shard-toewijzing.To avoid corruption or wrong query results, connections are brokered through the shard map manager. Dit houdt ook validatie en consistentie.This also retains validation and consistency.
  • Code First: Het gemak van de EF code eerste paradigma behouden.Code First: To retain the convenience of EF’s code first paradigm. Klassen in de toepassing worden in Code First transparant toegewezen aan de onderliggende databasestructuren.In Code First, classes in the application are mapped transparently to the underlying database structures. De code van de toepassing communiceert met DbSets die de meeste aspecten die betrokken zijn bij het verwerken van de onderliggende database maskeren.The application code interacts with DbSets that mask most aspects involved in the underlying database processing.
  • Schema: Entity Framework verwerkt de initiële database-schema wordt gemaakt en de ontwikkeling van de volgende schema via migraties.Schema: Entity Framework handles initial database schema creation and subsequent schema evolution through migrations. Met behoud van deze mogelijkheden, is aanpassing van uw app eenvoudig als de gegevens zich verder ontwikkelt.By retaining these capabilities, adapting your app is easy as the data evolves.

De volgende richtlijnen geïnstrueerd hoe om te voldoen aan deze vereisten voor Code First-toepassingen met hulpmiddelen voor elastic database.The following guidance instructs how to satisfy these requirements for Code First applications using elastic database tools.

Gegevensafhankelijke routering EF DbContext gebruikenData-dependent routing using EF DbContext

Databaseverbindingen met Entity Framework worden meestal beheerd via subklassen van DbContext.Database connections with Entity Framework are typically managed through subclasses of DbContext. Deze subklassen maken die is afgeleid van DbContext.Create these subclasses by deriving from DbContext. Dit is waar u definieert uw DbSets die de verzamelingen database-ondersteuning met CLR-objecten voor uw toepassing implementeren.This is where you define your DbSets that implement the database-backed collections of CLR objects for your application. In de context van gegevensafhankelijke routering, kunt u verschillende nuttige eigenschappen die niet noodzakelijkerwijs voor andere eerste toepassingsscenario's EF code bewaart identificeren:In the context of data-dependent routing, you can identify several helpful properties that do not necessarily hold for other EF code first application scenarios:

  • De database bestaat al en is geregistreerd in de shard-toewijzing voor elastische database.The database already exists and has been registered in the elastic database shard map.
  • Het schema van de toepassing is al geïmplementeerd voor de database (Zie hieronder).The schema of the application has already been deployed to the database (explained below).
  • Gegevensafhankelijke routering verbindingen met de database zijn brokered door de shard-toewijzing.Data-dependent routing connections to the database are brokered by the shard map.

Om te integreren DbContexts met gegevensafhankelijke routering voor scale-out:To integrate DbContexts with data-dependent routing for scale-out:

  1. Verbindingen van de fysieke database via de elastic database client-interfaces van de shard-Toewijzingsbeheer makenCreate physical database connections through the elastic database client interfaces of the shard map manager,
  2. Teruglopen van de verbinding met de DbContext subklasseWrap the connection with the DbContext subclass
  3. De verbinding naar beneden doorgeven aan de DbContext klassen om te controleren of de verwerking aan de EF gebeurt ook baseren.Pass the connection down into the DbContext base classes to ensure all the processing on the EF side happens as well.

Het volgende codevoorbeeld ziet u deze aanpak.The following code example illustrates this approach. (Deze code is ook in de bijbehorende Visual Studio-project)(This code is also in the accompanying Visual Studio project)

public class ElasticScaleContext<T> : DbContext
{
public DbSet<Blog> Blogs { get; set; }
...

    // C'tor for data-dependent routing. This call opens a validated connection 
    // routed to the proper shard by the shard map manager. 
    // Note that the base class c'tor call fails for an open connection
    // if migrations need to be done and SQL credentials are used. This is the reason for the 
    // separation of c'tors into the data-dependent routing case (this c'tor) and the internal c'tor for new shards.
    public ElasticScaleContext(ShardMap shardMap, T shardingKey, string connectionStr)
        : base(CreateDDRConnection(shardMap, shardingKey, connectionStr), 
        true /* contextOwnsConnection */)
    {
    }

    // Only static methods are allowed in calls into base class c'tors.
    private static DbConnection CreateDDRConnection(
    ShardMap shardMap, 
    T shardingKey, 
    string connectionStr)
    {
        // No initialization
        Database.SetInitializer<ElasticScaleContext<T>>(null);

        // Ask shard map to broker a validated connection for the given key
        SqlConnection conn = shardMap.OpenConnectionForKey<T>
                            (shardingKey, connectionStr, ConnectionOptions.Validate);
        return conn;
    }

Belangrijkste puntenMain points

  • Een nieuwe constructor vervangt de standaardconstructor in de subklasse DbContextA new constructor replaces the default constructor in the DbContext subclass

  • De nieuwe constructor neemt de argumenten die vereist zijn voor de gegevensafhankelijke routering via de clientbibliotheek voor elastic database:The new constructor takes the arguments that are required for data-dependent routing through elastic database client library:

    • de shard-toewijzing voor toegang tot de interfaces gegevensafhankelijke routeringthe shard map to access the data-dependent routing interfaces,
    • de sharding-sleutel voor het identificeren van de shardletthe sharding key to identify the shardlet,
    • een verbindingsreeks met de referenties voor de gegevensafhankelijke routering verbinding met de shard.a connection string with the credentials for the data-dependent routing connection to the shard.
  • De aanroep naar de basisklassenconstructor duurt een detour in een statische methode waarmee u alle stappen die nodig zijn voor gegevensafhankelijke routering.The call to the base class constructor takes a detour into a static method that performs all the steps necessary for data-dependent routing.

    • Hierbij de OpenConnectionForKey aanroep van de client-interfaces voor elastische database in de shard-toewijzing een open verbinding tot stand brengen.It uses the OpenConnectionForKey call of the elastic database client interfaces on the shard map to establish an open connection.
    • De shard-toewijzing wordt gemaakt van de open verbinding met de shard die de shardlet voor de opgegeven sharding-sleutel bevat.The shard map creates the open connection to the shard that holds the shardlet for the given sharding key.
    • Deze open verbinding wordt doorgegeven aan de constructor van de basisklasse van DbContext om aan te geven dat deze verbinding moet worden gebruikt door EF in plaats van laten EF automatisch een nieuwe verbinding maken.This open connection is passed back to the base class constructor of DbContext to indicate that this connection is to be used by EF instead of letting EF create a new connection automatically. Op deze manier de verbinding is gemarkeerd door de databaseclient-API van elastic, zodat deze consistentie onder beheerbewerkingen voor shard-toewijzing kunt garanderen.This way the connection has been tagged by the elastic database client API so that it can guarantee consistency under shard map management operations.

Gebruik de nieuwe constructor voor uw subklasse DbContext in plaats van de standaardconstructor in uw code.Use the new constructor for your DbContext subclass instead of the default constructor in your code. Hier volgt een voorbeeld:Here is an example:

// Create and save a new blog.

Console.Write("Enter a name for a new blog: "); 
var name = Console.ReadLine(); 

using (var db = new ElasticScaleContext<int>( 
                        sharding.ShardMap,  
                        tenantId1,  
                        connStrBldr.ConnectionString)) 
{ 
    var blog = new Blog { Name = name }; 
    db.Blogs.Add(blog); 
    db.SaveChanges(); 

    // Display all Blogs for tenant 1 
    var query = from b in db.Blogs 
                orderby b.Name 
                select b; 
    … 
}

De nieuwe constructor opent de verbinding met de shard waarin de gegevens voor de shardlet geïdentificeerd door de waarde van tenantid1.The new constructor opens the connection to the shard that holds the data for the shardlet identified by the value of tenantid1. De code in de met behulp van blok blijft ongewijzigd voor toegang tot de DbSet voor blogs EF met in de shard voor tenantid1.The code in the using block stays unchanged to access the DbSet for blogs using EF on the shard for tenantid1. Hiermee wordt semantiek gewijzigd voor de code in het gebruik blokkeren zodanig dat alle databasebewerkingen nu zijn gericht op één shard waar tenantid1 wordt bewaard.This changes semantics for the code in the using block such that all database operations are now scoped to the one shard where tenantid1 is kept. Bijvoorbeeld, een LINQ-query op de blogs DbSet retourneerde alleen opgeslagen op de huidige shard-blogs, maar niet de bestanden die zijn opgeslagen op andere shards.For instance, a LINQ query over the blogs DbSet would only return blogs stored on the current shard, but not the ones stored on other shards.

Tijdelijke fouten afhandelenTransient faults handling

Het team Microsoft Patterns & Practices gepubliceerd de de afhandeling van Toepassingsblok fouten.The Microsoft Patterns & Practices team published the The Transient Fault Handling Application Block. De bibliotheek wordt met elastische schaal-clientbibliotheek in combinatie met EF gebruikt.The library is used with elastic scale client library in combination with EF. Echter voor zorgen dat er een tijdelijke uitzondering op een plaats waar u ervoor zorgen retourneert kunt dat de nieuwe constructor wordt gebruikt nadat een tijdelijke fout zodat elke nieuwe verbindingspoging is gemaakt met behulp van de constructors die u toegepast.However, ensure that any transient exception returns to a place where you can ensure that the new constructor is being used after a transient fault so that any new connection attempt is made using the constructors you tweaked. Anders wordt een verbinding met de juiste shard kan niet worden gegarandeerd, en er zijn geen garanties die wordt bijgehouden als er wijzigingen aan de shard-toewijzing optreden.Otherwise, a connection to the correct shard is not guaranteed, and there are no assurances the connection is maintained as changes to the shard map occur.

Het volgende codevoorbeeld laat zien hoe een SQL-beleid voor opnieuw proberen kan worden gebruikt om de nieuwe DbContext subklasse constructors:The following code sample illustrates how a SQL retry policy can be used around the new DbContext subclass constructors:

SqlDatabaseUtils.SqlRetryPolicy.ExecuteAction(() => 
{ 
    using (var db = new ElasticScaleContext<int>( 
                            sharding.ShardMap,  
                            tenantId1,  
                            connStrBldr.ConnectionString)) 
        { 
                var blog = new Blog { Name = name }; 
                db.Blogs.Add(blog); 
                db.SaveChanges(); 
        … 
        } 
    }); 

SqlDatabaseUtils.SqlRetryPolicy in de bovenstaande code wordt gedefinieerd als een SqlDatabaseTransientErrorDetectionStrategy met een aantal nieuwe pogingen van 10, en op 5 seconden wachttijd tussen nieuwe pogingen.SqlDatabaseUtils.SqlRetryPolicy in the code above is defined as a SqlDatabaseTransientErrorDetectionStrategy with a retry count of 10, and 5 seconds wait time between retries. Deze aanpak is vergelijkbaar met de richtlijnen voor EF en de gebruiker geïnitieerde transacties (Zie beperkingen bij uitvoeringsstrategieën voor opnieuw proberen (EF6 en hoger).This approach is similar to the guidance for EF and user-initiated transactions (see Limitations with Retrying Execution Strategies (EF6 onwards). Beide situaties is vereist dat de toepassing Hiermee bepaalt u het bereik waarvoor de tijdelijke uitzondering geretourneerd: aan de transactie opnieuw of maak opnieuw de context van de juiste constructor (zoals) die gebruikmaakt van de clientbibliotheek van elastische database.Both situations require that the application program controls the scope to which the transient exception returns: to either reopen the transaction, or (as shown) recreate the context from the proper constructor that uses the elastic database client library.

De noodzaak om te bepalen waar tijdelijke uitzonderingen worden we weer binnen het bereik ook het gebruik van de ingebouwde uitsluit SqlAzureExecutionStrategy die wordt geleverd met EF.The need to control where transient exceptions take us back in scope also precludes the use of the built-in SqlAzureExecutionStrategy that comes with EF. SqlAzureExecutionStrategy zou opnieuw een verbinding openen, maar niet OpenConnectionForKey en daarom bypass alle validatietests die wordt uitgevoerd als onderdeel van de OpenConnectionForKeyaanroepen.SqlAzureExecutionStrategy would reopen a connection but not use OpenConnectionForKey and therefore bypass all the validation that is performed as part of the OpenConnectionForKey call. In plaats daarvan de voorbeeldcode maakt gebruik van de ingebouwde DefaultExecutionStrategy die wordt geleverd met EF.Instead, the code sample uses the built-in DefaultExecutionStrategy that also comes with EF. Plaats SqlAzureExecutionStrategy, deze correct werkt in combinatie met het beleid voor opnieuw proberen van de afhandeling van tijdelijke fouten.As opposed to SqlAzureExecutionStrategy, it works correctly in combination with the retry policy from Transient Fault Handling. Het uitvoeringsbeleid is ingesteld in de ElasticScaleDbConfiguration klasse.The execution policy is set in the ElasticScaleDbConfiguration class. Houd er rekening mee dat we niet te gebruiken besloten DefaultSqlExecutionStrategy omdat dit kan erop met behulp van wijzen SqlAzureExecutionStrategy als er tijdelijke uitzonderingen optreden - wat zou leiden tot onjuist gedrag, zoals beschreven.Note that we decided not to use DefaultSqlExecutionStrategy since it suggests using SqlAzureExecutionStrategy if transient exceptions occur - which would lead to wrong behavior as discussed. Zie voor meer informatie over de verschillende retry-beleid en de EF Verbindingstolerantie in EF.For more information on the different retry policies and EF, see Connection Resiliency in EF.

Constructor regeneratiesConstructor rewrites

De bovenstaande codevoorbeelden ziet u de standaard-constructor herschrijft vereist zijn voor uw toepassing om te kunnen gebruiken gegevensafhankelijke routering met het Entity Framework.The code examples above illustrate the default constructor re-writes required for your application in order to use data-dependent routing with the Entity Framework. De volgende tabel generaliseert deze aanpak voor het andere constructors.The following table generalizes this approach to other constructors.

Huidige ConstructorCurrent Constructor Herschreven Constructor voor gegevensRewritten Constructor for data Basis-ConstructorBase Constructor OpmerkingenNotes
MyContext()MyContext() ElasticScaleContext(ShardMap, TKey)ElasticScaleContext(ShardMap, TKey) DbContext (DbConnection, bool)DbContext(DbConnection, bool) De verbinding moet een functie van de shard-toewijzing en de gegevensafhankelijke routering sleutel.The connection needs to be a function of the shard map and the data-dependent routing key. U moet omzeilen automatisch verbinding maken met EF en in plaats daarvan de shard-toewijzing te gebruiken als Broker optreden voor de verbinding.You need to by-pass automatic connection creation by EF and instead use the shard map to broker the connection.
MyContext(string)MyContext(string) ElasticScaleContext(ShardMap, TKey)ElasticScaleContext(ShardMap, TKey) DbContext (DbConnection, bool)DbContext(DbConnection, bool) De verbinding is een functie van de shard-toewijzing en de gegevensafhankelijke routering sleutel.The connection is a function of the shard map and the data-dependent routing key. Een vaste databaserol naam of de verbindingsreeks werkt niet als ze validatie omzeilen door de shard-toewijzing.A fixed database name or connection string does not work as they by-pass validation by the shard map.
MyContext(DbCompiledModel)MyContext(DbCompiledModel) ElasticScaleContext(ShardMap, TKey, DbCompiledModel)ElasticScaleContext(ShardMap, TKey, DbCompiledModel) DbContext (DbConnection, DbCompiledModel, bool)DbContext(DbConnection, DbCompiledModel, bool) De verbinding wordt gemaakt voor de opgegeven shard-toewijzing en sharding-sleutel met het model dat is opgegeven.The connection gets created for the given shard map and sharding key with the model provided. Het gecompileerde model wordt doorgegeven aan de basis c'tor.The compiled model is passed on to the base c’tor.
MyContext (DbConnection, bool)MyContext(DbConnection, bool) ElasticScaleContext(ShardMap, TKey, bool)ElasticScaleContext(ShardMap, TKey, bool) DbContext (DbConnection, bool)DbContext(DbConnection, bool) De verbinding moet worden afgeleid van de shard-toewijzing en de sleutel.The connection needs to be inferred from the shard map and the key. Het kan niet worden opgegeven als invoer (tenzij deze invoer is al met behulp van de shard-toewijzing en de sleutel).It cannot be provided as an input (unless that input was already using the shard map and the key). De Booleaanse waarde wordt doorgegeven.The Boolean is passed on.
MyContext(string, DbCompiledModel)MyContext(string, DbCompiledModel) ElasticScaleContext(ShardMap, TKey, DbCompiledModel)ElasticScaleContext(ShardMap, TKey, DbCompiledModel) DbContext (DbConnection, DbCompiledModel, bool)DbContext(DbConnection, DbCompiledModel, bool) De verbinding moet worden afgeleid van de shard-toewijzing en de sleutel.The connection needs to be inferred from the shard map and the key. Het kan niet worden opgegeven als invoer (tenzij deze invoer is met behulp van de shard-toewijzing en de sleutel).It cannot be provided as an input (unless that input was using the shard map and the key). Het gecompileerde model wordt doorgegeven.The compiled model is passed on.
MyContext (ObjectContext, bool)MyContext(ObjectContext, bool) ElasticScaleContext(ShardMap, TKey, ObjectContext, bool)ElasticScaleContext(ShardMap, TKey, ObjectContext, bool) DbContext (ObjectContext, bool)DbContext(ObjectContext, bool) De nieuwe constructor nodig om ervoor te zorgen dat elke verbinding in de ObjectContext doorgegeven als invoer omgeleid naar een verbinding die wordt beheerd door elastisch schalen wordt.The new constructor needs to ensure that any connection in the ObjectContext passed as an input is re-routed to a connection managed by Elastic Scale. Een gedetailleerde bespreking van ObjectContexts valt buiten het bereik van dit document.A detailed discussion of ObjectContexts is beyond the scope of this document.
MyContext (DbConnection, DbCompiledModel, bool)MyContext(DbConnection, DbCompiledModel, bool) ElasticScaleContext(ShardMap, TKey, DbCompiledModel, bool)ElasticScaleContext(ShardMap, TKey, DbCompiledModel, bool) DbContext (DbConnection, DbCompiledModel, bool);DbContext(DbConnection, DbCompiledModel, bool); De verbinding moet worden afgeleid van de shard-toewijzing en de sleutel.The connection needs to be inferred from the shard map and the key. De verbinding kan niet worden opgegeven als invoer (tenzij deze invoer is al met behulp van de shard-toewijzing en de sleutel).The connection cannot be provided as an input (unless that input was already using the shard map and the key). Model en Booleaanse waarde zijn doorgegeven aan de constructor basisklasse.Model and Boolean are passed on to the base class constructor.

Shard-schema-implementatie via EF-migratiesShard schema deployment through EF migrations

Automatische Schemabeheer is voor uw gemak geleverd door de Entity Framework.Automatic schema management is a convenience provided by the Entity Framework. In de context van toepassingen die gebruikmaken van hulpprogramma's voor elastische databases, die u wilt bewaren deze mogelijkheid voor het automatisch inrichten van het schema naar de zojuist gemaakte shards wanneer databases worden toegevoegd aan de shard-toepassing.In the context of applications using elastic database tools, you want to retain this capability to automatically provision the schema to newly created shards when databases are added to the sharded application. De primaire use-case is om de capaciteit in de gegevenslaag voor shard-toepassingen met EF te vergroten.The primary use case is to increase capacity at the data tier for sharded applications using EF. Afhankelijk van de EF-mogelijkheden voor schemabeheer, vermindert u de database-beheer zonder veel moeite met een shard-toepassing die is gebouwd op EF.Relying on EF’s capabilities for schema management reduces the database administration effort with a sharded application built on EF.

Schema-implementatie via EF-migraties werkt het beste op nog niet gelezen verbindingen.Schema deployment through EF migrations works best on unopened connections. Dit is in tegenstelling tot het scenario voor het gegevensafhankelijke routering die is gebaseerd op de geopende verbinding geleverd door de databaseclient-API van elastic.This is in contrast to the scenario for data-dependent routing that relies on the opened connection provided by the elastic database client API. Een ander verschil is de vereiste consistentie: Tijdens het wenselijk om ervoor te zorgen consistent voor alle gegevensafhankelijke routering verbindingen om te beveiligen tegen gelijktijdige shard-kaart manipuleren, is het niet een probleem met de eerste schema-implementatie naar een nieuwe database die nog niet zijn geregistreerd in de shard-toewijzing en nog niet toegewezen shardlets kan bevatten.Another difference is the consistency requirement: While desirable to ensure consistency for all data-dependent routing connections to protect against concurrent shard map manipulation, it is not a concern with initial schema deployment to a new database that has not yet been registered in the shard map, and not yet been allocated to hold shardlets. Daarom kunt u vertrouwen op reguliere databaseverbindingen voor dit scenario, in plaats van gegevensafhankelijke routering.You can therefore rely on regular database connections for this scenario, as opposed to data-dependent routing.

Dit leidt tot een benadering waarbij schema-implementatie via EF-migraties is nauw gekoppeld aan de registratie van de nieuwe database als een shard in de shard-toewijzing van de toepassing.This leads to an approach where schema deployment through EF migrations is tightly coupled with the registration of the new database as a shard in the application’s shard map. Dit is afhankelijk van de volgende vereisten:This relies on the following prerequisites:

  • De database is al gemaakt.The database has already been created.
  • De database is leeg: deze bevat geen gebruikersschema en geen gebruikersgegevens.The database is empty - it holds no user schema and no user data.
  • De database kan niet nog worden geopend via de client-API's voor de elastische databases voor gegevensafhankelijke routering.The database cannot yet be accessed through the elastic database client APIs for data-dependent routing.

Met deze voorwaarden is voldaan, kunt u een regelmatige niet geopend SqlConnection naar een vliegende start EF-migraties voor distributie van het schema.With these prerequisites in place, you can create a regular un-opened SqlConnection to kick off EF migrations for schema deployment. Het volgende codevoorbeeld ziet u deze aanpak.The following code sample illustrates this approach.

// Enter a new shard - i.e. an empty database - to the shard map, allocate a first tenant to it  
// and kick off EF initialization of the database to deploy schema 

public void RegisterNewShard(string server, string database, string connStr, int key) 
{ 

    Shard shard = this.ShardMap.CreateShard(new ShardLocation(server, database)); 

    SqlConnectionStringBuilder connStrBldr = new SqlConnectionStringBuilder(connStr); 
    connStrBldr.DataSource = server; 
    connStrBldr.InitialCatalog = database; 

    // Go into a DbContext to trigger migrations and schema deployment for the new shard. 
    // This requires an un-opened connection. 
    using (var db = new ElasticScaleContext<int>(connStrBldr.ConnectionString)) 
    { 
        // Run a query to engage EF migrations 
        (from b in db.Blogs 
            select b).Count(); 
    } 

    // Register the mapping of the tenant to the shard in the shard map. 
    // After this step, data-dependent routing on the shard map can be used 

    this.ShardMap.CreatePointMapping(key, shard); 
} 

In dit voorbeeld toont de methode RegisterNewShard die de shard registreert in de shard-toewijzing, implementeert u het schema via EF-migraties en een toewijzing van een sharding-sleutel voor de shard wordt opgeslagen.This sample shows the method RegisterNewShard that registers the shard in the shard map, deploys the schema through EF migrations, and stores a mapping of a sharding key to the shard. Er wordt gebruikgemaakt van een constructor met de DbContext subklasse (ElasticScaleContext in het voorbeeld) waarmee een SQL-verbindingsreeks als invoer.It relies on a constructor of the DbContext subclass (ElasticScaleContext in the sample) that takes a SQL connection string as input. De code van deze constructor is eenvoudig, zoals in het volgende voorbeeld wordt weergegeven:The code of this constructor is straight-forward, as the following example shows:

// C'tor to deploy schema and migrations to a new shard 
protected internal ElasticScaleContext(string connectionString) 
    : base(SetInitializerForConnection(connectionString)) 
{ 
} 

// Only static methods are allowed in calls into base class c'tors 
private static string SetInitializerForConnection(string connectionString) 
{ 
    // You want existence checks so that the schema can get deployed 
    Database.SetInitializer<ElasticScaleContext<T>>( 
new CreateDatabaseIfNotExists<ElasticScaleContext<T>>()); 

    return connectionString; 
} 

Een mogelijk gebruikt de versie van de constructor overgenomen van de basisklasse.One might have used the version of the constructor inherited from the base class. Maar de code nodig om ervoor te zorgen dat de standaard-initialisatiefunctie voor EF wordt gebruikt wanneer verbinding wordt gemaakt.But the code needs to ensure that the default initializer for EF is used when connecting. De korte detour daarom in de statische methode voordat u aan de constructor basisklasse door de verbindingsreeks.Hence the short detour into the static method before calling into the base class constructor with the connection string. Houd er rekening mee dat de registratie van shards moet worden uitgevoerd in een ander toepassingsdomein of om ervoor te zorgen dat de initialisatiefunctie-instellingen voor EF geen conflict veroorzaken.Note that the registration of shards should run in a different app domain or process to ensure that the initializer settings for EF do not conflict.

BeperkingenLimitations

De methoden die worden beschreven in dit document leidt tot een aantal beperkingen:The approaches outlined in this document entail a couple of limitations:

  • EF-toepassingen die gebruikmaken van LocalDb moet u eerst om te migreren naar een normale SQL Server-database voordat u met behulp van de clientbibliotheek voor elastic database.EF applications that use LocalDb first need to migrate to a regular SQL Server database before using elastic database client library. Een toepassing via sharding uitbreiden met Elastic Scale is niet mogelijk is met LocalDb.Scaling out an application through sharding with Elastic Scale is not possible with LocalDb. Houd er rekening mee dat er nog steeds ontwikkeling kunt gebruiken LocalDb.Note that development can still use LocalDb.
  • Eventuele wijzigingen in de toepassing die schemawijzigingen database impliceren moeten gaan via EF-migraties op alle shards.Any changes to the application that imply database schema changes need to go through EF migrations on all shards. De voorbeeldcode voor dit document wordt niet laten zien hoe u dit doet.The sample code for this document does not demonstrate how to do this. Overweeg het gebruik van de Database bijwerken met een parameter ConnectionString om te herhalen alle shards; of ophalen van de T-SQL-script voor de in behandeling migratie met behulp van de Database bijwerken met een Script - optie en de T-SQL-script toepassen op uw shards.Consider using Update-Database with a ConnectionString parameter to iterate over all shards; or extract the T-SQL script for the pending migration using Update-Database with the -Script option and apply the T-SQL script to your shards.
  • Een aanvraag opgegeven, wordt ervan uitgegaan dat alle van de verwerking van de database zich in een enkele shard aangeduid met de sharding-sleutel die is opgegeven door de aanvraag.Given a request, it is assumed that all of its database processing is contained within a single shard as identified by the sharding key provided by the request. Echter deze aanname niet altijd over de waarde true.However, this assumption does not always hold true. Bijvoorbeeld, wanneer deze is niet mogelijk om een sharding-sleutel beschikbaar te maken.For example, when it is not possible to make a sharding key available. Om dit op te lossen, de clientbibliotheek biedt de MultiShardQuery klasse die een abstractie van de verbinding voor het uitvoeren van query's over verschillende shards.To address this, the client library provides the MultiShardQuery class that implements a connection abstraction for querying over several shards. Leren gebruiken de MultiShardQuery in combinatie met EF valt buiten het bereik van dit documentLearning to use the MultiShardQuery in combination with EF is beyond the scope of this document

ConclusieConclusion

Via de stappen die worden beschreven in dit document, EF-toepassingen de mogelijkheid de elastische database-clientbibliotheek kunnen gebruiken voor het gegevensafhankelijke routering door herstructurering constructors van de DbContext subklassen gebruikt in de EF-toepassing.Through the steps outlined in this document, EF applications can use the elastic database client library's capability for data-dependent routing by refactoring constructors of the DbContext subclasses used in the EF application. Dit beperkt de wijzigingen die zijn vereist voor deze locaties waar DbContext klassen bestaan al.This limits the changes required to those places where DbContext classes already exist. Bovendien kunnen EF-toepassingen blijven profiteren van het schema voor automatische implementatie door een combinatie van de stappen waarmee u de benodigde EF-migraties met de registratie van de nieuwe shards en toewijzingen in de shard-toewijzing kunt aanroepen.In addition, EF applications can continue to benefit from automatic schema deployment by combining the steps that invoke the necessary EF migrations with the registration of new shards and mappings in the shard map.

Aanvullende resourcesAdditional resources

Geen gebruik van hulpmiddelen voor elastic database nog?Not using elastic database tools yet? Bekijk onze Getting Started Guide.Check out our Getting Started Guide. U vragen hebt, neemt u contact met ons op de forum van SQL-Database en voor functieaanvragen, deze toe te voegen aan de forum met feedback van SQL-Database.For questions, please reach out to us on the SQL Database forum and for feature requests, please add them to the SQL Database feedback forum.