MessageQueue 클래스

정의

메시지 큐 서버에 있는 큐에 대한 액세스를 제공합니다.Provides access to a queue on a Message Queuing server.

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
type MessageQueue = class
    inherit Component
    interface IEnumerable
Public Class MessageQueue
Inherits Component
Implements IEnumerable
상속
특성
구현

예제

다음 코드 예제에서는 새 MessageQueue 다양 한 경로 이름을 구문 형식을 사용 하 여 개체입니다.The following code example creates new MessageQueue objects using various path name syntax types. 각각의 경우에서 경로가 생성자에 정의 된 큐에 메시지를 보냅니다.In each case, it sends a message to the queue whose path is defined in the constructor.

#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합니다.The following code example sends a message to a queue, and receives a message from a queue, using an application-specific class called 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

설명

메시지 큐 기술을 실행 중인 애플리케이션을 서로 다른 시간에 유형이 다른 네트워크와 일시적으로 오프 라인 상태일 수 있는 시스템 간에 통신할 수 있습니다.The Message Queuing technology allows applications running at different times to communicate across heterogeneous networks and systems that might be temporarily offline. 애플리케이션 송신, 수신 또는 피킹 큐에서 메시지 (제거 하지 않고 읽기).Applications send, receive, or peek (read without removing) messages from queues. 메시지 큐의 선택적 구성 요소는 Windows 2000Windows 2000 및 Windows NT 별도로 설치 해야 합니다.Message Queuing is an optional component of Windows 2000Windows 2000 and Windows NT, and must be installed separately.

MessageQueue 클래스는 메시지 큐 래퍼입니다.The MessageQueue class is a wrapper around Message Queuing. 메시지 큐를 사용 하 여 여러 버전의 MessageQueue 사용 중인 운영 체제에 따라, 클래스 약간 다른 동작이 발생할 수 있습니다.There are multiple versions of Message Queuing, and using the MessageQueue class can result in slightly different behavior, depending on the operating system you are using. 메시지 큐의 각 버전의 특정 기능에 대 한 정보를 msdn에서 Platform SDK에서 "What is 메시지 큐에서 새" 항목을 참조 합니다.For information about specific features of each version of Message Queuing, see the topic "What's New in Message Queuing" in the Platform SDK in MSDN.

MessageQueue 클래스는 메시지 큐에 대 한 참조를 제공 합니다.The MessageQueue class provides a reference to a Message Queuing queue. 경로 지정할 수 있습니다는 MessageQueue 생성자는 기존 리소스에 연결할 서버에서 새 큐를 만들 수 있습니다.You can specify a path in the MessageQueue constructor to connect to an existing resource, or you can create a new queue on the server. 호출 하기 전에 Send(Object), Peek, 또는 Receive의 새 인스턴스를 연결 해야 합니다는 MessageQueue 기존 큐를 사용 하 여 클래스입니다.Before you can call Send(Object), Peek, or Receive, you must associate the new instance of the MessageQueue class with an existing queue. 같은 큐 속성을 조작할 수는 해당 시점 CategoryLabel입니다.At that point, you can manipulate the queue properties such as Category and Label.

MessageQueue 두 가지 유형의 메시지 검색을 지원 합니다: 동기 및 비동기입니다.MessageQueue supports two types of message retrieval: synchronous and asynchronous. 동기 메서드인 PeekReceive, 프로세스 스레드가 큐에 도착 하는 새 메시지에 대해 지정 된 시간 간격을 대기 합니다.The synchronous methods, Peek and Receive, cause the process thread to wait a specified time interval for a new message to arrive in the queue. 비동기 메서드는 BeginPeekBeginReceive, 기본 애플리케이션 작업을 큐에 메시지가 도착할 때까지 별도 스레드에서 계속 허용 합니다.The asynchronous methods, BeginPeek and BeginReceive, allow the main application tasks to continue in a separate thread until a message arrives in the queue. 이러한 메서드는 스레드 간의 의사 소통이 콜백 개체 및 상태 개체를 사용 하 여 작동 합니다.These methods work by using callback objects and state objects to communicate information between threads.

새 인스턴스를 만들 때의 MessageQueue 클래스를 작성 하지 않으려면 새 큐입니다.When you create a new instance of the MessageQueue class, you are not creating a new Message Queuing queue. 대신 사용할 수는 Create(String), Delete(String), 및 Purge 서버의 큐를 관리 하는 방법입니다.Instead, you can use the Create(String), Delete(String), and Purge methods to manage queues on the server.

와 달리 Purge, Create(String)Delete(String) 됩니다 static 멤버의 새 인스턴스를 만들지 않고 호출할 수 있습니다 이므로 MessageQueue 클래스.Unlike Purge, Create(String) and Delete(String) are static members, so you can call them without creating a new instance of the MessageQueue class.

