Esporta (0) Stampa
Espandi tutto
Il presente articolo è stato tradotto automaticamente. Passare il puntatore sulle frasi nell'articolo per visualizzare il testo originale. Ulteriori informazioni.
Traduzione
Originale

Classe Message

Fornisce accesso alle proprietà necessarie per definire un messaggio di Accodamento messaggi.

Spazio dei nomi:  System.Messaging
Assembly:  System.Messaging (in System.Messaging.dll)

public class Message : Component

Il tipo Message espone i seguenti membri.

  NomeDescrizione
Metodo pubblicoMessage()Inizializza una nuova istanza della classe Message con un corpo vuoto.
Metodo pubblicoMessage(Object)Inizializza una nuova istanza della classe Message utilizzando XmlMessageFormatter per serializzare l'oggetto specificato nel corpo del messaggio.
Metodo pubblicoMessage(Object, IMessageFormatter)Inizializza una nuova istanza della classe Message utilizzando il formattatore specificato per serializzare l'oggetto specificato nel corpo del messaggio.
In alto

  NomeDescrizione
Proprietà pubblicaAcknowledgeTypeOttiene o imposta il tipo di messaggio di acknowledgment da restituire all'applicazione che esegue l'invio.
Proprietà pubblicaAcknowledgmentOttiene la classificazione dei messaggi di riconoscimento rappresentati da questo messaggio.
Proprietà pubblicaAdministrationQueueOttiene o imposta la coda che riceve i messaggi di riconoscimento generati da Accodamento messaggi.
Proprietà pubblicaAppSpecificOttiene o imposta informazioni aggiuntive specifiche di un'applicazione.
Proprietà pubblicaArrivedTimeOttiene l'ora in cui il messaggio ha raggiunto la coda di destinazione.
Proprietà pubblicaAttachSenderIdOttiene o imposta un valore che indica se l'ID del mittente deve essere allegato al messaggio.
Proprietà pubblicaAuthenticatedOttiene un valore che indica se il messaggio è stato autenticato.
Proprietà pubblicaAuthenticationProviderNameOttiene o imposta il nome del provider di crittografia utilizzato per generare la firma digitale del messaggio.
Proprietà pubblicaAuthenticationProviderTypeOttiene o imposta il tipo di provider di crittografia utilizzato per generare la firma digitale del messaggio.
Proprietà pubblicaBodyOttiene o imposta il contenuto del messaggio.
Proprietà pubblicaBodyStreamOttiene o imposta le informazioni presenti nel corpo del messaggio.
Proprietà pubblicaBodyTypeOttiene o imposta il tipo di dati contenuti nel corpo del messaggio.
Proprietà protetta.CanRaiseEventsOttiene un valore che indica se il componente può generare un evento. (Ereditato da Component)
Proprietà pubblicaConnectorTypeOttiene o imposta un valore che indica che alcune proprietà del messaggio normalmente impostate da Accodamento messaggi sono state impostate dall'applicazione mittente.
Proprietà pubblicaContainerOttiene il IContainer che contiene il Component. (Ereditato da Component)
Proprietà pubblicaCorrelationIdOttiene o imposta l'identificatore del messaggio utilizzato dai messaggi di riconoscimento, dei rapporti e di risposta per fare riferimento al messaggio originale.
Proprietà protetta.DesignModeOttiene un valore che indica se il Component si trova in modalità progettazione. (Ereditato da Component)
Proprietà pubblicaDestinationQueueOttiene la coda di destinazione desiderata per un messaggio.
Proprietà pubblicaDestinationSymmetricKeyOttiene o imposta la chiave simmetrica utilizzata per crittografare i messaggi crittografati dall'applicazione o i messaggi inviati alle code esterne.
Proprietà pubblicaDigitalSignatureOttiene o imposta la firma digitale utilizzata da Accodamento messaggi per autenticare il messaggio.
Proprietà pubblicaEncryptionAlgorithmOttiene o imposta l'algoritmo di crittografia utilizzato per crittografare il corpo di un messaggio privato.
Proprietà protetta.EventsOttiene l'elenco dei gestori eventi allegati a questo Component. (Ereditato da Component)
Proprietà pubblicaExtensionOttiene o imposta informazioni aggiuntive definite dall'applicazione, associate al messaggio.
Proprietà pubblicaFormatterOttiene o imposta il formattatore utilizzato per serializzare o deserializzare un oggetto da e nel corpo del messaggio.
Proprietà pubblicaHashAlgorithmOttiene o imposta l'algoritmo hash utilizzato da Accodamento messaggi per autenticare un messaggio o creare una firma digitale per un messaggio.
Proprietà pubblicaIdOttiene l'identificatore del messaggio.
Proprietà pubblicaIsFirstInTransactionOttiene un valore che indica se il messaggio è stato il primo messaggio inviato in una transazione.
Proprietà pubblicaIsLastInTransactionOttiene un valore che indica se il messaggio è stato l'ultimo messaggio inviato in una transazione.
Proprietà pubblicaLabelOttiene o imposta una stringa Unicode definita dall'applicazione che descrive il messaggio.
Proprietà pubblicaLookupIdIntrodotto in MSMQ 3.0. Ottiene l'identificatore di ricerca del messaggio.
Proprietà pubblicaMessageTypeOttiene il tipo di messaggio: Normal, Acknowledgment o Report.
Proprietà pubblicaPriorityOttiene o imposta la priorità del messaggio, che determina la posizione del messaggio nella coda.
Proprietà pubblicaRecoverableOttiene o imposta un valore che indica che il recapito del messaggio è garantito anche nel caso di un malfunzionamento del computer o di un problema di rete.
Proprietà pubblicaResponseQueueOttiene o imposta la coda che riceve i messaggi di risposta generati dall'applicazione.
Proprietà pubblicaSecurityContextOttiene o imposta il contesto per la sicurezza di un messaggio.
Proprietà pubblicaSenderCertificateOttiene o imposta il certificato di sicurezza usato per autenticare i messaggi.
Proprietà pubblicaSenderIdOttiene l'identificatore del mittente.
Proprietà pubblicaSenderVersionOttiene la versione di Accodamento messaggi utilizzata per inviare il messaggio.
Proprietà pubblicaSentTimeOttiene la data e l'ora di invio del messaggio da parte del computer mittente dalla gestione coda di origine.
Proprietà pubblicaSiteOttiene o imposta il ISite del Component. (Ereditato da Component)
Proprietà pubblicaSourceMachineOttiene informazioni sul computer in cui il messaggio ha avuto origine.
Proprietà pubblicaTimeToBeReceivedOttiene o imposta il limite di tempo massimo per la ricezione del messaggio dalla coda di destinazione.
Proprietà pubblicaTimeToReachQueueOttiene o imposta il limite di tempo massimo impiegato dal messaggio per raggiungere la coda.
Proprietà pubblicaTransactionIdOttiene l'identificatore per la transazione di cui fa parte il messaggio.
Proprietà pubblicaTransactionStatusQueueOttiene la coda di stato della transazione sul computer di origine.
Proprietà pubblicaUseAuthenticationOttiene o imposta un valore che indica se il messaggio è stato autenticato o deve esserlo prima del suo invio.
Proprietà pubblicaUseDeadLetterQueueOttiene o imposta un valore che indica se una copia del messaggio non recapitato deve essere inviata a una coda dei messaggi non recapitabili.
Proprietà pubblicaUseEncryptionOttiene o imposta un valore che indica se rendere privato il messaggio.
Proprietà pubblicaUseJournalQueueOttiene o imposta un valore che indica se è necessario inserire una copia del messaggio nel journal del computer di origine.
Proprietà pubblicaUseTracingOttiene o imposta un valore che indica se tenere traccia di un messaggio mentre procede verso la coda di destinazione.
In alto

  NomeDescrizione
