DLL et CSV

Quand je teste avec ton 2eme fichier, les valeurs

 Mesurande m = test.TrouveMesurande("Current", "BLA-.UH[48]0...E..22");

Ca marche

Essaye ça

        /// <summary>
        /// Construit une instance de DonneeTheolit à partir d'un csv
        /// </summary>
        /// <param name="Filename"></param>
        public ImportDonneTheolit(string Filename)
        {
            filename = Filename;
            if (!File.Exists(Filename))
                throw new Exception("Fichier introuvable");

            if (Path.GetExtension(Filename).ToLower() != ".csv")
                throw new Exception("Mauvaise extension");

            //Lecture du fichier
            string[] lesLignes = File.ReadAllLines(Filename, Encoding.Default);

            //Hypothèse 1, les métadatas sont toujours dans les 10 premières lignes
            List<string[]> metadatas = (from l in lesLignes.Take(10)
                                        select l.Split(';')
                                        ).ToList();

            //les hypothèses 2 et 3 ne sont pas applicables à tous les fichiers

            //hypothèse 4, le modèle AAAA_XX de la dernière ligne de métadatas permet de générer les prototypes.
            //dans un premier temps en groupant les entêtes en fonction de XX
            //dans un seconde temps en en tirerant les prototypes
            var entetesIndexes = metadatas[9].Select((texte, ind) => new { texte, ind });
            List<PrototypeMesurande> prototypes = (from x in entetesIndexes
                        let m = Regex.Match(x.texte, @"^(?<entete>[\w_]+)_(?<numero>\d+)$")
                        where m.Success
                        group new { ind = x.ind, numero = m.Groups["numero"].Value, entete = m.Groups["entete"].Value } by m.Groups["numero"].Value into g

                        select new PrototypeMesurande(metadatas[0][g.First().ind], g.First().ind, g.Select(y => y.entete).ToArray())
                        ).ToList();

            //hypothèse 5, l'index de la colonne MLFB_RegEx change mais son nom reste le même
            int indexRegex = entetesIndexes.First(x => x.texte == "MLFB_RegEx").ind;

            //hypothèses 6, la dernière ligne du fichier est a exclure de l'import
            var import = lesLignes.Skip(10).ToList();//on exclue les 10 premières ligne du fichier
            import = import.Take(import.Count - 1).ToList();//on exclue la dernière ligne

            //import des données
            Datas = (from l in import
                     let split = l.Split(';')
                     select new DonneeTheolit(split[0], split[indexRegex], ToMesurandes(split, prototypes))
                     ).ToList();
        }

J'avais bien compris que tu voulais t'en servir.
Et à raison, manifestement.
Mais tes explications initiales étaient trop floues et je n'ai pas vu l'intérêt de la chose.

Bon j'ai pu générer mes prototypes avec ces numéros.
Mais il y'a 2 nouveaux problèmes avec ce fichier.

D'abord la dernière ligne. Une ligne commMLFB_RegExe ça est-elle toujours présente?
Ensuite dans le premier fichier la colonne que tu avais appelées "Données-Regex" était la colonne E. Dans le second, il y a 3 colonnes dont les valeurs y ressemble, O, P et S. Celle qui y ressemble le plus est la O est s'appelle MLFB_RegEx. Est ce bien cette colonne et, s'appelle t elle toujours ainsi?