설정할 수 있습니다 합니다 MessageQueue 개체의 Path 세 가지 이름 중 하나를 사용 하 여 속성: 이름, 합니다 FormatName, 또는 Label합니다.You can set the MessageQueue object's Path property with one of three names: the friendly name, the FormatName, or the Label. 큐의에 정의 된 이름이 MachineNameQueueName 속성은 MachineName \ QueueName 공개 큐에 대 한 및 MachineName \ Private$ \ QueueName 개인 큐에 대 한 합니다.The friendly name, which is defined by the queue's MachineName and QueueName properties, is MachineName\QueueName for a public queue, and MachineName\Private$\QueueName for a private queue. FormatName 속성 메시지 큐 오프 라인 액세스를 허용 합니다.The FormatName property allows offline access to message queues. 마지막으로 큐의 사용할 수 있습니다 Label 큐의 설정 하려면 속성 Path합니다.Lastly, you can use the queue's Label property to set the queue's Path.

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

생성자

MessageQueue()

MessageQueue 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the MessageQueue class. 매개 변수가 없는 생성자가 새 인스턴스를 초기화하면, 이 인스턴스를 사용하기 전에 인스턴스의 Path 속성을 설정해야 합니다.After the parameterless constructor initializes the new instance, you must set the instance's Path property before you can use the instance.

MessageQueue(String)

지정된 경로에 있는 메시지 큐를 참조하는 MessageQueue 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the MessageQueue class that references the Message Queuing queue at the specified path.

MessageQueue(String, Boolean)

지정된 경로에 위치하고 읽기 액세스 제한이 설정된 메시지 큐를 참조하는 MessageQueue 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the MessageQueue class that references the Message Queuing queue at the specified path and with the specified read-access restriction.

MessageQueue(String, Boolean, Boolean)

MessageQueue 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the MessageQueue class.

MessageQueue(String, Boolean, Boolean, QueueAccessMode)

MessageQueue 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the MessageQueue class.

MessageQueue(String, QueueAccessMode)

MessageQueue 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the MessageQueue class.

필드

InfiniteQueueSize

큐에 크기 제한이 없도록 지정합니다.Specifies that no size restriction exists for a queue.

InfiniteTimeout

메시지를 피킹하거나 받는 메서드에 시간 제한이 없도록 지정합니다.Specifies that no time-out exists for methods that peek or receive messages.

속성

AccessMode

큐의 액세스 모드를 나타내는 값을 가져옵니다.Gets a value that indicates the access mode for the queue.

Authenticate

큐가 인증된 메시지만 허용하는지 여부를 나타내는 값을 가져오거나 설정합니다.Gets or sets a value that indicates whether the queue accepts only authenticated messages.

BasePriority

네트워크에서 공개 큐의 메시지를 라우팅하는 데 사용하는 기본 우선 순위 메시지 큐를 가져오거나 설정합니다.Gets or sets the base priority Message Queuing uses to route a public queue's messages over the network.

CanRaiseEvents

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

(다음에서 상속됨 Component)
CanRead

MessageQueue를 읽을 수 있는지 여부를 나타내는 값을 가져옵니다.Gets a value that indicates whether the MessageQueue can be read.

CanWrite

MessageQueue에 쓸 수 있는지 여부를 나타내는 값을 가져옵니다.Gets a value that indicates whether the MessageQueue can be written to.

Category

큐 범주를 가져오거나 설정합니다.Gets or sets the queue category.

Container

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

(다음에서 상속됨 Component)
CreateTime

메시지 큐에서 큐가 만들어진 날짜와 시간을 가져옵니다.Gets the time and date that the queue was created in Message Queuing.

DefaultPropertiesToSend

애플리케이션이 큐에 메시지를 보낼 때 기본적으로 사용되는 메시지 속성 값을 가져오거나 설정합니다.Gets or sets the message property values to be used by default when the application sends messages to the queue.

DenySharedReceive

MessageQueue가 메시지 큐에서 메시지를 받기 위한 단독 액세스 권한을 갖는지 여부를 나타내는 값을 가져오거나 설정합니다.Gets or sets a value that indicates whether this MessageQueue has exclusive access to receive messages from the Message Queuing queue.

DesignMode

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

(다음에서 상속됨 Component)
EnableConnectionCache

연결 캐시가 애플리케이션에 의해 유지 관리될지 여부를 나타내는 값을 가져오거나 설정합니다.Gets or sets a value that indicates whether a cache of connections will be maintained by the application.

EncryptionRequired

큐에서 프라이빗하지 않은(암호화되지 않은) 메시지만 허용하는지 여부를 나타내는 값을 가져오거나 설정합니다.Gets or sets a value that indicates whether the queue accepts only non-private (non-encrypted) messages.

Events

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

(다음에서 상속됨 Component)
FormatName

큐를 작성할 때 메시지 큐가 발생시킨 고유한 큐 이름을 가져옵니다.Gets the unique queue name that Message Queuing generated at the time of the queue's creation.

Formatter

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

Id

큐의 고유한 메시지 큐 식별자를 가져옵니다.Gets the unique Message Queuing identifier of the queue.

Label

큐 설명을 가져오거나 설정합니다.Gets or sets the queue description.

LastModifyTime

큐의 속성이 마지막으로 수정된 시간을 가져옵니다.Gets the last time the properties of a queue were modified.

MachineName

