/// <summary> /// refresh composition point - because old one and selected have same hash, /// but they can differ in ArgumentsProvider. /// </summary> private void refreshSelectedCompositionPoint() { if (_selectedCompositionPoint == null) { //nothing selected - nothing to do return; } var component = _appDomain.Loader.GetComponentInfo(_selectedCompositionPoint.DeclaringComponent); if (component == null) { //component is no more available return; } var compositionPoints = component.CompositionPoints; foreach (var compPoint in compositionPoints) { if (_selectedCompositionPoint.Equals(compPoint)) { //refresh composition point _selectedCompositionPoint = compPoint; break; } } }
/// <summary> /// Get arguments for given composition point. /// </summary> /// <param name="compositionPoint">Composition point which arguments are requested.</param> /// <returns>Composition point's arguments.</returns> /// <exception cref="System.InvalidOperationException">Preparing composition point arguments failed</exception> private Instance[] getCompositionPointArguments(CompositionPoint compositionPoint) { var entryMethod = compositionPoint.EntryMethod; var entryArguments = new List <Instance>(); //prepare composition point arguments entryArguments.Add(_machine.CreateInstance(compositionPoint.DeclaringComponent)); if (compositionPoint.ArgumentProvider != null) { var result = _machine.Run(_loader, compositionPoint.ArgumentProvider); var context = result.EntryContext; for (var i = 0; i < Naming.GetMethodParamCount(entryMethod); ++i) { var argVariable = "arg" + i; var entryArgument = context.GetValue(new VariableName(argVariable)); entryArguments.Add(entryArgument); } if (result.RuntimeException != null) { throw new InvalidOperationException("Preparing composition point arguments failed", result.RuntimeException); } } return(entryArguments.ToArray()); }
/// <summary> /// Run analysis on given composition point. /// </summary> /// <param name="compositionPoint">Composition point to be analyzed.</param> private void runAnalysis(CompositionPoint compositionPoint) { _analysisError = null; try { var entryMethod = compositionPoint.EntryMethod; _loader.Settings.CodeBaseFullPath = getCodeBase(entryMethod); var entryArguments = getCompositionPointArguments(compositionPoint); _currentArguments = entryArguments; //run analysis on selected compsition with obtained arguments _currentResult = _machine.Run(_loader, entryMethod, entryArguments); _currentResult.OnViewCommit += (v) => { _vs.ForceFlushChanges(); }; handleRuntimeException(_currentResult.RuntimeException); } catch (Exception ex) { _currentArguments = null; _analysisError = _vs.LogErrorEntry(ex.Message, ex.ToString()); } }
/// <summary> /// Removes the composition point. /// </summary> /// <param name="compositionPoint">The composition point.</param> private void removeCompositionPoint(CompositionPoint compositionPoint) { DispatchedAction(() => { if (_compositionPoints.ContainsKey(compositionPoint)) { _compositionPointRemoves[compositionPoint.EntryMethod] = compositionPoint; } _compositionPointAdds.Remove(compositionPoint.EntryMethod); }); }
/// <summary> /// Event handler for composition point items. /// </summary> /// <param name="selectedCompositionPoint">The selected composition point.</param> private void onCompositionPointSelected(CompositionPoint selectedCompositionPoint) { DispatchedAction(() => { SelectedCompositionPoint = selectedCompositionPoint; if (CompositionPointSelected != null) { CompositionPointSelected(); } }); }
/// <summary> /// Creates the composition point item. /// </summary> /// <param name="compositionPoint">The composition point.</param> /// <returns>Created item.</returns> private ComboBoxItem createCompositionPointItem(CompositionPoint compositionPoint) { var itemContent = new TextBlock(); itemContent.Text = compositionPoint.EntryMethod.MethodString; var item = new ComboBoxItem(); item.Content = itemContent; item.Selected += (e, s) => { onCompositionPointSelected(compositionPoint); }; return(item); }
/// <summary> /// Create shortest distinguishing name for given composition point against names. /// </summary> /// <param name="names">Collection of unavailable names.</param> /// <param name="compositionPoint">Name of composition point to display.</param> /// <returns>Distinguish name.</returns> private string distinguishName(HashSet <string> names, CompositionPoint compositionPoint) { var rawName = Naming.GetMethodPath(compositionPoint.EntryMethod).Name; var compPointName = rawName.Replace("." + Naming.CtorName, "").Replace("." + Naming.ClassCtorName, ""); var subNames = compPointName.Split('.'); subNames = subNames.Reverse().ToArray(); //allow single part names for class names var minLength = rawName == compPointName ? 2 : 1; var distName = subNames[0]; for (var i = 1; (names.Contains(distName) || i < minLength) && subNames.Length > i; i++) { distName = subNames[i] + "." + distName; } names.Add(distName); return(distName); }
/// <summary> /// Show composition based on analysis of given method. /// </summary> /// <param name="compositionPoint">Composition point to be analyzed.</param> private void showComposition(CompositionPoint compositionPoint) { _vs.SafeRunAction(() => { if (_currentResult != null) { //invalidate result, to free up resources UserInteraction.DisposeResources(); } if (compositionPoint == null) { _guiManager.Display(null, true); _currentResult = null; } else { var watch = Stopwatch.StartNew(); runAnalysis(compositionPoint); _vs.Log.Message("Executing composition point {0}ms", watch.ElapsedMilliseconds); if (_analysisError == null) { watch.Restart(); //analysis has been successful var drawing = createDrawings(_currentResult); _guiManager.Display(drawing); _vs.Log.Message("Drawing composition point {0}ms", watch.ElapsedMilliseconds); } else { _guiManager.DisplayEntry(_analysisError); } } }, "Refreshing composition point"); }