C# how to use parameters reading different parts of a Json output?

Crown Clit

Hello. I will need assistance with figuring out how to use parameters to read a different part of a Json file output. My project involves getting a response from coinmarketcap api and getting coin price value. See below sample. This part works fine.

while(sqlReader.Read()) 
{
    dynamic jObj = JsonConvert.DeserializeObject(response);
    decimal jUSDPrice = jObj.data.BTC[0].quote.USD.price;                 
}

Now, my challenge is to use a parameter CoinCode instead of hardcoded BTC so every time sql reader reads new record it will pull our new coin price eg ETH,XRP etc.

How do I use a variable so it looks similar to below?

decimal jUSDPrice = jObj.data.CoinName[0].quote.USD.price;

Your help will be much appreciated.
CC

5 Replies

Know the answer? Post it — somebody with the same question will find it here.

Daniel Wright1y ago
Accepted answer
Certainly! You are on the right track by wanting to use a parameter to dynamically read different parts of a Json output based on the CoinCode provided. To achieve this in C#, you can use the following approach:
```
while (sqlReader.Read()) 
{
    dynamic jObj = JsonConvert.DeserializeObject(response);
    
    // Assuming CoinCode is a variable holding the coin's code like "ETH", "XRP", etc.
    string coinCode = sqlReader["CoinCode"].ToString(); // Assuming "CoinCode" is the column name from SQL Reader
    
    decimal jUSDPrice = jObj.data[coinCode][0].quote.USD.price;
}
```
In this code snippet:

1. We first retrieve the coin code from the SQL Reader assuming it is stored in a column named "CoinCode."

2. Then, we use this coin code dynamically to access the corresponding part of the Json output using `jObj.data[coinCode]`.

This way, every time the SQL Reader reads a new record, the `CoinCode` parameter will determine which coin's price value to extract from the Json output.

I hope this helps clarify how you can use parameters to read different parts of a Json output based on the CoinCode provided. Let me know if you need further assistance or more explanation!
0
Tuhin Paul1y ago
By using indexer syntax (jObj.data[coinCode]), you can dynamically access JSON properties based on a variable. This approach integrates seamlessly with your SQL reader and allows you to process multiple coin codes efficiently.
0

Tuhin Paul1y ago

Assume the JSON response from the CoinMarketCap API looks like this:

{
  "data": {
    "BTC": [
      {
        "quote": {
          "USD": {
            "price": 27000.50
          }
        }
      }
    ],
    "ETH": [
      {
        "quote": {
          "USD": {
            "price": 1800.75
          }
        }
      }
    ]
  }
}

For coinCode = "BTC", the code accesses jObj.data["BTC"][0].quote.USD.price.
For coinCode = "ETH", the code accesses jObj.data["ETH"][0].quote.USD.price.

Tuhin Paul1y ago
```
while (sqlReader.Read())
{
    // Assuming CoinCode is read from the SQL reader
    string coinCode = sqlReader["CoinCode"].ToString(); // Example: "BTC", "ETH", "XRP"

    // Deserialize the JSON response into a dynamic object
    dynamic jObj = JsonConvert.DeserializeObject(response);

    // Use the variable `coinCode` to dynamically access the JSON property
    decimal jUSDPrice = jObj.data[coinCode][0].quote.USD.price;

    // Output or process the price as needed
    Console.WriteLine($"The price of {coinCode} is {jUSDPrice}");
}
```
1. Dynamic Access with Indexer Syntax :
  
  The data object in your JSON is essentially a dictionary-like structure where keys are coin codes (e.g., "BTC", "ETH").
  
  Using jObj.data[coinCode] allows you to dynamically access the value associated with the key stored in the coinCode variable.
2. SQL Reader Integration :
  
  The sqlReader["CoinCode"] retrieves the coin code (e.g., "BTC", "ETH") from the current record in the SQL result set.
  
  This value is then used to fetch the corresponding price from the JSON response.
3. Deserialization :
  
  The JsonConvert.DeserializeObject(response) converts the JSON string into a dynamic object, enabling flexible access to its properties.
0
Tuhin Paul1y ago
To dynamically access a part of a JSON object using a variable (e.g., CoinCode), you can use indexer syntax in C#. This allows you to replace the hardcoded key (like "BTC") with a variable. Here's how you can modify your code to achieve this:
1. Use Indexer Syntax :
  
  Instead of hardcoding the key (BTC), you can use a variable (e.g., CoinCode) to dynamically access the corresponding part of the JSON object.
  
  In C#, dynamic objects allow you to use indexer syntax ([]) to access properties dynamically.
2. Modify Your Code :
  
  Replace the hardcoded key with a variable that changes for each record in your SQL reader.
0