Exportar (0) Imprimir
Expandir todo
Este artículo proviene de un motor de traducción automática. Mueva el puntero sobre las frases del artículo para ver el texto original. Más información.
Traducción
Original

Message (Clase)

Proporciona acceso a las propiedades necesarias para definir un mensaje de Message Queuing.

Espacio de nombres:  System.Messaging
Ensamblado:  System.Messaging (en System.Messaging.dll)

public class Message : Component

El tipo Message expone los siguientes miembros.

  NombreDescripción
Método públicoMessage()Inicializa una nueva instancia de la clase Message con un cuerpo de mensaje vacío.
Método públicoMessage(Object)Inicializa una nueva instancia de la clase Message, utilizando XmlMessageFormatter para serializar el objeto especificado en el cuerpo del mensaje.
Método públicoMessage(Object, IMessageFormatter)Inicializa una instancia nueva de la clase Message, utilizando el formateador especificado para serializar el objeto especificado en el cuerpo del mensaje.
Arriba

  NombreDescripción
Propiedad públicaAcknowledgeTypeObtiene o establece el tipo de mensaje de confirmación que debe devolverse a la aplicación que hace el envío.
Propiedad públicaAcknowledgmentObtiene la clasificación de confirmación que este mensaje representa.
Propiedad públicaAdministrationQueueObtiene o establece la cola utilizada para los mensajes de confirmación generados por Message Queuing.
Propiedad públicaAppSpecificObtiene o establece información adicional específica de la aplicación.
Propiedad públicaArrivedTimeObtiene la hora en que llegó el mensaje a la cola de destino.
Propiedad públicaAttachSenderIdObtiene o establece un valor que indica si se adjuntará al mensaje el identificador del remitente.
Propiedad públicaAuthenticatedObtiene un valor que indica si se autenticó el mensaje.
Propiedad públicaAuthenticationProviderNameObtiene o establece el nombre del proveedor criptográfico que se utiliza para generar la firma digital del mensaje.
Propiedad públicaAuthenticationProviderTypeObtiene o establece el tipo del proveedor criptográfico que se utiliza para generar la firma digital del mensaje.
Propiedad públicaBodyObtiene o establece el contenido del mensaje.
Propiedad públicaBodyStreamObtiene o establece la información del cuerpo del mensaje.
Propiedad públicaBodyTypeObtiene o establece el tipo de datos que contiene el cuerpo del mensaje.
Propiedad protegidaCanRaiseEventsObtiene un valor que indica si el componente puede generar un evento. (Se hereda de Component).
Propiedad públicaConnectorTypeObtiene y establece un valor que indica que la aplicación de envío estableció algunas propiedades de mensajes, normalmente establecidas por Message Queuing.
Propiedad públicaContainerObtiene IContainer que contiene Component. (Se hereda de Component).
Propiedad públicaCorrelationIdObtiene o establece el identificador de mensaje que utilizan los mensajes de confirmación, informe y respuesta para hacer referencia al mensaje original.
Propiedad protegidaDesignModeObtiene un valor que indica si Component está actualmente en modo de diseño. (Se hereda de Component).
Propiedad públicaDestinationQueueObtiene la cola de destino deseada para un mensaje.
Propiedad públicaDestinationSymmetricKeyObtiene o establece la clave simétrica utilizada para cifrar los mensajes cifrados por la aplicación o los enviados a colas externas.
Propiedad públicaDigitalSignatureObtiene o establece la firma digital que Message Queuing utiliza para autenticar el mensaje.
Propiedad públicaEncryptionAlgorithmObtiene o establece el algoritmo de cifrado que se utiliza para cifrar el cuerpo de un mensaje privado.
Propiedad protegidaEventsObtiene la lista de controladores de eventos asociados a Component. (Se hereda de Component).
Propiedad públicaExtensionObtiene o establece información adicional, definida por la aplicación y asociada al mensaje.
Propiedad públicaFormatterObtiene o establece el formateador empleado para serializar o deserializar un objeto en el cuerpo de un mensaje.
Propiedad públicaHashAlgorithmObtiene o establece el algoritmo de hash que Message Queuing utiliza al autenticar mensajes o al crear una firma digital para un mensaje.
Propiedad públicaIdObtiene el identificador del mensaje.
Propiedad públicaIsFirstInTransactionObtiene un valor que indica si el mensaje era el primer mensaje enviado en una transacción.
Propiedad públicaIsLastInTransactionObtiene un valor que indica si el mensaje era el último mensaje enviado en una transacción.
Propiedad públicaLabelObtiene o establece una cadena Unicode definida por la aplicación que describe el mensaje.
Propiedad públicaLookupIdIntroducido en MSMQ 3.0. Obtiene el identificador de búsqueda del mensaje.
Propiedad públicaMessageTypeObtiene el tipo de mensaje: Normal, Acknowledgment o Report.
Propiedad públicaPriorityObtiene o establece la prioridad del mensaje, que determina en qué punto de la cola se ubica el mensaje.
Propiedad públicaRecoverableObtiene o establece un valor que indica si se garantiza la entrega del mensaje en caso de haber errores en el equipo o problemas en la red.
Propiedad públicaResponseQueueObtiene o establece la cola que recibe los mensajes de respuesta generados por la aplicación.
Propiedad públicaSecurityContextObtiene o establece el contexto de seguridad para un mensaje.
Propiedad públicaSenderCertificateObtiene o establece el certificado de seguridad que se utilizará para autenticar mensajes.
Propiedad públicaSenderIdObtiene el identificador del usuario remitente.
Propiedad públicaSenderVersionObtiene la versión de Message Queuing que se utilizó para enviar el mensaje.
Propiedad públicaSentTimeObtiene la fecha y hora del equipo de envío en las que el administrador de colas de origen envió el mensaje.
Propiedad públicaSiteObtiene o establece ISite de Component. (Se hereda de Component).
Propiedad públicaSourceMachineObtiene el equipo donde se originó el mensaje.
Propiedad públicaTimeToBeReceivedObtiene o establece el límite máximo de tiempo para recibir el mensaje de la cola de destino.
Propiedad públicaTimeToReachQueueObtiene o establece el límite máximo de tiempo para que el mensaje alcance la cola.
Propiedad públicaTransactionIdObtiene el identificador de la transacción a la que pertenecía el mensaje.
Propiedad públicaTransactionStatusQueueObtiene la cola de estado de transacción del equipo de origen.
Propiedad públicaUseAuthenticationObtiene o establece un valor que indica si se autenticó (o debe autenticarse) el mensaje antes de enviarse.
Propiedad públicaUseDeadLetterQueueObtiene o establece un valor que indica si debe enviarse una copia del mensaje que no pudo entregarse a la cola de mensajes no enviados.
Propiedad públicaUseEncryptionObtiene o establece un valor que indica si el mensaje debe ser privado.
Propiedad públicaUseJournalQueueObtiene o establece un valor que indica si debe conservarse una copia del mensaje en un diario del equipo de origen.
Propiedad públicaUseTracingObtiene o establece un valor que indica si se debe seguir la traza de un mensaje mientras se traslada a su cola de destino.
Arriba

  NombreDescripción
