How to merge two lists using LINQ Suming especifics fields with sublists

Question

Considering I have 2 list (listaProduto1 and listaProduto2), both with same properties, but with different values.

I need the result merge both lists, but it must consider the correspond id`s in which list.

Produtos = idProduto / TiposTitularidade = idTipoTitularidade / Faixa = idFaixa

I've tried to follow other similar topics, but this is much more complex for me.

This is my expected result:

1. a return list merged group by Produtos = idProduto, TiposTitularidade = idTipoTitularidade, Faixa = idFaixa merged from listaProduto1 and listaProduto2;
2. the fields quantidadeClientes, valor must be summed in case idFaixa matches in both lists.

Here is the code:

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

namespace ConsoleApp1

{
public class Program1
{
    public class Data
    {
        public List<Produto> produtos { get; set; }
    }

    public class Faixa
    {
        public int idFaixa { get; set; }
        public int quantidadeClientes { get; set; }
        public double valor { get; set; }
    }

    public class Produto
    {
        public string idProduto { get; set; }
        public List<TiposTitularidade> tiposTitularidades { get; set; }
    }

    public class TiposTitularidade
    {
        public int idTipoTitularidade { get; set; }
        public List<Faixa> faixas { get; set; }
    }
    public static void Main()
    {


        List<Faixa> listafaixas1 = new List<Faixa>()
        {
            new Faixa { idFaixa=1, quantidadeClientes = 2, valor = 32.2},
            new Faixa { idFaixa=2, quantidadeClientes = 4, valor = 62.2},
            new Faixa { idFaixa=4, quantidadeClientes = 6, valor = 165.7},
            new Faixa { idFaixa=7, quantidadeClientes = 126, valor = 234},
        };

        List<Faixa> listafaixas1p = new List<Faixa>()
        {
            new Faixa { idFaixa=7, quantidadeClientes = 126, valor = 234},
        };

        List<Faixa> listafaixas2 = new List<Faixa>()
        {
            new Faixa { idFaixa=1, quantidadeClientes = 4, valor = 25.45},
            new Faixa { idFaixa=3, quantidadeClientes = 7, valor = 45.12},
            new Faixa { idFaixa=4, quantidadeClientes = 3, valor = 112.18},
            new Faixa { idFaixa=7, quantidadeClientes = 34, valor = 278},
        };

        List<Faixa> listafaixas2p = new List<Faixa>()
        {
            new Faixa { idFaixa=7, quantidadeClientes = 34, valor = 278},
        };

        List<TiposTitularidade> listaTiposTitularidade1 = new List<TiposTitularidade>()
        {
            new TiposTitularidade { idTipoTitularidade=1, faixas = listafaixas1},
            new TiposTitularidade { idTipoTitularidade=2, faixas = listafaixas1p},
        };

        List<TiposTitularidade> listaTiposTitularidade2 = new List<TiposTitularidade>()
        {
            new TiposTitularidade { idTipoTitularidade=1, faixas = listafaixas2},
            new TiposTitularidade { idTipoTitularidade=2, faixas = listafaixas2p},
        };

        List<Produto> listaProduto1 = new List<Produto>()
        {
            new Produto { idProduto= "1", tiposTitularidades = listaTiposTitularidade1},
            new Produto { idProduto= "2", tiposTitularidades = listaTiposTitularidade1},
        };

        List<Produto> listaProduto2 = new List<Produto>()
        {
            new Produto { idProduto= "1", tiposTitularidades = listaTiposTitularidade2},
            new Produto { idProduto= "3", tiposTitularidades = listaTiposTitularidade2},
        };


    }
}
}

Answer 1

I think you need a balanced line merge here. Sort both lists using the id. Advance both lists to the first item and enter a loop until both lists are exhausted. Compare the current items in both lists. If a is bigger b than add b to the result and advance b and vice versa. If both are the same handle a and b and advance both lists.

Below is a graphical explanation of each iteration.

Iteration 1:

1 <-->  2    Handle 1 and advance list 1
2       4
3       5
4       6

Iteration 2:

2 <-->  2    Handle both and advance both lists
3       4
4       5
        6

Iteration 3:

3 <-->  4    Handle 3 and advance list 1
4       5
        6

Iteration 4:

4 <-->  4    Handle both and advance both
        5
        6

Iteration 5:

  ?-->  5    List 1 is exhausted handle 5 and advance list 2
        6

Iteration 6:

  ?-->  6    List 1 is exhausted handle 6 and advance list 2

Iteration 7:

  ?--?       finished