MessageQueue 클래스

정의

네임스페이스:

System.Messaging

어셈블리:

System.Messaging.dll

메시지 큐 서버에 있는 큐에 대한 액세스를 제공합니다.

public ref class MessageQueue : System::ComponentModel::Component, System::Collections::IEnumerable

[System.ComponentModel.TypeConverter(typeof(System.Messaging.Design.MessageQueueConverter))]
[System.Messaging.MessagingDescription("MessageQueueDesc")]
public class MessageQueue : System.ComponentModel.Component, System.Collections.IEnumerable

[<System.ComponentModel.TypeConverter(typeof(System.Messaging.Design.MessageQueueConverter))>]
[<System.Messaging.MessagingDescription("MessageQueueDesc")>]
type MessageQueue = class
    inherit Component
    interface IEnumerable

Public Class MessageQueue
Inherits Component
Implements IEnumerable

상속

Object

MarshalByRefObject

Component

MessageQueue

특성

TypeConverterAttribute MessagingDescriptionAttribute

구현

IEnumerable

예제

다음 코드 예제에서는 다양한 경로 이름 구문 형식을 사용하여 새 MessageQueue 개체를 만듭니다. 각 경우에서 경로가 생성자에 정의된 큐에 메시지를 보냅니다.

#using <system.dll>
#using <system.messaging.dll>

using namespace System;
using namespace System::Messaging;
ref class MyNewQueue
{
public:

   // References public queues.
   void SendPublic()
   {
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );
      myQueue->Send( "Public queue by path name." );
      return;
   }


   // References private queues.
   void SendPrivate()
   {
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\Private$\\myQueue" );
      myQueue->Send( "Private queue by path name." );
      return;
   }


   // References queues by label.
   void SendByLabel()
   {
      MessageQueue^ myQueue = gcnew MessageQueue( "Label:TheLabel" );
      myQueue->Send( "Queue by label." );
      return;
   }


   // References queues by format name.
   void SendByFormatName()
   {
      MessageQueue^ myQueue = gcnew MessageQueue( "FormatName:Public=5A5F7535-AE9A-41d4 -935C-845C2AFF7112" );
      myQueue->Send( "Queue by format name." );
      return;
   }


   // References computer journal queues.
   void MonitorComputerJournal()
   {
      MessageQueue^ computerJournal = gcnew MessageQueue( ".\\Journal$" );
      while ( true )
      {
         Message^ journalMessage = computerJournal->Receive();
         
         // Process the journal message.
      }
   }


   // References queue journal queues.
   void MonitorQueueJournal()
   {
      MessageQueue^ queueJournal = gcnew MessageQueue( ".\\myQueue\\Journal$" );
      while ( true )
      {
         Message^ journalMessage = queueJournal->Receive();
         
         // Process the journal message.
      }
   }


   // References dead-letter queues.
   void MonitorDeadLetter()
   {
      MessageQueue^ deadLetter = gcnew MessageQueue( ".\\DeadLetter$" );
      while ( true )
      {
         Message^ deadMessage = deadLetter->Receive();
         
         // Process the dead-letter message.
      }
   }


   // References transactional dead-letter queues.
   void MonitorTransactionalDeadLetter()
   {
      MessageQueue^ TxDeadLetter = gcnew MessageQueue( ".\\XactDeadLetter$" );
      while ( true )
      {
         Message^ txDeadLetter = TxDeadLetter->Receive();
         
         // Process the transactional dead-letter message.
      }
   }

};


//*************************************************
// Provides an entry point into the application.
//         
// This example demonstrates several ways to set
// a queue's path.
//*************************************************
int main()
{
   
   // Create a new instance of the class.
   MyNewQueue^ myNewQueue = gcnew MyNewQueue;
   myNewQueue->SendPublic();
   myNewQueue->SendPrivate();
   myNewQueue->SendByLabel();
   myNewQueue->SendByFormatName();
   myNewQueue->MonitorComputerJournal();
   myNewQueue->MonitorQueueJournal();
   myNewQueue->MonitorDeadLetter();
   myNewQueue->MonitorTransactionalDeadLetter();
   return 0;
}

using System;
using System.Messaging;

namespace MyProject
{
    /// <summary>
    /// Provides a container class for the example.
    /// </summary>
    public class MyNewQueue
    {

        //**************************************************
        // Provides an entry point into the application.
        //		
        // This example demonstrates several ways to set
        // a queue's path.
        //**************************************************

        public static void Main()
        {
            // Create a new instance of the class.
            MyNewQueue myNewQueue = new MyNewQueue();

            myNewQueue.SendPublic();
            myNewQueue.SendPrivate();
            myNewQueue.SendByLabel();
            myNewQueue.SendByFormatName();
            myNewQueue.MonitorComputerJournal();
            myNewQueue.MonitorQueueJournal();
            myNewQueue.MonitorDeadLetter();
            myNewQueue.MonitorTransactionalDeadLetter();

            return;
        }
        
        // References public queues.
        public void SendPublic()
        {
            MessageQueue myQueue = new MessageQueue(".\\myQueue");
            myQueue.Send("Public queue by path name.");

            return;
        }

