MessageQueue Konstruktory

Reference

Definice

Obor názvů:: System.Messaging

Sestavení:: System.Messaging.dll

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

Inicializuje novou instanci MessageQueue třídy .

Přetížení

MessageQueue()	Inicializuje novou instanci MessageQueue třídy. Jakmile konstruktor bez parametrů inicializuje novou instanci, musíte před použitím instance nastavit vlastnost instance Path .
MessageQueue(String)	Inicializuje novou instanci MessageQueue třídy, která odkazuje na frontu služby Řízení front zpráv v zadané cestě.
MessageQueue(String, Boolean)	Inicializuje novou instanci MessageQueue třídy, která odkazuje na frontu služby Řízení front zpráv v zadané cestě a se zadaným omezením přístupu pro čtení.
MessageQueue(String, QueueAccessMode)	Inicializuje novou instanci MessageQueue třídy.
MessageQueue(String, Boolean, Boolean)	Inicializuje novou instanci MessageQueue třídy.
MessageQueue(String, Boolean, Boolean, QueueAccessMode)	Inicializuje novou instanci MessageQueue třídy.

MessageQueue()

Inicializuje novou instanci MessageQueue třídy. Jakmile konstruktor bez parametrů inicializuje novou instanci, musíte před použitím instance nastavit vlastnost instance Path .

public:
 MessageQueue();

public MessageQueue ();

Public Sub New ()

Příklady

Následující příklad kódu vytvoří nový 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";

Poznámky

Toto přetížení použijte k vytvoření nové instance MessageQueue třídy, která není okamžitě svázána s frontou na serveru služby Řízení front zpráv. Před použitím této instance ji musíte připojit k existující frontě služby Řízení front zpráv nastavením Path vlastnosti . Případně můžete nastavit odkaz na MessageQueue Create(String) návratovou hodnotu metody a vytvořit tak novou frontu služby Řízení front zpráv.

Konstruktor MessageQueue vytvoří instanci nové instance MessageQueue třídy; nevytvoří novou frontu služby Řízení front zpráv.

Následující tabulka obsahuje počáteční hodnoty vlastností pro instanci .MessageQueue

Vlastnost	Počáteční hodnota
DefaultPropertiesToSend	Hodnoty nastavené konstruktorem DefaultPropertiesToSend třídy bez parametrů.
Formatter	XmlMessageFormatter
MessageReadPropertyFilter	Hodnoty nastavené konstruktorem MessagePropertyFilter třídy bez parametrů. Všechny hodnoty filtru jsou nastaveny na `true`.
DenySharedReceive	`false`

Viz také

Platí pro

MessageQueue(String)

Inicializuje novou instanci MessageQueue třídy, která odkazuje na frontu služby Řízení front zpráv v zadané cestě.

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

Umístění fronty, na kterou odkazuje tento MessageQueue.

Výjimky

ArgumentException

Vlastnost Path není platná, pravděpodobně proto, že nebyla nastavena.

Příklady

Následující příklad kódu vytvoří nové MessageQueue objekty pomocí různých typů syntaxe názvů cest. V každém případě odešle zprávu do fronty, jejíž cesta je definována v konstruktoru.

#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

Poznámky

Toto přetížení použijte, pokud chcete novou MessageQueue instanci svázat s konkrétní frontou služby Řízení front zpráv, pro kterou znáte cestu, název formátu nebo popisek. Pokud chcete udělit výhradní přístup první aplikaci, která odkazuje na frontu DenySharedReceive , musíte nastavit vlastnost na true nebo použít konstruktor, který předává parametr omezení přístupu pro čtení.

Konstruktor MessageQueue vytvoří instanci nové instance MessageQueue třídy; nevytvoří novou frontu služby Řízení front zpráv. Pokud chcete vytvořit novou frontu ve službě Řízení front zpráv, použijte Create(String).

Syntaxe parametru path závisí na typu fronty, na který odkazuje, jak je znázorněno v následující tabulce.

Typ fronty	Syntax
Veřejná fronta	`MachineName`\`QueueName`
Soukromá fronta	`MachineName`\`Private$`\`QueueName`
Deník fronta	`MachineName`\`QueueName`\`Journal$`
Fronta deníku počítače	`MachineName`\`Journal$`
Fronta nedoručených zpráv počítače	`MachineName`\`Deadletter$`
Fronta nedoručených zpráv na počítači	`MachineName`\`XactDeadletter$`

Případně můžete k popisu cesty fronty použít FormatName nebo Label , jak je znázorněno v následující tabulce.

