private static void _ExportsChanged(object sender, ExportsChangeEventArgs args)
{
try
{
if (args.AddedExports != null)
{
_ParseExports("** Added Export: ", args.AddedExports);
}
if (args.RemovedExports != null)
{
_ParseExports("** Removed Export: ", args.RemovedExports);
}
if (args.ChangedContractNames != null)
{
var first = true;
foreach (var contract in args.ChangedContractNames)
{
if (first)
{
Console.WriteLine("=== Contracts Changed ===");
first = false;
}
Console.WriteLine(" ==>{0}", contract);
}
}
}
catch(Exception ex)
{
Console.WriteLine("### MEF Debugger Error: {0}", ex.Message);
}
}
void SourceExportsChanging(object sender, ExportsChangeEventArgs e)
{
if (SentByThis(e))
return;
OnExportsChanging(ProjectChangeEvent(e));
}
ExportsChangeEventArgs ProjectChangeEvent(ExportsChangeEventArgs e)
{
var satisfiedImports = _importDefinitionCache.Values;
return new TaggedExportsChangedEventArgs(
this,
ProjectProductExportsIntoSatsifedCreatorExports(satisfiedImports, e.AddedExports),
ProjectProductExportsIntoSatsifedCreatorExports(satisfiedImports, e.RemovedExports),
e.AtomicComposition);
}
private void ExportsChangeing(object sender, ExportsChangeEventArgs exportsChangeEventArgs)
{
VisualServieMetadatas =
new ObservableCollection<IVisualServiceMetadata>(
VisualMainWindow.ApplicationProxy.VisualModuleManager.GetVisualServicesMetadata()
.OrderBy(s => s.Descriptor));
}
private void OnExportChangingInternal(object sender, ExportsChangeEventArgs e)
{
this.OnExportsChanging(e);
}
/// <summary>
/// Fired when exports are changing.
/// </summary>
/// <param name="sender">The sender of the event.</param>
/// <param name="e">The event arguments.</param>
private void SourceExportsChanging(object sender, ExportsChangeEventArgs e)
{
if (!SelfSent(e))
return;
OnExportsChanging(ProjectChangeEvent(e));
}
/// <summary>
/// Creates a new instance of <see cref="TaggedExportsChangeEventArgs" /> for the given event arguments.
/// </summary>
/// <param name="e">The event arguments.</param>
/// <returns>A new instance of <see cref="TaggedExportsChangeEventArgs" /> for the given event arguments.</returns>
private TaggedExportsChangeEventArgs ProjectChangeEvent(ExportsChangeEventArgs e)
{
var satisfiedImports = _definitionCache.Values;
return new TaggedExportsChangeEventArgs(
this,
ProjectExportsDefinitions(satisfiedImports, e.AddedExports),
ProjectExportsDefinitions(satisfiedImports, e.RemovedExports),
e.AtomicComposition);
}
/// <summary>
/// Raises the <see cref="ExportsChanging"/> event.
/// </summary>
/// <param name="e">
/// An <see cref="ExportsChangeEventArgs"/> containing the data for the event.
/// </param>
protected virtual void OnExportsChanging(ExportsChangeEventArgs e)
{
EventHandler<ExportsChangeEventArgs> changingEvent = this.ExportsChanging;
if (changingEvent != null)
{
CompositionResult result = CompositionServices.TryFire(changingEvent, this, e);
result.ThrowOnErrors(e.AtomicComposition);
}
}
private void OnExportChangingInternal(object?sender, ExportsChangeEventArgs e)
{
OnExportsChanging(e);
}
internal void OnExportsChangedInternal(object?sender, ExportsChangeEventArgs e)
{
OnExportsChanged(e);
}
private void OnExportChangedInternal(object sender, ExportsChangeEventArgs e)
{
this.OnExportsChanged(e);
}
private void Action(object sender, ExportsChangeEventArgs exportsChangeEventArgs)
{
VisualServiceMetadatas = new ObservableCollection<MetadataEx>(Module.Context.ServicePool.GetMetadatas<IVisualServiceMetadata>().Select(s => new MetadataEx(s)));
ServiceMetadatas = new ObservableCollection<MetadataEx>(Module.Context.ServicePool.GetAllMetadata().Select(s => new MetadataEx(s)).Except(VisualServiceMetadatas));
}
private void Recompose(object sender, ExportsChangeEventArgs e)
{
Recompose();
}
protected virtual new void OnExportsChanging(ExportsChangeEventArgs e)
{
}
protected virtual new void OnExportsChanging(ExportsChangeEventArgs e)
{
Contract.Requires(e != null);
}
bool SentByThis(ExportsChangeEventArgs e)
{
return e is TaggedExportsChangedEventArgs &&
((TaggedExportsChangedEventArgs)e).Sender == this;
}
private void ContainerExportsChanged(object sender, ExportsChangeEventArgs e) {
// figure out the new extensions...
var extensions = _container.GetExports<IAnalysisExtension, IDictionary<string, object>>();
HashSet<IAnalysisExtension> newExtensions = new HashSet<IAnalysisExtension>();
lock (_registeredExtensions) {
foreach (var extension in extensions) {
if (!_registeredExtensions.Contains(extension.Value)) {
newExtensions.Add(extension.Value);
if (extension.Metadata.ContainsKey("Name") && extension.Metadata["Name"] is string) {
_extensionsByName[(string)extension.Metadata["Name"]] = extension.Value;
} else {
Console.Error.WriteLine("Extension {0} has no name, will not respond to commands", extension.Value);
}
}
}
_registeredExtensions.UnionWith(newExtensions);
}
// inform them of the analyzer...
foreach (var extension in newExtensions) {
extension.Register(_pyAnalyzer);
}
}
private void OnExportsChangingInternal(object?sender, ExportsChangeEventArgs e)
{
UpdateRejections(e.AddedExports.Concat(e.RemovedExports), e.AtomicComposition);
}
void provider_ExportsChanged(object sender, ExportsChangeEventArgs args)
{
Contract.Requires<ArgumentNullException>(sender != null);
Contract.Requires<ArgumentNullException>(args != null);
OnExportsChanged(args);
}
internal void OnExportsChangingInternal(object sender, ExportsChangeEventArgs e)
{
OnExportsChanging(e);
}
/// <summary>
/// Determines if the specified event arguments were sent by this instance.
/// </summary>
/// <param name="e">The event arguments.</param>
/// <returns>True if the specified event arguments were sent by this instance, otherwise false.</returns>
private bool SelfSent(ExportsChangeEventArgs e)
{
return (e is TaggedExportsChangeEventArgs
&& ((TaggedExportsChangeEventArgs)e).Sender == this);
}
private void OnExportsChanging(object sender, ExportsChangeEventArgs e)
{
CompositionResult result = CompositionResult.SucceededResult;
// Prepare for the recomposition effort by minimizing the amount of work we'll have to do later
AtomicComposition atomicComposition = e.AtomicComposition;
IEnumerable<PartManager> affectedParts = this._recompositionManager.GetAffectedParts(e.ChangedContractNames);
// When in a atomicComposition account for everything that isn't yet reflected in the
// index
if (atomicComposition != null)
{
EngineContext engineContext;
if (atomicComposition.TryGetValue(this, out engineContext))
{
// always added the new part managers to see if they will also be
// affected by these changes
affectedParts = affectedParts.ConcatAllowingNull(engineContext.GetAddedPartManagers())
.Except(engineContext.GetRemovedPartManagers());
}
}
var changedExports = e.AddedExports.ConcatAllowingNull(e.RemovedExports);
foreach (var partManager in affectedParts)
{
result = result.MergeResult(this.TryRecomposeImports(partManager, changedExports, atomicComposition));
}
result.ThrowOnErrors(atomicComposition);
}
private void ExportsChanged(object sender, ExportsChangeEventArgs args)
{
try
{
if (args.AddedExports != null)
{
ParseExports(MsgAddExport, args.AddedExports);
}
if (args.RemovedExports != null)
{
ParseExports(MsgRemovedExport, args.RemovedExports);
}
if (args.ChangedContractNames != null)
{
bool first = true;
foreach (string contract in args.ChangedContractNames)
{
if (first)
{
LogInfo(MsgChangeContract);
first = false;
}
LogInfo(" ==>{0}", contract);
}
}
}
catch (Exception ex)
{
LogWarn(ex.Message);
}
}
private void ExportProvider_ExportsChanged(object sender, ExportsChangeEventArgs e)
{
UpdateTarget();
}
public void OnExportsChanged(object sender, ExportsChangeEventArgs args)
{
Assert.IsTrue(this._expectedAdds != null || this._expectedRemoves != null);
if (this._expectedAdds == null)
{
EnumerableAssert.IsEmpty(args.AddedExports);
}
else
{
foreach (var add in this._expectedAdds)
{
Assert.IsTrue(this._container.IsPresent(add), "Added exports should be added during changed");
}
}
if (this._expectedRemoves == null)
{
EnumerableAssert.IsEmpty(args.RemovedExports);
}
else
{
foreach (var remove in this._expectedRemoves)
{
Assert.IsFalse(this._container.IsPresent(remove), "Removed exports should be removed during changed");
}
}
Assert.IsNull(args.AtomicComposition);
this._changedEventCount++;
}
private void ModuleContainerOnExportsChanged(object sender, ExportsChangeEventArgs exportsChangeEventArgs)
{
Trace.TraceInformation("Module container exports changed");
}