Message Kelas

Referensi

Definisi

Ruang nama:: System.Messaging

Rakitan:: System.Messaging.dll

Penting

Beberapa informasi terkait produk prarilis yang dapat diubah secara signifikan sebelum dirilis. Microsoft tidak memberikan jaminan, tersirat maupun tersurat, sehubungan dengan informasi yang diberikan di sini.

Menyediakan akses ke properti yang diperlukan untuk menentukan pesan Antrean Pesan.

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

public class Message : System.ComponentModel.Component

type Message = class
    inherit Component

Public Class Message
Inherits Component

Warisan: Object

MarshalByRefObject

Component
Message

Contoh

Contoh kode berikut menunjukkan pemformatan isi pesan menggunakan 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

Contoh kode berikut menunjukkan pemformatan isi pesan menggunakan 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

Keterangan

Message Gunakan kelas untuk mengintip atau menerima pesan dari antrean, atau untuk memiliki kontrol yang baik atas properti pesan saat mengirim pesan ke antrean.

MessageQueue Message menggunakan kelas saat mengintip atau menerima pesan dari antrean, karena MessageQueue.Peek metode dan MessageQueue.Receive membuat instans Message baru kelas dan mengatur properti instans. Properti Message baca-saja kelas berlaku untuk mengambil pesan dari antrean, sementara properti baca/tulis berlaku untuk mengirim dan mengambil pesan. Saat MessageQueue mengintip atau menerima pesan dari antrean, propertinya MessageReadPropertyFilter menentukan properti pesan mana yang diambil.

Metode MessageQueue kelas Send memungkinkan Anda menentukan jenis objek apa pun untuk pesan yang dikirim ke antrean tersebut. Anda dapat menggunakan MessageQueue properti instans DefaultPropertiesToSend untuk menentukan pengaturan untuk pesan generik yang dikirim ke antrean. Jenis pengaturan termasuk formatter, label, enkripsi, dan autentikasi. Anda juga dapat menentukan nilai untuk anggota yang sesuai DefaultPropertiesToSend saat mengoordinasikan aplikasi olahpesan untuk merespons pengakuan dan melaporkan pesan. Message Menggunakan instans untuk mengirim pesan ke antrean memberi Anda fleksibilitas untuk mengakses dan memodifikasi banyak properti ini - baik untuk satu pesan atau berdasarkan pesan demi pesan. Message properti lebih diutamakan daripada DefaultPropertiesToSend.

Data pesan disimpan di Body properti dan ke tingkat yang lebih rendah, AppSpecific properti dan Extension . Saat data pesan dienkripsi, diserialisasikan, atau dideserialisasi, hanya konten Body properti yang terpengaruh.

Konten properti diserialisasikan Body saat pesan dikirim, menggunakan properti yang Formatter Anda tentukan. Konten berseri ditemukan di BodyStream properti . Anda juga dapat mengatur properti secara BodyStream langsung, misalnya, untuk mengirim file sebagai konten data pesan. Anda dapat mengubah Body properti atau Formatter kapan saja sebelum mengirim pesan, dan data akan diserialisasikan dengan tepat saat Anda memanggil Send.

Properti yang MessageQueue.DefaultPropertiesToSend ditentukan oleh properti hanya berlaku untuk pesan yang bukan berjenis Message. Jika Anda menentukan DefaultPropertiesToSend properti untuk MessageQueue, properti bernama identik dalam Message instans yang dikirim ke antrean tersebut menyebabkan properti default ini diabaikan.

Untuk daftar nilai properti awal untuk instans Message, lihat Message konstruktor.

Konstruktor

Message()	Menginisialisasi instans Message baru kelas dengan isi kosong.
Message(Object)	Menginisialisasi instans Message baru kelas , menggunakan XmlMessageFormatter untuk membuat serialisasi objek yang ditentukan ke dalam isi pesan.
Message(Object, IMessageFormatter)	Menginisialisasi instans Message baru kelas menggunakan pemformat yang ditentukan untuk membuat serialisasi objek yang ditentukan ke dalam isi pesan.

Bidang

InfiniteTimeout

Menentukan bahwa tidak ada waktu habis.

Properti

