Message Message Message Message Class

정의

메시지 큐 메시지를 정의하는 데 필요한 속성의 액세스 권한을 제공합니다.Provides access to the properties needed to define a Message Queuing message.

public ref class Message : System::ComponentModel::Component
public class Message : System.ComponentModel.Component
type Message = class
    inherit Component
Public Class Message
Inherits Component
상속

예제

다음 코드 예제에서는 사용 하 여 메시지 본문을 서식 지정 하는 방법을 보여 줍니다 BinaryMessageFormatter합니다.The following code example demonstrates formatting a message body using BinaryMessageFormatter.

#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;

/// <summary>
/// Provides a container class for the example.
/// </summary>
ref class MyNewQueue
{
public:

   //*************************************************
   // Creates a new queue.
   //*************************************************
   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 );
      }

   }


   //*************************************************
   // Sends an image to a queue, using the BinaryMessageFormatter.
   //*************************************************
   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 = gcnew MessageQueue( ".\\myQueue" );
         Message^ myMessage = gcnew Message( myImage,gcnew BinaryMessageFormatter );
         
         // Send the image to the queue.
         myQueue->Send( myMessage );
      }
      catch ( ArgumentException^ e ) 
      {
         Console::WriteLine( e->Message );
      }

      return;
   }


   //*************************************************
   // Receives a message containing an image.
   //*************************************************
   void ReceiveMessage()
   {
      try
      {
         
         // Connect to the a queue on the local computer.
         MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );
         
         // Set the formatter to indicate body contains an Order.
         myQueue->Formatter = gcnew BinaryMessageFormatter;
         
         // Receive and format the message. 
         Message^ myMessage = myQueue->Receive();
         Bitmap^ myImage = static_cast<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;
   }

};