메시지 큐가 있는 컴퓨터의 이름을 가져오거나 설정합니다.Gets or sets the name of the computer where the Message Queuing queue is located.

MaximumJournalSize

업무 일지 큐의 최대 크기를 가져오거나 설정합니다.Gets or sets the maximum size of the journal queue.

MaximumQueueSize

큐의 최대 크기를 가져오거나 설정합니다.Gets or sets the maximum size of the queue.

MessageReadPropertyFilter

메시지를 받거나 또는 피킹하는 데 필요한 속성 필터를 가져오거나 설정합니다.Gets or sets the property filter for receiving or peeking messages.

MulticastAddress

MSMQ 3.0에서 도입되었습니다.Introduced in MSMQ 3.0. 큐에 연결된 멀티캐스트 주소를 가져오거나 설정합니다.Gets or sets the multicast address associated with the queue.

Path

큐의 경로를 가져오거나 설정합니다.Gets or sets the queue's path. Path를 설정하면 MessageQueue가 새 큐를 가리킵니다.Setting the Path causes the MessageQueue to point to a new queue.

QueueName

큐를 식별하는 이름을 가져오거나 설정합니다.Gets or sets the friendly name that identifies the queue.

ReadHandle

메시지 큐에서 메시지를 읽는 데 사용되는 기본 핸들을 가져옵니다.Gets the native handle used to read messages from the message queue.

Site

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

(다음에서 상속됨 Component)
SynchronizingObject

ReceiveCompleted 또는 PeekCompleted 이벤트의 결과로 생성된 이벤트 처리기의 호출을 마샬링하는 개체를 가져오거나 설정합니다.Gets or sets the object that marshals the event-handler call resulting from a ReceiveCompleted or PeekCompleted event.

Transactional

큐가 트랜잭션만 허용하는지 여부를 나타내는 값을 가져옵니다.Gets a value that indicates whether the queue accepts only transactions.

UseJournalQueue

받은 메시지가 업무 일지 큐로 복사되는지 여부를 나타내는 값을 가져오거나 설정합니다.Gets or sets a value that indicates whether received messages are copied to the journal queue.

WriteHandle

메시지 큐에 메시지를 보내는 데 사용되는 기본 핸들을 가져옵니다.Gets the native handle used to send messages to the message queue.

메서드

BeginPeek()

시간 제한이 없는 비동기 피킹(peeking) 작업을 시작합니다. 큐에서 메시지를 사용할 수 있을 때까지 작업이 완료되지 않습니다.Initiates an asynchronous peek operation that has no time-out. The operation is not complete until a message becomes available in the queue.

BeginPeek(TimeSpan)

시간 제한이 지정된 비동기 피킹(peeking) 작업을 시작합니다. 큐에서 메시지를 사용할 수 있거나 시간 초과가 발생할 때까지 작업이 완료되지 않습니다.Initiates an asynchronous peek operation that has a specified time-out. The operation is not complete until either a message becomes available in the queue or the time-out occurs.

BeginPeek(TimeSpan, Cursor, PeekAction, Object, AsyncCallback)

지정된 제한 시간이 있고 지정된 커서, 지정된 피킹(peeking) 작업 및 지정된 상태 개체를 사용하는 비동기 피킹(peeking) 작업을 초기화합니다.Initiates an asynchronous peek operation that has a specified time-out and that uses a specified cursor, a specified peek action, and a specified state object. 상태 개체는 전체 작업 기간 동안 관련 정보를 제공합니다.The state object provides associated information throughout the lifetime of the operation. 이 오버로드는 콜백을 통해 해당 작업의 이벤트 처리기 ID에 대한 알림을 수신합니다.This overload receives notification, through a callback, of the identity of the event handler for the operation. 큐에서 메시지를 사용할 수 있거나 시간 초과가 발생할 때까지 작업이 완료되지 않습니다.The operation is not complete until either a message becomes available in the queue or the time-out occurs.

BeginPeek(TimeSpan, Object)

시간 제한 및 상태 개체가 지정되어 있는 비동기 피킹(peeking) 작업을 시작합니다. 이는 작업의 수명이 지속되는 동안 관련된 정보를 제공합니다.Initiates an asynchronous peek operation that has a specified time-out and a specified state object, which provides associated information throughout the operation's lifetime. 큐에서 메시지를 사용할 수 있거나 시간 초과가 발생할 때까지 작업이 완료되지 않습니다.The operation is not complete until either a message becomes available in the queue or the time-out occurs.

BeginPeek(TimeSpan, Object, AsyncCallback)

시간 제한 및 상태 개체가 지정되어 있는 비동기 피킹(peeking) 작업을 시작합니다. 이는 작업의 수명이 지속되는 동안 관련된 정보를 제공합니다.Initiates an asynchronous peek operation that has a specified time-out and a specified state object, which provides associated information throughout the operation's lifetime. 이 오버로드는 콜백을 통해 해당 작업의 이벤트 처리기 ID에 대한 알림을 수신합니다.This overload receives notification, through a callback, of the identity of the event handler for the operation. 큐에서 메시지를 사용할 수 있거나 시간 초과가 발생할 때까지 작업이 완료되지 않습니다.The operation is not complete until either a message becomes available in the queue or the time-out occurs.

