Message Classe

Référence

Définition

Espace de noms:: System.Messaging

Assembly:: System.Messaging.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Fournit l'accès aux propriétés nécessaires à la définition d'un message de Message Queuing.

public ref class Message : System::ComponentModel::Component

public class Message : System.ComponentModel.Component

type Message = class
    inherit Component

Public Class Message
Inherits Component

Héritage: Object

MarshalByRefObject

Component
Message

Exemples

L’exemple de code suivant illustre la mise en forme d’un corps de message à l’aide de BinaryMessageFormatter.

using System;
using System.Messaging;
using System.Drawing;
using System.IO;

namespace MyProject
{

    /// <summary>
    /// Provides a container class for the example.
    /// </summary>
    public class MyNewQueue
    {

        //**************************************************
        // Provides an entry point into the application.
        //		
        // This example sends and receives a message from
        // a queue.
        //**************************************************

        public static void Main()
        {
            // Create a new instance of the class.
            MyNewQueue myNewQueue = new MyNewQueue();

            // Create a queue on the local computer.
            CreateQueue(".\\myQueue");
            
            // Send a message to a queue.
            myNewQueue.SendMessage();

            // Receive a message from a queue.
            myNewQueue.ReceiveMessage();

            return;
        }

        //**************************************************
        // Creates a new queue.
        //**************************************************

        public static void CreateQueue(string queuePath)
        {
            try	
            {
                if(!MessageQueue.Exists(queuePath))
                {
                    MessageQueue.Create(queuePath);
                }
                else
                {
                    Console.WriteLine(queuePath + " already exists.");
                }
            }
            catch (MessageQueueException e)
            {
                Console.WriteLine(e.Message);
            }
        }

        //**************************************************
        // Sends an image to a queue, using the BinaryMessageFormatter.
        //**************************************************
        
        public void SendMessage()
        {
            try{

                // Create a new bitmap.
                // The file must be in the \bin\debug or \bin\retail folder, or
                // you must give a full path to its location.
                Image myImage = Bitmap.FromFile("SentImage.bmp");

                // Connect to a queue on the local computer.
                MessageQueue myQueue = new MessageQueue(".\\myQueue");
                
                Message myMessage = new Message(myImage, new BinaryMessageFormatter());

                // Send the image to the queue.
                myQueue.Send(myMessage);
            }
            catch(ArgumentException e)
            {
                Console.WriteLine(e.Message);
            }

            return;
        }

        //**************************************************
        // Receives a message containing an image.
        //**************************************************
        
        public  void ReceiveMessage()
        {
                        
            try
            {

                // Connect to the a queue on the local computer.
                MessageQueue myQueue = new MessageQueue(".\\myQueue");

                // Set the formatter to indicate body contains an Order.
                myQueue.Formatter = new BinaryMessageFormatter();

                // Receive and format the message.
                System.Messaging.Message myMessage = myQueue.Receive();
                Bitmap myImage = (Bitmap)myMessage.Body;
                
                // This will be saved in the \bin\debug or \bin\retail folder.
                myImage.Save("ReceivedImage.bmp",System.Drawing.Imaging.ImageFormat.Bmp);
            }
            
            catch (MessageQueueException)
            {
                // Handle Message Queuing exceptions.
            }

            // Handle invalid serialization format.
            catch (InvalidOperationException e)
            {
                Console.WriteLine(e.Message);
            }

            catch (IOException e)
            {
                // Handle file access exceptions.
            }
            
            // Catch other exceptions as necessary.

            return;
        }
    }
}

Imports System.Messaging
Imports System.Drawing
Imports System.IO


