MessageQueue 생성자
정의
중요
일부 정보는 릴리스되기 전에 상당 부분 수정될 수 있는 시험판 제품과 관련이 있습니다. Microsoft는 여기에 제공된 정보에 대해 어떠한 명시적이거나 묵시적인 보증도 하지 않습니다.
MessageQueue 클래스의 새 인스턴스를 초기화합니다.
오버로드
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 새 instance 만듭니다. 이 instance 사용하기 전에 속성을 설정 Path 하여 기존 메시지 큐 큐에 연결해야 합니다. 또는 메서드의 반환 값에 MessageQueue 대한 참조를 Create(String) 설정하여 새 메시지 큐 큐를 만들 수 있습니다.
MessageQueue 생성자는 클래스의 MessageQueue 새 instance 인스턴스화합니다. 새 메시지 큐 큐는 만들지 않습니다.
다음 표에서 인스턴스에 대 한 초기 속성 값을 보여 줍니다. 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가 참조하는 큐의 위치입니다.
예외
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 instance 연결하려는 경우 이 오버로드를 사용합니다. 큐를 참조 하는 첫 번째 애플리케이션에 대 한 배타적 액세스 권한을 부여 하려는 경우 설정 해야 합니다는 DenySharedReceive 속성을 true
또는 읽기 액세스 제한 매개 변수를 전달 하는 생성자를 사용 합니다.
MessageQueue 생성자는 클래스의 MessageQueue 새 instance 인스턴스화합니다. 새 메시지 큐 큐는 만들지 않습니다. 메시지 큐에서 새 큐를 만들려면 를 사용합니다 Create(String).
매개 변수의 구문 path
은 다음 표와 같이 참조하는 큐의 형식에 따라 달라집니다.
큐 유형 | Syntax |
---|---|
공개 큐 | MachineName \QueueName |
개인 큐 | MachineName \Private$ \QueueName |
저널 큐 | MachineName \QueueName \Journal$ |
컴퓨터 저널 큐 | MachineName \Journal$ |
컴퓨터 배달 못 한 편지 큐 | MachineName \Deadletter$ |
컴퓨터 트랜잭션 배달 못 한 편지 큐 | MachineName \XactDeadletter$ |
또는 다음 표와 FormatName 같이 또는 Label 을 사용하여 큐 경로를 설명할 수 있습니다.
참조 | 구문 | 예제 |
---|---|---|
형식 이름 | FormatName: [ 형식 이름 ] |
FormatName:Public= 5A5F7535-AE9A-41d4-935C-845C2AFF7112FormatName:DIRECT=SPX: NetworkNumber ; HostNumber \QueueName FormatName:DIRECT=TCP: IPAddress \QueueName FormatName:DIRECT=OS: MachineName \QueueName |
레이블 | Label: [ label ] |
Label: TheLabel |
오프라인으로 작업하려면 생성자의 경로 이름 구문이 아닌 형식 이름 구문을 사용해야 합니다. 그렇지 않으면 기본 도메인 컨트롤러를 형식 이름의 경로를 resolve 수 없으므로 예외가 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
입니다.
예외
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 를 연결하려는 경우 이 오버로드를 사용합니다. 큐를 참조 하는 첫 번째 애플리케이션에 대 한 배타적 액세스 권한을 부여 하려는 경우, 설정 된 sharedModeDenyReceive
매개 변수를 true
입니다. 그렇지 않으면 매개 변수만 path
있는 생성자를 로 false
설정 sharedModeDenyReceive
하거나 사용합니다.
설정 sharedModeDenyReceive
에 true
메시지 큐를 다른 애플리케이션을 포함 하 여 액세스 하는 모든 개체에 영향을 줍니다. 매개 변수의 효과이 애플리케이션에 제한 되지 않습니다.
MessageQueue 생성자는 클래스의 MessageQueue 새 instance 만듭니다. 새 메시지 큐 큐를 만들지 않습니다. 메시지 큐에서 새 큐를 만들려면 를 사용합니다 Create(String).
매개 변수의 구문 path
은 큐 유형에 따라 달라집니다.
큐 유형 | Syntax |
---|---|
공개 큐 | MachineName \QueueName |
개인 큐 | MachineName \Private$ \QueueName |
저널 큐 | MachineName \QueueName \Journal$ |
컴퓨터 저널 큐 | MachineName \Journal$ |
컴퓨터 배달 못 한 편지 큐 | MachineName \Deadletter$ |
컴퓨터 트랜잭션 배달 못 한 편지 큐 | MachineName \XactDeadletter$ |
또는 메시지 큐 큐의 형식 이름 또는 레이블을 사용하여 큐 경로를 설명할 수 있습니다.
참조 | 구문 | 예제 |
---|---|---|
형식 이름 | FormatName: [ 형식 이름 ] |
FormatName:Public= 5A5F7535-AE9A-41d4-935C-845C2AFF7112FormatName:DIRECT=SPX: NetworkNumber ; HostNumber \QueueName FormatName:DIRECT=TCP: IPAddress \QueueName FormatName:DIRECT=OS: MachineName \QueueName |
레이블 | Label: [ label ] |
Label: TheLabel |
오프라인으로 작업하려면 이름 구문 대신 형식 이름 구문을 사용해야 합니다. 그렇지 않으면 기본 도메인 컨트롤러(Active Directory가 있는)를 형식 이름의 경로를 resolve 수 없으므로 예외가 throw됩니다.
MessageQueue 가 매개 변수가 로 sharedModeDenyReceive
설정된 true
큐를 열면 이후에 큐에서 읽으려고 시도하는 모든 MessageQueue 큐는 공유 위반으로 인해 을 생성합니다MessageQueueException. MessageQueueException 또한 가 배타적 모드에서 MessageQueue 큐에 액세스하려고 하는 반면 다른 MessageQueue 큐에는 이미 비독점 액세스 권한이 있는 경우에도 이 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 | 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 값 중 하나입니다.
적용 대상
.NET
피드백
https://aka.ms/ContentUserFeedback
출시 예정: 2024년 내내 콘텐츠에 대한 피드백 메커니즘으로 GitHub 문제를 단계적으로 폐지하고 이를 새로운 피드백 시스템으로 바꿀 예정입니다. 자세한 내용은 다음을 참조하세요.다음에 대한 사용자 의견 제출 및 보기