public static CInventaire GetInventaire(object obj, IEnumerable <Type> listeTypesQuOnVeutPas, params IFournisseurInventaire[] fournisseurs) { CInventaire inventaire = new CInventaire(listeTypesQuOnVeutPas); FillInventaire(obj, inventaire, fournisseurs); return(inventaire); }
private static void FillInventaire(object obj, CInventaire inventaire, IFournisseurInventaire[] fournisseurs) { if (inventaire.ShouldExplore(obj)) { foreach (IFournisseurInventaire fournisseur in fournisseurs) { fournisseur.FillInventaireNonRecursif(obj, inventaire); } inventaire.SetExploré(obj); ArrayList lst = new ArrayList(inventaire.GetObjectsAInventorier().ToArray()); foreach (object objInv in lst) { FillInventaire(objInv, inventaire, fournisseurs); } } }
public void FillInventaireNonRecursif(object obj, CInventaire inventaire) { CChercheurDeTypesQuiUtilisentUnType <TypeRecherche> chercheur = new CChercheurDeTypesQuiUtilisentUnType <TypeRecherche>(inventaire.ListeDesTypesAPasExplorer); #region Recherche dans les Propriétés /* // Ca ne sert à rien de parcourir les Propriétés car elles sont traitée en tant que Methode Get_method et Set_method * foreach (PropertyInfo infoProp in obj.GetType().GetProperties()) * { * bool bIsEnumerable = false; * Type tpProp = infoProp.PropertyType; * //if (tpProp.IsArray) * // tpProp = tpProp.GetElementType(); * if(typeof(IEnumerable).IsAssignableFrom(tpProp)) * bIsEnumerable = true; * * //object valeurEvaluee = infoProp.GetValue(obj, null); * //ICollection collection = valeurEvaluee as ICollection; * * if (tpProp != typeof(object)) * { * if (bIsEnumerable) * { * try * { * IEnumerable objetEnumerable = infoProp.GetValue(obj, null) as IEnumerable; * if (objetEnumerable != null) * { * // Ici il faut évaluer chaque objet de la collection et l'ajouter à l'inventaire s'il est du type recherché * bool bDuBonType = false; * foreach (object item in objetEnumerable) * { * if(bDuBonType) * inventaire.AddObject(item, false); * else if (m_typeRecherche.IsAssignableFrom(item.GetType()) || item.GetType().IsAssignableFrom(m_typeRecherche)) * { * // Pour le premier item, on test forcément s'il est du bon type. Si oui, on flag bDuBonType pour nepas reteser chaque item de la collection * bDuBonType = true; * inventaire.AddObject(item, false); * } * else if (chercheur.IsDansLaListe(item.GetType())) * { * bDuBonType = true; * inventaire.AddObject(item, true); * } * } * } * } * catch (Exception e) * { * Console.WriteLine("Problème dans l'évaluation de l'objetEnumerable"); * Console.WriteLine(e.Message); * } * } * // Sinon, ce n'est pas une collection * else if (m_typeRecherche.IsAssignableFrom(tpProp) || tpProp.IsAssignableFrom(m_typeRecherche)) * { * // PROPRIETE DIRECTE: Ajoute directement à l'inventaire * try * { * object val = infoProp.GetValue(obj, null); * inventaire.AddObject(val, false); * } * catch (Exception e) * { * Console.WriteLine("Impossible d'évaluer la Propriété :" + infoProp.Name + " sur l'objet : " + obj.ToString()); * Console.WriteLine(e.Message); * } * * } * else * { * if (chercheur.IsDansLaListe(tpProp)) * { * // PROPRIETE INDIRECTE: Ajoute le valeur de l'objet qui utilise le type recherché * try * { * object valeurProp = infoProp.GetValue(obj, null); * inventaire.AddObject(valeurProp, true); * } * catch * { * Console.WriteLine("Impossible d'évaluer la Propriété :" + infoProp.Name + " sur l'objet : " + obj.ToString()); * } * } * } * } * * } */ #endregion #region Recherche dans les Methodes foreach (MethodInfo infoMethod in obj.GetType().GetMethods()) { if (infoMethod.IsStatic) { continue; } if (infoMethod.GetParameters().Count() > 0) { continue; } bool bIsEnumerable = false; Type tpMethod = infoMethod.ReturnType; if (typeof(IEnumerable).IsAssignableFrom(tpMethod) && tpMethod != typeof(string)) // on élimine les String, car le string est un IEnumerable et du coup ça fait parcourir chaque caractère de la chaine pour rien { bIsEnumerable = true; } if (tpMethod != typeof(object)) { if (bIsEnumerable) { try { IEnumerable objetEnumerable = infoMethod.Invoke(obj, null) as IEnumerable; if (objetEnumerable != null) { // Ici il faut évaluer chaque objet de la collection et l'ajouter à l'inventaire s'il est du type recherché bool bDuBonType = false; bool bHorsInventaire = false; bool bNePasExplorer = m_bNePasExplorerLeTypeRecherche; foreach (object item in objetEnumerable) { if (bDuBonType) { inventaire.AddObject(item, bHorsInventaire, bNePasExplorer); } else { // Pour le premier item, on test forcément s'il est du bon type. Si oui, on flag bDuBonType pour ne pas reteser chaque item de la collection if (m_typeRecherche.IsAssignableFrom(item.GetType()) || item.GetType().IsAssignableFrom(m_typeRecherche)) { bDuBonType = true; bHorsInventaire = false; bNePasExplorer = m_bNePasExplorerLeTypeRecherche; } else if (chercheur.IsDansLaListe(item.GetType())) { bDuBonType = true; bHorsInventaire = true; bNePasExplorer = false; } if (bDuBonType) { inventaire.AddObject(item, bHorsInventaire, bNePasExplorer); } } } } } catch (Exception e) { Console.WriteLine("Problème dans l'évaluation de l'objetEnumerable"); Console.WriteLine(e.Message); } } // Sinon, ce n'est pas une collection else if (m_typeRecherche.IsAssignableFrom(tpMethod) || tpMethod.IsAssignableFrom(m_typeRecherche)) { // PROPRIETE DIRECTE: Ajoute directement à l'inventaire try { object val = infoMethod.Invoke(obj, null); inventaire.AddObject(val, false, m_bNePasExplorerLeTypeRecherche); } catch (Exception e) { Console.WriteLine("Impossible d'évaluer la Propriété :" + infoMethod.Name + " sur l'objet : " + obj.ToString()); Console.WriteLine(e.Message); } } else { if (chercheur.IsDansLaListe(tpMethod)) { // PROPRIETE INDIRECTE: Ajoute le valeur de l'objet qui utilise le type recherché try { object valeurProp = infoMethod.Invoke(obj, null); inventaire.AddObject(valeurProp, true, false); } catch { Console.WriteLine("Impossible d'évaluer la Propriété :" + infoMethod.Name + " sur l'objet : " + obj.ToString()); } } } } } #endregion }