How would I perform a left join with coalesce in Linq?

Question

Consider tables

• Inventions, list of inventions
• Components, list of all components available for use in inventions, and
• InventionComponents, list of utilized components, with count, in an invention

For a given invention, &inventionID, I would like to do a 'covering' left join to all of the components instead of just the utilized components.

SQL would be something like

select 
  I.name as inventionName
, C.name as componentName
, coalese (IC.count, 0) as componentCount
from
  (select &inventionID as inventionID, ID, name from components) C -- all components applied to some &inventionID
left join
  inventionComponents IC
on
  C.ID = IC.ComponentID 
  and C.inventionID = IC.inventionID
join
  inventions I
on
  I.ID = C.inventionID

Sample data and Linq query in .NET fiddle at https://dotnetfiddle.net/cx4bHp results in an exception

[System.NullReferenceException: Object reference not set to an instance of an object.]

Question: How should the Linq query be modified to perform the desired covering query ?

For completeness, the C# fiddle code is repeated here

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

public class Program
{
  public static void Main()
  {
    var components = new List<Component>{
      new Component { ID=1, Name = "Florgebit" },
      new Component { ID=2, Name = "Phadron" },
      new Component { ID=3, Name = "Goobstem" },
      new Component { ID=4, Name = "Larchwren" },
      new Component { ID=5, Name = "Zangponder" },
      new Component { ID=6, Name = "Spoofork" },
      new Component { ID=7, Name = "Forkoon" },
      new Component { ID=8, Name = "Blidget" },
      new Component { ID=9, Name = "Wazzawim" },
      new Component { ID=10, Name = "Klackberg" },
    };
    var inventions = new List<Invention>{
      new Invention { ID=21, Name = "Swazzlute" },
      new Invention { ID=22, Name = "Corpocran" },
      new Invention { ID=23, Name = "Fillyboof" },
    };
    var inventionComponents  = new List<InventionComponent>{
      new InventionComponent { ID=100, InventionID=21, ComponentID=1, Count=1 },
      new InventionComponent { ID=101, InventionID=21, ComponentID=2, Count=2 },
      new InventionComponent { ID=102, InventionID=21, ComponentID=8, Count=3 },
      new InventionComponent { ID=103, InventionID=23, ComponentID=5, Count=4 },
      new InventionComponent { ID=104, InventionID=23, ComponentID=6, Count=5 },
      new InventionComponent { ID=105, InventionID=23, ComponentID=3, Count=4 },
      new InventionComponent { ID=106, InventionID=21, ComponentID=4, Count=3 },
      new InventionComponent { ID=107, InventionID=22, ComponentID=5, Count=2 },
      new InventionComponent { ID=108, InventionID=22, ComponentID=4, Count=1 },
      new InventionComponent { ID=109, InventionID=22, ComponentID=1, Count=6 },
      new InventionComponent { ID=110, InventionID=22, ComponentID=7, Count=1 },
      new InventionComponent { ID=111, InventionID=21, ComponentID=9, Count=1 },
    };

    var details =
      from A in inventions
      join B in inventionComponents on A.ID equals B.InventionID
      join C in components on B.ComponentID equals C.ID
      orderby A.Name, C.Name
      select new {
        InventionName = A.Name,
        ComponentName = C.Name,
        ComponentCount = B.Count
      };
/*
    foreach(var d in details)
    {
      Console.WriteLine("Invention: {0}, Component: {1}, Count: {2}", d.InventionName, d.ComponentName, d.ComponentCount);
    }
*/
    var inventionID = 22;
    var index = 1;

    // want full coverage of inventionID, componentID with applied counts
    // 22,1,6
    // 22,2,**0**
    // 22,3,**0**
    // 22,4,1
    // 22,5,2
    // 22,6,**0**
    // 22,7,1
    // 22,8,**0**
    // 22,9,**0**
    // 22,10,**0**

    var corpcheck = 
      from C in components select new { InventionID = inventionID, ComponentID = C.ID, ComponentName = C.Name } into allcomps
      join B in inventionComponents on new { allcomps.InventionID, allcomps.ComponentID } equals new { B.InventionID, B.ComponentID } into join1
      // from j1 in Join1 // inner join
      from j1 in join1.DefaultIfEmpty() // causes exception
      orderby allcomps.ComponentName
      select new {
          RowNum = index++,
        InventionID = allcomps.InventionID,
        ComponentName = allcomps.ComponentName,
        ComponentCount = j1.Count,
      };


    foreach(var x in corpcheck)
    {
      Console.WriteLine("InventionID: {0}, RowNum: {1}, ComponentName: {2}, Count: {3}", x.InventionID, x.RowNum, x.ComponentName, x.ComponentCount);
    }
  }

  public class Invention
  {
    public int ID { get; set; }
    public string Name { get; set; }
  }

  public class InventionComponent
  {
    public int ID { get; set; }
    public int InventionID { get; set; }
    public int ComponentID { get; set; }
    public int Count { get; set; }
  }

  public class Component
  {
    public int ID { get; set; }
    public string Name { get; set; }
  }
}

Answer 1

By adding DefaultIfEmpty(), j1 can be null for some components. If j1 is null, I assume you want count to be 0:

  from C in components select new { InventionID = inventionID, ComponentID = C.ID, ComponentName = C.Name } into allcomps
  join B in inventionComponents on new { allcomps.InventionID, allcomps.ComponentID } equals new { B.InventionID, B.ComponentID } into join1
  from j1 in join1.DefaultIfEmpty()
  orderby allcomps.ComponentName
  select new {
      RowNum = index++,
      InventionID = allcomps.InventionID,
      ComponentName = allcomps.ComponentName,
      ComponentCount = j1 == null ? 0 : j1.Count, // add null check
  };

In LINQ-to-objects you could also use ComponentCount = j1?.Count ?? 0. but I assume you're going to use this in LINQ to a SQL backend.