C# – Select Single Value with ADO.Net Data Services and LINQ

clinqwcf-data-services

Trying my hand at ADO.Net data services. All the examples shows how to retrieve lists but how would you go about retrieving a single value? e.g. Product X's Price.

Here is the LINQ query i use:

var qry = (from p in
svcContext.Products
where p.ProductName == "Chair"
&& p.Colour == 1
select c) as DataServiceQuery;

Product returnedProd;

qry.BeginExecute(
(pr) => returnedProd = qry.EndExecute(pr).First(), null);

Here i try to retrieve the product and load it into a local variable, but the local var stays null.

Pretty sure, i'm doing it completely wrong :)…any help would be greatly appreciated.

Best Answer

It's not suppose to be

var qry = (from p in svcContext.Products where p.ProductName == "Chair" && p.Colour == 1 select p) where did you declare the c ?

Related Solutions

C# – Preserving order with LINQ

I examined the methods of System.Linq.Enumerable, discarding any that returned non-IEnumerable results. I checked the remarks of each to determine how the order of the result would differ from order of the source.

Preserves Order Absolutely. You can map a source element by index to a result element

AsEnumerable
Cast
Concat
Select
ToArray
ToList

Preserves Order. Elements are filtered or added, but not re-ordered.

Distinct
Except
Intersect
OfType
Prepend (new in .net 4.7.1)
Skip
SkipWhile
Take
TakeWhile
Where
Zip (new in .net 4)

Destroys Order - we don't know what order to expect results in.

ToDictionary
ToLookup

Redefines Order Explicitly - use these to change the order of the result

OrderBy
OrderByDescending
Reverse
ThenBy
ThenByDescending

Redefines Order according to some rules.

GroupBy - The IGrouping objects are yielded in an order based on the order of the elements in source that produced the first key of each IGrouping. Elements in a grouping are yielded in the order they appear in source.
GroupJoin - GroupJoin preserves the order of the elements of outer, and for each element of outer, the order of the matching elements from inner.
Join - preserves the order of the elements of outer, and for each of these elements, the order of the matching elements of inner.
SelectMany - for each element of source, selector is invoked and a sequence of values is returned.
Union - When the object returned by this method is enumerated, Union enumerates first and second in that order and yields each element that has not already been yielded.

Edit: I've moved Distinct to Preserving order based on this implementation.

    private static IEnumerable<TSource> DistinctIterator<TSource>
      (IEnumerable<TSource> source, IEqualityComparer<TSource> comparer)
    {
        Set<TSource> set = new Set<TSource>(comparer);
        foreach (TSource element in source)
            if (set.Add(element)) yield return element;
    }

C# – Split List into Sublists with LINQ

Try the following code.

public static IList<IList<T>> Split<T>(IList<T> source)
{
    return  source
        .Select((x, i) => new { Index = i, Value = x })
        .GroupBy(x => x.Index / 3)
        .Select(x => x.Select(v => v.Value).ToList())
        .ToList();
}

The idea is to first group the elements by indexes. Dividing by three has the effect of grouping them into groups of 3. Then convert each group to a list and the IEnumerable of List to a List of Lists

Best Answer

Related Solutions

C# – Preserving order with LINQ

C# – Split List into Sublists with LINQ

Related Topic