Message Classe

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 pour définir un message 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 BinaryMessageFormatterde .

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 XmlMessageFormatterde .

#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 afficher ou recevoir des messages d’une file d’attente ou pour contrôler correctement les propriétés des messages lors de l’envoi d’un message à une file d’attente.

MessageQueueutilise la Message classe lorsqu’elle examine ou reçoit des messages à partir de files d’attente, car les méthodes et MessageQueue.Receive les MessageQueue.Peek méthodes créent une instance de la Message classe et définissent les propriétés de l’instance. Les Message propriétés en lecture seule de la classe s’appliquent à la récupération des messages à partir d’une file d’attente, tandis que les propriétés de lecture/écriture s’appliquent à l’envoi et à la récupération de messages. Lorsque MessageQueue vous examinez ou recevez un message à partir d’une file d’attente, sa MessageReadPropertyFilter propriété détermine les propriétés du message qui sont récupérées.

La méthode de Send la MessageQueue classe vous permet de spécifier n’importe quel type d’objet pour un message envoyé à cette file d’attente. Vous pouvez utiliser la propriété de l’instance MessageQueue DefaultPropertiesToSend 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 accusés de réception et aux messages de rapport. L’utilisation d’une Message instance pour envoyer un message à la file d’attente vous donne la possibilité d’accéder à la file d’attente et de modifier un grand nombre de ces propriétés, soit pour un seul message, soit sur une base de 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 propriétés et Extension les AppSpecific propriétés. 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 le ou Formatter les Body propriétés à 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 MessageQueue.DefaultPropertiesToSend propriété s’appliquent uniquement aux messages qui ne sont pas de type Message. Si vous spécifiez la DefaultPropertiesToSend propriété pour un MessageQueue, les propriétés identiques nommées dans une Message instance envoyée à cette file d’attente entraînent l’ignorer.

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

Constructeurs

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

Champs

Nom	Description
InfiniteTimeout	Spécifie qu’aucun délai d’attente n’existe.

Propriétés

Nom	Description
AcknowledgeType	Obtient ou définit le type de message d’accusé de réception à renvoyer à l’application d’envoi.
Acknowledgment	Obtient la classification de l’accusé de réception que ce message représente.
AdministrationQueue	Obtient ou définit la file d’attente qui reçoit 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 d’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 chiffrement utilisé pour générer la signature numérique du message.
AuthenticationProviderType	Obtient ou définit le type de fournisseur 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 que le corps du message contient.
CanRaiseEvents	Obtient une valeur indiquant 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 d’envoi.
Container	Obtient le IContainer fichier qui contient le Component. (Hérité de Component)
CorrelationId	Obtient ou définit l’identificateur de message utilisé par accusé de réception, rapport et messages de réponse pour référencer le message d’origine.
DesignMode	Obtient une valeur qui indique si la Component valeur est actuellement en mode création. (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 ou messages chiffrés par l’application envoyés aux files d’attente étrangères.
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 qui sont attachés à ce Component. (Hérité de Component)
Extension	Obtient ou définit des informations supplémentaires définies par l’application associées au message.
Formatter	Obtient ou définit le formateur utilisé pour sérialiser un objet dans ou désérialiser un objet à partir du corps du message.
HashAlgorithm	Obtient ou définit l’algorithme de hachage utilisé par Message Queuing lors de l’authentification d’un message ou de 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 a été le premier message envoyé dans une transaction.
IsLastInTransaction	Obtient une valeur qui indique si le message a été 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	Introduit dans MSMQ 3.0. Obtient l’identificateur de recherche du message.
MessageType	Obtient le type de message : `Normal`, `Acknowledgment`ou `Report`.
Priority	Obtient ou définit la priorité du message, qui détermine où se trouve le message dans la file d’attente.
Recoverable	Obtient ou définit une valeur qui indique si le message est garanti pour être remis en cas de défaillance d’ordinateur ou de problème 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 les messages.
SenderId	Obtient l’identificateur de l’utilisateur envoyant.
SenderVersion	Obtient la version de Message Queuing utilisée pour envoyer le message.
SentTime	Obtient la date et l’heure sur l’ordinateur d’envoi que le message a été envoyé par le gestionnaire de file d’attente source.
Site	Obtient ou définit le ISite Component. (Hérité de Component)
SourceMachine	Obtient l’ordinateur à partir duquel le message provient.
TimeToBeReceived	Obtient ou définit la durée maximale pendant laquelle le message doit être reçu de la file d’attente de destination.
TimeToReachQueue	Obtient ou définit la durée maximale pendant laquelle le message doit atteindre la file d’attente.
TransactionId	Obtient l’identificateur de la transaction dont le message faisait partie.
TransactionStatusQueue	Obtient la file d’attente d’état des transactions sur l’ordinateur source.
UseAuthentication	Obtient ou définit une valeur qui indique si le message a été (ou doit être) authentifié avant d’être envoyé.
UseDeadLetterQueue	Obtient ou définit une valeur qui indique si une copie du message qui n’a pas pu être remise doit être envoyée à une file d’attente de lettres mortes.
UseEncryption	Obtient ou définit une valeur qui indique s’il faut rendre le message privé.
UseJournalQueue	Obtient ou définit une valeur qui indique si une copie du message doit être conservée dans un journal d’ordinateur sur l’ordinateur d’origine.
UseTracing	Obtient ou définit une valeur qui indique s’il faut tracer un message à mesure qu’il se déplace vers sa file d’attente de destination.

Méthodes

Nom	Description
CreateObjRef(Type)	Crée un objet qui contient toutes les informations pertinentes requises pour générer un proxy utilisé pour communiquer avec un objet distant. (Hérité de MarshalByRefObject)
Dispose()	Libère toutes les ressources utilisées par le Component. (Hérité de Component)
Dispose(Boolean)	Libère les ressources non managées utilisées par les Component ressources gérées 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()	Sert 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 actuel 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 le Component ou par son Container. (Hérité de Component)
GetType()	Obtient la 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 Objectactuel. (Hérité de Object)
MemberwiseClone(Boolean)	Crée une copie superficielle de l’objet actuel MarshalByRefObject . (Hérité de MarshalByRefObject)
ToString()	Retourne un String nom contenant le nom du Component, le cas échéant. Cette méthode ne doit pas être remplacée. (Hérité de Component)

Événements

Nom	Description
Disposed	Se produit lorsque le composant est supprimé par un appel à la Dispose() méthode. (Hérité de Component)

S’applique à

Voir aussi

Commentaires

Cette page a-t-elle été utile ?