MessageQueue 생성자

정의

네임스페이스:: System.Messaging

어셈블리:: System.Messaging.dll

중요

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

MessageQueue 클래스의 새 인스턴스를 초기화합니다.

오버로드

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

MessageQueue()

MessageQueue 클래스의 새 인스턴스를 초기화합니다. 매개 변수가 없는 생성자가 새 인스턴스를 초기화한 후 인스턴스를 사용하려면 먼저 인스턴스의 Path 속성을 설정해야 합니다.

public:
 MessageQueue();

public MessageQueue();

Public Sub New ()

예제

다음 코드 예제에서는 새 MessageQueue를 만듭니다.

// Connect to a queue on the local computer. You must set the queue's
// Path property before you can use the queue.
MessageQueue queue = new MessageQueue();
queue.Path = ".\\exampleQueue";

설명

이 오버로드를 사용하여 메시지 큐 서버의 큐에 즉시 연결되지 않은 클래스의 MessageQueue 새 인스턴스를 만듭니다. 이 인스턴스를 사용하기 전에 속성을 설정 Path 하여 기존 메시지 큐에 연결해야 합니다. 또는 메서드의 반환 값에 대한 참조를 Create(String) 설정 MessageQueue 하여 새 메시지 큐 큐를 만들 수 있습니다.

MessageQueue 생성자는 클래스의 MessageQueue 새 인스턴스를 인스턴스화하며 새 메시지 큐 큐를 만들지 않습니다.

다음 표에서는 인스턴스에 대한 초기 속성 값을 보여 줍니다 MessageQueue.

재산	초기 값
DefaultPropertiesToSend	클래스의 매개 변수가 없는 생성자가 설정한 값입니다 DefaultPropertiesToSend .
Formatter	XmlMessageFormatter
MessageReadPropertyFilter	클래스의 매개 변수가 없는 생성자가 설정한 값입니다 MessagePropertyFilter . 모든 필터 값은 .로 `true`설정됩니다.
DenySharedReceive	`false`

추가 정보

적용 대상

MessageQueue(String)

지정된 경로에서 메시지 큐 큐를 참조하는 클래스의 MessageQueue 새 인스턴스를 초기화합니다.

public:
 MessageQueue(System::String ^ path);

public MessageQueue(string path);

new System.Messaging.MessageQueue : string -> System.Messaging.MessageQueue

Public Sub New (path As String)

매개 변수

path: String

에서 MessageQueue참조하는 큐의 위치입니다.

예외

ArgumentException

속성이 Path 설정되지 않았기 때문에 유효하지 않습니다.

예제

다음 코드 예제에서는 다양한 경로 이름 구문 형식을 사용하여 새 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

설명

경로, 형식 이름 또는 레이블을 알고 있는 특정 메시지 큐에 새 MessageQueue 인스턴스를 연결하려는 경우 이 오버로드를 사용합니다. 큐를 참조하는 첫 번째 애플리케이션에 단독 액세스 권한을 부여하려면 속성을 읽기 액세스 제한 매개 변수를 true 전달하는 생성자로 설정 DenySharedReceive 하거나 사용해야 합니다.

MessageQueue 생성자는 클래스의 MessageQueue 새 인스턴스를 인스턴스화하며 새 메시지 큐 큐를 만들지 않습니다. 메시지 큐에서 새 큐를 만들려면 .를 사용합니다 Create(String).

매개 변수의 구문 path 은 다음 표와 같이 참조하는 큐의 형식에 따라 달라집니다.

큐 유형	통사론
공용 큐	`MachineName`\`QueueName`
프라이빗 큐	`MachineName`\`Private$`\`QueueName`
저널 큐	`MachineName`\`QueueName`\`Journal$`
컴퓨터 저널 큐	`MachineName`\`Journal$`
컴퓨터 배달 못 한 편지 큐	`MachineName`\`Deadletter$`
컴퓨터 트랜잭션 배달 못 한 편지 큐	`MachineName`\`XactDeadletter$`

