[c#] functie templates te gebruiken?

[ThaStealth]

Hoi,

Voor een applicatie heb ik een class buffer geschreven, deze class doet niets anders dan een waarde van een bepaald type ontvangen, deze in een buffer (vandaar de naam ) opslaan en deze vervolgens aan een aanvrager geven (en uit de buffer mikken). Omdat deze buffer een aantal malen binnen de applicatie gebruikt gaat worden voor een verschillend aantal datatypes moeten er dus een aantal verschillende buffers komen.

Omdat ik het niet netjes vond om een alle objecten in de buffer te mogen stoppen, maar een bepaald type object maar heb ik ervoor besloten om de methodes alleen een string te accepteren als invoer of een string te retourneren als uitvoer. Nu komt echter het probleem dat de buffer ook objecten van een zelfverzonnen type moet aankunnen. Het probleem is nu dat C# het dus niet heel erg tof vond om een zelfverzonnen type in een buffer van een string type te steken. typecasten zou kunnen, maar dit is natuurlijk een enorm ranzige oplossing...

Uit mijn C++ boek wat ik hier heb rondslingeren kon ik me herinneren dat het mogelijk is in C++ om templates te maken voor een methode dus zodat een onderstaande code mogelijk wordt:

C++:

template<typename T>
T giveMax(T x, T y)
{
if (x>y)
{
return x;
}
else
{
return y;
}
}

T is dus nog niet ingevuld en wordt pas bij de methodeaanroep bepaald. Dit zou natuurlijk de ultieme oplossing voor mij zijn (dacht ik), alleen nog even in C# implementeren, how hard can it be?.....

Dit bleek toch wat tegen te vallen, het moet mogelijk zijn omdat het gebruikt wordt in de List class, immers het is mogelijk om een List van elk mogelijk type te maken, dus het zou toch ook mogelijk moeten zijn om dit te gebruiken voor mijn code? Heeft iemand hier ervaring mee?

[Tp21]

je zou eens moeten zoeken op 'generics' deze zijn de templates van C#

[ Voor 4% gewijzigd door Tp21 op 22-05-2008 20:54 ]

[MTWZZ]

En dan gelijk even zoeken naar de documentatie van Queue<T>

[ThaStealth]

Wat een dumbass ben ik! Generics TNX!!!
Was binnen 5 min gefixt toen ik eenmaal gevonden had op MSDN.

De Queue kan ik helaas niet gebruiken omdat ik een buffer heb tussen 2 threads en de uitlezende thread in een aantal gevallen moet blokkeren totdat er een item in de queue verschijnt.

[MTWZZ]

Je kunt Queue<T> gewoon overerven en er een signalling variant van maken.
Zoiets dus:
ThreadSafeQueue<T>

C#:

public class ThreadSafeQueue<T> : Queue<T>
{
    private AutoResetEvent _event;

    public ThreadSafeQueue() {
        _event = new AutoResetEvent (false);
    }

    public AutoResetEvent QueueEvent {
        get { return _event; }
    }

    public new void Enqueue(T item) {
        // Lock
        lock (this) {
            // Enqueue
            base.Enqueue(item);
            
            // Signal
            _event.Set();
        }
    }

    public new T Dequeue() {
        T retval;

        // Lock
        lock (this) {
            // Dequeue
            retval = base.Dequeue();
        }

        return retval;
    }
}

Worker<T>

C#:

public class Worker<T> {
    private ThreadSafeQueue<T> _queue;

    public Worker(ThreadSafeQueue<T> queue) {
        _queue = queue;
    }

    public void Run() {
        try {
            Console.WriteLine("Worker started, thread id: " + Thread.CurrentThread.ManagedThreadId);

            while (true) {
                bool queueEvent = _queue.QueueEvent.WaitOne();

                if (queueEvent) {
                    T item = _queue.Dequeue();

                    Console.WriteLine("Item: " + item);
                }
            }
        }
        catch (ThreadAbortException tx) { Console.WriteLine("Thread aborted!"); }
    }
}

Worker hoeft overigens niet <T> te zijn maar is wel makkelijker.

[curry684]

Tp21 schreef op donderdag 22 mei 2008 @ 20:54:
je zou eens moeten zoeken op 'generics' deze zijn de templates van C#

Dat is wel lichtelijk teveel eer toeschrijven aan generics.

Java en C# generics zijn een handige en zwaar versimplificeerde implementatie van C++ templates die voor 99% van de toepassingen ('containers') afdoende is.

[.oisyn]

Of je gebruikt C++/CLI, dan kun je gewoon templates gebruiken (en generics, en zelfs tegelijk )