Kom igång med tabell-API för Azure Cosmos DB och Azure Table Storage med .NET SDKGet started with Azure Cosmos DB Table API and Azure Table storage using the .NET SDK

GÄLLER för: tabell-API

Tips

Innehållet i den här artikeln gäller för Azure-tabellagring och Azure Cosmos DB tabell-API.The content in this article applies to Azure Table storage and the Azure Cosmos DB Table API. Azure Cosmos DB tabell-API är en förhandsversion av en premiumprodukt för tabellagring som erbjuder tabeller för optimerat dataflöde, global distribution och automatiska sekundära index.The Azure Cosmos DB Table API is a premium offering for table storage that offers throughput-optimized tables, global distribution, and automatic secondary indexes.

Du kan använda Azure Cosmos DB Tabell-API eller Azure Table Storage för att lagra strukturerade NoSQL-data i molnet, vilket ger ett Arkiv för nyckel/attribut med ett schema som är mindre design.You can use the Azure Cosmos DB Table API or Azure Table storage to store structured NoSQL data in the cloud, providing a key/attribute store with a schema less design. Eftersom Azure Cosmos DB Tabell-API-och table-lagring är ett schema som är mindre, är det enkelt att anpassa dina data när dina program behöver utvecklas.Because Azure Cosmos DB Table API and Table storage are schema less, it's easy to adapt your data as the needs of your application evolve. Du kan använda Azure Cosmos DB Tabell-API eller tabell lagringen för att lagra flexibla data uppsättningar, till exempel användar data för webb program, adress böcker, enhets information eller andra typer av metadata som din tjänst kräver.You can use Azure Cosmos DB Table API or the Table storage to store flexible datasets such as user data for web applications, address books, device information, or other types of metadata your service requires.

I den här självstudien beskrivs ett exempel som visar hur du använder Microsoft Azure Cosmos DB tabell bibliotek för .net med Azure Cosmos DB tabell-API och Azure Table Storage-scenarier.This tutorial describes a sample that shows you how to use the Microsoft Azure Cosmos DB Table Library for .NET with Azure Cosmos DB Table API and Azure Table storage scenarios. Du måste använda den anslutning som är speciell för Azure-tjänsten.You must use the connection specific to the Azure service. De här scenarierna är bekanta med C#-exempel som illustrerar hur du skapar tabeller, infogar/uppdaterar data, frågedata och tar bort tabeller.These scenarios are explored using C# examples that illustrate how to create tables, insert/ update data, query data and delete the tables.

KravPrerequisites

Du behöver följande för att kunna följa med i det här exemplet:You need the following to complete this sample successfully:

Skapa ett Azure Cosmos DB Table API-kontoCreate an Azure Cosmos DB Table API account

  1. Logga in på Azure Portal i ett nytt webbläsarfönster.In a new browser window, sign in to the Azure portal.

  2. Välj skapa en resurs i den vänstra menyn.In the left menu, select Create a resource.

    Skapa en resurs på Azure-portalen

  3. Välj databaser Azure Cosmos DB på sidan nytt > Azure Cosmos DB.On the New page, select Databases > Azure Cosmos DB.

    Fönstret Databaser på Azure Portal

  4. På sidan skapa Azure Cosmos DB konto anger du inställningarna för det nya Azure Cosmos DB-kontot.On the Create Azure Cosmos DB Account page, enter the settings for the new Azure Cosmos DB account.

    InställningSetting VärdeValue BeskrivningDescription
    PrenumerationSubscription Din prenumerationYour subscription Välj den Azure-prenumeration som ska användas för det här Azure Cosmos DB-kontot.Select the Azure subscription that you want to use for this Azure Cosmos DB account.
    ResursgruppResource Group Skapa nytt och sedan konto namnCreate new , then Account Name Välj Skapa ny.Select Create new. Ange sedan ett nytt resurs grupps namn för ditt konto.Then enter a new resource group name for your account. För enkelhetens skull använder du samma namn som ditt Azure Cosmos DB konto namn.For simplicity, use the same name as your Azure Cosmos DB account name.
    Account NameAccount Name Ett unikt namnA unique name Ange ett unikt namn som identifierar ditt Azure Cosmos DB-konto.Enter a unique name to identify your Azure Cosmos DB account.

    Konto namnet får bara innehålla gemena bokstäver, siffror och bindestreck (-) och måste vara mellan 3 och 31 tecken långt.The account name can use only lowercase letters, numbers, and hyphens (-), and must be between 3 and 31 characters long.
    APIAPI TabellerTable API:et avgör vilken typ av konto som skapas.The API determines the type of account to create. Azure Cosmos DB tillhandahåller fem API: er: Core (SQL) för dokument databaser, Gremlin för graf-databaser, MongoDB för dokument databaser, Azure Table och Cassandra.Azure Cosmos DB provides five APIs: Core (SQL) for document databases, Gremlin for graph databases, MongoDB for document databases, Azure Table, and Cassandra. Du måste skapa ett separat konto för varje API.You must create a separate account for each API.

    Välj Azure-tabell , eftersom du i den här snabb starten skapar en tabell som fungerar med tabell-API.Select Azure Table , because in this quickstart you are creating a table that works with the Table API.

    Läs mer om tabell-API.Learn more about the Table API.
    PlatsLocation Den region som är närmast dina användareThe region closest to your users Välj en geografisk plats som värd för ditt Azure Cosmos DB-konto.Select a geographic location to host your Azure Cosmos DB account. Använd den plats som är närmast dina användare så att de får så snabb åtkomst till data som möjligt.Use the location that's closest to your users to give them the fastest access to the data.
    KapacitetslägeCapacity mode Allokerat data flöde eller Server lösProvisioned throughput or Serverless Välj tillhandahållet data flöde för att skapa ett konto i ett allokerat data flödes läge.Select Provisioned throughput to create an account in provisioned throughput mode. Välj Server lös om du vill skapa ett konto i Server fritt läge.Select Serverless to create an account in serverless mode.

    Du kan lämna alternativen GEO-redundans och flera regioner vid inaktive ring för att undvika ytterligare kostnader och hoppa över avsnitten nätverk och taggar .You can leave the Geo-Redundancy and Multi-region Writes options at Disable to avoid additional charges, and skip the Network and Tags sections.

  5. Välj Granska + skapa.Select Review+Create. När verifieringen är klar väljer du skapa för att skapa kontot.After the validation is complete, select Create to create the account.

    Den nya kontosidan för Azure Cosmos DB

  6. Det tar några minuter att skapa kontot.It takes a few minutes to create the account. Ett meddelande visas som anger att distributionen pågår.You'll see a message that states Your deployment is underway. Vänta tills distributionen är klar och välj sedan gå till resurs.Wait for the deployment to finish, and then select Go to resource.

    Fönstret Azure Portal meddelanden

Skapa ett .NET-konsol projektCreate a .NET console project

Skapa ett nytt .NET-konsol program i Visual Studio.In Visual Studio, create a new .NET console application. Följande steg visar hur du skapar ett konsol program i Visual Studio 2019.The following steps show you how to create a console application in Visual Studio 2019. Du kan använda Azure Cosmos DB tabell bibliotek i vilken typ av .NET-program som helst, inklusive en Azure-moln tjänst eller webbapp, samt Skriv bords-och mobil program.You can use the Azure Cosmos DB Table Library in any type of .NET application, including an Azure cloud service or web app, and desktop and mobile applications. I den här guiden använder vi oss av en konsolapp för enkelhetens skull.In this guide, we use a console application for simplicity.

  1. Välj Arkiv > nytt > projekt.Select File > New > Project.

  2. Välj konsol program (.net Core) och välj sedan Nästa.Choose Console App (.NET Core), and then select Next.

  3. I fältet projekt namn anger du ett namn för ditt program, till exempel CosmosTableSamples.In the Project name field, enter a name for your application, such as CosmosTableSamples. (Du kan ange ett annat namn efter behov.)(You can provide a different name as needed.)

  4. Välj Skapa.Select Create.

Alla kod exempel i det här exemplet kan läggas till i Main ()-metoden i konsol programmets program.cs -fil.All code examples in this sample can be added to the Main() method of your console application's Program.cs file.

