How do I get rid of "[some event] never used" compiler warnings in Visual Studio?

This appears to be warning 67 and can thus be suppressed with:

#pragma warning disable 67

Don't forget to restore it as soon as possible (after the event declaration) with:

#pragma warning restore 67

However, I'd check again and make sure you're raising the event somewhere, not just subscribing to it. The fact that the compiler spits out 20 warnings and not 20 errors when you comment out the event is also suspicious...

There's also an interesting article about this warning and specifically how it applies to interfaces; there's a good suggestion on how to deal with "unused" events. The important parts are:

The right answer is to be explicit about what you expect from the event, which in this case, is nothing:

public event EventHandler Unimportant{    add { }    remove { }}

This will cleanly suppress the warning, as well as the extra compiler-generated implementation of a normal event. And as another added benefit, it prompts one to think about whether this do-nothing implementation is really the best implementation. For instance, if the event isn't so much unimportant as it is unsupported, such that clients that do rely on the functionality are likely to fail without it, it might be better to explicitly indicate the lack of support and fail fast by throwing an exception:

public event EventHandler Unsupported{    add { throw new NotSupportedException(); }    remove { }}

Of course, an interface that can be usefully implemented without some parts of its functionality is sometimes an indication that the interface is not optimally cohesive and should be split into separate interfaces.

If you are forced to implement an event from an interface, that your implementation doesn't need you can do the following to avoid the warning.

public event EventHandler CanExecuteChanged { add{} remove{} }

The second best way is imho to clearly state that the event is not supported by throwing an exception if someone tries to subscribe to it.

public event RoutedEventHandler SearchClick{    add { throw new NotSupportedException(); }    remove { throw new NotSupportedException(); }}

As a variant on this, you can also just leave the add and remove methods empty to silently ignore subscriptions on the event.

The best solution is to refactor the code, perhaps pull the declaration of the event to the implementor if possible.

As a last resort, you can also disable the warning like so

#pragma warning disable 67public event RoutedEventHandler SearchClick;#pragma warning restore 67