Question

I thought I’d use some (what I thought was) simple generics to enforce CRUD on some Business Classes.
eg.

public interface IReadable <T>
{
    T Read<T>(string ID);
}

and then perhaps, I could have a NoteAdapter to do CRUD with the Note class eg.

public class NoteAdapter : IReadable<Note>
{
    public Note Read<Note>(string ID) {
        return new Note();
    }
}

But for some reason, te compiler is getting confused if I have both a generic return Type and a function Parameterized with the same generic Type. That is , if I do :

public interface IReadable <T>
{
    void Read<T>(string ID);
}
public class NoteAdapter : IReadable<Note>
{
    public void Read<Note>(string ID) {
        return new Note();
    }
}

It compiles fine, although it doesnt do what I want it to !
Also, this :

public interface IReadable <T>
{
    T Read (string ID);
}
public class NoteAdapter : IReadable<Note>
{
    public Note Read(string ID) {
        return new Note();
    }
}

works fine as well, Although it too does not satisfy the requirements ! — Why ?
Because then I can’t have one Class that implements a bunch of these Interfaces ..eg.

public interface IReadable <T>{
    T Read (string ID);
}
public class UniversalAdapter : IReadable<Note>, IReadable<Customer> ...
{
    public Note Read(string ID) {
        return new Note();
    }
    public Customer Read(string ID) {
        return new Customer();
    }
}

Coz this would not compile as return types are not part of the methods signature !

I was under the impression, in C# 3.5 +

T Foo(T t);
T Foo<T> (T t);
T Foo(<SomeType> someInstance);

All have different signatures! What am I missing here ?

Answer 1

You’ve overspecified the interface. You declare T in the interface definition, but then you redeclare it in the method’s definition:

public interface IReadable <T>  /* T is declared here */
{
    T Read<T>(string ID); /* here, you've declare a NEW generic type parameter */
                          /* that makes this T not the same as the T in IReadable */
}

Due to this confusion, you end up with an error when you try to implement the interface.

public class NoteAdapter : IReadable<Note> /* IReadable defines T to be Note */
{
    public Note Read<Note>(string ID) { /* Here, you're declaring a generic parameter */
                                        /* named Note.  This name then conflicts with */
                                        /* the existing type name Note */
        return new Note();
    }
}

To fix this, you simply need to remove the generic parameter from the Read function, both in the interface, and in the NoteAdapter class:

public interface IReadable <T>
{
    T Read(string ID);
}
public class NoteAdapter : IReadable<Note>
{
    public Note Read(string ID) {
        return new Note();
    }
}

EDIT:

Okay, I read the rest of your post, and it seems that you’ve already discovered that this “works”, but you seem to think it’s incorrect. Why? What requirements does this not meet?