Message 클래스

정의

네임스페이스:: System.Messaging

어셈블리:: System.Messaging.dll

중요

일부 정보는 릴리스되기 전에 상당 부분 수정될 수 있는 시험판 제품과 관련이 있습니다. Microsoft는 여기에 제공된 정보에 대해 어떠한 명시적이거나 묵시적인 보증도 하지 않습니다.

메시지 큐 메시지를 정의하는 데 필요한 속성에 대한 액세스를 제공합니다.

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

public class Message : System.ComponentModel.Component

type Message = class
    inherit Component

Public Class Message
Inherits Component

상속: Object

MarshalByRefObject

Component
Message

예제

다음 코드 예제에서는 .를 사용하여 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

다음 코드 예제에서는 .를 사용하여 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

설명

클래스를 Message 사용하여 큐에서 메시지를 피킹하거나 받거나 큐에 메시지를 보낼 때 메시지 속성을 세부적으로 제어할 수 있습니다.

MessageQueue는 클래스와 메서드가 모두 MessageQueue.Peek MessageQueue.Receive 클래스의 Message 새 인스턴스를 만들고 인스턴스 Message 의 속성을 설정하기 때문에 큐에서 메시지를 피킹하거나 수신할 때 클래스를 사용합니다. 클래스의 읽기 전용 속성은 Message 큐에서 메시지를 검색하는 데 적용되는 반면 읽기/쓰기 속성은 메시지 보내기 및 검색에 적용됩니다. MessageQueue 큐에서 메시지를 피킹하거나 받으면 해당 MessageReadPropertyFilter 속성은 검색되는 메시지의 속성을 결정합니다.

클래스 MessageQueue 의 Send 메서드를 사용하면 해당 큐로 전송되는 메시지에 대한 개체 형식을 지정할 수 있습니다. 인스턴스의 MessageQueue DefaultPropertiesToSend 속성을 사용하여 큐로 전송된 일반 메시지에 대한 설정을 지정할 수 있습니다. 설정 유형에는 포맷터, 레이블, 암호화 및 인증이 포함됩니다. 메시지 애플리케이션을 조정하여 승인 메시지에 응답하고 메시지를 보고할 때 적절한 DefaultPropertiesToSend 멤버에 대한 값을 지정할 수도 있습니다. 인스턴스를 Message 사용하여 큐에 메시지를 보내면 단일 메시지 또는 메시지 단위로 이러한 많은 속성에 액세스하고 수정할 수 있습니다. Message 속성이 .보다 DefaultPropertiesToSend우선합니다.

메시지 데이터는 속성 및 Body 더 작은 범위, 및 Extension 속성에 AppSpecific 저장됩니다. 메시지 데이터가 암호화, 직렬화 또는 역직렬화되면 속성 내용 Body 만 영향을 받습니다.

지정한 속성을 사용하여 메시지를 보낼 때 속성의 Body 내용이 Formatter serialize됩니다. 직렬화된 콘텐츠는 속성에 BodyStream 있습니다. 예를 들어 파일을 메시지의 BodyStream 데이터 콘텐츠로 보내도록 속성을 직접 설정할 수도 있습니다. 메시지를 보내기 전에 언제든지 또는 Formatter 속성을 변경할 Body 수 있으며, 호출Send할 때 데이터가 적절하게 serialize됩니다.

속성에서 정의한 MessageQueue.DefaultPropertiesToSend 속성은 형식 Message이 아닌 메시지에만 적용됩니다. 속성에 DefaultPropertiesToSend 대해 MessageQueue지정하는 경우 해당 큐로 전송된 인스턴스의 Message 동일한 명명된 속성으로 인해 이러한 기본 속성이 무시됩니다.

인스턴스 Message의 초기 속성 값 목록은 생성자를 참조 Message 하세요.

생성자

Name	Description
Message()	빈 본문을 사용하여 클래스의 Message 새 인스턴스를 초기화합니다.
Message(Object, IMessageFormatter)	지정된 포맷터를 사용하여 지정된 개체를 Message 메시지 본문으로 serialize하여 클래스의 새 인스턴스를 초기화합니다.
Message(Object)	지정된 개체를 메시지 본 Message 문으로 serialize하는 데 사용하여 XmlMessageFormatter 클래스의 새 인스턴스를 초기화합니다.

필드

