(0) exportieren Drucken
Alle erweitern
Dieser Artikel wurde maschinell übersetzt. Bewegen Sie den Mauszeiger über die Sätze im Artikel, um den Originaltext anzuzeigen. Weitere Informationen
Übersetzung
Original

MessageQueue.Formatter-Eigenschaft

Ruft das Formatierungsprogramm ab, oder legt das Formatierungsprogramm fest, das zum Serialisieren und Deserialisieren eines Objekts in bzw. aus dem Körper einer Meldung verwendet wird, die aus einer Warteschlange gelesen oder in eine Warteschlange geschrieben wird.

Namespace:  System.Messaging
Assembly:  System.Messaging (in System.Messaging.dll)

[MessagingDescriptionAttribute("MQ_Formatter")]
[BrowsableAttribute(false)]
public IMessageFormatter Formatter { get; set; }

Eigenschaftswert

Typ: System.Messaging.IMessageFormatter
Der IMessageFormatter, der den Stream erstellt, der in den Meldungstext geschrieben oder aus diesem gelesen werden soll. Die Standardeinstellung ist XmlMessageFormatter.

Die Formatter-Eigenschaft enthält eine Instanz eines Formatierungsobjekts, das Meldungen zum Lesen oder Schreiben in einer Warteschlange konvertiert.

Wenn die Anwendung die Meldung an die Warteschlange sendet, serialisiert das Formatierungsprogramm das Objekt in einen Stream und fügt es in den Meldungskörper ein. Beim Lesen aus einer Warteschlange deserialisiert das Formatierungsprogramm die Meldungsdaten in die Body-Eigenschaft einer Message.

Da XmlMessageFormatter lose verknüpft ist, müssen der Objekttyp des Senders und des Empfängers bei diesem Format nicht übereinstimmen. Der ActiveXMessageFormatter und der BinaryMessageFormatter serialisieren die Daten in eine binäre Darstellung. Der ActiveXMessageFormatter wird beim Senden oder Empfangen von COM-Komponenten verwendet.

Der BinaryMessageFormatter und der ActiveXMessageFormatter ermöglichen einen höheren Durchsatz als der XmlMessageFormatter. Der ActiveXMessageFormatter bietet eine Interoperabilität mit Message Queuing-Anwendungen aus Visual Basic 6.0.

Wenn die Anwendung Meldungen an die Warteschlange sendet, wird der MessageQueue.Formatter nur auf Meldungen angewendet, die die Standardmeldungseigenschaften (DefaultPropertiesToSend) verwenden. Wenn eine Message an die Warteschlange gesendet wird, verwendet Message Queuing zur Serialisierung des Meldungstexts stattdessen das in der Message.Formatter-Eigenschaft angegebene Formatierungsprogramm.

Die MessageQueue-Klasse verwendet zum Abrufen oder Einsehen einer Meldung aus der Warteschlange immer eine Message. Die Meldung wird anhand der MessageQueue.Formatter-Eigenschaft deserialisiert.

Der folgenden Tabelle können Sie entnehmen, ob diese Eigenschaft in verschiedenen Arbeitsgruppenmodi verfügbar ist.

Arbeitsgruppenmodus

Verfügbar

Lokaler Computer

ja

Lokaler Computer + direkter Formatname

ja

Remotecomputer

nein

Remotecomputer und direkter Formatname

ja

Im folgenden Codebeispiel wird das Formatieren eines Nachrichtentexts mithilfe des BinaryMessageFormatter veranschaulicht.


using System;
using System.Messaging;
using System.Drawing;
using System.IO;

namespace MyProject
{
	

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

		//**************************************************
		// Provides an entry point into the application.
		//		 
		// This example sends and receives a message from
		// a queue.
		//**************************************************

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

			// Create a queue on the local computer.
			CreateQueue(".\\myQueue");
			
			// Send a message to a queue.
			myNewQueue.SendMessage();

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