BeginReceive()

시간 제한이 없는 비동기 수신 작업을 시작합니다. 큐에서 메시지를 사용할 수 있을 때까지 작업이 완료되지 않습니다.Initiates an asynchronous receive operation that has no time-out. The operation is not complete until a message becomes available in the queue.

BeginReceive(TimeSpan)

시간 제한이 지정된 비동기 수신 작업을 시작합니다. 큐에서 메시지를 사용할 수 있거나 시간 초과가 발생할 때까지 작업이 완료되지 않습니다.Initiates an asynchronous receive operation that has a specified time-out. The operation is not complete until either a message becomes available in the queue or the time-out occurs.

BeginReceive(TimeSpan, Cursor, Object, AsyncCallback)

지정된 제한 시간이 있고 지정된 커서 및 지정된 상태 개체를 사용하는 비동기 수신 작업을 초기화합니다.Initiates an asynchronous receive operation that has a specified time-out and uses a specified cursor and a specified state object. 상태 개체는 전체 작업 기간 동안 관련 정보를 제공합니다.The state object provides associated information throughout the lifetime of the operation. 이 오버로드는 콜백을 통해 해당 작업의 이벤트 처리기 ID에 대한 알림을 수신합니다.This overload receives notification, through a callback, of the identity of the event handler for the operation. 큐에서 메시지를 사용할 수 있거나 시간 초과가 발생할 때까지 작업이 완료되지 않습니다.The operation is not complete until either a message becomes available in the queue or the time-out occurs.

BeginReceive(TimeSpan, Object)

시간 제한 및 상태 개체가 지정되어 있는 비동기 수신 작업을 시작합니다. 이는 작업의 수명이 지속되는 동안 관련된 정보를 제공합니다.Initiates an asynchronous receive operation that has a specified time-out and a specified state object, which provides associated information throughout the operation's lifetime. 큐에서 메시지를 사용할 수 있거나 시간 초과가 발생할 때까지 작업이 완료되지 않습니다.The operation is not complete until either a message becomes available in the queue or the time-out occurs.

BeginReceive(TimeSpan, Object, AsyncCallback)

시간 제한 및 상태 개체가 지정되어 있는 비동기 수신 작업을 시작합니다. 이는 작업의 수명이 지속되는 동안 관련된 정보를 제공합니다.Initiates an asynchronous receive operation that has a specified time-out and a specified state object, which provides associated information throughout the operation's lifetime. 이 오버로드는 콜백을 통해 해당 작업의 이벤트 처리기 ID에 대한 알림을 수신합니다.This overload receives notification, through a callback, of the identity of the event handler for the operation. 큐에서 메시지를 사용할 수 있거나 시간 초과가 발생할 때까지 작업이 완료되지 않습니다.The operation is not complete until either a message becomes available in the queue or the time-out occurs.

ClearConnectionCache()

연결 캐시를 지웁니다.Clears the connection cache.

Close()

MessageQueue가 할당한 리소스를 모두 해제합니다.Frees all resources allocated by the MessageQueue.

Create(String)

지정된 경로에 비트랜잭션 메시지 큐를 만듭니다.Creates a non-transactional Message Queuing queue at the specified path.

Create(String, Boolean)

지정된 경로에 트랜잭션 또는 비트랜잭션 메시지 큐를 만듭니다.Creates a transactional or non-transactional Message Queuing queue at the specified path.

CreateCursor()

현재 메시지 큐의 새 Cursor를 만듭니다.Creates a new Cursor for the current message queue.

CreateObjRef(Type)

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

(다음에서 상속됨 MarshalByRefObject)
Delete(String)

메시지 큐 서버에 있는 큐를 삭제합니다.Deletes a queue on a Message Queuing server.

Dispose()

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

(다음에서 상속됨 Component)
Dispose(Boolean)

MessageQueue에서 사용하는 리소스(메모리 제외)를 삭제합니다.Disposes of the resources (other than memory) used by the MessageQueue.

EndPeek(IAsyncResult)

지정된 비동기 피킹(peeking) 작업을 완료합니다.Completes the specified asynchronous peek operation.

EndReceive(IAsyncResult)

지정된 비동기 수신 작업을 완료합니다.Completes the specified asynchronous receive operation.

Equals(Object)

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

(다음에서 상속됨 Object)
Exists(String)

지정된 경로에 메시지 큐가 있는지 여부를 확인합니다.Determines whether a Message Queuing queue exists at the specified path.

GetAllMessages()

큐에 있는 메시지를 모두 반환합니다.Returns all the messages that are in the queue.

GetEnumerator()

큐의 메시지를 열거합니다.Enumerates the messages in a queue. GetEnumerator()는 사용되지 않습니다.GetEnumerator() is deprecated. GetMessageEnumerator2()를 대신 사용해야 합니다.GetMessageEnumerator2() should be used instead.

GetHashCode()

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

(다음에서 상속됨 Object)
GetLifetimeService()

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

(다음에서 상속됨 MarshalByRefObject)
GetMachineId(String)