AcknowledgeType	Mendapatkan atau mengatur jenis pesan pengakuan yang akan dikembalikan ke aplikasi pengirim.
Acknowledgment	Mendapatkan klasifikasi pengakuan yang diwakili pesan ini.
AdministrationQueue	Mendapatkan atau mengatur antrean yang menerima pesan pengakuan yang dihasilkan Oleh Antrean Pesan.
AppSpecific	Mendapatkan atau mengatur informasi tambahan khusus aplikasi.
ArrivedTime	Mendapatkan waktu pesan tiba di antrean tujuan.
AttachSenderId	Mendapatkan atau menetapkan nilai yang menunjukkan apakah ID pengirim harus dilampirkan ke pesan.
Authenticated	Mendapatkan nilai yang menunjukkan apakah pesan diautentikasi.
AuthenticationProviderName	Mendapatkan atau mengatur nama penyedia kriptografi yang digunakan untuk menghasilkan tanda tangan digital pesan.
AuthenticationProviderType	Mendapatkan atau mengatur jenis penyedia kriptografi yang digunakan untuk menghasilkan tanda tangan digital pesan.
Body	Mendapatkan atau mengatur konten pesan.
BodyStream	Mendapatkan atau mengatur informasi dalam isi pesan.
BodyType	Mendapatkan atau mengatur jenis data yang dikandung isi pesan.
CanRaiseEvents	Mendapatkan nilai yang menunjukkan apakah komponen dapat menaikkan peristiwa. (Diperoleh dari Component)
ConnectorType	Mendapatkan atau menetapkan nilai yang menunjukkan bahwa beberapa properti pesan biasanya diatur oleh Antrean Pesan diatur oleh aplikasi pengirim.
Container	IContainer Mendapatkan yang berisi Component. (Diperoleh dari Component)
CorrelationId	Mendapatkan atau mengatur pengidentifikasi pesan yang digunakan oleh pesan pengakuan, laporan, dan respons untuk mereferensikan pesan asli.
DesignMode	Mendapatkan nilai yang menunjukkan apakah Component saat ini dalam mode desain. (Diperoleh dari Component)
DestinationQueue	Mendapatkan antrean tujuan yang dimaksudkan untuk pesan.
DestinationSymmetricKey	Mendapatkan atau mengatur kunci konten yang digunakan untuk mengenkripsi pesan atau pesan terenkripsi aplikasi yang dikirim ke antrean asing.
DigitalSignature	Mendapatkan atau mengatur tanda tangan digital yang digunakan Antrean Pesan untuk mengautentikasi pesan.
EncryptionAlgorithm	Mendapatkan atau mengatur algoritma enkripsi yang digunakan untuk mengenkripsi isi pesan privat.
Events	Mendapatkan daftar penanganan aktivitas yang dilampirkan ke ini Component. (Diperoleh dari Component)
Extension	Mendapatkan atau mengatur informasi tambahan yang ditentukan aplikasi yang terkait dengan pesan.
Formatter	Mendapatkan atau mengatur pemformat yang digunakan untuk menserialisasikan objek ke dalam atau mendeserialisasi objek dari isi pesan.
HashAlgorithm	Mendapatkan atau mengatur algoritma hashing yang digunakan Antrean Pesan saat mengautentikasi pesan atau membuat tanda tangan digital untuk pesan.
Id	Mendapatkan pengidentifikasi pesan.
IsFirstInTransaction	Mendapatkan nilai yang menunjukkan apakah pesan tersebut adalah pesan pertama yang dikirim dalam transaksi.
IsLastInTransaction	Mendapatkan nilai yang menunjukkan apakah pesan tersebut adalah pesan terakhir yang dikirim dalam transaksi.
Label	Mendapatkan atau mengatur string Unicode yang ditentukan aplikasi yang menjelaskan pesan.
LookupId	Diperkenalkan dalam MSMQ 3.0. Mendapatkan pengidentifikasi pencarian pesan.
MessageType	Mendapatkan jenis pesan: `Normal`, , `Acknowledgment`atau `Report`.
Priority	Mendapatkan atau mengatur prioritas pesan, yang menentukan di mana dalam antrean pesan ditempatkan.
Recoverable	Mendapatkan atau menetapkan nilai yang menunjukkan apakah pesan dijamin akan dikirim jika terjadi kegagalan komputer atau masalah jaringan.
ResponseQueue	Mendapatkan atau mengatur antrean yang menerima pesan respons yang dihasilkan aplikasi.
SecurityContext	Mendapatkan atau mengatur konteks keamanan untuk pesan.
SenderCertificate	Mendapatkan atau mengatur sertifikat keamanan yang digunakan untuk mengautentikasi pesan.
SenderId	Mendapatkan pengidentifikasi pengguna pengirim.
SenderVersion	Mendapatkan versi Antrean Pesan yang digunakan untuk mengirim pesan.
SentTime	Mendapatkan tanggal dan waktu pada komputer pengirim bahwa pesan dikirim oleh manajer antrean sumber.
Site	Mendapatkan atau mengatur ISite dari Component. (Diperoleh dari Component)
SourceMachine	Mendapatkan komputer dari mana pesan berasal.
TimeToBeReceived	Mendapatkan atau mengatur jumlah waktu maksimum pesan yang akan diterima dari antrean tujuan.
TimeToReachQueue	Mendapatkan atau mengatur jumlah waktu maksimum pesan untuk mencapai antrean.
TransactionId	Mendapatkan pengidentifikasi untuk transaksi tempat pesan menjadi bagiannya.
TransactionStatusQueue	Mendapatkan antrean status transaksi di komputer sumber.
UseAuthentication	Mendapatkan atau menetapkan nilai yang menunjukkan apakah pesan tersebut (atau harus) diautentikasi sebelum dikirim.
UseDeadLetterQueue	Mendapatkan atau menetapkan nilai yang menunjukkan apakah salinan pesan yang tidak dapat dikirim harus dikirim ke antrean surat mati.
UseEncryption	Mendapatkan atau menetapkan nilai yang menunjukkan apakah akan membuat pesan privat.
UseJournalQueue	Mendapatkan atau menetapkan nilai yang menunjukkan apakah salinan pesan harus disimpan dalam jurnal mesin di komputer asal.
UseTracing	Mendapatkan atau menetapkan nilai yang menunjukkan apakah akan melacak pesan saat berpindah ke antrean tujuannya.