Reference	Syntax	Příklad
Název formátu	`FormatName:` [ název formátu ]	`FormatName:Public=` 5A5F7535-AE9A-41d4-935C-845C2AFF7112 `FormatName:DIRECT=SPX:NetworkNumber`; `HostNumber`\`QueueName` `FormatName:DIRECT=TCP:` `IPAddress`\`QueueName` `FormatName:DIRECT=OS:` `MachineName`\`QueueName`
Popisek	`Label:` [ popisek ]	`Label:` Popisek

Pokud chcete pracovat offline, musíte použít syntaxi názvu formátu, nikoli syntaxi názvu cesty konstruktoru. V opačném případě dojde k výjimce, protože primární řadič domény není k dispozici pro překlad cesty k názvu formátu.

Následující tabulka obsahuje počáteční hodnoty vlastností pro instanci .MessageQueue Tyto hodnoty jsou založeny na vlastnostech fronty služby Řízení front zpráv s cestou určenou parametrem path .

Vlastnost	Počáteční hodnota
Authenticate	`false`
BasePriority	0
Category	Empty
DefaultPropertiesToSend	Hodnoty nastavené konstruktorem DefaultPropertiesToSend třídy bez parametrů.
EncryptionRequired	`true`, pokud je nastavení úrovně ochrany osobních údajů fronty služby Řízení front zpráv "Text"; v opačném případě . `false`
Formatter	XmlMessageFormatter
Label	Empty
MachineName	Hodnota vlastnosti názvu počítače fronty služby Řízení front zpráv.
MaximumJournalSize	InfiniteQueueSize
MaximumQueueSize	InfiniteQueueSize
MessageReadPropertyFilter	Hodnoty nastavené konstruktorem MessagePropertyFilter třídy bez parametrů.
Path	Empty, pokud není nastaven konstruktorem.
QueueName	Empty, pokud není nastaven konstruktorem.
DenySharedReceive	`false`
UseJournalQueue	`true`, pokud je povoleno nastavení deníku služby Řízení front zpráv; v opačném případě . `false`

Viz také

Platí pro

MessageQueue(String, Boolean)

Inicializuje novou instanci MessageQueue třídy, která odkazuje na frontu služby Řízení front zpráv v zadané cestě a se zadaným omezením přístupu pro čtení.

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

Umístění fronty, na kterou odkazuje tento MessageQueueobjekt , který může být "." pro místní počítač.

sharedModeDenyReceive: Boolean

trueudělit výhradní přístup pro čtení první aplikaci, která přistupuje k frontě; v opačném případě . false

Výjimky

ArgumentException

Vlastnost Path není platná, pravděpodobně proto, že nebyla nastavena.

Příklady

Následující příklad kódu vytvoří nový MessageQueue s výhradním přístupem, nastaví jeho cestu a odešle zprávu do fronty.

#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

Poznámky

Toto přetížení použijte, pokud chcete nový MessageQueue svázat s konkrétní frontou služby Řízení front zpráv, pro kterou znáte cestu, název formátu nebo popisek. Pokud chcete udělit výhradní přístup první aplikaci, která odkazuje na frontu, nastavte sharedModeDenyReceive parametr na true. V opačném případě nastavte sharedModeDenyReceivefalse nebo použijte konstruktor, který má pouze path parametr.

Nastavení sharedModeDenyReceive má vliv na true všechny objekty, které přistupují k frontě služby Řízení front zpráv, včetně jiných aplikací. Účinky parametru nejsou omezeny na tuto aplikaci.

Konstruktor MessageQueue vytvoří novou instanci MessageQueue třídy; nevytvoří novou frontu služby Řízení front zpráv. Pokud chcete vytvořit novou frontu ve službě Řízení front zpráv, použijte Create(String).

Syntaxe parametru path závisí na typu fronty.

Typ fronty	Syntax
Veřejná fronta	`MachineName`\`QueueName`
Soukromá fronta	`MachineName`\`Private$`\`QueueName`
Deník fronta	`MachineName`\`QueueName`\`Journal$`
Fronta deníku počítače	`MachineName`\`Journal$`
Fronta nedoručených zpráv počítače	`MachineName`\`Deadletter$`
Fronta nedoručených zpráv na počítači	`MachineName`\`XactDeadletter$`

Případně můžete použít název formátu nebo popisek fronty služby Řízení front zpráv k popisu cesty fronty.