MessageQueue가 참조하는 큐가 있는 컴퓨터의 식별자를 가져옵니다.Gets the identifier of the computer on which the queue referenced by this MessageQueue is located.

GetMessageEnumerator()

큐에 있는 모든 메시지에 대해 열거자 개체를 만듭니다.Creates an enumerator object for all the messages in the queue. GetMessageEnumerator()는 사용되지 않습니다.GetMessageEnumerator() is deprecated. GetMessageEnumerator2()를 대신 사용해야 합니다.GetMessageEnumerator2() should be used instead.

GetMessageEnumerator2()

큐에 있는 모든 메시지에 대해 열거자 개체를 만듭니다.Creates an enumerator object for all the messages in the queue.

GetMessageQueueEnumerator()

앞으로만 이동 가능한 커서 의미 체계 기능을 제공하여 네트워크에 있는 모든 공개 큐를 열거합니다.Provides forward-only cursor semantics to enumerate through all public queues on the network.

GetMessageQueueEnumerator(MessageQueueCriteria)

앞으로만 이동 가능한 커서 의미 체계 기능 제공하여 네트워크에 있는 공개 큐 중 지정된 기준을 만족하는 큐를 모두 열거합니다.Provides forward-only cursor semantics to enumerate through all public queues on the network that meet the specified criteria.

GetPrivateQueuesByMachine(String)

지정된 컴퓨터에 있는 프라이빗 큐를 모두 검색합니다.Retrieves all the private queues on the specified computer.

GetPublicQueues()

네트워크에 있는 공개 큐를 모두 검색합니다.Retrieves all the public queues on the network.

GetPublicQueues(MessageQueueCriteria)

네트워크에 있는 공개 큐 중 지정된 기준을 만족시키는 큐를 모두 검색합니다.Retrieves all the public queues on the network that meet the specified criteria.

GetPublicQueuesByCategory(Guid)

네트워크에 있는 공개 큐 중 지정된 범주에 속한 큐를 모두 검색합니다.Retrieves all the public queues on the network that belong to the specified category.

GetPublicQueuesByLabel(String)

네트워크에 있는 공개 큐 중 지정된 레이블이 있는 큐를 모두 검색합니다.Retrieves all the public queues on the network that carry the specified label.

GetPublicQueuesByMachine(String)

지정된 컴퓨터에 있는 공개 큐를 모두 검색합니다.Retrieves all the public queues that reside on the specified computer.

GetSecurityContext()

이 호출 시 MSMQ가 현재 사용자(스레드 ID)와 연결된 보안 컨텍스트를 검색합니다.Retrieves the security context that MSMQ associates with the current user (thread identity) at the time of this call.

GetService(Type)

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

(다음에서 상속됨 Component)
GetType()

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

(다음에서 상속됨 Object)
InitializeLifetimeService()

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

(다음에서 상속됨 MarshalByRefObject)
MemberwiseClone()

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

(다음에서 상속됨 Object)
MemberwiseClone(Boolean)

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

(다음에서 상속됨 MarshalByRefObject)
Peek()

MessageQueue가 참조하는 큐의 첫 번째 메시지를 반환하지만 제거(피킹)하지는 않습니다.Returns without removing (peeks) the first message in the queue referenced by this MessageQueue. Peek() 메서드는 동기적이므로 메시지를 사용할 수 있을 때까지 현재 스레드를 차단시킵니다.The Peek() method is synchronous, so it blocks the current thread until a message becomes available.

Peek(TimeSpan)

MessageQueue가 참조하는 큐의 첫 번째 메시지를 반환하지만 제거(피킹)하지는 않습니다.Returns without removing (peeks) the first message in the queue referenced by this MessageQueue. Peek() 메서드는 동기적이므로 메시지를 사용할 수 있거나 지정된 시간이 초과될 때까지 현재 실행 스레드를 차단시킵니다.The Peek() method is synchronous, so it blocks the current thread until a message becomes available or the specified time-out occurs.

Peek(TimeSpan, Cursor, PeekAction)

지정된 커서를 사용하여 큐에 있는 현재 또는 다음 메시지를 제거하지 않고 반환(피킹)합니다.Returns without removing (peeks) the current or next message in the queue, using the specified cursor. Peek() 메서드는 동기적이므로 메시지를 사용할 수 있거나 지정된 시간이 초과될 때까지 현재 실행 스레드를 차단시킵니다.The Peek() method is synchronous, so it blocks the current thread until a message becomes available or the specified time-out occurs.

PeekByCorrelationId(String)

주어진 상관 관계 식별자를 갖는 메시지를 피킹합니다. 지정된 상관 관계 식별자가 포함된 메시지가 큐에 현재 없는 경우에는 바로 예외가 발생합니다.Peeks the message that matches the given correlation identifier and immediately raises an exception if no message with the specified correlation identifier currently exists in the queue.

PeekByCorrelationId(String, TimeSpan)

주어진 상관 관계 식별자를 갖는 메시지를 피킹하며, 지정된 상관 관계 식별자가 포함된 메시지를 큐에서 사용할 수 있거나 제한 시간이 만료될 때까지 대기합니다.Peeks the message that matches the given correlation identifier and waits until either a message with the specified correlation identifier is available in the queue, or the time-out expires.