또는 다음 표와 FormatName 같이 큐 경로를 사용하거나 Label 설명할 수 있습니다.

참조	통사론	본보기
형식 이름	`FormatName:` [ 형식 이름 ]	`FormatName:Public=` 5A5F7535-AE9A-41d4-935C-845C2AFF7112 `FormatName:DIRECT=SPX:` `NetworkNumber`; `HostNumber`\`QueueName` `FormatName:DIRECT=TCP:` `IPAddress` \ `QueueName` `FormatName:DIRECT=OS:` `MachineName` \ `QueueName`
레이블	`Label:` [ 레이블 ]	`Label:` TheLabel

오프라인으로 작업하려면 생성자의 경로 이름 구문이 아닌 형식 이름 구문을 사용해야 합니다. 그렇지 않으면 기본 도메인 컨트롤러를 형식 이름의 경로를 확인할 수 없으므로 예외가 throw됩니다.

다음 표에서는 인스턴스에 대한 초기 속성 값을 보여 줍니다 MessageQueue. 이러한 값은 매개 변수로 지정된 경로가 있는 메시지 큐의 속성을 기반으로 합니다 path .

재산	초기 값
Authenticate	`false`
BasePriority	0
Category	Empty
DefaultPropertiesToSend	클래스의 매개 변수가 없는 생성자가 설정한 값입니다 DefaultPropertiesToSend .
EncryptionRequired	`true`메시지 큐의 개인 정보 수준 설정이 "본문"인 경우 그렇지 않으면 . `false`
Formatter	XmlMessageFormatter
Label	Empty
MachineName	메시지 큐의 컴퓨터 이름 속성 값입니다.
MaximumJournalSize	InfiniteQueueSize
MaximumQueueSize	InfiniteQueueSize
MessageReadPropertyFilter	클래스의 매개 변수가 없는 생성자가 설정한 값입니다 MessagePropertyFilter .
Path	Empty생성자에 의해 설정되지 않은 경우
QueueName	Empty생성자에 의해 설정되지 않은 경우
DenySharedReceive	`false`
UseJournalQueue	`true`메시지 큐 개체의 저널 설정을 사용하도록 설정하면 이고, 그렇지 않으면 . `false`

추가 정보

적용 대상

MessageQueue(String, Boolean)

지정된 경로에서 지정된 읽기 액세스 제한을 사용하여 메시지 큐 큐를 참조하는 클래스의 새 인스턴스 MessageQueue 를 초기화합니다.

public:
 MessageQueue(System::String ^ path, bool sharedModeDenyReceive);

public MessageQueue(string path, bool sharedModeDenyReceive);

new System.Messaging.MessageQueue : string * bool -> System.Messaging.MessageQueue

Public Sub New (path As String, sharedModeDenyReceive As Boolean)

매개 변수

path: String

로컬 컴퓨터의 경우 ""일 수 있는 이 MessageQueue큐에서 참조하는 큐의 위치입니다.

sharedModeDenyReceive: Boolean

true큐에 액세스하는 첫 번째 애플리케이션에 대한 단독 읽기 권한을 부여하려면 다음을 실행합니다. 그렇지 않으면 . false

예외

ArgumentException

속성이 Path 설정되지 않았기 때문에 유효하지 않습니다.

예제

다음 코드 예제에서는 단독 액세스 권한이 있는 새 MessageQueue 개체를 만들고, 경로를 설정하고, 메시지를 큐에 보냅니다.

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

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

   // Requests exlusive read access to the queue. If
   // access is granted, receives a message from the 
   // queue.
   void GetExclusiveAccess()
   {
      try
      {
         
         // Request exclusive read access to the queue.
         MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue",true );
         
         // Receive a message. This is where SharingViolation 
         // exceptions would be thrown.
         Message^ myMessage = myQueue->Receive();
      }
      catch ( MessageQueueException^ e ) 
      {
         
         // Handle request for denial of exclusive read access.
         if ( e->MessageQueueErrorCode == MessageQueueErrorCode::SharingViolation )
         {
            Console::WriteLine( "Denied exclusive read access" );
         }

         
         // Handle other sources of a MessageQueueException.
      }

      
      // Handle other exceptions as necessary.
      return;
   }

};


