Abrufen von Datensätzen aus der Datenbank in der Baumstruktur

Question

Ich versuche, die Datensätze aus der Datenbank abzurufen.

Meine Datenbanktabellen:

1. Abteilungen
2. EmployeeDepartments (Intermediate Tisch Abteilung ---> Mitarbeiter)
3. Mitarbeiter
4. EmployeeLocations (Mittel für Mitarbeiter Tabelle - -> Standorte)
5. Standorte

Die obigen Tabellen enthalten große Datensätze.

würden Meine Daten erzeugt auf der unten gezeigten Struktur basieren:

Was ich versucht:

Mein erster Ansatz:

using(SQLConnection con = new SQLConnection()) 
{ 
    //Get all the departments 
    List<Department> departmentList = sp.GetAllDeparments(); 

    foreach(Deparment deparment in departmentList){ 

    //Get all employees 
    List<Employee> employeeList= sp.GetEmployeesByDepartment(departmentId); 

     foreach(Employee employee in employeeList){ 

      //Get all locations 
      List<Location> locationList= sp.GetLocationsByEmployee(employeeId); 

      foreach(Location location in locationList){ 
        //Code for location generation for PDF. 
      } 
     } 
    } 
} 

Der obige Code braucht ungefähr 6 Minuten, wenn ich die Datenbank in foreach Schleifen anschlage.

Mein zweiter Ansatz:

//Get all the departments 
List<Department> departmentList = sp.GetAllDeparments(); 

//Get all employees 
List<Employee> employeeList= sp.GetAllEmployees(); 

//Get all locations 
List<Location> locationList= sp.GetAllLocations(); 

//Get EmployeeLocations List<EmployeeLocations> emplocationList= 
sp.GetAllEmployeeLocations(); 

//Get EmployeeDepartments List<EmployeeDepartments> empDepList= 
sp.GetAllEmployeeDepartments(); 

foreach(Deparment deparment in departmentList){ 

    foreach(Employee employee in employeeList){ 

     foreach(Location location in locationList){ 

     } 
    } 
} 

ich alle Datensätze aus allen oben genannten Tabellen bin Abrufen und in foreach-Code mit LINQ zu manipulieren. So reduziert sich die Zeit von 6 Minuten auf 4 Minuten.

Meine Frage: Was wäre der effiziente Weg, um die Daten in kürzester Zeit wie möglich zu holen. in dieser Art von Szenario?

Ich brauche die Daten im obigen Bild manipuliert.

Answer 1

Frage & Vorschlag;

Wenn die SQL-Verbindung wiederholt geöffnet wird, wenn die Daten aus der Liste empfängt, nur eine Anfrage an die Datenbank erforderlich ist. Sie benötigen , um die Liste aufzulisten, wenn mehrere Vorkommen in dieser Anforderung vorhanden sind.

Ergebnis: Die Anforderung sollte einmal an die Datenbank gesendet werden. Wenn alle Listen mit der Wörterbuchmethode abgerufen werden, wird eine Leistungssteigerung von 15% erreicht. Wenn Sie mit wirklich großen Daten arbeiten, können Sie arbeiten asynchron

Wir müssen die Inhalte der Funktionen sehen, die mit bekommen starten, wenn mehr Details benötigt wird.

Answer 2

Der zweite Ansatz mit weniger Datenbank-Roundtrips ist viel besser. Aber nach Ihrem Kommentar

Obwohl ich derzeit den zweiten Ansatz verwende, ist das Abrufen der Daten auf einmal und das Speichern im Speicher kein Problem. Aber während ich foreach mache, benutze ich LambdaExpression. Das braucht Zeit.

sieht aus wie Ihr Verarbeitungsteil viele ineffiziente lineare Suchen verwendet. Es kann erheblich verbessert werden, indem eine schnelle Hash-basierte Nachschlagedatenstruktur erstellt und verwendet wird.

In diesem speziellen Fall benötigen Sie zwei dictionaries für die schnelle Lokalisierung der Mitarbeiter nach PK und Standort von PK, und zwei lookups für die schnelle Lokalisierung von Mitarbeitern nach Abteilung PK und Standorten von Mitarbeiter PK.

Ihr Klassenmodell Unter der Annahme ist so etwas wie dieses (Sie es mit den tatsächlichen Eigenschaftsnamen/Typen ändern können):

class Department 
{ 
    public int Id { get; set; } // PK 
    // Other properties... 
} 

class Employee 
{ 
    public int Id { get; set; } // PK 
    // Other properties... 
} 

class Location 
{ 
    public int Id { get; set; } // PK 
    // Other properties... 
} 

class EmployeeDepartment 
{ 
    public int EmployeeId { get; set; } // FK 
    public int DepartmentId { get; set; } // FK 
} 

class EmployeeLocation 
{ 
    public int EmployeeId { get; set; } // FK 
    public int LocationId { get; set; } // FK 
} 

Dann könnte die Verarbeitung wie folgt sein:

//Fetch all necessary data 
List<Department> departmentList = sp.GetAllDeparments();  
List<Employee> employeeList = sp.GetAllEmployees(); 
List<Location> locationList = sp.GetAllLocations(); 
List<EmployeeLocation> employeeLocationList = sp.GetAllEmployeeLocations(); 
List<EmployeeDepartment> employeeDepartmentList = sp.GetAllEmployeeDepartments(); 

// Build the helper fast lookup structures 
var employeeById = employeeList.ToDictionary(e => e.Id); 
var locationById = locationList.ToDictionary(e => e.Id); 
var employeesByDepartmentId = employeeDepartmentList.ToLookup(e => e.DepartmentId, e => employeeById[e.EmployeeId]); 
var locationsByEmployeeId = employeeLocationList.ToLookup(e => e.EmployeeId, e => locationById[e.LocationId]); 

// The processing 
foreach (Department deparment in departmentList) 
{ 
    foreach (Employee employee in employeesByDepartmentId[deparment.Id]) 
    { 
     foreach (Location location in locationsByEmployeeId[employee.Id]) 
     { 

     } 
    } 
}