//*************************************************
// Provides an entry point into the application.
//         
// This example sends and receives a message from
// a queue.
//*************************************************
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
{
	

	/// <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 'MyNewQueue
End Namespace 'MyProj

다음 코드 예제에서는 사용 하 여 메시지 본문을 서식 지정 하는 방법을 보여 줍니다 XmlMessageFormatter합니다.The following code example demonstrates formatting a message body using 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 'Order

   
  
' 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 'MyNewQueue

설명

사용 하 여는 Message 클래스 보기 또는 큐에서 메시지를 수신 하거나 큐에 메시지를 보낼 때 메시지 속성에 대해 세부적으로 제어할 필요가 있습니다.Use the Message class to peek or receive messages from a queue, or to have fine control over message properties when sending a message to a queue.

MessageQueue 사용 하 여는 Message 클래스를 관찰 합니다. 또는 큐에서 메시지를 수신 하기 때문에 모두를 MessageQueue.PeekMessageQueue.Receive 메서드의 새 인스턴스를 만들고를 Message 클래스 및 인스턴스 속성을 설정 합니다.MessageQueue uses the Message class when it peeks or receives messages from queues, because both the MessageQueue.Peek and MessageQueue.Receive methods create a new instance of the Message class and set the instance's properties. Message 클래스의 읽기 전용 속성은 읽기/쓰기 속성은 전송 및 메시지를 검색에 적용 하는 동안 큐에서 메시지를 검색에 적용 합니다.The Message class's read-only properties apply to retrieving messages from a queue, while the read/write properties apply to sending and retrieving messages. MessageQueue 관찰 하거나 큐에서 메시지를 받을 해당 MessageReadPropertyFilter 속성 검색 되는 메시지의 속성을 결정 합니다.When MessageQueue peeks or receives a message from a queue, its MessageReadPropertyFilter property determines which of the message's properties are retrieved.

합니다 MessageQueue 클래스의 Send 메서드는 큐로 송신할 메시지에 대 한 모든 개체 형식을 지정할 수 있습니다.The MessageQueue class's Send method allows you to specify any object type for a message being sent to that queue. 사용할 수는 MessageQueue 인스턴스의 DefaultPropertiesToSend 큐로 전송 하는 제네릭 메시지에 대 한 설정을 지정 하는 속성입니다.You can use the MessageQueue instance's DefaultPropertiesToSend property to specify settings for generic messages sent to the queue. 설정의 형식에는 포맷터, 레이블, 암호화 및 인증 포함 됩니다.The types of settings include formatter, label, encryption, and authentication. 적절 한 값을 지정할 수도 있습니다 DefaultPropertiesToSend 승인 및 보고서 메시지에 응답 메시징 애플리케이션을 조정 하는 경우 멤버입니다.You can also specify values for the appropriate DefaultPropertiesToSend members when you coordinate your messaging application to respond to acknowledgment and report messages. Message 인스턴스를 사용 하 여 큐에 메시지를 보내면 단일 메시지나 메시지 별로 이러한 속성을 대부분 액세스 하 고 수정할 수 있습니다.Using a Message instance to send a message to the queue gives you the flexibility to access and modify many of these properties - either for a single message or on a message-by-message basis. Message 속성 보다 우선적으로 적용 DefaultPropertiesToSend합니다.Message properties take precedence over DefaultPropertiesToSend.

메시지 데이터에 저장 됩니다는 Body 속성 및 정도 덜하지만 합니다 AppSpecificExtension 속성입니다.Message data is stored in the Body property and to a lesser extent, the AppSpecific and Extension properties. 메시지 데이터 암호화, serialize 또는 deserialize의 내용만 Body 속성에 영향을 받습니다.When message data is encrypted, serialized, or deserialized, only the contents of the Body property are affected.

내용의 합니다 Body 속성은 메시지를 보낼 때 사용 하 여 serialize 되는 Formatter 지정할 속성입니다.The contents of the Body property are serialized when the message is sent, using the Formatter property you specify. Serialize 된 내용에서 발견 되는 BodyStream 속성입니다.The serialized contents are found in the BodyStream property. 설정할 수도 있습니다는 BodyStream 속성 직접 예를 들어 메시지의 데이터 콘텐츠로 파일을 보낼 수 있습니다.You can also set the BodyStream property directly, for example, to send a file as the data content of a message. 변경할 수 있습니다 합니다 BodyFormatter 메시지 및 데이터를 보내기 전에 언제 든 지 속성을 직렬화할지 적절 하 게 호출 하는 경우 Send합니다.You can change the Body or Formatter properties at any time before sending the message, and the data will be serialized appropriately when you call Send.

정의 하는 속성을 MessageQueue.DefaultPropertiesToSend 형식이 아닌 메시지에 대해서만 속성이 적용 Message합니다.The properties defined by the MessageQueue.DefaultPropertiesToSend property apply only to messages that are not of type Message. 지정 하는 경우는 DefaultPropertiesToSend 에 대 한 속성을 MessageQueue, 동일한 이름의 속성으로는 Message 인스턴스가 전송 큐를 야기 하는 이러한 기본 속성이 무시 됩니다.If you specify the DefaultPropertiesToSend property for a MessageQueue, the identically named properties in a Message instance sent to that queue cause these default properties to be ignored.

인스턴스의 초기 속성 값의 목록을 Message, 참조는 Message 생성자입니다.For a list of initial property values for an instance of Message, see the Message constructor.

생성자

Message() Message() Message() Message()

본문이 비어 있는 Message 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the Message class with an empty body.

Message(Object) Message(Object) Message(Object) Message(Object)

MessageXmlMessageFormatter 클래스의 새 인스턴스를 초기화하여 지정한 개체를 메시지 본문으로 serialize합니다.Initializes a new instance of the Message class, using the XmlMessageFormatter to serialize the specified object into the body of the message.

Message(Object, IMessageFormatter) Message(Object, IMessageFormatter) Message(Object, IMessageFormatter) Message(Object, IMessageFormatter)

지정한 포맷터로 Message 클래스의 새 인스턴스를 초기화하여 지정한 개체를 메시지 본문으로 serialize합니다.Initializes a new instance of the Message class using the specified formatter to serialize the specified object into the body of the message.

필드

InfiniteTimeout InfiniteTimeout InfiniteTimeout InfiniteTimeout

제한 시간이 없도록 지정합니다.Specifies that no time-out exists.

속성

AcknowledgeType AcknowledgeType AcknowledgeType AcknowledgeType

보내는 애플리케이션으로 반환되는 승인 메시지의 형식을 가져오거나 설정합니다.Gets or sets the type of acknowledgment message to be returned to the sending application.

Acknowledgment Acknowledgment Acknowledgment Acknowledgment

이 메시지가 나타내는 승인의 분류를 가져옵니다.Gets the classification of acknowledgment that this message represents.

AdministrationQueue AdministrationQueue AdministrationQueue AdministrationQueue

메시지 큐에서 생성한 승인 메시지를 받는 큐를 가져오거나 설정합니다.Gets or sets the queue that receives the acknowledgement messages that Message Queuing generates.

AppSpecific AppSpecific AppSpecific AppSpecific

애플리케이션 관련 추가 정보를 가져오거나 설정합니다.Gets or sets additional, application-specific information.

ArrivedTime ArrivedTime ArrivedTime ArrivedTime

메시지가 대상 큐에 도착한 시간을 가져옵니다.Gets the time that the message arrived in the destination queue.

AttachSenderId AttachSenderId AttachSenderId AttachSenderId

보낸 사람 ID를 메시지에 첨부할지 여부를 나타내는 값을 가져오거나 설정합니다.Gets or sets a value that indicates whether the sender ID should be attached to the message.

Authenticated Authenticated Authenticated Authenticated

메시지가 인증되었는지 여부를 나타내는 값을 가져옵니다.Gets a value that indicates whether the message was authenticated.

AuthenticationProviderName AuthenticationProviderName AuthenticationProviderName AuthenticationProviderName

메시지의 디지털 서명을 생성하는 데 사용되는 암호화 공급자의 이름을 가져오거나 설정합니다.Gets or sets the name of the cryptographic provider used to generate the digital signature of the message.

AuthenticationProviderType AuthenticationProviderType AuthenticationProviderType AuthenticationProviderType

메시지의 디지털 서명을 생성하는 데 사용되는 암호화 공급자의 형식을 가져오거나 설정합니다.Gets or sets the type of cryptographic provider used to generate the digital signature of the message.

Body Body Body Body

메시지의 내용을 가져오거나 설정합니다.Gets or sets the content of the message.

BodyStream BodyStream BodyStream BodyStream

메시지 본문의 정보를 가져오거나 설정합니다.Gets or sets the information in the body of the message.

BodyType BodyType BodyType BodyType

메시지 본문에 포함되는 데이터 형식을 가져오거나 설정합니다.Gets or sets the type of data that the message body contains.

CanRaiseEvents CanRaiseEvents CanRaiseEvents CanRaiseEvents

구성 요소가 이벤트를 발생시킬 수 있는지 여부를 나타내는 값을 가져옵니다.Gets a value indicating whether the component can raise an event.

(Inherited from Component)
ConnectorType ConnectorType ConnectorType ConnectorType

일반적으로 메시지 큐에서 설정된 일부 메시지 속성이 보내는 애플리케이션에서 설정되었음을 나타내는 값을 가져오거나 설정합니다.Gets or sets a value that indicates that some message properties typically set by Message Queuing were set by the sending application.

Container Container Container Container

IContainer가 포함된 Component를 가져옵니다.Gets the IContainer that contains the Component.

(Inherited from Component)
CorrelationId CorrelationId CorrelationId CorrelationId

원본 메시지를 참조하기 위해 승인, 보고 및 응답 메시지에서 사용하는 메시지 식별자를 가져오거나 설정합니다.Gets or sets the message identifier used by acknowledgment, report, and response messages to reference the original message.

DesignMode DesignMode DesignMode DesignMode

Component가 현재 디자인 모드인지 여부를 나타내는 값을 가져옵니다.Gets a value that indicates whether the Component is currently in design mode.

(Inherited from Component)
DestinationQueue DestinationQueue DestinationQueue DestinationQueue

메시지의 계획된 대상 큐를 가져옵니다.Gets the intended destination queue for a message.

DestinationSymmetricKey DestinationSymmetricKey DestinationSymmetricKey DestinationSymmetricKey

애플리케이션에서 암호화된 메시지를 외부 큐로 보낸 경우 해당 메시지를 암호화하는 데 사용하는 대칭 키를 가져오거나 설정합니다.Gets or sets the symmetric key used to encrypt application-encrypted messages or messages sent to foreign queues.

DigitalSignature DigitalSignature DigitalSignature DigitalSignature

메시지 큐에서 메시지를 인증하는 데 사용되는 디지털 서명을 가져오거나 설정합니다.Gets or sets the digital signature that Message Queuing uses to authenticate the message.

EncryptionAlgorithm EncryptionAlgorithm EncryptionAlgorithm EncryptionAlgorithm

프라이빗 메시지의 본문을 암호화하는 데 사용되는 암호화 알고리즘을 가져오거나 설정합니다.Gets or sets the encryption algorithm used to encrypt the body of a private message.

Events Events Events Events

Component에 연결된 이벤트 처리기의 목록을 가져옵니다.Gets the list of event handlers that are attached to this Component.

(Inherited from Component)
Extension Extension Extension Extension

메시지에 연결된 애플리케이션 정의 추가 정보를 가져오거나 설정합니다.Gets or sets additional, application-defined information associated with the message.

Formatter Formatter Formatter Formatter

개체를 메시지 본문으로 serialize하거나 메시지 본문에서 deserialize하는 데 사용되는 포맷터를 가져오거나 설정합니다.Gets or sets the formatter used to serialize an object into or deserialize an object from the message body.

HashAlgorithm HashAlgorithm HashAlgorithm HashAlgorithm

메시지를 인증하거나 메시지에 대해 디지털 서명을 만들 때 메시지 큐에서 사용하는 해시 알고리즘을 가져오거나 설정합니다.Gets or sets the hashing algorithm that Message Queuing uses when authenticating a message or creating a digital signature for a message.

Id Id Id Id

메시지의 식별자를 가져옵니다.Gets the message's identifier.

IsFirstInTransaction IsFirstInTransaction IsFirstInTransaction IsFirstInTransaction

메시지가 트랜잭션에서 보낸 첫 번째 메시지인지 여부를 나타내는 값을 가져옵니다.Gets a value that indicates whether the message was the first message sent in a transaction.

IsLastInTransaction IsLastInTransaction IsLastInTransaction IsLastInTransaction

메시지가 트랜잭션에서 보낸 마지막 메시지인지 여부를 나타내는 값을 가져옵니다.Gets a value that indicates whether the message was the last message sent in a transaction.

Label Label Label Label

메시지를 설명하는 애플리케이션 정의 유니코드 문자열을 가져오거나 설정합니다.Gets or sets an application-defined Unicode string that describes the message.

LookupId LookupId LookupId LookupId

MSMQ 3.0에서 도입되었습니다.Introduced in MSMQ 3.0. 메시지의 조회 식별자를 가져옵니다.Gets the message's lookup identifier.

MessageType MessageType MessageType MessageType

메시지 형식(Normal, Acknowledgment 또는 Report)를 가져옵니다.Gets the message type: Normal, Acknowledgment, or Report.

Priority Priority Priority Priority

메시지를 큐에 배치하는 위치를 결정하는 메시지 우선 순위를 가져오거나 설정합니다.Gets or sets the message priority, which determines where in the queue the message is placed.

Recoverable Recoverable Recoverable Recoverable

시스템 장애 또는 네트워크 문제가 있는 경우 메시지를 보낼지 여부를 나타내는 값을 가져오거나 설정합니다.Gets or sets a value that indicates whether the message is guaranteed to be delivered in the event of a computer failure or network problem.

ResponseQueue ResponseQueue ResponseQueue ResponseQueue

애플리케이션에서 생성한 응답 메시지를 받는 큐를 가져오거나 설정합니다.Gets or sets the queue that receives application-generated response messages.

SecurityContext SecurityContext SecurityContext SecurityContext

메시지에 대한 보안 컨텍스트를 가져오거나 설정합니다.Gets or sets the security context for a message.

SenderCertificate SenderCertificate SenderCertificate SenderCertificate

메시지를 인증하는 데 사용되는 보안 인증서를 가져오거나 설정합니다.Gets or sets the security certificate used to authenticate messages.

SenderId SenderId SenderId SenderId

보내는 사용자의 식별자를 가져옵니다.Gets the identifier of the sending user.

SenderVersion SenderVersion SenderVersion SenderVersion

메시지를 보내는데 사용되는 메시지 큐 버전을 가져옵니다.Gets the version of Message Queuing used to send the message.

SentTime SentTime SentTime SentTime

보내는 컴퓨터의 소스 큐 관리자가 메시지를 보낸 날짜 및 시간을 가져옵니다.Gets the date and time on the sending computer that the message was sent by the source queue manager.

Site Site Site Site

ComponentISite를 가져오거나 설정합니다.Gets or sets the ISite of the Component.

(Inherited from Component)
SourceMachine SourceMachine SourceMachine SourceMachine

메시지를 처음 생성한 컴퓨터를 가져옵니다.Gets the computer from which the message originated.

TimeToBeReceived TimeToBeReceived TimeToBeReceived TimeToBeReceived

대상 큐에서 메시지를 받는 데 필요한 최대 시간을 가져오거나 설정합니다.Gets or sets the maximum amount of time for the message to be received from the destination queue.

TimeToReachQueue TimeToReachQueue TimeToReachQueue TimeToReachQueue

메시지가 큐에 도달하기까지의 최대 시간을 가져오거나 설정합니다.Gets or sets the maximum amount of time for the message to reach the queue.

TransactionId TransactionId TransactionId TransactionId

메시지가 일부인 트랜잭션의 식별자를 가져옵니다.Gets the identifier for the transaction of which the message was a part.

TransactionStatusQueue TransactionStatusQueue TransactionStatusQueue TransactionStatusQueue

소스 컴퓨터의 트랜잭션 상태 큐를 가져옵니다.Gets the transaction status queue on the source computer.

UseAuthentication UseAuthentication UseAuthentication UseAuthentication

메시지를 보내기 전에 인증해야 하는지 여부를 나타내는 값을 가져오거나 설정합니다.Gets or sets a value that indicates whether the message was (or must be) authenticated before being sent.

UseDeadLetterQueue UseDeadLetterQueue UseDeadLetterQueue UseDeadLetterQueue

배달되지 않은 메시지의 복사본을 배달 못 한 큐로 보낼지 여부를 나타내는 값을 가져오거나 설정합니다.Gets or sets a value that indicates whether a copy of the message that could not be delivered should be sent to a dead-letter queue.

UseEncryption UseEncryption UseEncryption UseEncryption

개인 메시지를 만들지 여부를 나타내는 값을 가져오거나 설정합니다.Gets or sets a value that indicates whether to make the message private.

UseJournalQueue UseJournalQueue UseJournalQueue UseJournalQueue

메시지의 복사본을 원래 컴퓨터의 컴퓨터 업무 일지에 보관할지 여부를 나타내는 값을 가져오거나 설정합니다.Gets or sets a value that indicates whether a copy of the message should be kept in a machine journal on the originating computer.

UseTracing UseTracing UseTracing UseTracing

메시지가 대상 큐로 이동할 때 해당 메시지를 추적할지 여부를 나타내는 값을 가져오거나 설정합니다.Gets or sets a value that indicates whether to trace a message as it moves toward its destination queue.

메서드

CreateObjRef(Type) CreateObjRef(Type) CreateObjRef(Type) CreateObjRef(Type)

원격 개체와 통신하는 데 사용되는 프록시 생성에 필요한 모든 관련 정보가 들어 있는 개체를 만듭니다.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Inherited from MarshalByRefObject)
Dispose() Dispose() Dispose() Dispose()

