Discussion :

[yoyo88]

Bonjour à tous,

Voila j'ai un soucie, j'ai une méthode qui prend en paramètre un type générique.
Or je souhaite appeler cette méthode en lui passant dynamiquement le type.


En gros faire un truc du genre :

Code :

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

1
2
3
4
5
6
 
         private void MaMethode(Type pMonType, Object Foo)
        {
 
            Messenger.Send<pMonType>(Foo);
        }

C'est possible ? Et si oui, comment faire ?

Par avance, merci.

[ZenZiTone]

Quelque chose comme :

Code :

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

1
2
3
4
 
public void DoSomething<T>(T t)  
{
}

?

[yoyo88]

Non justement.
je ne souhaite pas passer un type en dur mais réellement de façon dynamique.

en gros avoir un truc qui ressemble a ça dans l'idée.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13

private void Main()
        { 
               IFoo MonObject = This.RecuperationDeIFoo();
               MaMethode(MonObject.GetType(), MonObject);
        }


private void MaMethode(Type pMonType, Object Foo)
        {
            Messenger.Send<???? (pMonType)>(Foo);
        }

[ZenZiTone]

C'est quoi ce Messenger.Send<> ?

Je ne comprends pas ce que tu veux

[WaterTwelve21]

Bonjour, Je crois avoir compris ce que tu souhaite faire , normalement avec une architecture tu n'a pas a typé dynamiquement comme cela , enfin tu peux toujours utiliser la Reflection.

J'ai essayé de reproduire ce que tu essayes de faire , dit moi si ça se rapproche de cela :

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
 class Program
    {
        static void Main(string[] args)
        {
            List<Vehicule> garage = new List<Vehicule>() {
                new Voiture() { ID = 1, Modele = "Peugeot" , Nom = "blabla" , nbRoue= 4},
                new Moto() { ID = 2, Modele = "Kawasaki" , Nom = "blabla" , nbRoue= 2}
            };
 
            Vehicule MonVehicule = garage.Find(v => v.ID == 2);
            Type monType = MonVehicule.GetType();
 
 
            object bruitDuMoteur = monType.InvokeMember("Demarre", System.Reflection.BindingFlags.InvokeMethod,null,MonVehicule,null); //Ne sert pas à grand chose,  => MonVehicule.Demarre() 
 
 
            Console.WriteLine(bruitDuMoteur.ToString());
 
            Console.ReadLine();
        }
    }
 
    class Vehicule
    {
        public int ID { get; set; }
        public string Nom { get; set; }
        public int nbRoue { get; set; }
 
        public virtual string Demarre() {
            return "pouetpouet";
        }
    }
 
    class Voiture : Vehicule
    {
        public string Modele { get; set; }
 
        public override string Demarre()
        {
            return "Vroom";
        }
    }
 
    class Moto : Vehicule
    {
        public string Modele { get; set; }
 
        public override string Demarre()
        {
            return "Zioooonnn";
        }
    }

[lutecefalco]

Un truc dans le genre pour caster obj en Type:

Code :

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

1
2
3
4
5
public T CastExamp1<T>(object input){return(T) input;   
}

public T ConvertExamp1<T>(object input){
    return(T)Convert.ChangeType(input,typeof(T));}

[yoyo88]

Bonjour, et merci pour vos réponse.


Je vais reprendre depuis le début, visiblement ma demande n'es pas claire.

j'utilise MVVM Light et notamment sont système de Message
ce dernier permet et un peu comparable a un systeme d'event et d'abonnement.
En gros, on envoie un Message et tous ceux qui sont abonnée sont notifier.

les abonnement ce font via le type de l'object.

On a donc un truc du genre :

Code :

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

1
2
 
            Messenger.Send<Foo>(Foo);

Code :

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

1
2
3
4
5
6
 
        private void GestionAbonnement()
        {
            // Abonnement 
            Messenger.Default.Register<Foo>(this, pFooObject=> {// monCode });
        }

Voila un exemple de se que je souhaite faire :

Code :

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

1
2
3
4
5
6
7
 
        private void GestionAbonnement()
        {
            // Abonnement voiture
            Messenger.Default.Register<Voiture>(this, pVoitureObject=> {// mon Code pour voiture });
            Messenger.Default.Register<Moto>(this, pMotoObject=> {// mon Code pour moto });
        }

Code :

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

1
2
3
4
5
6
7
8
 
private void MaMethode()
        { 
               ///recupration du vehicule
               IVehicule MonVehicule = This.RecuperationDeVehicule();
               // Transmettre la notification au reste de l'appli
               Messenger.Send<????>(MonVehicule );
        }

Du coup j'ai un problème, je dois typer la méthode Send en fonction du type de mon object "MonVehicule".

Comment faire pour gérer dynamiquement un type générique ?

J’espère avoir été assez claire. :/

[beekeep]

Bonjour,

il n'y a une erreur sur l'appel de la méthode générique.

Code :

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

1
2
3
4
5
6
7
static class TestClass
{
   public static string Send<T>(T obj)
   {
     return obj == null ? "null" : obj.GetType().ToString();
   }
}

Code :

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

Console.WriteLine("Type:" + TestClass.Send(new Object()));

Pas besoin d'utiliser <Object>.

[beekeep]

Si nécessaire c'est toujours possible:

Code :

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

1
2
3
4
5
6
7
static class TestClass
{
    public static string Add<T>(int count)
    {
        return String.Format("Type: {0}, Count: {1}", typeof(T), count + 1);
    }
}

Code :

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

Console.WriteLine(TestClass.Add<Object>(1));

Code :

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

1
2
3
4
5
6
7
8
9
10
var targetType = typeof(TestClass);
var dynamicType = typeof(Object);
 
var methodInfo = targetType.GetMethod("Add", new [] { typeof(int) });
 
var genericMethodInfo = methodInfo.MakeGenericMethod(dynamicType);
 
var result = genericMethodInfo.Invoke(dynamicType, new object[] { 2 });
 
Console.WriteLine(result);

[yoyo88]

Bien vu,
Je sais pas pourquoi je n'ai pas penser a ça.

merci