Installera det nödvändiga NuGet-paketetInstall the required NuGet package

Följ dessa steg för att hämta NuGet-paketet:To obtain the NuGet package, follow these steps:

  1. Högerklicka på ditt projekt i Solution Explorer och välj Hantera NuGet-paket.Right-click your project in Solution Explorer and choose Manage NuGet Packages.

  2. Sök online efter Microsoft.Azure.Cosmos.Table , Microsoft.Extensions.Configuration , Microsoft.Extensions.Configuration.Json Microsoft.Extensions.Configuration.Binder och välj Installera för att installera Microsoft Azure Cosmos DB tabell bibliotek.Search online for Microsoft.Azure.Cosmos.Table, Microsoft.Extensions.Configuration, Microsoft.Extensions.Configuration.Json, Microsoft.Extensions.Configuration.Binder and select Install to install the Microsoft Azure Cosmos DB Table Library.

Konfigurera anslutningssträngen för lagringConfigure your storage connection string

  1. Från Azure Portalnavigerar du till ditt Azure Cosmos-konto eller Table Storage-kontot.From the Azure portal, navigate to your Azure Cosmos account or the Table Storage account.

  2. Öppna fönstret anslutnings sträng eller åtkomst nycklar .Open the Connection String or Access keys pane. Använd knapparna på höger sida av fönstret för att kopiera PRIMÄR ANSLUTNINGSSTRÄNG.Use the copy button on the right side of the window to copy the PRIMARY CONNECTION STRING.

    Visa och kopiera PRIMÄR ANSLUTNINGSSTRÄNG i fönstret Anslutningssträng

  3. Om du vill konfigurera anslutnings strängen från Visual Studio högerklickar du på projektet CosmosTableSamples.To configure your connection string, from visual studio right click on your project CosmosTableSamples.

  4. Välj Lägg till och sedan nytt objekt.Select Add and then New Item. Skapa en ny fil Settings.jspå med filtypen typescript JSON-konfigurationsfil .Create a new file Settings.json with file type as TypeScript JSON Configuration File.

  5. Ersätt koden i Settings.jspå filen med följande kod och tilldela din primära anslutnings sträng:Replace the code in Settings.json file with the following code and assign your primary connection string:

    {
    "StorageConnectionString": <Primary connection string of your Azure Cosmos DB account>
    }
    
  6. Högerklicka på din Project- CosmosTableSamples.Right click on your project CosmosTableSamples. Välj Lägg till, nytt objekt och Lägg till en klass med namnet appSettings.cs.Select Add, New Item and add a class named AppSettings.cs.

  7. Lägg till följande kod i AppSettings.cs-filen.Add the following code to the AppSettings.cs file. Den här filen läser anslutnings strängen från Settings.jspå filen och tilldelar den till konfigurations parametern:This file reads the connection string from Settings.json file and assigns it to the configuration parameter:

namespace CosmosTableSamples
{
    using Microsoft.Extensions.Configuration;

    public class AppSettings
    {
        public string StorageConnectionString { get; set; }

        public static AppSettings LoadAppSettings()
        {
            IConfigurationRoot configRoot = new ConfigurationBuilder()
                .AddJsonFile("Settings.json")
                .Build();
            AppSettings appSettings = configRoot.Get<AppSettings>();
            return appSettings;
        }
    }
}