Namespace MyProj
    _
   
   
   Public Class MyNewQueue
      
      
      '**************************************************
      ' Provides an entry point into the application.
      '		 
      ' This example sends and receives a message from
      ' a queue.
      '**************************************************
      Public Shared Sub Main()
         ' Create a new instance of the class.
         Dim myNewQueue As New MyNewQueue()
         
         ' Create a queue on the local computer.
         CreateQueue(".\myQueue")
         
         ' Send a message to a queue.
         myNewQueue.SendMessage()
         
         ' Receive a message from a queue.
         myNewQueue.ReceiveMessage()
         
         Return
      End Sub
      
      
      '**************************************************
      ' Creates a new queue.
      '**************************************************
      Public Shared Sub CreateQueue(queuePath As String)
         Try
            If Not MessageQueue.Exists(queuePath) Then
               MessageQueue.Create(queuePath)
            Else
               Console.WriteLine((queuePath + " already exists."))
            End If
         Catch e As MessageQueueException
            Console.WriteLine(e.Message)
         End Try
      End Sub
       
      
      '**************************************************
      ' Sends an image to a queue, using the BinaryMessageFormatter.
      '**************************************************
      Public Sub SendMessage()
         Try
            
            ' Create a new bitmap.
            ' The file must be in the \bin\debug or \bin\retail folder, or
            ' you must give a full path to its location.
            Dim myImage As Image = Bitmap.FromFile("SentImage.bmp")
            
            ' Connect to a queue on the local computer.
            Dim myQueue As New MessageQueue(".\myQueue")
            
            Dim myMessage As New Message(myImage, New BinaryMessageFormatter())
            
            ' Send the image to the queue.
            myQueue.Send(myMessage)
         Catch e As ArgumentException
            Console.WriteLine(e.Message)
         End Try 
         
         Return
      End Sub
      
      
      
      '**************************************************
      ' Receives a message containing an image.
      '**************************************************
      Public Sub ReceiveMessage()
         
         Try
            
            ' Connect to the a queue on the local computer.
            Dim myQueue As New MessageQueue(".\myQueue")
            
            ' Set the formatter to indicate body contains an Order.
            myQueue.Formatter = New BinaryMessageFormatter()
            
            ' Receive and format the message. 
            Dim myMessage As System.Messaging.Message = myQueue.Receive()
            Dim myImage As Bitmap = CType(myMessage.Body, Bitmap)
            
            ' This will be saved in the \bin\debug or \bin\retail folder.
            myImage.Save("ReceivedImage.bmp", System.Drawing.Imaging.ImageFormat.Bmp)
         
         
         
         'Catch
         ' Handle Message Queuing exceptions.
         
         ' Handle invalid serialization format.
         Catch e As InvalidOperationException
            Console.WriteLine(e.Message)
         
         Catch e As IOException
         End Try
         ' Handle file access exceptions.
         
         ' Catch other exceptions as necessary.
         Return
      End Sub
   End Class
End Namespace 'MyProj

L’exemple de code suivant illustre la mise en forme d’un corps de message à l’aide de XmlMessageFormatter.

#using <system.dll>
#using <system.messaging.dll>
#using <system.drawing.dll>

using namespace System;
using namespace System::Messaging;
using namespace System::Drawing;
using namespace System::IO;
ref class Order
{
public:
   int orderId;
   DateTime orderTime;
};

ref class MyNewQueue
{
public:
   static void CreateQueue( String^ queuePath )
   {
      try
      {
         if (  !MessageQueue::Exists( queuePath ) )
         {
            MessageQueue::Create( queuePath );
         }
         else
         {
            Console::WriteLine(  "{0} already exists.", queuePath );
         }
      }
      catch ( MessageQueueException^ e ) 
      {
         Console::WriteLine( e->Message );
      }

   }

   void SendMessage()
   {
      try
      {
         // Create a new order and set values.
         Order^ sentOrder = gcnew Order;
         sentOrder->orderId = 3;
         sentOrder->orderTime = DateTime::Now;

         // Connect to a queue on the local computer.
         MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );

         // Create the new order.
         Message^ myMessage = gcnew Message( sentOrder );

         // Send the order to the queue.
         myQueue->Send( myMessage );
      }
      catch ( ArgumentException^ e ) 
      {
         Console::WriteLine( e->Message );
      }

      return;
   }

   void ReceiveMessage()
   {
      // Connect to the a queue on the local computer.
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );

      // Set the formatter to indicate body contains an Order.
      array<Type^>^p = gcnew array<Type^>(1);
      p[ 0 ] = Order::typeid;
      myQueue->Formatter = gcnew XmlMessageFormatter( p );
      try
      {
         // Receive and format the message. 
         Message^ myMessage = myQueue->Receive();
         Order^ myOrder = dynamic_cast<Order^>(myMessage->Body);

         // Display message information.
         Console::WriteLine( "Order ID: {0}", myOrder->orderId );
         Console::WriteLine( "Sent: {0}", myOrder->orderTime );
      }
      catch ( MessageQueueException^ ) 
      {
         // Handle Message Queuing exceptions.
      }
      // Handle invalid serialization format.
      catch ( InvalidOperationException^ e ) 
      {
         Console::WriteLine( e->Message );
      }

      // Catch other exceptions as necessary.
      return;
   }
};