PeekById(String)

메시지 식별자가 id 매개 변수와 일치하는 메시지를 피킹합니다.Peeks the message whose message identifier matches the id parameter.

PeekById(String, TimeSpan)

메시지 식별자가 id 매개 변수와 일치하는 메시지를 피킹합니다.Peeks the message whose message identifier matches the id parameter. 큐에 메시지가 표시되거나 제한 시간이 만료될 때까지 대기합니다.Waits until the message appears in the queue or a time-out occurs.

PeekByLookupId(Int64)

MSMQ 3.0에서 도입되었습니다.Introduced in MSMQ 3.0. 비트랜잭션 큐에서 지정된 조회 식별자를 갖는 메시지를 피킹합니다.Peeks at the message that matches the given lookup identifier from a non-transactional queue.

PeekByLookupId(MessageLookupAction, Int64)

MSMQ 3.0에서 도입되었습니다.Introduced in MSMQ 3.0. 큐의 특정 메시지를 피킹합니다.Peeks at a specific message from the queue. 메시지는 조회 식별자로 지정하거나 큐의 앞이나 뒤와 같은 위치로 지정할 수 있습니다.The message can be specified by a lookup identifier or by its position at the front or end of the queue.

Purge()

큐에 포함된 모든 메시지를 삭제합니다.Deletes all the messages contained in the queue.

Receive()

MessageQueue가 참조하는 큐에서 사용할 수 있는 첫 번째 메시지를 받습니다.Receives the first message available in the queue referenced by the MessageQueue. 이 호출은 동기적이므로 메시지를 사용할 수 있을 때까지 현재 실행 스레드를 중단합니다.This call is synchronous, and blocks the current thread of execution until a message is available.

Receive(MessageQueueTransaction)

MessageQueue가 참조하는 트랜잭션 큐에서 사용할 수 있는 첫 번째 메시지를 받습니다.Receives the first message available in the transactional queue referenced by the MessageQueue. 이 호출은 동기적이므로 메시지를 사용할 수 있을 때까지 현재 실행 스레드를 중단합니다.This call is synchronous, and blocks the current thread of execution until a message is available.

Receive(MessageQueueTransactionType)

MessageQueue가 참조하는 큐에서 사용할 수 있는 첫 번째 메시지를 받습니다.Receives the first message available in the queue referenced by the MessageQueue. 이 호출은 동기적이므로 메시지를 사용할 수 있을 때까지 현재 실행 스레드를 중단합니다.This call is synchronous, and blocks the current thread of execution until a message is available.

Receive(TimeSpan)

MessageQueue가 참조하는 큐의 첫 번째 메시지를 받고, 메시지를 큐에서 사용할 수 있거나 제한 시간이 만료될 때까지 대기합니다.Receives the first message available in the queue referenced by the MessageQueue and waits until either a message is available in the queue, or the time-out expires.

Receive(TimeSpan, Cursor)

지정된 커서를 사용하여 큐에 있는 현재 메시지를 받습니다.Receives the current message in the queue, using a specified cursor. 사용할 수 있는 메시지가 없는 경우 이 메서드는 메시지를 사용할 수 있거나 시간 제한이 만료될 때까지 대기합니다.If no message is available, this method waits until either a message is available, or the time-out expires.

Receive(TimeSpan, Cursor, MessageQueueTransaction)

지정된 커서를 사용하여 큐에 있는 현재 메시지를 받습니다.Receives the current message in the queue, using a specified cursor. 사용할 수 있는 메시지가 없는 경우 이 메서드는 메시지를 사용할 수 있거나 시간 제한이 만료될 때까지 대기합니다.If no message is available, this method waits until either a message is available, or the time-out expires.

Receive(TimeSpan, Cursor, MessageQueueTransactionType)

지정된 커서를 사용하여 큐에 있는 현재 메시지를 받습니다.Receives the current message in the queue, using a specified cursor. 사용할 수 있는 메시지가 없는 경우 이 메서드는 메시지를 사용할 수 있거나 시간 제한이 만료될 때까지 대기합니다.If no message is available, this method waits until either a message is available, or the time-out expires.

Receive(TimeSpan, MessageQueueTransaction)

MessageQueue가 참조하는 트랜잭션 큐의 첫 번째 메시지를 받으며, 메시지를 큐에서 사용할 수 있거나 제한 시간이 만료될 때까지 대기합니다.Receives the first message available in the transactional queue referenced by the MessageQueue and waits until either a message is available in the queue, or the time-out expires.

Receive(TimeSpan, MessageQueueTransactionType)

MessageQueue가 참조하는 큐에서 사용할 수 있는 첫 번째 메시지를 받습니다.Receives the first message available in the queue referenced by the MessageQueue. 이 호출은 동기적이므로 큐에 메시지를 사용할 수 있거나 제한 시간이 만료될 때까지 대기합니다.This call is synchronous, and waits until either a message is available in the queue, or the time-out expires.

ReceiveByCorrelationId(String)

