Exemples de données Obtention d'un élément unique à l'aide de sa clé primaire et d'expressions Obtention de plusieurs éléments à l'aide de la clé primaire de la table et d'expressions Obtenir plusieurs éléments par l'intermédiaire d'expressions et d'autres attributs d'élément Imprimer un élément Créer ou remplacer un élément à l'aide d'expressions Mettre à jour un élément à l'aide d'expressions Supprimer un élément à l'aide d'expressions Plus d'informations

Utilisation d'expressions avec Amazon DynamoDB et AWS SDK for .NET

Note

Les informations contenues dans cette rubrique sont spécifiques aux projets basés sur. NETFramework et AWS SDK for .NET versions 3.3 et antérieures.

Les exemples de code suivants montrent comment utiliser le AWS SDK for .NET pour programmer DynamoDB avec des expressions. Les expressions indiquent les attributs que vous souhaitez lire à partir d'un élément d'une table DynamoDB. Vous utilisez également des expressions lors de l'écriture d'un élément, pour signaler toutes les conditions qui doivent être satisfaites (aussi appelées mise à jour conditionnelle) et pour indiquer comment les attributs doivent être mis à jour. Des exemples de mise à jour remplacent l'attribut par une nouvelle valeur, ou ajoutent de nouvelles données à une liste ou une carte. Pour plus d'informations, consultez Lecture et écriture d'éléments à l'aide d'expressions.

Rubriques

Exemples de données
Obtention d'un élément unique à l'aide de sa clé primaire et d'expressions
Obtention de plusieurs éléments à l'aide de la clé primaire de la table et d'expressions
Obtenir plusieurs éléments par l'intermédiaire d'expressions et d'autres attributs d'élément
Imprimer un élément
Créer ou remplacer un élément à l'aide d'expressions
Mettre à jour un élément à l'aide d'expressions
Supprimer un élément à l'aide d'expressions
Plus d'informations

Exemples de données

Les exemples de code présentés dans cette rubrique s'appuient sur les deux exemples d'éléments suivants d'une table DynamoDB nommée. ProductCatalog Ces éléments décrivent des informations sur les entrées de produit dans un catalogue de magasin de cycles fictif. Ces éléments sont basés sur l'exemple fourni dans Case Study : A ProductCatalog Item. Les descripteurs de type de données tels que BOOLL,M,N,NS,S, et SS correspondent à ceux du format de JSON données.


{
  "Id": {
    "N": "205"
  },
  "Title": {
    "S": "20-Bicycle 205"
  },
  "Description": {
    "S": "205 description"
  },
  "BicycleType": {
    "S": "Hybrid"
  },
  "Brand": {
    "S": "Brand-Company C"
  },
  "Price": {
    "N": "500"
  },
  "Gender": {
    "S": "B"
  },
  "Color": {
    "SS": [
      "Red",
      "Black"
    ]
  },
  "ProductCategory": {
    "S": "Bike"
  },
  "InStock": {
    "BOOL": true
  },
  "QuantityOnHand": {
    "N": "1"
  },
  "RelatedItems": {
    "NS": [
      "341",
      "472",
      "649"
    ]
  },
  "Pictures": {
    "L": [
      {
        "M": {
          "FrontView": {
            "S": "http://example/products/205_front.jpg"
          }
        }
      },
      {
        "M": {
          "RearView": {
            "S": "http://example/products/205_rear.jpg"
          }
        }
      },
      {
        "M": {
          "SideView": {
            "S": "http://example/products/205_left_side.jpg"
          }
        }
      }
    ]
  },
  "ProductReviews": {
    "M": {
      "FiveStar": {
        "SS": [
          "Excellent! Can't recommend it highly enough! Buy it!",
          "Do yourself a favor and buy this."
        ]
      },
      "OneStar": {
        "SS": [
          "Terrible product! Do not buy this."
        ]
      }
    }
  }
},
{
  "Id": {
    "N": "301"
  },
  "Title": {
    "S": "18-Bicycle 301"
  },
  "Description": {
    "S": "301 description"
  },
  "BicycleType": {
    "S": "Road"
  },
  "Brand": {
    "S": "Brand-Company C"
  },
  "Price": {
    "N": "185"
  },
  "Gender": {
    "S": "F"
  },
  "Color": {
    "SS": [
      "Blue",
      "Silver"
    ]
  },
  "ProductCategory": {
    "S": "Bike"
  },
  "InStock": {
    "BOOL": true
  },
  "QuantityOnHand": {
    "N": "3"
  },
  "RelatedItems": {
    "NS": [
      "801",
      "822",
      "979"
    ]
  },
  "Pictures": {
    "L": [
      {
        "M": {
          "FrontView": {
            "S": "http://example/products/301_front.jpg"
          }
        }
      },
      {
        "M": {
          "RearView": {
            "S": "http://example/products/301_rear.jpg"
          }
        }
      },
      {
        "M": {
          "SideView": {
            "S": "http://example/products/301_left_side.jpg"
          }
        }
      }
    ]
  },
  "ProductReviews": {
    "M": {
      "FiveStar": {
        "SS": [
          "My daughter really enjoyed this bike!"
        ]
      },
      "ThreeStar": {
        "SS": [
          "This bike was okay, but I would have preferred it in my color.",
	      "Fun to ride."
        ]
      }
    }
  }
}

