C#: Preferred pattern for functions requiring arguments that implement two interfaces [closed]

Question

The argument to my function f() must implement two different interfaces that are not related to each other by inheritance, IFoo and IBar. I know of two different ways of doing this. The first is to declare an empty interface that inherits from both:

public interface IFooBar : IFoo, IBar
{
    // nothing to see here
}

public int f(IFooBar arg)
{
    // etc.
}

This, of course, requires that the classes declare themselves as implementing IFooBar rather than IFoo and IBar separately.

The second way is to make f() generic with a constraint:

public int f<T>(T arg) where T : IFoo, IBar
{
    // etc.
}

Which of these do you prefer, and why? Are there any non-obvious advantages or disadvantages to each?

Answer 1

The second option is more flexible. By introducing a new interface, you're forcing classes to implement a third interface, which will only be possible if they have a reference to your library (where the interface is defined).

By using generic constraints, the class only needs a reference to the library containing IFoo and IBar, and not IFooBar.