        // References private queues.
        public void SendPrivate()
        {
            MessageQueue myQueue = new
                MessageQueue(".\\Private$\\myQueue");
            myQueue.Send("Private queue by path name.");

            return;
        }

        // References queues by label.
        public void SendByLabel()
        {
            MessageQueue myQueue = new MessageQueue("Label:TheLabel");
            myQueue.Send("Queue by label.");

            return;
        }

        // References queues by format name.
        public void SendByFormatName()
        {
            MessageQueue myQueue = new
                MessageQueue("FormatName:Public=5A5F7535-AE9A-41d4" +
                "-935C-845C2AFF7112");
            myQueue.Send("Queue by format name.");

            return;
        }

        // References computer journal queues.
        public void MonitorComputerJournal()
        {
            MessageQueue computerJournal = new
                MessageQueue(".\\Journal$");
            while(true)
            {
                Message journalMessage = computerJournal.Receive();
                // Process the journal message.
            }
        }

        // References queue journal queues.
        public void MonitorQueueJournal()
        {
            MessageQueue queueJournal = new
                MessageQueue(".\\myQueue\\Journal$");
            while(true)
            {
                Message journalMessage = queueJournal.Receive();
                // Process the journal message.
            }
        }
        
        // References dead-letter queues.
        public void MonitorDeadLetter()
        {
            MessageQueue deadLetter = new
                MessageQueue(".\\DeadLetter$");
            while(true)
            {
                Message deadMessage = deadLetter.Receive();
                // Process the dead-letter message.
            }
        }

        // References transactional dead-letter queues.
        public void MonitorTransactionalDeadLetter()
        {
            MessageQueue TxDeadLetter = new
                MessageQueue(".\\XactDeadLetter$");
            while(true)
            {
                Message txDeadLetter = TxDeadLetter.Receive();
                // Process the transactional dead-letter message.
            }
        }
    }
}

Imports System.Messaging

Public Class MyNewQueue


        
        ' Provides an entry point into the application.
        '		 
        ' This example demonstrates several ways to set
        ' a queue's path.
        

        Public Shared Sub Main()

            ' Create a new instance of the class.
            Dim myNewQueue As New MyNewQueue()

            myNewQueue.SendPublic()
            myNewQueue.SendPrivate()
            myNewQueue.SendByLabel()
            myNewQueue.SendByFormatName()
            myNewQueue.MonitorComputerJournal()
            myNewQueue.MonitorQueueJournal()
            myNewQueue.MonitorDeadLetter()
            myNewQueue.MonitorTransactionalDeadLetter()

            Return

        End Sub


        ' References public queues.
        Public Sub SendPublic()

            Dim myQueue As New MessageQueue(".\myQueue")
            myQueue.Send("Public queue by path name.")

            Return

        End Sub


        ' References private queues.
        Public Sub SendPrivate()

            Dim myQueue As New MessageQueue(".\Private$\myQueue")
            myQueue.Send("Private queue by path name.")

            Return

        End Sub


        ' References queues by label.
        Public Sub SendByLabel()

            Dim myQueue As New MessageQueue("Label:TheLabel")
            myQueue.Send("Queue by label.")

            Return

        End Sub


        ' References queues by format name.
        Public Sub SendByFormatName()

            Dim myQueue As New _
                MessageQueue("FormatName:Public=" + _
                    "5A5F7535-AE9A-41d4-935C-845C2AFF7112")
            myQueue.Send("Queue by format name.")

            Return

        End Sub


        ' References computer journal queues.
        Public Sub MonitorComputerJournal()

            Dim computerJournal As New MessageQueue(".\Journal$")

            While True

                Dim journalMessage As Message = _
                    computerJournal.Receive()

                ' Process the journal message.

            End While

            Return
        End Sub


        ' References queue journal queues.
        Public Sub MonitorQueueJournal()

            Dim queueJournal As New _
                            MessageQueue(".\myQueue\Journal$")

            While True

                Dim journalMessage As Message = _
                    queueJournal.Receive()

                ' Process the journal message.

            End While

            Return
        End Sub


        ' References dead-letter queues.
        Public Sub MonitorDeadLetter()
            Dim deadLetter As New MessageQueue(".\DeadLetter$")

            While True

                Dim deadMessage As Message = deadLetter.Receive()

                ' Process the dead-letter message.

            End While

            Return

        End Sub


        ' References transactional dead-letter queues.
        Public Sub MonitorTransactionalDeadLetter()

            Dim TxDeadLetter As New MessageQueue(".\XactDeadLetter$")

            While True

                Dim txDeadLetterMessage As Message = _
                    TxDeadLetter.Receive()

                ' Process the transactional dead-letter message.

            End While

            Return

        End Sub

End Class

다음 코드 예제에서는 큐에 메시지를 보내고 라고 하는 애플리케이션 관련 클래스를 사용 하 여 큐에서 메시지를 받을 Order합니다.

#using <system.dll>
#using <system.messaging.dll>

using namespace System;
using namespace System::Messaging;

// This class represents an object the following example 
// sends to a queue and receives from a queue.
ref class Order
{
public:
   int orderId;
   DateTime orderTime;
};


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

   //*************************************************
   // Sends an Order to a queue.
   //*************************************************
   void SendMessage()
   {
      // 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" );

      // Send the Order to the queue.
      myQueue->Send( sentOrder );
      return;
   }

   //*************************************************
   // Receives a message containing an Order.
   //*************************************************
   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 = static_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;
   }
};

