Message Třída

Definice

Obor názvů:: System.Messaging

Sestavení:: System.Messaging.dll

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

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ři odesílání zprávy do fronty kontrolu nad vlastnostmi zprávy.

MessageQueue Message používá třídu při náhledu nebo příjmu zpráv z front, protože obě MessageQueue.Peek metody MessageQueue.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 náhledu nebo přijetí zprávy z fronty, jeho MessageReadPropertyFilter vlastnost určuje, které vlastnosti zprávy jsou načteny.

MessageQueue Metoda třídy Send umožňuje zadat libovolný typ objektu pro zprávu, která se odesílá 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, když koordinujete aplikaci pro zasílání zpráv, aby reagovala na potvrzení a zprávy sestavy. Message Použití instance k odeslání zprávy do fronty poskytuje flexibilitu pro přístup a úpravu mnoha těchto vlastností – buď pro jednu zprávu, nebo pro zprávu po jednotlivých zprávách. Message vlastnosti mají přednost před DefaultPropertiesToSend.

Data zpráv jsou uložena Body ve vlastnosti a v menším rozsahu, a AppSpecific Extension vlastnosti. Pokud jsou data zpráv zašifrována, serializována nebo deserializována, jsou ovlivněny pouze obsah Body vlastnosti.

Body Obsah 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 odeslat soubor jako datový obsah zprávy. Před odesláním zprávy můžete kdykoli změnit Body vlastnosti Formatter a data budou serializována odpovídajícím způsobem při volání Send.

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

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

Konstruktory

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

Pole

Name	Description
InfiniteTimeout	Určuje, že neexistuje žádný časový limit.

Vlastnosti

Name	Description
AcknowledgeType	Získá nebo nastaví typ potvrzovací zprávy, která se má vrátit do odesílající aplikace.
Acknowledgment	Získá klasifikaci potvrzení, že 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 vygeneruje.
AppSpecific	Získá nebo nastaví další informace specifické pro aplikaci.
ArrivedTime	Získá čas, kdy zpráva přišla do cílové fronty.
AttachSenderId	Získá nebo nastaví hodnotu, která urč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á text zprávy obsahuje.
CanRaiseEvents	Získá hodnotu určující, zda komponenta může vyvolat událost. (Zděděno od Component)
ConnectorType	Získá nebo nastaví hodnotu, která indikuje, že některé vlastnosti zprávy obvykle nastavené službou Řízení front zpráv byly nastaveny odesílající aplikací.
Container	Získá ten IContainer , který obsahuje Component. (Zděděno od Component)
CorrelationId	Získá nebo nastaví identifikátor zprávy, který používá potvrzení, sestava a odpovědi zprávy odkazovat na původní zprávu.
DesignMode	Získá hodnotu, která označuje, zda Component je aktuálně v režimu návrhu. (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 š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í textu 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í hashovací algoritmus, 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 odeslána v transakci.
IsLastInTransaction	Získá hodnotu, která označuje, zda zpráva byla poslední zpráva odeslána 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`, `Acknowledgment`nebo `Report`.
Priority	Získá nebo nastaví prioritu zprávy, která určuje, kde je zpráva umístěna ve frontě.
Recoverable	Získá nebo nastaví hodnotu, která indikuje, zda je zaručeno doručení zprávy v případě selhání počítače nebo síťového problému.
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žitý k ověření zpráv.
SenderId	Získá identifikátor odesílajícího uživatele.
SenderVersion	Získá verzi služby Řízení front zpráv použitou k odeslání zprávy.
SentTime	Získá datum a čas v odesílajícím počítači, který zprávu odeslal správce zdrojové fronty.
Site	Získá nebo nastaví ISite .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 pro transakci, ze které byla zpráva součástí.
TransactionStatusQueue	Získá frontu stavu transakce ve zdrojovém počítači.
UseAuthentication	Získá nebo nastaví hodnotu, která označuje, zda byla zpráva (nebo musí být) ověřena před odesláním.
UseDeadLetterQueue	Získá nebo nastaví hodnotu, která určuje, zda kopie zprávy, která nelze doručit, by měla být odeslána do fronty nedoručených zpráv.
UseEncryption	Získá nebo nastaví hodnotu, která určuje, zda má být zpráva soukromá.
UseJournalQueue	Získá nebo nastaví hodnotu, která určuje, zda má být kopie zprávy 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á zpráva trasovat při pohybu směrem k cílové frontě.

Metody

Name	Description
CreateObjRef(Type)	Vytvoří objekt, který obsahuje všechny relevantní informace potřebné k vygenerování proxy serveru sloužící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 a volitelně uvolní spravované prostředky. (Zděděno od Component)
Equals(Object)	Určuje, zda je zadaný objekt roven aktuálnímu objektu. (Zděděno od Object)
GetHashCode()	Slouží jako výchozí funkce hash. (Zděděno od Object)
GetLifetimeService()	Zastaralé. 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 jeho Container. (Zděděno od Component)
GetType()	Získá Type aktuální instance. (Zděděno od Object)
InitializeLifetimeService()	Zastaralé. Získá objekt služby životnosti pro řízení zásad životnosti pro tuto instanci. (Zděděno od MarshalByRefObject)
MemberwiseClone()	Vytvoří mělkou kopii aktuálního Object. (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

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

Platí pro

Viz také

Váš názor

Byla tato stránka užitečná?