public TemplatingContext(string basePath, TemplateData data, IEnumerable<IAssetUriResolver> resolvers, IFileProvider fileProvider)
 {
     this.BasePath = basePath;
     this.TemplateData = data;
     this.AssetUriResolvers = resolvers.ToArray();
     this.FileProvider = fileProvider;
 }

 public ResourceDeployment(IFileProvider fileProvider, string path, string destination, IResourceTransform[] transforms)
 {
     this.FileProvider = fileProvider;
     this.ResourcePath = path;
     this.Destination = destination;
     this.Transforms = transforms;
 }

        public FileProviderGlobbingDirectory(
            [NotNull] IFileProvider fileProvider,
            IFileInfo fileInfo,
            FileProviderGlobbingDirectory parent)
        {
            _fileProvider = fileProvider;
            _fileInfo = fileInfo;
            _parent = parent;

            if (_fileInfo == null)
            {
                // We're the root of the directory tree
                RelativePath = string.Empty;
                _isRoot = true;
            }
            else if (!string.IsNullOrEmpty(parent?.RelativePath))
            {
                // We have a parent and they have a relative path so concat that with my name
                RelativePath = _parent.RelativePath + DirectorySeparatorChar + _fileInfo.Name;
            }
            else
            {
                // We have a parent which is the root, so just use my name
                RelativePath = _fileInfo.Name;
            }
        }

 public Properties(IFileProvider fileProvider, string filename)
 {
     _list = new Dictionary<String, object>();
     _fileProvider = fileProvider;
     _filename = filename;
     LoadFromFile(_filename,"");
 }

 public BaseDocumentHandler(IFileProvider fileProvider, string subpath)
 {
     FileInfo = AcceptedExtensions
         .Select(x => fileProvider.GetFileInfo(subpath + x))
         .Where(x => x.Exists)
         .FirstOrDefault();
 }

 // Internal for unit testing
 internal DefaultChunkTreeCache(
     IFileProvider fileProvider,
     MemoryCacheOptions options)
 {
     _fileProvider = fileProvider;
     _chunkTreeCache = new MemoryCache(options);
 }

 public RSS20ContentProvider(IFileProvider fileProvider, Func<IEnumerable<Dictionary<string, string>>> getContentData, string feedTitle, string feedDescription, string feedLink)
     : base(fileProvider, getContentData)
 {
     this._feedTitle = feedTitle;
     this._feedDescription = feedDescription;
     this._feedLink = feedLink;
 }

        public static IConfigurationBuilder AddYamlFile(this IConfigurationBuilder builder, IFileProvider provider, string path, bool optional, bool reloadOnChange)
        {
            if (builder == null)
            {
                throw new ArgumentNullException(nameof(builder));
            }
            if (string.IsNullOrEmpty(path))
            {
                throw new ArgumentException("InvalidFilePath", nameof(path));
            }

            if (provider == null && Path.IsPathRooted(path))
            {
                provider = new PhysicalFileProvider(Path.GetDirectoryName(path));
                path = Path.GetFileName(path);
            }
            var source = new YamlConfigurationSource
            {
                FileProvider = provider,
                Path = path,
                Optional = optional,
                ReloadOnChange = reloadOnChange
            };
            builder.Add(source);
            return builder;
        }

 public bool TryResolveHandler(IFileProvider fileProvider, string subpath, out IDocumentHandler handler)
 {
     handler = GetHandlers(fileProvider, subpath)
         .Where(x => x.CanHandleRequest)
         .FirstOrDefault();
     return handler != null;
 }

 public FileEffectiveRights53EntityOperationEvaluator(
     FileEffectiveRightsObjectCollector objectCollector, IFileProvider fileProvider)
 {
     this.FileEffectiveRights53SystemDataSource = objectCollector;
     this.FileProvider = fileProvider;
     this.PathOperatorEvaluator = new PathOperatorEvaluator(fileProvider, FamilyEnumeration.windows);
 }

 public PluginCompositeFileProvider(IPluginManager pluginManager, IFileProvider defaultFileProvider, string subfolder=null)
 {
     var pluginsFileProviders = new List<IFileProvider>(pluginManager.LoadedPlugins.Count()+1);
     pluginsFileProviders.Add(defaultFileProvider);
     pluginsFileProviders.AddRange(GetPluginFileProviders(pluginManager, subfolder));
     _fileProvider = new CompositeFileProvider(pluginsFileProviders);
 }

 /// <summary>
 /// Constructs an instance of the <see cref="CssDataUriTransform"/> class with a custom set of exclusions
 /// </summary>
 /// <param name="fileProvider">A wrapper for access to the file system</param>
 /// <param name="exclusions">The exclusions to apply to matches</param>
 public CssDataUriTransform(IFileProvider fileProvider, params IExclude[] exclusions) : this(fileProvider)
 {
     foreach (var exclusion in exclusions)
     {
         _exclusions.Add(exclusion);
     }
 }

 public HomeworkController(IFileProvider fileProvider, IStudentHomeworkProvider studentHWProvider, IModuleProvider moduleProvider, IHomeworkProvider homeworkProvider)
 {
     _moduleProvider = moduleProvider;
     _homeworkProvider = homeworkProvider;
     _studentHWProvider = studentHWProvider;
     _fileProvider = fileProvider;
 }

 public AtomContentProvider(IFileProvider fileProvider, Func<IEnumerable<Dictionary<string, string>>> getContentData, string feedTitle, string feedLink, string feedAuthor, string feedId)
     : base(fileProvider, getContentData)
 {
     this._feedTitle = feedTitle;
     this._feedAuthor = feedAuthor;
     this._feedLink = feedLink;
     this._feedId = feedId;
 }

 // TODO we can eliminate the TemplateResolver here once we remove it as a requirement for the Template class
 public TemplateInfo(IFileProvider source, string path, string name, TemplateParameterInfo[] parameters, TemplateInfo inheritedTemplate)
 {
     this.Source = source;
     this.Name = name;
     this.Parameters = parameters;
     this.Path = path;
     this.Inherits = inheritedTemplate;
 }

 public DirectoryHandler(IFileProvider fileProvider, string path, DirectoryOptions options)
 {
     _fileProvider = fileProvider;
     _path = path;
     _extensionsOptionsRegex = new Regex(String.Join("|", options.DirectoryBrowsingStripExtensions.Select(i => String.Concat(i.FirstOrDefault() == '.' ? @"\" : "", i, @"$"))));
     _directoryOptions = options;
     CanHandleRequest = _fileProvider.GetDirectoryContents(_path).Exists;
 }

 public Template(IFileProvider fileProvider)
 {
     this._fileProvider = fileProvider;
     this._fileResolver = new FileResolver();
     this._resolvers = new List<IAssetUriResolver>();
     this._resolvers.Add(this._fileResolver);
     this._resolvers.Add(new MsdnResolver());
 }

 public BasePanelViewModel(IFileProvider fileProvider, IDirectory currentDirectory)
 {
     this.fileProvider = fileProvider;
     this.fileProvider.FileChangedEvent += FileProviderOnFileChangedEvent;
     this.currentDirectory = currentDirectory;
     openCommand = new OpenFileCommand(this);
     FillDirectoryFiles();
 }

 public OddrDeviceService(IFileProvider fileProvider, string pathToOddrProperties)
 {
     
     var properties = new Properties(fileProvider, pathToOddrProperties);
     _oddrService = new ODDRService(fileProvider);
     var defaultVocabularyIri = properties.GetProperty("oddr.vocabulary.device");
     _oddrService.Initialize(defaultVocabularyIri, properties);
 }

 public PluginAssemblyProvider(IFileProvider fileProvider, ILoggerFactory loggerFactory,
     IAssemblyLoadContextAccessor loadContextAccessor, IAssemblyLoaderContainer assemblyLoaderContainer)
 {
     _logger = loggerFactory.CreateLogger<PluginAssemblyProvider>();
     _fileProvider = fileProvider;
     _loadContextAccessor = loadContextAccessor;
     _assemblyLoaderContainer = assemblyLoaderContainer;
     _candidates = new Lazy<IEnumerable<Assembly>>(FindPluginAssemblies);
 }