comment convertir NameValueCollection à chaîne JSON?

Une façon de sérialiser NameValueCollection est en convertissant d'abord à Dictionnaire et puis sérialiser le Dictionnaire. Pour convertir de dictionnaire:

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

Si vous avez besoin de faire la conversion fréquemment, vous pouvez également créer une méthode d'extension pour NameValueCollection:

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

de sorte que vous pouvez faire la conversion en une ligne comme ceci:

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

Alors vous pouvez sérialiser le dictionnaire:

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

Mais NameValueCollection peut avoir plusieurs valeurs pour une clé, par exemple:

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

Si vous sérialiser ce vous permettra de obtenir {"Foo":"baa,again?"}.

Vous pouvez modifier le convertisseur de produire IDictionary<string, string[]> à la place:

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

De sorte que vous pouvez être sérialisé valeur comme ceci: {"Foo":["baa","again?"]}.

À des fins d'exhaustivité, et parce que la question continue à se poser (par exemple ici), aussi longtemps que vous utilisez Json.NET ou DataContractJsonSerializer (mais pas JavaScriptSerializer), vous pouvez utiliser le l'adaptateur et envelopper le NameValueCollection dans un IDictionary<string, string[]> adaptateur, et sérialiser que l'utilisation de tout processus qui prend complètement en charge de la sérialisation d'arbitraire dictionnaires.

Une fois que cette carte est comme suit:

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
}

Puis adaptée peut être construit pour un NameValueCollection Data simplement en faisant:

var adapter = Data.ToDictionaryAdapter();

Notes:

• À l'aide de l'adaptateur peut être plus performant que le simple fait de créer une copie du dictionnaire, et devrait bien fonctionner avec n'importe quel sérialiseur qui prend entièrement en charge le dictionnaire de la sérialisation.

  L'adaptateur peut également être utile dans l'aide d'une NameValueCollection avec tout autre code qui attend un IDictionary de la sorte - c'est l'avantage fondamental de l'adaptateur.

• Cela étant dit, JavaScriptSerializer ne peut pas être utilisé avec l'adaptateur, car ce processus ne peut pas sérialiser un type arbitraire la mise en œuvre de IDictionary<TKey, TValue> qui n'est pas aussi hériter de Dictionary<TKey, TValue>. Pour plus de détails voir La sérialisation des dictionnaires JavaScriptSerializer.

• Lors de l'utilisation de DataContractJsonSerializer, un NameValueCollection peut être remplacé par un adaptateur dans le graphe de sérialisation à l'aide de la contrat de données de substitution mécanisme.

• Lors de l'utilisation de Json.NET un NameValueCollection peut être remplacé par un adaptateur à l'aide d'un custom JsonConverter telles que les suivantes:

  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;
  }
  }

  Qui pourrait être utilisé par exemple comme suit:

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

• NameValueCollection prend en charge toutes les opérations suivantes

  • Un null valeur pour une clé donnée;
  • Plusieurs valeurs pour une clé donnée (dans ce cas, NameValueCollection.Élément[String] renvoie une liste séparée par des virgules de valeurs);
  • Une valeur unique contenant une virgule incorporée (qui ne peut être distinguée du cas de pluralité de valeurs lors de l'utilisation de NameValueCollection.Item[String]).

  Ainsi la carte doit mettre en œuvre IDictionary<string, string[]> plutôt que IDictionary<string, string> et prenez également le soin de gérer un null tableau de valeur.

Échantillon de violon (y compris une unité de base de test) ici: https://dotnetfiddle.net/gVPSi7