как преобразовать NameValueCollection в строку JSON?

Я старался:

  NameValueCollection Data = new NameValueCollection();
  Data.Add("foo","baa");
  string json = new JavaScriptSerializer().Serialize(Data);

он возвращает: ["foo"] Я ожидал {"foo" : "baa"} Как мне это сделать?

The Mask 09.08.2011 источник

Ответы (4)

arrow_upward
40
arrow_downward

NameValueCollection не является IDictionary, поэтому JavaScriptSerializer не может сериализовать его напрямую, как вы ожидаете. Вам нужно будет сначала преобразовать его в словарь, а затем сериализовать.

Обновление: после вопросов о нескольких значениях для ключа вызов nvc[key] просто вернет их через запятую, что может быть допустимо. Если нет, всегда можно вызвать GetValues и решить, что делать со значениями соответствующим образом. Обновлен код ниже, чтобы показать один из возможных способов.

public class StackOverflow_7003740
{
    static Dictionary<string, object> NvcToDictionary(NameValueCollection nvc, bool handleMultipleValuesPerKey)
    {
        var result = new Dictionary<string, object>();
        foreach (string key in nvc.Keys)
        {
            if (handleMultipleValuesPerKey)
            {
                string[] values = nvc.GetValues(key);
                if (values.Length == 1)
                {
                    result.Add(key, values[0]);
                }
                else
                {
                    result.Add(key, values);
                }
            }
            else
            {
                result.Add(key, nvc[key]);
            }
        }

        return result;
    }

    public static void Test()
    {
        NameValueCollection nvc = new NameValueCollection();
        nvc.Add("foo", "bar");
        nvc.Add("multiple", "first");
        nvc.Add("multiple", "second");

        foreach (var handleMultipleValuesPerKey in new bool[] { false, true })
        {
            if (handleMultipleValuesPerKey)
            {
                Console.WriteLine("Using special handling for multiple values per key");
            }
            var dict = NvcToDictionary(nvc, handleMultipleValuesPerKey);
            string json = new JavaScriptSerializer().Serialize(dict);
            Console.WriteLine(json);
            Console.WriteLine();
        }
    }
}

carlosfigueira 09.08.2011

comment

NameValueCollection может иметь несколько значений для каждого ключа, это не решает эту проблему. - zzzzBov; 16.04.2013

comment

Этот метод, скорее всего, вызовет исключения! Причина, по которой существует NameValueCollection (и .NET иногда не использует словарь), заключается в том, чтобы разрешить несколько значений для каждого ключа. Для словаря требуется один и только один ключ для каждого значения. - John Culviner; 08.07.2013

comment

Метод не будет генерировать исключение. Если есть несколько ключей, nvc[key] просто вернет их, соединенные символом ,. Но для полноты картины я обновил ответ, чтобы он был более подробным. - carlosfigueira; 08.07.2013

comment

Если строка запроса не была преобразована в NameValueCollection, это работает: string" title="как преобразовать строку запроса в строку json"> stackoverflow.com/questions/12428947/ - sobelito; 30.08.2013

comment

DotNetFiddle: Несколько ключей в NameValueCollection dotnetfiddle.net/hnYwGn - Rodrigo Groener; 23.12.2015

arrow_upward
54
arrow_downward

Один из способов сериализации NameValueCollection — сначала преобразовать его в словарь, а затем сериализовать словарь. Чтобы преобразовать в словарь:

thenvc.AllKeys.ToDictionary(k => k, k => thenvc[k]);

Если вам нужно часто выполнять преобразование, вы также можете создать метод расширения для NameValueCollection:

public static class NVCExtender
{
    public static IDictionary<string, string> ToDictionary(
                                        this NameValueCollection source)
    {
        return source.AllKeys.ToDictionary(k => k, k => source[k]);
    }
}

поэтому вы можете сделать преобразование в одну строку следующим образом:

NameValueCollection Data = new NameValueCollection();
Data.Add("Foo", "baa");

var dict = Data.ToDictionary();

Затем вы можете сериализовать словарь:

var json = new JavaScriptSerializer().Serialize(dict);
// you get {"Foo":"baa"}

Но NameValueCollection может иметь несколько значений для одного ключа, например:

NameValueCollection Data = new NameValueCollection();
Data.Add("Foo", "baa");
Data.Add("Foo", "again?");

Если вы сериализуете это, вы получите {"Foo":"baa,again?"}.

Вместо этого вы можете изменить конвертер, чтобы он производил IDictionary<string, string[]>:

public static IDictionary<string, string[]> ToDictionary(
                                    this NameValueCollection source)
{
    return source.AllKeys.ToDictionary(k => k, k => source.GetValues(k));
}

