C# IFileSystem.CopyFile方法代码示例

        public static void ProcessImage(GalleryImage galleryImage, IFileSystem fileSystem, string virtualRoot, string originalFileName, Color backgroundColor)
        {
            string originalPath = virtualRoot + "FullSizeImages/" + galleryImage.ImageFile;
            string webSizeImagePath = virtualRoot + "WebImages/" + galleryImage.WebImageFile;
            string thumbnailPath = virtualRoot + "Thumbnails/" + galleryImage.ThumbnailFile;

            using (Stream stream = fileSystem.GetAsStream(originalPath))
            {
                using (Bitmap originalImage = new Bitmap(stream))
                {
                    SetExifData(galleryImage, originalImage, originalFileName);
                }
            }

            fileSystem.CopyFile(originalPath, webSizeImagePath, true);

            mojoPortal.Web.ImageHelper.ResizeImage(
                webSizeImagePath,
                IOHelper.GetMimeType(Path.GetExtension(webSizeImagePath)),
                galleryImage.WebImageWidth,
                galleryImage.WebImageHeight,
                backgroundColor);

            fileSystem.CopyFile(originalPath, thumbnailPath, true);

            mojoPortal.Web.ImageHelper.ResizeImage(
                thumbnailPath,
                IOHelper.GetMimeType(Path.GetExtension(thumbnailPath)),
                galleryImage.ThumbNailWidth,
                galleryImage.ThumbNailHeight,
                backgroundColor);
        }

        /// <summary>
        /// Ensures the list.
        /// </summary>
        /// <param name="url">The URL.</param>
        /// <param name="file">The file.</param>
        /// <param name="httpClient">The HTTP client.</param>
        /// <param name="fileSystem">The file system.</param>
        /// <param name="semaphore">The semaphore.</param>
        /// <param name="cancellationToken">The cancellation token.</param>
        /// <returns>Task.</returns>
        public static async Task EnsureList(string url, string file, IHttpClient httpClient, IFileSystem fileSystem, SemaphoreSlim semaphore, CancellationToken cancellationToken)
        {
            var fileInfo = fileSystem.GetFileInfo(file);

            if (!fileInfo.Exists || (DateTime.UtcNow - fileSystem.GetLastWriteTimeUtc(fileInfo)).TotalDays > 1)
            {
                await semaphore.WaitAsync(cancellationToken).ConfigureAwait(false);

                try
                {
                    var temp = await httpClient.GetTempFile(new HttpRequestOptions
                    {
                        CancellationToken = cancellationToken,
                        Progress = new Progress<double>(),
                        Url = url

                    }).ConfigureAwait(false);

					fileSystem.CreateDirectory(Path.GetDirectoryName(file));

					fileSystem.CopyFile(temp, file, true);
                }
                finally
                {
                    semaphore.Release();
                }
            }
        }

		internal static string ExtractFont(string name, IApplicationPaths paths, IFileSystem fileSystem)
        {
            var filePath = Path.Combine(paths.ProgramDataPath, "fonts", name);

			if (fileSystem.FileExists(filePath))
            {
                return filePath;
            }

            var namespacePath = typeof(PlayedIndicatorDrawer).Namespace + ".fonts." + name;
            var tempPath = Path.Combine(paths.TempDirectory, Guid.NewGuid().ToString("N") + ".ttf");
			fileSystem.CreateDirectory(Path.GetDirectoryName(tempPath));

            using (var stream = typeof(PlayedIndicatorDrawer).Assembly.GetManifestResourceStream(namespacePath))
            {
                using (var fileStream = new FileStream(tempPath, FileMode.Create, FileAccess.Write, FileShare.Read))
                {
                    stream.CopyTo(fileStream);
                }
            }

			fileSystem.CreateDirectory(Path.GetDirectoryName(filePath));

            try
            {
				fileSystem.CopyFile(tempPath, filePath, false);
            }
            catch (IOException)
            {

            }

            return tempPath;
        }

        /// <summary>
        /// Performs a file modification.
        /// </summary>
        /// <param name="sourceFileSystem">The source file system.</param>
        /// <param name="targetFileSystem">The target file system.</param>
        /// <param name="sourceFile">The source file.</param>
        /// <param name="targetDirectory">The target directory.</param>
        /// <param name="execute">if set to true, the operation gets executed.</param>
        private void PerformFileModificationOperation(IFileSystem sourceFileSystem, IFileSystem targetFileSystem, IFileInfo sourceFile, IDirectoryInfo targetDirectory, bool execute)
        {
            var eventArgs = new FileCopyEventArgs(sourceFile, sourceFile.Directory, targetDirectory);

            this.OnModifyingFile(eventArgs);

            if (execute)
            {
                EventHandler<DataTransferEventArgs> handler = (sender, e) =>
                {
                    e.Cancel = this.IsStopped; //Stop the copy operation if the job is stopped

                    this.OnFileProgressChanged(e);
                };

                targetFileSystem.FileCopyProgressChanged += handler;

                try
                {
                    targetFileSystem.CopyFile(sourceFileSystem, sourceFile, targetDirectory);

                    this.OnModifiedFile(eventArgs);
                }

                catch (AccessException)
                {
                    this.OnFileCopyError(new FileCopyErrorEventArgs(sourceFile, targetDirectory));
                }

                targetFileSystem.FileCopyProgressChanged -= handler;
            }
        }

		internal static async Task<string> DownloadFont(string name, string url, IApplicationPaths paths, IHttpClient httpClient, IFileSystem fileSystem)
        {
            var filePath = Path.Combine(paths.ProgramDataPath, "fonts", name);

			if (fileSystem.FileExists(filePath))
            {
                return filePath;
            }

            var tempPath = await httpClient.GetTempFile(new HttpRequestOptions
            {
                Url = url,
                Progress = new Progress<double>()

            }).ConfigureAwait(false);

			fileSystem.CreateDirectory(Path.GetDirectoryName(filePath));

            try
            {
				fileSystem.CopyFile(tempPath, filePath, false);
            }
            catch (IOException)
            {

            }

            return tempPath;
        }