Metodo pubblicoCreateObjRefConsente di creare un oggetto che contiene tutte le informazioni rilevanti necessarie per la generazione del proxy utilizzato per effettuare la comunicazione con un oggetto remoto. (Ereditato da MarshalByRefObject)
Metodo pubblicoDispose()Rilascia tutte le risorse utilizzate dall'oggetto Component. (Ereditato da Component)
Metodo protettoDispose(Boolean)Rilascia le risorse non gestite utilizzate da Component e, facoltativamente, le risorse gestite. (Ereditato da Component)
Metodo pubblicoEquals(Object) Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
Metodo protettoFinalizeRilascia risorse non gestite ed esegue altre operazioni di pulizia prima che la classe Component venga recuperata tramite Garbage Collection. (Ereditato da Component)
Metodo pubblicoGetHashCode Funge da funzione hash per un particolare tipo. (Ereditato da Object)
Metodo pubblicoGetLifetimeServiceConsente di recuperare l'oggetto servizio di durata corrente per controllare i criteri di durata per l'istanza. (Ereditato da MarshalByRefObject)
Metodo protettoGetServiceConsente di restituire un oggetto che rappresenta un servizio fornito da Component o dal relativo Container. (Ereditato da Component)
Metodo pubblicoGetType Ottiene il Type dell'istanza corrente. (Ereditato da Object)
Metodo pubblicoInitializeLifetimeServiceConsente di ottenere un oggetto servizio di durata per il controllo dei criteri di durata per l'istanza. (Ereditato da MarshalByRefObject)
Metodo protettoMemberwiseClone() Crea una copia dei riferimenti dell'oggetto Object corrente. (Ereditato da Object)
Metodo protettoMemberwiseClone(Boolean)Crea una copia dei riferimenti dell'oggetto MarshalByRefObject corrente. (Ereditato da MarshalByRefObject)
Metodo pubblicoToStringRestituisce un oggetto String contenente il nome dell'oggetto Component, se presente. Non è consigliabile eseguire l'override di questo metodo. (Ereditato da Component)
In alto

  NomeDescrizione