			return;
		}

		//**************************************************
		// Creates a new queue.
		//**************************************************

		public static void CreateQueue(string queuePath)
		{
			try	
				{
				if(!MessageQueue.Exists(queuePath))
				{
					MessageQueue.Create(queuePath);
				}
				else
				{
					Console.WriteLine(queuePath + " already exists.");
				}
			}
			catch (MessageQueueException e)
			{
				Console.WriteLine(e.Message);
			}
			
		}

		//**************************************************
		// Sends an image to a queue, using the BinaryMessageFormatter.
		//**************************************************
		
		public void SendMessage()
		{
			try{

				// Create a new bitmap.
				// The file must be in the \bin\debug or \bin\retail folder, or
				// you must give a full path to its location.
				Image myImage = Bitmap.FromFile("SentImage.bmp");

				// Connect to a queue on the local computer.
				MessageQueue myQueue = new MessageQueue(".\\myQueue");
				
				Message myMessage = new Message(myImage, new BinaryMessageFormatter());

				// Send the image to the queue.
				myQueue.Send(myMessage);
			}
			catch(ArgumentException e)
			{
				Console.WriteLine(e.Message);
			
			}

			return;
		}


		//**************************************************
		// Receives a message containing an image.
		//**************************************************
		
		public  void ReceiveMessage()
		{
						
			try
			{

				// Connect to the a queue on the local computer.
				MessageQueue myQueue = new MessageQueue(".\\myQueue");

				// Set the formatter to indicate body contains an Order.
				myQueue.Formatter = new BinaryMessageFormatter();

				// Receive and format the message. 
				System.Messaging.Message myMessage = myQueue.Receive(); 
				Bitmap myImage = (Bitmap)myMessage.Body;
				
				// This will be saved in the \bin\debug or \bin\retail folder.
				myImage.Save("ReceivedImage.bmp",System.Drawing.Imaging.ImageFormat.Bmp);
				
				
			}
			
			catch (MessageQueueException)
			{
				// Handle Message Queuing exceptions.
			}

			// Handle invalid serialization format.
			catch (InvalidOperationException e)
			{
				Console.WriteLine(e.Message);
			}

			catch (IOException e)
			{
				// Handle file access exceptions.
			}
			
			// Catch other exceptions as necessary.

			return;
		}
	}
}


Im folgenden Codebeispiel wird das Formatieren eines Nachrichtentexts mithilfe des XmlMessageFormatter veranschaulicht.


using System;
using System.Messaging;
using System.Drawing;
using System.IO;

namespace MyProject
{

	// The following example 
	// sends to a queue and receives from a queue.
	public class Order
	{
		public int orderId;
		public DateTime orderTime;
	};	

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

		//**************************************************
		// Provides an entry point into the application.
		//		 
		// This example sends and receives a message from
		// a queue.
		//**************************************************

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

			// Create a queue on the local computer.
			CreateQueue(".\\myQueue");
			
			// Send a message to a queue.
			myNewQueue.SendMessage();

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

			return;
		}

		//**************************************************
		// Creates a new queue.
		//**************************************************

		public static void CreateQueue(string queuePath)
		{
			try	
			{
				if(!MessageQueue.Exists(queuePath))
				{
					MessageQueue.Create(queuePath);
				}
				else
				{
					Console.WriteLine(queuePath + " already exists.");
				}
			}
			catch (MessageQueueException e)
			{
				Console.WriteLine(e.Message);
			}
			
		}

		//**************************************************
		// Sends an Order to a queue.
		//**************************************************
		
		public void SendMessage()
		{
			try
			{

				// Create a new order and set values.
				Order sentOrder = new Order();
				sentOrder.orderId = 3;
				sentOrder.orderTime = DateTime.Now;

				// Connect to a queue on the local computer.
				MessageQueue myQueue = new MessageQueue(".\\myQueue");


				
				// Create the new order.
				Message myMessage = new Message(sentOrder);

				// Send the order to the queue.
				myQueue.Send(myMessage);
			}
			catch(ArgumentException e)
			{
				Console.WriteLine(e.Message);
			
			}

			return;
		}


		//**************************************************
		// Receives a message containing an order.
		//**************************************************
		
		public  void ReceiveMessage()
		{
			// Connect to the a queue 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(MyProject.Order)});
			
			try
			{
				// Receive and format the message. 
				Message myMessage =	myQueue.Receive(); 
				Order myOrder = (Order)myMessage.Body;

				// Display message information.
				Console.WriteLine("Order ID: " + 
					myOrder.orderId.ToString());
				Console.WriteLine("Sent: " + 
					myOrder.orderTime.ToString());
			}
			
			catch (MessageQueueException)
			{
				// Handle Message Queuing exceptions.
			}

				// Handle invalid serialization format.
			catch (InvalidOperationException e)
			{
				Console.WriteLine(e.Message);
			}
			
			// Catch other exceptions as necessary.

			return;
		}
	}
}


.NET Framework

Unterstützt in: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Unterstützt in: 4, 3.5 SP1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (Server Core-Rolle wird nicht unterstützt), Windows Server 2008 R2 (Server Core-Rolle wird mit SP1 oder höher unterstützt; Itanium wird nicht unterstützt)

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen für .NET Framework.

Community-Beiträge

HINZUFÜGEN
Anzeigen:
© 2014 Microsoft