C# Interface<T> { T Func<T>(T t);} : Generic Interfaces with Parameterized Methods with Generic Return Types

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 un开发者_如何学运维der 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 ?

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?

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

here really two different Ts : IReadable <T> and T Read<T>(string ID)

maybe just

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

because otherwise is equal to

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

Good Generics tutorial

EDIT:

May be you need public interface IReadable <T> { T Read(T ID); } ?

The CIL does not support method overloading by return type.