Good reason to inherit from generics in C #

Update

I revisited the question, your last comments, and I came up with an idea based on my interpretation of your problem.

I agree with your last statement, there really won't be any difference between an interface Join<...>

and a hypothetical interface IOddAndPrimeCounter : IOddCounter, IPrimeCounter

. What I had in mind with point 2 is that you cannot distinguish whether the resulting connection interface should be called like T1

or T2

.

I would suggest a slightly different approach, which I myself use in such scenarios. I would keep the two interfaces IFirstColumnBuilder

and INextColumnBuilder

, but change the latter a bit:

interface INextColumnBuilder : 
    IFirstColumnBuilder, ITransactionBuilder, IRowBuilder, ITransactionHolder {}

      

        
        
        
      

    

Then I'll move on to one implementation IFirstColumnBuilder

and INextColumnBuilder

which looks like this:

public class ColumnBulder : INextColumnBuilder // IFirstColumnBuilder is already implemented
{
}

      

        
        
        
      

    

A typical implementation IRowBulder

would look like this:

public class RowBulder : IRowBulder
{
    public IFirstColumnBuilder Column(...)
    {
         // do stuff
         return new ColumnBuilder(...);
    }
}

      

        
        
        
      

    

The trick is that while ColumnBuilder

implements both IFirstColumnBuilder

, and the INextColumnBuilder

result from rowBuilder.Column()

will only have access to public methods IFirstColumnBuilder

.

I know this doesn't solve the interface problem very much, but still you have one single implementation, which means less code to write and less duplicate code on your interfaces. In addition, your call chain will be limited at will.

Original Answer

Since I had some thoughts on your question and I was a C # developer myself, I came up with some reasons why this probably won't happen in the CLR.

• Your suggestion requires additional compile-time checking for T
  
  being an interface. In C #, generics can be subject to certain compile-time constraints. For example,

  public class ConstrainedList<T> : List<T> 
      where T: class, IEquatable<T>, new() { }
  
        
  
          
          
          
        
  
      

  The restriction will class
  
  restrict T
  
  only to reference types, the restriction IEquatable<T>
  
  will only allow types that implement the interface, IEquatable<T>
  
  and the restriction new()
  
  that T must have a public parameterless constructor. Multiple constraints, as in the example, must be executed immediately.

  Your suggestion is that the CLR should support the new constraint, let you call it interface
  
  , so it's T
  
  limited by the interface type. This constraint would be incompatible with the constraints new()
  
  and class
  
  would result in additional compile-time checks that CLR teams would need to implement. Perhaps if such a change is backward compatible or not, I think it won't, since both types class
  
  and value types hidden behind the interfaces behave like reference types. Thus, the restriction interface
  
  will act the same as the restrictionclass
  
  and yet allow value types that implement the interface to be considered acceptable, in other words, the constraint would contradict itself and could cause confusion and / or unexpected behavior in the code.

• The second argument I have against this proposal is more practical. In C # and CLR languages ​​in general, you can explicitly implement interfaces. (If you don't know which is the explicit implementation of the interface and how it is used, I explained that at the end of the post). When you have this Join<T1, T2>
  
  interface, and the material from point 1 is implemented, then you will have problems when T1
  
  both T2
  
  provide a method with the same signature and require (and have) explicit implementations. So when you have this:

  IColumnBuilder columnBuilder = ...; // Assume a valid column builder is set
  var joinResult = columnBuilder.Column("col", "val");
  joinResult.ConflictingMethod(); // Oops!
  
        
  
          
          
          
        
  
      

  If it is ConflictingMethod()
  
  defined in both in T1
  
  and in T2
  
  what is joinResult
  
  inherited, but T1
  
  and are T2
  
  explicitly implemented, then in this line the compiler will not know which implementation ( T1
  
  or T2
  
  's) is called.

The above example may require more significant and non-dispatch changes to the CLR, if at all possible; so now it seems even less likely.

A note on explicit interfaces

This is a really useful feature if you have a class that needs to implement multiple interfaces, and at least two of the interfaces use a method with the same signature. The problem is that you may need to provide different implementations for each interface. Here's an example to illustrate:

    public interface IOddNumberCounter
    {
        int Count(params int[] input);
    }
    public interface IPrimeNumberCounter
    {
        int Count(params int[] input);
    }

      

        
        
        
      

    

Imagine a test that tests them:

    public void TestOddCounter(IOddNumberCounter counter)
    {
        AssertTrue(counter.Count(1, 2, 3, 15) == 3);
    }

    public void TestPrimeCounter(IPrimeNumberCounter counter)
    {
        AssertTrue(counter.Count(2, 3, 15, 16) == 2);
    }

      

        
        
        
      

    

Now, for some reason, you need this class:

    public class OddAndPrimeCounter : IOddNumberCounter, IPrimeNumberCounter
    {
        public int Count(params int[] input)
        {
            // Now what ?
        }
    }

      

        
        
        
      

    

The decision to pass tests for a class OddAndPrimeCounter

is to implement at least one (or both) conflicting methods explicitly. Explicit implementations have a slightly different syntax:

    public class OddAndPrimeCounter : IOddNumberCounter, IPrimeNumberCounter
    {
        int IOddNumberCounter.Count(params int[] input)
        {
            //count the odds
        }
        int IPrimeNumberCounter.Count(params int[] input)
        {
            //count the primes
        }
    }