Parsing XML in C# with variable children structure

Linq will not be helpful here. What you can do is create the DTO for your xml using the sample xml that contains all the attributes and nodes which can be returned in the xml.

and then deserialize the xml in to that type.

Your classes would be something like following from the xml above which are being generated:

[XmlRoot(ElementName="min")]
public class Min {
    [XmlAttribute(AttributeName="missing")]
    public string Missing { get; set; }
}

[XmlRoot(ElementName="max")]
public class Max {
    [XmlAttribute(AttributeName="missing")]
    public string Missing { get; set; }
}

[XmlRoot(ElementName="source_code")]
public class Source_code {
    [XmlAttribute(AttributeName="missing")]
    public string Missing { get; set; }
}

[XmlRoot(ElementName="COMPO")]
public class COMPO {
    [XmlElement(ElementName="alim_code")]
    public string Alim_code { get; set; }
    [XmlElement(ElementName="const_code")]
    public string Const_code { get; set; }
    [XmlElement(ElementName="teneur")]
    public string Teneur { get; set; }
    [XmlElement(ElementName="min")]
    public Min Min { get; set; }
    [XmlElement(ElementName="max")]
    public Max Max { get; set; }
    [XmlElement(ElementName="code_confiance")]
    public string Code_confiance { get; set; }
    [XmlElement(ElementName="source_code")]
    public Source_code Source_code { get; set; }
}

Now you can use `XmlSerializer class to deserialize it :

XmlSerializer serializer = new XmlSerializer(typeof(List<COMPO>));
List<COMPO> compos = null;
using (var reader = new StringReader(xml))
{
   compos = (List<COMPO>)serializer.Deserialize(reader);
}

EDIT:

In that case add another type for Table which would be :

[XmlRoot(ElementName="Table")]
public class Table {
    [XmlElement(ElementName="COMPO")]
    public List<COMPO> COMPO { get; set; }
}

and now the adjust the de-serialization code accordingly:

XmlSerializer serializer = new XmlSerializer(typeof(Table));
Table table = null;
using (var reader = new StringReader(xml))
{
   compos = (Table)serializer.Deserialize(reader);
}

I would use Xml Linq. There are some items that can be null that you need to handle properly. See code below

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml;
using System.Xml.Linq;
using System.Globalization;

namespace ConsoleApplication1
{
    class Program
    {
        const string FILENAME = @"c:\temp\test.xml";
        static void Main(string[] args)
        {
            XDocument doc = XDocument.Load(FILENAME);
            IFormatProvider provider = CultureInfo.InvariantCulture;

            List<Compo> compos = doc.Descendants("COMPO").Select(x => new Compo() {
                alim_code = (int?)x.Element("alim_code"),
                const_code = (int?)x.Element("const_code"),
                teneur =  (string)x.Element("teneur") == "" ? null : (decimal?)Convert.ToDecimal((string) x.Element("teneur"),provider),
                min = (string)x.Element("min") == "" ? null : (decimal?)Convert.ToDecimal((string) x.Element("teneur"),provider),
                max = (string)x.Element("max") == "" ? null : (decimal?)Convert.ToDecimal((string) x.Element("teneur"),provider),
                code_confiance = (string)x.Element("code_confiance"),
                source_code = (string)x.Element("source_code") == "" ? null : (int?)int.Parse(((string)x.Element("source_code")).Trim())
            }).ToList();
        }
    }
    public class Compo
    {
        public int? alim_code {get; set;}
        public int? const_code {get; set;}
        public decimal? teneur {get; set;}
        public decimal? min {get; set;}
        public decimal? max {get; set;}
        public string code_confiance {get; set;}
        public int? source_code { get; set; }
    }
}