[C#,NUNIT] Remoting en ongewilde static eventHandler

[Devilfish]

Ik ben voor een project bezig met een systeem dat op het door sturen van xml berichten is gebaseerd. Elk component heeft z'n eigen queue die kan worden gevuld via een remoting aanroep over http (MarshalByRefObject). Nu is het probleem dat de componenten voortborduren op deze klasse:

C#:

    /// <summary>
    /// Server is the base class for all Servers
    /// </summary>
    public class Server
    {
        /// <summary>
        /// every Server has a synchronized queue for sending and receiving events 
        /// </summary>
        public Queue eventQueue;

        /// <summary>
        /// Default Constructor
        /// </summary>
        public Server() 
        {
            eventQueue = Queue.Synchronized(new Queue());
            Common.EventHandler.server = this;
        }
    }

En daar zit de regel Common.EventHandler.server = this; in welke een static is. Dat zorgt er voor dat als je wil gaan testen met nunit en dus meerdere queues wil gaan gebruiken dat een bericht steeds weer in de zelfde queue komt te staan. De remoting klasse:

C#:

    /// <summary>
    /// The following class can be remotely created to send events to the attached Server
    /// </summary>
    public class EventHandler : MarshalByRefObject
    {
        /// <summary>
        /// the Server to which all created EventHandlers are attached.
        /// </summary>
        public static Server server;

        /// <summary>
        /// Default constructor. Set the static server first, or an exception will occur.
        /// </summary>
        public EventHandler() 
        {
            if (server == null) 
                throw new Exception("Define a server for this EventHandler first");
        }   

        /// <summary>
        /// Send a event to this server
        /// </summary>
        /// <param name="m">The event</param>
        /// <returns>Is the event delivered?</returns>
        public bool SendEvent(Event m) 
        {
            // there should always be a static Server attached to a EventHandler
            if (server == null) 
            {
                return false;
            }
            server.eventQueue.Enqueue(m);
            return true;
        }
    }

Mijn vraag is dus hoe kan ik er voor zorgen dat ik die static call niet nodig heb? Of moet ik voor elk component een aparte eventhandler maken?

[whoami]

Het is moeilijk om hier wat zinnigs over te zeggen, aangezien het me totaal niet duidelijk is.

Allereerst, wat is 'Common' in jouw Server - class ?
Ik vind het ook geen goed idee om jouw class de naam EventHandler te geven, omdat dit een naam is die al gebruikt wordt door het .NET framework.
Ik vind het ook maar raar dat jouw constructor checkt of er al een waarde gegeven is aan die static member.

[Devilfish]

Common is een namespace waar in onder andere de twee bovenstaande klasses zitten (ik heb een prefix weggelaten).
Tweede punt: is een goed punt
Derde: Dat is niet opzich niet heel raar toch? Mocht er nog geen server ingesteld zijn dan mag hij hem ook niet remote aanroepen.

[H!GHGuY]

kun je geen server meegeven in de constructor van de eventhandler?

[Sappie]

whoami schreef op woensdag 06 april 2005 @ 08:47:
Ik vind het ook geen goed idee om jouw class de naam EventHandler te geven, omdat dit een naam is die al gebruikt wordt door het .NET framework.

Devilfish schreef op woensdag 06 april 2005 @ 09:29:
Common is een namespace waar in onder andere de twee bovenstaande klasses zitten (ik heb een prefix weggelaten).

Aangezien common een namespace is en je twee klasses daarin zitten is het toch juist ok om je class de naam eventHandler te geven (het is immers de meest triviale naam daarvoor)? Tenminste ik dacht dat dat juist één van de voordelen van het gebruik van namespaces was, dat er klasses met dezelfde naam konden bestaan, zodat je niet één of andere exotische naam moet verzinnen. Of heb ik het nu fout?

[joopst]

Static methods zijn instance onafhankelijk.
nu zeg je:

every Server has a synchronized queue for sending and receiving events

elke component erft van server en gaat dus zichzelf op de static method registreren. Hierdoor wordt de registratie van het vorige component overschreven.

een dergelijke constructie zal (dus) nooit gaan werken.

Er zijn iig twee (vast wel meer) oplossingen:
1. 1 queue gebruiken voor alle msgs en dan afhankelijk van het soort msg actie ondernemen.
2. voor elke component een aparte queue maken, met de daarbij behorende queue listener.


happy programming