Sorry forgot the compiler messages:

Error 1 The best overloaded method match for
'SignalList.SignalValidator.Validate(SignalList.Signal)' has some invalid
arguments D:\Users\Bart\Visual Studio
2008\Projects\SignalList\SignalList\Signals.cs 65 13 SignalList

Error 2 Argument '1': cannot convert from 'Signal' to 'SignalList.Signal'
D:\Users\Bart\Visual Studio 2008\Projects\SignalList\SignalList\Signals.cs
65 33 SignalList

Bart

Well, ignoring for a moment at least three other errors in your code that  
I see, I think the issue you're running into is here:

Your SignalValidator class requires that you pass it a Signal.  However,  
your Signals<Signal> class is actually a generic class, with the type  
parameter named "Signal" not constrained to anything.  So when you try to  
call "_validater.Validate(item) [sic]", the compiler complains because it  
has no idea at the moment that it's compiling that code that "item" is of  
type "Signal".  It has the type of the generic type parameter _named_  
"Signal" but that's the name of the type parameter, not the class actually  
being used.

I suspect that what you really want is to declare your Signals class like  
this:

    public class Signals : IList<Signal>

If you do that, I think the code will compile (after you fix the other  
errors).

Alternative solutions would include constraining the type parameter:

    public class Signals<T> : IList<T> where T : Signal

Or making the SignalValidator class generic as well:

    public class SignalValidator<T> { ... }

    public class Signals<T> : IList<T>
    {
        private SignalValidator<T> _validator;
        private List<T> _list = new List<T>();

        public Signals(SignalValidator<T> Validator)
        {
            _validator = Validator;
        }

        public void Add(T item)
        {
            if(!_validator.Validate(item))
            {
               throw new Exception();
            }
            else
            {
               _list.Add(item);
            }
        }
    }

Of course, in this last option, it begs the question as to what the  
generic SignalValidator<T> might do.  Since it wouldn't necessarily know  
anything about the generic type parameter (unless you constrained its type  
parameter to Signal, when you'd then have to do for the Signals class  
anyway, obviating the need to make SignalValidator generic in the first  
place), you would need to provide some sort of validating method for the  
class.  Assuming all the class does is call the validating method, you  
could do away with the SignalValidator class altogether and just declare a  
validating method delegate type to be passed to the Signals class instead:

    public delegate bool SignalValidator<T>(T t);

    public class Signals<T> : IList<T>
    {
        private SignalValidator<T> _validator;
        private List<T> _list = new List<T>();

        public Signals(SignalValidator<T> Validator)
        {
            _validator = Validator;
        }

        public void Add(T item)
        {
            if(!_validator(item))
            {
               throw new Exception();
            }
            else
            {
               _list.Add(item);
            }
        }
    }

Then when you instantiate a Signals<T>, you'd simply pass in a method to  
be used for validation rather than a whole class.

Anyway, as I said...I think what you really want is the first suggestion  
above.  But any of the above should work better than what you've got right  
now.

Pete