//------------------------------------------------
        public CResultAErreurType <CObjetDonnee> FindObjet(
            DataRow rowSource,
            CContexteImportDonnee contexteImport,
            CValeursImportFixe valeursFixes,
            ref string strFiltre)
        {
            CResultAErreurType <CObjetDonnee> resObjet = new CResultAErreurType <CObjetDonnee>();
            CResultAErreur res = CResultAErreur.True;

            StringBuilder blFiltre = new StringBuilder();

            if (valeursFixes != null)
            {
                foreach (KeyValuePair <string, object> kv in valeursFixes.ValeursFixes)
                {
                    blFiltre.Append(kv.Key);
                    blFiltre.Append("=");
                    blFiltre.Append(kv.Value == null ? "null" : kv.Value.ToString());
                    blFiltre.Append(";");
                }
            }


            //Création du filtre
            CComposantFiltreDynamiqueEt compoPrincipal = new CComposantFiltreDynamiqueEt();

            //Recherche à partir des champs simples
            foreach (CMappageChampSimple mapSimple in MappagesChampsSimples)
            {
                if (mapSimple.UseAsKey)
                {
                    res = mapSimple.GetValue(rowSource, contexteImport);
                    if (!res)
                    {
                        res.EmpileErreur(I.T("Erreur while searching object|20093"));
                        resObjet.EmpileErreur(res.Erreur);
                        return(resObjet);
                    }

                    //Stockage valeur témoin
                    CSourceSmartImportField sourceField = mapSimple.Source as CSourceSmartImportField;
                    if (sourceField != null)
                    {
                        contexteImport.SetValeurTemoin(sourceField.NomChampSource, res.Data);
                    }

                    blFiltre.Append(mapSimple.Propriete.NomPropriete);
                    if (res.Data == null)
                    {
                        CComposantFiltreDynamiqueTestNull testNull = new CComposantFiltreDynamiqueTestNull();
                        testNull.Champ    = mapSimple.Propriete;
                        testNull.TestNull = true;
                        compoPrincipal.AddComposantFils(testNull);
                        blFiltre.Append("=null;");
                    }
                    else
                    {
                        CComposantFiltreDynamiqueValeurChamp testValeur = new CComposantFiltreDynamiqueValeurChamp();
                        testValeur.Champ            = mapSimple.Propriete;
                        testValeur.IdOperateur      = CComposantFiltreOperateur.c_IdOperateurEgal;
                        testValeur.ExpressionValeur = new C2iExpressionConstante(res.Data);
                        compoPrincipal.AddComposantFils(testValeur);
                        blFiltre.Append("=");
                        blFiltre.Append(res.Data.ToString());
                        blFiltre.Append(";");
                    }
                }
            }


            //Recherche à partir des objets parents
            foreach (CMappageEntiteParente mapParent in m_listeMappagesParents)
            {
                if (mapParent.UseAsKey)
                {
                    CResultAErreurType <CObjetDonnee> resParent = mapParent.GetObjetAssocie(rowSource, contexteImport, false);
                    if (!resParent)
                    {
                        resObjet.EmpileErreur(resParent.Erreur);
                        return(resObjet);
                    }
                    CObjetDonneeAIdNumerique      objetId = resParent.DataType as CObjetDonneeAIdNumerique;
                    CDefinitionProprieteDynamique defId   = null;
                    object valeurTest = null;

                    if (typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(mapParent.Propriete.TypeDonnee.TypeDotNetNatif))
                    {
                        defId = new CDefinitionProprieteDynamiqueDotNet(
                            "Id",
                            "Id",
                            new CTypeResultatExpression(typeof(int), false),
                            false,
                            true, "");
                        defId.InsereParent(mapParent.Propriete);
                        valeurTest = objetId != null?objetId.Id:-1;
                    }
                    else if (CObjetDonnee.TypeManageIdUniversel(mapParent.Propriete.TypeDonnee.TypeDotNetNatif))
                    {
                        defId = new CDefinitionProprieteDynamiqueDotNet("Universal id",
                                                                        "IdUniversel",
                                                                        new CTypeResultatExpression(typeof(string), false),
                                                                        false, true, "");
                        defId.InsereParent(mapParent.Propriete);
                        valeurTest = resParent.DataType != null ? resParent.DataType.IdUniversel : null;
                    }
                    else
                    {
                        resObjet.EmpileErreur(I.T("Can not search objet of type @1|20094",
                                                  DynamicClassAttribute.GetNomConvivial(mapParent.Propriete.TypeDonnee.TypeDotNetNatif)));
                        return(resObjet);
                    }
                    blFiltre.Append(defId.NomPropriete);

                    if (resParent.DataType == null)
                    {
                        CComposantFiltreDynamiqueTestNull testNull = new CComposantFiltreDynamiqueTestNull();
                        testNull.Champ    = defId;
                        testNull.TestNull = true;
                        compoPrincipal.AddComposantFils(testNull);
                        blFiltre.Append("=null;");
                    }
                    else
                    {
                        CComposantFiltreDynamiqueValeurChamp testValeur = new CComposantFiltreDynamiqueValeurChamp();
                        testValeur.Champ            = defId;
                        testValeur.IdOperateur      = CComposantFiltreOperateur.c_IdOperateurEgal;
                        testValeur.ExpressionValeur = new C2iExpressionConstante(valeurTest);
                        compoPrincipal.AddComposantFils(testValeur);
                        blFiltre.Append("=");
                        blFiltre.Append(valeurTest.ToString());
                        blFiltre.Append(";");
                    }
                }
            }
            if (blFiltre.Length == 0)//Pas de filtre
            {
                return(resObjet);
            }
            strFiltre = blFiltre.ToString();
            CObjetDonnee objet = contexteImport.GetEntiteForFiltre(TypeEntite, strFiltre);

            if (objet != null)
            {
                resObjet.DataType = objet;
                return(resObjet);
            }

            CFiltreDynamique filtre = new CFiltreDynamique(contexteImport.ContexteDonnee);

            filtre.TypeElements       = TypeEntite;
            filtre.ComposantPrincipal = compoPrincipal;
            res = filtre.GetFiltreData();
            if (res && res.Data is CFiltreDataAvance)
            {
                if (valeursFixes != null)
                {
                    CFiltreDataAvance filtreData = res.Data as CFiltreDataAvance;
                    StringBuilder     blAdd      = new StringBuilder();
                    int nParam = filtreData.Parametres.Count + 1;
                    foreach (KeyValuePair <string, object> kv in valeursFixes.ValeursFixes)
                    {
                        if (kv.Value == null)
                        {
                            blAdd.Append("HasNo(");
                            blAdd.Append(kv.Key);
                            blAdd.Append(") and ");
                        }
                        else
                        {
                            blAdd.Append(kv.Key);
                            blAdd.Append("=@");
                            blAdd.Append((nParam++));
                            blAdd.Append(" and ");
                            filtreData.Parametres.Add(kv.Value);
                        }
                    }
                    blAdd.Remove(blAdd.Length - 5, 5);
                    if (filtreData.Filtre.Length > 0)
                    {
                        blAdd.Insert(0, " and ");
                    }
                    filtreData.Filtre += blAdd;
                }
                objet = Activator.CreateInstance(TypeEntite, new object[] { contexteImport.ContexteDonnee }) as CObjetDonnee;
                if (objet.ReadIfExists(((CFiltreData)res.Data)))
                {
                    contexteImport.SetEntiteForFiltre(strFiltre, objet);
                    resObjet.DataType = objet;
                    return(resObjet);
                }
            }
            else
            {
                res.EmpileErreur(I.T("Erreur while searching object|20093"));
                resObjet.EmpileErreur(res.Erreur);
                return(resObjet);
            }
            return(resObjet);
        }
        //------------------------------------------------
        private CResultAErreur UpdateObjet(
            DataRow row,
            CObjetDonnee objet,
            bool bIsNewObject,
            CContexteImportDonnee contexteImport,
            CValeursImportFixe valeursFixes)
        {
            CResultAErreur result = CResultAErreur.True;

            foreach (CMappageChampSimple mappage in MappagesChampsSimples)
            {
                if (mappage.Source != null && mappage.Source.ShouldImport(row, contexteImport))
                {
                    try
                    {
                        contexteImport.PushChamp(mappage.Propriete);
                        result = mappage.GetValue(row, contexteImport);
                        if (!result)
                        {
                            contexteImport.AddLog(new CLigneLogImport(
                                                      ETypeLigneLogImport.Error,
                                                      row,
                                                      mappage.Source.LibelleSource,
                                                      contexteImport,
                                                      result.Erreur.ToString()));
                            return(result);
                        }

                        try
                        {
                            CInterpreteurProprieteDynamique.SetValue(objet, mappage.Propriete, result.Data);

                            //Stockage valeur témoin
                            CSourceSmartImportField sourceField = mappage.Source as CSourceSmartImportField;
                            if (sourceField != null)
                            {
                                result = CInterpreteurProprieteDynamique.GetValue(objet, mappage.Propriete);
                                if (result)
                                {
                                    contexteImport.SetValeurTemoin(sourceField.NomChampSource, result.Data);
                                }
                                result = CResultAErreur.True;
                            }
                        }
                        catch (Exception e)
                        {
                            result.EmpileErreur(new CErreurException(e));
                            result.EmpileErreur(I.T("Error while affecting value @1 to field @2|20097",
                                                    result.Data == null ? "null" : result.Data.ToString()));
                            contexteImport.AddLog(new CLigneLogImport(
                                                      ETypeLigneLogImport.Error,
                                                      row,
                                                      mappage.Source.LibelleSource,
                                                      contexteImport,
                                                      result.Erreur.ToString()));
                            return(result);
                        }
                    }
                    finally
                    {
                        contexteImport.PopChamp();
                    }
                }
            }

            foreach (CMappageEntiteParente mapParent in MappagesEntitesParentes)
            {
                if (mapParent.Source != null && mapParent.Source.ShouldImport(row, contexteImport))
                {
                    try
                    {
                        contexteImport.PushChamp(mapParent.Propriete);

                        CResultAErreurType <CObjetDonnee> resObjet = mapParent.GetObjetAssocie(row, contexteImport, true);
                        if (!resObjet)
                        {
                            contexteImport.AddLog(new CLigneLogImport(
                                                      ETypeLigneLogImport.Error,
                                                      row,
                                                      mapParent.Source.LibelleSource,
                                                      contexteImport,
                                                      resObjet.MessageErreur));
                        }
                        else
                        {
                            try
                            {
                                if (mapParent.AlternativeSetMethodInfo != null)
                                {
                                    mapParent.AlternativeSetMethodInfo.Invoke(objet, new object[] { resObjet.DataType });
                                }
                                else
                                {
                                    result = CInterpreteurProprieteDynamique.SetValue(objet, mapParent.Propriete, resObjet.DataType);
                                    if (!result && mapParent.Propriete is CDefinitionProprieteDynamiqueDotNet)
                                    {
                                        //Tente affectation via fonction spécifique
                                        PropertyInfo info = objet.GetType().GetProperty(mapParent.Propriete.NomProprieteSansCleTypeChamp);
                                        if (info != null)
                                        {
                                            SpecificImportSetAttribute spec = info.GetCustomAttribute <SpecificImportSetAttribute>(true);
                                            if (spec != null)
                                            {
                                                MethodInfo method = objet.GetType().GetMethod(spec.NomMethodeSetSpecifique);
                                                if (method != null)
                                                {
                                                    method.Invoke(objet, new object[] { resObjet.DataType });
                                                }
                                                mapParent.AlternativeSetMethodInfo = method;
                                            }
                                        }
                                    }
                                }
                            }
                            catch (Exception e)
                            {
                                result.EmpileErreur(new CErreurException(e));
                                result.EmpileErreur(I.T("Error while affecting value @1 to field @2|20097",
                                                        result.Data == null ? "null" : result.Data.ToString()));
                                contexteImport.AddLog(new CLigneLogImport(
                                                          ETypeLigneLogImport.Error,
                                                          row,
                                                          mapParent.Source.LibelleSource,
                                                          contexteImport,
                                                          result.Erreur.ToString()));
                                return(result);
                            }
                        }
                    }
                    finally
                    {
                        contexteImport.PopChamp();
                    }
                }
            }

            if (valeursFixes != null)
            {
                foreach (KeyValuePair <string, object> kv in valeursFixes.ValeursFixes)
                {
                    objet.Row[kv.Key] = kv.Value == null ? DBNull.Value : kv.Value;
                }
            }

            foreach (CMappageEntitesFilles mapFille in m_listeMappagesFilles)
            {
                try
                {
                    contexteImport.PushChamp(mapFille.Propriete);
                    result = mapFille.ImportRow(row, contexteImport, objet);
                    if (!result)
                    {
                        contexteImport.AddLog(new CLigneLogImport(
                                                  ETypeLigneLogImport.Error,
                                                  row,
                                                  "",
                                                  contexteImport,
                                                  result.Erreur.ToString()));
                        result = CResultAErreur.True;
                    }
                }
                finally
                {
                    contexteImport.PopChamp();
                }
            }

            return(result);
        }