C# IFileSystem类代码示例

 public Bundler(IFileSystem system, IDeploymentController controller, DeploymentSettings settings, IBottleRepository bottles)
 {
     _system = system;
     _controller = controller;
     _settings = settings;
     _bottles = bottles;
 }

        public static IAppBuilder UseRazor(this IAppBuilder builder, IFileSystem fileSystem)
        {
            Requires.NotNull(builder, "builder");
            Requires.NotNull(fileSystem, "fileSystem");

            return UseRazor(builder, fileSystem, "/");
        }

 public CollectionManager(ILibraryManager libraryManager, IFileSystem fileSystem, ILibraryMonitor iLibraryMonitor, ILogger logger)
 {
     _libraryManager = libraryManager;
     _fileSystem = fileSystem;
     _iLibraryMonitor = iLibraryMonitor;
     _logger = logger;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="ProgressiveStreamWriter" /> class.
 /// </summary>
 /// <param name="path">The path.</param>
 /// <param name="logger">The logger.</param>
 /// <param name="fileSystem">The file system.</param>
 public ProgressiveStreamWriter(string path, ILogger logger, IFileSystem fileSystem, TranscodingJob job)
 {
     Path = path;
     Logger = logger;
     _fileSystem = fileSystem;
     _job = job;
 }

        /// <summary>
        /// Sets the initial item values.
        /// </summary>
        /// <param name="item">The item.</param>
        /// <param name="args">The args.</param>
        /// <param name="fileSystem">The file system.</param>
        /// <param name="libraryManager">The library manager.</param>
        public static void SetInitialItemValues(BaseItem item, ItemResolveArgs args, IFileSystem fileSystem, ILibraryManager libraryManager)
        {
            // If the resolver didn't specify this
            if (string.IsNullOrEmpty(item.Path))
            {
                item.Path = args.Path;
            }

            // If the resolver didn't specify this
            if (args.Parent != null)
            {
                item.Parent = args.Parent;
            }

            item.Id = libraryManager.GetNewItemId(item.Path, item.GetType());

            // Make sure the item has a name
            EnsureName(item, args.FileInfo);

            item.IsLocked = item.Path.IndexOf("[dontfetchmeta]", StringComparison.OrdinalIgnoreCase) != -1 ||
                item.Parents.Any(i => i.IsLocked);

            // Make sure DateCreated and DateModified have values
            EnsureDates(fileSystem, item, args, true);
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="ImageSaver" /> class.
 /// </summary>
 /// <param name="config">The config.</param>
 /// <param name="libraryMonitor">The directory watchers.</param>
 /// <param name="fileSystem">The file system.</param>
 /// <param name="logger">The logger.</param>
 public ImageSaver(IServerConfigurationManager config, ILibraryMonitor libraryMonitor, IFileSystem fileSystem, ILogger logger)
 {
     _config = config;
     _libraryMonitor = libraryMonitor;
     _fileSystem = fileSystem;
     _logger = logger;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="ImageSaver"/> class.
 /// </summary>
 /// <param name="config">The config.</param>
 /// <param name="directoryWatchers">The directory watchers.</param>
 public ImageSaver(IServerConfigurationManager config, IDirectoryWatchers directoryWatchers, IFileSystem fileSystem)
 {
     _config = config;
     _directoryWatchers = directoryWatchers;
     _fileSystem = fileSystem;
     _remoteImageCache = new FileSystemRepository(config.ApplicationPaths.DownloadedImagesDataPath);
 }

 public static void Move(this IFileSystem sourceFileSystem, FileSystemPath sourcePath, IFileSystem destinationFileSystem, FileSystemPath destinationPath)
 {
     IEntityMover mover;
     if (!EntityMovers.Registration.TryGetSupported(sourceFileSystem.GetType(), destinationFileSystem.GetType(), out mover))
         throw new ArgumentException("The specified combination of file-systems is not supported.");
     mover.Move(sourceFileSystem, sourcePath, destinationFileSystem, destinationPath);
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="FanArtAlbumProvider"/> class.
 /// </summary>
 /// <param name="httpClient">The HTTP client.</param>
 /// <param name="logManager">The log manager.</param>
 /// <param name="configurationManager">The configuration manager.</param>
 /// <param name="providerManager">The provider manager.</param>
 public FanArtAlbumProvider(IHttpClient httpClient, ILogManager logManager, IServerConfigurationManager configurationManager, IProviderManager providerManager, IFileSystem fileSystem)
     : base(logManager, configurationManager)
 {
     _providerManager = providerManager;
     _fileSystem = fileSystem;
     HttpClient = httpClient;
 }

 private static XDocument CreateDocument(XName rootName, IFileSystem fileSystem, string path)
 {
     XDocument document = new XDocument(new XElement(rootName));
     // Add it to the file system
     fileSystem.AddFile(path, document.Save);
     return document;
 }

 private static XDocument GetDocument(IFileSystem fileSystem, string path)
 {
     using (Stream configStream = fileSystem.OpenFile(path))
     {
         return XDocument.Load(configStream, LoadOptions.PreserveWhitespace);
     }
 }

 protected override IPackageManager CreatePackageManager(IFileSystem packagesFolderFileSystem) {
     var sourceRepository = GetRepository();
     var pathResolver = new CustomPackagePathResolver(packagesFolderFileSystem, true) {
         OverlayDirectory = OverlayPackageDirectory
     };
     return new PackageManager(sourceRepository, pathResolver, packagesFolderFileSystem, new LocalPackageRepository(pathResolver, packagesFolderFileSystem)) { Logger = base.Console };
 }

		public ISharedPackageRepository CreateSharedRepository(IPackagePathResolver pathResolver, IFileSystem fileSystem, IFileSystem configSettingsFileSystem)
		{
			PathResolverPassedToCreateSharedRepository = pathResolver;
			FileSystemPassedToCreateSharedRepository = fileSystem;
			ConfigSettingsFileSystemPassedToCreateSharedRepository = configSettingsFileSystem;
			return FakeSharedRepository;
		}

 public DeploymentStatusManager(IEnvironment environment,
                                IFileSystem fileSystem)
 {
     _environment = environment;
     _fileSystem = fileSystem;
     _activeFile = Path.Combine(environment.DeploymentCachePath, Constants.ActiveDeploymentFile);
 }

 protected WritableXapFile(string outputPath, IFileSystem fileSystem)
     : base(outputPath, fileSystem.OpenArchive(outputPath, ZipArchiveMode.Update))
 {
     FileSystem = fileSystem;
     OutputPath = outputPath;
     OutputArchive = InputArchive;
 }