// Provides an entry point into the application.
// This example connects to a message queue, and
// requests exclusive read access to the queue.
int main()
{
   
   // Create a new instance of the class.
   MyNewQueue^ myNewQueue = gcnew MyNewQueue;
   
   // Output the count of Lowest priority messages.
   myNewQueue->GetExclusiveAccess();
   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 connects to a message queue, and
        // requests exclusive read access to the queue.
        //**************************************************

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

            // Output the count of Lowest priority messages.
            GetExclusiveAccess();
                        
            return;
        }

        //**************************************************
        // Requests exlusive read access to the queue. If
        // access is granted, receives a message from the
        // queue.
        //**************************************************
        
        public static void GetExclusiveAccess()
        {
            try
            {
                // Request exclusive read access to the queue.
                MessageQueue myQueue = new
                    MessageQueue(".\\myQueue", true);

                // Receive a message. This is where SharingViolation
                // exceptions would be thrown.
                Message myMessage = myQueue.Receive();
            }
            
            catch (MessageQueueException e)
            {
                // Handle request for denial of exclusive read access.
                if (e.MessageQueueErrorCode ==
                    MessageQueueErrorCode.SharingViolation)
                {
                    Console.WriteLine("Denied exclusive read access");
                }

                // Handle other sources of a MessageQueueException.
            }

            // Handle other exceptions as necessary.

            return;
        }
    }
}

Imports System.Messaging

Public Class MyNewQueue


        ' Provides an entry point into the application.
        '		 
        ' This example connects to a message queue, and
        ' requests exclusive read access to the queue.
 

        Public Shared Sub Main()

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

            ' Output the count of Lowest priority messages.
            myNewQueue.GetExclusiveAccess()

            Return

        End Sub


  
        ' Requests exlusive read access to the queue. If
        ' access is granted, receives a message from the 
        ' queue.
  

        Public Sub GetExclusiveAccess()

            Try

                ' Request exclusive read access to the queue.
                Dim myQueue As New MessageQueue(".\myQueue", True)

                ' Receive a message. This is where a SharingViolation 
                ' exception would be thrown.
                Dim myMessage As Message = myQueue.Receive()

            Catch e As MessageQueueException

                ' Handle request for denial of exclusive read access.
                If e.MessageQueueErrorCode = _
                    MessageQueueErrorCode.SharingViolation Then

                    Console.WriteLine("Denied exclusive read access.")

                End If

                ' Handle other sources of a MessageQueueException.

                ' Handle other exceptions as necessary.

            End Try

            Return

        End Sub

End Class

설명

경로, 형식 이름 또는 레이블을 알고 있는 특정 메시지 큐에 새 MessageQueue 항목을 연결하려는 경우 이 오버로드를 사용합니다. 큐를 참조하는 첫 번째 애플리케이션에 대한 단독 액세스 권한을 부여하려면 매개 변수true를 sharedModeDenyReceive .로 설정합니다. 그렇지 않으면 매개 변수만 path 있는 생성자로 설정 sharedModeDenyReceivefalse 하거나 사용합니다.

설정 sharedModeDenyReceive 은 true 다른 애플리케이션을 포함하여 메시지 큐 큐에 액세스하는 모든 개체에 영향을 줍니다. 매개 변수의 효과는 이 애플리케이션으로 제한되지 않습니다.

MessageQueue 생성자는 클래스의 새 인스턴스를 MessageQueue 만듭니다. 새 메시지 큐를 만들지 않습니다. 메시지 큐에서 새 큐를 만들려면 .를 사용합니다 Create(String).