Metode

CreateObjRef(Type)	Membuat objek yang berisi semua informasi relevan yang diperlukan untuk menghasilkan proksi yang digunakan untuk berkomunikasi dengan objek jarak jauh. (Diperoleh dari MarshalByRefObject)
Dispose()	Merilis semua sumber daya yang Componentdigunakan oleh . (Diperoleh dari Component)
Dispose(Boolean)	Merilis sumber daya tidak terkelola yang digunakan oleh Component dan secara opsional merilis sumber daya terkelola. (Diperoleh dari Component)
Equals(Object)	Menentukan apakah objek yang ditentukan sama dengan objek saat ini. (Diperoleh dari Object)
GetHashCode()	Berfungsi sebagai fungsi hash default. (Diperoleh dari Object)
GetLifetimeService()	Kedaluwarsa. Mengambil objek layanan seumur hidup saat ini yang mengontrol kebijakan seumur hidup untuk instans ini. (Diperoleh dari MarshalByRefObject)
GetService(Type)	Mengembalikan objek yang mewakili layanan yang disediakan oleh Component atau oleh Container. (Diperoleh dari Component)
GetType()	Mendapatkan dari instans Type saat ini. (Diperoleh dari Object)
InitializeLifetimeService()	Kedaluwarsa. Mendapatkan objek layanan seumur hidup untuk mengontrol kebijakan seumur hidup untuk instans ini. (Diperoleh dari MarshalByRefObject)
MemberwiseClone()	Membuat salinan dangkal dari saat ini Object. (Diperoleh dari Object)
MemberwiseClone(Boolean)	Membuat salinan dangkal objek saat ini MarshalByRefObject . (Diperoleh dari MarshalByRefObject)
ToString()	Mengembalikan yang String berisi nama Component, jika ada. Metode ini tidak boleh ditimpa. (Diperoleh dari Component)

Acara

Disposed

Terjadi ketika komponen dibuang oleh panggilan ke Dispose() metode .

(Diperoleh dari Component)

Berlaku untuk

Bagikan melalui