IEnumerable zu HashSet Umwandlung in LINQ optimieren

Question

public HashSet<Student> GetStudents(int studentId) 
{ 
    IEnumerable<Student> studentTypes = this.studentTypes .Where(x => (x.studentID== studentId)); 
    if (studentTypes .FirstOrDefault() != null) 
    { 

     //return new HashSet<Student>(studentTypes); 
     return studentTypes.ToHashSet(); 
    } 
    else 
    { 
     return new HashSet<Student>(); 
    } 
} 

public static class LinqUtilities 
{ 
    public static HashSet<T> ToHashSet<T>(this IEnumerable<T> enumerable) 
    { 
     HashSet<T> hashSet = new HashSet<T>(); 

     foreach (var en in enumerable) 
     { 
      hashSet.Add(en); 
     } 

     return hashSet; 
    } 
} 

Diese Funktion heißt oft tausend mal sagen, und es gibt 5000 Studenten in der Ergebnismenge. Wie kann ich diese Funktion optimieren? Ich weiß, dass die Konvertierung von IEnumerable zu HashSet viel Overhead verursacht. ToHashSet ist meine Erweiterungsmethode. Diese Funktion ist zu langsam und essen eine Menge Zeit.

Answer 1

Erstens brauchen Sie nicht die Hashset Werte aufzuzählen in Ihrem Dienstprogramme funktionieren Sie die effiziente Verwendung von schöner statischer Dehnung Klasse von @ Jon geschrieben verbessern könnten

Converting linq result to hashset

und ich denke, Ihnen don Sie müssen den FirstOrDefault nicht überprüfen, da die Erweiterung das neue Schülerobjekt mit T behandelt, damit Sie sauberer und aufgeräumter werden können.

IEnumerable<Student> studentTypes = this.studentTypes.Where(x => (x.studentID== studentId)); 
return studentTypes.toHashSet(); 

Die andere Option ist, dass Sie nicht laufen passieren kann

Sie IEnumerable in Ihrem Konstruktor für HashSet wie

HashSet<Student> studentTypes = new HashSet<Student>(this.studentTypes.Where(x => (x.studentID== studentId))); 

so dass Sie nur eine Zeile Code haben in Ihrer GetStudents Funktion

Answer 2

Sie die Abfrage zweimal pro Anruf.

//sets up a deferred query. This query will be "executed" when enumerated. 
IEnumerable<Student> studentTypes = this.studentTypes 
    .Where(x => (x.studentID== studentId)); 

//enumeration #1 (stops on first hit) 
if (studentTypes .FirstOrDefault() != null) 
{ 
    //enumeration #2 
    return studentTypes.ToHashSet(); 

Ihr Zustand ist nicht notwendig:

//sets up a deferred query. This query will be "executed" when enumerated. 
IEnumerable<Student> studentTypes = this.studentTypes 
    .Where(x => (x.studentID== studentId)); 

//enumeration #1 
return studentTypes.ToHashSet(); 

---

Ich weiß, dass die Umwandlung von IEnumerable Hasste viele die Gemeinkosten

Das Stier verursacht. Sie haben nichts gemessen und führen sich selbst in die Irre, um den falschen Teil des Codes zu optimieren.