Сделать NameValueCollection доступным для запроса LINQ

Ответ 1

Вам нужно "поднять" неуниверсальный IEnumerable в IEnumerable<string>. Было предложено использовать OfType но это метод фильтрации. То, что вы делаете, эквивалентно приведению, для которого есть оператор Cast:

var fields = RequestFields().Cast<string>();

Как указал Франс, это только обеспечивает доступ к ключам. Вам по-прежнему нужно индексировать в коллекцию для значений. Вот метод расширения для извлечения KeyValuePair из NameValueCollection:

public static IEnumerable<KeyValuePair<string, string>> ToPairs(this NameValueCollection collection)
{
    if(collection == null)
    {
        throw new ArgumentNullException("collection");
    }

    return collection.Cast<string>().Select(key => new KeyValuePair<string, string>(key, collection[key]));
}

Изменить: В ответ на запрос @Ruben Bartelink, вот как получить доступ к полному набору значений для каждого ключа, используя ToLookup:

public static ILookup<string, string> ToLookup(this NameValueCollection collection)
{
    if(collection == null)
    {
        throw new ArgumentNullException("collection");
    }

    var pairs =
        from key in collection.Cast<String>()
        from value in collection.GetValues(key)
        select new { key, value };

    return pairs.ToLookup(pair => pair.key, pair => pair.value);
}

В качестве альтернативы, используя кортежи С# 7.0:

public static IEnumerable<(String name, String value)> ToTuples(this NameValueCollection collection)
{
    if(collection == null)
    {
        throw new ArgumentNullException("collection");
    }

    return
        from key in collection.Cast<string>()
        from value in collection.GetValues(key)
        select (key, value);
}

Ответ 2

AsQueryable должен взять IEnumerable<T>, общий. NameValueCollection реализует IEnumerable, что отличается.

Вместо этого:

{
    NameValueCollection nvc = RequestFields();
    IQueryable queryable = nvc.AsQueryable();
}

Попробуйте OfType (он принимает не общий интерфейс)

{
    NameValueCollection nvc = RequestFields();
    IEnumerable<string> canBeQueried = nvc.OfType<string>();
    IEnumerable<string> query =
       canBeQueried.Where(s => s.StartsWith("abc"));
}

Ответ 3

Словарь, вероятно, на самом деле ближе к тому, что вы хотите использовать, поскольку он фактически заполняет больше тех ролей, которые заполняет NameValueCollection. Это вариант решения Брайана Уотса:

public static class CollectionExtensions
{
    public static IDictionary<string, string> ToDictionary(this NameValueCollection source)
    {
        return source.Cast<string>().Select(s => new { Key = s, Value = source[s] }).ToDictionary(p => p.Key, p => p.Value); 
    }
}

Ответ 4

Я знаю, что опаздываю на вечеринку, но просто хочу добавить свой ответ, который не связан с методом расширения .Cast, но вместо этого использует свойство AllKeys:

var fields = RequestFields().AllKeys;

Это позволит использовать следующий метод расширения:

public static IEnumerable<KeyValuePair<string, string>> ToPairs(this NameValueCollection collection)
{
    if(collection == null)
    {
        throw new ArgumentNullException("collection");
    }

    return collection.AllKeys.Select(key => new KeyValuePair<string, string>(key, collection[key]));
}

Надеюсь, это поможет любому будущему посетителю.

Ответ 5

Проблема состоит в том, что коллекция реализует IEnumerable (в отличие от IEnumerable<T>), и перечисление коллекции возвращает ключи, а не пары.

Если бы я был вами, я использовал бы Dictionary<string, string>, который можно перечислить и может использоваться с LINQ.

Ответ 6

Для меня вариант ответа @Bryan Watts (+ 1'd) ToLookup представляет собой, безусловно, самый ясный способ его использования в режиме только для чтения.

В моем случае использования я манипулирую строку запроса для использования с Linq2Rest, а также должен вернуть все это обратно в NameValueCollection в конце, поэтому у меня есть набор методов расширения для NameValueCollection, которые предлагают более подробные операции (для работы как для имени параметра (AsEnumerable), так и для каждого аргумента (AsKeyValuePairs)), а также обратная операция преобразования его обратно ToNameValueCollection (из любого представления)).