Obtention d'un élément unique à l'aide de sa clé primaire et d'expressions

L'exemple suivant présente la méthode Amazon.DynamoDBv2.AmazonDynamoDBClient.GetItem et un jeu d'expressions pour obtenir, puis imprimer, l'élément pour lequel Id est égal à 205. Seuls les attributs suivants de l'élément sont renvoyés : Id, Title, Description, Color, RelatedItems, Pictures et ProductReviews.


// using Amazon.DynamoDBv2;
// using Amazon.DynamoDBv2.Model;

var client = new AmazonDynamoDBClient();
var request = new GetItemRequest
{
  TableName = "ProductCatalog",
  ProjectionExpression = "Id, Title, Description, Color, #ri, Pictures, #pr",
  ExpressionAttributeNames = new Dictionary<string, string>
  {
    { "#pr", "ProductReviews" },
    { "#ri", "RelatedItems" }
  },
  Key = new Dictionary<string, AttributeValue>
  {
    { "Id", new AttributeValue { N = "205" } }
  },
};
var response = client.GetItem(request);

// PrintItem() is a custom function.
PrintItem(response.Item);

Obtention de plusieurs éléments à l'aide de la clé primaire de la table et d'expressions

Les exemples suivants présentent la méthode Amazon.DynamoDBv2.AmazonDynamoDBClient.Query et un jeu d'expressions pour obtenir, puis imprimer, l'élément pour lequel Id est égal à 301, mais uniquement si la valeur de Price est supérieure à 150. Seuls les attributs suivants de l'élément sont renvoyés : Id, Title et l'ensemble des attributs ThreeStar dans ProductReviews.


// using Amazon.DynamoDBv2;
// using Amazon.DynamoDBv2.Model;

var client = new AmazonDynamoDBClient();
var request = new QueryRequest
{
  TableName = "ProductCatalog",
  KeyConditions = new Dictionary<string,Condition>
  {
    { "Id", new Condition()
      {
        ComparisonOperator = ComparisonOperator.EQ,
        AttributeValueList = new List<AttributeValue>
        {
          new AttributeValue { N = "301" }
        }
      }
    }
  },
  ProjectionExpression = "Id, Title, #pr.ThreeStar",
  ExpressionAttributeNames = new Dictionary<string, string>
  {
    { "#pr", "ProductReviews" },
    { "#p", "Price" }
  },
  ExpressionAttributeValues = new Dictionary<string,AttributeValue>
  {
    { ":val", new AttributeValue { N = "150" } }
  },
  FilterExpression = "#p > :val"
};
var response = client.Query(request);