Name	Description
InfiniteTimeout	시간 제한 없음을 지정합니다.

속성

Name	Description
AcknowledgeType	보내는 애플리케이션에 반환할 승인 메시지의 형식을 가져오거나 설정합니다.
Acknowledgment	이 메시지가 나타내는 승인의 분류를 가져옵니다.
AdministrationQueue	메시지 큐에서 생성하는 승인 메시지를 받는 큐를 가져오거나 설정합니다.
AppSpecific	애플리케이션별 추가 정보를 가져오거나 설정합니다.
ArrivedTime	메시지가 대상 큐에 도착한 시간을 가져옵니다.
AttachSenderId	보낸 사람 ID를 메시지에 첨부해야 하는지 여부를 나타내는 값을 가져오거나 설정합니다.
Authenticated	메시지가 인증되었는지 여부를 나타내는 값을 가져옵니다.
AuthenticationProviderName	메시지의 디지털 서명을 생성하는 데 사용되는 암호화 공급자의 이름을 가져오거나 설정합니다.
AuthenticationProviderType	메시지의 디지털 서명을 생성하는 데 사용되는 암호화 공급자의 형식을 가져오거나 설정합니다.
Body	메시지의 내용을 가져오거나 설정합니다.
BodyStream	메시지 본문의 정보를 가져오거나 설정합니다.
BodyType	메시지 본문에 포함된 데이터 형식을 가져오거나 설정합니다.
CanRaiseEvents	구성 요소가 이벤트를 발생시키는지 여부를 나타내는 값을 가져옵니다. (다음에서 상속됨 Component)
ConnectorType	메시지 큐에 의해 일반적으로 설정된 일부 메시지 속성이 보내는 애플리케이션에 의해 설정되었음을 나타내는 값을 가져오거나 설정합니다.
Container	를 IContainer 포함하는 값을 가져옵니다 Component. (다음에서 상속됨 Component)
CorrelationId	승인, 보고서 및 응답 메시지에서 원본 메시지를 참조하는 데 사용되는 메시지 식별자를 가져오거나 설정합니다.
DesignMode	현재 디자인 모드인지 여부를 Component 나타내는 값을 가져옵니다. (다음에서 상속됨 Component)
DestinationQueue	메시지의 대상 큐를 가져옵니다.
DestinationSymmetricKey	외래 큐로 전송된 애플리케이션 암호화 메시지 또는 메시지를 암호화하는 데 사용되는 대칭 키를 가져오거나 설정합니다.
DigitalSignature	메시지 큐에서 메시지를 인증하는 데 사용하는 디지털 서명을 가져오거나 설정합니다.
EncryptionAlgorithm	프라이빗 메시지의 본문을 암호화하는 데 사용되는 암호화 알고리즘을 가져오거나 설정합니다.
Events	이 Component에 연결된 이벤트 처리기 목록을 가져옵니다. (다음에서 상속됨 Component)
Extension	메시지와 연결된 추가 애플리케이션 정의 정보를 가져오거나 설정합니다.
Formatter	메시지 본문에서 개체를 직렬화하거나 개체를 역직렬화하는 데 사용되는 포맷터를 가져오거나 설정합니다.
HashAlgorithm	메시지를 인증하거나 메시지에 대한 디지털 서명을 만들 때 메시지 큐에서 사용하는 해시 알고리즘을 가져오거나 설정합니다.
Id	메시지의 식별자를 가져옵니다.
IsFirstInTransaction	메시지가 트랜잭션에서 보낸 첫 번째 메시지인지 여부를 나타내는 값을 가져옵니다.
IsLastInTransaction	메시지가 트랜잭션에서 보낸 마지막 메시지인지 여부를 나타내는 값을 가져옵니다.
Label	메시지를 설명하는 애플리케이션 정의 유니코드 문자열을 가져오거나 설정합니다.
LookupId	MSMQ 3.0에 도입되었습니다. 메시지의 조회 식별자를 가져옵니다.
MessageType	메시지 형식을 `NormalAcknowledgmentReport`가져옵니다.
Priority	큐에서 메시지가 배치되는 위치를 결정하는 메시지 우선 순위를 가져오거나 설정합니다.
Recoverable	컴퓨터 오류 또는 네트워크 문제가 발생할 경우 메시지가 배달되도록 보장되는지 여부를 나타내는 값을 가져오거나 설정합니다.
ResponseQueue	애플리케이션에서 생성된 응답 메시지를 수신하는 큐를 가져오거나 설정합니다.
SecurityContext	메시지의 보안 컨텍스트를 가져오거나 설정합니다.
SenderCertificate	메시지를 인증하는 데 사용되는 보안 인증서를 가져오거나 설정합니다.
SenderId	보내는 사용자의 식별자를 가져옵니다.
SenderVersion	메시지를 보내는 데 사용되는 메시지 큐의 버전을 가져옵니다.
SentTime	원본 큐 관리자가 메시지를 보낸 보내는 컴퓨터의 날짜와 시간을 가져옵니다.
Site	의 ISite값을 Component 가져오거나 설정합니다. (다음에서 상속됨 Component)
SourceMachine	메시지가 시작된 컴퓨터를 가져옵니다.
TimeToBeReceived	대상 큐에서 메시지를 받을 최대 시간을 가져오거나 설정합니다.
TimeToReachQueue	메시지가 큐에 도달하는 최대 시간을 가져오거나 설정합니다.
TransactionId	메시지가 일부인 트랜잭션의 식별자를 가져옵니다.
TransactionStatusQueue	원본 컴퓨터의 트랜잭션 상태 큐를 가져옵니다.
UseAuthentication	메시지를 보내기 전에 인증되었는지 여부를 나타내는 값을 가져오거나 설정합니다.
UseDeadLetterQueue	배달할 수 없는 메시지의 복사본을 배달 못 한 편지 큐로 보낼지 여부를 나타내는 값을 가져오거나 설정합니다.
UseEncryption	메시지를 비공개로 만들지 여부를 나타내는 값을 가져오거나 설정합니다.
UseJournalQueue	메시지 복사본을 원래 컴퓨터의 컴퓨터 업무 일지에 보관해야 하는지 여부를 나타내는 값을 가져오거나 설정합니다.
UseTracing	대상 큐로 이동할 때 메시지를 추적할지 여부를 나타내는 값을 가져오거나 설정합니다.

