private void ExpandAndSelectNode(BenchmarkTreeNode previousSelection)
{
List <BenchmarkTreeNode> previousPath = BuildPreviousPath(previousSelection);
ObservableCollection <BenchmarkTreeNode> currentNodes = Nodes;
for (int i = 0; i < previousPath.Count; i++)
{
BenchmarkTreeNode previousNode = previousPath[i];
var newNode = currentNodes.FirstOrDefault(c => c.NodeName == previousNode.NodeName);
if (newNode == null)
{
return;
}
newNode.IsExpanded = true;
if (i == previousPath.Count - 1)
{
newNode.IsSelected = true;
SelectedBenchmark = newNode;
}
currentNodes = newNode.Nodes;
}
}
private BenchmarkTreeNode GetOrInsertNode(BenchmarkTreeNode parent, string nodeName, Func <BenchmarkTreeNode, BenchmarkTreeNode> createFunc)
{
int previousIndex = 0;
foreach (var currentNode in parent.Nodes)
{
int comparisonResult = string.Compare(nodeName, currentNode.NodeName);
if (comparisonResult == 0)
{
return(currentNode);
}
else if (comparisonResult < 0)
{
break;
}
previousIndex++;
}
var newNode = createFunc(parent);
newNode.TreeViewModel = _treeViewModel;
parent.Nodes.Insert(previousIndex, newNode);
return(newNode);
}
public BenchmarkTreeNode(BenchmarkTreeNode parent, string nodeName)
{
Parent = parent;
NodeName = nodeName;
Nodes = new ObservableCollection <BenchmarkTreeNode>();
RunSelectedCommand = new AsyncDelegateCommand(async() => await TreeViewModel.CommandHandler.RunAsync(false));
DryRunSelectedCommand = new AsyncDelegateCommand(async() => await TreeViewModel.CommandHandler.RunAsync(true));
GoToCodeCommand = new AsyncDelegateCommand(async() => await TreeViewModel.CommandHandler.GoToCodeAsync(Benchmark.Project, TargetSymbol), () => SupportsGoToCode);
}
private void BuildNamespaceClassHierarchy(ObservableCollection <BenchmarkTreeNode> nodeList, ProjectBenchmarkTreeNode projectNode, Benchmark benchmark)
{
BenchmarkTreeNode lastNamespaceNode = projectNode;
string[] namespaceParts = benchmark.Namespace.Split('.');
foreach (var namespacePart in namespaceParts)
{
lastNamespaceNode = GetOrInsertNode(lastNamespaceNode, namespacePart, p => CreateNamespaceNode(p, namespacePart));
}
var classNode = GetOrInsertNode(lastNamespaceNode, benchmark.ClassName, p => CreateClassNode(p, benchmark));
GetOrInsertNode(classNode, benchmark.MethodName, p => CreateMethodNode(p, benchmark));
}
private static List <BenchmarkTreeNode> BuildPreviousPath(BenchmarkTreeNode previousSelection)
{
List <BenchmarkTreeNode> previousPath = new List <BenchmarkTreeNode>();
previousPath.Add(previousSelection);
BenchmarkTreeNode current = previousSelection;
while (current.Parent != null)
{
previousPath.Add(current.Parent);
current = current.Parent;
}
previousPath.Reverse();
return(previousPath);
}
public async Task RefreshAsync(IBenchmarkDiscoverer discoverer, Grouping grouping)
{
_discoveredBenchmarks.Clear();
var benchmarks = discoverer.FindBenchmarks().Select(b =>
{
_discoveredBenchmarks.Add(b);
return(b);
});
BenchmarkTreeNode previousSelection = SelectedBenchmark;
BenchmarkNodeBuilder nodeBuilder = new BenchmarkNodeBuilder(this, grouping);
await nodeBuilder.RebuildNodesAsync(benchmarks);
if (Nodes.Sum(n => n.TotalNodeCount) <= 20)
{
ExpandAll();
}
if (previousSelection != null)
{
ExpandAndSelectNode(previousSelection);
}
}
private BenchmarkTreeNode CreateMethodNode(BenchmarkTreeNode parent, Benchmark benchmark)
{
return(new MethodBenchmarkTreeNode(parent, benchmark, benchmark.MethodName));
}
private BenchmarkTreeNode CreateClassNode(BenchmarkTreeNode parent, Benchmark benchmark)
{
return(new ClassBenchmarkTreeNode(parent, benchmark, benchmark.ClassName));
}
private BenchmarkTreeNode CreateCategoryNode(BenchmarkTreeNode parent, string category)
{
return(new CategoryBenchmarkTreeNode(parent, category));
}
private BenchmarkTreeNode CreateNamespaceNode(BenchmarkTreeNode parent, string namespacePart)
{
return(new NamespaceBenchmarkTreeNode(parent, namespacePart));
}
public MethodBenchmarkTreeNode(BenchmarkTreeNode parent, Benchmark benchmark, string methodName) : base(parent, methodName)
{
_benchmark = benchmark;
Parent?.IncrementChildNodeCount();
}
public ClassBenchmarkTreeNode(BenchmarkTreeNode parent, Benchmark benchmark, string className) : base(parent, className)
{
_benchmark = benchmark;
}
public CategoryBenchmarkTreeNode(BenchmarkTreeNode parent, string categoryName) : base(parent, categoryName)
{
}
public NamespaceBenchmarkTreeNode(BenchmarkTreeNode parent, string namespaceName) : base(parent, namespaceName)
{
}
