public int GetItem(string dbKey, string dbKeyValue, string table, out GetItemResponse paramResponse)
{
GetItemRequest request = new GetItemRequest();
request.TableName = table; // set the table name for DynamoDB
request.Key = new Dictionary<string, AttributeValue>() { { dbKey, new AttributeValue { S = dbKeyValue } } };
int response = (int)DBEnum.DBResponseCodes.DEFAULT_VALUE;
try
{
paramResponse = this.client.GetItem(request); // value set to NOT null
//Check to see if entry exist
if (0 == paramResponse.Item.Count) // Entry does not exist
{
response = (int)DBEnum.DBResponseCodes.DOES_NOT_EXIST;
}
else // Entry exists
{
response = (int)DBEnum.DBResponseCodes.SUCCESS;
}
}
catch
{
response = (int)DBEnum.DBResponseCodes.DYNAMODB_EXCEPTION; // set reponse to DB Exception flag
paramResponse = null; // set to null on Error
}
return response;
}
// Get TestID
public static void GetData1(int Id)
{
var Req = new Amazon.DynamoDBv2.Model.GetItemRequest
{
TableName = "TestID",
Key = new Dictionary<string, Amazon.DynamoDBv2.Model.AttributeValue>() { {"Id",new Amazon.DynamoDBv2.Model.AttributeValue{N=Id.ToString()}}}
};
var Rsp = client.GetItem(Req);
PrintItem(Rsp.GetItemResult.Item);
Console.ReadLine();
}
public static void GetData(string UID, string tableName)
{
Table testDB = Table.LoadTable(client, tableName);
var request = new Amazon.DynamoDBv2.Model.GetItemRequest
{
TableName = tableName,
Key = new Dictionary<string,Amazon.DynamoDBv2.Model.AttributeValue>()
{{"UID",new Amazon.DynamoDBv2.Model.AttributeValue{S=UID}}}
};
var response = client.GetItem(request);
var result = response.GetItemResult;
Console.WriteLine("Units");
Console.WriteLine(response.GetItemResult.ConsumedCapacity.CapacityUnits);
Console.WriteLine("Data");
Console.WriteLine(response.GetItemResult.Item.Count);
Console.ReadLine();
}
public bool CheckUserIsExist(string userID)
{
var config = new AmazonDynamoDBConfig();
GetItemResponse response;
config.ServiceURL = System.Configuration.ConfigurationManager.AppSettings["ServiceURL"];
client = new AmazonDynamoDBClient(config);
bool retval = false;
try
{
GetItemRequest request = new GetItemRequest
{
TableName = "User",
Key = new Dictionary<string, AttributeValue>() { { "UserID", new AttributeValue { S = userID } } },
ReturnConsumedCapacity = "TOTAL"
};
response = client.GetItem(request);
retval = response.Item.Count > 0;
}
catch (AmazonDynamoDBException e) { Console.WriteLine(e.Message); }
catch (AmazonServiceException e) { Console.WriteLine(e.Message); }
catch (Exception e) { Console.WriteLine(e.Message); }
return retval;
}
/// <summary>
/// Initiates the asynchronous execution of the GetItem operation.
/// <seealso cref="Amazon.DynamoDBv2.AmazonDynamoDB.GetItem"/>
/// </summary>
///
/// <param name="getItemRequest">Container for the necessary parameters to execute the GetItem operation on AmazonDynamoDBv2.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetItem
/// operation.</returns>
public IAsyncResult BeginGetItem(GetItemRequest getItemRequest, AsyncCallback callback, object state)
{
return invokeGetItem(getItemRequest, callback, state, false);
}
/// <summary>
/// The <i>GetItem</i> operation returns a set of attributes for the item with the given
/// primary key. If there is no matching item, <i>GetItem</i> does not return any data.
///
///
/// <para>
/// <i>GetItem</i> provides an eventually consistent read by default. If your application
/// requires a strongly consistent read, set <i>ConsistentRead</i> to <code>true</code>.
/// Although a strongly consistent read might take more time than an eventually consistent
/// read, it always returns the last updated value.
/// </para>
/// </summary>
/// <param name="tableName">The name of the table containing the requested item.</param>
/// <param name="key">A map of attribute names to <i>AttributeValue</i> objects, representing the primary key of the item to retrieve. For the primary key, you must provide all of the attributes. For example, with a hash type primary key, you only need to provide the hash attribute. For a hash-and-range type primary key, you must provide both the hash attribute and the range attribute.</param>
/// <param name="consistentRead">A value that if set to <code>true</code>, then the operation uses strongly consistent reads; otherwise, eventually consistent reads are used.</param>
///
/// <returns>The response from the GetItem service method, as returned by DynamoDB.</returns>
/// <exception cref="Amazon.DynamoDBv2.Model.InternalServerErrorException">
/// An error occurred on the server side.
/// </exception>
/// <exception cref="Amazon.DynamoDBv2.Model.ProvisionedThroughputExceededException">
/// The request rate is too high, or the request is too large, for the available throughput
/// to accommodate. The AWS SDKs automatically retry requests that receive this exception;
/// therefore, your request will eventually succeed, unless the request is too large or
/// your retry queue is too large to finish. Reduce the frequency of requests by using
/// the strategies listed in <a href="http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ErrorHandling.html#APIRetries">Error
/// Retries and Exponential Backoff</a> in the <i>Amazon DynamoDB Developer Guide</i>.
/// </exception>
/// <exception cref="Amazon.DynamoDBv2.Model.ResourceNotFoundException">
/// The operation tried to access a nonexistent table or index. The resource might not
/// be specified correctly, or its status might not be <code>ACTIVE</code>.
/// </exception>
public GetItemResponse GetItem(string tableName, Dictionary<string, AttributeValue> key, bool consistentRead)
{
var request = new GetItemRequest();
request.TableName = tableName;
request.Key = key;
request.ConsistentRead = consistentRead;
return GetItem(request);
}
IAsyncResult invokeGetItem(GetItemRequest getItemRequest, AsyncCallback callback, object state, bool synchronized)
{
IRequest irequest = new GetItemRequestMarshaller().Marshall(getItemRequest);
var unmarshaller = GetItemResponseUnmarshaller.GetInstance();
AsyncResult result = new AsyncResult(irequest, callback, state, synchronized, signer, unmarshaller);
Invoke(result);
return result;
}
/// <summary>
/// <para>The <i>GetItem</i> operation returns a set of attributes for the item with the given primary key. If there is no matching item,
/// <i>GetItem</i> does not return any data.</para> <para> <i>GetItem</i> provides an eventually consistent read by default. If your application
/// requires a strongly consistent read, set <i>ConsistentRead</i> to <c>true</c> . Although a strongly consistent read might take more time
/// than an eventually consistent read, it always returns the last updated value.</para>
/// </summary>
///
/// <param name="getItemRequest">Container for the necessary parameters to execute the GetItem service method on AmazonDynamoDBv2.</param>
///
/// <returns>The response from the GetItem service method, as returned by AmazonDynamoDBv2.</returns>
///
/// <exception cref="T:Amazon.DynamoDBv2.Model.ResourceNotFoundException" />
/// <exception cref="T:Amazon.DynamoDBv2.Model.ProvisionedThroughputExceededException" />
/// <exception cref="T:Amazon.DynamoDBv2.Model.InternalServerErrorException" />
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
public Task<GetItemResponse> GetItemAsync(GetItemRequest getItemRequest, CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new GetItemRequestMarshaller();
var unmarshaller = GetItemResponseUnmarshaller.GetInstance();
return Invoke<IRequest, GetItemRequest, GetItemResponse>(getItemRequest, marshaller, unmarshaller, signer, cancellationToken);
}
/// <summary>
/// The <i>GetItem</i> operation returns a set of attributes for the item with the given
/// primary key. If there is no matching item, <i>GetItem</i> does not return any data.
///
///
/// <para>
/// <i>GetItem</i> provides an eventually consistent read by default. If your application
/// requires a strongly consistent read, set <i>ConsistentRead</i> to <code>true</code>.
/// Although a strongly consistent read might take more time than an eventually consistent
/// read, it always returns the last updated value.
/// </para>
/// </summary>
/// <param name="tableName">The name of the table containing the requested item.</param>
/// <param name="key">A map of attribute names to <i>AttributeValue</i> objects, representing the primary key of the item to retrieve. For the primary key, you must provide all of the attributes. For example, with a hash type primary key, you only need to provide the hash attribute. For a hash-and-range type primary key, you must provide both the hash attribute and the range attribute.</param>
///
/// <returns>The response from the GetItem service method, as returned by DynamoDB.</returns>
/// <exception cref="Amazon.DynamoDBv2.Model.InternalServerErrorException">
/// An error occurred on the server side.
/// </exception>
/// <exception cref="Amazon.DynamoDBv2.Model.ProvisionedThroughputExceededException">
/// The request rate is too high, or the request is too large, for the available throughput
/// to accommodate. The AWS SDKs automatically retry requests that receive this exception;
/// therefore, your request will eventually succeed, unless the request is too large or
/// your retry queue is too large to finish. Reduce the frequency of requests by using
/// the strategies listed in <a href="http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ErrorHandling.html#APIRetries">Error
/// Retries and Exponential Backoff</a> in the <i>Amazon DynamoDB Developer Guide</i>.
/// </exception>
/// <exception cref="Amazon.DynamoDBv2.Model.ResourceNotFoundException">
/// The operation tried to access a nonexistent table or index. The resource might not
/// be specified correctly, or its status might not be <code>ACTIVE</code>.
/// </exception>
public GetItemResponse GetItem(string tableName, Dictionary<string, AttributeValue> key)
{
var request = new GetItemRequest();
request.TableName = tableName;
request.Key = key;
return GetItem(request);
}
/// <summary>
/// The <i>GetItem</i> operation returns a set of attributes for the item with the given
/// primary key. If there is no matching item, <i>GetItem</i> does not return any data.
///
///
/// <para>
/// <i>GetItem</i> provides an eventually consistent read by default. If your application
/// requires a strongly consistent read, set <i>ConsistentRead</i> to <code>true</code>.
/// Although a strongly consistent read might take more time than an eventually consistent
/// read, it always returns the last updated value.
/// </para>
/// </summary>
/// <param name="tableName">The name of the table containing the requested item.</param>
/// <param name="key">A map of attribute names to <i>AttributeValue</i> objects, representing the primary key of the item to retrieve. For the primary key, you must provide all of the attributes. For example, with a hash type primary key, you only need to provide the hash attribute. For a hash-and-range type primary key, you must provide both the hash attribute and the range attribute.</param>
/// <param name="consistentRead">Determines the read consistency model: If set to <code>true</code>, then the operation uses strongly consistent reads; otherwise, the operation uses eventually consistent reads.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
///
/// <returns>The response from the GetItem service method, as returned by DynamoDB.</returns>
/// <exception cref="Amazon.DynamoDBv2.Model.InternalServerErrorException">
/// An error occurred on the server side.
/// </exception>
/// <exception cref="Amazon.DynamoDBv2.Model.ProvisionedThroughputExceededException">
/// Your request rate is too high. The AWS SDKs for DynamoDB automatically retry requests
/// that receive this exception. Your request is eventually successful, unless your retry
/// queue is too large to finish. Reduce the frequency of requests and use exponential
/// backoff. For more information, go to <a href="http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ErrorHandling.html#APIRetries">Error
/// Retries and Exponential Backoff</a> in the <i>Amazon DynamoDB Developer Guide</i>.
/// </exception>
/// <exception cref="Amazon.DynamoDBv2.Model.ResourceNotFoundException">
/// The operation tried to access a nonexistent table or index. The resource might not
/// be specified correctly, or its status might not be <code>ACTIVE</code>.
/// </exception>
public Task<GetItemResponse> GetItemAsync(string tableName, Dictionary<string, AttributeValue> key, bool consistentRead, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var request = new GetItemRequest();
request.TableName = tableName;
request.Key = key;
request.ConsistentRead = consistentRead;
return GetItemAsync(request, cancellationToken);
}
internal GetItemResponse GetItem(GetItemRequest request)
{
var task = GetItemAsync(request);
try
{
return task.Result;
}
catch(AggregateException e)
{
ExceptionDispatchInfo.Capture(e.InnerException).Throw();
return null;
}
}
/// <summary>
/// Initiates the asynchronous execution of the GetItem operation.
/// <seealso cref="Amazon.DynamoDBv2.IAmazonDynamoDB"/>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the GetItem operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
public Task<GetItemResponse> GetItemAsync(GetItemRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new GetItemRequestMarshaller();
var unmarshaller = GetItemResponseUnmarshaller.Instance;
return InvokeAsync<GetItemRequest,GetItemResponse>(request, marshaller,
unmarshaller, cancellationToken);
}
/// <summary>
/// The <i>GetItem</i> operation returns a set of attributes for the item with the given
/// primary key. If there is no matching item, <i>GetItem</i> does not return any data.
///
///
/// <para>
/// <i>GetItem</i> provides an eventually consistent read by default. If your application
/// requires a strongly consistent read, set <i>ConsistentRead</i> to <code>true</code>.
/// Although a strongly consistent read might take more time than an eventually consistent
/// read, it always returns the last updated value.
/// </para>
/// </summary>
/// <param name="tableName">The name of the table containing the requested item.</param>
/// <param name="key">A map of attribute names to <i>AttributeValue</i> objects, representing the primary key of the item to retrieve. For the primary key, you must provide all of the attributes. For example, with a hash type primary key, you only need to provide the hash attribute. For a hash-and-range type primary key, you must provide both the hash attribute and the range attribute.</param>
/// <param name="consistentRead">A value that if set to <code>true</code>, then the operation uses strongly consistent reads; otherwise, eventually consistent reads are used.</param>
///
/// <returns>The response from the GetItem service method, as returned by DynamoDB.</returns>
/// <exception cref="Amazon.DynamoDBv2.Model.InternalServerErrorException">
/// An error occurred on the server side.
/// </exception>
/// <exception cref="Amazon.DynamoDBv2.Model.ProvisionedThroughputExceededException">
/// The request rate is too high, or the request is too large, for the available throughput
/// to accommodate. The AWS SDKs automatically retry requests that receive this exception;
/// therefore, your request will eventually succeed, unless the request is too large or
/// your retry queue is too large to finish. Reduce the frequency of requests by using
/// the strategies listed in <a href="http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ErrorHandling.html#APIRetries">Error
/// Retries and Exponential Backoff</a> in the <i>Amazon DynamoDB Developer Guide</i>.
/// </exception>
/// <exception cref="Amazon.DynamoDBv2.Model.ResourceNotFoundException">
/// The operation tried to access a nonexistent table or index. The resource might not
/// be specified correctly, or its status might not be <code>ACTIVE</code>.
/// </exception>
public void GetItemAsync(string tableName, Dictionary<string, AttributeValue> key, bool consistentRead, AmazonServiceCallback<GetItemRequest, GetItemResponse> callback, AsyncOptions options = null)
{
var request = new GetItemRequest();
request.TableName = tableName;
request.Key = key;
request.ConsistentRead = consistentRead;
GetItemAsync(request, callback, options);
}
public Dictionary<string, object> GetUser(string userID)
{
Dictionary<string, object> retval = new Dictionary<string, object>();
GetItemResponse response;
var config = new AmazonDynamoDBConfig();
config.ServiceURL = System.Configuration.ConfigurationManager.AppSettings["ServiceURL"];
client = new AmazonDynamoDBClient(config);
try
{
GetItemRequest request = new GetItemRequest
{
TableName = "User",
Key = new Dictionary<string, AttributeValue>() { { "UserID", new AttributeValue { S = userID } } },
ReturnConsumedCapacity = "TOTAL"
};
response = client.GetItem(request);
retval.Add("UserID", response.Item["UserID"].S);
retval.Add("HeadshotURL", response.Item["HeadshotURL"].S);
retval.Add("IsPayUser", Convert.ToBoolean(response.Item["IsPayUser"].S));
retval.Add("UserName", response.Item["UserName"].S);
retval.Add("RegistDate", response.Item["RegistDate"].N);
retval.Add("LastLoginDate", response.Item["LastLoginDate"].N);
retval.Add("LastSyncDate", response.Item["LastSyncDate"].N);
}
catch (AmazonDynamoDBException e) { Console.WriteLine(e.Message); }
catch (AmazonServiceException e) { Console.WriteLine(e.Message); }
catch (Exception e) { Console.WriteLine(e.Message); }
return retval;
}
/// <summary>
/// <para>The <i>GetItem</i> operation returns a set of attributes for the item with the given primary key. If there is no matching item,
/// <i>GetItem</i> does not return any data.</para> <para> <i>GetItem</i> provides an eventually consistent read by default. If your application
/// requires a strongly consistent read, set <i>ConsistentRead</i> to <c>true</c> . Although a strongly consistent read might take more time
/// than an eventually consistent read, it always returns the last updated value.</para>
/// </summary>
///
/// <param name="getItemRequest">Container for the necessary parameters to execute the GetItem service method on AmazonDynamoDBv2.</param>
///
/// <returns>The response from the GetItem service method, as returned by AmazonDynamoDBv2.</returns>
///
/// <exception cref="ResourceNotFoundException"/>
/// <exception cref="ProvisionedThroughputExceededException"/>
/// <exception cref="InternalServerErrorException"/>
public GetItemResponse GetItem(GetItemRequest getItemRequest)
{
IAsyncResult asyncResult = invokeGetItem(getItemRequest, null, null, true);
return EndGetItem(asyncResult);
}
internal Document GetItemHelper(Key key, GetItemOperationConfig config, bool isAsync)
{
var currentConfig = config ?? new GetItemOperationConfig();
var request = new GetItemRequest
{
TableName = TableName,
Key = key,
ConsistentRead = currentConfig.ConsistentRead
};
request.BeforeRequestEvent += isAsync ?
new RequestEventHandler(UserAgentRequestEventHandlerAsync) :
new RequestEventHandler(UserAgentRequestEventHandlerSync);
if (currentConfig.AttributesToGet != null)
request.WithAttributesToGet(currentConfig.AttributesToGet);
var result = DDBClient.GetItem(request);
var attributeMap = result.GetItemResult.Item;
if (attributeMap == null)
return null;
return Document.FromAttributeMap(attributeMap);
}
public void Get_item_with_AWSSDK()
{
db.PutItem(new Todo { Id = 1, Content = "TODO 1", Order = 1 });
var request = new GetItemRequest
{
TableName = "Todo",
Key = new Dictionary<string, AttributeValue> {
{ "Id", new AttributeValue { N = "1"} }
},
ConsistentRead = true,
};
var response = awsDb.GetItem(request);
var todo = new Todo
{
Id = Convert.ToInt64(response.Item["Id"].N),
Content = response.Item["Content"].S,
Order = Convert.ToInt32(response.Item["Order"].N),
Done = response.Item["Done"].BOOL,
};
todo.PrintDump();
}
/// <summary>
/// Initiates the asynchronous execution of the GetItem operation.
/// <seealso cref="Amazon.DynamoDBv2.IAmazonDynamoDB.GetItem"/>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the GetItem operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
public async Task<GetItemResponse> GetItemAsync(GetItemRequest request, CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new GetItemRequestMarshaller();
var unmarshaller = GetItemResponseUnmarshaller.GetInstance();
var response = await Invoke<IRequest, GetItemRequest, GetItemResponse>(request, marshaller, unmarshaller, signer, cancellationToken)
.ConfigureAwait(continueOnCapturedContext: false);
return response;
}
public void CRUDSamples()
{
EnsureTables();
PutSample();
{
#region GetItem Sample
// Create a client
AmazonDynamoDBClient client = new AmazonDynamoDBClient();
// Define item key
// Hash-key of the target item is string value "Mark Twain"
// Range-key of the target item is string value "The Adventures of Tom Sawyer"
Dictionary<string, AttributeValue> key = new Dictionary<string, AttributeValue>
{
{ "Author", new AttributeValue { S = "Mark Twain" } },
{ "Title", new AttributeValue { S = "The Adventures of Tom Sawyer" } }
};
// Create GetItem request
GetItemRequest request = new GetItemRequest
{
TableName = "SampleTable",
Key = key,
};
// Issue request
var result = client.GetItem(request);
// View response
Console.WriteLine("Item:");
Dictionary<string, AttributeValue> item = result.Item;
foreach (var keyValuePair in item)
{
Console.WriteLine("{0} : S={1}, N={2}, SS=[{3}], NS=[{4}]",
keyValuePair.Key,
keyValuePair.Value.S,
keyValuePair.Value.N,
string.Join(", ", keyValuePair.Value.SS ?? new List<string>()),
string.Join(", ", keyValuePair.Value.NS ?? new List<string>()));
}
#endregion
}
{
#region UpdateItem Sample
// Create a client
AmazonDynamoDBClient client = new AmazonDynamoDBClient();
// Define item key
// Hash-key of the target item is string value "Mark Twain"
// Range-key of the target item is string value "The Adventures of Tom Sawyer"
Dictionary<string, AttributeValue> key = new Dictionary<string, AttributeValue>
{
{ "Author", new AttributeValue { S = "Mark Twain" } },
{ "Title", new AttributeValue { S = "The Adventures of Tom Sawyer" } }
};
// Define attribute updates
Dictionary<string, AttributeValueUpdate> updates = new Dictionary<string, AttributeValueUpdate>();
// Update item's Setting attribute
updates["Setting"] = new AttributeValueUpdate()
{
Action = AttributeAction.PUT,
Value = new AttributeValue { S = "St. Petersburg, Missouri" }
};
// Remove item's Bibliography attribute
updates["Bibliography"] = new AttributeValueUpdate()
{
Action = AttributeAction.DELETE
};
// Add a new string to the item's Genres SS attribute
updates["Genres"] = new AttributeValueUpdate()
{
Action = AttributeAction.ADD,
Value = new AttributeValue { SS = new List<string> { "Bildungsroman" } }
};
// Create UpdateItem request
UpdateItemRequest request = new UpdateItemRequest
{
TableName = "SampleTable",
Key = key,
AttributeUpdates = updates
};
// Issue request
client.UpdateItem(request);
#endregion
}
{
#region DeleteItem Sample
// Create a client
AmazonDynamoDBClient client = new AmazonDynamoDBClient();
// Define item key
// Hash-key of the target item is string value "Mark Twain"
// Range-key of the target item is string value "The Adventures of Tom Sawyer"
Dictionary<string, AttributeValue> key = new Dictionary<string, AttributeValue>
{
{ "Author", new AttributeValue { S = "Mark Twain" } },
{ "Title", new AttributeValue { S = "The Adventures of Tom Sawyer" } }
};
// Create DeleteItem request
DeleteItemRequest request = new DeleteItemRequest
{
TableName = "SampleTable",
Key = key
};
// Issue request
client.DeleteItem(request);
#endregion
}
}
/// <summary>
/// Initiates the asynchronous execution of the GetItem operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the GetItem operation on AmazonDynamoDBClient.</param>
/// <param name="callback">An Action delegate that is invoked when the operation completes.</param>
/// <param name="options">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
public void GetItemAsync(GetItemRequest request, AmazonServiceCallback<GetItemRequest, GetItemResponse> callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var marshaller = new GetItemRequestMarshaller();
var unmarshaller = GetItemResponseUnmarshaller.Instance;
Action<AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult<GetItemRequest,GetItemResponse> responseObject
= new AmazonServiceResult<GetItemRequest,GetItemResponse>((GetItemRequest)req, (GetItemResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke<GetItemRequest>(request, marshaller, unmarshaller, options, callbackHelper);
}
internal GetItemResponse GetItem(GetItemRequest request)
{
var marshaller = new GetItemRequestMarshaller();
var unmarshaller = GetItemResponseUnmarshaller.Instance;
return Invoke<GetItemRequest,GetItemResponse>(request, marshaller, unmarshaller);
}
internal GetItemResponse GetItem(GetItemRequest request)
{
var task = GetItemAsync(request);
try
{
return task.Result;
}
catch(AggregateException e)
{
throw e.InnerException;
}
}
internal Document GetItemHelper(Key key, GetItemOperationConfig config, bool isAsync)
{
var currentConfig = config ?? new GetItemOperationConfig();
var request = new GetItemRequest
{
TableName = TableName,
Key = key,
ConsistentRead = currentConfig.ConsistentRead
};
((Amazon.Runtime.Internal.IAmazonWebServiceRequest)request).AddBeforeRequestHandler(isAsync ?
new RequestEventHandler(UserAgentRequestEventHandlerAsync) :
new RequestEventHandler(UserAgentRequestEventHandlerSync)
);
if (currentConfig.AttributesToGet != null)
request.AttributesToGet = currentConfig.AttributesToGet;
var result = DDBClient.GetItem(request);
var attributeMap = result.Item;
if (attributeMap == null || attributeMap.Count == 0)
return null;
return Document.FromAttributeMap(attributeMap);
}
/// <summary>
/// Initiates the asynchronous execution of the GetItem operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the GetItem operation on AmazonDynamoDBClient.</param>
/// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param>
/// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback
/// procedure using the AsyncState property.</param>
///
/// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetItem
/// operation.</returns>
public IAsyncResult BeginGetItem(GetItemRequest request, AsyncCallback callback, object state)
{
var marshaller = new GetItemRequestMarshaller();
var unmarshaller = GetItemResponseUnmarshaller.Instance;
return BeginInvoke<GetItemRequest>(request, marshaller, unmarshaller,
callback, state);
}
