/// <summary> /// Returns all components of the specified kind. /// </summary> public IEnumerable <ComponentInfo> GetAllComponents(string kind) { Contracts.CheckNonEmpty(kind, nameof(kind)); Contracts.CheckParam(IsValidName(kind), nameof(kind), "Invalid component kind"); return(_components.Where(x => x.Kind == kind).OrderBy(x => x.Name)); }
/// <summary> /// Returns all components that implement the specified interface. /// </summary> public IEnumerable <ComponentInfo> GetAllComponents(Type interfaceType) { Contracts.CheckValue(interfaceType, nameof(interfaceType)); return(_components.Where(x => x.InterfaceType == interfaceType).OrderBy(x => x.Name)); }
/// <summary> /// Sets the metric with index <paramref name="index"/> to <paramref name="value"/>. /// </summary> public void SetMetric(int index, Double value) { Contracts.Check(0 <= index && index < Metrics.Length); Metrics[index] = value; }
public bool TryFindEntryPoint(string name, out EntryPointInfo entryPoint) { Contracts.CheckNonEmpty(name, nameof(name)); return(_entryPointMap.TryGetValue(name, out entryPoint)); }
/// <summary> /// Set the progress value for the index <paramref name="index"/> to <paramref name="value"/>, /// and the limit value for the progress becomes 'unknown'. /// </summary> public void SetProgress(int index, Double value) { Contracts.Check(0 <= index && index < Progress.Length); Progress[index] = value; ProgressLim[index] = null; }
private void SubChannelStarted(int id, SubChannel channel) { var res = _subChannels.GetOrAdd(id, channel); Contracts.Assert(res == channel); }
/// <summary> /// Make sure the given assemblies are loaded and that their loadable classes have been catalogued. /// </summary> public static void CacheClassesExtra(string[] assemblies) { if (Utils.Size(assemblies) > 0) { lock (_lock) { foreach (string path in assemblies) { if (!_cachedPaths.Add(path)) { continue; } Exception ex = null; try { // REVIEW: Will LoadFrom ever return null? var assem = LoadFrom(path); if (assem != null) { continue; } } catch (Exception e) { ex = e; } // If it is a zip file, load it that way. ZipArchive zip; try { zip = ZipFile.OpenRead(path); } catch (Exception e) { // Couldn't load as an assembly and not a zip, so warn the user. ex = ex ?? e; Console.Error.WriteLine("Warning: Could not load '{0}': {1}", path, ex.Message); continue; } string dir; try { dir = CreateTempDirectory(); } catch (Exception e) { throw Contracts.ExceptIO(e, "Creating temp directory for extra assembly zip extraction failed: '{0}'", path); } try { zip.ExtractToDirectory(dir); } catch (Exception e) { throw Contracts.ExceptIO(e, "Extracting extra assembly zip failed: '{0}'", path); } LoadAssembliesInDir(dir, false); } } } CacheLoadedAssemblies(); }
private static Assembly LoadFrom(string path) { Contracts.CheckNonEmpty(path, nameof(path)); return(Assembly.LoadFrom(path)); }
/// <summary> /// This loads assemblies that are in our "root" directory (where this assembly is) and caches /// information for the loadable classes in loaded assemblies. /// </summary> private static void CacheLoadedAssemblies() { // The target assembly is the one containing LoadableClassAttributeBase. If an assembly doesn't reference // the target, then we don't want to scan its assembly attributes (there's no point in doing so). var target = typeof(LoadableClassAttributeBase).Assembly; lock (_lock) { if (_assemblyQueue == null) { // Create the loaded assembly queue and dictionary, set up the AssemblyLoad / AssemblyResolve // event handlers and populate the queue / dictionary with all assemblies that are currently loaded. Contracts.Assert(_assemblyQueue == null); Contracts.Assert(_loadedAssemblies == null); _assemblyQueue = new ConcurrentQueue <Assembly>(); _loadedAssemblies = new ConcurrentDictionary <string, Assembly>(); AppDomain.CurrentDomain.AssemblyLoad += CurrentDomainAssemblyLoad; AppDomain.CurrentDomain.AssemblyResolve += CurrentDomainAssemblyResolve; foreach (Assembly a in AppDomain.CurrentDomain.GetAssemblies()) { // Ignore dynamic assemblies. if (a.IsDynamic) { continue; } _assemblyQueue.Enqueue(a); if (!_loadedAssemblies.TryAdd(a.FullName, a)) { // Duplicate loading. Console.Error.WriteLine("Duplicate loaded assembly '{0}'", a.FullName); } } // Load all assemblies in our directory. var moduleName = typeof(ComponentCatalog).Module.FullyQualifiedName; // If were are loaded in the context of SQL CLR then the FullyQualifiedName and Name properties are set to // string "<Unknown>" and we skip scanning current directory. if (moduleName != "<Unknown>") { string dir = Path.GetDirectoryName(moduleName); LoadAssembliesInDir(dir, true); dir = Path.Combine(dir, "AutoLoad"); LoadAssembliesInDir(dir, true); } } Contracts.AssertValue(_assemblyQueue); Contracts.AssertValue(_loadedAssemblies); Assembly assembly; while (_assemblyQueue.TryDequeue(out assembly)) { if (!_cachedAssemblies.Add(assembly.FullName)) { continue; } if (assembly != target) { bool found = false; var targetName = target.GetName(); foreach (var name in assembly.GetReferencedAssemblies()) { if (name.Name == targetName.Name) { found = true; break; } } if (!found) { continue; } } #if TRACE_ASSEMBLY_LOADING // The "" no-op argument is necessary because WriteLine has multiple overloads, and with two strings // it will be the one that is message/category, rather than format string with System.Diagnostics.Debug.WriteLine("*** Caching classes in {0}", assembly.FullName, ""); #endif int added = 0; foreach (LoadableClassAttributeBase attr in assembly.GetCustomAttributes(typeof(LoadableClassAttributeBase))) { MethodInfo getter = null; ConstructorInfo ctor = null; MethodInfo create = null; bool requireEnvironment = false; if (attr.InstanceType != typeof(void) && !TryGetIniters(attr.InstanceType, attr.LoaderType, attr.CtorTypes, out getter, out ctor, out create, out requireEnvironment)) { Console.Error.WriteLine( "CacheClassesFromAssembly: can't instantiate loadable class {0} with name {1}", attr.InstanceType.Name, attr.LoadNames[0]); Contracts.Assert(getter == null && ctor == null && create == null); } var info = new LoadableClassInfo(attr, getter, ctor, create, requireEnvironment); AddClass(info, attr.LoadNames); added++; } #if TRACE_ASSEMBLY_LOADING System.Diagnostics.Debug.WriteLine(" Found {0} entries in {1}", added, assembly.FullName); #endif } } }