MessageQueue.Close Methode

public:
 void Close();

public void Close ();

member this.Close : unit -> unit

Public Sub Close ()

Beispiele

Im folgenden Codebeispiel wird eine Message Queuing-Warteschlange geschlossen.

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

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

   // Sends a message to a queue.
   void SendMessage()
   {
      // Connect to a queue on the local computer.
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );

      // Send a message to the queue.
      myQueue->Send( "My message data1." );

      // Explicitly release resources.
      myQueue->Close();

      // Attempt to reaquire resources.
      myQueue->Send( "My message data2." );
      return;
   }

   // Receives a message from a queue.
   void ReceiveMessage()
   {
      // Connect to the a on the local computer.
      MessageQueue^ myQueue = gcnew MessageQueue( ".\\myQueue" );

      // Set the formatter to indicate body contains an Order.
      array<Type^>^p = gcnew array<Type^>(1);
      p[ 0 ] = String::typeid;
      myQueue->Formatter = gcnew XmlMessageFormatter( p );
      try
      {
         // Receive and format the message. 
         Message^ myMessage1 = myQueue->Receive();
         Message^ myMessage2 = myQueue->Receive();
      }
      catch ( MessageQueueException^ ) 
      {
         // Handle sources of any MessageQueueException.
      }
      finally
      {
         // Free resources.
         myQueue->Close();
      }

      return;
   }
};


// Provides an entry point into the application.
// This example closes a queue and frees its 
// resources.
int main()
{
   // Create a new instance of the class.
   MyNewQueue^ myNewQueue = gcnew MyNewQueue;

   // Send a message to a queue.
   myNewQueue->SendMessage();

   // Receive a message from a queue.
   myNewQueue->ReceiveMessage();
   return 0;
}

using System;
using System.Messaging;

namespace MyProject
{

    /// <summary>
    /// Provides a container class for the example.
    /// </summary>
    public class MyNewQueue
    {

        //**************************************************
        // Provides an entry point into the application.
        //	
        // This example closes a queue and frees its
        // resources.
        //**************************************************

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

            // Send a message to a queue.
            myNewQueue.SendMessage();

            // Receive a message from a queue.
            myNewQueue.ReceiveMessage();

            return;
        }

        //**************************************************
        // Sends a message to a queue.
        //**************************************************
        
        public void SendMessage()
        {
            // Connect to a queue on the local computer.
            MessageQueue myQueue = new MessageQueue(".\\myQueue");

            // Send a message to the queue.
            myQueue.Send("My message data1.");
            
            // Explicitly release resources.
            myQueue.Close();

            // Attempt to reacquire resources.
            myQueue.Send("My message data2.");

            return;
        }

        //**************************************************
        // Receives a message from a queue.
        //**************************************************
        
        public  void ReceiveMessage()
        {
            // Connect to the a on the local computer.
            MessageQueue myQueue = new MessageQueue(".\\myQueue");

            // Set the formatter to indicate body contains an Order.
            myQueue.Formatter = new XmlMessageFormatter(new Type[]
                {typeof(String)});
            
            try
            {
                // Receive and format the message.
                Message myMessage1 = myQueue.Receive();
                Message myMessage2 = myQueue.Receive();
            }
            
            catch (MessageQueueException)
            {
                // Handle sources of any MessageQueueException.
            }

            // Catch other exceptions as necessary.

            finally
            {
                // Free resources.
                myQueue.Close();
            }

            return;
        }
    }
}

Imports System.Messaging

  
'Provides a container class for the example.

Public Class MyNewQueue



        ' Provides an entry point into the application.
        '	 
        ' This example closes a queue and frees its 
        ' resources.
 

        Public Shared Sub Main()

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

            ' Send a message to a queue.
            myNewQueue.SendMessage()

            ' Receive a message from a queue.
            myNewQueue.ReceiveMessage()

            Return

        End Sub



        ' Sends a message to a queue.
 

        Public Sub SendMessage()

            ' Connect to a queue on the local computer.
            Dim myQueue As New MessageQueue(".\myQueue")

            ' Send a message to the queue.
            myQueue.Send("My message data1.")

            ' Explicitly release resources.
            myQueue.Close()

            ' Attempt to reacquire resources.
            myQueue.Send("My message data2.")

            Return

        End Sub



        ' Receives a message from a queue.


        Public Sub ReceiveMessage()

            ' Connect to the a on the local computer.
            Dim myQueue As New MessageQueue(".\myQueue")

            ' Set the formatter to indicate the body contains an 
            ' Order.
            myQueue.Formatter = New XmlMessageFormatter(New Type() _
                {GetType([String])})

            Try
                ' Receive and format the message. 
                Dim myMessage1 As Message = myQueue.Receive()
                Dim myMessage2 As Message = myQueue.Receive()

            Catch
                ' Handle sources of any MessageQueueException.

                ' Catch other exceptions as necessary.

            Finally

                ' Free resources.
                myQueue.Close()

            End Try

            Return

        End Sub

End Class

Hinweise

Close gibt alle Ressourcen frei, die einem MessageQueuezugeordnet sind, einschließlich freigegebener Ressourcen, falls zutreffend. Das System ruft diese Ressourcen automatisch erneut ab, wenn sie noch verfügbar sind, z. B. wenn Sie die Send(Object) -Methode aufrufen, wie im folgenden C#-Code beschrieben.

myMessageQueue.Send("Text 1.");
myMessageQueue.Close();
myMessageQueue.Send("Text 2."); //Resources are re-acquired.

Wenn Sie aufrufen Close, werden alle MessageQueue Eigenschaften gelöscht, die direkt auf die Message Queuing-Warteschlange zugreifen. Die Path, DefaultPropertiesToSend, Formatterund MessageReadPropertyFilter alle bleiben wie sie waren.

Close gibt die Lese- und Schreibhandles nicht immer für eine Warteschlange frei, da sie möglicherweise freigegeben werden. Sie können einen der folgenden Schritte ausführen, um sicherzustellen, dass Close die Lese- und Schreibhandles für eine Warteschlange freigegeben werden:

• Create mit MessageQueue exklusivem Zugriff. Rufen Sie hierzu den MessageQueue(String, Boolean) Konstruktor oder auf MessageQueue(String, Boolean, Boolean) , und legen Sie den sharedModeDenyReceive Parameter auf fest true.

• Create mit deaktivierter MessageQueue Verbindungszwischenspeicherung. Rufen Sie hierzu den MessageQueue(String, Boolean, Boolean) Konstruktor auf, und legen Sie den enableConnectionCache Parameter auf falsefest.

• Deaktivieren Sie die Verbindungszwischenspeicherung. Legen Sie dazu die EnableConnectionCache -Eigenschaft auf fest false.

Sie sollten eine Warteschlange aufrufen Close , bevor Sie die Warteschlange auf dem Message Queuing-Server löschen. Andernfalls können Nachrichten, die an die Warteschlange gesendet werden, Ausnahmen auslösen oder in der Warteschlange für unzustellbare Nachrichten angezeigt werden.

Die folgende Tabelle zeigt, ob diese Methode in verschiedenen Arbeitsgruppenmodi verfügbar ist.

Gilt für: