void LoadCommandContainer(TypeDescriptor containerType, AssemblyDescriber describer) { if (containerType.IsAbstract || !containerType.HasPublicParameterlessConstructor) { return; } var methods = describer.GetPublicMethods(containerType); var cmdMethods = (from method in methods let commandAttr = method.APIAttributes.OfType <CommandAttribute>().FirstOrDefault() where commandAttr != null select new { method, commandAttr }).ToArray(); if (cmdMethods.Length == 0) { return; } var dupeCommandNames = from i in cmdMethods group i by i.commandAttr.Name into g where g.Count() > 1 select g; if (dupeCommandNames.Any()) { throw new LoaderItemInitException(string.Format("Duplicate command names in container {0}", containerType)); } var container = CreateLoaderInstance <CommandContainer>(containerType); var commandInfos = new List <LoaderCommand>(); foreach (var method in cmdMethods) { try { var reflectedCmd = new ReflectedCommand(container, method.method, method.commandAttr); var lcInfo = new LoaderCommand(this, reflectedCmd); reflectedCmd.LoaderCommand = lcInfo; commandInfos.Add(lcInfo); } catch (Exception ex) { Debug.WriteLine("Could not initialize command {0} in container {1}: {2}", method.method.Name, containerType, ex.Message); } } var lccInfo = new LoaderCommandContainer(this, container, containerType); ExtensionStore.InitCommandContainer(lccInfo, commandInfos); container.Initialize(Hooks); AddItems(commandInfos); AddItem(lccInfo); }
void LoadFacetFactory(TypeDescriptor factoryType, AssemblyDescriber describer) { if (factoryType.IsAbstract || !factoryType.HasPublicParameterlessConstructor) { return; } var attr = describer.GetClassAttributes(factoryType).OfType <FacetFactoryAttribute>().FirstOrDefault(); var factory = CreateLoaderInstance <IFacetFactory>(factoryType); var info = new LoaderFacetFactory(this, factory, factoryType, attr); ExtensionStore.InitFacetFactory(info); factory.Initialize(Hooks); AddItem(info); }
void LoadFacetType(TypeDescriptor type, AssemblyDescriber describer) { if (!type.IsInterface && !type.IsAbstract) { if (!type.GetImplementedTypes(true).Any(x => x.IsInterface && x.Implements(typeof(IFacet)))) { throw new LoaderItemInitException("None of the interfaces implemented by facet class implements IFacet"); } } LoaderAmbientFacet ambientInfo = null; if (!type.IsInterface) { var ambientAttr = describer.GetClassAttributes(type).OfType <AmbientFacetAttribute>().FirstOrDefault(); if (ambientAttr != null) { if (!type.HasPublicParameterlessConstructor || type.IsAbstract) { throw new LoaderItemInitException("No public parameterless constructor for ambient facet type"); } var facet = CreateLoaderInstance <IFacet>(type); facet.Initialize(Hooks); ambientInfo = new LoaderAmbientFacet(this, ambientAttr.Token, facet, new FacetMoniker(ambientAttr.Token, type, facet.DisplayName)); } } var info = new LoaderFacetType(this, type); ExtensionStore.InitFacetType(info); AddItem(info); if (ambientInfo != null) { AddItem(ambientInfo); } }
void Initialize(AssemblyDescriber describer, TypeDescriptor[] types) { ExtensionStore.InitExtension(this); foreach (var type in types .OrderBy(x => x.IsInterface ? 0 : 1) .ThenBy(x => x.Implements(typeof(IFacet)) ? 0 : 1)) { try { if (type.Implements(typeof(IFacet))) { LoadFacetType(type, describer); } else if (type.Implements(typeof(IFacetFactory))) { LoadFacetFactory(type, describer); } else if (type.Implements(typeof(CommandContainer))) { LoadCommandContainer(type, describer); } else if (type.Implements(typeof(IConfigurator))) { if (!type.IsAbstract && type.HasPublicParameterlessConstructor) { AddItem(new LoaderConfiguratorType(this, type)); } } } catch (LoaderItemInitException e) { Debug.WriteLine("Could not load type {0}: {1}", type.FullName, e.Message); } } }