Evento pubblicoDisposedSi verifica quando il componente viene eliminato da una chiamata al metodo Dispose. (Ereditato da Component)
In alto

  NomeDescrizione
Campo pubblicoMembro staticoInfiniteTimeoutSpecifica che non è previsto un timeout.
In alto

Utilizzare la classe Message per visualizzare o ricevere messaggi da una coda o per mantenere un controllo completo sulle proprietà del messaggio durante l'invio a una coda.

MessageQueue utilizza la classe Message quando legge o riceve messaggi dalle code, poiché entrambi i metodi MessageQueue.Peek e MessageQueue.Receive creano una nuova istanza della classe Message e impostano le proprietà dell'istanza. Le proprietà di sola lettura della classe Message si applicano al recupero dei messaggi da una coda, mentre le proprietà in lettura/scrittura si applicano all'invio e al recupero dei messaggi. Quando MessageQueue visualizza o riceve un messaggio da un coda, la relativa proprietà MessageReadPropertyFilter determina le proprietà del messaggio da recuperate.

Il metodo Send della classe MessageQueue consente di specificare un tipo di oggetto per un messaggio inviato alla coda indicata. È possibile utilizzare la proprietà DefaultPropertiesToSend dell'istanza MessageQueue per specificare le impostazioni per messaggi generici inviati alla coda. I tipi di impostazioni includono il formattatore, l'etichetta, la crittografia e l'autenticazione. È inoltre possibile specificare i valori dei membri di DefaultPropertiesToSend appropriati quando si coordina l'applicazione di messaggistica affinché risponda a messaggi di riconoscimento e di rapporto. Utilizzando un'istanza di Message per inviare un messaggio alla coda è possibile accedere a molte di queste proprietà e modificarle, sia per un solo messaggio che per ogni messaggio. Le proprietà Message hanno la precedenza su DefaultPropertiesToSend.

I dati del messaggio sono memorizzati nella proprietà Body e, in misura minore, nelle proprietà AppSpecific e Extension. Quando i dati del messaggio vengono crittografati, serializzati o deserializzati, l'operazione ha effetto solo sul contenuto della proprietà Body.

Il contenuto della proprietà Body viene serializzato all'invio del messaggio, utilizzando la proprietà Formatter specificata. Il contenuto serializzato si trova nella proprietà BodyStream. È inoltre possibile impostare la proprietà BodyStream direttamente, ad esempio per inviare un file come contenuto di dati di un messaggio. È possibile modificare le proprietà Body o Formatter in qualsiasi momento prima dell'invio del messaggio e i dati verranno serializzati correttamente durante una chiamata a Send.

Le proprietà definite dalla proprietà MessageQueue.DefaultPropertiesToSend si applicano soltanto ai messaggi non di tipo Message. Se si specifica la proprietà DefaultPropertiesToSend per un oggetto MessageQueue, le proprietà con lo stesso nome di un'istanza di Message inviata a tale coda prevalgono su queste proprietà predefinite, che verranno ignorate.

Per un elenco dei valori iniziali delle proprietà di un'istanza della classe Message, vedere il costruttore Message.

Nell'esempio di codice riportato di seguito viene illustrata la formattazione del corpo di un messaggio mediante BinaryMessageFormatter.


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;
		}
	}
}


Nell'esempio di codice riportato di seguito viene illustrata la formattazione del corpo di un messaggio mediante XmlMessageFormatter.


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

Supportato in: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Supportato 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 (ruoli di base del server non supportati), Windows Server 2008 R2 (ruoli di base del server supportati con SP1 o versione successiva, Itanium non supportato)

.NET Framework non supporta tutte le versioni di ciascuna piattaforma. Per un elenco delle versioni supportate, vedere Requisiti di sistema di .NET Framework.

Qualsiasi membro static (Shared in Visual Basic) pubblico di questo tipo è thread-safe. I membri di istanza non sono garantiti come thread-safe.

Aggiunte alla community

AGGIUNGI
Microsoft sta conducendo un sondaggio in linea per comprendere l'opinione degli utenti in merito al sito Web di MSDN. Se si sceglie di partecipare, quando si lascia il sito Web di MSDN verrà visualizzato il sondaggio in linea.

Si desidera partecipare?
Mostra:
© 2015 Microsoft