//*************************************************
// 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;

   // Send a message to a queue.
   myNewQueue->SendMessage();

   // Receive a message from a queue.
   myNewQueue->ReceiveMessage();
   return 0;
}

using System;
using System.Messaging;

namespace MyProject
{

    // This class represents an object 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();

            // Send a message to a queue.
            myNewQueue.SendMessage();

            // Receive a message from a queue.
            myNewQueue.ReceiveMessage();

            return;
        }

        //**************************************************
        // Sends an Order to a queue.
        //**************************************************
        
        public void SendMessage()
        {
            
            // 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");

            // Send the Order to the queue.
            myQueue.Send(sentOrder);

            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

    ' This class represents an object 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


   
    Public Class MyNewQueue


        '
        ' Provides an entry point into the application.
        '		 
        ' This example sends and receives a message from
        ' a qeue.
        '

        Public Shared Sub Main()

            ' Create a new instance of the class.
            Dim myNewQueue As New MyNewQueue()

            ' Send a message to a queue.
            myNewQueue.SendMessage()

            ' Receive a message from a queue.
            myNewQueue.ReceiveMessage()

            Return

        End Sub


        '
        ' Sends an Order to a queue.
        '

        Public Sub SendMessage()

            ' 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")

            ' Send the Order to the queue.
            myQueue.Send(sentOrder)

            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 the 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()))

            Catch m As MessageQueueException
                ' Handle Message Queuing exceptions.

            Catch e As InvalidOperationException
                ' Handle invalid serialization format.
                Console.WriteLine(e.Message)


                ' Catch other exceptions as necessary.

            End Try

            Return

        End Sub

End Class

설명

메시지 큐 기술을 실행 중인 애플리케이션을 서로 다른 시간에 유형이 다른 네트워크와 일시적으로 오프 라인 상태일 수 있는 시스템 간에 통신할 수 있습니다. 애플리케이션 송신, 수신 또는 피킹 큐에서 메시지 (제거 하지 않고 읽기). 메시지 큐는 Windows 2000 및 Windows NT의 선택적 구성 요소이며 별도로 설치해야 합니다.

클래스는 MessageQueue 메시지 큐에 대한 래퍼입니다. 메시지 큐에는 여러 버전이 있으며 클래스를 MessageQueue 사용하면 사용 중인 운영 체제에 따라 약간 다른 동작이 발생할 수 있습니다.

클래스는 MessageQueue 메시지 큐 큐에 대한 참조를 제공합니다. 기존 리소스에 MessageQueue 연결할 경로를 생성자에 지정하거나 서버에 새 큐를 만들 수 있습니다. , 또는 Receive를 Peek호출Send(Object)하려면 먼저 클래스의 MessageQueue 새 instance 기존 큐와 연결해야 합니다. 이 시점에서 및 Label와 같은 Category 큐 속성을 조작할 수 있습니다.

MessageQueue 는 동기 및 비동기라는 두 가지 유형의 메시지 검색을 지원합니다. 동기 메서드 Peek 및 Receive을 사용하면 프로세스 스레드가 지정된 시간 간격을 대기하여 새 메시지가 큐에 도착할 때까지 기다립니다. 비동기 메서드는 BeginPeek 고 BeginReceive, 기본 애플리케이션 작업을 큐에 메시지가 도착할 때까지 별도 스레드에서 계속 허용 합니다. 이러한 메서드는 콜백 개체와 상태 개체를 사용하여 스레드 간에 정보를 전달하는 방식으로 작동합니다.

클래스의 MessageQueue 새 instance 만들 때 새 메시지 큐 큐를 만들지 않습니다. 대신 , Delete(String)및 Purge 메서드를 Create(String)사용하여 서버의 큐를 관리할 수 있습니다.

와 달리 Purge및 Delete(String)Create(String) 는 static 멤버이므로 클래스의 MessageQueue 새 instance 만들지 않고 호출할 수 있습니다.

개체의 Path 속성을 이름, 이름, FormatName또는 Label의 세 가지 이름 중 하나로 설정할 MessageQueue 수 있습니다. 큐 및 속성으로 정의된 식별 이름은 공용 큐 MachineName 및\\QueueNameMachineNamePrivate$프라이빗 큐에 대한 이름입니다.MachineName\QueueNameQueueName 속성은 FormatName 메시지 큐에 대한 오프라인 액세스를 허용합니다. 마지막으로 큐의 Label 속성을 사용하여 큐의 를 Path설정할 수 있습니다.

인스턴스의 초기 속성 값의 목록을 MessageQueue, 참조는 MessageQueue 생성자입니다.

생성자

