Envoyer un Message en C#

Je suis en création d'une application qui utilise un projet principal qui est connecté à plusieurs Dll. À partir d'une DLL fenêtre j'ai besoin d'être en mesure d'ouvrir une fenêtre à l'autre, mais la DLL ne peut pas référence les uns des autres.

Il m'a été suggéré d'utiliser la fonction sendmessage dans la DLL et un auditeur dans le programme principal qui dirige ce message à la DLL approprié pour ouvrir la fenêtre.

Cependant, je ne suis pas familier avec la fonction sendmessage et je rencontre beaucoup de diffculty choses assemblant de renseignements je suis la recherche en ligne.

Si quelqu'un pourrait s'il vous plaît me montrer le bon chemin (si elles existent) pour utiliser la fonction sendmessage et peut-être comment un auditeur saisit le message qui serait étonnant. Voici le code que j'ai obtenu jusqu'à présent, je ne sais pas si je suis dans la bonne direction.

    [DllImport("user32.dll")]
    public static extern int FindWindow(string lpClassName, String lpWindowName);
    [DllImport("user32.dll")]
    public static extern int SendMessage(IntPtr hWnd, int wMsg, IntPtr wParam, IntPtr lParam);

    public void button1_Click(object sender, EventArgs e)
    {
        int WindowToFind = FindWindow(null, "Form1");
    }

Salut Nicole, SendMessage "pourrait" aider dans ce cas oui, mais j'ai peur que cela n'est pas le meilleur moyen pour vous d'atteindre votre objectif. Pouvez-vous décrire un peu ce qu'est l'ensemble de votre scénario? Avez-vous des 1 WindowsForms application et certaines bibliothèques de classes contenant plus de formes que vous souhaitez afficher ou si non, qu'est-ce exactement que vous essayez de faire? Donner plus de détails et nous allons voir de quelle manière vous allez.
Si vous avez le contrôle sur les applications, l'utilisation de certains autres CIB stratégie ( tube nommé/socket )

OriginalL'auteur Nicole | 2011-02-22

c#sendmessage

6

Vous n'avez pas besoin d'envoyer des messages.

Ajouter un l'événement d'une forme et d'un gestionnaire d'événement à l'autre. Ensuite, vous pouvez utiliser un troisième projet qui références les deux autres pour joindre le gestionnaire d'événement pour l'événement. Les deux Dll n'avez pas besoin de référence les uns des autres pour que cela fonctionne.

OriginalL'auteur
10
```
public static extern int FindWindow(string lpClassName, String lpWindowName);
```
Afin de trouver la fenêtre, vous avez besoin du nom de la classe de la fenêtre. Voici quelques exemples:

C#:
```
const string lpClassName = "Winamp v1.x";
IntPtr hwnd = FindWindow(lpClassName, null);
```
Exemple à partir d'un programme que j'ai fait, écrite en VB:
```
hParent = FindWindow("TfrmMain", vbNullString)
```
Afin d'obtenir le nom de la classe d'une fenêtre, vous aurez besoin de quelque chose appelé Win Spy

Une fois que vous avez la poignée de la fenêtre, vous pouvez envoyer des messages à l'aide de la fonction SendMessage(IntPtr hWnd, int wMsg, IntPtr wParam, IntPtr lParam) de la fonction.

hWnd, ici, est le résultat de la fonction FindWindow. Dans les exemples ci-dessus, ce sera hwnd et hParent. Il indique à la fonction SendMessage la fenêtre pour envoyer le message.

Le deuxième paramètre, wMsg, est une constante qui indique le TYPE de message que vous envoyez. Le message pourrait être une combinaison de touches (par exemple, envoyer des "la touche entrée" ou "barre d'espace" pour une fenêtre), mais il peut aussi être une commande pour fermer la fenêtre (WM_CLOSE), une commande pour modifier la fenêtre (le cacher, de le montrer, de le réduire, modifier son titre, etc.), une demande de renseignements à l'intérieur de la fenêtre (le titre, l'obtention d'un texte dans une zone de texte, etc.), et ainsi de suite. Quelques exemples courants sont les suivants:
```
Public Const WM_CHAR = &H102
Public Const WM_SETTEXT = &HC
Public Const WM_KEYDOWN = &H100
Public Const WM_KEYUP = &H101
Public Const WM_LBUTTONDOWN = &H201
Public Const WM_LBUTTONUP = &H202
Public Const WM_CLOSE = &H10
Public Const WM_COMMAND = &H111
Public Const WM_CLEAR = &H303
Public Const WM_DESTROY = &H2
Public Const WM_GETTEXT = &HD
Public Const WM_GETTEXTLENGTH = &HE
Public Const WM_LBUTTONDBLCLK = &H203
```
Ceux-ci peuvent être trouvés avec une visionneuse d'API (ou un simple éditeur de texte tel que le bloc-notes) par l'ouverture (Microsoft Visual Studio Répertoire)/Common/Tools/WINAPI/winapi32.txt.

