與LINQ

Question

我在審計類的日誌條目列表凝結事件列表

public class Audit 
{ 
    public DateTime TimeStamp { get; set; } 
    public string User { get; set; } 
    public string AuditType { get; set; } 
} 

所以列表可能是這樣的;

20140206 11:29:20 Owen Open 
20140206 11:29:21 Owen Close 
20140206 11:31:20 Owen Open 
20140206 11:32:20 Owen Close 
20140206 11:42:20 Owen Open 
20140206 11:50:00 Owen Acknowledge 

這給了我們1秒1分40秒的空白。所以開放時間最長的是中間一對1分鐘，然後在11:50確認。我正在尋找日期對，它是開放的時間，在這種情況下是1分鐘。

我知道我可以按順序處理列表，並使用TimeSpan找到最大的差距，但我認爲有一種整潔的LINQ方式可以與組一起使用？

UPDATE這並不漂亮，但這是真的擴大散步邏輯

var audits = notice.AuditEntries.Where(a => a.User == user); 

DateTime? currentOpen = null; 
DateTime? bestOpen = null; 
DateTime? bestClose = null; 
foreach (var audit in audits) 
{ 
    if (audit.AuditType == "Open") 
    { 
     if (currentOpen.HasValue) continue; 
     currentOpen = audit.TimeStamp; 
    } 
    if (audit.AuditType == "Close" || audit.AuditType == "Acknowledge") 
    { 
     if (currentOpen.HasValue) 
     { 
      DateTime? currentClose = audit.TimeStamp; 
      if (!bestOpen.HasValue) 
      { 
      bestOpen = currentOpen; 
      bestClose = currentClose; 
      } 
      else 
      { 
      if (bestClose.Value.Subtract(bestOpen.Value) >            currentClose.Value.Subtract(currentOpen.Value)) 
      { 
       bestOpen = currentOpen; 
       bestClose = currentClose; 
      } 
      } 
     currentOpen = null; 
     } 
     } 
    } 

Answer 1

：

IEnumerable<Audit> audits = ... 

var longestAuditsByUser = audits.OrderBy(a => a.Timestamp) 
    // group by user, since presumably we don't want to match an open from one user with a close from another 
    .GroupBy(a => a.User) 
    .Select(userAudits => 
    { 
     // first, align each audit entry with it's index within the entries for the user 
     var indexedAudits = userAudits.Select((audit, index) => new { audit, index }); 
     // create separate sequences for open and close/ack entries 
     var starts = indexedAudits.Where(t => t.audit.AuditType == "Open"); 
     var ends = indexedAudits.Where(t => t.audit.AuditType == "Close" || t.audit.AuditType == "Acknowledge"); 

     // find the "transactions" by joining starts to ends where start.index = end.index - 1 
     var pairings = starts.Join(ends, s => s.index, e => e.index - 1, (start, end) => new { start, end }); 

     // find the longest such pairing with Max(). This will throw if no pairings were 
     // found. If that can happen, consider changing this Select() to SelectMany() 
     // and returning pairings.OrderByDescending(time).Take(1) 
     var longestPairingTime = pairings.Max(t => t.end.Timestamp - t.start.Timestamp); 
     return new { user = userAudits.Key, time = longestPairingTime }; 
    }); 

// now that we've found the longest time for each user, we can easily find the longest 
// overall time as well 
var longestOverall = longestAuditsByUser.Max(t => t.time); 

Answer 2

未經測試，但應該工作：我認爲這將這樣的伎倆

var auditGaps = audits 
    .GroupBy(a => a.User) 
    .Select(g => new 
    { 
     User = g.Key, 
     MinOpen = g.Where(a => a.AuditType == "Open").Select(a=> a.TimeStamp).Min(), 
     MaxClosed = g.Where(a => a.AuditType == "Close").Select(a=> a.TimeStamp).Max(), 
     MaxAcknowledge = g.Where(a => a.AuditType == "Acknowledge").Select(a=> a.TimeStamp).Max() 
    }) 
    .Select(x => new 
    { 
     x.User, 
     LargestOpenCloseGap = x.MaxClosed - x.MinOpen, 
     LargestOpenAcknowledgeGap = x.MaxAcknowledge - x.MinOpen 
    });