MessageQueue()	MessageQueue 클래스의 새 인스턴스를 초기화합니다. 매개 변수가 없는 생성자가 새 인스턴스를 초기화하면, 이 인스턴스를 사용하기 전에 인스턴스의 Path 속성을 설정해야 합니다.
MessageQueue(String)	지정된 경로에 있는 메시지 큐를 참조하는 MessageQueue 클래스의 새 인스턴스를 초기화합니다.
MessageQueue(String, Boolean)	지정된 경로에 위치하고 읽기 액세스 제한이 설정된 메시지 큐를 참조하는 MessageQueue 클래스의 새 인스턴스를 초기화합니다.
MessageQueue(String, Boolean, Boolean)	MessageQueue 클래스의 새 인스턴스를 초기화합니다.
MessageQueue(String, Boolean, Boolean, QueueAccessMode)	MessageQueue 클래스의 새 인스턴스를 초기화합니다.
MessageQueue(String, QueueAccessMode)	MessageQueue 클래스의 새 인스턴스를 초기화합니다.

필드

InfiniteQueueSize	큐에 크기 제한이 없도록 지정합니다.
InfiniteTimeout	메시지를 피킹하거나 받는 메서드에 시간 제한이 없도록 지정합니다.

속성

AccessMode	큐의 액세스 모드를 나타내는 값을 가져옵니다.
Authenticate	큐가 인증된 메시지만 허용하는지 여부를 나타내는 값을 가져오거나 설정합니다.
BasePriority	네트워크에서 공개 큐의 메시지를 라우팅하는 데 사용하는 기본 우선 순위 메시지 큐를 가져오거나 설정합니다.
CanRaiseEvents	구성 요소가 이벤트를 발생시킬 수 있는지 여부를 나타내는 값을 가져옵니다. (다음에서 상속됨 Component)
CanRead	MessageQueue를 읽을 수 있는지 여부를 나타내는 값을 가져옵니다.
CanWrite	MessageQueue에 쓸 수 있는지 여부를 나타내는 값을 가져옵니다.
Category	큐 범주를 가져오거나 설정합니다.
Container	IContainer을 포함하는 Component를 가져옵니다. (다음에서 상속됨 Component)
CreateTime	메시지 큐에서 큐가 만들어진 날짜와 시간을 가져옵니다.
DefaultPropertiesToSend	애플리케이션이 큐에 메시지를 보낼 때 기본적으로 사용되는 메시지 속성 값을 가져오거나 설정합니다.
DenySharedReceive	이 MessageQueue가 메시지 큐에서 메시지를 받기 위한 단독 액세스 권한을 갖는지 여부를 나타내는 값을 가져오거나 설정합니다.
DesignMode	Component가 현재 디자인 모드인지 여부를 나타내는 값을 가져옵니다. (다음에서 상속됨 Component)
EnableConnectionCache	연결 캐시가 애플리케이션에 의해 유지 관리될지 여부를 나타내는 값을 가져오거나 설정합니다.
EncryptionRequired	큐에서 프라이빗하지 않은(암호화되지 않은) 메시지만 허용하는지 여부를 나타내는 값을 가져오거나 설정합니다.
Events	이 Component에 연결된 이벤트 처리기의 목록을 가져옵니다. (다음에서 상속됨 Component)
FormatName	큐를 작성할 때 메시지 큐가 발생시킨 고유한 큐 이름을 가져옵니다.
Formatter	큐에서 읽거나 쓴 메시지 본문으로 개체를 직렬화하거나 그 메시지 본문에서 개체를 역직렬화하는 데 사용되는 포맷터를 가져오거나 설정합니다.
Id	큐의 고유한 메시지 큐 식별자를 가져옵니다.
Label	큐 설명을 가져오거나 설정합니다.
LastModifyTime	큐의 속성이 마지막으로 수정된 시간을 가져옵니다.
MachineName	메시지 큐가 있는 컴퓨터의 이름을 가져오거나 설정합니다.
MaximumJournalSize	업무 일지 큐의 최대 크기를 가져오거나 설정합니다.
MaximumQueueSize	큐의 최대 크기를 가져오거나 설정합니다.
MessageReadPropertyFilter	메시지를 받거나 또는 피킹하는 데 필요한 속성 필터를 가져오거나 설정합니다.
MulticastAddress	MSMQ 3.0에서 도입되었습니다. 큐에 연결된 멀티캐스트 주소를 가져오거나 설정합니다.
Path	큐의 경로를 가져오거나 설정합니다. Path를 설정하면 MessageQueue가 새 큐를 가리킵니다.
QueueName	큐를 식별하는 이름을 가져오거나 설정합니다.
ReadHandle	메시지 큐에서 메시지를 읽는 데 사용되는 기본 핸들을 가져옵니다.
Site	Component의 ISite를 가져오거나 설정합니다. (다음에서 상속됨 Component)
SynchronizingObject	ReceiveCompleted 또는 PeekCompleted 이벤트의 결과로 생성된 이벤트 처리기의 호출을 마샬링하는 개체를 가져오거나 설정합니다.
Transactional	큐가 트랜잭션만 허용하는지 여부를 나타내는 값을 가져옵니다.
UseJournalQueue	받은 메시지가 업무 일지 큐로 복사되는지 여부를 나타내는 값을 가져오거나 설정합니다.
WriteHandle	메시지 큐에 메시지를 보내는 데 사용되는 기본 핸들을 가져옵니다.

메서드