int main()
{
   // Create a new instance of the class.
   MyNewQueue^ myNewQueue = gcnew MyNewQueue;

   // Create a queue on the local computer.
   MyNewQueue::CreateQueue( ".\\myQueue" );

   // Send a message to a queue.
   myNewQueue->SendMessage();

   // Receive a message from a queue.
   myNewQueue->ReceiveMessage();
   return 0;
}

using System;
using System.Messaging;
using System.Drawing;
using System.IO;

namespace MyProject
{

    // The following example
    // sends to a queue and receives from a queue.
    public class Order
    {
        public int orderId;
        public DateTime orderTime;
    };	

    /// <summary>
    /// Provides a container class for the example.
    /// </summary>
    public class MyNewQueue
    {

        //**************************************************
        // Provides an entry point into the application.
        //		
        // This example sends and receives a message from
        // a queue.
        //**************************************************

        public static void Main()
        {
            // Create a new instance of the class.
            MyNewQueue myNewQueue = new MyNewQueue();

            // Create a queue on the local computer.
            CreateQueue(".\\myQueue");
            
            // Send a message to a queue.
            myNewQueue.SendMessage();

            // Receive a message from a queue.
            myNewQueue.ReceiveMessage();

            return;
        }

        //**************************************************
        // Creates a new queue.
        //**************************************************

        public static void CreateQueue(string queuePath)
        {
            try	
            {
                if(!MessageQueue.Exists(queuePath))
                {
                    MessageQueue.Create(queuePath);
                }
                else
                {
                    Console.WriteLine(queuePath + " already exists.");
                }
            }
            catch (MessageQueueException e)
            {
                Console.WriteLine(e.Message);
            }
        }

        //**************************************************
        // Sends an Order to a queue.
        //**************************************************
        
        public void SendMessage()
        {
            try
            {

                // Create a new order and set values.
                Order sentOrder = new Order();
                sentOrder.orderId = 3;
                sentOrder.orderTime = DateTime.Now;

                // Connect to a queue on the local computer.
                MessageQueue myQueue = new MessageQueue(".\\myQueue");

                // Create the new order.
                Message myMessage = new Message(sentOrder);

                // Send the order to the queue.
                myQueue.Send(myMessage);
            }
            catch(ArgumentException e)
            {
                Console.WriteLine(e.Message);
            }

            return;
        }

        //**************************************************
        // Receives a message containing an order.
        //**************************************************
        
        public  void ReceiveMessage()
        {
            // Connect to the a queue on the local computer.
            MessageQueue myQueue = new MessageQueue(".\\myQueue");

            // Set the formatter to indicate body contains an Order.
            myQueue.Formatter = new XmlMessageFormatter(new Type[]
                {typeof(MyProject.Order)});
            
            try
            {
                // Receive and format the message.
                Message myMessage =	myQueue.Receive();
                Order myOrder = (Order)myMessage.Body;

                // Display message information.
                Console.WriteLine("Order ID: " +
                    myOrder.orderId.ToString());
                Console.WriteLine("Sent: " +
                    myOrder.orderTime.ToString());
            }
            
            catch (MessageQueueException)
            {
                // Handle Message Queuing exceptions.
            }

                // Handle invalid serialization format.
            catch (InvalidOperationException e)
            {
                Console.WriteLine(e.Message);
            }
            
            // Catch other exceptions as necessary.

            return;
        }
    }
}

Imports System.Messaging
Imports System.Drawing
Imports System.IO



   
' The following example 
' sends to a queue and receives from a queue.
Public Class Order
      Public orderId As Integer
      Public orderTime As DateTime
End Class

   
  
' Provides a container class for the example.