foreach (var item in response.Items)
{
  // Write out the first page of an item's attribute keys and values.
  // PrintItem() is a custom function.
  PrintItem(item);
  Console.WriteLine("=====");
}

Dans l'exemple précédent, la propriété ProjectionExpression spécifie l'attribut à renvoyer. La propriété ExpressionAttributeNames spécifie l'espace réservé #pr pour représenter l'attribut ProductReviews et l'espace réservé #p pour représenter l'attribut Price. #pr.ThreeStar spécifie de retourner uniquement l'attribut ThreeStar. La propriété ExpressionAttributeValues spécifie l'espace réservé :val pour représenter la valeur 150. La propriété FilterExpression spécifie que #p (Price) doit être supérieur à :val (150). L'appel à PrintItem fait référence à une fonction personnalisée, comme décrit dans Imprimer un élément.

Obtenir plusieurs éléments par l'intermédiaire d'expressions et d'autres attributs d'élément

L'exemple suivant présente la méthode Amazon.DynamoDBv2.AmazonDynamoDBClient.Scan et un jeu d'expressions pour obtenir, puis imprimer, l'ensemble des éléments pour lesquels ProductCategory est égal à Bike. Seuls les attributs suivants de l'élément sont renvoyés : Id, Title et l'ensemble des attributs dans ProductReviews.


// using Amazon.DynamoDBv2;
// using Amazon.DynamoDBv2.Model;

var client = new AmazonDynamoDBClient();
var request = new ScanRequest
{
  TableName = "ProductCatalog",
  ProjectionExpression = "Id, Title, #pr",
  ExpressionAttributeValues = new Dictionary<string,AttributeValue>
  {
    { ":catg", new AttributeValue { S = "Bike" } }
  },
  ExpressionAttributeNames = new Dictionary<string, string>
  {
    { "#pr", "ProductReviews" },
    { "#pc", "ProductCategory" }
  },
  FilterExpression = "#pc = :catg",  
};
var response = client.Scan(request);

foreach (var item in response.Items)
{
  // Write out the first page/scan of an item's attribute keys and values.
  // PrintItem() is a custom function.
  PrintItem(item);
  Console.WriteLine("=====");
}

Dans l'exemple précédent, la propriété ProjectionExpression spécifie l'attribut à renvoyer. La propriété ExpressionAttributeNames spécifie l'espace réservé #pr pour représenter l'attribut ProductReviews et l'espace réservé #pc pour représenter l'attribut ProductCategory. La propriété ExpressionAttributeValues spécifie l'espace réservé :catg pour représenter la valeur Bike. La propriété FilterExpression spécifie que #pc (ProductCategory) doit être égal à :catg (Bike). L'appel à PrintItem fait référence à une fonction personnalisée, comme décrit dans Imprimer un élément.

Imprimer un élément

L'exemple suivant présente comment imprimer les attributs et les valeurs d'un élément. Cet exemple est utilisé dans les exemples précédents qui montrent comment Obtention d'un élément unique à l'aide de sa clé primaire et d'expressions, Obtention de plusieurs éléments à l'aide de la clé primaire de la table et d'expressions et Obtention de plusieurs éléments à l'aide d'expressions et d'autres attributs d'élément.


// using Amazon.DynamoDBv2.Model;

// Writes out an item's attribute keys and values.
public static void PrintItem(Dictionary<string, AttributeValue> attrs)
{
  foreach (KeyValuePair<string, AttributeValue> kvp in attrs)
  {
    Console.Write(kvp.Key + " = ");
    PrintValue(kvp.Value);
  }
}

