What is the cleanest way to define this generic interface so it compiles?

Question

Since, two methods with the same parameters but different return values will not compile. What is the best way to define this interface without loosing clarity?

public interface IDuplexChannel<T, U>
{
    void Send(T value, int timeout = -1);
    void Send(U value, int timeout = -1);
    bool TrySend(T value, int timeout = -1);
    bool TrySend(U value, int timeout = -1);
    T Receive(int timeout = -1);
    U Receive(int timeout = -1);
    bool TryReceive(out T value, int timeout = -1);
    bool TryReceive(out U value, int timeout = -1);
}

I considered using out params but that would make it a little awkward to use.

public interface IDuplexChannel<T, U>
{
    void Send(T value, int timeout = -1);
    void Send(U value, int timeout = -1);
    bool TrySend(T value, int timeout = -1);
    bool TrySend(U value, int timeout = -1);
    void Receive(out T value, int timeout = -1);
    void Receive(out U value, int timeout = -1);
    bool TryReceive(out T value, int timeout = -1);
    bool TryReceive(out U value, int timeout = -1);
}

Generic version, a little unwieldy but it works.

public interface IDuplexChannel<T, U>
{
    void Send(T value, int timeout = -1);
    void Send(U value, int timeout = -1);
    bool TrySend(T value, int timeout = -1);
    bool TrySend(U value, int timeout = -1);
    V Receive<V>(int timeout = -1) where V : T, U;
    bool TryReceive(out T value, int timeout = -1);
    bool TryReceive(out U value, int timeout = -1);
}

Answer 1

Rename these two methods. They only differ by return type.

T Receive(int timeout = -1);
U Receive(int timeout = -1);

Note, I have not tested this. Try this.

R Receive<R>(int timeout = -1);

Answer 2

The problem is indeed that there are two Receive methods that differ only by the return type. Because your type represents a duplex channel, you had to duplicate everything in the interface - I believe a simpler approach would be to define a type that allows you to represent "either T or U" value. This is quite related to Tuple<T, U>, which is now in .NET that allows you to represent "both T and U". The signature of the type could look like this:

// Represents either a value of type T or a value of type U
class Either<T, U> { 
  public bool TryGetFirst(out T val);
  public bool TryGetSecond(out U val);
}

// For constructing values of type Either<T, U>
static class Either {
  public static Either<T, U> First<T, U>(T val);
  public static Either<T, U> Second<T, U>(U val);
}

A sample usage of this class might look like this:

var val = Either.First<int, string>(42);

int num;
string str;
if (val.TryGetFirst(out num)) 
  Console.WriteLine("Got number: {0}", num);
else if (val.TryGetSecond(out str)) 
  Console.WriteLine("Got string: {0}", str);

Then you can represent your duplex channel using a simpler interface:

public interface IDuplexChannel<T, U> { 
    void Send(Either<T, U> value, int timeout = -1); 
    bool TrySend(Either<T, U> value, int timeout = -1); 
    Either<T, U> Receive(int timeout = -1); 
    bool TryReceive(out Either<T, U> value, int timeout = -1); 
} 

As Josh suggest, I would also get rid of the Receive and Send methods. Why? Because it makes implementing the interface simple and you can easily provide an implementation of Receive and Send in terms of TryReceive and TrySend as an extension method. So, you end up with an interface:

public interface IDuplexChannel<T, U> { 
    bool TrySend(Either<T, U> value, int timeout = -1); 
    bool TryReceive(out Either<T, U> value, int timeout = -1); 
} 

And the extension methods would look roughly like this:

public static Either<T, U> Receive
    (this IDuplexChannel<T, U> ch, int timeout = -1) {
  Either<T, U> v;
  if (!ch.TryReceive(out v, timeout)) throw new Exception(...);
  return v;
}

Answer 3

The main problem is you are trying to view the duplex channel from both ends at the same time. Data travels both ways on a duplex channel, but there are still definite endpoints. What you send on one end is what you receive on the other.

public interface IDuplexChannel<TSend, TReceive>
{
    void Send(TSend data);
    TReceive Receive();
}

That said, you should be using WCF anyway, especially since you're using .NET 4.0.

Edit: Pictures

        "PERSON" A                                     "PERSON" B
            O            int ----------------->            O
           -|-           <-------------- string           -|-
           / \                                            / \
IDuplexChannel<int, string>                     IDuplexChannel<string, int>