Sequence contains no elements ошибка

I’m currently using a single query in two places to get a row from a database.

BlogPost post = (from p in dc.BlogPosts
                 where p.BlogPostID == ID
                 select p).Single();

The query is fine when retrieving the row to put data in to the text boxes, but it returns an error «Sequence contains no elements» when used to retrieve the row in order to edit it and put it back in to the database. I can’t understand why it might find an appropriate row in one instance but not another.

(Using ASP.NET MVC and LINQ)

In addition to everything else that has been said, you can call DefaultIfEmpty() before you call Single(). This will ensure that your sequence contains something and thereby averts the InvalidOperationException «Sequence contains no elements». For example:

BlogPost post = (from p in dc.BlogPosts
                 where p.BlogPostID == ID
                 select p).DefaultIfEmpty().Single();

I had a similar situation on a function that calculates the average.

Example:

ws.Cells[lastRow, startingmonths].Value = lstMediaValues.Average();

Case Solved:

ws.Cells[lastRow, startingmonths].Value = lstMediaValues.Count == 0 ? 0 : lstMediaValues.Average();

answered Apr 25, 2019 at 11:13

Reason for error:

1. The query from p in dc.BlogPosts where p.BlogPostID == ID select p returns a sequence.

2. Single() tries to retrieve an element from the sequence returned in step1.

3. As per the exception — The sequence returned in step1 contains no elements.

4. Single() tries to retrieve an element from the sequence returned in step1 which contains no elements.

5. Since Single() is not able to fetch a single element from the sequence returned in step1, it throws an error.

Fix:

Make sure the query (from p in dc.BlogPosts where p.BlogPostID == ID select p)

returns a sequence with at least one element.

1

At:- 2/26/2018 6:55:30 AM

When you start playing with LINQ queries over sequences of elements (e.g. getting min / max value for enumerable source) sooner or later you will come across this one — the InvalidOperationException (“Sequence contains no elements”).

The problem occurs as by default queries like IEnumerable<T>.Min(…) and IEnumerable<T>.Max(…) do not play nicely if you try to execute them on an empty sequence and just throw the exception described above. Unfortunately these methods do not have a corresponding counterpart like Single(…) / SingleOrDefault(…) that is smart enough to query the sequence if it is not empty or alternatively use the default value without raising an exception.

Basically you got two options now:

• Either perform the check on the enumerable sequence every time you are querying it
• OR integrate the logic in an extension method.

The second approach is much preferable so let’s add the missing link below:

namespace ExtensionMethods
{
    using System;
    using System.Collections.Generic;
    using System.Linq; public static class IEnumerableExtensions
    {
        /// <summary>
        /// Invokes a transform function on each element of a sequence and returns the minimum Double value 
        /// if the sequence is not empty; otherwise returns the specified default value. 
        /// </summary>
        /// <typeparam name=»TSource»>The type of the elements of source.</typeparam>
        /// <param name=»source»>A sequence of values to determine the minimum value of.</param>
        /// <param name=»selector»>A transform function to apply to each element.</param>
        /// <param name=»defaultValue»>The default value.</param>
        /// <returns>The minimum value in the sequence or default value if sequence is empty.</returns>
        public static double MinOrDefault<TSource>(this IEnumerable<TSource> source, Func<TSource, double> selector, double defaultValue)
        {
            if (source.Any<TSource>())
                return source.Min<TSource>(selector);  return defaultValue;
        } /// <summary>
        /// Invokes a transform function on each element of a sequence and returns the maximum Double value 
        /// if the sequence is not empty; otherwise returns the specified default value. 
        /// </summary>
        /// <typeparam name=»TSource»>The type of the elements of source.</typeparam>
        /// <param name=»source»>A sequence of values to determine the maximum value of.</param>
        /// <param name=»selector»>A transform function to apply to each element.</param>
        /// <param name=»defaultValue»>The default value.</param>
        /// <returns>The maximum value in the sequence or default value if sequence is empty.</returns>
        public static double MaxOrDefault<TSource>(this IEnumerable<TSource> source, Func<TSource, double> selector, double defaultValue)
        {
            if (source.Any<TSource>())
                return source.Max<TSource>(selector);  return defaultValue;
        }
    }
}

Now you only need to add the using ExtensionMethods; directive in your project and you are all set:

Hope this helps.

Latest Stories
in Your Inbox