static void _catalog_Changed(object sender, ComposablePartCatalogChangeEventArgs e) { if (null != _directoryCatalog) { _directoryCatalog.Refresh(); } }
/// <summary> /// Método acionado quando o catálogo estiver sendo alterado. /// </summary> /// <param name="e"></param> protected virtual void OnChanging(ComposablePartCatalogChangeEventArgs e) { if (Changing != null) { Changing(this, e); } }
void directoryCatalog_Changing(object sender, ComposablePartCatalogChangeEventArgs e) { try { // Remove handlers foreach (var handler in Handlers) { for (var i = handlerService.Handlers.Count - 1; i > 0; i--) { var h = handlerService.Handlers[i]; if (h.GetType() == handler.GetType()) { handlerService.Handlers.RemoveAt(i); } } Stencil.Instance.RemoveType(handler.GetType()); } } catch (Exception ex) { Out.WriteLine(ex.Message); } }
/// <summary> /// Refreshes the <see cref="ComposablePartDefinition"/>s with the latest files in the directory that match /// the searchPattern. If any files have been added they will be added to the catalog and if any files were /// removed they will be removed from the catalog. For files that have been removed keep in mind that the /// assembly cannot be unloaded from the process so <see cref="ComposablePartDefinition"/>s for those files /// will simply be removed from the catalog. /// /// Possible exceptions that can be thrown are any that <see cref="Directory.GetFiles(string, string)"/>. /// </summary> /// <exception cref="DirectoryNotFoundException"> /// The specified path has been removed since object construction. /// </exception> public void Refresh() { ThrowIfDisposed(); ComposablePartDefinition[] addedDefinitions; ComposablePartDefinition[] removedDefinitions; object changeReferenceObject; string[] afterFiles; string[] beforeFiles; while (true) { afterFiles = GetFiles(); lock (_thisLock) { changeReferenceObject = _loadedFiles; beforeFiles = _loadedFiles.ToArray(); } var newCatalog = ExecuteScripts(afterFiles); // Notify listeners to give them a preview before completing the changes addedDefinitions = newCatalog.ToArray(); removedDefinitions = _catalog.ToArray(); using (var atomicComposition = new AtomicComposition()) { var changingArgs = new ComposablePartCatalogChangeEventArgs(addedDefinitions, removedDefinitions, atomicComposition); OnChanging(changingArgs); // if the change went through then write the catalog changes lock (_thisLock) { if (changeReferenceObject != _loadedFiles) { // Someone updated the list while we were diffing so we need to try the diff again continue; } _catalog = newCatalog; _loadedFiles = afterFiles.ToReadOnlyCollection(); // Lastly complete any changes added to the atomicComposition during the change event atomicComposition.Complete(); // Break out of the while(true) break; } // WriteLock } // AtomicComposition } // while (true) var changedArgs = new ComposablePartCatalogChangeEventArgs(addedDefinitions, removedDefinitions, null); OnChanged(changedArgs); }
private void Watcher_Deleted(object sender, FileSystemEventArgs e) { if (innerCatalog.KeyedParts.ContainsKey(e.FullPath)) { var affectedParts = innerCatalog.KeyedParts[e.FullPath]; var changeArgs = new ComposablePartCatalogChangeEventArgs(Enumerable.Empty <ComposablePartDefinition>(), affectedParts, null); AddOrDeleteChanging(changeArgs, () => innerCatalog.RemoveKeyedParts(e.FullPath), false); } }
protected virtual void OnChanging(ComposablePartCatalogChangeEventArgs e) { EventHandler <ComposablePartCatalogChangeEventArgs> handler = this.Changing; if (handler != null) { handler(this, e); } }
/// <summary> /// Raises the <see cref="INotifyComposablePartCatalogChanged.Changing"/> event. /// </summary> /// <param name="e"> /// An <see cref="ComposablePartCatalogChangeEventArgs"/> containing the data for the event. /// </param> protected virtual void OnChanging(ComposablePartCatalogChangeEventArgs e) { EventHandler <ComposablePartCatalogChangeEventArgs> changingEvent = this.Changing; if (changingEvent != null) { changingEvent(this, e); } }
/// <summary> /// Event handler. Called by Catalog for changed events. /// </summary> /// /// <param name="sender"> Source of the event. </param> /// <param name="e"> Composable part catalog change event information. </param> private void Catalog_Changed(object sender, ComposablePartCatalogChangeEventArgs e) { foreach (ComposablePartDefinition a in e.AddedDefinitions) { Debug.Print($"ADDED {a.ToString()}"); } foreach (ComposablePartDefinition r in e.RemovedDefinitions) { Debug.Print($"REMOVED {r.ToString()}"); } }
void directoryCatalog_Changed(object sender, ComposablePartCatalogChangeEventArgs e) { // Register handlers foreach (var handler in Handlers) { Stencil.Instance.AddType(handler.GetType()); var instance = Stencil.Instance.Resolve(handler.GetType()) as IHandler; handlerService.Handlers.Add(instance); } }
private void Watcher_Created(object sender, FileSystemEventArgs e) { if (filter(new FileInfo(e.FullPath))) { var streamReader = new StreamReader(e.FullPath); var html = streamReader.ReadToEnd(); streamReader.Dispose(); var newParts = innerCatalog.AddFragmentWithKey(e.FullPath, html, false); if (newParts.Count > 0) { var changeArgs = new ComposablePartCatalogChangeEventArgs(newParts, Enumerable.Empty <ComposablePartDefinition>(), null); AddOrDeleteChanging(changeArgs, () => innerCatalog.AddKeyedParts(e.FullPath, newParts), true); } } }
/// <summary> /// </summary> /// <param name="assemblies"> /// </param> /// <exception cref="ObjectDisposedException"> /// The <see cref="XapCatalog"/> has been disposed of. /// </exception> private void DiscoverParts(IEnumerable <Assembly> assemblies) { ThrowIfDisposed(); List <ComposablePartDefinition> addedDefinitions = new List <ComposablePartDefinition>(); Dictionary <string, ComposablePartCatalog> addedCatalogs = new Dictionary <string, ComposablePartCatalog>(); using (new ReadLock(_lock)) { foreach (Assembly assembly in assemblies) { if (addedCatalogs.ContainsKey(assembly.FullName)) { // Nothing to do because the assembly has already been added. continue; } AssemblyCatalog catalog = new AssemblyCatalog(assembly); addedDefinitions.AddRange(catalog.Parts); addedCatalogs.Add(assembly.FullName, catalog); } } // Generate notifications using (AtomicComposition atomicComposition = new AtomicComposition()) { ComposablePartCatalogChangeEventArgs changingArgs = new ComposablePartCatalogChangeEventArgs( addedDefinitions, Enumerable.Empty <ComposablePartDefinition>(), atomicComposition); OnChanging(changingArgs); using (new WriteLock(_lock)) { foreach (KeyValuePair <string, ComposablePartCatalog> item in addedCatalogs) { _catalogCollection.Catalogs.Add(item.Value); } } atomicComposition.Complete(); } ComposablePartCatalogChangeEventArgs changedArgs = new ComposablePartCatalogChangeEventArgs( addedDefinitions, Enumerable.Empty <ComposablePartDefinition>(), null); OnChanged(changedArgs); }
/// <summary> /// Fires the <see cref="Changed"/> event. /// </summary> /// <param name="addedDefinitions">The collection of added <see cref="ComposablePartDefinition"/> instances.</param> /// <param name="removedDefinitions">The collection of removed <see cref="ComposablePartDefinition"/> instances.</param> /// <param name="composition"><see cref="AtomicComposition"/> instance.</param> protected virtual void OnChanged(IEnumerable <ComposablePartDefinition> addedDefinitions, IEnumerable <ComposablePartDefinition> removedDefinitions, AtomicComposition composition) { if (Changed != null) { if (addedDefinitions == null) { addedDefinitions = Enumerable.Empty <ComposablePartDefinition>(); } if (removedDefinitions == null) { removedDefinitions = Enumerable.Empty <ComposablePartDefinition>(); } var args = new ComposablePartCatalogChangeEventArgs( addedDefinitions, removedDefinitions, composition); Changed(this, args); } }
private void AddOrDeleteChanging(ComposablePartCatalogChangeEventArgs changeArgs, Action addDeleteAction, bool added) { bool changeException = false; ChangeRejectedException changeRejectedException = null; string failureDetails = null; bool recompositionSuccess = false; RecompositionEventReason recompositionEventReason = RecompositionEventReason.Deleted; try { Changing?.Invoke(this, changeArgs); } catch (ChangeRejectedException exc) { failureDetails = GetChangeRejectedExceptionMessage(exc); changeException = true; } addDeleteAction(); Changed?.Invoke(this, changeArgs); if (!changeException) { recompositionSuccess = true; } else { RecompositionException(changeRejectedException); } if (added) { recompositionEventReason = RecompositionEventReason.Added; } RecompositionAttemptEvent?.Invoke(this, new RecompositionAttemptEventArgs(recompositionSuccess, recompositionEventReason, failureDetails)); }
void clusterBrightPluginsCatalog_Changed(object sender, ComposablePartCatalogChangeEventArgs e) { this.OnBrightPluginsChanged(); }
public void ShouldRaiseOnchangedAndOnChanging() { // arrange bool onChangedCalled = false; bool onChangingCalled = false; ComposablePartCatalogChangeEventArgs onChangedEventArgs = null; ComposablePartCatalogChangeEventArgs onChangingEventArgs = null; var scriptName = @"c:\workingdirectory\_plugins\SimpleScript.csx"; var fileSystem = GetMockFileSystem(scriptName, Scripts.SimpleScript); var scriptCsCatalog = new ScriptCsCatalog("_plugins", GetOptions(fileSystem: fileSystem.Object)); scriptCsCatalog.Changing += (object sender, ComposablePartCatalogChangeEventArgs e) => { onChangingCalled = true; onChangingEventArgs = e; }; scriptCsCatalog.Changed += (object sender, ComposablePartCatalogChangeEventArgs e) => { onChangedCalled = true; onChangedEventArgs = e; }; // act var mefHost = GetComposedMefHost(scriptCsCatalog); // assert scriptCsCatalog.LoadedFiles.Count.ShouldEqual(1); mefHost.Plugins.Count.ShouldEqual(1); mefHost.Plugins[0].DoSomething().ShouldEqual("Simple"); // arrange UpdateFileSystem(fileSystem, new[] { scriptName }, new[] { Scripts.DoubleScript }); // act scriptCsCatalog.Refresh(); // assert scriptCsCatalog.LoadedFiles.Count.ShouldEqual(1); mefHost.Plugins.Count.ShouldEqual(1); mefHost.Plugins[0].DoSomething().ShouldEqual("Double"); onChangingCalled.ShouldBeTrue(); onChangingEventArgs.ShouldNotBeNull(); onChangingEventArgs.AtomicComposition.ShouldNotBeNull(); onChangingEventArgs.AddedDefinitions.ShouldNotBeNull(); onChangingEventArgs.AddedDefinitions.ShouldNotBeEmpty(); onChangingEventArgs.AddedDefinitions.Count().ShouldEqual(1); onChangingEventArgs.AddedDefinitions.First().ToString().ShouldEqual("Submission#0+DoubleSomething"); onChangingEventArgs.RemovedDefinitions.ShouldNotBeNull(); onChangingEventArgs.RemovedDefinitions.ShouldNotBeEmpty(); onChangingEventArgs.RemovedDefinitions.Count().ShouldEqual(1); onChangingEventArgs.RemovedDefinitions.First().ToString().ShouldEqual("Submission#0+SimpleSomething"); onChangedCalled.ShouldBeTrue(); onChangedEventArgs.ShouldNotBeNull(); onChangedEventArgs.AtomicComposition.ShouldBeNull(); onChangedEventArgs.AddedDefinitions.ShouldNotBeNull(); onChangedEventArgs.AddedDefinitions.ShouldNotBeEmpty(); onChangedEventArgs.AddedDefinitions.Count().ShouldEqual(1); onChangedEventArgs.AddedDefinitions.First().ToString().ShouldEqual("Submission#0+DoubleSomething"); onChangedEventArgs.RemovedDefinitions.ShouldNotBeNull(); onChangedEventArgs.RemovedDefinitions.ShouldNotBeEmpty(); onChangedEventArgs.RemovedDefinitions.Count().ShouldEqual(1); onChangedEventArgs.RemovedDefinitions.First().ToString().ShouldEqual("Submission#0+SimpleSomething"); }
private void DiscoverTypes(IEnumerable <ContractInfo> contracts) { lock (_lock) { if (_catalogCollection == null) { _catalogCollection = new AggregateCatalog(); } var exports = new List <Tuple <ContractInfo, Colosoft.Reflection.Composition.IExport> >(); foreach (var i in contracts) { if (i.Types.Count == 0) { var tuple = new Tuple <ContractInfo, Reflection.Composition.IExport>(i, ExportManager.GetExport(i.ContractType, i.ContractName, _uiContext)); if (tuple.Item2 != null) { exports.Add(tuple); } } else { var contractExports = ExportManager.GetExports(i.ContractType, i.ContractName, _uiContext); int contractCount = 0; foreach (var j in contractExports) { if (i.Types.Contains(j.Type, Colosoft.Reflection.TypeName.TypeNameEqualityComparer.Instance)) { contractCount++; var tuple = new Tuple <ContractInfo, Reflection.Composition.IExport>(i, j); exports.Add(tuple); } } } } if (exports.Count > 0) { var pkgParts = new List <Colosoft.Reflection.AssemblyPart>(); var partDescriptions = new List <PartDescription>(); foreach (var i in exports) { var assemblyPart = new Colosoft.Reflection.AssemblyPart(string.Format("{0}.dll", i.Item2.Type.AssemblyName.Name)); if (!pkgParts.Exists(f => StringComparer.InvariantCultureIgnoreCase.Equals(f.Source, assemblyPart.Source))) { pkgParts.Add(assemblyPart); } System.ComponentModel.Composition.CreationPolicy creationPolicy = System.ComponentModel.Composition.CreationPolicy.Any; switch (i.Item2.CreationPolicy) { case Reflection.Composition.CreationPolicy.NonShared: creationPolicy = System.ComponentModel.Composition.CreationPolicy.NonShared; break; case Reflection.Composition.CreationPolicy.Shared: creationPolicy = System.ComponentModel.Composition.CreationPolicy.Shared; break; } ImportingConstructorDescription importingConstructor = null; if (i.Item2.ImportingConstructor) { importingConstructor = new ImportingConstructorDescription(i.Item2.Type, null); } var partDescription = new PartDescription(i.Item2.Type, new ExportDescription[] { new ExportDescription { ContractTypeName = i.Item1.ContractType, ContractName = string.IsNullOrEmpty(i.Item2.ContractName) ? null : i.Item2.ContractName.Trim(), Metadata = i.Item2.Metadata } }, new ImportDescription[0], i.Item2.UseDispatcher, importingConstructor, creationPolicy); partDescriptions.Add(partDescription); } var catalog = new DefinitionCatalog(new DiscoverAssembliesContainer(this, _assemblyRepository, pkgParts.ToArray(), exports), partDescriptions); var addedDefinitions = catalog.Parts; using (AtomicComposition composition = new AtomicComposition()) { var args = new ComposablePartCatalogChangeEventArgs(addedDefinitions, Enumerable.Empty <ComposablePartDefinition>(), composition); this.OnChanging(args); _catalogCollection.Catalogs.Add(catalog); composition.Complete(); } ComposablePartCatalogChangeEventArgs e = new ComposablePartCatalogChangeEventArgs(addedDefinitions, Enumerable.Empty <ComposablePartDefinition>(), null); this.OnChanged(e); } } }
void Catalog_Changed(object sender, ComposablePartCatalogChangeEventArgs e) { //e.AddedDefinitions; }
/// <summary> /// Adds a Package to the catalog. It will ensure that the same Package added more than /// once will not cause duplication in the catalog. It will also ensure that the same /// assembly appearing in multiple packages will not cause duplication in the catalog. /// </summary> /// <param name="package"> /// Package obtained by constructing a <see cref="Package" /> object or /// calling <see cref="Package.DownloadPackageAsync" />. /// </param> public void AddPackage(Package package) { this.ThrowIfDisposed(); Requires.NotNull(package, "package"); List <AssemblyCatalog> addedCatalogs = new List <AssemblyCatalog>(); ComposablePartDefinition[] addedDefinitions; using (new ReadLock(this._lock)) { if (this._packages.ContainsKey(package.Uri)) { // Nothing to do because the package has already been added. return; } foreach (Assembly assembly in package.Assemblies) { if (!this._loadedAssemblies.Contains(assembly.FullName)) { addedCatalogs.Add(new AssemblyCatalog(assembly)); } } } addedDefinitions = addedCatalogs.SelectMany(asmCat => asmCat.Parts).ToArray <ComposablePartDefinition>(); if (addedDefinitions.Length == 0) { // If the package doesn't contain any added definitions then simply add it to the // list of known packages and then return using (new WriteLock(this._lock)) { if (!this._packages.ContainsKey(package.Uri)) { this._packages.Add(package.Uri, package); } } return; } // Need to raise the changing event inside an AtomicComposition to allow listeners // to contribute state change based on whether or not the changes to the catalog // are completed. using (var atomicComposition = new AtomicComposition()) { var changingArgs = new ComposablePartCatalogChangeEventArgs(addedDefinitions, Enumerable.Empty <ComposablePartDefinition>(), atomicComposition); this.OnChanging(changingArgs); // throws ChangedRejectedException if these changes break the composition. using (new WriteLock(this._lock)) { if (this._packages.ContainsKey(package.Uri)) { // Someone beat us to it so return and don't complete the AtomicComosition return; } this._packages.Add(package.Uri, package); foreach (var catalog in addedCatalogs) { if (!this._loadedAssemblies.Contains(catalog.Assembly.FullName)) { this._loadedAssemblies.Add(catalog.Assembly.FullName); this._parts.AddRange(catalog.Parts); } } } atomicComposition.Complete(); } var changedArgs = new ComposablePartCatalogChangeEventArgs(addedDefinitions, Enumerable.Empty <ComposablePartDefinition>(), null); this.OnChanged(changedArgs); }
private void UpdateWebApiRegistry(ComposablePartCatalogChangeEventArgs eventArg) { using (TraceSources.AddInManager.TraceActivity("Updating WebApi routes.")) { // TODO this could be cleaned up a bit foreach (var partDefinition in eventArg.RemovedDefinitions) { IEnumerable <ExportDefinition> exports = partDefinition.ExportDefinitions; var apiExport = exports.SingleOrDefault(export => StringComparer.Ordinal.Equals(export.ContractName, Extensibility.ContractNames.ApiController)); if (apiExport == null) { continue; } IApiControllerMetadata controllerMetadata = AttributedModelServices.GetMetadataView <IApiControllerMetadata>(apiExport.Metadata); Type controllerType = AddInModelServices.GetPartType(partDefinition).Value; string routeName = string.Format("{0}_{1}", controllerMetadata.PackageId, controllerType.FullName.Replace('.', '_')); TraceSources.AddInManager.TraceInformation("Removing route: {0} (Source: {1}, Version: {2})", routeName, controllerMetadata.PackageId, controllerMetadata.PackageVersion); RouteBase route = RouteTable.Routes[routeName]; using (RouteTable.Routes.GetWriteLock()) { RouteTable.Routes.Remove(route); } } foreach (var partDefinition in eventArg.AddedDefinitions) { IEnumerable <ExportDefinition> exports = partDefinition.ExportDefinitions; var apiExport = exports.SingleOrDefault(export => StringComparer.Ordinal.Equals(export.ContractName, Extensibility.ContractNames.ApiController)); if (apiExport == null) { continue; } IApiControllerMetadata controllerMetadata = AttributedModelServices.GetMetadataView <IApiControllerMetadata>(apiExport.Metadata); Type controllerType = AddInModelServices.GetPartType(partDefinition).Value; // Pacakge version explicitly ignored in order to remain backwards compatible string urlTemplate = string.Format("api/{0}/{1}/", controllerMetadata.PackageId, controllerMetadata.UrlFragment.Trim('/')); string routeName = string.Format("{0}_{1}", controllerMetadata.PackageId, controllerType.FullName.Replace('.', '_')); string controllerName = controllerType.Name.Substring(0, controllerType.Name.Length - "Controller".Length); TraceSources.AddInManager.TraceInformation( "Adding route: {0} (Template: '{1}', Controller: {2}, Source: {3}, Version: {4})", routeName, urlTemplate, controllerName, controllerMetadata.PackageId, controllerMetadata.PackageVersion); using (RouteTable.Routes.GetWriteLock()) { RouteTable.Routes.MapHttpRoute( routeName, urlTemplate, new { Controller = controllerName, }); } } } }
void serverPluginsCatalog_Changed(object sender, ComposablePartCatalogChangeEventArgs e) { this.OnServerPluginsChanged(); }
void dCat_Changed(object sender, ComposablePartCatalogChangeEventArgs e) { Console.WriteLine("Directory catalog changed"); }
private void HandleInterceptedCatalogChanging(object sender, ComposablePartCatalogChangeEventArgs e) { Recompose(e.AddedDefinitions, e.RemovedDefinitions, e.AtomicComposition); }