Je développe une application de framework .Net Compact en C# qui utilise un logiciel tiers de mise en file d'attente de messages installé sur le périphérique. Je suis assez nouveau à cet environnement et je me demandais si je pouvais exécuter quelques concepts clés de l'architecture passé des yeux plus sages pour voir si je suis sur la bonne voie ou comment il pourrait être amélioré. Pendant que mon application est en cours d'exécution, je dois garder la bibliothèque de files d'attente en arrière-plan afin qu'elle puisse générer des notifications et informer mon application des messages entrants et traiter les messages générés par mon application. Il doit fonctionner pendant toute la durée de vie de mon application, donc je pense que la meilleure façon de le faire est de le lancer dans son propre thread quand mon application se lance?.NET CF Running Thread pour la durée de vie d'une application
Je ne voulais pas inonder ce poste avec du code, donc j'ai mis les sections sur je pense sont importants, s'il vous plaît faites le moi savoir si je dois clarifier plus.
Je commence le processus de message dans un thread séparé lorsque l'application se lance comme celui-ci,
[MTAThread]
static void Main()
{
//Run the message processor in its own thread
Thread messagingThread = new Thread(new ThreadStart(msgProcessorStart));
messagingThread.Priority = ThreadPriority.Highest;
messagingThread.Start();
…..
Application.Run(splashForm);
}
private static void msgProcessorStart()
{
MessageProcessor.Start();
}
Le MessageProcessor est une façade sur la bibliothèque de messagerie pour simplifier l'interaction et de garder une seule instance. J'en ai posté une partie ci-dessous, il soulève des événements pour la non-livraison et notifie quand les messages sont reçus.
public static class MessageProcessor
{
#region Declarations
//private static reference to the MessageProvider as specified in the configuration files.
private static readonly IMessageProcessor _messageProcessor = MessageAccess.MessageProvider;
#endregion
#region Constructor
/// <summary>
/// Static constructor, connects to the events on the messageProcessor instance which
/// relate to messages received, notifications received and exceptions raised.
/// </summary>
static MessageProcessor()
{
//Connect up events specifed on the IMessageProcessor interface.
_messageProcessor.MessageReceived += messageReceived;
}
#endregion
#region Public Methods
/// <summary>
/// Sends a request based data message.
/// </summary>
/// <typeparam name="T">Message which implements RequestBase</typeparam>
/// <param name="message">The message to send</param>
public static void SendMessage<T>(T message) where T : RequestBase
{
_messageProcessor.SendMessage(message);
}
/// <summary>
/// Starts the Message Processor.
/// </summary>
/// <returns>bool, true if started successfully.</returns>
public static void Start()
{
_messageProcessor.Start();
}
#endregion
#region Private methods
//Registered listener of the IMessageProcessor.MessageReceived event
private static void messageReceived(object sender, MsgEventArgs<IMessage> message)
{
ThreadPool.QueueUserWorkItem(new WaitCallback(processMessage),(object)message.Value);
}
//Invoked via messageReceived.
private static void processMessage(object msg)
{
//process the message
}
#endregion
}
La méthode Start est d'abord appelée et établit une session; nous allons alors commencer à recevoir des notifications et être en mesure d'envoyer des messages.
Lorsqu'un message est reçu, je suis en train de gérer le traitement des événements dans un thread séparé via le ThreadPool, afin de continuer et de répondre à d'autres notifications et messages.
Est-ce que cela semble une approche raisonnable et va-t-il m'assurer que ma bibliothèque de files d'attente de messages sera capable de traiter indépendamment de mon application?
Un conseil serait le bienvenu, merci pour votre temps.