LINQ独立项_Linq - Fatal编程技术网

LINQ独立项

linq

LINQ独立项,linq,Linq,我有一个包含约会的数据库。可以同时安排多个约会。我想检索一个不包括重复时间的可用约会时间列表编辑例如，我的数据库中可能有 REQUEST_ID REQUESTER_ID APPOINTMENT_TIME 1 0 30-JUN-13 03.30.00 AM 2 1 30-JUN-13 03.30.00 AM 3 0 30-JUN-13 03.

我有一个包含约会的数据库。可以同时安排多个约会。我想检索一个不包括重复时间的可用约会时间列表

编辑

例如，我的数据库中可能有

REQUEST_ID    REQUESTER_ID   APPOINTMENT_TIME
     1             0        30-JUN-13 03.30.00 AM
     2             1        30-JUN-13 03.30.00 AM
     3             0        30-JUN-13 03.30.00 AM
     4             0        30-JUN-13 03.30.00 AM
     5             3        30-JUN-13 03.35.00 AM
     6             0        30-JUN-13 03.45.00 AM
     7             0        30-JUN-13 03.45.00 AM

我想退货

REQUEST_ID    REQUESTER_ID   APPOINTMENT_TIME
     1             0        30-JUN-13 03.30.00 AM
     6             0        30-JUN-13 03.45.00 AM

结束编辑

此查询返回所有可用的约会时段

var data =
    (from a in db.FLU_SHOT
      where a.REQUESTER_ID == 0
      select a).ToArray();

此查询只返回次，我将丢失数据库中的其余信息

var times =
   (from a in data
    orderby Convert.ToDateTime(a.APPOINTMENT_TIME)
    select a.APPOINTMENT_TIME).Distinct().ToArray();

此查询返回与第一个查询相同的信息

var times =
   (from a in data
    orderby Convert.ToDateTime(a.APPOINTMENT_TIME)
    select a).Distinct().ToArray();

任何帮助都将不胜感激。

您正在寻找的

区别于

：

var times =
   (from a in data
    orderby Convert.ToDateTime(a.APPOINTMENT_TIME)
    select a).DistinctBy(a => a.APPOINTMENT_TIME).ToArray();

var times = data.GroupBy(d => Convert.ToDateTime(d.APPOINTMENT_TIME))
    .Select(g => g.First())
    .ToArray();

或者，您可以使用基本的

GroupBy

方法：

var times =
   (from a in data
    orderby Convert.ToDateTime(a.APPOINTMENT_TIME)
    select a).GroupBy(a => a.APPOINTMENT_TIME).Select(g => g.First()).ToArray();

或者我的自定义lambda相等比较器（这比

GroupBy

快，但比

DistinctBy

慢，正如Servy多次指出的那样）：

下面是它的代码：

public class PropertyEqualityComparer<TObject, TProperty> 
    : IEqualityComparer<TObject>
{
    Func<TObject, TProperty> _selector;
    IEqualityComparer<TProperty> _internalComparer;
    public PropertyEqualityComparer(Func<TObject, TProperty> propertySelector,
        IEqualityComparer<TProperty> innerEqualityComparer = null)
    {
        _selector = propertySelector;
        _internalComparer = innerEqualityComparer;
    }
    public int GetHashCode(TObject obj)
    {
        return _selector(obj).GetHashCode();
    }
    public bool Equals(TObject x, TObject y)
    {
        IEqualityComparer<TProperty> comparer = 
            _internalComparer ?? EqualityComparer<TProperty>.Default;
        return comparer.Equals(_selector(x), _selector(y));
    }
}
//and here's a class to help instantiate it with anonymous objects
public static class PropertyEqualityComparer
{
    public static PropertyEqualityComparer<TObject, TProperty>
        GetNew<TObject, TProperty>(Func<TObject, TProperty> propertySelector)
    { 
        return new PropertyEqualityComparer<TObject, TProperty>
            (propertySelector);
    }
    public static PropertyEqualityComparer<TObject, TProperty>
        GetNew<TObject, TProperty>
        (Func<TObject, TProperty> propertySelector, 
        IEqualityComparer<TProperty> comparer)
    { 
        return new PropertyEqualityComparer<TObject, TProperty>
            (propertySelector, comparer);
    }
}

公共类PropertyQualityComparer
：IEqualityComparer
{
函数选择器；
IEqualityComparer\u内部比较器；
公共财产资格比较人（Func Property Selector，
IEqualityComparer innerEqualityComparer=null）
{
_选择器=属性选择器；
_internalComparer=innerEqualityComparer；
}
公共int GetHashCode（TObject obj）
{
返回_选择器（obj）.GetHashCode（）；
}
公共布尔等于（TObject x，TObject y）
{
IEqualityComparer比较器=
_internalComparer？？EqualityComparer.Default；
返回比较器.Equals（_选择器（x），_选择器（y））；
}
}
//这里有一个类可以帮助用匿名对象实例化它
公共静态类PropertyQualityComparer
{
公共静态属性质量比较程序
GetNew（函数属性选择器）
{ 
返回新属性EqualityComparer
（属性选择器）；
}
公共静态属性质量比较程序
GetNew
（Func属性选择器，
IEqualityComparer（比较器）
{ 
返回新属性EqualityComparer
（属性选择器、比较器）；
}
}

您要查找的

不同于

：

var times =
   (from a in data
    orderby Convert.ToDateTime(a.APPOINTMENT_TIME)
    select a).DistinctBy(a => a.APPOINTMENT_TIME).ToArray();