Reference	Syntax	Příklad
Název formátu	`FormatName:` [ název formátu ]	`FormatName:Public=` 5A5F7535-AE9A-41d4-935C-845C2AFF7112 `FormatName:DIRECT=SPX:NetworkNumber`; `HostNumber`\`QueueName` `FormatName:DIRECT=TCP:` `IPAddress`\`QueueName` `FormatName:DIRECT=OS:` `MachineName`\`QueueName`
Popisek	`Label:` [ popisek ]	`Label:` Popisek

Pokud chcete pracovat offline, musíte místo popisné syntaxe názvů použít syntaxi názvu formátu. Jinak dojde k výjimce, protože primární řadič domény (na kterém je umístěná služba Active Directory) není k dispozici pro překlad cesty k názvu formátu.

MessageQueue Pokud otevře frontu s parametrem sharedModeDenyReceive nastaveným na true, všechnyMessageQueue, které se následně pokusí číst z fronty, vygenerují MessageQueueException kvůli narušení sdílení . Vyvolá MessageQueueException se také v případě, že MessageQueue se někdo pokusí o přístup k frontě ve výhradním režimu, zatímco jiný MessageQueue už má k frontě nevýhradní přístup.

Následující tabulka uvádí počáteční hodnoty vlastností pro instanci .MessageQueue Tyto hodnoty jsou založeny na vlastnostech fronty služby Řízení front zpráv s cestou určenou parametrem path .

Vlastnost	Počáteční hodnota
Authenticate	`false`.
BasePriority	0.
Category	Empty.
DefaultPropertiesToSend	Hodnoty nastavené konstruktorem DefaultPropertiesToSend třídy bez parametrů.
EncryptionRequired	`true`, pokud je nastavení úrovně ochrany osobních údajů fronty služby Řízení front zpráv "Text"; v opačném případě . `false`
Formatter	XmlMessageFormatter.
Label	Empty.
MachineName	Hodnota vlastnosti počítače fronty služby Řízení front zpráv.
MaximumJournalSize	InfiniteQueueSize.
MaximumQueueSize	InfiniteQueueSize.
MessageReadPropertyFilter	Hodnoty nastavené konstruktorem MessagePropertyFilter třídy bez parametrů.
Path	Empty, pokud není nastaven konstruktorem.
QueueName	Empty, pokud není nastaven konstruktorem.
DenySharedReceive	Hodnota parametru `sharedModeDenyReceive` .
UseJournalQueue	`true`, pokud řízení front zpráv nastavení deníku objektu je povoleno; v opačném případě . `false`

Viz také

Platí pro

MessageQueue(String, QueueAccessMode)

Inicializuje novou instanci MessageQueue třídy .

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

Umístění fronty, na kterou odkazuje tato MessageQueue, která může být pro místní počítač "."

accessMode: QueueAccessMode

Jedna z QueueAccessMode hodnot.

Platí pro

MessageQueue(String, Boolean, Boolean)

Inicializuje novou instanci MessageQueue třídy .

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

Umístění fronty, na kterou odkazuje tato MessageQueue, která může být pro místní počítač "."

sharedModeDenyReceive: Boolean

trueudělit výhradní přístup pro čtení první aplikaci, která přistupuje k frontě; v opačném případě . false

enableCache: Boolean

truevytvoření a použití mezipaměti připojení; v opačném případě . false

Příklady

Následující příklad kódu vytvoří nový MessageQueue s výhradním přístupem pro čtení a s povoleným ukládáním připojení do mezipaměti.

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

Platí pro

MessageQueue(String, Boolean, Boolean, QueueAccessMode)

Inicializuje novou instanci MessageQueue třídy .

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

Umístění fronty, na kterou odkazuje tato MessageQueue, která může být pro místní počítač "."

sharedModeDenyReceive: Boolean

trueudělit výhradní přístup pro čtení první aplikaci, která přistupuje k frontě; v opačném případě . false

enableCache: Boolean

truevytvoření a použití mezipaměti připojení; v opačném případě . false

accessMode: QueueAccessMode

Jedna z QueueAccessMode hodnot.

Platí pro

MessageQueue Konstruktory

Definice

Přetížení

MessageQueue()

Příklady

Poznámky

Viz také

Platí pro

MessageQueue(String)

Parametry

Výjimky

Příklady

Poznámky

Viz také

Platí pro

MessageQueue(String, Boolean)

Parametry

Výjimky

Příklady

Poznámky

Viz také

Platí pro

MessageQueue(String, QueueAccessMode)

Parametry

Platí pro

MessageQueue(String, Boolean, Boolean)

Parametry

Příklady

Platí pro

MessageQueue(String, Boolean, Boolean, QueueAccessMode)

Parametry

Platí pro

Váš názor

Další materiály