Public Class MyNewQueue
      
      

   ' Provides an entry point into the application.
   '		 
   ' This example sends and receives a message from
   ' a queue.

   Public Shared Sub Main()
      ' Create a new instance of the class.
      Dim myNewQueue As New MyNewQueue()
        
      ' Create a queue on the local computer.
      CreateQueue(".\myQueue")
         
      ' Send a message to a queue.
      myNewQueue.SendMessage()
       
      ' Receive a message from a queue.
      myNewQueue.ReceiveMessage()
         
      Return
   End Sub
      
      

      ' Creates a new queue.
   Public Shared Sub CreateQueue(queuePath As String)
      Try
         If Not MessageQueue.Exists(queuePath) Then
            MessageQueue.Create(queuePath)
         Else
            Console.WriteLine((queuePath + " already exists."))
         End If
      Catch e As MessageQueueException
         Console.WriteLine(e.Message)
      End Try
   End Sub
       
      

      ' Sends an Order to a queue.

   Public Sub SendMessage()
      Try
            
            ' Create a new order and set values.
            Dim sentOrder As New Order()
            sentOrder.orderId = 3
            sentOrder.orderTime = DateTime.Now
            
            ' Connect to a queue on the local computer.
            Dim myQueue As New MessageQueue(".\myQueue")
            
            
            
            ' Create the new order.
            Dim myMessage As New Message(sentOrder)
            
            ' Send the order to the queue.
            myQueue.Send(myMessage)
      Catch e As ArgumentException
            Console.WriteLine(e.Message)
      End Try 
         
      Return
   End Sub
      
      
      
 
      ' Receives a message containing an order.
 
   Public Sub ReceiveMessage()
         ' Connect to the a queue on the local computer.
         Dim myQueue As New MessageQueue(".\myQueue")
         
         ' Set the formatter to indicate body contains an Order.
         myQueue.Formatter = New XmlMessageFormatter(New Type() {GetType(Order)})
         
         Try
            ' Receive and format the message. 
            Dim myMessage As Message = myQueue.Receive()
            Dim myOrder As Order = CType(myMessage.Body, Order)
            
            ' Display message information.
            Console.WriteLine(("Order ID: " + myOrder.orderId.ToString()))
            Console.WriteLine(("Sent: " + myOrder.orderTime.ToString()))
         
  
         ' Handle invalid serialization format.
         Catch e As InvalidOperationException
            Console.WriteLine(e.Message)
         End Try
         
         ' Catch other exceptions as necessary.
         Return
   End Sub
End Class

Remarques

Utilisez la Message classe pour lire ou recevoir des messages d’une file d’attente, ou pour avoir un contrôle précis sur les propriétés des messages lors de l’envoi d’un message à une file d’attente.

MessageQueueutilise la Message classe lorsqu’elle effectue un aperçu ou reçoit des messages à partir de files d’attente, car les MessageQueue.Peek méthodes et MessageQueue.Receive créent une nouvelle instance de la Message classe et définissent les propriétés du instance. Les Message propriétés en lecture seule de la classe s’appliquent à la récupération de messages à partir d’une file d’attente, tandis que les propriétés en lecture/écriture s’appliquent à l’envoi et à la récupération de messages. Lors MessageQueue de la lecture ou de la réception d’un message à partir d’une file d’attente, sa MessageReadPropertyFilter propriété détermine laquelle des propriétés du message est récupérée.

La MessageQueue méthode de la Send classe vous permet de spécifier n’importe quel type d’objet pour un message envoyé à cette file d’attente. Vous pouvez utiliser la MessageQueue propriété du DefaultPropertiesToSend instance pour spécifier les paramètres des messages génériques envoyés à la file d’attente. Les types de paramètres incluent le formateur, l’étiquette, le chiffrement et l’authentification. Vous pouvez également spécifier des valeurs pour les membres appropriés DefaultPropertiesToSend lorsque vous coordonnez votre application de messagerie pour répondre aux messages d’accusé de réception et de rapport. L’utilisation d’un Message instance pour envoyer un message à la file d’attente vous offre la possibilité d’accéder et de modifier un grand nombre de ces propriétés, soit pour un seul message, soit pour un message par message. Message les propriétés sont prioritaires sur DefaultPropertiesToSend.