var times = data.GroupBy(d => Convert.ToDateTime(d.APPOINTMENT_TIME))
    .Select(g => g.First())
    .ToArray();

或者，您可以使用基本的

GroupBy

方法：

var times =
   (from a in data
    orderby Convert.ToDateTime(a.APPOINTMENT_TIME)
    select a).GroupBy(a => a.APPOINTMENT_TIME).Select(g => g.First()).ToArray();

或者我的自定义lambda相等比较器（这比

GroupBy

快，但比

DistinctBy

慢，正如Servy多次指出的那样）：

下面是它的代码：

public class PropertyEqualityComparer<TObject, TProperty> 
    : IEqualityComparer<TObject>
{
    Func<TObject, TProperty> _selector;
    IEqualityComparer<TProperty> _internalComparer;
    public PropertyEqualityComparer(Func<TObject, TProperty> propertySelector,
        IEqualityComparer<TProperty> innerEqualityComparer = null)
    {
        _selector = propertySelector;
        _internalComparer = innerEqualityComparer;
    }
    public int GetHashCode(TObject obj)
    {
        return _selector(obj).GetHashCode();
    }
    public bool Equals(TObject x, TObject y)
    {
        IEqualityComparer<TProperty> comparer = 
            _internalComparer ?? EqualityComparer<TProperty>.Default;
        return comparer.Equals(_selector(x), _selector(y));
    }
}
//and here's a class to help instantiate it with anonymous objects
public static class PropertyEqualityComparer
{
    public static PropertyEqualityComparer<TObject, TProperty>
        GetNew<TObject, TProperty>(Func<TObject, TProperty> propertySelector)
    { 
        return new PropertyEqualityComparer<TObject, TProperty>
            (propertySelector);
    }
    public static PropertyEqualityComparer<TObject, TProperty>
        GetNew<TObject, TProperty>
        (Func<TObject, TProperty> propertySelector, 
        IEqualityComparer<TProperty> comparer)
    { 
        return new PropertyEqualityComparer<TObject, TProperty>
            (propertySelector, comparer);
    }
}

公共类PropertyQualityComparer
：IEqualityComparer
{
函数选择器；
IEqualityComparer\u内部比较器；
公共财产资格比较人（Func Property Selector，
IEqualityComparer innerEqualityComparer=null）
{
_选择器=属性选择器；
_internalComparer=innerEqualityComparer；
}
公共int GetHashCode（TObject obj）
{
返回_选择器（obj）.GetHashCode（）；
}
公共布尔等于（TObject x，TObject y）
{
IEqualityComparer比较器=
_internalComparer？？EqualityComparer.Default；
返回比较器.Equals（_选择器（x），_选择器（y））；
}
}
//这里有一个类可以帮助用匿名对象实例化它
公共静态类PropertyQualityComparer
{
公共静态属性质量比较程序
GetNew（函数属性选择器）
{ 
返回新属性EqualityComparer
（属性选择器）；
}
公共静态属性质量比较程序
GetNew
（Func属性选择器，
IEqualityComparer（比较器）
{ 
返回新属性EqualityComparer
（属性选择器、比较器）；
}
}

每当我试图用LINQ（最终查询数据库）完成某件事情，而答案并不明显时，我首先编写SQL语句，然后找出如何将其转换为LINQ

如果您不知道如何进行翻译，那么您可以在线找到一个工具来提供帮助，或者您可以将查询转换为存储的proc或UDF，并从数据上下文调用它

在中等到高度复杂的查询中，手工编写几乎总是更好的。最有可能的是，LINQ吐出的任何东西都不会针对您的特定场景进行优化。通常，您可以诱使LINQ输出您想要的查询，但到那时，您已经浪费了大量宝贵的时间，而这些时间本可以花在其他更有效率的事情上

编辑：

为了更直接地回答你的问题，看起来你主要对约会时间感兴趣。在这种情况下，对该列进行分组，然后您可以循环遍历每个组并获得时间。

每当我试图使用LINQ（最终查询数据库）完成某项任务，并且答案不明显时，我首先编写SQL语句，然后找出如何将其转换为LINQ

如果您不知道如何进行翻译，那么您可以在线找到一个工具来提供帮助，或者您可以将查询转换为存储的proc或UDF，并从数据上下文调用它

编辑：

为了更直接地回答你的问题，看起来你主要对约会时间感兴趣。在这种情况下，对该列执行分组，然后您可以循环遍历每个组并获取时间。

您可以使用

GroupBy

：

var times =
   (from a in data
    orderby Convert.ToDateTime(a.APPOINTMENT_TIME)
    select a).DistinctBy(a => a.APPOINTMENT_TIME).ToArray();

var times = data.GroupBy(d => Convert.ToDateTime(d.APPOINTMENT_TIME))
    .Select(g => g.First())
    .ToArray();

您可以使用

GroupBy

：

var times =
   (from a in data
    orderby Convert.ToDateTime(a.APPOINTMENT_TIME)
    select a).DistinctBy(a => a.APPOINTMENT_TIME).ToArray();

var times = data.GroupBy(d => Convert.ToDateTime(d.APPOINTMENT_TIME))
    .Select(g => g.First())
    .ToArray();

您的第一个、第二个和第三个查询差异很大。第二个和第三个查询在第一个查询之后运行，试图进一步细分数据。我正在分享我的尝试。您的第一个、第二个和第三个查询差异很大。第二个和第三个运行