我有一个庞大的项目列表,需要将它们分组为一个属性.然后应该选择每组中最老的一组.

简化示例:选择每个用户中最早的用户FirstName.

using (ED.NWEntities ctx = new ED.NWEntities())
{
    IQueryable<ED.User> Result = ctx.User.GroupBy(x => x.FirstName)
                                    .Select(y => y.OrderBy(z => z.BirthDate)
                                    .FirstOrDefault())
                                    .AsQueryable();
}

课程User:

public partial class User
{
    public int UserID { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public Nullable<System.DateTime> BirthDate { get; set; }
}

我想知道为什么这个语句花了这么长时间,直到我设置了一个断点Result并查看生成的SQL语句:

{SELECT
`Apply1`.`UserID`, 
`Apply1`.`FIRSTNAME1` AS `FirstName`, 
`Apply1`.`LastName`, 
`Apply1`.`BirthDate`
FROM (SELECT
`Distinct1`.`FirstName`, 
(SELECT
`Project2`.`UserID`
FROM `User` AS …

我对未编制索引的数据集上的GroupBy操作的渐近复杂度(大O)感兴趣.最着名的算法的复杂性是什么？SQL服务器和LINQ使用的算法的复杂性是什么？

我想知道如何实现这一目标？

我想从对象集合中只获取不同的名称

MyObject a = new Object();
a.Name = 'One';
a.Value = '10';


MyObject b = new Object();
b.Name = 'One';
b.Value = '15';


MyObject c = new Object();
c.Name = 'Two';
c.Value = '10';

所以我只想取回这个名字.在这种情况下,我不关心这个名称的价值.

所以我试过了

//将所有对象添加到集合中.

myCollection.Disinct()..Select(x => new MyClassToStore() {Text = x.Name, Value = x.Name}).ToList());

但是我需要在属性级别而不是在对象级别进行区分.所以我要回"一"和"两".现在我回来了"一个","一个"和"两个".

我看到一个名为morelinq的库,但我不确定是否应该使用它,因为它仍处于测试阶段,似乎不再开发了.

加上一个提取查询的整个库我不确定它是否值得.

我有这种情况:

class User
{
Id,
UserName
}

class UserRelationship
{
User GroupUser,
User MemberUser
}

and query

var query = QueryOver.Of<UserRelationship>()
.JoinqueryOver(x=>x.MemberUser)
.Where(x=>x.UserName == "TestUser");

现在我想返回List Distinct User,所以我不能这样做

TransformUsing(Transformers.DistinctRootEntity)

因为这会给我UserRelationship.

我需要这样的东西:

Select distinct user.ID 
from UserRelationship relationship
inner join User user on user.ID = relationship.MemberUser_ID

请帮助谢谢

代码:

news = (from New myNew in new News()
       select myNew).Distinct().ToList();

但是这个区别是具有相同值的"对象".myNew每个月我都需要在我的名单中.(一个用于一月,一个用于februaru,依此类推).比,news将获得12记录.

有可能是某种Distinct(myNew.Month)？

类似的还有这与正确的输入和输出类型涉及几个问题是这样.我的问题更多的是正确的做法,方法命名,选择参数类型,事故等维护中的唤醒IEnumerable.

Linq几乎所有地方都处理,IEnumerable而这不是它,但它也引入了一些我们称之为延迟执行的异类.现在,当我们认为最好的想法是采用最基本的类型时,我们可能在设计我们的方法(特别是扩展方法)时出错了.所以我们的方法看起来像:

public static IEnumerable<T> Shuffle<T>(this IEnumerable<T> lstObject)
{
    foreach (T t in lstObject)
       //some fisher-yates may be
}

显而易见的危险是当我们将上述功能与懒惰混合Linq并且如此易受影响时.

var query = foos.Select(p => p).Where(p => p).OrderBy(p => p); //doesn't execute
//but
var query = foos.Select(p => p).Where(p => p).Shuffle().OrderBy(p => p);
//the second line executes up to a point.

这是一个很大的编辑:

澄清上面这一行 - 我的问题不是关于第二个表达没有得到评估,严重不是.程序员都知道.我担心的是Shuffle到目前为止实际执行查询的方法.查看第一个查询,其中没有任何内容被执行.现在类似于构造另一个Linq表达式(应该稍后执行)时,我们的自定义函数正在播放spoilsport.换句话说,如何让调用者知道Shuffle并不是他们在Linq表达点上想要的那种功能.我希望这一点被带回家.道歉!:)虽然它就像去检查方法一样简单,但我问你们通常如何防御性地编程......

上面的例子可能没那么危险,但你明白了.这是某些(自定义)函数与Linq延迟执行的想法不相符.问题不仅在于性能,还在于意外的副作用. …

我有一个名为的自定义对象数组AnalysisResult.该数组可以包含数十万个对象; 并且,偶尔我只需要Distinct()该数组的元素.所以,我写了一个调用的项比较器类,AnalysisResultDistinctItemComparer并按我这样的方式调用:

public static AnalysisResult[] GetDistinct(AnalysisResult[] results)
{
    return results.Distinct(new AnalysisResultDistinctItemComparer()).ToArray();
}

我的问题是,当数组特别大(大于200,000个对象)时,此调用可能需要很长时间(大约几分钟).

我目前在后台工作程序中调用该方法并显示一个旋转gif,以警告用户该方法正在执行,并且应用程序尚未冻结.这一切都很好,但它没有给用户任何当前进展的指示.

我真的需要能够向用户指出此动作的当前进度; 但是,我一直无法想出一个好方法.我正在玩这样的事情:

public static AnalysisResult[] GetDistinct(AnalysisResult[] results)
{
    var query = results.Distinct(new AnalysisResultDistinctItemComparer());

    List<AnalysisResult> retVal = new List<AnalysisResult>();
    foreach(AnalysisResult ar in query)
    {
        // Show progress here
        retVal.Add(ar);
    }

    return retVal.ToArray();
}

但问题是我无法知道我的实际进展是什么.思考？建议？

我正在使用以下内容填充可观察集合：

var customers = new ObservableCollection<Customer>();

foreach (
    var customer in
        collListItem.Select(
            item =>
            new Customer
                {
                    Persona = item["Persona"].ToString(),
                    CustomerName = item["Title"].ToString()
                }))
{
    customers.Add(customer);
}

在使用此集合中的元素填充 WPF 数据网格之前，我想让它成为角色和客户的唯一列表（没有重复的行）。

我尝试为此使用以下内容：

customers = customers.Distinct();

但是我收到了错误：

无法将源类型“System.Collections.Generic.IEnumerable”转换为目标类型“System.Collections.ObjectModel.ObservableCollection”

是否有ObservableCollection我可以使用的等价物？

我有类的类列表

public class MyClass
{        
    public SomeOtherClass classObj;         
    public string BillId;           
}

public List<MyClass> myClassObject;

示例值:

BillId = "123",classObj = {},
BillId = "999",classObj = {},
BillId = "777",classObj = {},
BillId = "123",classObj = {}

所以在上面的例子中,我们有重复的值BillId.我想删除所有重复值(不区分),因此结果只包含999&777value.

实现这一目标的一种方法

• 遍历所有项目
• 得到独特的数量 BillId
• 如果count大于1,则将其存储BillId在另一个变量中
• 再次循环并基于删除项目 BillId

有没有直接的方法来实现这一目标？

我的目标就是这种形式

List<SignUp>

class SignUp
{
  public int Id { get ; set;}
  public int VersionId { get ; set;}
  public int PersonId{ get ; set;}
  public DateTime? SignUpDate { get ; set;}
}

人们注册到文档的版本.有些版本永远不会存档,他们每年都要辞职.所以我最终得到了像

SignUp s = new SignUp { Id = 1, VersionId = 1, PersonId = 5}
SignUp s2 = new SignUp { Id = 2, VersionId = 2, PersonId = 5}
SignUp s3 = new SignUp { Id = 3, VersionId = 1, PersonId = 5}

没有这个有s,s2,s3的列表在personId,versionId组合上有2个重复,它们是s&s3.唯一的事情是s3的Id比s高.因此我想消除s并只显示s2,s3(s是旧版本,我忽略它) …