Message Sınıf

Başvuru

Tanım

Ad Alanı:: System.Messaging

Bütünleştirilmiş Kod:: System.Messaging.dll

Önemli

Bazı bilgiler ürünün ön sürümüyle ilgilidir ve sürüm öncesinde önemli değişiklikler yapılmış olabilir. Burada verilen bilgilerle ilgili olarak Microsoft açık veya zımni hiçbir garanti vermez.

Message Queuing iletisini tanımlamak için gereken özelliklere erişim sağlar.

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

public class Message : System.ComponentModel.Component

type Message = class
    inherit Component

Public Class Message
Inherits Component

Devralma: Object

MarshalByRefObject

Component
Message

Örnekler

Aşağıdaki kod örneği, kullanarak BinaryMessageFormatterileti gövdesini biçimlendirmeyi gösterir.

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

Aşağıdaki kod örneği, kullanarak XmlMessageFormatterileti gövdesini biçimlendirmeyi gösterir.

#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

Açıklamalar

Sınıfını Message kullanarak kuyruktan iletileri inceleyin veya alın ya da kuyruğa ileti gönderirken ileti özellikleri üzerinde ayrıntılı denetim sahibi olun.

MessageQueuehem ve MessageQueue.Receive yöntemleri sınıfın yeni bir örneğini Message Message oluşturduğundan hem de MessageQueue.Peek örneğin özelliklerini ayarladığından kuyruklardan iletiler aldığında sınıfını kullanır. Sınıfın Message salt okunur özellikleri bir kuyruktan ileti almak için, okuma/yazma özellikleri ise iletileri gönderme ve alma için geçerlidir. Kuyruğa göz attığında MessageQueue veya kuyruktan bir ileti aldığında, MessageReadPropertyFilter iletinin özelliklerinden hangilerinin alındığını özelliği belirler.

sınıfının MessageQueue yöntemi, Send o kuyruğa gönderilen ileti için herhangi bir nesne türü belirtmenize olanak tanır. Kuyruğa gönderilen genel iletilerin MessageQueue ayarlarını belirtmek için örneğin DefaultPropertiesToSend özelliğini kullanabilirsiniz. Ayar türleri biçimlendirici, etiket, şifreleme ve kimlik doğrulamasıdır. Ayrıca, mesajlaşma uygulamanızı onay ve rapor iletilerine yanıt verecek şekilde koordine ederken uygun DefaultPropertiesToSend üyeler için değerler belirtebilirsiniz. Kuyruğa ileti göndermek için bir Message örnek kullanmak, bu özelliklerin çoğuna tek bir ileti için veya ileti temelinde erişme ve bunları değiştirme esnekliği sağlar. Message özellikleri üzerinde DefaultPropertiesToSendönceliklidir.

İleti verileri özelliğinde Body ve daha az ölçüde ve Extension özelliklerinde AppSpecific depolanır. İleti verileri şifrelendiğinde, seri hale getirildiğinde veya seri durumdan çıkarıldığında, yalnızca özelliğin Body içeriği etkilenir.

İleti gönderildiğinde özelliğin Body içeriği, belirttiğiniz özellik kullanılarak Formatter seri hale getirilir. Serileştirilmiş içerik özelliğinde BodyStream bulunur. Örneğin, bir dosyayı iletinin BodyStream veri içeriği olarak göndermek için özelliğini doğrudan da ayarlayabilirsiniz. veya özelliklerini iletiyi göndermeden önce istediğiniz zaman değiştirebilirsiniz Body Formatter ve çağrısı Sendyaptığınızda veriler uygun şekilde seri hale getirilir.

özelliği tarafından MessageQueue.DefaultPropertiesToSend tanımlanan özellikler yalnızca türünde Messageolmayan iletiler için geçerlidir. bir için özelliğini belirtirsenizDefaultPropertiesToSend, söz konusu kuyruğa gönderilen örnekteki Message aynı adlı özellikler bu varsayılan özelliklerin yoksayılmasına neden olur.MessageQueue

örneğinin ilk özellik değerlerinin Messagelistesi için oluşturucuya Message bakın.

Oluşturucular

Message()	Boş bir gövde ile sınıfının yeni bir örneğini Message başlatır.
Message(Object)	Belirtilen nesneyi iletinin gövdesinde Message seri hale getirmek için kullanarak XmlMessageFormatter sınıfının yeni bir örneğini başlatır.
Message(Object, IMessageFormatter)	Belirtilen nesneyi iletinin gövdesine Message seri hale getirmek için belirtilen biçimlendiriciyi kullanarak sınıfının yeni bir örneğini başlatır.

