C# .NET Core 3.1调用FitBit API如何处理两种返回对象类型？

Hey there! Let's break down how to tackle this scenario where the FitBit Sleep API can return either your SleepJSON object or a retry-focused meta response. Dynamic types can feel messy and error-prone here, so let's use a more reliable approach with Newtonsoft.Json's JObject to inspect the response first.

Step 1: Define Classes for Both Response Types #

You already have your SleepJSON class, so add these classes to handle the retry meta response:

public class MetaResponse
{
    public MetaDetails Meta { get; set; }
}

public class MetaDetails
{
    public int RetryDuration { get; set; }
    public string State { get; set; }
}

Step 2: Inspect the Raw JSON Before Deserializing #

Instead of jumping straight to deserializing into SleepJSON, grab the raw response string, parse it into a JObject, and check if it contains the "meta" key. This lets you branch your logic cleanly based on the response type:

using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System.Net;

// Assuming 'wc' is your WebClient instance
try
{
    var rawResponse = await wc.DownloadStringTaskAsync(url);
    var parsedResponse = JObject.Parse(rawResponse);

    // Check if we got a retry meta response
    if (parsedResponse.ContainsKey("meta"))
    {
        var retryInfo = parsedResponse.ToObject<MetaResponse>();
        // Handle retry logic here—e.g., wait and re-run the API call
        Console.WriteLine($"Pending request: Retry after {retryInfo.Meta.RetryDuration}ms");
        // Example: await Task.Delay(retryInfo.Meta.RetryDuration);
        // Then re-execute your API fetch logic
    }
    else
    {
        // It's the sleep data we want—deserialize into SleepJSON
        var sleepData = JsonConvert.DeserializeObject<SleepJSON>(rawResponse);
        // Process your sleep data here
    }
}
catch (WebException ex)
{
    // Handle network errors, unauthorized access, etc.
    Console.WriteLine($"API call failed: {ex.Message}");
}
catch (JsonException ex)
{
    // Handle invalid JSON format issues
    Console.WriteLine($"Failed to parse response: {ex.Message}");
}

Why This Beats Using Dynamic #

Dynamic types might seem quick, but they come with big downsides:

• No compile-time type checking, so typos in property names will cause runtime crashes.
• Checking for the "meta" property would require messy reflection or try-catch blocks when accessing properties.

Using JObject gives you a safe, structured way to inspect the response before committing to a specific type—no guesswork involved.

Bonus: Add Automated Retry Logic (Optional) #

Since the API can return a retry duration, you could wrap your API call in a retry loop (with a maximum retry count) to automatically handle pending states. This saves you from manually triggering retries every time you get a meta response.

内容的提问来源于stack exchange，提问作者bandworthy