Improve tree perf

Author: badsyntax

.vscode/settings.json

@@ -59,5 +59,7 @@
     "waitfor",
     "wdio",
     "Xvfb"
-  ]
+  ],
+  "entityframework.project": "sample_dotnet/src/Infrastructure",
+  "entityframework.startupProject": "sample_dotnet/ExampleAPI"
 }

src/actions/ConfigureAction.ts

@@ -33,6 +33,7 @@ export class ConfigureAction implements IAction {
         value: configProject,
         options: {
           title: 'Select Project (1/2)',
+          ignoreFocusOut: true,
         },
         required: true,
       },
@@ -42,6 +43,7 @@ export class ConfigureAction implements IAction {
         value: configStartupProject,
         options: {
           title: 'Select Startup Project (2/2)',
+          ignoreFocusOut: true,
         },
         required: true,
       },

src/actions/RefreshTreeAction.ts

@@ -1,17 +1,10 @@
-import { clearTreeCache } from '../treeView/treeCache';
 import type { TreeDataProvider } from '../treeView/TreeDataProvider';
 import type { IAction } from './IAction';
 
 export class RefreshTreeAction implements IAction {
-  constructor(
-    private readonly treeDataProvider: TreeDataProvider,
-    private readonly clearCache = true,
-  ) {}
+  constructor(private readonly treeDataProvider: TreeDataProvider) {}
 
   public async run() {
-    if (this.clearCache) {
-      clearTreeCache();
-    }
     this.treeDataProvider.refresh();
   }
 }

src/commands/CommandProvider.ts

@@ -70,8 +70,7 @@ export class CommandProvider extends Disposable {
     );
     this.registerCommand(
       RefreshTreeCommand.commandName,
-      (clearCache: boolean) =>
-        new RefreshTreeCommand(treeDataProvider, clearCache),
+      () => new RefreshTreeCommand(treeDataProvider),
     );
     this.registerCommand(
       RefreshDbContextTreeCommand.commandName,

src/commands/RefreshTreeCommand.ts

@@ -5,14 +5,11 @@ import { Command } from './Command';
 export class RefreshTreeCommand extends Command {
   public static commandName = 'refreshTree';
 
-  constructor(
-    private readonly treeDataProvider: TreeDataProvider,
-    private readonly clearCache = true,
-  ) {
+  constructor(private readonly treeDataProvider: TreeDataProvider) {
     super();
   }
 
   public async run() {
-    await new RefreshTreeAction(this.treeDataProvider, this.clearCache).run();
+    await new RefreshTreeAction(this.treeDataProvider).run();
   }
 }

src/treeView/TreeDataProvider.ts

@@ -10,11 +10,17 @@ import { OpenMigrationFileCommand } from '../commands/OpenMigrationFileCommand';
 import type { Logger } from '../util/Logger';
 import { getProjectsConfig } from '../config/config';
 import { ProjectFilesProvider } from '../solution/ProjectFilesProvider';
+import { TreeItemCache } from './TreeItemCache';
+import { clearTreeCache } from './treeCache';
+
+export const treeDataProviderCache = new TreeItemCache<ProjectTreeItem[]>();
 
 export class TreeDataProvider
   extends Disposable
   implements vscode.TreeDataProvider<vscode.TreeItem>
 {
+  private readonly cacheId: string;
+
   private _onDidChangeTreeData: vscode.EventEmitter<
     TreeItem | undefined | null | void
   > = new vscode.EventEmitter<TreeItem | undefined | null | void>();
@@ -28,14 +34,19 @@ export class TreeDataProvider
     private readonly cli: CLI,
   ) {
     super();
+    this.cacheId = 'TreeDataProvider';
     const view = vscode.window.createTreeView(`${EXTENSION_NAMESPACE}Tree`, {
       treeDataProvider: this,
     });
     view.onDidChangeSelection(this.handleTreeItemSelection.bind(this));
     this.subscriptions.push(view);
 
     var onDidChangeConfiguration = vscode.workspace.onDidChangeConfiguration(
-      () => this.refresh(),
+      e => {
+        if (e.affectsConfiguration(EXTENSION_NAMESPACE)) {
+          this.refresh();
+        }
+      },
     );
     this.subscriptions.push(onDidChangeConfiguration);
   }
@@ -55,6 +66,7 @@ export class TreeDataProvider
   }
 
   public refresh(): void {
+    clearTreeCache();
     this._onDidChangeTreeData.fire();
   }
 
@@ -66,15 +78,24 @@ export class TreeDataProvider
     if (element) {
       return element.getChildren();
     } else {
+      const cachedChildren = treeDataProviderCache.get(this.cacheId);
+
+      if (cachedChildren) {
+        return cachedChildren;
+      }
+
       const { project } = getProjectsConfig();
       const { projectFiles } = await ProjectFilesProvider.getProjectFiles();
 
-      return projectFiles
+      const projectItems = projectFiles
         .filter(projectFile => !project || projectFile.name === project)
         .map(
           projectFile =>
             new ProjectTreeItem(this.logger, projectFile, this.cli),
         );
+
+      treeDataProviderCache.set(this.cacheId, projectItems);
+      return projectItems;
     }
   }
 }

src/treeView/treeCache.ts

@@ -1,7 +1,9 @@
 import { dbContextsCache } from './DbContextTreeItem';
 import { projectsCache } from './ProjectTreeItem';
+import { treeDataProviderCache } from './TreeDataProvider';
 
 export function clearTreeCache() {
   dbContextsCache.clearAll();
   projectsCache.clearAll();
+  treeDataProviderCache.clearAll();
 }