得到警告，“类型参数X隐藏接口X”

Question

This is occurring in Visual Studio 2010.

I'm working with generic methods, and basically losing my intellisense and stopping me from continuing work on this project.

I basically have the following class:

public class SearchRepository : DataRepository<IAudit>
{
    public override IEnumerable<IAudit> RetrieveAll<IAuditSearch>(IAuditSearch searchParameters)
    {
        // CODE GOES HERE
    }

    public override bool Delete<TIAudit>(IAudit audit)
    {
        // CODE GOES HERE
    }
}

This inherits from:

public abstract class DataRepository<T>
{
    public virtual IEnumerable<T> RetrieveAll<U>(U parameter1)
    {
        throw new NotImplementedException();
    }

    public virtual bool Delete<U>(U parameter1)
    {
        throw new NotImplementedException();
    }
}

So Delete works exactly how I would expect it to work. I have intellisense and it compiles correctly. RetrieveAll doesn't work correctly using IAuditSearch. If I change it to TIAuditSearch, then it says I'm "There is no suitable method to override".

Not sure what I'm doing wrong, but it's definitely not happy with me.

UPDATED: changed the virtual to override for the Delete method at the top. That was a mistake.

Answer 1

You are implicitly hiding (by not overriding) the method signature of

bool Delete<myType>(myType param) { ... }

You can overcome the error my introducing the "new" keyword on the derived class's Delete property. This explicitly hides the signature and makes everyone happy as it illustrates your intent.

Read the Microsoft documentation at: http://msdn.microsoft.com/en-us/library/aa691135%28v=vs.71%29.aspx .

Answer 2

You can't define the method public override IEnumerable RetrieveAll(IAuditSearch searchParameters)

The method must still use the U type parameter in place of IAuditSearch. Its up to the caller to choose what type to pass.

You'll probably need to create an ISearch interface and on the base class add where U : ISearch, but even then your subclass would need to accept all ISearch implemenations, not just IAuditSearch.

Probably the best solution is to define an IAuditSearch repository which is what defines your RetreiveAll method.

EDIT: I see the question has changed. You now have the same problem on both methods; you cannot dictate which interface to use when overriding the method, you must maintain the generic type parameter.

public override IEnumerable<T> RetrieveAll<U>(U parameter1)  { }

public override bool Delete<U>(U parameter1)  { }

Note that you cannot add where clauses to the methods either; this breaks the Liskov Substitution Prinicple . Also I'm not even sure the compiler would allow you to do that.

Answer 3

Unfortunately, the exact context is not quite clear to me, but I believe your code should look like this:

public interface IParameter<T> {
    bool Match(T entry);
}
public abstract class DataRepository<T, TParameter>
    where TParameter : IParameter<T> {
    public abstract IEnumerable<T> RetrieveAll(TParameter parameter1);
    public abstract bool Delete(TParameter parameter1);
}
//
public interface IAudit {/* ... */}
public interface IAuditSearch : IParameter<IAudit> {/* ... */}

public class SearchRepository : DataRepository<IAudit, IAuditSearch> {
    public override bool Delete(IAuditSearch parameter1) {
        // iterate by collection items using parameter matching
        // CODE GOES HERE (DELETE ALL FOUND ENTRIES)
    }
    public override IEnumerable<IAudit> RetrieveAll(IAuditSearch parameter1) {
        // iterate by collection items using parameter matching
        // CODE GOES HERE (RETURN ALL FOUND ENTRIES)
    }
}

Different IAuditSearch implementation will incapsulate a "search by different parameter" logic:

var guidSearchResult = repository.RetrieveAll(
    new GuidSearch(new Guid("00000000-0000-0000-0000-000000000000")));
var idRangeSearchResult = repository.RetrieveAll(
    new IDRangeSearch(1000, 2000));

where GuidSearch and IDRangeSearch are implemented as:

public class GuidSearch : IAuditSearch {
    Guid ID;
    public GuidSearch(Guid id) {
        this.ID = id;
    }
    public bool Match(IAudit entry) {
        /* search implementation using ID(Guid)*/
        throw new NotImplementedException();
    }

}
public class IDRangeSearch : IAuditSearch {
    int StartID;
    int EndID;
    public IDRangeSearch(int startId, int endId) {
        this.StartID = startId;
        this.EndID = endId;
    }
    public bool Match(IAudit entry) {
        /* search implementation using ID range (StartID...EndID)*/
        throw new NotImplementedException();
    }
}

Answer 4

Would the following code work instead?

public class SearchRepository : DataRepository<IAudit, IAuditSearch>
{
    public override IEnumerable<IAudit> RetrieveAll<IAuditSearch>(IAuditSearch searchParameters)
    {
        // CODE GOES HERE
    }

    public override bool Delete<TIAudit>(IAudit audit)
    {
        // CODE GOES HERE
    }
}

public abstract class DataRepository<T, TSearch>
{
    public virtual IEnumerable<T> RetrieveAll(TSearch parameter1)
    {
        throw new NotImplementedException();
    }

    public virtual bool Delete(T parameter1)
    {
        throw new NotImplementedException();
    }
}

So for every instantiation of DataRepository, we declare the result type (T), and the search type (TSearch).

-C