Пример потребления:

public static NameValueCollection WithoutPagingOperators( this NameValueCollection that )
{
    return that.AsEnumerable()
        .Where( @param => @param.Key != OdataParameters.Skip 
          && @param.Key != OdataParameters.Top )
        .ToNameValueCollection();
}

код:

using System.Collections.Generic;
using System.Collections.Specialized;
using System.Linq;

public static class NamedValueCollectionExtensions
{
    public static IEnumerable<KeyValuePair<string, string[]>> AsEnumerable( this NameValueCollection that )
    {
        return that
            .Cast<string>() // doesn't implement IEnumerable<T>, but does implement IEnumerable
            .Select( ( item, index ) => // enable indexing by integer rather than string
                new KeyValuePair<string, string[]>( item, that.GetValues( index ) ) ); // if you use the indexer or GetValue it flattens multiple values for a key, Joining them with a ',' which we don't want
    }

    public static IEnumerable<KeyValuePair<string, string>> AsKeyValuePairs( this IEnumerable<KeyValuePair<string, string[]>> that )
    {
        return that
            .SelectMany( item =>
                item.Value.Select( value =>
                    new KeyValuePair<string, string>( item.Key, value ) ) );
    }

    public static NameValueCollection ToNameValueCollection( this IEnumerable<KeyValuePair<string, string[]>> that )
    {
        return that.AsKeyValuePairs().ToNameValueCollection();
    }

    public static NameValueCollection ToNameValueCollection( this IEnumerable<KeyValuePair<string, string>> that )
    {
        var result = new NameValueCollection();
        foreach ( KeyValuePair<string, string> item in that )
            result.Add( item.Key, item.Value );
        return result;
    }
}

Ответ 7

Я действительно не понимаю, почему кто-то должен будет добавить метод расширения.
Вот несколько способов сделать это в VB.NET. Он включает в себя 4 различные промежуточные формы IEnumerable: Array, Tuple, Anonymous и KeyValuePair. Для эквивалента С# перейдите в convert.telerik dot com и преобразуйте его.

Dim nvc As New NameValueCollection() From {{"E", "55"}, {"A", "11"}, {"D", "44"}, {"C", "33"}, {"G", "66"}, {"B", "22"}}

Dim dictStrings As Dictionary(Of String, String) = nvc.Cast(Of String).ToDictionary(Function(key) key, Function(key) nvc(key))
Dim Ints2Chars__ As Dictionary(Of Integer, Char) = nvc.Cast(Of Object).ToDictionary(Function(key) CInt(nvc(CStr(key))), Function(key) CChar(key))

Dim arrEnumerable__ = From x In nvc.Cast(Of String) Select {x, nvc(x)}
Dim tupleEnumerable = From x In nvc.Cast(Of String) Select Tuple.Create(x, nvc(x))
Dim anonEnumerable_ = From X In nvc.Cast(Of String) Select New With {X, .Y = nvc(X)}
Dim kvpEnumerable__ = From x In nvc.Cast(Of String) Select New KeyValuePair(Of String, String)(x, nvc(x))

Dim anonQuery = From anon In anonEnumerable_ Let n = CInt(anon.Y) Order By n Where n > 30 Select New With {.num = n, .val = anon.X}
Dim dictQuery = anonQuery.ToDictionary(Of Integer, String)(Function(o) o.num, Function(o) o.val)


Dim dictArray_ = arrEnumerable__.ToDictionary(Function(x) x(0), Function(x) x(1))
Dim dictTuples = tupleEnumerable.ToDictionary(Function(tuple) tuple.Item1, Function(tuple) tuple.Item2)
Dim dictAnon__ = anonEnumerable_.ToDictionary(Function(anon) anon.X, Function(anon) anon.Y)
Dim dictKVPrs_ = kvpEnumerable__.ToDictionary(Function(kvp) kvp.Key, Function(kvp) kvp.Value)