Envoi d'une classe en tant que paramètre à un thread?

Question

Donc j'essaie de trouver un moyen de passer dynamiquement un type de classe à un thread, afin qu'il puisse rappeler la classe à laquelle il a été émis, et ainsi renvoyer dynamiquement des données à cette classe.

Voici ce que je suis en train, où ServerClass est la classe de cette fonction principale:

public static void Main() 
{ 
    UDPClass clsUDP = new UDPClass(); 
    Thread clsUDPThread = new Thread(new ThreadStart(delegate() { clsUDP.UDPListen(64000, ServerClass); })); 
    clsUDPThread.Start(); 
} 

Ceci est la fin de réception, dans le UDPClass:

public void UDPListen(int UDPPort, Type OldClass) 
{ 
} 

Answer 1

Vous pouvez faire beaucoup avec un code comme celui-ci.

class X : BaseClass 
{ 
    ... 
} 

class Y : X 
{ 
    int yField; 
} 

... 

int Main(BaseClass instance) 
{ 
    if (instance is Y) (instance as Y).yField = 1; 
} 

Answer 2

Vous devez changer la ligne comme suit:

Thread clsUDPThread = new Thread(new ThreadStart(delegate() { clsUDP.UDPListen(64000, typeof(ServerClass)); })); 

Bien que, seul type d'accepter ne résoudra pas votre problème - vous devez accepter en fait l'instance (objet) du type (en supposant vouloir invoquer des méthodes/propriétés d'instance). Le meilleur moyen serait d'accepter une interface que votre type de cible doit implémenter.

EDIT:

Ok - voici comment vous pouvez utiliser une interface.

public interface IUDPListener 
{ 
    void Notify(string status); 
} 

En classe UDP,

public void UDPListen(int UDPPort, IUDPListener listner) 
{ 
    ... 
    listener.Notify("bla bla"); 
    ... 
} 

public class ServerClass : IUDPListener 
{ 
    ... 

    public void Notify(string status) 
    { 
    // Callback from thread 
    ... 
    } 

    // Method that starts thread 
    public void StartThread() 
    { 
    UDPClass clsUDP = new UDPClass(); 
    Thread clsUDPThread = new Thread(new ThreadStart(delegate() { clsUDP.UDPListen(64000, this); })); 
    clsUDPThread.Start(); 
    } 
} 

Vous pouvez également utiliser un délégué pour ces notifications si son simple de rappel d'une méthode. Avec l'interface, vous pouvez définir plusieurs rappels ainsi que des méthodes/propriétés pour interroger l'écouteur si nécessaire. Voici l'exemple de code utilisant délégué

En classe UDP,

public void UDPListen(int UDPPort, Action<string> callback) 
{ 
    ... 
    callback("bla bla"); 
    ... 
} 

En classe serveur

public class ServerClass 
{ 
    ... 
    private void UdpCallback(string message) 
    { 
     ... 
    } 

    // code to start thread 
    UDPClass clsUDP = new UDPClass(); 
    var clsUDPThread = new Thread(new ThreadStart(delegate() {clsUDP.UDPListen(64000, UdpCallback); })); 
    clsUDPThread.Start(); 

Answer 3

Vous pouvez utiliser ParameterizedThreadStart appeler une méthode avec des paramètres dans un nouveau thread.

public static void Main() 
{ 
    UDPClass.UDPListenParameters threadParameters = new UDPClass.UDPListenParameters(); 
    threadParameters.UDPPort = 64000; 
    threadParameters.OldClass = this.GetType(); 

    UDPClass clsUDP = new UDPClass(); 
    Thread clsUDPThread = new Thread(new ParameterizedThreadStart(clsUDP.UDPListen)); 

    clsUDPThread.Start(threadParameters); 
} 

public class UDPClass 
{ 
    public void UDPListen(object parameter) 
    { 
     UDPListenParameters parameters = (UDPListenParameters)parameter; 
     // parameters.UDPPort 
     // parameters.OldClass 
    } 

    public class UDPListenParameters 
    { 
     public int UDPPort; 
     public Type OldClass; 
    } 
} 

Mais comme VinayC a souligné, vous devez passer une référence à la classe de serveur au lieu du type de pouvoir utiliser ses membres.