매개 변수의 구문 path 은 큐 유형에 따라 달라집니다.

큐 유형	통사론
공용 큐	`MachineName`\`QueueName`
프라이빗 큐	`MachineName`\`Private$`\`QueueName`
저널 큐	`MachineName`\`QueueName`\`Journal$`
컴퓨터 저널 큐	`MachineName`\`Journal$`
컴퓨터 배달 못 한 편지 큐	`MachineName`\`Deadletter$`
컴퓨터 트랜잭션 배달 못 한 편지 큐	`MachineName`\`XactDeadletter$`

또는 메시지 큐 큐의 형식 이름 또는 레이블을 사용하여 큐 경로를 설명할 수 있습니다.

참조	통사론	본보기
형식 이름	`FormatName:` [ 형식 이름 ]	`FormatName:Public=` 5A5F7535-AE9A-41d4-935C-845C2AFF7112 `FormatName:DIRECT=SPX:` `NetworkNumber`; `HostNumber`\`QueueName` `FormatName:DIRECT=TCP:` `IPAddress` \ `QueueName` `FormatName:DIRECT=OS:` `MachineName` \ `QueueName`
레이블	`Label:` [ 레이블 ]	`Label:` TheLabel

오프라인으로 작업하려면 이름 구문 대신 형식 이름 구문을 사용해야 합니다. 그렇지 않으면 Active Directory가 있는 기본 도메인 컨트롤러를 형식 이름의 경로를 확인할 수 없으므로 예외가 throw됩니다.

매개 변수가 MessageQueue 설정된 큐를 열면 이후에 큐 sharedModeDenyReceive 에서 읽으려고 하는 큐 MessageQueue 가 공유 위반으로 인해 생성됩니다 MessageQueueExceptiontrue. 또한 다른 MessageQueue 큐가 이미 큐에 대한 비독점 액세스 권한이 있는 동안 전용 모드에서 큐에 액세스하려고 하면 A MessageQueueException 가 throw MessageQueue 됩니다.

다음 표에서는 인스턴스에 대한 초기 속성 값을 보여 줍니다 MessageQueue. 이러한 값은 매개 변수로 지정된 path 경로를 사용하여 메시지 큐의 속성을 기반으로 합니다.

재산	초기 값
Authenticate	`false`;
BasePriority	0.
Category	Empty;
DefaultPropertiesToSend	클래스의 매개 변수가 없는 생성자가 설정한 값입니다 DefaultPropertiesToSend .
EncryptionRequired	`true`메시지 큐의 개인 정보 수준 설정이 "본문"인 경우 그렇지 않으면 . `false`
Formatter	XmlMessageFormatter;
Label	Empty;
MachineName	메시지 큐의 컴퓨터 이름 속성 값입니다.
MaximumJournalSize	InfiniteQueueSize;
MaximumQueueSize	InfiniteQueueSize;
MessageReadPropertyFilter	클래스의 매개 변수가 없는 생성자가 설정한 값입니다 MessagePropertyFilter .
Path	Empty생성자에 의해 설정되지 않은 경우
QueueName	Empty생성자에 의해 설정되지 않은 경우
DenySharedReceive	매개 변수의 값입니다 `sharedModeDenyReceive` .
UseJournalQueue	`true`메시지 큐 개체의 저널 설정을 사용하도록 설정하면 이고, 그렇지 않으면 . `false`

추가 정보

적용 대상

MessageQueue(String, QueueAccessMode)

MessageQueue 클래스의 새 인스턴스를 초기화합니다.

public:
 MessageQueue(System::String ^ path, System::Messaging::QueueAccessMode accessMode);

public MessageQueue(string path, System.Messaging.QueueAccessMode accessMode);

new System.Messaging.MessageQueue : string * System.Messaging.QueueAccessMode -> System.Messaging.MessageQueue