Question subsidiaire, y a t il toujours une colonne "Nber_of_Variable" (même si j'ai fait sans, ça peut permettre de vérifier)

Le 1/03 je t'ai écrit

Bon j'aurais eu d'autres questions, mais j'ai émis des hypothèses (elles sont en commentaire dans le code).
Si elle ne sont pas exactes, faudra me le dire

Et ça n'est que maintenant, parce que volontairement je joue à l'idiot pour te forcer la main, que tu commences à esquisser

C’est à dire pas de pattern défini ?

ce qui sous entends qu'au moins une hypothèse n'est pas valable du tout (pas juste qu'il faut l'adapter un peu), mais tu ne le dis toujours pas clairement.

Je n'ai pas accès à tes fichiers (à part 2 morceaux dont je ne sais pas à quel point ils sont représentatifs). Je ne peux pas me faire une idée générale de ce qui pourrait marcher.
Donc quand je te dis "j'ai constaté... je pars sur cette base..." et que c'est faux, c'est toi qui perd du temps à ne pas le dire.

On est bien d'accord que le but c'est que l'opérateur n'ait pas à définir où commence chaque mesurande? (Et je veux une réponse claire)

Dans ce cas il faut trouver quelque chose de reproductible.

Au début, tu parlais des nombres à la fin des entêtes de la ligne 10.
Que tous les 1 correspondent à un mesurande, les 2 au suivant etc...

Est ce que ça, c'est toujours vrai? (Et je veux une réponse claire)

Dans ce cas, il faut changer la regex.

Si c'est toujours Variable_ suivit du nom de la variable, alors la regex est

@"^Variable_\w+$"

OK mais dans tes autres "vrais" fichiers c'est comment?

Non ça c’est pas l’hypothèse, c’est le code qui en découle.

L’hypothèse c’est

//Hypothèse 2, le nom d'un mesurande est toujours précédé de varXXX

une précision que je n’avais pas faite c’est XXX représente un nombre à trois chiffres.

• Est ce que cette hypothèse s’applique au nouveau fichier?
• Voire s’applique t elle tout court (en gros avais tu modifié les noms dans le premier fichier envoyé)?

C’est certain commenter ne peut pas fonctionner.
On a besoin de savoir à quelle colonne commence chaque mesurande pour la suite.

Mais comment faudrait il modifier cette hypothèse pour qu’elle soit applicable à ce fichier et au précédent ?

Oui bonne piste.
Que dit l'énoncé de l'hypothèse 2?
Est applicable à ce fichier?

Ok, je viens de tester rapidement.

As tu exécuté en pas à pas et espionné les variable pour voir ce qui se passe?
Je ne pense pas.
J'ai cerné d'où vient le problème en quelques instants, et vu le problème en question si tu l'avais fait toi aussi.

Pour progresser savoir débogger est aussi important que savoir coder (p'tet même plus).

Je t'invite donc par commencer à regarder ce qui se passe et revenir me dire ce que tu constates.

Je suis en déplacement jusqu’au début de la semaine prochaine, je n’ai que ma tablette, et elle ne me permet pas de coder.

Quoiqu’il en soit j’aurais besoin du fichier (anonymisé bien sûr) qui fait planter

Ha, je n’ai pas bien vu l’image peut-être.

Et la classe DonneeTheolit?

A la ligne où tu as l’erreur

D'accord, mais où dois-je ajouter ce public ?
Sachant que "Datas" est présent là:

 public ImportDonneTheolit(string Filename)
        {
 Datas = (from l in lesLignes.Skip(10)
                     let split = l.Split(';')
                     select new DonneeTheolit(split[0], split[4], ToMesurandes(split, prototypes))
                     ).ToList();
        }

et là :

 public List<DonneeTheolit> Datas { get; private set; }

Il faut que cette propriété soit public aussi

Bonjour

Suite à ton MP, je ne conçois le MP que s’il y a un besoin impérieux de discrétion.
Je te réponds donc ici.

Il faut que la classe soit public, pas seulement le constructeur.
Il faut probablement aussi que la classe Mesurande soit public.

Si c’est le cas, il faudra poster le code et peut-être aussi des captures d’écran.

Alors ton problème c'est que tu n'as pas compris ce qu'est un objet.
Et C# c'est un langage "tout" objet.

Ça

Mesurande m = test.TrouveMesurande("Pression","Lower_Tol", "ALB-.M[12]...V.190");

c'est à la fois, inutile et "impossible".
Impossible puisque cet objet Mesurande encapsule toutes les valeurs de pression qui correspondent à ALB-.M[12]...V.190. On ne peut donc pas mettre cette valeurs (qui est un double) dans un Mesurande.
Et donc c'est inutile car m contient déjà cette valeur, il suffit de lui "prendre".

Le meilleur conseil que je puisse te donner c'est de trouver un cours ou un tuto sur l'objet avant d'aller plus loin dans te prochains.

J'en ai écrit un qui s'adresse aux autodidactes, c'est pas académique, mais c'est basé sur mes propres ratés.
https://codes-sources.commentcamarche.net/faq/11239-la-programmation-objet-appliquee-a-net-par-l-exemple-partie-1-sur-3

Mais y'en a pleins d'autres.

Bon j'aurais eu d'autres questions, mais j'ai émis des hypothèses (elles sont en commentaire dans le code).
Si elle ne sont pas exactes, faudra me le dire

Soit le CSV

Name:;test;;;;Modification;;var1;Température;;var2;Pression;var3;Hygrométrie;;;
Nr:;123;;;;Comments;;Nom Var;Temp;;nameVar2;;;;;;
Cout ;1234;;;;Control;;;;;;;;;;;
Modification date:;23/02/2021;;;;;;;;;;;;;;;
Resp of modif.:;moi;;;;;;Unit;deg C;;;;;;;;
File Name;test;;;;;;;;;;;;;;;
File Place;c:\Temp;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;
Name;Type;Yeux;Taille;Donnée_RegEx;donnée_test;blabla;bla;Nominal_Value_1;Lower_Tol_1;Upper_Tol_1;Nominal_Value_2;Lower_Tol_2;Nominal_Value_3;Lower_Tol_3;Upper_Tol_3;Autre_3
Pauline;Feminin;bleu;170;BLA-.P[12]...B.170;.;.;.;-5;-1;1;0;-60;1;2;3;4
Maxime;Masculin;vert;190;ALB-.M[12]...V.190;.;.;.;-0,5;-0,2;0,2;0;-19;1;2;3;4

Ce qui vu d'Excel donne


Voici d'abord 3 classes qui permettent de structurer les données

    /// <summary>
    /// Correspond à un relevé pour un mesurande
    /// </summary>
    class Mesurande
    {
        public Mesurande(string LeNom, Dictionary<string, double> LesDatas)
        {
            Nom = LeNom;
            Datas = LesDatas;
        }

        public string Nom { get; private set; }

        public Dictionary<string, double> Datas { get; private set; }

        public override string ToString()
        {
            return string.Format("{0}, {1} valeurs", Nom, Datas.Count);
        }

    }

    /// <summary>
    /// Permet de construire un mesurande à partir d'un fichier
    /// </summary>
    class PrototypeMesurande
    {
        public PrototypeMesurande(string LeNom, int LIndex, string[] LesEntetes)
        {
            Nom = LeNom;
            Index = LIndex;
            Entetes = LesEntetes.ToList();
        }

        public string Nom { get; private set; }

        public int Index { get; private set; }

        public List<string> Entetes { get; set; }
    }

    /// <summary>
    /// Correspond à une ligne de mesure
    /// </summary>
    class DonneeTheolit
    {
        public DonneeTheolit(string LeNom, string LaDonneeRegex, List<Mesurande> LesMesurandes)
        {
            Nom = LeNom;
            DonneeRegex = LaDonneeRegex;
            Mesurandes = LesMesurandes;
        }

        public string Nom { get; private set; }

        public string DonneeRegex { get; private set; }

        public List<Mesurande> Mesurandes { get; private set; }

        public override string ToString()
        {
            return string.Format("{0}, {1} mesurandes", Nom, Mesurandes.Count);
        }
    }

Puis la classe qui lit le fichier et met ça en musique

    /// <summary>
    /// Classe qui gère le tout
    /// </summary>
    class ImportDonneTheolit
    {
        private string filename;

        /// <summary>
        /// Construit une instance de DonneeTheolit à partir d'un csv
        /// </summary>
        /// <param name="Filename"></param>
        public ImportDonneTheolit(string Filename)
        {
            filename = Filename;
            if (!File.Exists(Filename))
                throw new Exception("Fichier introuvable");

            if (Path.GetExtension(Filename).ToLower() != ".csv")
                throw new Exception("Mauvaise extension");

            //Lecture du fichier
            string[] lesLignes = File.ReadAllLines(Filename, Encoding.Default);

            //Hypothèse 1, les métadatas sont toujours dans les 10 premières lignes
            List<string[]> metadatas = (from l in lesLignes.Take(10)
                                        select l.Split(';')
                                        ).ToList();

            //Hypothèse 2, le nom d'un mesurande est toujours précédé de varXXX
            // => on peut extraire l'index de début de chaque mesurande
            List<int> indexMesurandes = metadatas[0].Select((texte, ind) => new { texte, ind }).Where(x => Regex.IsMatch(x.texte, @"^var\d+$")).Select(x => x.ind + 1).ToList();

            //Hypothèse 3, y'a pas de colonne vide entre 2 mesurandes
            // => on peut extraire les prototypes, sans s'embêter avec les _XX
            metadatas[9] = (from x in metadatas[9]
                            let m = Regex.Match(x, @"_\d+$")
                            select m.Success ? x.Replace(m.Value, "") : x
                            ).ToArray();

            int i, index1;
            List<PrototypeMesurande> prototypes = new List<PrototypeMesurande>();

            for (i = 0; i < indexMesurandes.Count - 1; i++)
            {
                index1 = indexMesurandes[i];
                int index2 = indexMesurandes[i + 1];
                prototypes.Add(new PrototypeMesurande(metadatas[0][index1], index1, metadatas[9].Skip(index1).Take(index2 - index1).ToArray()));
            }
            //le dernier mesurande s'arrête à la fin de la ligne
            index1 = indexMesurandes[i];
            prototypes.Add(new PrototypeMesurande(metadatas[0][index1], index1, metadatas[9].Skip(index1).ToArray()));

            //import des données
            Datas = (from l in lesLignes.Skip(10)
                     let split = l.Split(';')
                     select new DonneeTheolit(split[0], split[4], ToMesurandes(split, prototypes))
                     ).ToList();
        }

        private List<Mesurande> ToMesurandes(string[] Split, List<PrototypeMesurande> Prototypes)
        {
            List<Mesurande> m = new List<Mesurande>();
            foreach (PrototypeMesurande p in Prototypes)
            {
                m.Add(new Mesurande(p.Nom,
                                        (from e in p.Entetes
                                        let indexE = p.Entetes.IndexOf(e)
                                        let indexS = p.Index + indexE
                                        select new { Key = p.Entetes[indexE], Value = Convert.ToDouble(Split[indexS]) }
                                        ).ToDictionary(x => x.Key, x => x.Value)
                        ));
            }


            return m;

        }

        public List<DonneeTheolit> Datas { get; private set; }

        /// <summary>
        /// Retourn eun mesurande selon la colonne DonneeRegex et son nom
        /// </summary>
        /// <param name="Nom"></param>
        /// <param name="DonneeRegex"></param>
        /// <returns></returns>
        public Mesurande TrouveMesurande(string Nom, string DonneeRegex)
        {
            return Datas.FirstOrDefault(d => d.DonneeRegex == DonneeRegex)?.Mesurandes.FirstOrDefault(m => m.Nom == Nom);
        }

        public override string ToString()
        {
            return string.Format("{0}, {1} lignes de mesures", filename, Datas.Count);
        }
    }

Enfin le code qui utilise cette classe

            ImportDonneTheolit test = new ImportDonneTheolit("TestTheolit.csv");

            Mesurande m = test.TrouveMesurande("Pression", "ALB-.M[12]...V.190");

Ce qui donne

Ok, donc plus loin on pourrait imaginer une pression avec elle aussi plusieurs colonnes de données.

On va arrêter de parler de variable qui a plusieurs sens, dont un en développement, mais de mesurande (phénomène physique à mesurer) qui n’a qu’un sens qui correspond à ton tableau.

Les colonnes de données par mesurande sont elles toujours au nombre de 3?

Si ta capture m'avait permis de comprendre, je ne t'aurais pas demandé un fichier représentatif
Envoyer ta capture ne sert à rien.

Et je ne comprend toujours pas ce que vient faire Température là dedans, j'avais espéré comprendre avec un fichier représentatif