MessageQueue Konstruktory

Odwołanie

Definicja

Przestrzeń nazw:: System.Messaging

Zestaw:: System.Messaging.dll

Ważne

Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.

Inicjuje nowe wystąpienie klasy MessageQueue.

Przeciążenia

MessageQueue()	Inicjuje nowe wystąpienie klasy MessageQueue. Gdy konstruktor bez parametrów inicjuje nowe wystąpienie, należy ustawić właściwość wystąpienia Path przed użyciem wystąpienia.
MessageQueue(String)	Inicjuje MessageQueue nowe wystąpienie klasy odwołującej się do kolejki kolejki kolejkowania komunikatów w określonej ścieżce.
MessageQueue(String, Boolean)	Inicjuje nowe wystąpienie MessageQueue klasy, które odwołuje się do kolejki kolejki kolejki komunikatów w określonej ścieżce i z określonym ograniczeniem dostępu do odczytu.
MessageQueue(String, QueueAccessMode)	Inicjuje nowe wystąpienie klasy MessageQueue.
MessageQueue(String, Boolean, Boolean)	Inicjuje nowe wystąpienie klasy MessageQueue.
MessageQueue(String, Boolean, Boolean, QueueAccessMode)	Inicjuje nowe wystąpienie klasy MessageQueue.

MessageQueue()

Inicjuje nowe wystąpienie klasy MessageQueue. Gdy konstruktor bez parametrów inicjuje nowe wystąpienie, należy ustawić właściwość wystąpienia Path przed użyciem wystąpienia.

public:
 MessageQueue();

public MessageQueue ();

Public Sub New ()

Przykłady

Poniższy przykład kodu tworzy nowy MessageQueueelement .

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

Uwagi

Użyj tego przeciążenia, aby utworzyć nowe wystąpienie MessageQueue klasy, która nie jest natychmiast powiązana z kolejką na serwerze kolejkowania komunikatów. Przed użyciem tego wystąpienia należy połączyć go z istniejącą kolejką kolejki kolejkowania komunikatów, ustawiając Path właściwość . Alternatywnie można ustawić MessageQueue odwołanie do Create(String) wartości zwracanej metody, tworząc w ten sposób nową kolejkę kolejkowania komunikatów.

Konstruktor MessageQueue tworzy wystąpienie nowej klasy MessageQueue ; nie tworzy nowej kolejki kolejki kolejkowania komunikatów.

W poniższej tabeli przedstawiono początkowe wartości właściwości dla wystąpienia klasy MessageQueue.

Właściwość	Wartość początkowa
DefaultPropertiesToSend	Wartości ustawione przez konstruktora bez parametrów DefaultPropertiesToSend klasy.
Formatter	XmlMessageFormatter
MessageReadPropertyFilter	Wartości ustawione przez konstruktora bez parametrów MessagePropertyFilter klasy. Wszystkie wartości filtru są ustawione na `true`wartość .
DenySharedReceive	`false`

Zobacz też

Dotyczy

MessageQueue(String)

Inicjuje MessageQueue nowe wystąpienie klasy odwołującej się do kolejki kolejki kolejkowania komunikatów w określonej ścieżce.

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

public MessageQueue (string path);

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

Public Sub New (path As String)

Parametry

path: String

Lokalizacja kolejki, do których odwołuje się ten MessageQueueelement .

Wyjątki

ArgumentException

Właściwość jest nieprawidłowa Path , prawdopodobnie dlatego, że nie została ustawiona.

Przykłady

Poniższy przykład kodu tworzy nowe MessageQueue obiekty przy użyciu różnych typów składni nazw ścieżek. W każdym przypadku wysyła komunikat do kolejki, której ścieżka jest zdefiniowana w konstruktorze.

#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

Uwagi

Użyj tego przeciążenia, jeśli chcesz powiązać nowe MessageQueue wystąpienie z określoną kolejką kolejkowania komunikatów, dla której znasz ścieżkę, nazwę formatu lub etykietę. Jeśli chcesz udzielić wyłącznego dostępu do pierwszej aplikacji, która odwołuje się do kolejki, musisz ustawić DenySharedReceive właściwość na true lub użyć konstruktora, który przekazuje parametr ograniczenia dostępu do odczytu.

Konstruktor MessageQueue tworzy wystąpienie nowej klasy MessageQueue ; nie tworzy nowej kolejki kolejki kolejkowania komunikatów. Aby utworzyć nową kolejkę w kolejce komunikatów, użyj polecenia Create(String).

Składnia parametru path zależy od typu kolejki, do których odwołuje się, jak pokazano w poniższej tabeli.

Typ kolejki	Składnia
Kolejka publiczna	`MachineName`\`QueueName`
Kolejka prywatna	`MachineName`\`Private$`\`QueueName`
kolejka Dziennik	`MachineName`\`QueueName`\`Journal$`
Kolejka dziennika maszynowego	`MachineName`\`Journal$`
Kolejka utraconych komunikatów maszynowych	`MachineName`\`Deadletter$`
Kolejka utraconych komunikatów maszyny	`MachineName`\`XactDeadletter$`

