Explain the difference between using a variable and direct execution

Question

The image above are my sample data of ListN.

I've another list ListA with two items in it {ID=1090,ID=1089}

Now I've the following code:

CodeA:

var x = 0;
foreach(var item in ListA){
    if(ListN.Where(x=>x.ID==item.ID).Any(y=>y.Data != null))
    {
        x = ListN.Where(x=>x.ID==item.ID).Min(y=>y.Data).Value;
        break;
    }
}

CodeB:

var x = 0;
foreach(var item in ListA){
    var list = ListN.Where(x=>x.ID==item.ID);
    if(list.Any(y=>y.Data != null))
    {
        x = list.Min(y=>y.Data).Value;
        break;
    }
}

Can anyone explain to me why CodeA is giving me error throwing null exception but CodeB working fine?

Answer 1

Not an answer to the question. But this is an awful way to achieve what you are trying to do...

var x = (from item in ListA
        join list in ListN on item.ID equals list.ID
        where list.Data != null
        select list.Data).Min();

Is much clearer in your meaning. Plus the Linq compiler will actually produce more optimal code for you (since it will use Hash Look ups).

The main problem you are having is that you are trying to mix up imperative programming (foreach, break, etc) with declarative programming (Where, Min etc) and confusing yourself.

Answer 2

This is because you tested for nulls in the first If condition but in the second you are disregarding that test and selecting the items that match the Where clause again.

You are not getting the same list in the second selection as the one you got from the first test.

In CodeB sample you are only processing the items that definitely do not have null data fields.

I would suggest to do something like this :

var x = 0;
foreach(var item in ListA)
{
    var list = ListN.Where(x=> x.ID == item.ID && x.Data != null).ToList();

    if(list.Any())
    {
       x = list.Min(y=>y.Data).Value;
       break;
    }    
}

Answer 3

This is not an answer. But it's far too big to be a comment.

I cannot reproduce your problem. I've no idea what the two answers claiming there's some form of "more filtering" happening in one sample than the other are going on about.

Here's your code, a couple of fixups (because you can't have var x and use x as a lambda parameter) and your data. And it outputs No Exception twice, indicating that both code samples run fine:

using System;
using System.Collections;
using System.Collections.Generic;
using System.Data.SqlClient;
using System.Linq;
using System.Runtime.InteropServices;
using System.Security;

namespace ConsoleApplication4
{
    class Program
    {
        class N
        {
            public int ID { get; set; }
            public int? Data { get; set; }
        }

        class A
        {
            public int ID { get; set; }
        }

        static int CodeA(List<N> ListN, List<A> ListA)
        {
            var c = 0;
            foreach (var item in ListA)
            {
                if (ListN.Where(x => x.ID == item.ID).Any(y => y.Data != null))
                {
                    c = ListN.Where(x => x.ID == item.ID).Min(y => y.Data).Value;
                    break;
                }
            }
            return c;
        }

        static int CodeB(List<N> ListN, List<A> ListA)
        {
            var c = 0;
            foreach (var item in ListA)
            {
                var list = ListN.Where(x => x.ID == item.ID);
                if (list.Any(y => y.Data != null))
                {
                    c = list.Min(y => y.Data).Value;
                    break;
                }
            }
            return c;
        }

        static void Main(string[] args)
        {
            var listN = new List<N>
            {
                new N {ID = 1090, Data = 1},
                new N {ID = 1090, Data = 3},
                new N {ID = 1090, Data = 4},
                new N {ID = 1089, Data = 1},
                new N {ID = 1089, Data = 3},
                new N {ID = 1089, Data = 4},
                new N {ID = 1089, Data = null}
            };
            var listA = new List<A>
            {
                new A {ID = 1089},
                new A {ID = 1090}
            };
            try
            {
                CodeA(listN, listA);
                Console.WriteLine("No Exception");
            }
            catch (Exception ex)
            {
                Console.WriteLine("A exception: " + ex.ToString());
            }
            try
            {
                CodeB(listN, listA);
                Console.WriteLine("No Exception");
            }
            catch (Exception ex)
            {
                Console.WriteLine("B exception: " + ex.ToString());
            }
            Console.ReadLine();
        }
    }

}

If you want some help with your actual problem, can you please take the above code sample and make appropriate changes to the point where CodeA throws this exception you talk about and CodeB doesn't. You can then incorporate this into your question and I'll delete this "answer".