Método públicoCreateObjRefCrea un objeto que contiene toda la información relevante necesaria para generar un proxy utilizado para comunicarse con un objeto remoto. (Se hereda de MarshalByRefObject).
Método públicoDispose()Libera todos los recursos utilizados por Component. (Se hereda de Component).
Método protegidoDispose(Boolean)Libera los recursos no administrados que utiliza Component y libera los recursos administrados de forma opcional. (Se hereda de Component).
Método públicoEquals(Object)Determina si el objeto especificado es igual al objeto actual. (Se hereda de Object).
Método protegidoFinalizeLibera recursos no administrados y realiza otras operaciones de limpieza antes de que se reclame el objeto Component durante la recolección de elementos no utilizados. (Se hereda de Component).
Método públicoGetHashCode Sirve como una función hash para un tipo en particular. (Se hereda de Object).
Método públicoGetLifetimeServiceRecupera el objeto de servicio de duración actual que controla la directiva de duración de esta instancia. (Se hereda de MarshalByRefObject).
Método protegidoGetServiceDevuelve un objeto que representa el servicio suministrado por Component o por Container. (Se hereda de Component).
Método públicoGetType Obtiene el Type de la instancia actual. (Se hereda de Object).
Método públicoInitializeLifetimeServiceObtiene un objeto de servicio de duración para controlar la directiva de duración de esta instancia. (Se hereda de MarshalByRefObject).
Método protegidoMemberwiseClone() Crea una copia superficial del Object actual. (Se hereda de Object).
Método protegidoMemberwiseClone(Boolean)Crea una copia superficial del objeto MarshalByRefObject actual. (Se hereda de MarshalByRefObject).
Método públicoToStringDevuelve un objeto String que contiene el nombre del objeto Component, en caso de que exista. Este método no debe reemplazarse. (Se hereda de Component).
Arriba

  NombreDescripción
