Doc AWS SDK 예제 GitHub 리포지토리에서 더 많은 SDK 예제를 사용할 수 있습니다. [AWS](https://github.com/awsdocs/aws-doc-sdk-examples)
기계 번역으로 제공되는 번역입니다. 제공된 번역과 원본 영어의 내용이 상충하는 경우에는 영어 버전이 우선합니다.
# 를 사용한 DynamoDB 예제 SDK for .NET
다음 코드 예제에서는 DynamoDB와 AWS SDK for .NET 함께를 사용하여 작업을 수행하고 일반적인 시나리오를 구현하는 방법을 보여줍니다.
*작업*은 대규모 프로그램에서 발췌한 코드이며 컨텍스트에 맞춰 실행해야 합니다. 작업은 개별 서비스 함수를 직접 호출하는 방법을 보여주며, 관련 시나리오의 컨텍스트에 맞는 작업을 볼 수 있습니다.
*시나리오*는 동일한 서비스 내에서 또는 다른 AWS 서비스와 결합된 상태에서 여러 함수를 직접적으로 호출하여 특정 태스크를 수행하는 방법을 보여주는 코드 예제입니다.
*AWS 커뮤니티 기여*는 여러 팀이 생성하고 유지 관리하는 예입니다 AWS. 피드백을 제공하려면 연결된 리포지토리에 제공된 메커니즘을 사용합니다.
각 예시에는 전체 소스 코드에 대한 링크가 포함되어 있으며, 여기에서 컨텍스트에 맞춰 코드를 설정하고 실행하는 방법에 대한 지침을 찾을 수 있습니다.
**Topics**
+ [작업](#actions)
+ [시나리오](#scenarios)
+ [서버리스 예제](#serverless_examples)
+ [AWS 커뮤니티 기여](#aws_community_contributions)
## 작업
### `BatchExecuteStatement`
다음 코드 예시는 `BatchExecuteStatement`의 사용 방법을 보여줍니다.
**SDK for .NET**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/dynamodb#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
INSERT 문 배치를 사용하여 항목을 추가합니다.
```
///
/// Inserts movies imported from a JSON file into the movie table by
/// using an Amazon DynamoDB PartiQL INSERT statement.
///
/// The name of the table into which the movie
/// information will be inserted.
/// The name of the JSON file that contains
/// movie information.
/// A Boolean value that indicates the success or failure of
/// the insert operation.
public static async Task InsertMovies(string tableName, string movieFileName)
{
// Get the list of movies from the JSON file.
var movies = ImportMovies(movieFileName);
var success = false;
if (movies is not null)
{
// Insert the movies in a batch using PartiQL. Because the
// batch can contain a maximum of 25 items, insert 25 movies
// at a time.
string insertBatch = $"INSERT INTO {tableName} VALUE {{'title': ?, 'year': ?}}";
var statements = new List();
try
{
for (var indexOffset = 0; indexOffset < 250; indexOffset += 25)
{
for (var i = indexOffset; i < indexOffset + 25; i++)
{
statements.Add(new BatchStatementRequest
{
Statement = insertBatch,
Parameters = new List
{
new AttributeValue { S = movies[i].Title },
new AttributeValue { N = movies[i].Year.ToString() },
},
});
}
var response = await Client.BatchExecuteStatementAsync(new BatchExecuteStatementRequest
{
Statements = statements,
});
// Wait between batches for movies to be successfully added.
System.Threading.Thread.Sleep(3000);
success = response.HttpStatusCode == System.Net.HttpStatusCode.OK;
// Clear the list of statements for the next batch.
statements.Clear();
}
}
catch (AmazonDynamoDBException ex)
{
Console.WriteLine(ex.Message);
}
}
return success;
}
///
/// Loads the contents of a JSON file into a list of movies to be
/// added to the DynamoDB table.
///
/// The full path to the JSON file.
/// A generic list of movie objects.
public static List ImportMovies(string movieFileName)
{
if (!File.Exists(movieFileName))
{
return null!;
}
using var sr = new StreamReader(movieFileName);
string json = sr.ReadToEnd();
var allMovies = JsonConvert.DeserializeObject>(json);
if (allMovies is not null)
{
// Return the first 250 entries.
return allMovies.GetRange(0, 250);
}
else
{
return null!;
}
}
```
SELECT 문 배치를 사용하여 항목을 가져옵니다.
```
///
/// Gets movies from the movie table by
/// using an Amazon DynamoDB PartiQL SELECT statement.
///
/// The name of the table.
/// The title of the first movie.
/// The title of the second movie.
/// The year of the first movie.
/// The year of the second movie.
/// True if successful.
public static async Task GetBatch(
string tableName,
string title1,
string title2,
int year1,
int year2)
{
var getBatch = $"SELECT * FROM {tableName} WHERE title = ? AND year = ?";
var statements = new List
{
new BatchStatementRequest
{
Statement = getBatch,
Parameters = new List
{
new AttributeValue { S = title1 },
new AttributeValue { N = year1.ToString() },
},
},
new BatchStatementRequest
{
Statement = getBatch,
Parameters = new List
{
new AttributeValue { S = title2 },
new AttributeValue { N = year2.ToString() },
},
}
};
var response = await Client.BatchExecuteStatementAsync(new BatchExecuteStatementRequest
{
Statements = statements,
});
if (response.Responses.Count > 0)
{
response.Responses.ForEach(r =>
{
if (r.Item.Any())
{
Console.WriteLine($"{r.Item["title"]}\t{r.Item["year"]}");
}
});
return true;
}
else
{
Console.WriteLine($"Couldn't find either {title1} or {title2}.");
return false;
}
}
```
UPDATE 문 배치를 사용하여 항목을 업데이트합니다.
```
///
/// Updates information for multiple movies.
///
/// The name of the table containing the
/// movies to be updated.
/// The producer name for the first movie
/// to update.
/// The title of the first movie.
/// The year that the first movie was released.
/// The producer name for the second
/// movie to update.
/// The title of the second movie.
/// The year that the second movie was released.
/// A Boolean value that indicates the success of the update.
public static async Task UpdateBatch(
string tableName,
string producer1,
string title1,
int year1,
string producer2,
string title2,
int year2)
{
string updateBatch = $"UPDATE {tableName} SET Producer=? WHERE title = ? AND year = ?";
var statements = new List
{
new BatchStatementRequest
{
Statement = updateBatch,
Parameters = new List
{
new AttributeValue { S = producer1 },
new AttributeValue { S = title1 },
new AttributeValue { N = year1.ToString() },
},
},
new BatchStatementRequest
{
Statement = updateBatch,
Parameters = new List
{
new AttributeValue { S = producer2 },
new AttributeValue { S = title2 },
new AttributeValue { N = year2.ToString() },
},
}
};
var response = await Client.BatchExecuteStatementAsync(new BatchExecuteStatementRequest
{
Statements = statements,
});
return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
}
```
DELETE 문 배치를 사용하여 항목을 삭제합니다.
```
///
/// Deletes multiple movies using a PartiQL BatchExecuteAsync
/// statement.
///
/// The name of the table containing the
/// moves that will be deleted.
/// The title of the first movie.
/// The year the first movie was released.
/// The title of the second movie.
/// The year the second movie was released.
/// A Boolean value indicating the success of the operation.
public static async Task DeleteBatch(
string tableName,
string title1,
int year1,
string title2,
int year2)
{
string updateBatch = $"DELETE FROM {tableName} WHERE title = ? AND year = ?";
var statements = new List
{
new BatchStatementRequest
{
Statement = updateBatch,
Parameters = new List
{
new AttributeValue { S = title1 },
new AttributeValue { N = year1.ToString() },
},
},
new BatchStatementRequest
{
Statement = updateBatch,
Parameters = new List
{
new AttributeValue { S = title2 },
new AttributeValue { N = year2.ToString() },
},
}
};
var response = await Client.BatchExecuteStatementAsync(new BatchExecuteStatementRequest
{
Statements = statements,
});
return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
}
```
+ API 세부 정보는 *AWS SDK for .NET API 참조*의 [BatchExecuteStatement](https://docs.aws.amazon.com/goto/DotNetSDKV3/dynamodb-2012-08-10/BatchExecuteStatement)를 참조하세요.
### `BatchGetItem`
다음 코드 예시는 `BatchGetItem`의 사용 방법을 보여줍니다.
**SDK for .NET**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/dynamodb#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
using System;
using System.Collections.Generic;
using Amazon.DynamoDBv2;
using Amazon.DynamoDBv2.Model;
namespace LowLevelBatchGet
{
public class LowLevelBatchGet
{
private static readonly string _table1Name = "Forum";
private static readonly string _table2Name = "Thread";
public static async void RetrieveMultipleItemsBatchGet(AmazonDynamoDBClient client)
{
var request = new BatchGetItemRequest
{
RequestItems = new Dictionary()
{
{ _table1Name,
new KeysAndAttributes
{
Keys = new List >()
{
new Dictionary()
{
{ "Name", new AttributeValue {
S = "Amazon DynamoDB"
} }
},
new Dictionary()
{
{ "Name", new AttributeValue {
S = "Amazon S3"
} }
}
}
}},
{
_table2Name,
new KeysAndAttributes
{
Keys = new List >()
{
new Dictionary()
{
{ "ForumName", new AttributeValue {
S = "Amazon DynamoDB"
} },
{ "Subject", new AttributeValue {
S = "DynamoDB Thread 1"
} }
},
new Dictionary()
{
{ "ForumName", new AttributeValue {
S = "Amazon DynamoDB"
} },
{ "Subject", new AttributeValue {
S = "DynamoDB Thread 2"
} }
},
new Dictionary()
{
{ "ForumName", new AttributeValue {
S = "Amazon S3"
} },
{ "Subject", new AttributeValue {
S = "S3 Thread 1"
} }
}
}
}
}
}
};
BatchGetItemResponse response;
do
{
Console.WriteLine("Making request");
response = await client.BatchGetItemAsync(request);
// Check the response.
var responses = response.Responses; // Attribute list in the response.
foreach (var tableResponse in responses)
{
var tableResults = tableResponse.Value;
Console.WriteLine("Items retrieved from table {0}", tableResponse.Key);
foreach (var item1 in tableResults)
{
PrintItem(item1);
}
}
// Any unprocessed keys? could happen if you exceed ProvisionedThroughput or some other error.
Dictionary unprocessedKeys = response.UnprocessedKeys;
foreach (var unprocessedTableKeys in unprocessedKeys)
{
// Print table name.
Console.WriteLine(unprocessedTableKeys.Key);
// Print unprocessed primary keys.
foreach (var key in unprocessedTableKeys.Value.Keys)
{
PrintItem(key);
}
}
request.RequestItems = unprocessedKeys;
} while (response.UnprocessedKeys.Count > 0);
}
private static void PrintItem(Dictionary attributeList)
{
foreach (KeyValuePair kvp in attributeList)
{
string attributeName = kvp.Key;
AttributeValue value = kvp.Value;
Console.WriteLine(
attributeName + " " +
(value.S == null ? "" : "S=[" + value.S + "]") +
(value.N == null ? "" : "N=[" + value.N + "]") +
(value.SS == null ? "" : "SS=[" + string.Join(",", value.SS.ToArray()) + "]") +
(value.NS == null ? "" : "NS=[" + string.Join(",", value.NS.ToArray()) + "]")
);
}
Console.WriteLine("************************************************");
}
static void Main()
{
var client = new AmazonDynamoDBClient();
RetrieveMultipleItemsBatchGet(client);
}
}
}
```
+ API 세부 정보는 *AWS SDK for .NET API 참조*의 [BatchGetItem](https://docs.aws.amazon.com/goto/DotNetSDKV3/dynamodb-2012-08-10/BatchGetItem)을 참조하세요.
### `DescribeTable`
다음 코드 예시는 `DescribeTable`의 사용 방법을 보여줍니다.
**SDK for .NET**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/dynamodb#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
private static async Task GetTableInformation()
{
Console.WriteLine("\n*** Retrieving table information ***");
var response = await Client.DescribeTableAsync(new DescribeTableRequest
{
TableName = ExampleTableName
});
var table = response.Table;
Console.WriteLine($"Name: {table.TableName}");
Console.WriteLine($"# of items: {table.ItemCount}");
}
```
+ API 세부 정보는 *AWS SDK for .NET API 참조*의 [DescribeTable](https://docs.aws.amazon.com/goto/DotNetSDKV3/dynamodb-2012-08-10/DescribeTable)을 참조하세요.
### `ExecuteStatement`
다음 코드 예시는 `ExecuteStatement`의 사용 방법을 보여줍니다.
**SDK for .NET**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/dynamodb#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
INSERT 문을 사용하여 항목을 추가합니다.
```
///
/// Inserts a single movie into the movies table.
///
/// The name of the table.
/// The title of the movie to insert.
/// The year that the movie was released.
/// A Boolean value that indicates the success or failure of
/// the INSERT operation.
public static async Task InsertSingleMovie(string tableName, string movieTitle, int year)
{
string insertBatch = $"INSERT INTO {tableName} VALUE {{'title': ?, 'year': ?}}";
var response = await Client.ExecuteStatementAsync(new ExecuteStatementRequest
{
Statement = insertBatch,
Parameters = new List
{
new AttributeValue { S = movieTitle },
new AttributeValue { N = year.ToString() },
},
});
return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
}
```
SELECT 문을 사용하여 항목을 가져옵니다.
```
///
/// Uses a PartiQL SELECT statement to retrieve a single movie from the
/// movie database.
///
/// The name of the movie table.
/// The title of the movie to retrieve.
/// A list of movie data. If no movie matches the supplied
/// title, the list is empty.
public static async Task>> GetSingleMovie(string tableName, string movieTitle)
{
string selectSingle = $"SELECT * FROM {tableName} WHERE title = ?";
var parameters = new List
{
new AttributeValue { S = movieTitle },
};
var response = await Client.ExecuteStatementAsync(new ExecuteStatementRequest
{
Statement = selectSingle,
Parameters = parameters,
});
return response.Items;
}
```
SELECT 문을 사용하여 항목 목록을 가져옵니다.
```
///
/// Retrieve multiple movies by year using a SELECT statement.
///
/// The name of the movie table.
/// The year the movies were released.
///
public static async Task>> GetMovies(string tableName, int year)
{
string selectSingle = $"SELECT * FROM {tableName} WHERE year = ?";
var parameters = new List
{
new AttributeValue { N = year.ToString() },
};
var response = await Client.ExecuteStatementAsync(new ExecuteStatementRequest
{
Statement = selectSingle,
Parameters = parameters,
});
return response.Items;
}
```
UPDATE 문을 사용하여 항목을 업데이트합니다.
```
///
/// Updates a single movie in the table, adding information for the
/// producer.
///
/// the name of the table.
/// The name of the producer.
/// The movie title.
/// The year the movie was released.
/// A Boolean value that indicates the success of the
/// UPDATE operation.
public static async Task UpdateSingleMovie(string tableName, string producer, string movieTitle, int year)
{
string insertSingle = $"UPDATE {tableName} SET Producer=? WHERE title = ? AND year = ?";
var response = await Client.ExecuteStatementAsync(new ExecuteStatementRequest
{
Statement = insertSingle,
Parameters = new List
{
new AttributeValue { S = producer },
new AttributeValue { S = movieTitle },
new AttributeValue { N = year.ToString() },
},
});
return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
}
```
DELETE 문을 사용하여 하나의 영화를 삭제합니다.
```
///
/// Deletes a single movie from the table.
///
/// The name of the table.
/// The title of the movie to delete.
/// The year that the movie was released.
/// A Boolean value that indicates the success of the
/// DELETE operation.
public static async Task DeleteSingleMovie(string tableName, string movieTitle, int year)
{
var deleteSingle = $"DELETE FROM {tableName} WHERE title = ? AND year = ?";
var response = await Client.ExecuteStatementAsync(new ExecuteStatementRequest
{
Statement = deleteSingle,
Parameters = new List
{
new AttributeValue { S = movieTitle },
new AttributeValue { N = year.ToString() },
},
});
return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
}
```
+ API 세부 정보는 *AWS SDK for .NET API 참조*의 [ExecuteStatement](https://docs.aws.amazon.com/goto/DotNetSDKV3/dynamodb-2012-08-10/ExecuteStatement)를 참조하세요.
### `ListTables`
다음 코드 예시는 `ListTables`의 사용 방법을 보여줍니다.
**SDK for .NET**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/dynamodb#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
private static async Task ListMyTables()
{
Console.WriteLine("\n*** Listing tables ***");
string lastTableNameEvaluated = null;
do
{
var response = await Client.ListTablesAsync(new ListTablesRequest
{
Limit = 2,
ExclusiveStartTableName = lastTableNameEvaluated
});
foreach (var name in response.TableNames)
{
Console.WriteLine(name);
}
lastTableNameEvaluated = response.LastEvaluatedTableName;
} while (lastTableNameEvaluated != null);
}
```
+ API 세부 정보는 *AWS SDK for .NET API 참조*의 [ListTables](https://docs.aws.amazon.com/goto/DotNetSDKV3/dynamodb-2012-08-10/ListTables)를 참조하세요.
## 시나리오
### 사진을 관리하기 위한 서버리스 애플리케이션 만들기
다음 코드 예시에서는 사용자가 레이블을 사용하여 사진을 관리할 수 있는 서버리스 애플리케이션을 생성하는 방법을 보여줍니다.
**SDK for .NET**
Amazon Rekognition을 사용하여 이미지에서 레이블을 감지하고 나중에 검색할 수 있도록 저장하는 사진 자산 관리 애플리케이션을 개발하는 방법을 보여줍니다.
전체 소스 코드와 설정 및 실행 방법에 대한 지침은 [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/cross-service/PhotoAssetManager)에서 전체 예제를 참조하세요.
이 예제의 출처에 대한 자세한 내용은 [AWS 커뮤니티](https://community.aws/posts/cloud-journeys/01-serverless-image-recognition-app)의 게시물을 참조하세요.
**이 예제에서 사용되는 서비스**
+ API Gateway
+ DynamoDB
+ Lambda
+ Amazon Rekognition
+ Amazon S3
+ Amazon SNS
### DynamoDB 데이터를 추적하는 웹 애플리케이션 만들기
다음 코드 예제에서는 Amazon DynamoDB 테이블에서 작업 항목을 추적하고 Amazon Simple Email Service(Amazon SES)를 사용하여 보고서를 보내는 웹 애플리케이션을 만드는 방법을 보여줍니다.
**SDK for .NET**
Amazon DynamoDB .NET API를 사용하여 DynamoDB 작업 데이터를 추적하는 동적 웹 애플리케이션을 만드는 방법을 보여줍니다.
전체 소스 코드와 설정 및 실행 방법에 대한 지침은 [GitHub](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/cross-service/DynamoDbItemTracker)에서 전체 예제를 참조하세요.
**이 예제에서 사용되는 서비스**
+ DynamoDB
+ Amazon SES
### PartiQL 문 배치를 사용하여 테이블 쿼리
다음 코드 예제에서는 다음과 같은 작업을 수행하는 방법을 보여줍니다.
+ 여러 SELECT 문을 실행하여 항목 배치를 가져옵니다.
+ 여러 INSERT 문을 실행하여 항목 배치를 추가합니다.
+ 여러 UPDATE 문을 실행하여 항목 배치를 업데이트합니다.
+ 여러 DELETE 문을 실행하여 항목 배치를 삭제합니다.
**SDK for .NET**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/dynamodb#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
// Before you run this example, download 'movies.json' from
// https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GettingStarted.Js.02.html,
// and put it in the same folder as the example.
// Separator for the console display.
var SepBar = new string('-', 80);
const string tableName = "movie_table";
const string movieFileName = @"..\..\..\..\..\..\..\..\resources\sample_files\movies.json";
DisplayInstructions();
// Create the table and wait for it to be active.
Console.WriteLine($"Creating the movie table: {tableName}");
var success = await DynamoDBMethods.CreateMovieTableAsync(tableName);
if (success)
{
Console.WriteLine($"Successfully created table: {tableName}.");
}
WaitForEnter();
// Add movie information to the table from moviedata.json. See the
// instructions at the top of this file to download the JSON file.
Console.WriteLine($"Inserting movies into the new table. Please wait...");
success = await PartiQLBatchMethods.InsertMovies(tableName, movieFileName);
if (success)
{
Console.WriteLine("Movies successfully added to the table.");
}
else
{
Console.WriteLine("Movies could not be added to the table.");
}
WaitForEnter();
// Update multiple movies by using the BatchExecute statement.
var title1 = "Star Wars";
var year1 = 1977;
var title2 = "Wizard of Oz";
var year2 = 1939;
Console.WriteLine($"Updating two movies with producer information: {title1} and {title2}.");
success = await PartiQLBatchMethods.GetBatch(tableName, title1, title2, year1, year2);
if (success)
{
Console.WriteLine($"Successfully retrieved {title1} and {title2}.");
}
else
{
Console.WriteLine("Select statement failed.");
}
WaitForEnter();
// Update multiple movies by using the BatchExecute statement.
var producer1 = "LucasFilm";
var producer2 = "MGM";
Console.WriteLine($"Updating two movies with producer information: {title1} and {title2}.");
success = await PartiQLBatchMethods.UpdateBatch(tableName, producer1, title1, year1, producer2, title2, year2);
if (success)
{
Console.WriteLine($"Successfully updated {title1} and {title2}.");
}
else
{
Console.WriteLine("Update failed.");
}
WaitForEnter();
// Delete multiple movies by using the BatchExecute statement.
Console.WriteLine($"Now we will delete {title1} and {title2} from the table.");
success = await PartiQLBatchMethods.DeleteBatch(tableName, title1, year1, title2, year2);
if (success)
{
Console.WriteLine($"Deleted {title1} and {title2}");
}
else
{
Console.WriteLine($"could not delete {title1} or {title2}");
}
WaitForEnter();
// DNow that the PartiQL Batch scenario is complete, delete the movie table.
success = await DynamoDBMethods.DeleteTableAsync(tableName);
if (success)
{
Console.WriteLine($"Successfully deleted {tableName}");
}
else
{
Console.WriteLine($"Could not delete {tableName}");
}
///
/// Displays the description of the application on the console.
///
void DisplayInstructions()
{
Console.Clear();
Console.WriteLine();
Console.Write(new string(' ', 24));
Console.WriteLine("DynamoDB PartiQL Basics Example");
Console.WriteLine(SepBar);
Console.WriteLine("This demo application shows the basics of using Amazon DynamoDB with the AWS SDK for");
Console.WriteLine(".NET version 3.7 and .NET 6.");
Console.WriteLine(SepBar);
Console.WriteLine("Creates a table by using the CreateTable method.");
Console.WriteLine("Gets multiple movies by using a PartiQL SELECT statement.");
Console.WriteLine("Updates multiple movies by using the ExecuteBatch method.");
Console.WriteLine("Deletes multiple movies by using a PartiQL DELETE statement.");
Console.WriteLine("Cleans up the resources created for the demo by deleting the table.");
Console.WriteLine(SepBar);
WaitForEnter();
}
///
/// Simple method to wait for the key to be pressed.
///
void WaitForEnter()
{
Console.WriteLine("\nPress to continue.");
Console.Write(SepBar);
_ = Console.ReadLine();
}
///
/// Gets movies from the movie table by
/// using an Amazon DynamoDB PartiQL SELECT statement.
///
/// The name of the table.
/// The title of the first movie.
/// The title of the second movie.
/// The year of the first movie.
/// The year of the second movie.
/// True if successful.
public static async Task GetBatch(
string tableName,
string title1,
string title2,
int year1,
int year2)
{
var getBatch = $"SELECT * FROM {tableName} WHERE title = ? AND year = ?";
var statements = new List
{
new BatchStatementRequest
{
Statement = getBatch,
Parameters = new List
{
new AttributeValue { S = title1 },
new AttributeValue { N = year1.ToString() },
},
},
new BatchStatementRequest
{
Statement = getBatch,
Parameters = new List
{
new AttributeValue { S = title2 },
new AttributeValue { N = year2.ToString() },
},
}
};
var response = await Client.BatchExecuteStatementAsync(new BatchExecuteStatementRequest
{
Statements = statements,
});
if (response.Responses.Count > 0)
{
response.Responses.ForEach(r =>
{
if (r.Item.Any())
{
Console.WriteLine($"{r.Item["title"]}\t{r.Item["year"]}");
}
});
return true;
}
else
{
Console.WriteLine($"Couldn't find either {title1} or {title2}.");
return false;
}
}
///
/// Inserts movies imported from a JSON file into the movie table by
/// using an Amazon DynamoDB PartiQL INSERT statement.
///
/// The name of the table into which the movie
/// information will be inserted.
/// The name of the JSON file that contains
/// movie information.
/// A Boolean value that indicates the success or failure of
/// the insert operation.
public static async Task InsertMovies(string tableName, string movieFileName)
{
// Get the list of movies from the JSON file.
var movies = ImportMovies(movieFileName);
var success = false;
if (movies is not null)
{
// Insert the movies in a batch using PartiQL. Because the
// batch can contain a maximum of 25 items, insert 25 movies
// at a time.
string insertBatch = $"INSERT INTO {tableName} VALUE {{'title': ?, 'year': ?}}";
var statements = new List();
try
{
for (var indexOffset = 0; indexOffset < 250; indexOffset += 25)
{
for (var i = indexOffset; i < indexOffset + 25; i++)
{
statements.Add(new BatchStatementRequest
{
Statement = insertBatch,
Parameters = new List
{
new AttributeValue { S = movies[i].Title },
new AttributeValue { N = movies[i].Year.ToString() },
},
});
}
var response = await Client.BatchExecuteStatementAsync(new BatchExecuteStatementRequest
{
Statements = statements,
});
// Wait between batches for movies to be successfully added.
System.Threading.Thread.Sleep(3000);
success = response.HttpStatusCode == System.Net.HttpStatusCode.OK;
// Clear the list of statements for the next batch.
statements.Clear();
}
}
catch (AmazonDynamoDBException ex)
{
Console.WriteLine(ex.Message);
}
}
return success;
}
///
/// Loads the contents of a JSON file into a list of movies to be
/// added to the DynamoDB table.
///
/// The full path to the JSON file.
/// A generic list of movie objects.
public static List ImportMovies(string movieFileName)
{
if (!File.Exists(movieFileName))
{
return null!;
}
using var sr = new StreamReader(movieFileName);
string json = sr.ReadToEnd();
var allMovies = JsonConvert.DeserializeObject>(json);
if (allMovies is not null)
{
// Return the first 250 entries.
return allMovies.GetRange(0, 250);
}
else
{
return null!;
}
}
///
/// Updates information for multiple movies.
///
/// The name of the table containing the
/// movies to be updated.
/// The producer name for the first movie
/// to update.
/// The title of the first movie.
/// The year that the first movie was released.
/// The producer name for the second
/// movie to update.
/// The title of the second movie.
/// The year that the second movie was released.
/// A Boolean value that indicates the success of the update.
public static async Task UpdateBatch(
string tableName,
string producer1,
string title1,
int year1,
string producer2,
string title2,
int year2)
{
string updateBatch = $"UPDATE {tableName} SET Producer=? WHERE title = ? AND year = ?";
var statements = new List
{
new BatchStatementRequest
{
Statement = updateBatch,
Parameters = new List
{
new AttributeValue { S = producer1 },
new AttributeValue { S = title1 },
new AttributeValue { N = year1.ToString() },
},
},
new BatchStatementRequest
{
Statement = updateBatch,
Parameters = new List
{
new AttributeValue { S = producer2 },
new AttributeValue { S = title2 },
new AttributeValue { N = year2.ToString() },
},
}
};
var response = await Client.BatchExecuteStatementAsync(new BatchExecuteStatementRequest
{
Statements = statements,
});
return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
}
///
/// Deletes multiple movies using a PartiQL BatchExecuteAsync
/// statement.
///
/// The name of the table containing the
/// moves that will be deleted.
/// The title of the first movie.
/// The year the first movie was released.
/// The title of the second movie.
/// The year the second movie was released.
/// A Boolean value indicating the success of the operation.
public static async Task DeleteBatch(
string tableName,
string title1,
int year1,
string title2,
int year2)
{
string updateBatch = $"DELETE FROM {tableName} WHERE title = ? AND year = ?";
var statements = new List
{
new BatchStatementRequest
{
Statement = updateBatch,
Parameters = new List
{
new AttributeValue { S = title1 },
new AttributeValue { N = year1.ToString() },
},
},
new BatchStatementRequest
{
Statement = updateBatch,
Parameters = new List
{
new AttributeValue { S = title2 },
new AttributeValue { N = year2.ToString() },
},
}
};
var response = await Client.BatchExecuteStatementAsync(new BatchExecuteStatementRequest
{
Statements = statements,
});
return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
}
```
+ API 세부 정보는 *AWS SDK for .NET API 참조*의 [BatchExecuteStatement](https://docs.aws.amazon.com/goto/DotNetSDKV3/dynamodb-2012-08-10/BatchExecuteStatement)를 참조하세요.
### PartiQL을 사용하여 테이블 쿼리
다음 코드 예제에서는 다음과 같은 작업을 수행하는 방법을 보여줍니다.
+ SELECT 문을 실행하여 항목을 가져옵니다.
+ INSERT 문을 실행하여 항목을 추가합니다.
+ UPDATE 문을 실행하여 항목을 업데이트합니다.
+ DELETE 문을 실행하여 항목을 삭제합니다.
**SDK for .NET**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/dynamodb#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
```
namespace PartiQL_Basics_Scenario
{
public class PartiQLMethods
{
private static readonly AmazonDynamoDBClient Client = new AmazonDynamoDBClient();
///
/// Inserts movies imported from a JSON file into the movie table by
/// using an Amazon DynamoDB PartiQL INSERT statement.
///
/// The name of the table where the movie
/// information will be inserted.
/// The name of the JSON file that contains
/// movie information.
/// A Boolean value that indicates the success or failure of
/// the insert operation.
public static async Task InsertMovies(string tableName, string movieFileName)
{
// Get the list of movies from the JSON file.
var movies = ImportMovies(movieFileName);
var success = false;
if (movies is not null)
{
// Insert the movies in a batch using PartiQL. Because the
// batch can contain a maximum of 25 items, insert 25 movies
// at a time.
string insertBatch = $"INSERT INTO {tableName} VALUE {{'title': ?, 'year': ?}}";
var statements = new List();
try
{
for (var indexOffset = 0; indexOffset < 250; indexOffset += 25)
{
for (var i = indexOffset; i < indexOffset + 25; i++)
{
statements.Add(new BatchStatementRequest
{
Statement = insertBatch,
Parameters = new List
{
new AttributeValue { S = movies[i].Title },
new AttributeValue { N = movies[i].Year.ToString() },
},
});
}
var response = await Client.BatchExecuteStatementAsync(new BatchExecuteStatementRequest
{
Statements = statements,
});
// Wait between batches for movies to be successfully added.
System.Threading.Thread.Sleep(3000);
success = response.HttpStatusCode == System.Net.HttpStatusCode.OK;
// Clear the list of statements for the next batch.
statements.Clear();
}
}
catch (AmazonDynamoDBException ex)
{
Console.WriteLine(ex.Message);
}
}
return success;
}
///
/// Loads the contents of a JSON file into a list of movies to be
/// added to the DynamoDB table.
///
/// The full path to the JSON file.
/// A generic list of movie objects.
public static List ImportMovies(string movieFileName)
{
if (!File.Exists(movieFileName))
{
return null!;
}
using var sr = new StreamReader(movieFileName);
string json = sr.ReadToEnd();
var allMovies = JsonConvert.DeserializeObject>(json);
if (allMovies is not null)
{
// Return the first 250 entries.
return allMovies.GetRange(0, 250);
}
else
{
return null!;
}
}
///
/// Uses a PartiQL SELECT statement to retrieve a single movie from the
/// movie database.
///
/// The name of the movie table.
/// The title of the movie to retrieve.
/// A list of movie data. If no movie matches the supplied
/// title, the list is empty.
public static async Task>> GetSingleMovie(string tableName, string movieTitle)
{
string selectSingle = $"SELECT * FROM {tableName} WHERE title = ?";
var parameters = new List
{
new AttributeValue { S = movieTitle },
};
var response = await Client.ExecuteStatementAsync(new ExecuteStatementRequest
{
Statement = selectSingle,
Parameters = parameters,
});
return response.Items;
}
///
/// Retrieve multiple movies by year using a SELECT statement.
///
/// The name of the movie table.
/// The year the movies were released.
///
public static async Task>> GetMovies(string tableName, int year)
{
string selectSingle = $"SELECT * FROM {tableName} WHERE year = ?";
var parameters = new List
{
new AttributeValue { N = year.ToString() },
};
var response = await Client.ExecuteStatementAsync(new ExecuteStatementRequest
{
Statement = selectSingle,
Parameters = parameters,
});
return response.Items;
}
///
/// Inserts a single movie into the movies table.
///
/// The name of the table.
/// The title of the movie to insert.
/// The year that the movie was released.
/// A Boolean value that indicates the success or failure of
/// the INSERT operation.
public static async Task InsertSingleMovie(string tableName, string movieTitle, int year)
{
string insertBatch = $"INSERT INTO {tableName} VALUE {{'title': ?, 'year': ?}}";
var response = await Client.ExecuteStatementAsync(new ExecuteStatementRequest
{
Statement = insertBatch,
Parameters = new List
{
new AttributeValue { S = movieTitle },
new AttributeValue { N = year.ToString() },
},
});
return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
}
///
/// Updates a single movie in the table, adding information for the
/// producer.
///
/// the name of the table.
/// The name of the producer.
/// The movie title.
/// The year the movie was released.
/// A Boolean value that indicates the success of the
/// UPDATE operation.
public static async Task UpdateSingleMovie(string tableName, string producer, string movieTitle, int year)
{
string insertSingle = $"UPDATE {tableName} SET Producer=? WHERE title = ? AND year = ?";
var response = await Client.ExecuteStatementAsync(new ExecuteStatementRequest
{
Statement = insertSingle,
Parameters = new List
{
new AttributeValue { S = producer },
new AttributeValue { S = movieTitle },
new AttributeValue { N = year.ToString() },
},
});
return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
}
///
/// Deletes a single movie from the table.
///
/// The name of the table.
/// The title of the movie to delete.
/// The year that the movie was released.
/// A Boolean value that indicates the success of the
/// DELETE operation.
public static async Task DeleteSingleMovie(string tableName, string movieTitle, int year)
{
var deleteSingle = $"DELETE FROM {tableName} WHERE title = ? AND year = ?";
var response = await Client.ExecuteStatementAsync(new ExecuteStatementRequest
{
Statement = deleteSingle,
Parameters = new List
{
new AttributeValue { S = movieTitle },
new AttributeValue { N = year.ToString() },
},
});
return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
}
///
/// Displays the list of movies returned from a database query.
///
/// The list of movie information to display.
private static void DisplayMovies(List> items)
{
if (items.Count > 0)
{
Console.WriteLine($"Found {items.Count} movies.");
items.ForEach(item => Console.WriteLine($"{item["year"].N}\t{item["title"].S}"));
}
else
{
Console.WriteLine($"Didn't find a movie that matched the supplied criteria.");
}
}
}
}
///
/// Uses a PartiQL SELECT statement to retrieve a single movie from the
/// movie database.
///
/// The name of the movie table.
/// The title of the movie to retrieve.
/// A list of movie data. If no movie matches the supplied
/// title, the list is empty.
public static async Task>> GetSingleMovie(string tableName, string movieTitle)
{
string selectSingle = $"SELECT * FROM {tableName} WHERE title = ?";
var parameters = new List
{
new AttributeValue { S = movieTitle },
};
var response = await Client.ExecuteStatementAsync(new ExecuteStatementRequest
{
Statement = selectSingle,
Parameters = parameters,
});
return response.Items;
}
///
/// Inserts a single movie into the movies table.
///
/// The name of the table.
/// The title of the movie to insert.
/// The year that the movie was released.
/// A Boolean value that indicates the success or failure of
/// the INSERT operation.
public static async Task InsertSingleMovie(string tableName, string movieTitle, int year)
{
string insertBatch = $"INSERT INTO {tableName} VALUE {{'title': ?, 'year': ?}}";
var response = await Client.ExecuteStatementAsync(new ExecuteStatementRequest
{
Statement = insertBatch,
Parameters = new List
{
new AttributeValue { S = movieTitle },
new AttributeValue { N = year.ToString() },
},
});
return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
}
///
/// Updates a single movie in the table, adding information for the
/// producer.
///
/// the name of the table.
/// The name of the producer.
/// The movie title.
/// The year the movie was released.
/// A Boolean value that indicates the success of the
/// UPDATE operation.
public static async Task UpdateSingleMovie(string tableName, string producer, string movieTitle, int year)
{
string insertSingle = $"UPDATE {tableName} SET Producer=? WHERE title = ? AND year = ?";
var response = await Client.ExecuteStatementAsync(new ExecuteStatementRequest
{
Statement = insertSingle,
Parameters = new List
{
new AttributeValue { S = producer },
new AttributeValue { S = movieTitle },
new AttributeValue { N = year.ToString() },
},
});
return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
}
///
/// Deletes a single movie from the table.
///
/// The name of the table.
/// The title of the movie to delete.
/// The year that the movie was released.
/// A Boolean value that indicates the success of the
/// DELETE operation.
public static async Task DeleteSingleMovie(string tableName, string movieTitle, int year)
{
var deleteSingle = $"DELETE FROM {tableName} WHERE title = ? AND year = ?";
var response = await Client.ExecuteStatementAsync(new ExecuteStatementRequest
{
Statement = deleteSingle,
Parameters = new List
{
new AttributeValue { S = movieTitle },
new AttributeValue { N = year.ToString() },
},
});
return response.HttpStatusCode == System.Net.HttpStatusCode.OK;
}
```
+ API 세부 정보는 *AWS SDK for .NET API 참조*의 [ExecuteStatement](https://docs.aws.amazon.com/goto/DotNetSDKV3/dynamodb-2012-08-10/ExecuteStatement)를 참조하세요.
### 문서 모델 사용
다음 코드 예제에서는 DynamoDB 및 AWS SDK용 문서 모델을 사용하여 생성, 읽기, 업데이트 및 삭제(CRUD) 및 배치 작업을 수행하는 방법을 보여줍니다.
자세한 내용은 [문서 모델](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DotNetSDKMidLevel.html)을 참조하세요.
**SDK for .NET**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/dynamodb/mid-level-api#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
문서 모델을 사용하여 CRUD 작업을 수행합니다.
```
///
/// Performs CRUD operations on an Amazon DynamoDB table.
///
public class MidlevelItemCRUD
{
public static async Task Main()
{
var tableName = "ProductCatalog";
var sampleBookId = 555;
var client = new AmazonDynamoDBClient();
var productCatalog = LoadTable(client, tableName);
await CreateBookItem(productCatalog, sampleBookId);
RetrieveBook(productCatalog, sampleBookId);
// Couple of sample updates.
UpdateMultipleAttributes(productCatalog, sampleBookId);
UpdateBookPriceConditionally(productCatalog, sampleBookId);
// Delete.
await DeleteBook(productCatalog, sampleBookId);
}
///
/// Loads the contents of a DynamoDB table.
///
/// An initialized DynamoDB client object.
/// The name of the table to load.
/// A DynamoDB table object.
public static Table LoadTable(IAmazonDynamoDB client, string tableName)
{
Table productCatalog = Table.LoadTable(client, tableName);
return productCatalog;
}
///
/// Creates an example book item and adds it to the DynamoDB table
/// ProductCatalog.
///
/// A DynamoDB table object.
/// An integer value representing the book's ID.
public static async Task CreateBookItem(Table productCatalog, int sampleBookId)
{
Console.WriteLine("\n*** Executing CreateBookItem() ***");
var book = new Document
{
["Id"] = sampleBookId,
["Title"] = "Book " + sampleBookId,
["Price"] = 19.99,
["ISBN"] = "111-1111111111",
["Authors"] = new List { "Author 1", "Author 2", "Author 3" },
["PageCount"] = 500,
["Dimensions"] = "8.5x11x.5",
["InPublication"] = new DynamoDBBool(true),
["InStock"] = new DynamoDBBool(false),
["QuantityOnHand"] = 0,
};
// Adds the book to the ProductCatalog table.
await productCatalog.PutItemAsync(book);
}
///
/// Retrieves an item, a book, from the DynamoDB ProductCatalog table.
///
/// A DynamoDB table object.
/// An integer value representing the book's ID.
public static async void RetrieveBook(
Table productCatalog,
int sampleBookId)
{
Console.WriteLine("\n*** Executing RetrieveBook() ***");
// Optional configuration.
var config = new GetItemOperationConfig
{
AttributesToGet = new List { "Id", "ISBN", "Title", "Authors", "Price" },
ConsistentRead = true,
};
Document document = await productCatalog.GetItemAsync(sampleBookId, config);
Console.WriteLine("RetrieveBook: Printing book retrieved...");
PrintDocument(document);
}
///
/// Updates multiple attributes for a book and writes the changes to the
/// DynamoDB table ProductCatalog.
///
/// A DynamoDB table object.
/// An integer value representing the book's ID.
public static async void UpdateMultipleAttributes(
Table productCatalog,
int sampleBookId)
{
Console.WriteLine("\nUpdating multiple attributes....");
int partitionKey = sampleBookId;
var book = new Document
{
["Id"] = partitionKey,
// List of attribute updates.
// The following replaces the existing authors list.
["Authors"] = new List { "Author x", "Author y" },
["newAttribute"] = "New Value",
["ISBN"] = null, // Remove it.
};
// Optional parameters.
var config = new UpdateItemOperationConfig
{
// Gets updated item in response.
ReturnValues = ReturnValues.AllNewAttributes,
};
Document updatedBook = await productCatalog.UpdateItemAsync(book, config);
Console.WriteLine("UpdateMultipleAttributes: Printing item after updates ...");
PrintDocument(updatedBook);
}
///
/// Updates a book item if it meets the specified criteria.
///
/// A DynamoDB table object.
/// An integer value representing the book's ID.
public static async void UpdateBookPriceConditionally(
Table productCatalog,
int sampleBookId)
{
Console.WriteLine("\n*** Executing UpdateBookPriceConditionally() ***");
int partitionKey = sampleBookId;
var book = new Document
{
["Id"] = partitionKey,
["Price"] = 29.99,
};
// For conditional price update, creating a condition expression.
var expr = new Expression
{
ExpressionStatement = "Price = :val",
};
expr.ExpressionAttributeValues[":val"] = 19.00;
// Optional parameters.
var config = new UpdateItemOperationConfig
{
ConditionalExpression = expr,
ReturnValues = ReturnValues.AllNewAttributes,
};
Document updatedBook = await productCatalog.UpdateItemAsync(book, config);
Console.WriteLine("UpdateBookPriceConditionally: Printing item whose price was conditionally updated");
PrintDocument(updatedBook);
}
///
/// Deletes the book with the supplied Id value from the DynamoDB table
/// ProductCatalog.
///
/// A DynamoDB table object.
/// An integer value representing the book's ID.
public static async Task DeleteBook(
Table productCatalog,
int sampleBookId)
{
Console.WriteLine("\n*** Executing DeleteBook() ***");
// Optional configuration.
var config = new DeleteItemOperationConfig
{
// Returns the deleted item.
ReturnValues = ReturnValues.AllOldAttributes,
};
Document document = await productCatalog.DeleteItemAsync(sampleBookId, config);
Console.WriteLine("DeleteBook: Printing deleted just deleted...");
PrintDocument(document);
}
///
/// Prints the information for the supplied DynamoDB document.
///
/// A DynamoDB document object.
public static void PrintDocument(Document updatedDocument)
{
if (updatedDocument is null)
{
return;
}
foreach (var attribute in updatedDocument.GetAttributeNames())
{
string stringValue = null;
var value = updatedDocument[attribute];
if (value is null)
{
continue;
}
if (value is Primitive)
{
stringValue = value.AsPrimitive().Value.ToString();
}
else if (value is PrimitiveList)
{
stringValue = string.Join(",", (from primitive
in value.AsPrimitiveList().Entries
select primitive.Value).ToArray());
}
Console.WriteLine($"{attribute} - {stringValue}", attribute, stringValue);
}
}
}
```
문서 모델을 사용하여 배치 쓰기 작업을 수행합니다.
```
///
/// Shows how to use mid-level Amazon DynamoDB API calls to perform batch
/// operations.
///
public class MidLevelBatchWriteItem
{
public static async Task Main()
{
IAmazonDynamoDB client = new AmazonDynamoDBClient();
await SingleTableBatchWrite(client);
await MultiTableBatchWrite(client);
}
///
/// Perform a batch operation on a single DynamoDB table.
///
/// An initialized DynamoDB object.
public static async Task SingleTableBatchWrite(IAmazonDynamoDB client)
{
Table productCatalog = Table.LoadTable(client, "ProductCatalog");
var batchWrite = productCatalog.CreateBatchWrite();
var book1 = new Document
{
["Id"] = 902,
["Title"] = "My book1 in batch write using .NET helper classes",
["ISBN"] = "902-11-11-1111",
["Price"] = 10,
["ProductCategory"] = "Book",
["Authors"] = new List { "Author 1", "Author 2", "Author 3" },
["Dimensions"] = "8.5x11x.5",
["InStock"] = new DynamoDBBool(true),
["QuantityOnHand"] = new DynamoDBNull(), // Quantity is unknown at this time.
};
batchWrite.AddDocumentToPut(book1);
// Specify delete item using overload that takes PK.
batchWrite.AddKeyToDelete(12345);
Console.WriteLine("Performing batch write in SingleTableBatchWrite()");
await batchWrite.ExecuteAsync();
}
///
/// Perform a batch operation involving multiple DynamoDB tables.
///
/// An initialized DynamoDB client object.
public static async Task MultiTableBatchWrite(IAmazonDynamoDB client)
{
// Specify item to add in the Forum table.
Table forum = Table.LoadTable(client, "Forum");
var forumBatchWrite = forum.CreateBatchWrite();
var forum1 = new Document
{
["Name"] = "Test BatchWrite Forum",
["Threads"] = 0,
};
forumBatchWrite.AddDocumentToPut(forum1);
// Specify item to add in the Thread table.
Table thread = Table.LoadTable(client, "Thread");
var threadBatchWrite = thread.CreateBatchWrite();
var thread1 = new Document
{
["ForumName"] = "S3 forum",
["Subject"] = "My sample question",
["Message"] = "Message text",
["KeywordTags"] = new List { "S3", "Bucket" },
};
threadBatchWrite.AddDocumentToPut(thread1);
// Specify item to delete from the Thread table.
threadBatchWrite.AddKeyToDelete("someForumName", "someSubject");
// Create multi-table batch.
var superBatch = new MultiTableDocumentBatchWrite();
superBatch.AddBatch(forumBatchWrite);
superBatch.AddBatch(threadBatchWrite);
Console.WriteLine("Performing batch write in MultiTableBatchWrite()");
// Execute the batch.
await superBatch.ExecuteAsync();
}
}
```
문서 모델을 사용하여 테이블을 스캔합니다.
```
///
/// Shows how to use mid-level Amazon DynamoDB API calls to scan a DynamoDB
/// table for values.
///
public class MidLevelScanOnly
{
public static async Task Main()
{
IAmazonDynamoDB client = new AmazonDynamoDBClient();
Table productCatalogTable = Table.LoadTable(client, "ProductCatalog");
await FindProductsWithNegativePrice(productCatalogTable);
await FindProductsWithNegativePriceWithConfig(productCatalogTable);
}
///
/// Retrieves any products that have a negative price in a DynamoDB table.
///
/// A DynamoDB table object.
public static async Task FindProductsWithNegativePrice(
Table productCatalogTable)
{
// Assume there is a price error. So we scan to find items priced < 0.
var scanFilter = new ScanFilter();
scanFilter.AddCondition("Price", ScanOperator.LessThan, 0);
Search search = productCatalogTable.Scan(scanFilter);
do
{
var documentList = await search.GetNextSetAsync();
Console.WriteLine("\nFindProductsWithNegativePrice: printing ............");
foreach (var document in documentList)
{
PrintDocument(document);
}
}
while (!search.IsDone);
}
///
/// Finds any items in the ProductCatalog table using a DynamoDB
/// configuration object.
///
/// A DynamoDB table object.
public static async Task FindProductsWithNegativePriceWithConfig(
Table productCatalogTable)
{
// Assume there is a price error. So we scan to find items priced < 0.
var scanFilter = new ScanFilter();
scanFilter.AddCondition("Price", ScanOperator.LessThan, 0);
var config = new ScanOperationConfig()
{
Filter = scanFilter,
Select = SelectValues.SpecificAttributes,
AttributesToGet = new List { "Title", "Id" },
};
Search search = productCatalogTable.Scan(config);
do
{
var documentList = await search.GetNextSetAsync();
Console.WriteLine("\nFindProductsWithNegativePriceWithConfig: printing ............");
foreach (var document in documentList)
{
PrintDocument(document);
}
}
while (!search.IsDone);
}
///
/// Displays the details of the passed DynamoDB document object on the
/// console.
///
/// A DynamoDB document object.
public static void PrintDocument(Document document)
{
Console.WriteLine();
foreach (var attribute in document.GetAttributeNames())
{
string stringValue = null;
var value = document[attribute];
if (value is Primitive)
{
stringValue = value.AsPrimitive().Value.ToString();
}
else if (value is PrimitiveList)
{
stringValue = string.Join(",", (from primitive
in value.AsPrimitiveList().Entries
select primitive.Value).ToArray());
}
Console.WriteLine($"{attribute} - {stringValue}");
}
}
}
```
문서 모델을 사용하여 테이블을 쿼리하고 스캔합니다.
```
///
/// Shows how to perform mid-level query procedures on an Amazon DynamoDB
/// table.
///
public class MidLevelQueryAndScan
{
public static async Task Main()
{
IAmazonDynamoDB client = new AmazonDynamoDBClient();
// Query examples.
Table replyTable = Table.LoadTable(client, "Reply");
string forumName = "Amazon DynamoDB";
string threadSubject = "DynamoDB Thread 2";
await FindRepliesInLast15Days(replyTable);
await FindRepliesInLast15DaysWithConfig(replyTable, forumName, threadSubject);
await FindRepliesPostedWithinTimePeriod(replyTable, forumName, threadSubject);
// Get Example.
Table productCatalogTable = Table.LoadTable(client, "ProductCatalog");
int productId = 101;
await GetProduct(productCatalogTable, productId);
}
///
/// Retrieves information about a product from the DynamoDB table
/// ProductCatalog based on the product ID and displays the information
/// on the console.
///
/// The name of the table from which to retrieve
/// product information.
/// The ID of the product to retrieve.
public static async Task GetProduct(Table tableName, int productId)
{
Console.WriteLine("*** Executing GetProduct() ***");
Document productDocument = await tableName.GetItemAsync(productId);
if (productDocument != null)
{
PrintDocument(productDocument);
}
else
{
Console.WriteLine("Error: product " + productId + " does not exist");
}
}
///
/// Retrieves replies from the passed DynamoDB table object.
///
/// The table we want to query.
public static async Task FindRepliesInLast15Days(
Table table)
{
DateTime twoWeeksAgoDate = DateTime.UtcNow - TimeSpan.FromDays(15);
var filter = new QueryFilter("Id", QueryOperator.Equal, "Id");
filter.AddCondition("ReplyDateTime", QueryOperator.GreaterThan, twoWeeksAgoDate);
// Use Query overloads that take the minimum required query parameters.
Search search = table.Query(filter);
do
{
var documentSet = await search.GetNextSetAsync();
Console.WriteLine("\nFindRepliesInLast15Days: printing ............");
foreach (var document in documentSet)
{
PrintDocument(document);
}
}
while (!search.IsDone);
}
///
/// Retrieve replies made during a specific time period.
///
/// The table we want to query.
/// The name of the forum that we're interested in.
/// The subject of the thread, which we are
/// searching for replies.
public static async Task FindRepliesPostedWithinTimePeriod(
Table table,
string forumName,
string threadSubject)
{
DateTime startDate = DateTime.UtcNow.Subtract(new TimeSpan(21, 0, 0, 0));
DateTime endDate = DateTime.UtcNow.Subtract(new TimeSpan(1, 0, 0, 0));
var filter = new QueryFilter("Id", QueryOperator.Equal, forumName + "#" + threadSubject);
filter.AddCondition("ReplyDateTime", QueryOperator.Between, startDate, endDate);
var config = new QueryOperationConfig()
{
Limit = 2, // 2 items/page.
Select = SelectValues.SpecificAttributes,
AttributesToGet = new List
{
"Message",
"ReplyDateTime",
"PostedBy",
},
ConsistentRead = true,
Filter = filter,
};
Search search = table.Query(config);
do
{
var documentList = await search.GetNextSetAsync();
Console.WriteLine("\nFindRepliesPostedWithinTimePeriod: printing replies posted within dates: {0} and {1} ............", startDate, endDate);
foreach (var document in documentList)
{
PrintDocument(document);
}
}
while (!search.IsDone);
}
///
/// Perform a query for replies made in the last 15 days using a DynamoDB
/// QueryOperationConfig object.
///
/// The table we want to query.
/// The name of the forum that we're interested in.
/// The bane of the thread that we are searching
/// for replies.
public static async Task FindRepliesInLast15DaysWithConfig(
Table table,
string forumName,
string threadName)
{
DateTime twoWeeksAgoDate = DateTime.UtcNow - TimeSpan.FromDays(15);
var filter = new QueryFilter("Id", QueryOperator.Equal, forumName + "#" + threadName);
filter.AddCondition("ReplyDateTime", QueryOperator.GreaterThan, twoWeeksAgoDate);
var config = new QueryOperationConfig()
{
Filter = filter,
// Optional parameters.
Select = SelectValues.SpecificAttributes,
AttributesToGet = new List
{
"Message",
"ReplyDateTime",
"PostedBy",
},
ConsistentRead = true,
};
Search search = table.Query(config);
do
{
var documentSet = await search.GetNextSetAsync();
Console.WriteLine("\nFindRepliesInLast15DaysWithConfig: printing ............");
foreach (var document in documentSet)
{
PrintDocument(document);
}
}
while (!search.IsDone);
}
///
/// Displays the contents of the passed DynamoDB document on the console.
///
/// A DynamoDB document to display.
public static void PrintDocument(Document document)
{
Console.WriteLine();
foreach (var attribute in document.GetAttributeNames())
{
string stringValue = null;
var value = document[attribute];
if (value is Primitive)
{
stringValue = value.AsPrimitive().Value.ToString();
}
else if (value is PrimitiveList)
{
stringValue = string.Join(",", (from primitive
in value.AsPrimitiveList().Entries
select primitive.Value).ToArray());
}
Console.WriteLine($"{attribute} - {stringValue}");
}
}
}
```
### 상위 수준 객체 지속성 모델 사용
다음 코드 예제에서는 DynamoDB 및 AWS SDK용 객체 지속성 모델을 사용하여 생성, 읽기, 업데이트 및 삭제(CRUD) 및 배치 작업을 수행하는 방법을 보여줍니다.
자세한 내용은 [객체 지속성 모델](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DotNetSDKHighLevel.html)을 참조하세요.
**SDK for .NET**
GitHub에 더 많은 내용이 있습니다. [AWS 코드 예 리포지토리](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/dynamodb/high-level-api#code-examples)에서 전체 예를 찾고 설정 및 실행하는 방법을 배워보세요.
상위 수준 객체 지속성 모델을 사용하여 CRUD 작업을 수행합니다.
```
///
/// Shows how to perform high-level CRUD operations on an Amazon DynamoDB
/// table.
///
public class HighLevelItemCrud
{
public static async Task Main()
{
var client = new AmazonDynamoDBClient();
DynamoDBContext context = new DynamoDBContext(client);
await PerformCRUDOperations(context);
}
public static async Task PerformCRUDOperations(IDynamoDBContext context)
{
int bookId = 1001; // Some unique value.
Book myBook = new Book
{
Id = bookId,
Title = "object persistence-AWS SDK for.NET SDK-Book 1001",
Isbn = "111-1111111001",
BookAuthors = new List { "Author 1", "Author 2" },
};
// Save the book to the ProductCatalog table.
await context.SaveAsync(myBook);
// Retrieve the book from the ProductCatalog table.
Book bookRetrieved = await context.LoadAsync(bookId);
// Update some properties.
bookRetrieved.Isbn = "222-2222221001";
// Update existing authors list with the following values.
bookRetrieved.BookAuthors = new List { " Author 1", "Author x" };
await context.SaveAsync(bookRetrieved);
// Retrieve the updated book. This time, add the optional
// ConsistentRead parameter using DynamoDBContextConfig object.
await context.LoadAsync(bookId, new DynamoDBContextConfig
{
ConsistentRead = true,
});
// Delete the book.
await context.DeleteAsync(bookId);
// Try to retrieve deleted book. It should return null.
Book deletedBook = await context.LoadAsync(bookId, new DynamoDBContextConfig
{
ConsistentRead = true,
});
if (deletedBook == null)
{
Console.WriteLine("Book is deleted");
}
}
}
```
상위 수준 객체 지속성 모델을 사용하여 배치 쓰기 작업을 수행합니다.
```
///
/// Performs high-level batch write operations to an Amazon DynamoDB table.
/// This example was written using the AWS SDK for .NET version 3.7 and .NET
/// Core 5.0.
///
public class HighLevelBatchWriteItem
{
public static async Task SingleTableBatchWrite(IDynamoDBContext context)
{
Book book1 = new Book
{
Id = 902,
InPublication = true,
Isbn = "902-11-11-1111",
PageCount = "100",
Price = 10,
ProductCategory = "Book",
Title = "My book3 in batch write",
};
Book book2 = new Book
{
Id = 903,
InPublication = true,
Isbn = "903-11-11-1111",
PageCount = "200",
Price = 10,
ProductCategory = "Book",
Title = "My book4 in batch write",
};
var bookBatch = context.CreateBatchWrite();
bookBatch.AddPutItems(new List { book1, book2 });
Console.WriteLine("Adding two books to ProductCatalog table.");
await bookBatch.ExecuteAsync();
}
public static async Task MultiTableBatchWrite(IDynamoDBContext context)
{
// New Forum item.
Forum newForum = new Forum
{
Name = "Test BatchWrite Forum",
Threads = 0,
};
var forumBatch = context.CreateBatchWrite();
forumBatch.AddPutItem(newForum);
// New Thread item.
Thread newThread = new Thread
{
ForumName = "S3 forum",
Subject = "My sample question",
KeywordTags = new List { "S3", "Bucket" },
Message = "Message text",
};
DynamoDBOperationConfig config = new DynamoDBOperationConfig();
config.SkipVersionCheck = true;
var threadBatch = context.CreateBatchWrite(config);
threadBatch.AddPutItem(newThread);
threadBatch.AddDeleteKey("some partition key value", "some sort key value");
var superBatch = new MultiTableBatchWrite(forumBatch, threadBatch);
Console.WriteLine("Performing batch write in MultiTableBatchWrite().");
await superBatch.ExecuteAsync();
}
public static async Task Main()
{
AmazonDynamoDBClient client = new AmazonDynamoDBClient();
DynamoDBContext context = new DynamoDBContext(client);
await SingleTableBatchWrite(context);
await MultiTableBatchWrite(context);
}
}
```
상위 수준 객체 지속성 모델을 사용하여 임의 데이터를 테이블에 매핑합니다.
```
///
/// Shows how to map arbitrary data to an Amazon DynamoDB table.
///
public class HighLevelMappingArbitraryData
{
///
/// Creates a book, adds it to the DynamoDB ProductCatalog table, retrieves
/// the new book from the table, updates the dimensions and writes the
/// changed item back to the table.
///
/// The DynamoDB context object used to write and
/// read data from the table.
public static async Task AddRetrieveUpdateBook(IDynamoDBContext context)
{
// Create a book.
DimensionType myBookDimensions = new DimensionType()
{
Length = 8M,
Height = 11M,
Thickness = 0.5M,
};
Book myBook = new Book
{
Id = 501,
Title = "AWS SDK for .NET Object Persistence Model Handling Arbitrary Data",
Isbn = "999-9999999999",
BookAuthors = new List { "Author 1", "Author 2" },
Dimensions = myBookDimensions,
};
// Add the book to the DynamoDB table ProductCatalog.
await context.SaveAsync(myBook);
// Retrieve the book.
Book bookRetrieved = await context.LoadAsync(501);
// Update the book dimensions property.
bookRetrieved.Dimensions.Height += 1;
bookRetrieved.Dimensions.Length += 1;
bookRetrieved.Dimensions.Thickness += 0.2M;
// Write the changed item to the table.
await context.SaveAsync(bookRetrieved);
}
public static async Task Main()
{
var client = new AmazonDynamoDBClient();
DynamoDBContext context = new DynamoDBContext(client);
await AddRetrieveUpdateBook(context);
}
}
```
상위 수준 객체 지속성 모델을 사용하여 테이블을 쿼리하고 스캔합니다.
```
///
/// Shows how to perform high-level query and scan operations to Amazon
/// DynamoDB tables.
///
public class HighLevelQueryAndScan
{
public static async Task Main()
{
var client = new AmazonDynamoDBClient();
DynamoDBContext context = new DynamoDBContext(client);
// Get an item.
await GetBook(context, 101);
// Sample forum and thread to test queries.
string forumName = "Amazon DynamoDB";
string threadSubject = "DynamoDB Thread 1";
// Sample queries.
await FindRepliesInLast15Days(context, forumName, threadSubject);
await FindRepliesPostedWithinTimePeriod(context, forumName, threadSubject);
// Scan table.
await FindProductsPricedLessThanZero(context);
}
public static async Task GetBook(IDynamoDBContext context, int productId)
{
Book bookItem = await context.LoadAsync(productId);
Console.WriteLine("\nGetBook: Printing result.....");
Console.WriteLine($"Title: {bookItem.Title} \n ISBN:{bookItem.Isbn} \n No. of pages: {bookItem.PageCount}");
}
///
/// Queries a DynamoDB table to find replies posted within the last 15 days.
///
/// The DynamoDB context used to perform the query.
/// The name of the forum that we're interested in.
/// The thread object containing the query parameters.
public static async Task FindRepliesInLast15Days(
IDynamoDBContext context,
string forumName,
string threadSubject)
{
string replyId = $"{forumName} #{threadSubject}";
DateTime twoWeeksAgoDate = DateTime.UtcNow - TimeSpan.FromDays(15);
List