using System;

using System.Collections;

using System.Collections.Generic;

using System.IO;

using System.Linq;

using Newtonsoft.Json;

​

public class Program

{

    public static void Main()

    {

        var dictionaryJson = @"{ 'foo': '1', 'bar': '2' }";

        var errorJson = @"{ 'error': 'blah' }";

​

        var serializer = new JsonSerializer();

​

        using (var stringReader = new StringReader(dictionaryJson))

        using (var jsonTextReader = new JsonTextReader(stringReader))

        {

            var dictionaryResponse = serializer.Deserialize<DictionaryResponse<string>>(jsonTextReader);

            Console.WriteLine(dictionaryResponse); // [foo, 1] [bar, 2]

        }

​

        Console.WriteLine();

​

        using (var stringReader = new StringReader(errorJson))

        using (var jsonTextReader = new JsonTextReader(stringReader))

        {

            var dictionaryResponse = serializer.Deserialize<DictionaryResponse<string>>(jsonTextReader);

            Console.WriteLine(dictionaryResponse); // [error, blah]

        }

    }

}

​

internal class ResponseBase

{

    [JsonProperty("error")]

    public string Error { get; set; }

}

​

internal sealed class DictionaryResponse<T> : ResponseBase, IDictionary<string, T>

{

    private readonly IDictionary<string, T> _dictionaryImplementation = new Dictionary<string, T>();

​

    #region IDictionary impl

​

    public IEnumerator<KeyValuePair<string, T>> GetEnumerator()

    {

        return _dictionaryImplementation.GetEnumerator();

    }

​

    IEnumerator IEnumerable.GetEnumerator()

    {

        return ((IEnumerable)_dictionaryImplementation).GetEnumerator();

    }

​

    public void Add(KeyValuePair<string, T> item)

    {

        _dictionaryImplementation.Add(item);

    }

​

    public void Clear()

    {

        _dictionaryImplementation.Clear();

    }

​

    public bool Contains(KeyValuePair<string, T> item)

    {

        return _dictionaryImplementation.Contains(item);

    }

​

    public void CopyTo(KeyValuePair<string, T>[] array, int arrayIndex)

    {

        _dictionaryImplementation.CopyTo(array, arrayIndex);

    }

​

    public bool Remove(KeyValuePair<string, T> item)

    {

        return _dictionaryImplementation.Remove(item);

    }

​

    public int Count { get { return _dictionaryImplementation.Count; } }

​

    public bool IsReadOnly { get { return _dictionaryImplementation.IsReadOnly; } }

​

    public bool ContainsKey(string key)

    {

        return _dictionaryImplementation.ContainsKey(key);

    }

​

    public void Add(string key, T value)

    {

        _dictionaryImplementation.Add(key, value);

    }

​

    public bool Remove(string key)

    {

        return _dictionaryImplementation.Remove(key);

    }

​

    public bool TryGetValue(string key, out T value)

    {

        return _dictionaryImplementation.TryGetValue(key, out value);

    }

​

    public T this[string key]

    {

        get { return _dictionaryImplementation[key]; }

        set { _dictionaryImplementation[key] = value; }

    }

​

    public ICollection<string> Keys { get { return _dictionaryImplementation.Keys; } }

​

    public ICollection<T> Values { get { return _dictionaryImplementation.Values; } }

​

    public override string ToString()

    {

        return Error != null ?

            "Error is " + Error :

            string.Join(Environment.NewLine, _dictionaryImplementation.Select(kvp => kvp.ToString()));

    }

​

    #endregion

}