BeginPeek()	시간 제한이 없는 비동기 피킹(peeking) 작업을 시작합니다. 큐에서 메시지를 사용할 수 있을 때까지 작업이 완료되지 않습니다.
BeginPeek(TimeSpan)	지정된 시간 제한이 있는 비동기 피킹(peeking) 작업을 시작합니다. 큐에서 메시지를 사용할 수 있거나 시간이 초과될 때까지 작업이 완료되지 않습니다.
BeginPeek(TimeSpan, Cursor, PeekAction, Object, AsyncCallback)	지정된 제한 시간이 있고 지정된 커서, 지정된 피킹(peeking) 작업 및 지정된 상태 개체를 사용하는 비동기 피킹(peeking) 작업을 초기화합니다. 상태 개체는 전체 작업 기간 동안 관련 정보를 제공합니다. 이 오버로드는 콜백을 통해 해당 작업의 이벤트 처리기 ID에 대한 알림을 수신합니다. 큐에서 메시지를 사용할 수 있거나 시간 초과가 발생할 때까지 작업이 완료되지 않습니다.
BeginPeek(TimeSpan, Object)	시간 제한 및 상태 개체가 지정되어 있는 비동기 피킹(peeking) 작업을 시작합니다. 이는 작업의 수명이 지속되는 동안 관련된 정보를 제공합니다. 큐에서 메시지를 사용할 수 있거나 시간 초과가 발생할 때까지 작업이 완료되지 않습니다.
BeginPeek(TimeSpan, Object, AsyncCallback)	시간 제한 및 상태 개체가 지정되어 있는 비동기 피킹(peeking) 작업을 시작합니다. 이는 작업의 수명이 지속되는 동안 관련된 정보를 제공합니다. 이 오버로드는 콜백을 통해 해당 작업의 이벤트 처리기 ID에 대한 알림을 수신합니다. 큐에서 메시지를 사용할 수 있거나 시간 초과가 발생할 때까지 작업이 완료되지 않습니다.
BeginReceive()	시간 제한이 없는 비동기 수신 작업을 시작합니다. 큐에서 메시지를 사용할 수 있을 때까지 작업이 완료되지 않습니다.
BeginReceive(TimeSpan)	지정된 시간 제한이 있는 비동기 수신 작업을 시작합니다. 큐에서 메시지를 사용할 수 있거나 시간이 초과될 때까지 작업이 완료되지 않습니다.
BeginReceive(TimeSpan, Cursor, Object, AsyncCallback)	지정된 제한 시간이 있고 지정된 커서 및 지정된 상태 개체를 사용하는 비동기 수신 작업을 초기화합니다. 상태 개체는 전체 작업 기간 동안 관련 정보를 제공합니다. 이 오버로드는 콜백을 통해 해당 작업의 이벤트 처리기 ID에 대한 알림을 수신합니다. 큐에서 메시지를 사용할 수 있거나 시간 초과가 발생할 때까지 작업이 완료되지 않습니다.
BeginReceive(TimeSpan, Object)	시간 제한 및 상태 개체가 지정되어 있는 비동기 수신 작업을 시작합니다. 이는 작업의 수명이 지속되는 동안 관련된 정보를 제공합니다. 큐에서 메시지를 사용할 수 있거나 시간 초과가 발생할 때까지 작업이 완료되지 않습니다.
BeginReceive(TimeSpan, Object, AsyncCallback)	시간 제한 및 상태 개체가 지정되어 있는 비동기 수신 작업을 시작합니다. 이는 작업의 수명이 지속되는 동안 관련된 정보를 제공합니다. 이 오버로드는 콜백을 통해 해당 작업의 이벤트 처리기 ID에 대한 알림을 수신합니다. 큐에서 메시지를 사용할 수 있거나 시간 초과가 발생할 때까지 작업이 완료되지 않습니다.
ClearConnectionCache()	연결 캐시를 지웁니다.
Close()	MessageQueue가 할당한 리소스를 모두 해제합니다.
Create(String)	지정된 경로에 비트랜잭션 메시지 큐를 만듭니다.
Create(String, Boolean)	지정된 경로에 트랜잭션 또는 비트랜잭션 메시지 큐를 만듭니다.
CreateCursor()	현재 메시지 큐의 새 Cursor를 만듭니다.
CreateObjRef(Type)	원격 개체와 통신하는 데 사용되는 프록시 생성에 필요한 모든 관련 정보가 들어 있는 개체를 만듭니다. (다음에서 상속됨 MarshalByRefObject)
Delete(String)	메시지 큐 서버에 있는 큐를 삭제합니다.
Dispose()	Component에서 사용하는 모든 리소스를 해제합니다. (다음에서 상속됨 Component)
Dispose(Boolean)	MessageQueue에서 사용하는 리소스(메모리 제외)를 삭제합니다.
EndPeek(IAsyncResult)	지정된 비동기 피킹(peeking) 작업을 완료합니다.
EndReceive(IAsyncResult)	지정된 비동기 수신 작업을 완료합니다.
Equals(Object)	지정된 개체가 현재 개체와 같은지 확인합니다. (다음에서 상속됨 Object)
Exists(String)	지정된 경로에 메시지 큐가 있는지 여부를 확인합니다.
GetAllMessages()	큐에 있는 메시지를 모두 반환합니다.
GetEnumerator()	사용되지 않음. 큐의 메시지를 열거합니다. GetEnumerator()는 사용되지 않습니다. GetMessageEnumerator2()를 대신 사용해야 합니다.
GetHashCode()	기본 해시 함수로 작동합니다. (다음에서 상속됨 Object)
GetLifetimeService()	이 인스턴스의 수명 정책을 제어하는 현재의 수명 서비스 개체를 검색합니다. (다음에서 상속됨 MarshalByRefObject)
GetMachineId(String)	이 MessageQueue가 참조하는 큐가 있는 컴퓨터의 식별자를 가져옵니다.
GetMessageEnumerator()	사용되지 않음. 큐에 있는 모든 메시지에 대해 열거자 개체를 만듭니다. GetMessageEnumerator()는 사용되지 않습니다. GetMessageEnumerator2()를 대신 사용해야 합니다.
GetMessageEnumerator2()	큐에 있는 모든 메시지에 대해 열거자 개체를 만듭니다.
GetMessageQueueEnumerator()	앞으로만 이동 가능한 커서 의미 체계 기능을 제공하여 네트워크에 있는 모든 공개 큐를 열거합니다.
GetMessageQueueEnumerator(MessageQueueCriteria)	앞으로만 이동 가능한 커서 의미 체계 기능 제공하여 네트워크에 있는 공개 큐 중 지정된 기준을 만족하는 큐를 모두 열거합니다.
GetPrivateQueuesByMachine(String)	지정된 컴퓨터에 있는 프라이빗 큐를 모두 검색합니다.
GetPublicQueues()	네트워크에 있는 공개 큐를 모두 검색합니다.
GetPublicQueues(MessageQueueCriteria)	네트워크에 있는 공개 큐 중 지정된 기준을 만족시키는 큐를 모두 검색합니다.
GetPublicQueuesByCategory(Guid)	네트워크에 있는 공개 큐 중 지정된 범주에 속한 큐를 모두 검색합니다.
GetPublicQueuesByLabel(String)	네트워크에 있는 공개 큐 중 지정된 레이블이 있는 큐를 모두 검색합니다.
GetPublicQueuesByMachine(String)	지정된 컴퓨터에 있는 공개 큐를 모두 검색합니다.
GetSecurityContext()	이 호출 시 MSMQ가 현재 사용자(스레드 ID)와 연결된 보안 컨텍스트를 검색합니다.
GetService(Type)	Component 또는 해당 Container에서 제공하는 서비스를 나타내는 개체를 반환합니다. (다음에서 상속됨 Component)
GetType()	현재 인스턴스의 Type을 가져옵니다. (다음에서 상속됨 Object)
InitializeLifetimeService()	이 인스턴스의 수명 정책을 제어하는 수명 서비스 개체를 가져옵니다. (다음에서 상속됨 MarshalByRefObject)
MemberwiseClone()	현재 Object의 단순 복사본을 만듭니다. (다음에서 상속됨 Object)
MemberwiseClone(Boolean)	현재 MarshalByRefObject 개체의 단순 복사본을 만듭니다. (다음에서 상속됨 MarshalByRefObject)
Peek()	이 MessageQueue가 참조하는 큐의 첫 번째 메시지를 반환하지만 제거(피킹)하지는 않습니다. Peek() 메서드는 동기적이므로 메시지를 사용할 수 있을 때까지 현재 스레드를 차단시킵니다.
Peek(TimeSpan)	이 MessageQueue가 참조하는 큐의 첫 번째 메시지를 반환하지만 제거(피킹)하지는 않습니다. Peek() 메서드는 동기적이므로 메시지를 사용할 수 있거나 지정된 시간이 초과될 때까지 현재 실행 스레드를 차단시킵니다.
Peek(TimeSpan, Cursor, PeekAction)	지정된 커서를 사용하여 큐에 있는 현재 또는 다음 메시지를 제거하지 않고 반환(피킹)합니다. Peek() 메서드는 동기적이므로 메시지를 사용할 수 있거나 지정된 시간이 초과될 때까지 현재 실행 스레드를 차단시킵니다.
PeekByCorrelationId(String)	주어진 상관 관계 식별자를 갖는 메시지를 피킹합니다. 지정된 상관 관계 식별자가 포함된 메시지가 큐에 현재 없는 경우에는 바로 예외가 발생합니다.
PeekByCorrelationId(String, TimeSpan)	주어진 상관 관계 식별자를 갖는 메시지를 피킹하며, 지정된 상관 관계 식별자가 포함된 메시지를 큐에서 사용할 수 있거나 제한 시간이 만료될 때까지 대기합니다.
PeekById(String)	메시지 식별자가 id 매개 변수와 일치하는 메시지를 피킹합니다.
PeekById(String, TimeSpan)	메시지 식별자가 id 매개 변수와 일치하는 메시지를 피킹합니다. 큐에 메시지가 표시되거나 제한 시간이 만료될 때까지 대기합니다.
PeekByLookupId(Int64)	MSMQ 3.0에서 도입되었습니다. 비트랜잭션 큐에서 지정된 조회 식별자를 갖는 메시지를 피킹합니다.
PeekByLookupId(MessageLookupAction, Int64)	MSMQ 3.0에서 도입되었습니다. 큐의 특정 메시지를 피킹합니다. 메시지는 조회 식별자로 지정하거나 큐의 앞이나 뒤와 같은 위치로 지정할 수 있습니다.
Purge()	큐에 포함된 모든 메시지를 삭제합니다.
Receive()	MessageQueue가 참조하는 큐에서 사용할 수 있는 첫 번째 메시지를 받습니다. 이 호출은 동기적이므로 메시지를 사용할 수 있을 때까지 현재 실행 스레드를 중단합니다.
Receive(MessageQueueTransaction)	MessageQueue가 참조하는 트랜잭션 큐에서 사용할 수 있는 첫 번째 메시지를 받습니다. 이 호출은 동기적이므로 메시지를 사용할 수 있을 때까지 현재 실행 스레드를 중단합니다.
Receive(MessageQueueTransactionType)	MessageQueue가 참조하는 큐에서 사용할 수 있는 첫 번째 메시지를 받습니다. 이 호출은 동기적이므로 메시지를 사용할 수 있을 때까지 현재 실행 스레드를 중단합니다.
Receive(TimeSpan)	MessageQueue가 참조하는 큐의 첫 번째 메시지를 받고, 메시지를 큐에서 사용할 수 있거나 제한 시간이 만료될 때까지 대기합니다.
Receive(TimeSpan, Cursor)	지정된 커서를 사용하여 큐에 있는 현재 메시지를 받습니다. 사용할 수 있는 메시지가 없는 경우 이 메서드는 메시지를 사용할 수 있거나 시간 제한이 만료될 때까지 대기합니다.
Receive(TimeSpan, Cursor, MessageQueueTransaction)	지정된 커서를 사용하여 큐에 있는 현재 메시지를 받습니다. 사용할 수 있는 메시지가 없는 경우 이 메서드는 메시지를 사용할 수 있거나 시간 제한이 만료될 때까지 대기합니다.
Receive(TimeSpan, Cursor, MessageQueueTransactionType)	지정된 커서를 사용하여 큐에 있는 현재 메시지를 받습니다. 사용할 수 있는 메시지가 없는 경우 이 메서드는 메시지를 사용할 수 있거나 시간 제한이 만료될 때까지 대기합니다.
Receive(TimeSpan, MessageQueueTransaction)	MessageQueue가 참조하는 트랜잭션 큐의 첫 번째 메시지를 받으며, 메시지를 큐에서 사용할 수 있거나 제한 시간이 만료될 때까지 대기합니다.
Receive(TimeSpan, MessageQueueTransactionType)	MessageQueue가 참조하는 큐에서 사용할 수 있는 첫 번째 메시지를 받습니다. 이 호출은 동기적이므로 큐에 메시지를 사용할 수 있거나 제한 시간이 만료될 때까지 대기합니다.
ReceiveByCorrelationId(String)	주어진 상관 관계 식별자를 갖는 메시지를 비트랜잭션 큐로부터 받습니다. 지정된 상관 관계 식별자가 포함된 메시지가 큐에 현재 존재하지 않는 경우에는 바로 예외가 발생합니다.
ReceiveByCorrelationId(String, MessageQueueTransaction)	주어진 상관 관계 식별자를 갖는 메시지를 트랜잭션 큐로부터 받습니다. 지정된 상관 관계 식별자가 포함된 메시지가 큐에 현재 존재하지 않는 경우에는 바로 예외가 발생합니다.
ReceiveByCorrelationId(String, MessageQueueTransactionType)	주어진 상관 관계 식별자를 갖는 메시지를 받습니다. 지정된 상관 관계 식별자가 들어 있는 메시지가 큐에 현재 없는 경우에는 바로 예외가 발생합니다.
ReceiveByCorrelationId(String, TimeSpan)	주어진 상관 관계 식별자를 갖는 메시지를 비트랜잭션 큐로부터 받고, 지정된 상관 관계 식별자가 포함된 메시지를 큐에서 사용할 수 있거나 제한 시간이 만료될 때까지 대기합니다.
ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransaction)	주어진 상관 관계 식별자를 갖는 메시지를 트랜잭션 큐로부터 받고, 지정된 상관 관계 식별자가 포함된 메시지를 큐에서 사용할 수 있거나 제한 시간이 만료될 때까지 대기합니다.
ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransactionType)	주어진 상관 관계 식별자를 갖는 메시지를 받고, 지정된 상관 관계 식별자가 포함된 메시지를 큐에서 사용할 수 있거나 제한 시간이 만료될 때까지 대기합니다.
ReceiveById(String)	주어진 식별자를 갖는 메시지를 비트랜잭션 큐로부터 받습니다. 지정된 식별자가 들어 있는 메시지가 큐에 현재 없는 경우에는 바로 예외가 발생합니다.
ReceiveById(String, MessageQueueTransaction)	주어진 식별자를 갖는 메시지를 트랜잭션 큐로부터 받습니다. 지정된 식별자가 포함된 메시지가 큐에 현재 없는 경우에는 바로 예외가 발생합니다.
ReceiveById(String, MessageQueueTransactionType)	주어진 식별자를 갖는 메시지를 받습니다. 지정된 식별자가 포함된 메시지가 큐에 현재 없는 경우에는 바로 예외가 발생합니다.
ReceiveById(String, TimeSpan)	주어진 식별자를 갖는 메시지를 비트랜잭션 큐로부터 받고, 지정된 식별자가 포함된 메시지를 큐에서 사용할 수 있거나 제한 시간이 만료될 때까지 대기합니다.
ReceiveById(String, TimeSpan, MessageQueueTransaction)	주어진 식별자를 갖는 메시지를 트랜잭션 큐로부터 받고, 지정된 식별자가 포함된 메시지를 큐에서 사용할 수 있거나 제한 시간이 만료될 때까지 대기합니다.
ReceiveById(String, TimeSpan, MessageQueueTransactionType)	주어진 식별자를 갖는 메시지를 받고, 지정된 식별자가 포함된 메시지를 큐에서 사용할 수 있거나 제한 시간이 만료될 때까지 대기합니다.
ReceiveByLookupId(Int64)	MSMQ 3.0에서 도입되었습니다. 비트랜잭션 큐에서 지정된 조회 식별자를 갖는 메시지를 받습니다.
ReceiveByLookupId(MessageLookupAction, Int64, MessageQueueTransaction)	MSMQ 3.0에서 도입되었습니다. 트랜잭션 큐에서 특정 메시지를 받습니다. 메시지는 조회 식별자로 지정하거나 큐의 앞이나 뒤와 같은 위치로 지정할 수 있습니다.
ReceiveByLookupId(MessageLookupAction, Int64, MessageQueueTransactionType)	MSMQ 3.0에서 도입되었습니다. 지정된 트랜잭션 컨텍스트를 사용하여 큐에서 특정 메시지를 받습니다. 메시지는 조회 식별자로 지정하거나 큐의 앞이나 뒤와 같은 위치로 지정할 수 있습니다.
Refresh()	MessageQueue가 제공하는 속성을 새로 고쳐 리소스의 현재 상태를 반영합니다.
ResetPermissions()	사용 권한 목록을 운영 체제의 기본값으로 다시 설정합니다. 기본 목록에 추가한 큐 권한을 모두 제거합니다.
Send(Object)	이 MessageQueue가 참조하는 비트랜잭션 큐에 개체를 보냅니다.
Send(Object, MessageQueueTransaction)	이 MessageQueue가 참조하는 트랜잭션 큐에 개체를 보냅니다.
Send(Object, MessageQueueTransactionType)	이 MessageQueue가 참조하는 큐에 개체를 보냅니다.
Send(Object, String)	이 MessageQueue가 참조하는 비트랜잭션 큐에 개체를 보내고 메시지에 레이블을 지정합니다.
Send(Object, String, MessageQueueTransaction)	이 MessageQueue가 참조하는 트랜잭션 큐에 개체를 보내고 메시지에 레이블을 지정합니다.
Send(Object, String, MessageQueueTransactionType)	이 MessageQueue가 참조하는 큐에 개체를 보내고 메시지에 레이블을 지정합니다.
SetPermissions(AccessControlList)	액세스 제어 목록의 내용을 기준으로 큐에 액세스 권한을 할당합니다.
SetPermissions(MessageQueueAccessControlEntry)	액세스 제어 항목의 내용을 기준으로 큐에 액세스 권한을 할당합니다.
SetPermissions(String, MessageQueueAccessRights)	지정된 액세스 권한을 컴퓨터, 그룹, 또는 사용자에게 부여합니다.
SetPermissions(String, MessageQueueAccessRights, AccessControlEntryType)	지정된 액세스 제어 형식(예: 허용, 거부, 해지, 또는 설정)을 포함하여, 지정된 액세스 권한을 컴퓨터, 그룹 또는 사용자에게 제공합니다.
ToString()	Component의 이름이 포함된 String을 반환합니다(있는 경우). 이 메서드는 재정의할 수 없습니다. (다음에서 상속됨 Component)

