private static void Member(JsonTextWriter writer, string name, NameValueCollection collection) { Debug.Assert(writer != null); Debug.AssertStringNotEmpty(name); // // Bail out early if the collection is null or empty. // if (collection == null || collection.Count == 0) { return; } // // Save the depth, which we'll use to lazily emit the collection. // That is, if we find that there is nothing useful in it, then // we could simply avoid emitting anything. // var depth = writer.Depth; // // For each key, we get all associated values and loop through // twice. The first time round, we count strings that are // neither null nor empty. If none are found then the key is // skipped. Otherwise, second time round, we encode // strings that are neither null nor empty. If only such string // exists for a key then it is written directly, otherwise // multiple strings are naturally wrapped in an array. // var items = from i in Enumerable.Range(0, collection.Count) let values = collection.GetValues(i) where values != null && values.Length > 0 let some = // Neither null nor empty from v in values where !string.IsNullOrEmpty(v) select v let nom = some.Take(2).Count() where nom > 0 select new { Key = collection.GetKey(i), IsArray = nom > 1, Values = some, }; foreach (var item in items) { // // There is at least one value so now we emit the key. // Before doing that, we check if the collection member // was ever started. If not, this would be a good time. // if (depth == writer.Depth) { writer.Member(name); writer.Object(); } writer.Member(item.Key ?? string.Empty); if (item.IsArray) { writer.Array(); // Wrap multiples in an array } foreach (var value in item.Values) { writer.String(value); } if (item.IsArray) { writer.Pop(); // Close multiples array } } // // If we are deeper than when we began then the collection was // started so we terminate it here. // if (writer.Depth > depth) { writer.Pop(); } }
private static void Member(JsonTextWriter writer, string name, NameValueCollection collection) { Debug.Assert(writer != null); Debug.AssertStringNotEmpty(name); // // Bail out early if the collection is null or empty. // if (collection == null || collection.Count == 0) return; // // Save the depth, which we'll use to lazily emit the collection. // That is, if we find that there is nothing useful in it, then // we could simply avoid emitting anything. // var depth = writer.Depth; // // For each key, we get all associated values and loop through // twice. The first time round, we count strings that are // neither null nor empty. If none are found then the key is // skipped. Otherwise, second time round, we encode // strings that are neither null nor empty. If only such string // exists for a key then it is written directly, otherwise // multiple strings are naturally wrapped in an array. // var items = from i in Enumerable.Range(0, collection.Count) let values = collection.GetValues(i) where values != null && values.Length > 0 let some = // Neither null nor empty from v in values where !string.IsNullOrEmpty(v) select v let nom = some.Take(2).Count() where nom > 0 select new { Key = collection.GetKey(i), IsArray = nom > 1, Values = some, }; foreach (var item in items) { // // There is at least one value so now we emit the key. // Before doing that, we check if the collection member // was ever started. If not, this would be a good time. // if (depth == writer.Depth) { writer.Member(name); writer.Object(); } writer.Member(item.Key ?? string.Empty); if (item.IsArray) writer.Array(); // Wrap multiples in an array foreach (var value in item.Values) writer.String(value); if (item.IsArray) writer.Pop(); // Close multiples array } // // If we are deeper than when we began then the collection was // started so we terminate it here. // if (writer.Depth > depth) writer.Pop(); }
private static void Member(JsonTextWriter writer, string name, NameValueCollection collection) { Debug.Assert(writer != null); Debug.AssertStringNotEmpty(name); // // Bail out early if the collection is null or empty. // if (collection == null || collection.Count == 0) return; // // Save the depth, which we'll use to lazily emit the collection. // That is, if we find that there is nothing useful in it, then // we could simply avoid emitting anything. // int depth = writer.Depth; // // For each key, we get all associated values and loop through // twice. The first time round, we count strings that are // neither null nor empty. If none are found then the key is // skipped. Otherwise, second time round, we encode // strings that are neither null nor empty. If only such string // exists for a key then it is written directly, otherwise // multiple strings are naturally wrapped in an array. // foreach (string key in collection.Keys) { string[] values = collection.GetValues(key); if (values == null || values.Length == 0) continue; int count = 0; // Strings neither null nor empty. for (int i = 0; i < values.Length; i++) { string value = values[i]; if (value != null && value.Length > 0) count++; } if (count == 0) // None? continue; // Skip key // // There is at least one value so now we emit the key. // Before doing that, we check if the collection member // was ever started. If not, this would be a good time. // if (depth == writer.Depth) { writer.Member(name); writer.Object(); } writer.Member(key); if (count > 1) writer.Array(); // Wrap multiples in an array for (int i = 0; i < values.Length; i++) { string value = values[i]; if (value != null && value.Length > 0) writer.String(value); } if (count > 1) writer.Pop(); // Close multiples array } // // If we are deeper than when we began then the collection was // started so we terminate it here. // if (writer.Depth > depth) writer.Pop(); }
private static void Member(JsonTextWriter writer, string name, NameValueCollection collection) { Debug.Assert(writer != null); Debug.AssertStringNotEmpty(name); // // Bail out early if the collection is null or empty. // if (collection == null || collection.Count == 0) { return; } // // Save the depth, which we'll use to lazily emit the collection. // That is, if we find that there is nothing useful in it, then // we could simply avoid emitting anything. // int depth = writer.Depth; // // For each key, we get all associated values and loop through // twice. The first time round, we count strings that are // neither null nor empty. If none are found then the key is // skipped. Otherwise, second time round, we encode // strings that are neither null nor empty. If only such string // exists for a key then it is written directly, otherwise // multiple strings are naturally wrapped in an array. // foreach (string key in collection.Keys) { string[] values = collection.GetValues(key); if (values == null || values.Length == 0) { continue; } int count = 0; // Strings neither null nor empty. for (int i = 0; i < values.Length; i++) { string value = values[i]; if (value != null && value.Length > 0) { count++; } } if (count == 0) // None? { continue; // Skip key } // // There is at least one value so now we emit the key. // Before doing that, we check if the collection member // was ever started. If not, this would be a good time. // if (depth == writer.Depth) { writer.Member(name); writer.Object(); } writer.Member(key); if (count > 1) { writer.Array(); // Wrap multiples in an array } for (int i = 0; i < values.Length; i++) { string value = values[i]; if (value != null && value.Length > 0) { writer.String(value); } } if (count > 1) { writer.Pop(); // Close multiples array } } // // If we are deeper than when we began then the collection was // started so we terminate it here. // if (writer.Depth > depth) { writer.Pop(); } }