Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# .NET und DAX
<a name="DAX.client.run-application-dotnet"></a>

Gehen Sie wie folgt vor, um das .NET-Beispiel auf Ihrer Amazon-EC2-Instance auszuführen.

**Anmerkung**  
In diesem Tutorial wird das.NET 9 SDK verwendet. Sie zeigt, wie Sie ein Programm in der Standard-Amazon VPC ausführen können, um auf den Amazon-DynamoDB-Accelerator-(DAX)-Cluster zuzugreifen. Es funktioniert mit dem [AWS SDK v4 für .NET](https://docs.aws.amazon.com/sdk-for-net/v4/developer-guide/welcome.html). Einzelheiten zu Änderungen in V4 und Informationen zur Migration finden Sie unter [Migration auf Version 4 des AWS SDK for .NET](https://docs.aws.amazon.com/sdk-for-net/v4/developer-guide/net-dg-v4.html). Wenn Sie möchten, können Sie die verwenden, AWS Toolkit for Visual Studio um eine.NET-Anwendung zu schreiben und sie in Ihrer VPC bereitzustellen.  
Weitere Informationen finden Sie unter [Erstellen und Bereitstellen von Elastic-Beanstalk-Anwendungen in .NET mit AWS -Toolkit for Visual Studio](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/create_deploy_NET.html) im *AWS Elastic Beanstalk -Entwicklerhandbuch*.

**So führen Sie das .NET-Beispiel für DAX aus**

1. Gehen Sie zur [Microsoft-Downloadseite](https://www.microsoft.com/net/download?initial-os=linux) und laden Sie das neueste.NET 9-SDK für Linux herunter. Der Name der heruntergeladenen Datei lautet `dotnet-sdk-N.N.N-linux-x64.tar.gz`.

1. Extrahieren Sie die SDK-Dateien.

   ```
   mkdir dotnet
   tar zxvf dotnet-sdk-N.N.N-linux-x64.tar.gz -C dotnet
   ```

   Ersetzen Sie `N.N.N` durch die tatsächliche Versionsnummer des .NET SDK (z. B.: `9.0.305`).

1. Überprüfen Sie die Installation.

   ```
   alias dotnet=$HOME/dotnet/dotnet
   dotnet --version
   ```

   Damit sollte die Versionsnummer des .NET SDK ausgegeben werden.
**Anmerkung**  
Statt der Versionsnummer erhalten Sie möglicherweise die folgende Fehlermeldung:  
error: libunwind.so.8: cannot open shared object file: No such file or directory (Fehler: libunwind.so.8: Die freigegebene Datei kann nicht geöffnet werden: Datei oder Verzeichnis nicht vorhanden)  
Um den Fehler zu beheben, installieren Sie das `libunwind`-Paket.  

   ```
   sudo yum install -y libunwind
   ```
Anschließend sollte es möglich sein, den `dotnet --version`-Befehl fehlerfrei auszuführen.

1. Erstellen Sie ein neues .NET-Projekt.

   ```
   dotnet new console -o myApp 
   ```

   Dies dauert einige Minuten, um ein one-time-only Setup durchzuführen. Nachdem sie fertig ist, führen Sie das Beispielprojekt aus.

   ```
   dotnet run --project myApp
   ```

   Sie sollten die folgende Meldung erhalten: `Hello World!`

1. Die Datei `myApp/myApp.csproj` enthält Metadaten über Ihr Projekt. Um den DAX-Client in Ihrer Anwendung nutzen zu können, ändern Sie die Datei, sodass sie wie folgt aussieht.

   ```
   <Project Sdk="Microsoft.NET.Sdk">
       <PropertyGroup>
           <OutputType>Exe</OutputType>
           <TargetFramework>net9.0</TargetFramework>
       </PropertyGroup>
       <ItemGroup>
           <PackageReference Include="AWSSDK.DAX.Client" Version="*" />
       </ItemGroup>
   </Project>
   ```

1. Downloaden Sie den Quellcode des Beispielprogramms (`.zip`-Datei):

   ```
   wget http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/samples/TryDax.zip
   ```

   Wenn der Download abgeschlossen ist, extrahieren Sie die Quelldateien.

   ```
   unzip TryDax.zip
   ```

1. Führen Sie nun nacheinander die Beispielprogramme von *DotNet* aus. Kopieren Sie für jedes Programm seinen Inhalt in die Datei `myApp/Program.cs` und führen Sie dann das `MyApp`-Projekt aus.

   Führen Sie die folgenden .NET-Programme aus. Das erste Programm erstellt eine DynamoDB-Tabelle mit dem Namen `TryDaxTable`. Das zweite Programm schreibt Daten in die Tabelle.

   ```
   cp TryDax/dotNet/01-CreateTable.cs myApp/Program.cs
   dotnet run --project myApp
   
   cp TryDax/dotNet/02-Write-Data.cs myApp/Program.cs
   dotnet run --project myApp
   ```

1. Führen Sie jetzt einige Programme zur Durchführung von `GetItem`-, `Query`- und `Scan`-Operationen auf dem DAX-Cluster aus. Um den Endpunkt für Ihren DAX-Cluster zu bestimmen, wählen Sie einen der folgenden Schritte aus:
   +  **Using the DynamoDB console** (Verwenden der DynamoDB-Konsole) — Wählen Sie Ihren DAX-Cluster aus. Der Cluster-Endpunkt wird auf der Konsole angezeigt, wie im folgenden Beispiel gezeigt.

     ```
     dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com
     ```
   + **Verwenden Sie den AWS CLI** — Geben Sie den folgenden Befehl ein.

     ```
     aws dax describe-clusters --query "Clusters[*].ClusterDiscoveryEndpoint"
     ```

     Der Clusterendpunkt wird wie im folgenden Beispiel in der Ausgabe angezeigt.

     ```
     {
         "Address": "my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com",
         "Port": 8111,
         "URL": "dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com"
     }
     ```

   Führen Sie jetzt die folgenden Programme aus und geben Sie den Cluster-Endpunkt als Befehlszeilenparameter an. (Ersetzen Sie den Beispiel-Endpunkt durch den tatsächlichen DAX-Cluster-Endpunkt.)

   ```
   cp TryDax/dotNet/03-GetItem-Test.cs myApp/Program.cs
   dotnet run --project myApp dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com
   
   cp TryDax/dotNet/04-Query-Test.cs myApp/Program.cs
   dotnet run --project myApp dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com
                           
   cp TryDax/dotNet/05-Scan-Test.cs myApp/Program.cs
   dotnet run --project myApp dax://my-cluster.l6fzcv.dax-clusters.us-east-1.amazonaws.com
   ```

   Beachten Sie die Zeitinformationen – die Anzahl der benötigten Millisekunden für den `GetItem`-, `Query`- und `Scan`-Test.

1. Führen Sie das folgende .NET-Programm aus, um `TryDaxTable` zu löschen.

   ```
   cp TryDax/dotNet/06-DeleteTable.cs myApp/Program.cs
   dotnet run --project myApp
   ```

Weitere Informationen zu diesen Programmen finden Sie in folgenden Abschnitten:
+ [0-1 CreateTable .cs](DAX.client.run-application-dotnet.01-CreateTable.md)
+ [02-Write-Data.cs](DAX.client.run-application-dotnet.02-Write-Data.md)
+ [03- -Test.cs GetItem](DAX.client.run-application-dotnet.03-GetItem-Test.md)
+ [04-Query-Test.cs](DAX.client.run-application-dotnet.04-Query-Test.md)
+ [05-Scan-Test.cs](DAX.client.run-application-dotnet.05-Scan-Test.md)
+ [0-6. DeleteTable cs](DAX.client.run-application-dotnet.06-DeleteTable.md)

# 0-1 CreateTable .cs
<a name="DAX.client.run-application-dotnet.01-CreateTable"></a>

Das Programm `01-CreateTable.cs` erstellt eine Tabelle (`TryDaxTable`). Die restlichen .NET-Programme in diesem Abschnitt hängen von dieser Tabelle ab.

```
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.Model;

namespace ClientTest
{
    class Program
    {
        public static async Task Main(string[] args)
        {
            AmazonDynamoDBClient client = new AmazonDynamoDBClient();

            var tableName = "TryDaxTable";

            var request = new CreateTableRequest()
            {
                TableName = tableName,
                KeySchema = new List<KeySchemaElement>()
                {
                    new KeySchemaElement{ AttributeName = "pk",KeyType = "HASH"},
                    new KeySchemaElement{ AttributeName = "sk",KeyType = "RANGE"}
                },
                AttributeDefinitions = new List<AttributeDefinition>() {
                    new AttributeDefinition{ AttributeName = "pk",AttributeType = "N"},
                    new AttributeDefinition{ AttributeName = "sk",AttributeType  = "N"}
                },
                ProvisionedThroughput = new ProvisionedThroughput()
                {
                    ReadCapacityUnits = 10,
                    WriteCapacityUnits = 10
                }
            };

            var response = await client.CreateTableAsync(request);

            Console.WriteLine("Hit <enter> to continue...");
            Console.ReadLine();
        }
    }
}
```

# 02-Write-Data.cs
<a name="DAX.client.run-application-dotnet.02-Write-Data"></a>

Das Programm `02-Write-Data.cs` schreibt Testdaten in `TryDaxTable`.

```
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.Model;

namespace ClientTest
{
    class Program
    {
        public static async Task Main(string[] args)
        {
            AmazonDynamoDBClient client = new AmazonDynamoDBClient();

            var tableName = "TryDaxTable";

            string someData = new string('X', 1000);
            var pkmax = 10;
            var skmax = 10;

            for (var ipk = 1; ipk <= pkmax; ipk++)
            {
                Console.WriteLine($"Writing {skmax} items for partition key: {ipk}");
                for (var isk = 1; isk <= skmax; isk++)
                {
                    var request = new PutItemRequest()
                    {
                        TableName = tableName,
                        Item = new Dictionary<string, AttributeValue>()
                       {
                            { "pk", new AttributeValue{N = ipk.ToString() } },
                            { "sk", new AttributeValue{N = isk.ToString() } },
                            { "someData", new AttributeValue{S = someData } }
                       }
                    };

                    var response = await client.PutItemAsync(request);
                }
            }

            Console.WriteLine("Hit <enter> to continue...");
            Console.ReadLine();
        }
    }
}
```

# 03- -Test.cs GetItem
<a name="DAX.client.run-application-dotnet.03-GetItem-Test"></a>

Das Programm `03-GetItem-Test.cs` führt `GetItem`-Operationen für `TryDaxTable` aus.

```
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Amazon.DAX;
using Amazon.DynamoDBv2.Model;
using Amazon.Runtime;

namespace ClientTest
{
    class Program
    {
        public static async Task Main(string[] args)
        {
            string endpointUri = args[0];
            Console.WriteLine($"Using DAX client - endpointUri={endpointUri}");

            var clientConfig = new DaxClientConfig(endpointUri)
            {
                AwsCredentials = FallbackCredentialsFactory.GetCredentials()
            };
            var client = new ClusterDaxClient(clientConfig);

            var tableName = "TryDaxTable";

            var pk = 1;
            var sk = 10;
            var iterations = 5;

            var startTime = System.DateTime.Now;

            for (var i = 0; i < iterations; i++)
            {
                for (var ipk = 1; ipk <= pk; ipk++)
                {
                    for (var isk = 1; isk <= sk; isk++)
                    {
                        var request = new GetItemRequest()
                        {
                            TableName = tableName,
                            Key = new Dictionary<string, AttributeValue>() {
                            {"pk", new AttributeValue {N = ipk.ToString()} },
                            {"sk", new AttributeValue {N = isk.ToString() } }
                        }
                        };
                        var response = await client.GetItemAsync(request);
                        Console.WriteLine($"GetItem succeeded for pk: {ipk},sk: {isk}");
                    }
                }
            }

            var endTime = DateTime.Now;
            TimeSpan timeSpan = endTime - startTime;
            Console.WriteLine($"Total time: {timeSpan.TotalMilliseconds} milliseconds");

            Console.WriteLine("Hit <enter> to continue...");
            Console.ReadLine();
        }
    }
}
```

# 04-Query-Test.cs
<a name="DAX.client.run-application-dotnet.04-Query-Test"></a>

Das Programm `04-Query-Test.cs` führt `Query`-Operationen für `TryDaxTable` aus.

```
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Amazon.Runtime;
using Amazon.DAX;
using Amazon.DynamoDBv2.Model;

namespace ClientTest
{
    class Program
    {
        public static async Task Main(string[] args)
        {
            string endpointUri = args[0];
            Console.WriteLine($"Using DAX client - endpointUri={endpointUri}");


            var clientConfig = new DaxClientConfig(endpointUri)
            {
                AwsCredentials = FallbackCredentialsFactory.GetCredentials()
            };
            var client = new ClusterDaxClient(clientConfig);

            var tableName = "TryDaxTable";

            var pk = 5;
            var sk1 = 2;
            var sk2 = 9;
            var iterations = 5;

            var startTime = DateTime.Now;

            for (var i = 0; i < iterations; i++)
            {
                var request = new QueryRequest()
                {
                    TableName = tableName,
                    KeyConditionExpression = "pk = :pkval and sk between :skval1 and :skval2",
                    ExpressionAttributeValues = new Dictionary<string, AttributeValue>() {
                            {":pkval", new AttributeValue {N = pk.ToString()} },
                            {":skval1", new AttributeValue {N = sk1.ToString()} },
                            {":skval2", new AttributeValue {N = sk2.ToString()} }
                    }
                };
                var response = await client.QueryAsync(request);
                Console.WriteLine($"{i}: Query succeeded");

            }

            var endTime = DateTime.Now;
            TimeSpan timeSpan = endTime - startTime;
            Console.WriteLine($"Total time: {timeSpan.TotalMilliseconds} milliseconds");

            Console.WriteLine("Hit <enter> to continue...");
            Console.ReadLine();
        }
    }
}
```

# 05-Scan-Test.cs
<a name="DAX.client.run-application-dotnet.05-Scan-Test"></a>

Das Programm `05-Scan-Test.cs` führt `Scan`-Operationen für `TryDaxTable` aus.

```
using System;
using System.Threading.Tasks;
using Amazon.Runtime;
using Amazon.DAX;
using Amazon.DynamoDBv2.Model;

namespace ClientTest
{
    class Program
    {
        public static async Task Main(string[] args)
        {
            string endpointUri = args[0];
            Console.WriteLine($"Using DAX client - endpointUri={endpointUri}");

            var clientConfig = new DaxClientConfig(endpointUri)
            {
                AwsCredentials = FallbackCredentialsFactory.GetCredentials()
            };
            var client = new ClusterDaxClient(clientConfig);

            var tableName = "TryDaxTable";

            var iterations = 5;

            var startTime = DateTime.Now;

            for (var i = 0; i < iterations; i++)
            {
                var request = new ScanRequest()
                {
                    TableName = tableName
                };
                var response = await client.ScanAsync(request);
                Console.WriteLine($"{i}: Scan succeeded");
            }

            var endTime = DateTime.Now;
            TimeSpan timeSpan = endTime - startTime;
            Console.WriteLine($"Total time: {timeSpan.TotalMilliseconds} milliseconds");

            Console.WriteLine("Hit <enter> to continue...");
            Console.ReadLine();
        }
    }
}
```

# 0-6. DeleteTable cs
<a name="DAX.client.run-application-dotnet.06-DeleteTable"></a>

Das `06-DeleteTable.cs`-Programm löscht `TryDaxTable`. Führen Sie dieses Programm aus, sobald Sie mit dem Testen fertig sind.

```
using System;
using System.Threading.Tasks;
using Amazon.DynamoDBv2.Model;
using Amazon.DynamoDBv2;

namespace ClientTest
{
    class Program
    {
        public static async Task Main(string[] args)
        {
            AmazonDynamoDBClient client = new AmazonDynamoDBClient();

            var tableName = "TryDaxTable";

            var request = new DeleteTableRequest()
            {
                TableName = tableName
            };

            var response = await client.DeleteTableAsync(request);

            Console.WriteLine("Hit <enter> to continue...");
            Console.ReadLine();
        }
    }
}
```