Component에서 사용하는 모든 리소스를 해제합니다.Releases all resources used by the Component.

(Inherited from Component)
Dispose(Boolean) Dispose(Boolean) Dispose(Boolean) Dispose(Boolean)

Component에서 사용하는 관리되지 않는 리소스를 해제하고, 관리되는 리소스를 선택적으로 해제할 수 있습니다.Releases the unmanaged resources used by the Component and optionally releases the managed resources.

(Inherited from Component)
Equals(Object) Equals(Object) Equals(Object) Equals(Object)

지정한 개체와 현재 개체가 같은지 여부를 확인합니다.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

기본 해시 함수로 작동합니다.Serves as the default hash function.

(Inherited from Object)
GetLifetimeService() GetLifetimeService() GetLifetimeService() GetLifetimeService()

이 인스턴스의 수명 정책을 제어하는 현재의 수명 서비스 개체를 검색합니다.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Inherited from MarshalByRefObject)
GetService(Type) GetService(Type) GetService(Type) GetService(Type)

Component 또는 해당 Container에서 제공하는 서비스를 나타내는 개체를 반환합니다.Returns an object that represents a service provided by the Component or by its Container.

(Inherited from Component)
GetType() GetType() GetType() GetType()

현재 인스턴스의 Type을 가져옵니다.Gets the Type of the current instance.