Alternatywnie możesz użyć elementu FormatName lub Label , aby opisać ścieżkę kolejki, jak pokazano w poniższej tabeli.

Odwołanie	Składnia	Przykład
Nazwa formatu	`FormatName:` [ nazwa formatu ]	`FormatName:Public=` 5A5F7535-AE9A-41d4-935C-845C2AFF7112 `FormatName:DIRECT=SPX:NetworkNumber`; `HostNumber`\`QueueName` `FormatName:DIRECT=TCP:` `IPAddress`\`QueueName` `FormatName:DIRECT=OS:` `MachineName`\`QueueName`
Etykieta	`Label:` [ etykieta ]	`Label:` TheLabel

Aby pracować w trybie offline, należy użyć składni nazwy formatu, a nie składni nazwy ścieżki dla konstruktora. W przeciwnym razie zgłaszany jest wyjątek, ponieważ podstawowy kontroler domeny nie jest dostępny, aby rozpoznać ścieżkę do nazwy formatu.

W poniższej tabeli przedstawiono początkowe wartości właściwości dla wystąpienia klasy MessageQueue. Te wartości są oparte na właściwościach kolejki kolejkowania komunikatów ze ścieżką path określoną przez parametr .

Właściwość	Wartość początkowa
Authenticate	`false`
BasePriority	0
Category	Empty
DefaultPropertiesToSend	Wartości ustawione przez konstruktora bez parametrów DefaultPropertiesToSend klasy.
EncryptionRequired	`true`, jeśli ustawienie poziomu prywatności kolejki kolejki kolejki komunikatów ma wartość "Treść"; w przeciwnym razie , `false`.
Formatter	XmlMessageFormatter
Label	Empty
MachineName	Wartość właściwości nazwa komputera kolejki komunikatów.
MaximumJournalSize	InfiniteQueueSize
MaximumQueueSize	InfiniteQueueSize
MessageReadPropertyFilter	Wartości ustawione przez konstruktora bez parametrów MessagePropertyFilter klasy.
Path	Empty, jeśli nie zostanie ustawiona przez konstruktora.
QueueName	Empty, jeśli nie zostanie ustawiona przez konstruktora.
DenySharedReceive	`false`
UseJournalQueue	`true`, jeśli ustawienie dziennika obiektu kolejkowania komunikatów jest włączone; w przeciwnym razie , `false`.

Zobacz też

Dotyczy

MessageQueue(String, Boolean)

Inicjuje MessageQueue nowe wystąpienie klasy odwołującej się do kolejki kolejki kolejkowania komunikatów w określonej ścieżce i z określonym ograniczeniem dostępu do odczytu.

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)

Parametry

path: String

Lokalizacja kolejki, do której odwołuje się ten MessageQueueobiekt , który może być "." dla komputera lokalnego.

sharedModeDenyReceive: Boolean

true przyznać wyłączny dostęp do odczytu do pierwszej aplikacji, która uzyskuje dostęp do kolejki; w przeciwnym razie , false.

Wyjątki

ArgumentException

Właściwość jest nieprawidłowa Path , prawdopodobnie dlatego, że nie została ustawiona.

Przykłady

Poniższy przykład kodu tworzy nowy MessageQueue z wyłącznym dostępem, ustawia ścieżkę i wysyła komunikat do kolejki.

#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

Uwagi

Użyj tego przeciążenia, jeśli chcesz powiązać nowe MessageQueue z określoną kolejką kolejkowania komunikatów, dla której znasz ścieżkę, nazwę formatu lub etykietę. Jeśli chcesz udzielić wyłącznego dostępu do pierwszej aplikacji, która odwołuje się do kolejki, ustaw sharedModeDenyReceive parametr na true. W przeciwnym razie ustaw sharedModeDenyReceive wartość false lub użyj konstruktora, który ma tylko path parametr.

Ustawienie sharedModeDenyReceive ma true wpływ na wszystkie obiekty, które uzyskują dostęp do kolejki kolejkowania komunikatów, w tym innych aplikacji. Efekty parametru nie są ograniczone do tej aplikacji.

Konstruktor MessageQueue tworzy nowe wystąpienie MessageQueue klasy ; nie tworzy nowej kolejki kolejki kolejkowania komunikatów. Aby utworzyć nową kolejkę w kolejce komunikatów, użyj polecenia Create(String).

Składnia parametru path zależy od typu kolejki.

Typ kolejki	Składnia
Kolejka publiczna	`MachineName`\`QueueName`
Kolejka prywatna	`MachineName`\`Private$`\`QueueName`
kolejka Dziennik	`MachineName`\`QueueName`\`Journal$`
Kolejka dziennika maszynowego	`MachineName`\`Journal$`
Kolejka utraconych komunikatów maszynowych	`MachineName`\`Deadletter$`
Kolejka utraconych komunikatów maszyny	`MachineName`\`XactDeadletter$`

Alternatywnie możesz użyć nazwy formatu lub etykiety kolejki kolejkowania komunikatów, aby opisać ścieżkę kolejki.