Public Sub New (path As String, accessMode As QueueAccessMode)

매개 변수

path: String

로컬 컴퓨터의 경우 ""일 수 있는 이 MessageQueue큐에서 참조하는 큐의 위치입니다.

accessMode: QueueAccessMode

값 중 QueueAccessMode 하나입니다.

적용 대상

MessageQueue(String, Boolean, Boolean)

MessageQueue 클래스의 새 인스턴스를 초기화합니다.

public:
 MessageQueue(System::String ^ path, bool sharedModeDenyReceive, bool enableCache);

public MessageQueue(string path, bool sharedModeDenyReceive, bool enableCache);

new System.Messaging.MessageQueue : string * bool * bool -> System.Messaging.MessageQueue

Public Sub New (path As String, sharedModeDenyReceive As Boolean, enableCache As Boolean)

매개 변수

path: String

로컬 컴퓨터의 경우 ""일 수 있는 이 MessageQueue큐에서 참조하는 큐의 위치입니다.

sharedModeDenyReceive: Boolean

true큐에 액세스하는 첫 번째 애플리케이션에 대한 단독 읽기 권한을 부여하려면 다음을 실행합니다. 그렇지 않으면 . false

enableCache: Boolean

true연결 캐시를 만들고 사용하려면 그렇지 않으면 . false

예제

다음 코드 예제에서는 단독 읽기 액세스 및 연결 캐싱을 사용하도록 설정된 새 MessageQueue 개체를 만듭니다.

// Connect to a queue on the local computer, grant exclusive read
// access to the first application that accesses the queue, and
// enable connection caching.
MessageQueue^ queue = gcnew MessageQueue(".\\exampleQueue", true, true);

queue->Close();

// Connect to a queue on the local computer, grant exclusive read
// access to the first application that accesses the queue, and
// enable connection caching.
MessageQueue queue = new MessageQueue(".\\exampleQueue", true, true);

적용 대상

MessageQueue(String, Boolean, Boolean, QueueAccessMode)

MessageQueue 클래스의 새 인스턴스를 초기화합니다.

public:
 MessageQueue(System::String ^ path, bool sharedModeDenyReceive, bool enableCache, System::Messaging::QueueAccessMode accessMode);

public MessageQueue(string path, bool sharedModeDenyReceive, bool enableCache, System.Messaging.QueueAccessMode accessMode);

new System.Messaging.MessageQueue : string * bool * bool * System.Messaging.QueueAccessMode -> System.Messaging.MessageQueue

Public Sub New (path As String, sharedModeDenyReceive As Boolean, enableCache As Boolean, accessMode As QueueAccessMode)

매개 변수

path: String

로컬 컴퓨터의 경우 ""일 수 있는 이 MessageQueue큐에서 참조하는 큐의 위치입니다.

sharedModeDenyReceive: Boolean

true큐에 액세스하는 첫 번째 애플리케이션에 대한 단독 읽기 권한을 부여하려면 다음을 실행합니다. 그렇지 않으면 . false

enableCache: Boolean

true연결 캐시를 만들고 사용하려면 그렇지 않으면 . false

accessMode: QueueAccessMode

값 중 QueueAccessMode 하나입니다.

적용 대상

피드백

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

다음을 통해 공유

MessageQueue 생성자

정의

오버로드

MessageQueue()

예제

설명

추가 정보

적용 대상

MessageQueue(String)

매개 변수

예외

예제

설명

추가 정보

적용 대상

MessageQueue(String, Boolean)

매개 변수

예외

예제

설명

추가 정보

적용 대상

MessageQueue(String, QueueAccessMode)

매개 변수

적용 대상

MessageQueue(String, Boolean, Boolean)

매개 변수

예제

적용 대상

MessageQueue(String, Boolean, Boolean, QueueAccessMode)

매개 변수

적용 대상

피드백