Таким образом, вы можете получить сериализованное значение следующим образом: {"Foo":["baa","again?"]}.

Endy Tjahjono 16.03.2013

arrow_upward
3
arrow_downward

Если ваш словарь не предназначен для большого количества статей, вы можете использовать класс: System.Collections.Specialized.ListDictionary

groch 22.11.2011

arrow_upward
1
arrow_downward

Для полноты картины и поскольку вопрос продолжает задаваться (например, здесь), пока вы используя Json.NET или DataContractJsonSerializer (но не JavaScriptSerializer), вы можете использовать шаблон адаптера и оберните NameValueCollection адаптером IDictionary<string, string[]> и сериализуйте его с помощью любого сериализатора, который полностью поддерживает сериализацию произвольных словарей.

Раз такой переходник выглядит следующим образом:

public class NameValueCollectionDictionaryAdapter<TNameValueCollection> : IDictionary<string, string[]>
    where TNameValueCollection : NameValueCollection, new()
{
    readonly TNameValueCollection collection;

    public NameValueCollectionDictionaryAdapter() : this(new TNameValueCollection()) { }

    public NameValueCollectionDictionaryAdapter(TNameValueCollection collection)
    {
        this.collection = collection;
    }

    // Method instead of a property to guarantee that nobody tries to serialize it.
    public TNameValueCollection GetCollection() { return collection; }

    #region IDictionary<string,string[]> Members

    public void Add(string key, string[] value)
    {
        if (collection.GetValues(key) != null)
            throw new ArgumentException("Duplicate key " + key);
        if (value == null)
            collection.Add(key, null);
        else
            foreach (var str in value)
                collection.Add(key, str);
    }

    public bool ContainsKey(string key) { return collection.GetValues(key) != null; }

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

    public bool Remove(string key)
    {
        bool found = ContainsKey(key);
        if (found)
            collection.Remove(key);
        return found;
    }

    public bool TryGetValue(string key, out string[] value)
    {
        return (value = collection.GetValues(key)) != null;
    }

    public ICollection<string[]> Values
    {
        get
        {
            return new ReadOnlyCollectionAdapter<KeyValuePair<string, string[]>, string[]>(this, p => p.Value);
        }
    }

    public string[] this[string key]
    {
        get
        {
            var value = collection.GetValues(key);
            if (value == null)
                throw new KeyNotFoundException(key);
            return value;
        }
        set
        {
            Remove(key);
            Add(key, value);
        }
    }

    #endregion

    #region ICollection<KeyValuePair<string,string[]>> Members

    public void Add(KeyValuePair<string, string[]> item) { Add(item.Key, item.Value); }

    public void Clear() { collection.Clear(); }

    public bool Contains(KeyValuePair<string, string[]> item)
    {
        string[] value;
        if (!TryGetValue(item.Key, out value))
            return false;
        return EqualityComparer<string[]>.Default.Equals(item.Value, value); // Consistent with Dictionary<TKey, TValue>
    }

    public void CopyTo(KeyValuePair<string, string[]>[] array, int arrayIndex)
    {
        foreach (var item in this)
            array[arrayIndex++] = item;
    }

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

    public bool IsReadOnly { get { return false; } }

    public bool Remove(KeyValuePair<string, string[]> item)
    {
        if (Contains(item))
            return Remove(item.Key);
        return false;
    }

    #endregion

    #region IEnumerable<KeyValuePair<string,string[]>> Members

    public IEnumerator<KeyValuePair<string, string[]>> GetEnumerator()
    {
        foreach (string key in collection)
            yield return new KeyValuePair<string, string[]>(key, collection.GetValues(key));
    }

    #endregion

    #region IEnumerable Members

    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return GetEnumerator(); }

    #endregion
}

public static class NameValueCollectionExtensions
{
    public static NameValueCollectionDictionaryAdapter<TNameValueCollection> ToDictionaryAdapter<TNameValueCollection>(this TNameValueCollection collection)
        where TNameValueCollection : NameValueCollection, new()
    {
        if (collection == null)
            throw new ArgumentNullException();
        return new NameValueCollectionDictionaryAdapter<TNameValueCollection>(collection);
    }
}

public class ReadOnlyCollectionAdapter<TIn, TOut> : CollectionAdapterBase<TIn, TOut, ICollection<TIn>>
{
    public ReadOnlyCollectionAdapter(ICollection<TIn> collection, Func<TIn, TOut> toOuter)
        : base(() => collection, toOuter)
    {
    }

    public override void Add(TOut item) { throw new NotImplementedException(); }

    public override void Clear() { throw new NotImplementedException(); }

    public override bool IsReadOnly { get { return true; } }