(Inherited from Object)
InitializeLifetimeService() InitializeLifetimeService() InitializeLifetimeService() InitializeLifetimeService()

이 인스턴스의 수명 정책을 제어하는 수명 서비스 개체를 가져옵니다.Obtains a lifetime service object to control the lifetime policy for this instance.

(Inherited from MarshalByRefObject)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

현재 Object의 단순 복사본을 만듭니다.Creates a shallow copy of the current Object.

(Inherited from Object)
MemberwiseClone(Boolean) MemberwiseClone(Boolean) MemberwiseClone(Boolean) MemberwiseClone(Boolean)

현재 MarshalByRefObject 개체의 단순 복사본을 만듭니다.Creates a shallow copy of the current MarshalByRefObject object.

(Inherited from MarshalByRefObject)
ToString() ToString() ToString() ToString()

Component의 이름이 포함된 String을 반환합니다(있는 경우).Returns a String containing the name of the Component, if any. 이 메서드는 재정의할 수 없습니다.This method should not be overridden.

(Inherited from Component)

이벤트

Disposed Disposed Disposed Disposed

Dispose() 메서드를 호출하여 구성 요소가 삭제되는 경우 발생합니다.Occurs when the component is disposed by a call to the Dispose() method.

(Inherited from Component)

적용 대상

추가 정보