Les données de message sont stockées dans la Body propriété et, dans une moindre mesure, les AppSpecific propriétés et Extension . Lorsque les données de message sont chiffrées, sérialisées ou désérialisées, seul le contenu de la Body propriété est affecté.

Le contenu de la Body propriété est sérialisé lorsque le message est envoyé, à l’aide de la Formatter propriété que vous spécifiez. Le contenu sérialisé se trouve dans la BodyStream propriété . Vous pouvez également définir la BodyStream propriété directement, par exemple pour envoyer un fichier en tant que contenu de données d’un message. Vous pouvez modifier les Body propriétés ou Formatter à tout moment avant d’envoyer le message, et les données seront sérialisées de manière appropriée lorsque vous appelez Send.

Les propriétés définies par la propriété s’appliquent MessageQueue.DefaultPropertiesToSend uniquement aux messages qui ne sont pas de type Message. Si vous spécifiez la DefaultPropertiesToSend propriété d’un MessageQueue, les propriétés au nom identique d’un Message instance envoyées à cette file d’attente entraînent l’ignorer.

Pour obtenir la liste des valeurs de propriété initiales d’un instance de Message, consultez le Message constructeur.

Constructeurs

Message()	Initialise une nouvelle instance de la classe Message avec un corps vide.
Message(Object)	Initialise une nouvelle instance de la classe Message, à l'aide de XmlMessageFormatter pour sérialiser l'objet spécifié dans le corps du message.
Message(Object, IMessageFormatter)	Initialise une nouvelle instance de la classe Message, à l'aide du formateur spécifié pour sérialiser l'objet spécifié dans le corps du message.

Champs

InfiniteTimeout

Spécifie qu'il n'y a pas de délai d'attente.

Propriétés

