Discussion :

[Luc1an0]

Bonjour,

Je suis sur un problème assez épineux.

Je voudrais passer un type (au format : Type monType) à une fonction ayant une signature comme cela :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
List<T> MaFonction<T>(params) { ... }

En fait, l'idée générale est de charger une liste d'objet dans une propriété d'un objet. Via un attribut, je définis que telle propriété, s'associe à tel type :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
class Marque 
{
public int Identifiant { get; set; }
public string Nom { get; set; }
}
 
class Utilisateur 
{
public string Nom { get; set; }
 
[MonAttributType(typeof(Marque))]
public IEnumerable<Marque> Marques { get; set; }
 
}

Et de manière générique, allez charger par utilisateur, sa liste de marque, en utilisant la fonction utilisé plus haut. Et c'est là que je n'arrive pas à relayer l'information à ma fonction pour lui dire que je veux une liste d'un certain type connu... Un peu de cette manière :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
foreach(Property p in Utilisateur.GetProperties()) 
{
   if(p.GetAttributes<MonAttributType>() != null)
{
Type monType = p.GetAttributes<MonAttributType>().First().MonType;
 
// là je dois appeler ma fonction citée plus haut, en lui passant le type définit par l'attribut de propriété avec ce genre d'appel, mais non supporté
var monResultat = MaFonction<monType.GetType()>(mesDonnees);
 
 
}
 
}

En gros, c'est du mapping DB <-> Classe objet, et jusqu'à maintenant, je gérais seulement les objets "plats". Je souhaite maintenant gérer les objets complexes...

Merci à vous d'avance

[youtpout978]

Je ne sais pas ce que tu cherches à faire précisément mais j'ai l'impression que tu complexifie ça.

tu peux simplement faire ça:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
class Utilisateur<T>
	{
		public string Nom { get; set; }
 
		public IEnumerable<T> Marques { get; set; }
 
	}

Tu déclare ton type quand tu initialises ta classe Utilisateur.

[Luc1an0]

Pour être plus précis :

J'ai un "Mapper" qui se charge de lire les attributs d'une classe C# et des ses propriétés, et qui est capable d'associer les champs de base de données à des objets.

Un exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
IEnumerable<MonObjet> values = MonMapper.Select<MonObjet>();

Dans cet exemple, le mapper s'occupe alors, de récupérer les données, conformément au paramétrage fait sur la classe et de construire une liste d'objet en associant les champs de données aux propriétés

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
[DBTable("MaTable" ...)]
class MonObjet 
{
[DBField("MonChampDeDonneePour_UneProp")]
public string UneProp { get; set; }
[DBField("MonChampDeDonneePour_Identifiant")]
public int Identifiant { get; set; }
 
}

Là où je souhaite faire évoluer mon Mapper, c'est que je souhaite récupérer, les données des types complexes dans une propriété de mon objet, en admettant bien entendu que les données de base de données que je vais passer à ma fonction seront présentes pour que le mapper extrait les objets correspondants.

En fait, la question est :

Comment je passe un "Type" comme type générique "T" à une fonction ayant cette signature :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
public T MaFonction<T>(mesParams) { ... }

Et de l'autre côté

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
Type monType; // je récupère le type de classe cible & je m'en sert ensuite comme type générique pour consommer "MaFonction"

Ta solution pourrait être envisageable, mais je veux pouvoir récupérer, si besoin, plusieurs types d'objets différents, sachant que j'ai ce point d'entrée dans mon Mapper :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
T Get<T>(string commandName, DBArgument[] dbArguments, params Type[] args) où je mettrai tous les types dépendants de "T" que je souhaite charger en parallèle du type de base "T" dans les paramètres variables de cette fonction.

Bien entendu, le résultat de la requête SQL exécutée contient toutes les données nécessaires à la construction de mon objet et de ses dépendances.

[Sehnsucht]

un bon lien vaut mieux qu'un long discours

[Luc1an0]

Je n'ai malheureusement aucun lien, étant donné que ce code, c'est le mien

Mais voilà le morceau de code qui me casse la tête:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
 
public static T Get<T>(string command, List<AdapterParameter> parameters = null, params Type[] args)
        {
            DBObjectWrapping mapping = WrapObject<T>();
            T entity = default(T);
            IEnumerable<DbDataReader> results = OleDbDataAdapter.ExecuteQuery(command, parameters);
            foreach (DbDataReader line in results)
            {
                entity = (T)Activator.CreateInstance<T>();
                foreach (DBFieldMapping map in mapping.Mappings.Where(x => x.IsCollection == false))
                    map.PropertyInformation.SetValue(entity, WrapValue(map.PropertyInformation.PropertyType, line.GetValue(line.GetOrdinal(map.DBFieldName))));
 
                break;
            }
 
            if (args != null)
            {
                foreach (Type typ in args)
                {
                    DBFieldMapping map = null;
                    if ((map = mapping.Mappings.Where(x => x.IsCollection && x.TypeCollection == typ).FirstOrDefault()) != null) 
                        map.PropertyInformation.SetValue(entity, FetchList<typ.GetType()>(results));
 
                }
            }
            return entity;
        }

Et basiquement, je voudrais indiquer à ma fonction "FetchList<T>()" que le type "T" provient de la variable "typ"

[youtpout978]

Tu peux récupérer le type de ton générique:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
public Type FunctionGetType<T>()
		{
			return typeof(T);
		}

Mais je crois savoir ce que tu cherches à faire il faut pouvoir récupérer chaque sous objet de ta classe.

Et donc tu veux traiter différemment un objet qui n'est pas un type simple (du genre string, int ...), dans ce cas là le dataattribute n'est pas une mauvaise solution: https://msdn.microsoft.com/en-us/library/z919e8tw.aspx

L'idée c'est que comme tu fais surement actuellement tu examines chaque propriété sauf que si la propriété à l'attribut class par exemple tu rappel ta fonction pour cette propriété ( une fonction récursive peut être pas mal dans ce là) mais attention à bien gérer les liste et autres pour pas faire 50 000 appel à ta bdd. Le mieux c'est de tout scanner et une fois fait, de faire une seule requête en BDD qui te ramène tout.

Dans un but purement de recherche et d'apprentissage c'est une bonne chose mais si c'est destiné à être utilisé dans un logiciel d'entreprise c'est pas une bonne idée, il y a de bons ORM comme Entity qui permettent de pas trop se faire chier.

[Luc1an0]

[HS]
Je me demandais quand est ce que cette question allait être soulevée ...

Je ne compte pas utiliser d'ORM tout prêt, notamment Entity. Et à vrai dire, le débat "vaut il mieux utiliser un ORM tout prêt, ou faire évoluer ce qui existe déjà" n'est pas à l'ordre du jour
Donc effectivement, Entity pourrait correspondre, mais non... Lourd, lent, contraignant ...
[/HS]

Dans mon approche, je ne code pas les objets de base, ni les proc' stock de base...

Je veux juste m'affranchir des fonctions à répétitions pour assigner manuellement des données à des objets.

Et je peux aussi te confirmer que je ne fais qu'un seul appel à ma BDD pour récupérer un objet et ses dépendances.