Evento públicoDisposedSe produce cuando el componente se elimina mediante una llamada al método Dispose. (Se hereda de Component).
Arriba

  NombreDescripción
Campo públicoMiembro estáticoInfiniteTimeoutEspecifica que no existe un tiempo de espera.
Arriba

Utilice la clase Message para buscar o recibir los mensajes de una cola, o bien para tener un control más preciso sobre las propiedades de los mensajes al enviarlos a la cola.

MessageQueue utiliza la clase Message al buscar o recibir los mensajes de las colas, ya que tanto MessageQueue.Peek como MessageQueue.Receive crean una nueva instancia de la clase Message y establecen sus propiedades. Las propiedades de solo lectura de la clase Message se aplican a la recuperación de mensajes de una cola, mientas que las propiedades de lectura y escritura se aplican al envío y recuperación de mensajes. Cuando MessageQueue ejecuta el método Peek o recibe un mensaje de una cola, su propiedad MessageReadPropertyFilter determina qué propiedades del mensaje se recuperan.

El método Send de la clase MessageQueue permite especificar cualquier tipo de objeto para un mensaje que se esté enviando a dicha cola. Se puede utilizar la propiedad DefaultPropertiesToSend de la instancia de MessageQueue para especificar la configuración de los mensajes genéricos enviados a dicha cola. Los diferentes valores configurables incluyen el formateador, la etiqueta, el tipo de cifrado y la autenticación. También se pueden especificar valores para los miembros correspondientes de DefaultPropertiesToSend al coordinar nuestra aplicación de mensajería para que responda a los mensajes de confirmación e informe. Utilizar una instancia de Message para enviar un mensaje a la cola le da la flexibilidad necesaria para acceder y modificar muchas de estas propiedades, ya sea para un mensaje único o mensaje a mensaje. Las propiedades Message tienen precedencia sobre DefaultPropertiesToSend.

Los datos de los mensajes se almacenan en la propiedad Body y, en menor medida, en las propiedades AppSpecific y Extension. Cuando se cifran, serializan o deserializan los datos de un mensaje, solo queda afectado el contenido de la propiedad Body.

El contenido de la propiedad Body se serializa al enviar el mensaje, mediante la propiedad Formatter especificada. El contenido serializado se encuentra en la propiedad BodyStream. También se puede establecer directamente la propiedad BodyStream, por ejemplo, para enviar un archivo como contenido de datos de un mensaje. Es posible cambiar las propiedades Body o Formatter en cualquier momento antes de enviar el mensaje, serializándose apropiadamente los datos al llamar a Send.

Las propiedades definidas por la propiedad MessageQueue.DefaultPropertiesToSend se aplican solo a los mensajes que no son del tipo Message. Si se especifica la propiedad DefaultPropertiesToSend para un objeto MessageQueue, las propiedades de idéntico nombre de una instancia de Message enviada a dicha cola hacen que se pasen por alto estas propiedades predeterminadas.

Para obtener una lista con los valores de propiedad iniciales de una instancia de Message, vea el constructor Message.

En el ejemplo de código siguiente se muestra la forma de aplicar un formato al cuerpo de un mensaje utilizando 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;
		}
	}
}


En el ejemplo de código siguiente se muestra la forma de aplicar un formato al cuerpo de un mensaje utilizando 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

Compatible con: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Compatible con: 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 (no se admite el rol Server Core), Windows Server 2008 R2 (se admite el rol Server Core con SP1 o versiones posteriores; no se admite Itanium)

.NET Framework no admite todas las versiones de todas las plataformas. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.

Todos los miembros static (Shared en Visual Basic) públicos de este tipo son seguros para la ejecución de subprocesos. No se garantiza que los miembros de instancias sean seguros para la ejecución de subprocesos.

Adiciones de comunidad

AGREGAR
Mostrar:
© 2014 Microsoft