Message Třída

Definice

Obor názvů:

System.Messaging

Sestavení:

System.Messaging.dll

Poskytuje přístup k vlastnostem potřebným k definování zprávy služby Řízení front zpráv.

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

public class Message : System.ComponentModel.Component

type Message = class
    inherit Component

Public Class Message
Inherits Component

Dědičnost

Object

MarshalByRefObject

Component

Message

Příklady

Následující příklad kódu ukazuje formátování textu zprávy pomocí 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

Následující příklad kódu ukazuje formátování textu zprávy pomocí 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

Poznámky

Message Pomocí třídy můžete zobrazit nebo přijímat zprávy z fronty nebo mít přesnou kontrolu nad vlastnostmi zprávy při odesílání zprávy do fronty.

MessageQueueMessage používá třídu při náhledu nebo příjmu zpráv z front, protože metody a MessageQueue.PeekMessageQueue.Receive vytvoří novou instanci Message třídy a nastaví vlastnosti instance. Vlastnosti Message třídy jen pro čtení platí pro načítání zpráv z fronty, zatímco vlastnosti pro čtení a zápis platí pro odesílání a načítání zpráv. Při MessageQueue zobrazení nebo přijetí zprávy z fronty určuje jeho MessageReadPropertyFilter vlastnost, které z vlastností zprávy se načtou.

Metoda MessageQueue třídy Send umožňuje zadat libovolný typ objektu pro zprávu odesílanou do této fronty. Vlastnost instance DefaultPropertiesToSend můžete použít MessageQueue k určení nastavení obecných zpráv odesílaných do fronty. Mezi typy nastavení patří formátovací modul, popisek, šifrování a ověřování. Můžete také zadat hodnoty pro příslušné DefaultPropertiesToSend členy při koordinaci aplikace zasílání zpráv, aby reagovala na potvrzované zprávy a hlášení. Message Použití instance k odeslání zprávy do fronty poskytuje flexibilitu pro přístup a úpravy mnoha z těchto vlastností – buď pro jednu zprávu, nebo pro jednotlivé zprávy. Message vlastnosti mají přednost před DefaultPropertiesToSend.

Data zpráv jsou uložena Body ve vlastnosti a v menší míře vlastnosti AppSpecific a Extension . Při šifrování, serializaci nebo deserializaci dat zpráv jsou ovlivněny pouze obsah Body vlastnosti.

Obsah Body vlastnosti se serializuje při odeslání zprávy pomocí Formatter vlastnosti, kterou zadáte. Serializovaný obsah se nachází ve BodyStream vlastnosti. Vlastnost můžete také nastavit BodyStream přímo, například tak, aby se soubor odeslal jako datový obsah zprávy. Vlastnosti nebo Formatter můžete kdykoli před odesláním zprávy změnit Body a data budou při volání Sendodpovídajícím způsobem serializována.

Vlastnosti definované MessageQueue.DefaultPropertiesToSend vlastností se vztahují pouze na zprávy, které nejsou typu Message. Pokud zadáte DefaultPropertiesToSend vlastnost pro MessageQueue, identicky pojmenované vlastnosti v Message instanci odeslané do této fronty způsobí, že tyto výchozí vlastnosti budou ignorovány.

Seznam počátečních hodnot vlastností pro instanci Messagenástroje najdete v konstruktoru Message .

Konstruktory

Message()	Inicializuje novou instanci Message třídy s prázdným tělem.
Message(Object)	Inicializuje novou instanci Message třídy pomocí XmlMessageFormatter k serializaci zadaného objektu do textu zprávy.
Message(Object, IMessageFormatter)	Inicializuje novou instanci Message třídy pomocí zadaného formátovače serializovat zadaný objekt do textu zprávy.

Pole

InfiniteTimeout

Určuje, že časový limit neexistuje.

Vlastnosti