Alanlar

InfiniteTimeout

Zaman aşımı olmadığını belirtir.

Özellikler

AcknowledgeType	Gönderen uygulamaya döndürülecek bildirim iletisinin türünü alır veya ayarlar.
Acknowledgment	Bu iletinin temsil ettiği bildirim sınıflandırmasını alır.
AdministrationQueue	Message Queuing'in oluşturduğu onay iletilerini alan kuyruğu alır veya ayarlar.
AppSpecific	Uygulamaya özgü ek bilgileri alır veya ayarlar.
ArrivedTime	İletinin hedef kuyruğa ulaştığı zamanı alır.
AttachSenderId	Gönderen kimliğinin iletiye eklenip eklenmeyeceğini belirten bir değer alır veya ayarlar.
Authenticated	İletinin kimliğinin doğrulanıp doğrulanmamış olduğunu belirten bir değer alır.
AuthenticationProviderName	İletinin dijital imzasını oluşturmak için kullanılan şifreleme sağlayıcısının adını alır veya ayarlar.
AuthenticationProviderType	İletinin dijital imzasını oluşturmak için kullanılan şifreleme sağlayıcısı türünü alır veya ayarlar.
Body	İletinin içeriğini alır veya ayarlar.
BodyStream	İletinin gövdesindeki bilgileri alır veya ayarlar.
BodyType	İleti gövdesinin içerdiği veri türünü alır veya ayarlar.
CanRaiseEvents	Bileşenin olay oluşturup oluşturamayacağını belirten bir değer alır. (Devralındığı yer: Component)
ConnectorType	Genellikle Message Queuing tarafından ayarlanan bazı ileti özelliklerinin gönderen uygulama tarafından ayarlandığını belirten bir değer alır veya ayarlar.
Container	öğesini IContainer içeren öğesini Componentalır. (Devralındığı yer: Component)
CorrelationId	Özgün iletiye başvurmak için bildirim, rapor ve yanıt iletileri tarafından kullanılan ileti tanımlayıcısını alır veya ayarlar.
DesignMode	öğesinin şu anda tasarım modunda olup olmadığını Component gösteren bir değer alır. (Devralındığı yer: Component)
DestinationQueue	İleti için hedeflenen hedef kuyruğu alır.
DestinationSymmetricKey	Uygulamayla şifrelenmiş iletileri veya yabancı kuyruklara gönderilen iletileri şifrelemek için kullanılan simetrik anahtarı alır veya ayarlar.
DigitalSignature	Message Queuing'in iletinin kimliğini doğrulamak için kullandığı dijital imzayı alır veya ayarlar.
EncryptionAlgorithm	Özel iletinin gövdesini şifrelemek için kullanılan şifreleme algoritmasını alır veya ayarlar.
Events	Bu Componentöğesine eklenen olay işleyicilerinin listesini alır. (Devralındığı yer: Component)
Extension	İletiyle ilişkili ek, uygulama tanımlı bilgileri alır veya ayarlar.
Formatter	İleti gövdesinden bir nesneyi seri hale getirmek veya seri durumdan kaldırmak için kullanılan biçimlendiriciyi alır veya ayarlar.
HashAlgorithm	Message Queuing'in bir iletinin kimliğini doğrularken veya ileti için dijital imza oluştururken kullandığı karma algoritmayı alır veya ayarlar.
Id	İletinin tanımlayıcısını alır.
IsFirstInTransaction	İletinin bir işlemde gönderilen ilk ileti olup olmadığını gösteren bir değer alır.
IsLastInTransaction	İletinin bir işlemde gönderilen son ileti olup olmadığını gösteren bir değer alır.
Label	İletiyi açıklayan uygulama tanımlı bir Unicode dizesini alır veya ayarlar.
LookupId	MSMQ 3.0'da kullanıma sunulmuştur. İletinin arama tanımlayıcısını alır.
MessageType	İleti türünü alır: `Normal`, `Acknowledgment`veya `Report`.
Priority	İletinin kuyruğa nereye yerleştirileceğini belirleyen ileti önceliğini alır veya ayarlar.
Recoverable	Bir bilgisayar hatası veya ağ sorunu durumunda iletinin teslim edilmesi garanti edilip edilmediğini belirten bir değer alır veya ayarlar.
ResponseQueue	Uygulama tarafından oluşturulan yanıt iletilerini alan kuyruğu alır veya ayarlar.
SecurityContext	İletinin güvenlik bağlamını alır veya ayarlar.
SenderCertificate	İletilerin kimliğini doğrulamak için kullanılan güvenlik sertifikasını alır veya ayarlar.
SenderId	Gönderen kullanıcının tanımlayıcısını alır.
SenderVersion	İletiyi göndermek için kullanılan Message Queuing sürümünü alır.
SentTime	İletinin kaynak kuyruk yöneticisi tarafından gönderildiği tarihi ve saati gönderen bilgisayarda alır.
Site	öğesini alır veya ayarlar ISite Component. (Devralındığı yer: Component)
SourceMachine	İletinin kaynaklandığı bilgisayarı alır.
TimeToBeReceived	İletinin hedef kuyruktan alınması için gereken en uzun süreyi alır veya ayarlar.
TimeToReachQueue	İletinin kuyruğa ulaşması için gereken en uzun süreyi alır veya ayarlar.
TransactionId	İletinin parçası olduğu işlemin tanımlayıcısını alır.
TransactionStatusQueue	Kaynak bilgisayarda işlem durumu sırasını alır.
UseAuthentication	İletinin gönderilmeden önce kimliğinin doğrulanıp doğrulanmadığını (veya doğrulanması gerektiğini) belirten bir değer alır veya ayarlar.
UseDeadLetterQueue	teslim edilemeyen iletinin bir kopyasının teslim edilemeyen bir kuyruğa gönderilmesi gerekip gerekmediğini belirten bir değer alır veya ayarlar.
UseEncryption	İletinin özel yapılıp yapılmayacağını belirten bir değer alır veya ayarlar.
UseJournalQueue	İletinin bir kopyasının kaynak bilgisayardaki bir makine günlüğünde tutulup tutulmayacağını belirten bir değeri alır veya ayarlar.
UseTracing	İletinin hedef kuyruğuna doğru izlenip izlenmeyeceğini belirten bir değer alır veya ayarlar.