Analysera och verifiera anslutnings informationenParse and validate the connection details

  1. Högerklicka på din Project- CosmosTableSamples.Right click on your project CosmosTableSamples. Välj Lägg till, nytt objekt och Lägg till en klass med namnet common.cs.Select Add, New Item and add a class named Common.cs. Du kommer att skriva kod för att verifiera anslutnings informationen och skapa en tabell i den här klassen.You will write code to validate the connection details and create a table within this class.

  2. Definiera en metod CreateStorageAccountFromConnectionString som visas nedan.Define a method CreateStorageAccountFromConnectionString as shown below. Med den här metoden tolkas anslutnings Strängs informationen och du kan kontrol lera att konto namnet och konto nyckel informationen i filen "Settings.jspå" är giltig.This method will parse the connection string details and validate that the account name and account key details provided in the "Settings.json" file are valid.

    using System;
    
    namespace CosmosTableSamples
    {
        using System.Threading.Tasks;
        using Microsoft.Azure.Cosmos.Table;
        using Microsoft.Azure.Documents;
    
        public class Common
        {
            public static CloudStorageAccount CreateStorageAccountFromConnectionString(string storageConnectionString)
            {
                CloudStorageAccount storageAccount;
                try
                {
                    storageAccount = CloudStorageAccount.Parse(storageConnectionString);
                }
                catch (FormatException)
                {
                    Console.WriteLine("Invalid storage account information provided. Please confirm the AccountName and AccountKey are valid in the app.config file - then restart the application.");
                    throw;
                }
                catch (ArgumentException)
                {
                    Console.WriteLine("Invalid storage account information provided. Please confirm the AccountName and AccountKey are valid in the app.config file - then restart the sample.");
                    Console.ReadLine();
                    throw;
                }
    
                return storageAccount;
            }
    

Skapa en tabellCreate a Table

Med klassen CloudTableClient kan du hämta tabeller och de entiteter som lagras i Table Storage.The CloudTableClient class enables you to retrieve tables and entities stored in Table storage. Eftersom vi inte har några tabeller i Cosmos DB Tabell-API-kontot ska vi lägga till CreateTableAsync metoden i klassen common.cs för att skapa en tabell:Because we don’t have any tables in the Cosmos DB Table API account, let’s add the CreateTableAsync method to the Common.cs class to create a table:

public static async Task<CloudTable> CreateTableAsync(string tableName)
{
    string storageConnectionString = AppSettings.LoadAppSettings().StorageConnectionString;

    // Retrieve storage account information from connection string.
    CloudStorageAccount storageAccount = CreateStorageAccountFromConnectionString(storageConnectionString);

    // Create a table client for interacting with the table service
    CloudTableClient tableClient = storageAccount.CreateCloudTableClient(new TableClientConfiguration());

    Console.WriteLine("Create a Table for the demo");

    // Create a table client for interacting with the table service 
    CloudTable table = tableClient.GetTableReference(tableName);
    if (await table.CreateIfNotExistsAsync())
    {
        Console.WriteLine("Created Table named: {0}", tableName);
    }
    else
    {
        Console.WriteLine("Table {0} already exists", tableName);
    }

    Console.WriteLine();
    return table;
}

Om du får fel meddelandet "503 Service Unavailable Exception" är det möjligt att de portar som krävs för anslutnings läget blockeras av en brand vägg.If you get a "503 service unavailable exception" error, it's possible that the required ports for the connectivity mode are blocked by a firewall. Du kan åtgärda det här problemet genom att antingen öppna de portar som krävs eller använda anslutnings tjänsten för gateway-läge som visas i följande kod:To fix this issue, either open the required ports or use the gateway mode connectivity as shown in the following code:

tableClient.TableClientConfiguration.UseRestExecutorForCosmosEndpoint = true;

Definiera entitetenDefine the entity

Entiteter mappar till C#-objekt med hjälp av en anpassad klass som härletts från TableEntity.Entities map to C# objects by using a custom class derived from TableEntity. Om du vill lägga till en entitet i en tabell skapar du en klass som definierar egenskaperna för entiteten.To add an entity to a table, create a class that defines the properties of your entity.

Högerklicka på din Project- CosmosTableSamples.Right click on your project CosmosTableSamples. Välj Lägg till, ny mapp och ge den namnet som modell.Select Add, New Folder and name it as Model. I mappen modell lägger du till en klass med namnet CustomerEntity.cs och lägger till följande kod i den.Within the Model folder add a class named CustomerEntity.cs and add the following code to it.

namespace CosmosTableSamples.Model
{
    using Microsoft.Azure.Cosmos.Table;

    public class CustomerEntity : TableEntity
    {
        public CustomerEntity()
        {
        }

        public CustomerEntity(string lastName, string firstName)
        {
            PartitionKey = lastName;
            RowKey = firstName;
        }

        public string Email { get; set; }

        public string PhoneNumber { get; set; }
    }
}

Den här koden definierar en entitets klass som använder kundens förnamn som rad nyckel och efter namn som partitionsnyckel.This code defines an entity class that uses the customer's first name as the row key and last name as the partition key. Tillsammans identifierar en entitets partition och radnyckel den unikt i tabellen.Together, an entity's partition and row key uniquely identify it in the table. Entiteter med samma partitionsnyckel kan efter frågas snabbare än entiteter med olika partitionsnyckel, men med hjälp av olika partitionstyper kan du få bättre skalbarhet för parallella åtgärder.Entities with the same partition key can be queried faster than entities with different partition keys but using diverse partition keys allows for greater scalability of parallel operations. Enheter som ska lagras i tabeller måste ha en typ som stöds, till exempel härledda från klassen TableEntity.Entities to be stored in tables must be of a supported type, for example derived from the TableEntity class. Entitetsegenskaper som du vill lagra i en tabell måste vara offentliga egenskaper av den typen och ha stöd för att både hämta och ange värden.Entity properties you'd like to store in a table must be public properties of the type, and support both getting and setting of values. Dessutom måste entitetstypen exponera en parameterlös konstruktor.Also, your entity type must expose a parameter-less constructor.

Infoga eller sammanfoga en entitetInsert or merge an entity

Följande kod exempel skapar ett entitet-objekt och lägger till det i tabellen.The following code example creates an entity object and adds it to the table. Metoden InsertOrMerge i klassen TableOperation används för att infoga eller slå samman en entitet.The InsertOrMerge method within the TableOperation class is used to insert or merge an entity. Metoden CloudTable.ExecuteAsync anropas för att utföra åtgärden.The CloudTable.ExecuteAsync method is called to execute the operation.

Högerklicka på din Project- CosmosTableSamples.Right click on your project CosmosTableSamples. Välj Lägg till, nytt objekt och Lägg till en klass med namnet SamplesUtils.cs.Select Add, New Item and add a class named SamplesUtils.cs. Den här klassen lagrar all kod som krävs för att utföra CRUD-åtgärder på entiteterna.This class stores all the code required to perform CRUD operations on the entities.

public static async Task<CustomerEntity> InsertOrMergeEntityAsync(CloudTable table, CustomerEntity entity)
{
    if (entity == null)
    {
        throw new ArgumentNullException("entity");
    }

    try
    {
        // Create the InsertOrReplace table operation
        TableOperation insertOrMergeOperation = TableOperation.InsertOrMerge(entity);

        // Execute the operation.
        TableResult result = await table.ExecuteAsync(insertOrMergeOperation);
        CustomerEntity insertedCustomer = result.Result as CustomerEntity;

        if (result.RequestCharge.HasValue)
        {
            Console.WriteLine("Request Charge of InsertOrMerge Operation: " + result.RequestCharge);
        }

        return insertedCustomer;
    }
    catch (StorageException e)
    {
        Console.WriteLine(e.Message);
        Console.ReadLine();
        throw;
    }
}

Hämta en entitet från en partitionGet an entity from a partition

Du kan hämta entiteten från en partition med hjälp av metoden GET under klassen TableOperation .You can get entity from a partition by using the Retrieve method under the TableOperation class. I följande kod exempel hämtas rad nyckel, e-postadress och telefonnummer för en kundentitet.The following code example gets the partition key row key, email and phone number of a customer entity. I det här exemplet skrivs även de enheter för programbegäran som används för att fråga efter entiteten.This example also prints out the request units consumed to query for the entity. Om du vill fråga efter en entitet lägger du till följande kod i SamplesUtils.cs -filen:To query for an entity, append the following code to SamplesUtils.cs file:

public static async Task<CustomerEntity> RetrieveEntityUsingPointQueryAsync(CloudTable table, string partitionKey, string rowKey)
{
    try
    {
        TableOperation retrieveOperation = TableOperation.Retrieve<CustomerEntity>(partitionKey, rowKey);
        TableResult result = await table.ExecuteAsync(retrieveOperation);
        CustomerEntity customer = result.Result as CustomerEntity;
        if (customer != null)
        {
            Console.WriteLine("\t{0}\t{1}\t{2}\t{3}", customer.PartitionKey, customer.RowKey, customer.Email, customer.PhoneNumber);
        }

        if (result.RequestCharge.HasValue)
        {
            Console.WriteLine("Request Charge of Retrieve Operation: " + result.RequestCharge);
        }

        return customer;
    }
    catch (StorageException e)
    {
        Console.WriteLine(e.Message);
        Console.ReadLine();
        throw;
    }
}

Ta bort en entitetDelete an entity

Du kan enkelt ta bort en enhet när du har hämtat den genom att använda samma mönster som när du uppdaterar en entitet.You can easily delete an entity after you have retrieved it by using the same pattern shown for updating an entity. Följande kod hämtar och tar bort en kundentitet.The following code retrieves and deletes a customer entity. Om du vill ta bort en entitet lägger du till följande kod i SamplesUtils.cs -filen:To delete an entity, append the following code to SamplesUtils.cs file:

public static async Task DeleteEntityAsync(CloudTable table, CustomerEntity deleteEntity)
{
    try
    {
        if (deleteEntity == null)
        {
            throw new ArgumentNullException("deleteEntity");
        }

        TableOperation deleteOperation = TableOperation.Delete(deleteEntity);
        TableResult result = await table.ExecuteAsync(deleteOperation);

        if (result.RequestCharge.HasValue)
        {
            Console.WriteLine("Request Charge of Delete Operation: " + result.RequestCharge);
        }

    }
    catch (StorageException e)
    {
        Console.WriteLine(e.Message);
        Console.ReadLine();
        throw;
    }
}

Kör CRUD-åtgärder på exempel dataExecute the CRUD operations on sample data

När du har definierat metoder för att skapa tabeller, infoga eller sammanfoga entiteter kör du dessa metoder i exempel data.After you define the methods to create table, insert or merge entities, run these methods on the sample data. Det gör du genom att högerklicka på projektet CosmosTableSamples.To do so, right click on your project CosmosTableSamples. Välj Lägg till, nytt objekt och Lägg till en klass med namnet BasicSamples.cs och Lägg till följande kod till den.Select Add, New Item and add a class named BasicSamples.cs and add the following code to it. Den här koden skapar en tabell, lägger till entiteter i den.This code creates a table, adds entities to it.

Om du inte vill ta bort entiteten och tabellen i slutet av projektet, kommenterar du await table.DeleteIfExistsAsync() SamplesUtils.DeleteEntityAsync(table, customer) metoderna och från följande kod.If don't want to delete the entity and table at the end of the project, comment the await table.DeleteIfExistsAsync() and SamplesUtils.DeleteEntityAsync(table, customer) methods from the following code. Det är bäst att kommentera ut dessa metoder och verifiera data innan du tar bort tabellen.It's best to comment out these methods and validate the data before you delete the table.

using System;

namespace CosmosTableSamples
{
    using System.Threading.Tasks;
    using Microsoft.Azure.Cosmos.Table;
    using Model;

    class BasicSamples
    {
        public async Task RunSamples()
        {
            Console.WriteLine("Azure Cosmos DB Table - Basic Samples\n");
            Console.WriteLine();

            string tableName = "demo" + Guid.NewGuid().ToString().Substring(0, 5);

            // Create or reference an existing table
            CloudTable table = await Common.CreateTableAsync(tableName);

            try
            {
                // Demonstrate basic CRUD functionality 
                await BasicDataOperationsAsync(table);
            }
            finally
            {
                // Delete the table
                await table.DeleteIfExistsAsync();
            }
        }

        private static async Task BasicDataOperationsAsync(CloudTable table)
        {
            // Create an instance of a customer entity. See the Model\CustomerEntity.cs for a description of the entity.
            CustomerEntity customer = new CustomerEntity("Harp", "Walter")
            {
                Email = "Walter@contoso.com",
                PhoneNumber = "425-555-0101"
            };

            // Demonstrate how to insert the entity
            Console.WriteLine("Insert an Entity.");
            customer = await SamplesUtils.InsertOrMergeEntityAsync(table, customer);

            // Demonstrate how to Update the entity by changing the phone number
            Console.WriteLine("Update an existing Entity using the InsertOrMerge Upsert Operation.");
            customer.PhoneNumber = "425-555-0105";
            await SamplesUtils.InsertOrMergeEntityAsync(table, customer);
            Console.WriteLine();

            // Demonstrate how to Read the updated entity using a point query 
            Console.WriteLine("Reading the updated Entity.");
            customer = await SamplesUtils.RetrieveEntityUsingPointQueryAsync(table, "Harp", "Walter");
            Console.WriteLine();

            // Demonstrate how to Delete an entity
            Console.WriteLine("Delete the entity. ");
            await SamplesUtils.DeleteEntityAsync(table, customer);
            Console.WriteLine();
        }
    }
}

Föregående kod skapar en tabell som börjar med "demo" och det genererade GUID: t läggs till i tabell namnet.The previous code creates a table that starts with “demo” and the generated GUID is appended to the table name. Sedan läggs en kundentitet med för-och efter namn till "Harp Walter" och senare uppdateras telefonnumret för den här användaren.It then adds a customer entity with first and last name as “Harp Walter” and later updates the phone number of this user.

I den här självstudien har du skapat kod för att utföra grundläggande CRUD-åtgärder på de data som lagras i Tabell-API-kontot.In this tutorial, you built code to perform basic CRUD operations on the data stored in Table API account. Du kan också utföra avancerade åtgärder, till exempel – batch infoga data, fråga alla data i en partition, fråga efter data intervall i en partition, listar tabeller i kontot vars namn börjar med det angivna prefixet.You can also perform advanced operations such as – batch inserting data, query all the data within a partition, query a range of data within a partition, Lists tables in the account whose names begin with the specified prefix. Du kan hämta det fullständiga exempel formuläret Azure-Cosmos-Table-dotNet-Core-komma igång-GitHub- lagringsplats.You can download the complete sample form azure-cosmos-table-dotnet-core-getting-started GitHub repository. AdvancedSamples.cs -klassen har fler åtgärder som du kan utföra på data.The AdvancedSamples.cs class has more operations that you can perform on the data.

Kör projektetRun the project

Från din Project- CosmosTableSamples.From your project CosmosTableSamples. Öppna klassen med namnet program.cs och Lägg till följande kod i den för att anropa BasicSamples när projektet körs.Open the class named Program.cs and add the following code to it for calling BasicSamples when the project runs.

using System;

namespace CosmosTableSamples
{
    class Program
    {
        public static void Main(string[] args)
        {
            Console.WriteLine("Azure Cosmos Table Samples");
            BasicSamples basicSamples = new BasicSamples();
            basicSamples.RunSamples().Wait();

            AdvancedSamples advancedSamples = new AdvancedSamples();
            advancedSamples.RunSamples().Wait();

            Console.WriteLine();
            Console.WriteLine("Press any key to exit");
            Console.Read();
        }
    }
}

Nu ska du skapa lösningen och trycka på F5 för att köra projektet.Now build the solution and press F5 to run the project. När projektet körs visas följande utdata i kommando tolken:When the project is run, you will see the following output in the command prompt:

Utdata från kommando tolken

Om du får ett fel meddelande om att det inte går att hitta Settings.jspå filen när du kör projektet kan du lösa det genom att lägga till följande XML-post i projekt inställningarna.If you receive an error that says Settings.json file can’t be found when running the project, you can resolve it by adding the following XML entry to the project settings. Högerklicka på CosmosTableSamples, Välj Redigera CosmosTableSamples. CSPROJ och Lägg till följande itemGroup:Right click on CosmosTableSamples, select Edit CosmosTableSamples.csproj and add the following itemGroup:

  <ItemGroup>
    <None Update="Settings.json">
      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
    </None>
  </ItemGroup>

Nu kan du logga in på Azure Portal och kontrol lera att data finns i tabellen.Now you can sign into the Azure portal and verify that the data exists in the table.

Resultat i portalen

Nästa stegNext steps

Nu kan du fortsätta till nästa självstudie och lära dig hur du migrerar data till Azure Cosmos DB Tabell-API-kontot.You can now proceed to the next tutorial and learn how to migrate data to Azure Cosmos DB Table API account.