# Dictionary Data-Structure

Links:\
[MSDN: Dictionary](https://docs.microsoft.com/en-us/dotnet/api/system.collections.generic.dictionary-2?redirectedfrom=MSDN\&view=netframework-4.7.2)

[Gitbook Definition and Examples](/cs2335/c-language/c_language/dictionary.md)

[Unity Scripting Tutorial: Dictionary ](https://unity3d.com/learn/tutorials/modules/intermediate/scripting/lists-and-dictionaries)

[Unity TextAdventure Tutorial - Use Dictionary Inventory](https://unity3d.com/learn/tutorials/topics/scripting/preparing-use-item-dictionary)

[Using Arrays, Lists, ArrayLists, Dictionaries, HashTable in Unity](https://hub.packtpub.com/arrays-lists-dictionaries-unity-3d-game-development/)

{% content-ref url="/pages/-M0-KZCV2xtQuema9\_om" %}
[Dictionary](/cs2335/c-language/c_language/dictionary.md)
{% endcontent-ref %}

## Dictionaries: A collection of Key,Value pairs

Dictionaries provide a data-structure for storing data that has 2 associated parts, which is very useful for data associated with games, such as inventory systems, character choice systems, weapon systems, etc.

The Key is used as a index to allow storage of a value that is associated with a unique Key. **Keys must be unique, there cannot be duplicate Keys** in a dictionary, so we must use care when adding new elements to a dictionary object to ensure that the item's key does not already exist in the dictionary. There are several methods that can be used to test for the presence of a specific key, these helper functions prevent runtime errors in our programs.

Unity does not show Dictionary elements in the inspector.

**Include as a directive at top of script:** **using System.Collections.Generic;**

Dictionary < TKey,TValue >\
Dictionary - you specify the data-type of the key: Tkey, and value: TValue.

When adding elements to a C# Dictionary, it is first necessary to **check to see if the key already exists in the dictionary. on**  .  If the key does not exist, then a new key,value pair are added using the C# Dictionary method:  Add( Tkey, TValue ) as in the code snippet below.

**C# Dictionary Add, Update operations:**  \
\
**ContainsKey( Tkey ):** Check to see if dictionary contains a given key ( previously added)

```
//check to see if the dictionary already has a given key
C# Dictionary ContainsKey(Tkey) returns a bool

if (choiceData.ContainsKey(choiceKey)) //check for given key
```

**Add ( Tkey, Tvalue)** If the key does not already exist in the dictionary:  using the Dictionary method: Add( Tkey, Tvalue) , then add the new key,value pair

```
//Add new key, value pair
choiceData.Add(choiceKey, choiceValue);
```

&#x20;**Update key,value pair:**  If the key exists, then use the key within brackets \[ Tkey ] to modify the value associated with the key.

```
//modify, update the value associated with choiceKey
choiceData[choiceKey] = choiceValue;  
```

**Getting a key,value pair:** C# provides a convenient method: **TryGetValue( )** that allows checking to see if a key exists, and which also returns the associated key.  The method TryGetValue uses a new type of method parameter, which is specified as an **out parameter.**  The  variable used as the out parameter must be declared prior to calling the method, then passed as a parameter, when the method returns, the out parameter will contain the key's associated value.  If the key does not exist, then the out parameter's value remains unchanged.  This can also be used when trying to add a key,value pair.

```java
        string choiceValue = "None"; //declare out variable
        choiceData.TryGetValue(choiceKey, out choiceValue); 
        //choiceValue will either have value of "None" or the value associated with the key
        Debug.Log("Choice Data Accessed" + choiceKey + " : " + choiceValue);
       
```

**TryGetValue( Tkey, out  Tvalue)** is also useful when adding or updating key,value pairs.

```java
string choiceValue = "NewValue";
if( choiceData.TryGetValue( choiceKey,out choiceValue){
  choiceData[choiceKey] = choiceValue;  //key exists, update value
  } 
  else{
    choiceData.Add(choiceKey, choiceValue); //add new key,value pair
  }
```

## Simple Dictionary Examples:

### GameData C# Dictionary< string, string >  choiceData

The code below shows declaration of a private C# Dictionary< string, string> choiceData, where both the key and the value are of type string.  The methods:  SaveChoice and GetChoice  provides ability to save and access data. &#x20;

```
 //Add to GameData Variables
 
 private Dictionary<string,string> choiceData = new Dictionary< string,string>();
   
 // Add to GameData Methods
    
 public void SaveChoice( string choiceKey, string choiceValue)
    {

        if (choiceData.ContainsKey(choiceKey))
        {
            choiceData[choiceKey] = choiceValue; //change stored value
            Debug.Log("Choice Changed" + choiceKey + " : " + choiceValue);
        }
        else
        {
            choiceData.Add(choiceKey, choiceValue); //adds key,value pair
            Debug.Log("Choice Data Created" + choiceKey + " : " + choiceValue);
        }
    }

    public string GetChoice( string choiceKey)
    {
        string choiceValue = "None";
        choiceData.TryGetValue(choiceKey, out choiceValue);
        Debug.Log("Choice Data Accessed" + choiceKey + " : " + choiceValue);
        return choiceValue;
    }
```

### TKey:  PickupType, enum type of Pickup objects

### TValue: int, count of number of items

```java
public Dictionary<PickupType, int> inventory_v1 = new Dictionary<PickupType, int>(); //initialize

inventory_v1.Add(PickupType.Gem, 1); //add an item
int gems = inventory_v1[PickupType.Gem]; //get value associated with key

inventory_v1[PickupType.Gem] = 2; //change an item

if( inventory_v1.ContainsKey( PickupType.Cow ){
  int count = inventory_v1[PickupType.Cow]
  inventory_v1[PickupType.Cow] = count +1;
}else{
   Debug.Log("No Cows")
   inventory_v1.Add( PickupType.Cow, 1); //added
}

//TryGetValue
int count = 0;
if( inventory_v1.TryGetValue( PickupType.Gem,out count){
  inventory_v1[PickupType.Gem] = count + 1;
  } 
  else{
    inventory_v1.Add(PickupType.Gem ,1);
  }
```

###


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://kdoore.gitbook.io/cs2335/overview-branchlogic/dictionary-data-structure.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
