.ToListAsync() vs .ToList() + Task.Run

Question

Ich habe eine WPF-Anwendung.

Die Daten werden vom Repository zum ViewModel übertragen. Was wäre der bessere Weg, um die Daten abzurufen:

Methode 1:

In Repository:

public List<LogDetail> GetLogsOfTypeForCase(int caseId, LoggType logType) 
    { 
     using (var ctx = new SidraEntitiesNoChangesDetection()) 
     { 
      var logs = (from l in ctx.Loggs 
       where l.log_fk_caseid == caseId && l.log_operation == logType.ToString() 
       select new LogDetail() 
       { 
        ColumnName = l.log_columnname, 
        DateAndTime = l.log_dateandtime, 
        IdentificationDetail = l.log_identificationDetail, 
        NewValue = l.log_new_value, 
        OldValue = l.log_old_value, 
        TableName = l.log_tablename, 
        UserCode = l.User.usr_code 
       }).ToList(); 

      return logs; 
     } 
    } 

In Ansichtsmodell:

await Task.Run(
      () => 
      { 
       if (false == this.CancellationTokenSource.IsCancellationRequested) 
       { 
        this.CaseLogs = this.dataAdapter.GetLogsOfTypeForCase(this.CaseId, LoggType.S); 
       } 

      }, 
      this.CancellationTokenSource.Token 
      ); 

oder Methode 2

In Repository:

public async Task<List<LogDetail>> GetLogsOfTypeForCase(int caseId, LoggType logType) 
    { 
     using (var ctx = new SidraEntitiesNoChangesDetection()) 
     { 
      var logs = await (from l in ctx.Loggs 
       where l.log_fk_caseid == caseId && l.log_operation == logType.ToString() 
       select new LogDetail() 
       { 
        ColumnName = l.log_columnname, 
        DateAndTime = l.log_dateandtime, 
        IdentificationDetail = l.log_identificationDetail, 
        NewValue = l.log_new_value, 
        OldValue = l.log_old_value, 
        TableName = l.log_tablename, 
        UserCode = l.User.usr_code 
       }).ToListAsync(); 

      return logs; 
     } 
    } 

und in Ansichtsmodell

protected override async void Load() 
    { 
      if (false == this.CancellationTokenSource.IsCancellationRequested) 
      { 
       this.CaseLogs = await this.dataAdapter.GetLogsOfTypeForCase(this.CaseId, LoggType.S); 
      } 
    } 

Von dem, was ich gelesen habe, Methode 1 bevorzugt würde, aber was die Vorteile sein?

Answer 1

Methode 2 ist vorzuziehen, da ein Thread weniger verwendet wird.

Es kann auch (mit einigen Modifikationen) richtig unterstützen Stornierung:

public async Task<List<LogDetail>> GetLogsOfTypeForCase(int caseId, LoggType logType, CancellationToken token) 
{ 
    ... 
     }).ToListAsync(token); 
    ... 
} 

protected override async void Load() 
{ 
    this.CaseLogs = await this.dataAdapter.GetLogsOfTypeForCase(this.CaseId, LoggType.S, this.CancellationTokenSource.Token); 
} 

Answer 2

Methode 2. Die Async-Versionen dieser Methoden machen das "Heavy Lifting" für Sie, für das sie entwickelt wurden. Task.Run() ist ein schwerer Prozess-Aufruf, Sie müssen alle möglichen Fehler und Ausfälle selbst behandeln, Sie brauchen hier keinen Vorschlaghammer, nur einen leichten Fertigschlaghammer.

Damit meine ich, dass Sie versuchen zu erstellen, was das Framework für Sie bereits getan hat, das ist, wo Async-Anrufe verwendet werden sollten, also warum nicht nur sie verwenden?