메서드

Name	Description
CreateObjRef(Type)	원격 개체와 통신하는 데 사용되는 프록시를 생성하는 데 필요한 모든 관련 정보를 포함하는 개체를 만듭니다. (다음에서 상속됨 MarshalByRefObject)
Dispose()	에서 사용하는 모든 리소스를 Component해제합니다. (다음에서 상속됨 Component)
Dispose(Boolean)	관리되지 않는 리소스를 Component 해제하고 관리되는 리소스를 선택적으로 해제합니다. (다음에서 상속됨 Component)
Equals(Object)	지정된 개체가 현재 개체와 같은지 여부를 확인합니다. (다음에서 상속됨 Object)
GetHashCode()	기본 해시 함수로 사용됩니다. (다음에서 상속됨 Object)
GetLifetimeService()	사용되지 않음. 이 인스턴스의 수명 정책을 제어하는 현재 수명 서비스 개체를 검색합니다. (다음에서 상속됨 MarshalByRefObject)
GetService(Type)	또는 해당 서비스에서 제공하는 서비스를 나타내는 개체를 Component 반환합니다 Container. (다음에서 상속됨 Component)
GetType()	현재 인스턴스의 Type 가져옵니다. (다음에서 상속됨 Object)
InitializeLifetimeService()	사용되지 않음. 이 인스턴스의 수명 정책을 제어하는 수명 서비스 개체를 가져옵니다. (다음에서 상속됨 MarshalByRefObject)
MemberwiseClone()	현재 Object단순 복사본을 만듭니다. (다음에서 상속됨 Object)
MemberwiseClone(Boolean)	현재 MarshalByRefObject 개체의 단순 복사본을 만듭니다. (다음에서 상속됨 MarshalByRefObject)
ToString()	String(있는 경우)의 Component이름을 포함하는 값을 반환합니다. 이 메서드는 재정의해서는 안 됩니다. (다음에서 상속됨 Component)

이벤트

Name	Description
Disposed	구성 요소가 메서드 호출에 Dispose() 의해 삭제될 때 발생합니다. (다음에서 상속됨 Component)

적용 대상

추가 정보

피드백

이 페이지가 도움이 되었나요?

다음을 통해 공유

Message 클래스

정의

예제

설명

생성자

필드

속성

메서드

이벤트

적용 대상

추가 정보

피드백