/// <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");
}
