Linq 从通用列表中删除

我的列表有这个问题，我似乎无法解决它

我有一个类，它实现了一个具有以下方法的接口

public List<T> CalculateWad<T, TH>(
    List<T> outputList,
    List<TH> inputList,
    bool flag)
{
    ...
}

public List CalculateWad(
列表输出列表，
列表输入列表，
布尔旗）
{
...
}

现在，我有一个输出列表和一个带有公共字段约定的输入列表。我需要删除outputlist中存在的所有合同

它必须尽可能通用。我似乎无法获取列表的字段

---

有什么想法吗？

这是您的界面：

公共列表CalculateWad（列表输出列表、列表输入列表、布尔标志）{ ... }

你需要这样做吗？假设每个列表中的对象都可以通过equals方法进行比较

public List<T> CalculateWad<T, TH>( List<T> outputList, List<TH> inputList, bool flag) {

              // cast list to be regular object lists
              List out = (List) outputList;
              List in = (List) inputList;

              for(Object object : in){
                  out.remove(object);  // this looks for an object that matches using contract.equals(object)         
              }
}

public List CalculateWad（列表输出列表、列表输入列表、布尔标志）{
//强制转换列表为常规对象列表
列表输出=（列表）输出列表；
列表输入=（列表）输入列表；
用于（对象：中）{
out.remove（object）；//使用contract.equals（object）查找匹配的对象
}
}

---

什么是标志变量？

这是您的界面：

公共列表CalculateWad（列表输出列表、列表输入列表、布尔标志）{ ... }

你需要这样做吗？假设每个列表中的对象都可以通过equals方法进行比较

public List<T> CalculateWad<T, TH>( List<T> outputList, List<TH> inputList, bool flag) {

              // cast list to be regular object lists
              List out = (List) outputList;
              List in = (List) inputList;

              for(Object object : in){
                  out.remove(object);  // this looks for an object that matches using contract.equals(object)         
              }
}

public List CalculateWad（列表输出列表、列表输入列表、布尔标志）{
//强制转换列表为常规对象列表
列表输出=（列表）输出列表；
列表输入=（列表）输入列表；
用于（对象：中）{
out.remove（object）；//使用contract.equals（object）查找匹配的对象
}
}

---

什么是flag变量？

为了访问Contract属性，泛型T和TH必须实现与Contract属性的接口

文件：

然后，包含CalculateWad方法的类必须定义如下：

class MyClass<T, TH>
    where T : IContractable
    where TH : IContractable
{
    public List<T> CalculateWad(List<T> outputList, List<TH> inputList, bool flag)
    {
        return outputList
                  .Where(o => 
                      inputList.Select(i => i.Contract).Contains(o.Contract) == false)
                  .ToList();
    }
}

class-MyClass
式中T:i可收缩
其中TH:I可合同
{
公共列表CalculateWad（列表输出列表、列表输入列表、布尔标志）
{
返回输出列表
。其中（o=>
输入列表。选择（i=>i.Contract）。包含（o.Contract）==false）
.ToList（）；
}
}

为了访问合同属性，泛型T和TH必须实现与合同属性的接口

文件：

然后，包含CalculateWad方法的类必须定义如下：

class MyClass<T, TH>
    where T : IContractable
    where TH : IContractable
{
    public List<T> CalculateWad(List<T> outputList, List<TH> inputList, bool flag)
    {
        return outputList
                  .Where(o => 
                      inputList.Select(i => i.Contract).Contains(o.Contract) == false)
                  .ToList();
    }
}

class-MyClass
式中T:i可收缩
其中TH:I可合同
{
公共列表CalculateWad（列表输出列表、列表输入列表、布尔标志）
{
返回输出列表
。其中（o=>
输入列表。选择（i=>i.Contract）。包含（o.Contract）==false）
.ToList（）；
}
}

通过添加一个通用的

IHasContract

接口，这应该应用到作业中，

T

和

TH

必须实现：

class Program
{
    static void Main(string[] args)
    {
    }

    private IList<T> CalculateWad<T, TH>(IList<T> output,
        IList<TH> input, bool flag)
        where T : IHasContract
        where TH : IHasContract
    {
        var contracts = new HashSet<string >(input.Select(i => i.Contract));

        var qry = from o in output
                  where !contracts.Contains(o.Contract)
                  select o;

        return qry.ToList();
    }

    private sealed class Contract
    {

    }

    private interface IHasContract
    {
        string Contract { get; }
    }

    private sealed class Foo : IHasContract
    {
        public string Contract { get; set; }
    }

    private sealed class Bar : IHasContract
    {
        public string Contract { get; set; }
    }
}

类程序
{
静态void Main（字符串[]参数）
{
}
专用IList CalculateWad（IList输出，
IList输入，bool标志）
其中T:IHasContract
其中TH:IHasContract
{
var contracts=newhashset（input.Select（i=>i.Contract））；
var qry=输出中的o
其中！contracts.Contains（o.Contract）
选择o；
返回qry.ToList（）；
}
私人密封类合同
{
}
专用接口IHasContract
{
字符串协定{get；}
}
私人密封类Foo:IHasContract
{
公共字符串协定{get；set；}
}
私人密封类酒吧：IHasContract
{
公共字符串协定{get；set；}
}
}

---

请注意，is不会修改您在本文中提到的

输出。但是，它会返回列表的新修改副本，这可能与方法签名所描述的内容相反。
这应该添加到作业中，方法是添加一个通用的
IHasContract
接口，
T
和
TH
必须实现：

class Program
{
    static void Main(string[] args)
    {
    }

    private IList<T> CalculateWad<T, TH>(IList<T> output,
        IList<TH> input, bool flag)
        where T : IHasContract
        where TH : IHasContract
    {
        var contracts = new HashSet<string >(input.Select(i => i.Contract));

        var qry = from o in output
                  where !contracts.Contains(o.Contract)
                  select o;

        return qry.ToList();
    }

    private sealed class Contract
    {

    }

    private interface IHasContract
    {
        string Contract { get; }
    }

    private sealed class Foo : IHasContract
    {
        public string Contract { get; set; }
    }

    private sealed class Bar : IHasContract
    {
        public string Contract { get; set; }
    }
}

类程序
{
静态void Main（字符串[]参数）
{
}
专用IList CalculateWad（IList输出，
IList输入，bool标志）
其中T:IHasContract
其中TH:IHasContract
{
var contracts=newhashset（input.Select（i=>i.Contract））；
var qry=输出中的o
其中！contracts.Contains（o.Contract）
选择o；
返回qry.ToList（）；
}
私人密封类合同
{
}
专用接口IHasContract
{
字符串协定{get；}
}
私人密封类Foo:IHasContract
{
公共字符串协定{get；set；}
}
私人密封类酒吧：IHasContract
{
公共字符串协定{get；set；}
}
}

请注意，is不会修改您在本文中提到的
输出。但是，它确实返回了列表的一个新的修改副本，这可能与方法签名描述的内容相反。
您的意思是，在方法内部，您不能访问例如
outputList[0]。Contract
？您的意思是，在方法内部，您不能访问例如
outputList[0]。Contract
？+1我猜您比我快。我将合同从输入列表显式复制到一个集合中。这可能会节省一点运行时成本，不是吗？我不确定，我不是Linq向导，但我认为Linq必须已经做了优化。最好问问Jon Skeet:）两个列表中的合同属性都是string类型。显然，这是我想要的，但它不起作用。@ruimatins“不起作用”是什么意思？我的代码应该是什么？我猜你比我快。我从inpu复制了合同