// Writes out just an attribute's value.
public static void PrintValue(AttributeValue value)
{
  // Binary attribute value.
  if (value.B != null)
  {
    Console.Write("Binary data");
  }
  // Binary set attribute value.
  else if (value.BS.Count > 0)
  {
    foreach (var bValue in value.BS)
    {
      Console.Write("\n  Binary data");
    }
  }
  // List attribute value.
  else if (value.L.Count > 0)
  {
    foreach (AttributeValue attr in value.L)
    {
      PrintValue(attr);
    }
  }
  // Map attribute value.
  else if (value.M.Count > 0)
  {
    Console.Write("\n");
    PrintItem(value.M);
  }
  // Number attribute value.
  else if (value.N != null)
  {
    Console.Write(value.N);
  }
  // Number set attribute value.
  else if (value.NS.Count > 0)
  {
    Console.Write("{0}", string.Join("\n", value.NS.ToArray()));
  }
  // Null attribute value.
  else if (value.NULL)
  {
    Console.Write("Null");
  }
  // String attribute value.
  else if (value.S != null)
  {
    Console.Write(value.S);
  }
  // String set attribute value.
  else if (value.SS.Count > 0)
  {
    Console.Write("{0}", string.Join("\n", value.SS.ToArray()));
  }
  // Otherwise, boolean value.
  else
  {
    Console.Write(value.BOOL);
  }
 
  Console.Write("\n");
}

Dans l'exemple précédent, chaque valeur d'attribut possède plusieurs data-type-specific propriétés qui peuvent être évaluées afin de déterminer le format correct pour imprimer l'attribut. Ces propriétés incluentB,BOOL,BS,L,M,N,NS, NULLS, etSS, qui correspondent à celles du format de JSON données. Pour des propriétés telles que B, N, NULL et S, si la propriété correspondante n'est pas null, l'attribut est du type de données non null correspondant. Pour les propriétés telles que BSL,M,NS, etSS, si la valeur Count est supérieure à zéro, l'attribut est du type de non-zero-value données correspondant. Si toutes les data-type-specific propriétés de l'attribut sont égales à zéro null ou sont Count égales à zéro, l'attribut correspond au type de BOOL données.

Créer ou remplacer un élément à l'aide d'expressions

L'exemple suivant présente la méthode Amazon.DynamoDBv2.AmazonDynamoDBClient.PutItem et un jeu d'expressions pour mettre à jour l'élément pour lequel Title est 18-Bicycle 301. Si cet élément n'existe pas déjà, un nouvel élément est ajouté.


// using Amazon.DynamoDBv2;
// using Amazon.DynamoDBv2.Model;

var client = new AmazonDynamoDBClient();
var request = new PutItemRequest
{
  TableName = "ProductCatalog",
  ExpressionAttributeNames = new Dictionary<string, string>
  {
    { "#title", "Title" }
  },
  ExpressionAttributeValues = new Dictionary<string, AttributeValue>
  {
    { ":product", new AttributeValue { S = "18-Bicycle 301" } }
  },
  ConditionExpression = "#title = :product", 
  // CreateItemData() is a custom function.
  Item = CreateItemData()
};
client.PutItem(request);

Dans l'exemple précédent, la propriété ExpressionAttributeNames spécifie l'espace réservé #title pour représenter l'attribut Title. La propriété ExpressionAttributeValues spécifie l'espace réservé :product pour représenter la valeur 18-Bicycle 301. La propriété ConditionExpression spécifie que #title (Title) doit être égal à :product (18-Bicycle 301). L'appel à CreateItemData fait référence à la fonction personnalisée suivante :


// using Amazon.DynamoDBv2.Model;