AcknowledgeType	Obtient ou définit le type de message d'accusé de réception à retourner à l'application émettrice.
Acknowledgment	Obtient la classification de l'accusé de réception représenté par ce message.
AdministrationQueue	Obtient ou définit la file d'attente utilisée pour les messages d'accusé de réception générés par Message Queuing.
AppSpecific	Obtient ou définit des informations supplémentaires spécifiques à l'application.
ArrivedTime	Obtient l'heure à laquelle le message est arrivé dans la file d'attente de destination.
AttachSenderId	Obtient ou définit une valeur qui indique si l'ID de l'expéditeur doit être attaché au message.
Authenticated	Obtient une valeur qui indique si le message a été authentifié.
AuthenticationProviderName	Obtient ou définit le nom du fournisseur de services de chiffrement utilisé pour générer la signature numérique du message.
AuthenticationProviderType	Obtient ou définit le type de fournisseur de services de chiffrement utilisé pour générer la signature numérique du message.
Body	Obtient ou définit le contenu du message.
BodyStream	Obtient ou définit les informations dans le corps du message.
BodyType	Obtient ou définit le type de données contenu dans le corps du message.
CanRaiseEvents	Obtient une valeur qui indique si le composant peut déclencher un événement. (Hérité de Component)
ConnectorType	Obtient ou définit une valeur qui indique que certaines propriétés de message généralement définies par Message Queuing ont été définies par l'application source.
Container	Obtient le IContainer qui contient la Component. (Hérité de Component)
CorrelationId	Obtient ou définit l'identificateur de message utilisé par les messages d'accusé de réception, de rapport et de réponse en référence au message d'origine.
DesignMode	Obtient une valeur qui indique si Component est actuellement en mode design. (Hérité de Component)
DestinationQueue	Obtient la file d'attente de destination prévue pour un message.
DestinationSymmetricKey	Obtient ou définit la clé symétrique utilisée pour chiffrer les messages chiffrés par l'application ou les messages envoyés aux files d'attente externes.
DigitalSignature	Obtient ou définit la signature numérique utilisée par Message Queuing pour authentifier le message.
EncryptionAlgorithm	Obtient ou définit l'algorithme de chiffrement utilisé pour chiffrer le corps d'un message privé.
Events	Obtient la liste des gestionnaires d'événements attachés à ce Component. (Hérité de Component)
Extension	Obtient ou définit des informations supplémentaires définies par l'application qui sont associées au message.
Formatter	Obtient ou définit le formateur utilisé pour sérialiser un objet dans le corps du message ou le désérialiser.
HashAlgorithm	Obtient ou définit l'algorithme de hachage utilisé par Message Queuing lors de l'authentification d'un message ou la création d'une signature numérique pour un message.
Id	Obtient l'identificateur du message.
IsFirstInTransaction	Obtient une valeur qui indique si le message était le premier message envoyé dans une transaction.
IsLastInTransaction	Obtient une valeur qui indique si le message était le dernier message envoyé dans une transaction.
Label	Obtient ou définit une chaîne Unicode définie par l'application qui décrit le message.
LookupId	Présentation dans MSMQ 3.0. Obtient l'identificateur de la recherche du message.
MessageType	Obtient le type du message : `Normal`, `Acknowledgment` ou `Report`.
Priority	Obtient ou définit la priorité du message, qui détermine la position du message dans la file d'attente.
Recoverable	Obtient ou définit une valeur qui indique si le message est toujours remis, même en cas de défaillance de l'ordinateur ou du réseau.
ResponseQueue	Obtient ou définit la file d'attente qui reçoit les messages de réponse générés par l'application.
SecurityContext	Obtient ou définit le contexte de sécurité d'un message.
SenderCertificate	Obtient ou définit le certificat de sécurité utilisé pour authentifier des messages.
SenderId	Obtient l'identificateur de l'utilisateur expéditeur.
SenderVersion	Obtient la version de Message Queuing utilisée pour envoyer le message.
SentTime	Obtient la date et l'heure de l'ordinateur source auxquelles le message a été envoyé par le Gestionnaire de files d'attente source.
Site	Obtient ou définit le ISite de Component. (Hérité de Component)
SourceMachine	Obtient l'ordinateur d'origine du message.
TimeToBeReceived	Obtient ou définit le délai d'attente pour la réception du message à partir de la file d'attente de destination.
TimeToReachQueue	Obtient ou définit le délai accordé à un message pour atteindre la file d'attente.
TransactionId	Obtient l'identificateur pour la transaction dont faisait partie le message.
TransactionStatusQueue	Obtient la file d'attente des statuts de transaction sur l'ordinateur source.
UseAuthentication	Obtient ou définit une valeur qui indique si le message a été (ou doit être) authentifié avant son envoi.
UseDeadLetterQueue	Obtient ou définit une valeur qui indique si une copie du message non remis doit être envoyée dans une file d'attente de lettres mortes.
UseEncryption	Obtient ou définit une valeur qui indique si le message doit être privé.
UseJournalQueue	Obtient ou définit une valeur qui indique si une copie du message doit être conservée dans un journal sur l'ordinateur d'origine.
UseTracing	Obtient ou définit une valeur qui indique si un message doit être suivi lors de son transfert vers la file d'attente de destination correspondante.

Méthodes

CreateObjRef(Type)	Crée un objet contenant toutes les informations appropriées requises pour générer un proxy permettant de communiquer avec un objet distant. (Hérité de MarshalByRefObject)
Dispose()	Libère toutes les ressources utilisées par Component. (Hérité de Component)
Dispose(Boolean)	Libère les ressources non managées utilisées par Component et libère éventuellement les ressources managées. (Hérité de Component)
Equals(Object)	Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object)
GetHashCode()	Fait office de fonction de hachage par défaut. (Hérité de Object)
GetLifetimeService()	Obsolète. Récupère l'objet de service de durée de vie en cours qui contrôle la stratégie de durée de vie de cette instance. (Hérité de MarshalByRefObject)
GetService(Type)	Retourne un objet qui représente un service fourni par Component ou par son Container. (Hérité de Component)
GetType()	Obtient le Type de l'instance actuelle. (Hérité de Object)
InitializeLifetimeService()	Obsolète. Obtient un objet de service de durée de vie pour contrôler la stratégie de durée de vie de cette instance. (Hérité de MarshalByRefObject)
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
MemberwiseClone(Boolean)	Crée une copie superficielle de l'objet MarshalByRefObject actuel. (Hérité de MarshalByRefObject)
ToString()	Retourne un String contenant le nom du Component, s’il en existe un. Cette méthode ne doit pas être remplacée. (Hérité de Component)

Événements

Disposed

Se produit lorsque le composant est supprimé par un appel à la méthode Dispose().

(Hérité de Component)

S’applique à

Partage via