Les deux paramètres suivants sont certains détails, si elles sont nécessaires. En termes de en appuyant sur certaines touches, ils devront préciser exactement ce qui touche spécifique est d'être pressé.

Exemple en C#, définir le texte de "windowHandle" avec WM_SETTEXT:
```
x = SendMessage(windowHandle, WM_SETTEXT, new IntPtr(0),
m_strURL);
```
Plus d'exemples à partir d'un programme que j'ai fait, écrite en VB, en établissant un programme de l'icône (ICONBIG est une constante qui peut être trouvé dans winapi32.txt):
```
Call SendMessage(hParent, WM_SETICON, ICON_BIG, ByVal hIcon)
```
Un autre exemple à partir de VB, en appuyant sur la touche espace (VK_SPACE est une constante qui peut être trouvé dans winapi32.txt):
```
Call SendMessage(button%, WM_KEYDOWN, VK_SPACE, 0)
Call SendMessage(button%, WM_KEYUP, VK_SPACE, 0)
```
VB envoi d'un clic sur un bouton (un gauche bouton vers le bas, puis vers le haut):
```
Call SendMessage(button%, WM_LBUTTONDOWN, 0, 0&)
Call SendMessage(button%, WM_LBUTTONUP, 0, 0&)
```
Aucune idée de comment mettre en place l'auditeur dans une .DLL, mais ces exemples devraient vous aider à comprendre comment faire pour envoyer le message.

OriginalL'auteur

Vous y êtes presque. (noter le changement dans la valeur de retour de la fonction FindWindow déclaration). Je vous recommande d'utiliser RegisterWindowMessage dans ce cas, si vous n'avez pas à vous soucier de les tenants et les aboutissants de WM_USER.

[DllImport("user32.dll")]    
public static extern IntPtr FindWindow(string lpClassName, String lpWindowName);    
[DllImport("user32.dll")]    
public static extern int SendMessage(IntPtr hWnd, int wMsg, IntPtr wParam, IntPtr lParam);    
[DllImport("user32.dll", SetLastError=true, CharSet=CharSet.Auto)]
static extern uint RegisterWindowMessage(string lpString);

public void button1_Click(object sender, EventArgs e)   
{        
     //this would likely go in a constructor because you only need to call it 
     //once per process to get the id - multiple calls in the same instance 
     //of a windows session return the same value for a given string
     uint id = RegisterWindowMessage("MyUniqueMessageIdentifier");
     IntPtr WindowToFind = FindWindow(null, "Form1");    
     Debug.Assert(WindowToFind != IntPtr.Zero);
     SendMessage(WindowToFind, id, IntPtr.Zero, IntPtr.Zero);
}

Et puis dans votre classe Form1:

class Form1 : Form
{
    [DllImport("user32.dll", SetLastError=true, CharSet=CharSet.Auto)]
    static extern uint RegisterWindowMessage(string lpString);

    private uint _messageId = RegisterWindowMessage("MyUniqueMessageIdentifier");

    protected override void WndProc(ref Message m)
    {
       if (m.Msg == _messageId)
       {
           //do stuff

       }
       base.WndProc(ref m);
    }
}

Garder à l'esprit que je n'ai pas compilé ci-dessus est donc de quelques ajustements peuvent être nécessaires.
Aussi garder à l'esprit que d'autres réponses d'avertissement vous éloigner de SendMessage sont sur place. Ce n'est pas la voie privilégiée entre le module de communication de nos jours et genrally parlant substitution de la WndProc et à l'aide de SendMessage/PostMessage implique une bonne compréhension de la façon dont la Win32 message de l'infrastructure œuvres.

Mais si vous voulez/besoin d'aller dans cette voie, je pense que le ci-dessus vous aideront à aller dans la bonne direction.

OriginalL'auteur

0

Il ne sonne pas comme une bonne idée d'utiliser envoyer un message. Je pense que vous devriez essayer de contourner le problème que la Dll ne peut pas référence à chacun des autres...

OriginalL'auteur
0

Quelques autres options:

Assemblée Commune

Créer une autre assemblée qui a des interfaces communes qui peuvent être mises en œuvre par les assemblées.

Réflexion

Cela a toutes sortes de mises en garde et des inconvénients, mais vous pouvez utiliser la réflexion pour instancier /communiquer avec les formes. C'est à la fois lent et exécution dynamique (pas de vérification statique de ce code au moment de la compilation).

OriginalL'auteur
0

La construction de la Marque Byers réponse.

Le 3ème projet pourrait être un WCF projet, accueilli comme un Service Windows. Si tous les programmes écouté ce service, une application peut appeler le service. Le service transmet le message à tout à l'écoute des clients et ils peuvent effectuer une action, si approprié.

Bonne WCF vidéos ici - http://msdn.microsoft.com/en-us/netframework/dd728059

OriginalL'auteur

Vous devez vous connecter pour publier un commentaire.