Bagikan melalui


Message Kelas

Definisi

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

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.

MessageQueueMessage 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, , Acknowledgmentatau 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

Lihat juga