c# 7 when using generics for method parameter I get The constraints for type parameter 'U' of method must match the constraints for the interface

Question

我正在尝试创建一个接口和一个具体实现，其中接口是泛型类型并且其中一个方法具有泛型参数。

我想保留 GetPagedList 方法参数，resourceParams，通用，以便我可以为接口的不同实现传递不同的 resourceParams 对象。

当使用下面显示的代码时，我得到了错误；

方法“ShippingServicesRepository.GetPagedList(U)”的类型参数“U”的约束必须匹配接口方法 IBaseRepository.GetPagedList(U) 的类型参数“U”的约束。考虑改用显式接口实现

这是我的界面；

public interface IBaseRepository<T> 
{
    bool Save();
    bool Exists(int recordId);
    bool MarkForDeletion(int recordId);
    PagedList<T> GetPagedList<U>(U resourceParams) where U : class;
    T Get(int id);
    void Add(T record);
    void Update(T record);
}

这是我的实现；

public class ShippingServicesRepository<T> : IBaseRepository<T> 
{

    //                      /--- GetPagedList is what is throwing the error
    //                      |
    public PagedList<T> GetPagedList<U> (U resourceParams) where U : ShippingServicesResourceParameters
    {
        try
        {

            var collectionBeforePaging =
                _manifestContext.ShippingServices
                .ApplySort(resourceParams.OrderBy, _propertyMappingService.GetPropertyMapping<ShippingServicesDto, ShippingServices>());
            if (!string.IsNullOrEmpty(resourceParams.SearchQuery))
            {
                var searchQueryForWhereClause = resourceParams.SearchQuery.Trim().ToLowerInvariant();
                collectionBeforePaging = collectionBeforePaging
                    .Where(a => a.ReferenceId.ToLowerInvariant().Contains(searchQueryForWhereClause));
            }
            collectionBeforePaging = collectionBeforePaging
                .Where(d => d.DeleteFlag == resourceParams.DeleteFlag);

            return (dynamic)PagedList<ShippingServices>.Create(collectionBeforePaging,
                resourceParams.PageNumber,
                resourceParams.PageSize);
        }
        catch (Exception)
        {
            _logger.LogError(500, "ShippingServices Filter [{FILTER}]", resourceParams);
            throw;
        }
    }

    public void Add(T record)
    {
        ...
    }

    public bool Exists(int recordId)
    {
        ...
    }

    public T Get(int id)
    {
        ...
    }

    public bool MarkForDeletion(int recordId)
    {
        ...
    }

    public bool Save()
    {
        ...
    }

    public void Update(T record)
    {
        ...
    }

}

这是我的 ShippingServicesResourceParameters 类

public class ShippingServicesResourceParameters : BaseResourceParameters
{
    public string FileName { get; set; }
}

这里是 ShippingServicesResourceParameters 继承的 BaseResourceParameters 类

public class BaseResourceParameters
{
    private int _pageSize;
    public int PageNumber { get; set; } = 1;
    public int PageSize
    {
        get
        {
            return _pageSize;
        }
        set
        {
            _pageSize = (value > MaxPageSize) ? MaxPageSize : value;
            if (value == 0)
            {
                _pageSize = 10; // set a default size
            }
        }
    }

    public int MaxPageSize { get; set; } = 20;
    public bool DeleteFlag { get; set; }
    public string SearchQuery { get; set; }
    public string OrderBy { get; set; } = "Id";
    public string Fields { get; set; }
}

如果我没有在具体实现中的方法签名和接口中的“where U:class”中添加“where U: ShippingServicesResourceParameters”，我得到一个“无法从方法组转换为字符串...”在具体实现中第一次使用 resourceParams 变量时出错。 （在“.ApplySort(resourceParams.OrderBy”)

我在这里错过了什么？

Answer 1

让我们首先做你应该做的事情，并制作一个演示问题的最小程序：

interface I 
{
    void M<U>(U u) where U : class;
}
class D 
{
    public void O() {}
}
class C : I
{
    public void M<U>(U u) where U : D
    {
        u.O();
    }
}

这是一个错误，因为 C 没有实现 I。它没有实现 I，因为：

I i = new C();
i.M<Giraffe>(new Giraffe());

现在我们有一个长颈鹿传递给C.M<Giraffe>(Giraffe)，但C.M<U> 要求U 是D。所以这是非法的。

我们不能这样修复它：

    public void M<U>(U u) where U : class
    {
        u.O();
    }

因为现在我们可以在 Giraffe 类型的接收器上调用 D.O()。

因此我们必须像这样修复它：

interface I 
{
    void M<U>(U u) where U : D;
}
class D 
{
    public void O() {}
}
class C : I
{
    public void M<U>(U u) where U : D
    {
        u.O();
    }
}

现在我们都很好。

您需要使实现约束与接口约束相匹配，就像您需要满足接口施加的所有其他要求一样。 接口是合同。你必须履行你的讨价还价。

我注意到这就是错误消息所说的：你必须匹配约束，而你没有这样做。注意错误信息；大多数时候他们会告诉你哪里出了问题。