이벤트

Disposed	Dispose() 메서드를 호출하여 구성 요소를 삭제할 때 발생합니다. (다음에서 상속됨 Component)
PeekCompleted	큐에서 메시지를 제거하지 않고 메시지를 읽는 경우에 발생합니다. 이는 비동기 작업인 BeginPeek()의 결과입니다.
ReceiveCompleted	큐에서 메시지가 제거된 경우에 발생합니다. 이 이벤트는 비동기 작업인 BeginReceive()에 의해 발생합니다.

확장 메서드

Cast<TResult>(IEnumerable)	IEnumerable의 요소를 지정된 형식으로 캐스팅합니다.
OfType<TResult>(IEnumerable)	지정된 형식에 따라 IEnumerable의 요소를 필터링합니다.
AsParallel(IEnumerable)	쿼리를 병렬화할 수 있도록 합니다.
AsQueryable(IEnumerable)	IEnumerable을 IQueryable로 변환합니다.

스레드 보안

GetAllMessages() 메서드만 스레드로부터 안전합니다.

추가 정보

• Message
• DefaultPropertiesToSend
• MessageQueueException
• MessageQueue()
• Peek()
• Receive()
• BeginPeek()
• BeginReceive()
• Path
• Label
• FormatName
• QueueName
• MachineName