private void SetFilters(Predicate <Type> filter, Dictionary <string, Predicate <Type> > taggedFilters, TypeFinderCriteria criteria,
                                Action <TypeFinderCriteriaBuilder> configureFinder)
        {
            if (_options.TypeFinderCriterias == null)
            {
                _options.TypeFinderCriterias = new Dictionary <string, TypeFinderCriteria>();
            }

            if (filter != null)
            {
                var filterCriteria = new TypeFinderCriteria {
                    Query = (context, type) => filter(type)
                };

                _options.TypeFinderCriterias.Add(string.Empty, filterCriteria);
            }

            if (taggedFilters?.Any() == true)
            {
                foreach (var taggedFilter in taggedFilters)
                {
                    var taggedCriteria = new TypeFinderCriteria {
                        Query = (context, type) => taggedFilter.Value(type)
                    };

                    _options.TypeFinderCriterias.Add(taggedFilter.Key, taggedCriteria);
                }
            }

            if (configureFinder != null)
            {
                var builder = new TypeFinderCriteriaBuilder();
                configureFinder(builder);

                var configuredCriteria = builder.Build();

                _options.TypeFinderCriterias.Add("", configuredCriteria);
            }

            if (criteria != null)
            {
                _options.TypeFinderCriterias.Add("", criteria);
            }

            if (_options.TypeFinderCriterias?.Any() != true)
            {
                var findAll = TypeFinderCriteriaBuilder
                              .Create()
                              .Build();

                _options.TypeFinderCriterias.Add(string.Empty, findAll);
            }
        }
        public AssemblyPluginCatalog(string assemblyPath = null, Assembly assembly = null, Predicate <Type> filter = null,
                                     Dictionary <string, Predicate <Type> > taggedFilters = null, Action <TypeFinderCriteriaBuilder> configureFinder = null,
                                     TypeFinderCriteria criteria = null, AssemblyPluginCatalogOptions options = null)
        {
            if (assembly != null)
            {
                _assembly     = assembly;
                _assemblyPath = _assembly.Location;
            }
            else if (!string.IsNullOrWhiteSpace(assemblyPath))
            {
                _assemblyPath = assemblyPath;
            }
            else
            {
                throw new ArgumentNullException($"{nameof(assembly)} or {nameof(assemblyPath)} must be set.");
            }

            _options = options ?? new AssemblyPluginCatalogOptions();

            SetFilters(filter, taggedFilters, criteria, configureFinder);
        }
        public FolderPluginCatalog(string folderPath, Action <TypeFinderCriteriaBuilder> configureFinder, TypeFinderCriteria finderCriteria,
                                   FolderPluginCatalogOptions options)
        {
            if (string.IsNullOrWhiteSpace(folderPath))
            {
                throw new ArgumentNullException(nameof(folderPath));
            }

            _folderPath = folderPath;
            _options    = options ?? new FolderPluginCatalogOptions();

            if (_options.TypeFinderOptions == null)
            {
                _options.TypeFinderOptions = new TypeFinderOptions();
            }

            if (_options.TypeFinderOptions.TypeFinderCriterias == null)
            {
                _options.TypeFinderOptions.TypeFinderCriterias = new List <TypeFinderCriteria>();
            }

            if (configureFinder != null)
            {
                var builder = new TypeFinderCriteriaBuilder();
                configureFinder(builder);

                var criteria = builder.Build();

                _options.TypeFinderOptions.TypeFinderCriterias.Add(criteria);
            }

            if (finderCriteria != null)
            {
                _options.TypeFinderOptions.TypeFinderCriterias.Add(finderCriteria);
            }

            if (_options.TypeFinderCriteria != null)
            {
                _options.TypeFinderOptions.TypeFinderCriterias.Add(_options.TypeFinderCriteria);
            }

            if (_options.TypeFinderCriterias?.Any() == true)
            {
                foreach (var typeFinderCriteria in _options.TypeFinderCriterias)
                {
                    var crit = typeFinderCriteria.Value;
                    crit.Tags = new List <string>()
                    {
                        typeFinderCriteria.Key
                    };

                    _options.TypeFinderOptions.TypeFinderCriterias.Add(crit);
                }
            }
        }
 public FolderPluginCatalog(string folderPath, TypeFinderCriteria finderCriteria, FolderPluginCatalogOptions options) : this(folderPath, null,
                                                                                                                             finderCriteria, options)
 {
 }
 public FolderPluginCatalog(string folderPath, TypeFinderCriteria finderCriteria) : this(folderPath, finderCriteria, null)
 {
 }
 public AssemblyPluginCatalog(string assemblyPath, TypeFinderCriteria criteria = null, AssemblyPluginCatalogOptions options = null) : this(assemblyPath,
                                                                                                                                           null, null, null,
                                                                                                                                           null, criteria, options)
 {
 }
        public FolderPluginCatalog(string folderPath, Action <TypeFinderCriteriaBuilder> configureFinder, TypeFinderCriteria finderCriteria,
                                   FolderPluginCatalogOptions options)
        {
            if (string.IsNullOrWhiteSpace(folderPath))
            {
                throw new ArgumentNullException(nameof(folderPath));
            }

            _folderPath = folderPath;
            _options    = options ?? new FolderPluginCatalogOptions();

            if (configureFinder != null)
            {
                var builder = new TypeFinderCriteriaBuilder();
                configureFinder(builder);

                var criteria = builder.Build();

                _options.TypeFinderCriterias.Add("", criteria);
            }

            if (finderCriteria != null)
            {
                _options.TypeFinderCriterias.Add("", finderCriteria);
            }

            if (_options.TypeFinderCriteria != null)
            {
                _options.TypeFinderCriterias.Add("", _options.TypeFinderCriteria);
            }
        }
 public AssemblyPluginProviders(string assemblyPath, TypeFinderCriteria criteria = null, AssemblyPluginOptions options = null) : this(assemblyPath,
                                                                                                                                      null, null, null,
                                                                                                                                      null, criteria, options)
 {
 }
Example #9
0
 public FolderPluginProviders(string folderPath, TypeFinderCriteria finderCriteria, FolderPluginOptions options) : this(folderPath, null,
                                                                                                                        finderCriteria, options)
 {
 }
Example #10
0
 public FolderPluginProviders(string folderPath, TypeFinderCriteria finderCriteria) : this(folderPath, finderCriteria, null)
 {
 }