// Provides a sample item that can be added to a table.
public static Dictionary<string, AttributeValue> CreateItemData()
{
  var itemData = new Dictionary<string, AttributeValue>
  {
    { "Id", new AttributeValue { N = "301" } },
    { "Title", new AttributeValue { S = "18\" Girl's Bike" } },
    { "BicycleType", new AttributeValue { S = "Road" } },
    { "Brand" , new AttributeValue { S = "Brand-Company C" } },
    { "Color", new AttributeValue { SS = new List<string>{ "Blue", "Silver" } } },
    { "Description", new AttributeValue { S = "301 description" } },
    { "Gender", new AttributeValue { S = "F" } },
    { "InStock", new AttributeValue { BOOL = true } },
    { "Pictures", new AttributeValue { L = new List<AttributeValue>{ 
      { new AttributeValue { M = new Dictionary<string,AttributeValue>{
        { "FrontView", new AttributeValue { S = "http://example/products/301_front.jpg" } } } } },
      { new AttributeValue { M = new Dictionary<string,AttributeValue>{
        { "RearView", new AttributeValue {S = "http://example/products/301_rear.jpg" } } } } },
      { new AttributeValue { M = new Dictionary<string,AttributeValue>{
        { "SideView", new AttributeValue { S = "http://example/products/301_left_side.jpg" } } } } }
    } } },
    { "Price", new AttributeValue { N = "185" } },
    { "ProductCategory", new AttributeValue { S = "Bike" } },
    { "ProductReviews", new AttributeValue { M = new Dictionary<string,AttributeValue>{
      { "FiveStar", new AttributeValue { SS = new List<string>{
        "My daughter really enjoyed this bike!" } } },
      { "OneStar", new AttributeValue { SS = new List<string>{
        "Fun to ride.",
        "This bike was okay, but I would have preferred it in my color." } } }
    } } },
    { "QuantityOnHand", new AttributeValue { N = "3" } },
    { "RelatedItems", new AttributeValue { NS = new List<string>{ "979", "822", "801" } } }
  };

  return itemData;
}

Dans l'exemple précédent, un exemple d'élément avec des exemples de données est renvoyé au mandataire. Une série d'attributs et de valeurs correspondantes sont construits à l'aide de types de données tels que BOOL LM,N,NS,S,, etSS, qui correspondent à ceux du format de JSON données.

Mettre à jour un élément à l'aide d'expressions

L'exemple suivant présente la méthode Amazon.DynamoDBv2.AmazonDynamoDBClient.UpdateItem et un jeu d'expressions pour modifier Title en 18" Girl's Bike pour l'élément pour lequel Id est égal à 301.


// using Amazon.DynamoDBv2;
// using Amazon.DynamoDBv2.Model;

var client = new AmazonDynamoDBClient();
var request = new UpdateItemRequest
{
  TableName = "ProductCatalog",
  Key = new Dictionary<string,AttributeValue>
  {
     { "Id", new AttributeValue { N = "301" } }
  },
  ExpressionAttributeNames = new Dictionary<string, string>
  {
    { "#title", "Title" }
  },
  ExpressionAttributeValues = new Dictionary<string, AttributeValue>
  {
    { ":newproduct", new AttributeValue { S = "18\" Girl's Bike" } }
  },
  UpdateExpression = "SET #title = :newproduct"
};
client.UpdateItem(request);

Dans l'exemple précédent, la propriété ExpressionAttributeNames spécifie l'espace réservé #title pour représenter l'attribut Title. La propriété ExpressionAttributeValues spécifie l'espace réservé :newproduct pour représenter la valeur 18" Girl's Bike. La propriété UpdateExpression spécifie de modifier #title (Title) en :newproduct (18" Girl's Bike).

Supprimer un élément à l'aide d'expressions

L'exemple suivant présente la méthode Amazon.DynamoDBv2.AmazonDynamoDBClient.DeleteItem et un jeu d'expressions pour supprimer les éléments pour lesquels Id est égal à 301 et Title est égal à 18-Bicycle 301.


// using Amazon.DynamoDBv2;
// using Amazon.DynamoDBv2.Model;

var client = new AmazonDynamoDBClient();
var request = new DeleteItemRequest
{
  TableName = "ProductCatalog",
  Key = new Dictionary<string,AttributeValue>
  {
     { "Id", new AttributeValue { N = "301" } }
  },
  ExpressionAttributeNames = new Dictionary<string, string>
  {
    { "#title", "Title" }
  },
  ExpressionAttributeValues = new Dictionary<string, AttributeValue>
  {
    { ":product", new AttributeValue { S = "18-Bicycle 301" } }
  },
  ConditionExpression = "#title = :product"
};
client.DeleteItem(request);

Plus d'informations

Pour plus d'informations et des exemples de code, consultez :

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

DynamoDB

JSONsoutien