    public override bool Remove(TOut item) { throw new NotImplementedException(); }
}

public abstract class CollectionAdapterBase<TIn, TOut, TCollection> : ICollection<TOut> 
    where TCollection : ICollection<TIn>
{
    readonly Func<TCollection> getCollection;
    readonly Func<TIn, TOut> toOuter;

    public CollectionAdapterBase(Func<TCollection> getCollection, Func<TIn, TOut> toOuter)
    {
        if (getCollection == null || toOuter == null)
            throw new ArgumentNullException();
        this.getCollection = getCollection;
        this.toOuter = toOuter;
    }

    protected TCollection Collection { get { return getCollection(); } }

    protected TOut ToOuter(TIn inner) { return toOuter(inner); }

    #region ICollection<TOut> Members

    public abstract void Add(TOut item);

    public abstract void Clear();

    public virtual bool Contains(TOut item)
    {
        var comparer = EqualityComparer<TOut>.Default;
        foreach (var member in Collection)
            if (comparer.Equals(item, ToOuter(member)))
                return true;
        return false;
    }

    public void CopyTo(TOut[] array, int arrayIndex)
    {
        foreach (var item in this)
            array[arrayIndex++] = item;
    }

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

    public abstract bool IsReadOnly { get; }

    public abstract bool Remove(TOut item);

    #endregion

    #region IEnumerable<TOut> Members

    public IEnumerator<TOut> GetEnumerator()
    {
        foreach (var item in Collection)
            yield return ToOuter(item);
    }

    #endregion

    #region IEnumerable Members

    IEnumerator IEnumerable.GetEnumerator() { return GetEnumerator(); }

    #endregion
}

Затем для данного NameValueCollection Data можно построить адаптированный вариант, просто выполнив:

var adapter = Data.ToDictionaryAdapter();

Примечания:

Использование адаптера может быть более эффективным, чем простое создание скопированного словаря, и должно хорошо работать с любым сериализатором, который полностью поддерживает сериализацию словаря.

Адаптер также может быть полезен при использовании NameValueCollection с любым другим кодом, который ожидает какой-либо IDictionary — это фундаментальное преимущество шаблона адаптера.
При этом JavaScriptSerializer нельзя использовать с адаптером, потому что этот сериализатор не может сериализовать произвольный тип, реализующий IDictionary<TKey, TValue>, который также не наследуется от Dictionary<TKey, TValue>. Подробнее см. в разделе Сериализация словарей с помощью JavaScriptSerializer.
При использовании DataContractJsonSerializer NameValueCollection можно заменить адаптером в графе сериализации с помощью механизм суррогата контракта данных.

При использовании Json.NET NameValueCollection можно заменить адаптером с помощью настраиваемого JsonConverter< /a> например:

public class NameValueJsonConverter<TNameValueCollection> : JsonConverter
    where TNameValueCollection : NameValueCollection, new()
{
    public override bool CanConvert(Type objectType)
    {
        return typeof(TNameValueCollection).IsAssignableFrom(objectType);
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        if (reader.SkipComments().TokenType == JsonToken.Null)
            return null;

        // Reuse the existing NameValueCollection if present
        var collection = (TNameValueCollection)existingValue ?? new TNameValueCollection();
        var dictionaryWrapper = collection.ToDictionaryAdapter();

        serializer.Populate(reader, dictionaryWrapper);

        return collection;
    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        var collection = (TNameValueCollection)value;
        var dictionaryWrapper = new NameValueCollectionDictionaryAdapter<TNameValueCollection>(collection);
        serializer.Serialize(writer, dictionaryWrapper);
    }
}

public static partial class JsonExtensions
{
    public static JsonReader SkipComments(this JsonReader reader)
    {
        while (reader.TokenType == JsonToken.Comment && reader.Read())
            ;
        return reader;
    }
}

Что можно использовать, например. следующим образом:

string json = JsonConvert.SerializeObject(Data, Formatting.Indented, new NameValueJsonConverter<NameValueCollection>());

NameValueCollection поддерживает все следующие

A null value for a given key;

Несколько значений для данного ключа (в этом случае NameValueCollection.Item[String] возвращает список значений, разделенных запятыми);

Одно значение, содержащее встроенную запятую (которую нельзя отличить от случая нескольких значений при использовании NameValueCollection.Item[String]).

Поэтому адаптер должен реализовать IDictionary<string, string[]>, а не IDictionary<string, string>, а также позаботиться об обработке массива значений null.

Пример скрипта (включая базовое модульное тестирование) здесь: https://dotnetfiddle.net/gVPSi7

dbc 09.10.2018

как преобразовать NameValueCollection в строку JSON?

Ответы (4)

Вопросы по теме