주어진 상관 관계 식별자를 갖는 메시지를 비트랜잭션 큐로부터 받습니다. 지정된 상관 관계 식별자가 포함된 메시지가 큐에 현재 존재하지 않는 경우에는 바로 예외가 발생합니다.Receives the message that matches the given correlation identifier (from a non-transactional queue) and immediately raises an exception if no message with the specified correlation identifier currently exists in the queue.

ReceiveByCorrelationId(String, MessageQueueTransaction)

주어진 상관 관계 식별자를 갖는 메시지를 트랜잭션 큐로부터 받습니다. 지정된 상관 관계 식별자가 포함된 메시지가 큐에 현재 존재하지 않는 경우에는 바로 예외가 발생합니다.Receives the message that matches the given correlation identifier (from a transactional queue) and immediately raises an exception if no message with the specified correlation identifier currently exists in the queue.

ReceiveByCorrelationId(String, MessageQueueTransactionType)

주어진 상관 관계 식별자를 갖는 메시지를 받습니다. 지정된 상관 관계 식별자가 들어 있는 메시지가 큐에 현재 없는 경우에는 바로 예외가 발생합니다.Receives the message that matches the given correlation identifier and immediately raises an exception if no message with the specified correlation identifier currently exists in the queue.

ReceiveByCorrelationId(String, TimeSpan)

주어진 상관 관계 식별자를 갖는 메시지를 비트랜잭션 큐로부터 받고, 지정된 상관 관계 식별자가 포함된 메시지를 큐에서 사용할 수 있거나 제한 시간이 만료될 때까지 대기합니다.Receives the message that matches the given correlation identifier (from a non-transactional queue) and waits until either a message with the specified correlation identifier is available in the queue, or the time-out expires.

ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransaction)

주어진 상관 관계 식별자를 갖는 메시지를 트랜잭션 큐로부터 받고, 지정된 상관 관계 식별자가 포함된 메시지를 큐에서 사용할 수 있거나 제한 시간이 만료될 때까지 대기합니다.Receives the message that matches the given correlation identifier (from a transactional queue) and waits until either a message with the specified correlation identifier is available in the queue, or the time-out expires.

ReceiveByCorrelationId(String, TimeSpan, MessageQueueTransactionType)

주어진 상관 관계 식별자를 갖는 메시지를 받고, 지정된 상관 관계 식별자가 포함된 메시지를 큐에서 사용할 수 있거나 제한 시간이 만료될 때까지 대기합니다.Receives the message that matches the given correlation identifier and waits until either a message with the specified correlation identifier is available in the queue, or the time-out expires.

ReceiveById(String)

주어진 식별자를 갖는 메시지를 비트랜잭션 큐로부터 받습니다. 지정된 식별자가 들어 있는 메시지가 큐에 현재 없는 경우에는 바로 예외가 발생합니다.Receives the message that matches the given identifier from a non-transactional queue and immediately raises an exception if no message with the specified identifier currently exists in the queue.

ReceiveById(String, MessageQueueTransaction)

주어진 식별자를 갖는 메시지를 트랜잭션 큐로부터 받습니다. 지정된 식별자가 포함된 메시지가 큐에 현재 없는 경우에는 바로 예외가 발생합니다.Receives the message that matches the given identifier (from a transactional queue) and immediately raises an exception if no message with the specified identifier currently exists in the queue.

ReceiveById(String, MessageQueueTransactionType)

주어진 식별자를 갖는 메시지를 받습니다. 지정된 식별자가 포함된 메시지가 큐에 현재 없는 경우에는 바로 예외가 발생합니다.Receives the message that matches the given identifier and immediately raises an exception if no message with the specified identifier currently exists in the queue.

ReceiveById(String, TimeSpan)

주어진 식별자를 갖는 메시지를 비트랜잭션 큐로부터 받고, 지정된 식별자가 포함된 메시지를 큐에서 사용할 수 있거나 제한 시간이 만료될 때까지 대기합니다.Receives the message that matches the given identifier (from a non-transactional queue) and waits until either a message with the specified identifier is available in the queue or the time-out expires.

ReceiveById(String, TimeSpan, MessageQueueTransaction)

주어진 식별자를 갖는 메시지를 트랜잭션 큐로부터 받고, 지정된 식별자가 포함된 메시지를 큐에서 사용할 수 있거나 제한 시간이 만료될 때까지 대기합니다.Receives the message that matches the given identifier (from a transactional queue) and waits until either a message with the specified identifier is available in the queue or the time-out expires.

ReceiveById(String, TimeSpan, MessageQueueTransactionType)

주어진 식별자를 갖는 메시지를 받고, 지정된 식별자가 포함된 메시지를 큐에서 사용할 수 있거나 제한 시간이 만료될 때까지 대기합니다.Receives the message that matches the given identifier and waits until either a message with the specified identifier is available in the queue or the time-out expires.

ReceiveByLookupId(Int64)

MSMQ 3.0에서 도입되었습니다.Introduced in MSMQ 3.0. 비트랜잭션 큐에서 지정된 조회 식별자를 갖는 메시지를 받습니다.Receives the message that matches the given lookup identifier from a non-transactional queue.