Yöntemler

CreateObjRef(Type)	Uzak bir nesneyle iletişim kurmak için kullanılan bir ara sunucu oluşturmak için gereken tüm ilgili bilgileri içeren bir nesne oluşturur. (Devralındığı yer: MarshalByRefObject)
Dispose()	Component tarafından kullanılan tüm kaynakları serbest bırakır. (Devralındığı yer: Component)
Dispose(Boolean)	Component tarafından kullanılan yönetilmeyen kaynakları serbest bırakır ve yönetilen kaynakları isteğe bağlı olarak serbest bırakır. (Devralındığı yer: Component)
Equals(Object)	Belirtilen nesnenin geçerli nesneye eşit olup olmadığını belirler. (Devralındığı yer: Object)
GetHashCode()	Varsayılan karma işlevi işlevi görür. (Devralındığı yer: Object)
GetLifetimeService()	Geçersiz. Bu örnek için yaşam süresi ilkesini denetleen geçerli yaşam süresi hizmet nesnesini alır. (Devralındığı yer: MarshalByRefObject)
GetService(Type)	veya tarafından Component Containersağlanan bir hizmeti temsil eden bir nesnesi döndürür. (Devralındığı yer: Component)
GetType()	Type Geçerli örneğini alır. (Devralındığı yer: Object)
InitializeLifetimeService()	Geçersiz. Bu örneğin yaşam süresi ilkesini denetlemek için bir yaşam süresi hizmet nesnesi alır. (Devralındığı yer: MarshalByRefObject)
MemberwiseClone()	Geçerli Objectöğesinin sığ bir kopyasını oluşturur. (Devralındığı yer: Object)
MemberwiseClone(Boolean)	Geçerli MarshalByRefObject nesnenin sığ bir kopyasını oluşturur. (Devralındığı yer: MarshalByRefObject)
ToString()	Varsa, adını Componentiçeren bir String döndürür. Bu yöntem geçersiz kılınmamalıdır. (Devralındığı yer: Component)

Ekinlikler

Disposed

Bileşen yöntemine Dispose() yapılan bir çağrı tarafından atıldığında gerçekleşir.

(Devralındığı yer: Component)

Şunlara uygulanır

Aracılığıyla paylaş