Odwołanie	Składnia	Przykład
Nazwa formatu	`FormatName:` [ nazwa formatu ]	`FormatName:Public=` 5A5F7535-AE9A-41d4-935C-845C2AFF7112 `FormatName:DIRECT=SPX:NetworkNumber`; `HostNumber`\`QueueName` `FormatName:DIRECT=TCP:` `IPAddress`\`QueueName` `FormatName:DIRECT=OS:` `MachineName`\`QueueName`
Etykieta	`Label:` [ etykieta ]	`Label:` TheLabel

Aby pracować w trybie offline, należy użyć składni nazwy formatu, a nie przyjaznej składni nazw. W przeciwnym razie zgłaszany jest wyjątek, ponieważ podstawowy kontroler domeny (na którym znajduje się usługa Active Directory) nie jest dostępny, aby rozpoznać ścieżkę do nazwy formatu.

Jeśli kolejka MessageQueue zostanie otwarta z ustawionym parametrem sharedModeDenyReceive na truewartość , każda MessageQueue , która następnie próbuje odczytać z kolejki, generuje MessageQueueException element z powodu naruszenia udostępniania. Wartość A MessageQueueException jest również zgłaszana, jeśli MessageQueue próbuje uzyskać dostęp do kolejki w trybie wyłącznym, podczas gdy inny MessageQueue ma już nie wyłączny dostęp do kolejki.

Właściwość	Wartość początkowa
Authenticate	`false`.
BasePriority	0.
Category	Empty.
DefaultPropertiesToSend	Wartości ustawione przez konstruktora bez parametrów DefaultPropertiesToSend klasy.
EncryptionRequired	`true`, jeśli ustawienie poziomu prywatności kolejki komunikatów ma wartość "Treść"; w przeciwnym razie , `false`.
Formatter	XmlMessageFormatter.
Label	Empty.
MachineName	Wartość właściwości nazwa komputera kolejki kolejki kolejki komunikatów.
MaximumJournalSize	InfiniteQueueSize.
MaximumQueueSize	InfiniteQueueSize.
MessageReadPropertyFilter	Wartości ustawione przez konstruktora bez parametrów MessagePropertyFilter klasy.
Path	Empty, jeśli nie zostanie ustawiona przez konstruktora.
QueueName	Empty, jeśli nie zostanie ustawiona przez konstruktora.
DenySharedReceive	Wartość parametru `sharedModeDenyReceive` .
UseJournalQueue	`true`, jeśli ustawienie dziennika obiektu kolejkowania komunikatów jest włączone; w przeciwnym razie , `false`.

Zobacz też

Dotyczy

MessageQueue(String, QueueAccessMode)

Inicjuje nowe wystąpienie klasy 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)

Parametry

path: String

Lokalizacja kolejki, do której odwołuje się ten MessageQueueobiekt , który może być "." dla komputera lokalnego.

accessMode: QueueAccessMode

Jedna z QueueAccessMode wartości.

Dotyczy

MessageQueue(String, Boolean, Boolean)

Inicjuje nowe wystąpienie klasy 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)

Parametry

path: String

Lokalizacja kolejki, do której odwołuje się ten MessageQueueobiekt , który może być "." dla komputera lokalnego.

sharedModeDenyReceive: Boolean

true przyznać wyłączny dostęp do odczytu do pierwszej aplikacji, która uzyskuje dostęp do kolejki; w przeciwnym razie , false.

enableCache: Boolean

true do tworzenia i używania pamięci podręcznej połączeń; w przeciwnym razie , false.

Przykłady

Poniższy przykład kodu tworzy nowy MessageQueue z wyłącznym dostępem do odczytu i włączonym buforowaniem połączeń.

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

Dotyczy

MessageQueue(String, Boolean, Boolean, QueueAccessMode)

Inicjuje nowe wystąpienie klasy 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)

Parametry

path: String

Lokalizacja kolejki, do której odwołuje się ten MessageQueueobiekt , który może być "." dla komputera lokalnego.

sharedModeDenyReceive: Boolean

true przyznać wyłączny dostęp do odczytu do pierwszej aplikacji, która uzyskuje dostęp do kolejki; w przeciwnym razie , false.

enableCache: Boolean

true do tworzenia i używania pamięci podręcznej połączeń; w przeciwnym razie , false.

accessMode: QueueAccessMode

Jedna z QueueAccessMode wartości.

Dotyczy

MessageQueue Konstruktory

Definicja

Przeciążenia

MessageQueue()

Przykłady

Uwagi

Zobacz też

Dotyczy

MessageQueue(String)

Parametry

Wyjątki

Przykłady

Uwagi

Zobacz też

Dotyczy

MessageQueue(String, Boolean)

Parametry

Wyjątki

Przykłady

Uwagi

Zobacz też

Dotyczy

MessageQueue(String, QueueAccessMode)

Parametry

Dotyczy

MessageQueue(String, Boolean, Boolean)

Parametry

Przykłady

Dotyczy

MessageQueue(String, Boolean, Boolean, QueueAccessMode)

Parametry

Dotyczy

Opinia

Dodatkowe zasoby