ReceiveByLookupId(MessageLookupAction, Int64, MessageQueueTransaction)

MSMQ 3.0에서 도입되었습니다.Introduced in MSMQ 3.0. 트랜잭션 큐에서 특정 메시지를 받습니다.Receives a specific message from a transactional queue. 메시지는 조회 식별자로 지정하거나 큐의 앞이나 뒤와 같은 위치로 지정할 수 있습니다.The message can be specified by a lookup identifier or by its position at the front or end of the queue.

ReceiveByLookupId(MessageLookupAction, Int64, MessageQueueTransactionType)

MSMQ 3.0에서 도입되었습니다.Introduced in MSMQ 3.0. 지정된 트랜잭션 컨텍스트를 사용하여 큐에서 특정 메시지를 받습니다.Receives a specific message from the queue, using the specified transaction context. 메시지는 조회 식별자로 지정하거나 큐의 앞이나 뒤와 같은 위치로 지정할 수 있습니다.The message can be specified by a lookup identifier or by its position at the front or end of the queue.

Refresh()

MessageQueue가 제공하는 속성을 새로 고쳐 리소스의 현재 상태를 반영합니다.Refreshes the properties presented by the MessageQueue to reflect the current state of the resource.

ResetPermissions()

사용 권한 목록을 운영 체제의 기본값으로 다시 설정합니다.Resets the permission list to the operating system's default values. 기본 목록에 추가한 큐 권한을 모두 제거합니다.Removes any queue permissions you have appended to the default list.

Send(Object)

MessageQueue가 참조하는 비트랜잭션 큐에 개체를 보냅니다.Sends an object to non-transactional queue referenced by this MessageQueue.

Send(Object, MessageQueueTransaction)

MessageQueue가 참조하는 트랜잭션 큐에 개체를 보냅니다.Sends an object to the transactional queue referenced by this MessageQueue.

Send(Object, MessageQueueTransactionType)

MessageQueue가 참조하는 큐에 개체를 보냅니다.Sends an object to the queue referenced by this MessageQueue.

Send(Object, String)

MessageQueue가 참조하는 비트랜잭션 큐에 개체를 보내고 메시지에 레이블을 지정합니다.Sends an object to the non-transactional queue referenced by this MessageQueue and specifies a label for the message.

Send(Object, String, MessageQueueTransaction)

MessageQueue가 참조하는 트랜잭션 큐에 개체를 보내고 메시지에 레이블을 지정합니다.Sends an object to the transactional queue referenced by this MessageQueue and specifies a label for the message.

Send(Object, String, MessageQueueTransactionType)

MessageQueue가 참조하는 큐에 개체를 보내고 메시지에 레이블을 지정합니다.Sends an object to the queue referenced by this MessageQueue and specifies a label for the message.

SetPermissions(AccessControlList)

액세스 제어 목록의 내용을 기준으로 큐에 액세스 권한을 할당합니다.Assigns access rights to the queue based on the contents of an access control list.

SetPermissions(MessageQueueAccessControlEntry)

액세스 제어 항목의 내용을 기준으로 큐에 액세스 권한을 할당합니다.Assigns access rights to the queue based on the contents of an access control entry.

SetPermissions(String, MessageQueueAccessRights)

지정된 액세스 권한을 컴퓨터, 그룹, 또는 사용자에게 부여합니다.Gives a computer, group, or user the specified access rights.

SetPermissions(String, MessageQueueAccessRights, AccessControlEntryType)

지정된 액세스 제어 형식(예: 허용, 거부, 해지, 또는 설정)을 포함하여, 지정된 액세스 권한을 컴퓨터, 그룹 또는 사용자에게 제공합니다.Gives a computer, group, or user the specified access rights, with the specified access control type (allow, deny, revoke, or set).

ToString()

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

(다음에서 상속됨 Component)

이벤트

Disposed

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

(다음에서 상속됨 Component)
PeekCompleted

큐에서 메시지를 제거하지 않고 메시지를 읽는 경우에 발생합니다.Occurs when a message is read without being removed from the queue. 이는 비동기 작업인 BeginPeek()의 결과입니다.This is a result of the asynchronous operation, BeginPeek().

ReceiveCompleted

큐에서 메시지가 제거된 경우에 발생합니다.Occurs when a message has been removed from the queue. 이 이벤트는 비동기 작업인 BeginReceive()에 의해 발생합니다.This event is raised by the asynchronous operation, BeginReceive().

확장 메서드

Cast<TResult>(IEnumerable)

IEnumerable의 요소를 지정된 형식으로 캐스팅합니다.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable)

지정된 형식에 따라 IEnumerable의 요소를 필터링합니다.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable)

쿼리를 병렬화할 수 있도록 합니다.Enables parallelization of a query.

AsQueryable(IEnumerable)

IEnumerableIQueryable로 변환합니다.Converts an IEnumerable to an IQueryable.

적용 대상

스레드 보안

GetAllMessages() 메서드는 스레드로부터 안전 합니다.Only the GetAllMessages() method is thread safe.

추가 정보