AcknowledgeType	Získá nebo nastaví typ potvrzovací zprávy, která se má vrátit do odesílající aplikace.
Acknowledgment	Získá klasifikaci potvrzení, které tato zpráva představuje.
AdministrationQueue	Získá nebo nastaví frontu, která přijímá potvrzovací zprávy, které služba Řízení front zpráv generuje.
AppSpecific	Získá nebo nastaví další informace specifické pro aplikaci.
ArrivedTime	Získá čas, kdy zpráva dorazila do cílové fronty.
AttachSenderId	Získá nebo nastaví hodnotu, která označuje, zda má být id odesílatele připojeno ke zprávě.
Authenticated	Získá hodnotu, která označuje, zda zpráva byla ověřena.
AuthenticationProviderName	Získá nebo nastaví název kryptografického zprostředkovatele použitého k vygenerování digitálního podpisu zprávy.
AuthenticationProviderType	Získá nebo nastaví typ kryptografického zprostředkovatele použitého k vygenerování digitálního podpisu zprávy.
Body	Získá nebo nastaví obsah zprávy.
BodyStream	Získá nebo nastaví informace v textu zprávy.
BodyType	Získá nebo nastaví typ dat, které obsahuje text zprávy.
CanRaiseEvents	Získá hodnotu označující, zda komponenta může vyvolat událost. (Zděděno od Component)
ConnectorType	Získá nebo nastaví hodnotu, která označuje, že některé vlastnosti zprávy obvykle nastaveny podle řízení front zpráv byly nastaveny odesílající aplikace.
Container	Získá objekt IContainer , který obsahuje Component. (Zděděno od Component)
CorrelationId	Získá nebo nastaví identifikátor zprávy používané potvrzením, sestavou a zprávami odpovědi odkazovat na původní zprávu.
DesignMode	Získá hodnotu, která označuje, zda je aktuálně v režimu návrhu Component . (Zděděno od Component)
DestinationQueue	Získá zamýšlenou cílovou frontu pro zprávu.
DestinationSymmetricKey	Získá nebo nastaví symetrický klíč použitý k šifrování zpráv zašifrovaných aplikací nebo zpráv odesílaných do cizích front.
DigitalSignature	Získá nebo nastaví digitální podpis, který služba Řízení front zpráv používá k ověření zprávy.
EncryptionAlgorithm	Získá nebo nastaví šifrovací algoritmus použitý k šifrování těla soukromé zprávy.
Events	Získá seznam obslužných rutin událostí, které jsou připojeny k tomuto Component. (Zděděno od Component)
Extension	Získá nebo nastaví další informace definované aplikací přidružené ke zprávě.
Formatter	Získá nebo nastaví formátovací modul použitý k serializaci objektu do nebo deserializovat objekt z textu zprávy.
HashAlgorithm	Získá nebo nastaví algoritmus hash, který služba Řízení front zpráv používá při ověřování zprávy nebo vytvoření digitálního podpisu pro zprávu.
Id	Získá identifikátor zprávy.
IsFirstInTransaction	Získá hodnotu, která označuje, zda zpráva byla první zpráva odeslaná v transakci.
IsLastInTransaction	Získá hodnotu, která označuje, zda zpráva byla poslední zpráva odeslaná v transakci.
Label	Získá nebo nastaví řetězec Unicode definovaný aplikací, který popisuje zprávu.
LookupId	Zavedeno v MSMQ 3.0. Získá vyhledávací identifikátor zprávy.
MessageType	Získá typ zprávy: Normal, Acknowledgmentnebo Report.
Priority	Získá nebo nastaví prioritu zprávy, která určuje, kam ve frontě je zpráva umístěna.
Recoverable	Získá nebo nastaví hodnotu, která označuje, zda je zaručeno doručení zprávy v případě selhání počítače nebo problém se sítí.
ResponseQueue	Získá nebo nastaví frontu, která přijímá zprávy odpovědi generované aplikací.
SecurityContext	Získá nebo nastaví kontext zabezpečení pro zprávu.
SenderCertificate	Získá nebo nastaví certifikát zabezpečení používaný k ověřování zpráv.
SenderId	Získá identifikátor odesílajícího uživatele.
SenderVersion	Získá verzi služby Řízení front zpráv použité k odeslání zprávy.
SentTime	Získá datum a čas na odesílajícím počítači, že zpráva byla odeslána správcem zdrojové fronty.
Site	Získá nebo nastaví ISite hodnotu Component. (Zděděno od Component)
SourceMachine	Získá počítač, ze kterého zpráva pochází.
TimeToBeReceived	Získá nebo nastaví maximální dobu pro přijetí zprávy z cílové fronty.
TimeToReachQueue	Získá nebo nastaví maximální dobu, po kterou se zpráva dostane do fronty.
TransactionId	Získá identifikátor transakce, jejíž součástí byla zpráva.
TransactionStatusQueue	Získá frontu stavu transakce na zdrojovém počítači.
UseAuthentication	Získá nebo nastaví hodnotu, která označuje, zda zpráva byla (nebo musí být) ověřena před odesláním.
UseDeadLetterQueue	Získá nebo nastaví hodnotu, která označuje, zda kopie zprávy, která nemohla být doručena, by měla být odeslána do fronty nedoručených zpráv.
UseEncryption	Získá nebo nastaví hodnotu, která označuje, zda se má zpráva nastavit jako soukromá.
UseJournalQueue	Získá nebo nastaví hodnotu, která označuje, zda kopie zprávy by měla být uložena v deníku počítače na původním počítači.
UseTracing	Získá nebo nastaví hodnotu, která označuje, zda se má trasovat zpráva, když se pohybuje směrem k cílové frontě.

Metody

CreateObjRef(Type)	Vytvoří objekt, který obsahuje všechny relevantní informace potřebné k vygenerování proxy používaného ke komunikaci se vzdáleným objektem. (Zděděno od MarshalByRefObject)
Dispose()	Uvolní všechny prostředky používané nástrojem Component. (Zděděno od Component)
Dispose(Boolean)	Uvolní nespravované prostředky používané Component nástrojem a volitelně uvolní spravované prostředky. (Zděděno od Component)
Equals(Object)	Určí, zda se zadaný objekt rovná aktuálnímu objektu. (Zděděno od Object)
GetHashCode()	Slouží jako výchozí hashovací funkce. (Zděděno od Object)
GetLifetimeService()	Načte objekt služby aktuální životnosti, který řídí zásady životnosti pro tuto instanci. (Zděděno od MarshalByRefObject)
GetService(Type)	Vrátí objekt, který představuje službu poskytovanou objektem Component nebo jejím Containerobjektem . (Zděděno od Component)
GetType()	Získá aktuální Type instanci. (Zděděno od Object)
InitializeLifetimeService()	Získá objekt služby životnosti, který řídí zásady životnosti pro tuto instanci. (Zděděno od MarshalByRefObject)
MemberwiseClone()	Vytvoří mělkou kopii aktuálního Objectsouboru . (Zděděno od Object)
MemberwiseClone(Boolean)	Vytvoří mělkou kopii aktuálního MarshalByRefObject objektu. (Zděděno od MarshalByRefObject)
ToString()	String Vrátí hodnotu obsahující název Component, pokud existuje. Tato metoda by neměla být přepsána. (Zděděno od Component)

Událost

Disposed

Nastane, když je komponenta odstraněna voláním Dispose() metody. (Zděděno od Component)

Viz také

• MessageQueue
• DefaultPropertiesToSend
• Send(Object)
• Receive()
• Peek()