C# IPackage.GetContentFiles方法代码示例

        public void InstallPackage(IPackage package)
        {
            var directoryToExpandTo = Path.Combine(_localRepository.Source, package.Id);
            foreach (var file in package.GetContentFiles())
            {
                string pathWithoutContextPrefix = file.Path.Substring("content/".Length);
                var fullPath = Path.Combine(directoryToExpandTo, pathWithoutContextPrefix);
                Directory.CreateDirectory(Path.GetDirectoryName(fullPath));

                using (Stream writeStream = File.OpenWrite(fullPath),
                              readStream = file.GetStream())
                {
                    readStream.CopyTo(writeStream);
                }
            }

            // If there is no xdt file, generate a default one
            string xdtPath = Path.Combine(directoryToExpandTo, "applicationHost.xdt");
            if (!File.Exists(xdtPath))
            {
                var xdtTemplate = new XdtTemplate { Path = package.Id };
                File.WriteAllText(xdtPath, xdtTemplate.TransformText().Trim());
            }

            var packageFile = Path.Combine(
                directoryToExpandTo,
                String.Format("{0}.{1}.nupkg", package.Id, package.Version));
            using (Stream readStream = package.GetStream(),
                          writeStream = File.OpenWrite(packageFile))
            {
                readStream.CopyTo(writeStream);
            }
        }

        /// <summary>
        /// This method will be called first when a package is installed.  We're using
        /// this method to perform some pre processing of XDT files in the 
        /// </summary>
        /// <param name="package"></param>
        protected override void ExtractPackageFilesToProject( IPackage package )
        {
            List<IPackageFile> contentFiles = package.GetContentFiles().ToList();
            Dictionary<string, string> transformedFiles = new Dictionary<string, string>();
            string packageRestorePath = Path.Combine( Project.Root, "App_Data", "PackageRestore" );

            // go through each *.rock.xdt file and apply the transform first,
            foreach ( var xdtFile in contentFiles.Where( f => f.Path.EndsWith( TRANSFORM_FILE_PREFIX, StringComparison.OrdinalIgnoreCase ) ) )
            {
                using ( Stream stream = xdtFile.GetStream() )
                {
                    var fileName = xdtFile.EffectivePath;

                    // write the transform file out to the PackageRestore/xdt folder
                    var transformFilefullPath = Path.Combine( packageRestorePath, "xdt", fileName );
                    Directory.CreateDirectory( Path.GetDirectoryName( transformFilefullPath ) );
                    using ( var fileStream = File.Create( transformFilefullPath ) )
                    {
                        stream.CopyTo( fileStream );
                    }

                    var sourceFile = fileName.Remove( fileName.Length - TRANSFORM_FILE_PREFIX.Length );
                    var sourceFileFullPath = Path.Combine( Project.Root, sourceFile );
                    var tempPathOfTransformedFile = Path.Combine( packageRestorePath, "xdt", sourceFile );

                    // now transform the Rock file using the xdt file, but write it to the PackageRestore\xdt folder and we'll
                    // move it into place after the update is finished.
                    // If the transform fails, then we have to quit and inform the user.
                    if ( !ProcessXmlDocumentTransformation( transformFilefullPath, sourceFileFullPath, tempPathOfTransformedFile ) )
                    {
                        throw new System.Xml.XmlException( sourceFile );
                    }
                    transformedFiles.Add( tempPathOfTransformedFile, sourceFile );
                }
            }

            // now let the package installation proceed as normal
            base.ExtractPackageFilesToProject( package );

            // lastly, move the transformed xml files into place
            MoveTransformedFiles( transformedFiles );

            try
            {
                Directory.Delete( packageRestorePath, recursive: true );
            }
            catch ( Exception ex )
            {
                ExceptionLogService.LogException( ex, System.Web.HttpContext.Current );
                ExceptionLogService.LogException( new Exception( string.Format( "Unable to delete package restore folder ({0}) after a successful update.", packageRestorePath ) ), System.Web.HttpContext.Current );
            }
        }

        public void InstallPackage(IPackage package)
        {
            var directoryToExpandTo = Path.Combine(_localRepository.Source, package.Id);
            foreach (var file in package.GetContentFiles())
            {
                string pathWithoutContextPrefix = file.Path.Substring("content/".Length);
                var fullPath = Path.Combine(directoryToExpandTo, pathWithoutContextPrefix);
                Directory.CreateDirectory(Path.GetDirectoryName(fullPath));

                using (Stream writeStream = File.OpenWrite(fullPath),
                              readStream = file.GetStream())
                {
                    readStream.CopyTo(writeStream);
                }
            }

            var packageFile = Path.Combine(directoryToExpandTo, package.GetFullName() + ".nupkg");
            using (Stream readStream = package.GetStream(),
                          writeStream = File.OpenWrite(packageFile))
            {
                readStream.CopyTo(writeStream);
            }
        }

 private IEnumerable<IPackageFile> GetTransformFiles(IPackage package)
 {
     return package.GetContentFiles().Where(IsTransformFile);
 }

        private IPackage InstallExtension(IPackage package, string installationDirectory)
        {
            try
            {
                if (FileSystemHelpers.DirectoryExists(installationDirectory))
                {
                    FileSystemHelpers.DeleteDirectorySafe(installationDirectory);
                }

                foreach (IPackageFile file in package.GetContentFiles())
                {
                    // It is necessary to place applicationHost.xdt under site extension root.
                    string contentFilePath = file.Path.Substring("content/".Length);
                    string fullPath = Path.Combine(installationDirectory, contentFilePath);
                    FileSystemHelpers.CreateDirectory(Path.GetDirectoryName(fullPath));
                    using (Stream writeStream = FileSystemHelpers.OpenWrite(fullPath), readStream = file.GetStream())
                    {
                        OperationManager.Attempt(() => readStream.CopyTo(writeStream));
                    }
                }

                // If there is no xdt file, generate default.
                GenerateApplicationHostXdt(installationDirectory, '/' + package.Id, isPreInstalled: false);

                OperationManager.Attempt(() => DeploySiteExtensionJobs(package.Id));

                var externalCommandFactory = new ExternalCommandFactory(_environment, _settings, installationDirectory);
                string installScript = Path.Combine(installationDirectory, _installScriptName);
                if (FileSystemHelpers.FileExists(installScript))
                {
                    OperationManager.Attempt(() =>
                    {
                        Executable exe = externalCommandFactory.BuildCommandExecutable(installScript,
                            installationDirectory,
                            _settings.GetCommandIdleTimeout(), NullLogger.Instance);
                        exe.ExecuteWithProgressWriter(NullLogger.Instance, _traceFactory.GetTracer(), String.Empty);
                    });
                }

                // Copy nupkg file for package list/lookup
                FileSystemHelpers.CreateDirectory(installationDirectory);
                string packageFilePath = GetNuGetPackageFile(package.Id, package.Version.ToString());
                using (
                    Stream readStream = package.GetStream(), writeStream = FileSystemHelpers.OpenWrite(packageFilePath))
                {
                    OperationManager.Attempt(() => readStream.CopyTo(writeStream));
                }
            }
            catch (Exception ex)
            {
                ITracer tracer = _traceFactory.GetTracer();
                tracer.TraceError(ex);
                FileSystemHelpers.DeleteDirectorySafe(installationDirectory);
                throw;
            }

            return _localRepository.FindPackage(package.Id);
        }

        public bool InstallExtension(IPackage package, string installationDirectory)
        {
            try
            {
                if (FileSystemHelpers.DirectoryExists(installationDirectory))
                {
                    FileSystemHelpers.DeleteDirectorySafe(installationDirectory);
                }

                foreach (IPackageFile file in package.GetContentFiles())
                {
                    // It is necessary to place applicationHost.xdt under site extension root.
                    string contentFilePath = file.Path.Substring("content/".Length);
                    string fullPath = Path.Combine(installationDirectory, contentFilePath);
                    FileSystemHelpers.CreateDirectory(Path.GetDirectoryName(fullPath));
                    using (Stream writeStream = FileSystemHelpers.OpenWrite(fullPath), readStream = file.GetStream())
                    {
                        OperationManager.Attempt(() => readStream.CopyTo(writeStream));
                    }
                }

                // If there is no xdt file, generate default.
                string xdtPath = Path.Combine(installationDirectory, "applicationHost.xdt");
                if (!FileSystemHelpers.FileExists(xdtPath))
                {
                    string xdtContent = CreateDefaultXdtFile(package.Id);
                    OperationManager.Attempt(() => FileSystemHelpers.WriteAllText(xdtPath, xdtContent));
                }

                // Copy nupkg file for package list/lookup
                FileSystemHelpers.CreateDirectory(installationDirectory);
                string packageFilePath = Path.Combine(installationDirectory,
                    String.Format("{0}.{1}.nupkg", package.Id, package.Version));
                using (
                    Stream readStream = package.GetStream(), writeStream = FileSystemHelpers.OpenWrite(packageFilePath))
                {
                    OperationManager.Attempt(() => readStream.CopyTo(writeStream));
                }
            }
            catch (Exception ex)
            {
                ITracer tracer = _traceFactory.GetTracer();
                tracer.TraceError(ex);
                FileSystemHelpers.DeleteDirectorySafe(installationDirectory);
                return false;
            }

            return true;
        }

        private void ShowMessageAndReadme(IPackage package, string message)
        {
            var files = package.GetContentFiles();

            string filePath = null;

            if (files != null)
            {
                var readme = files.FirstOrDefault(
                                (file) => file.Path.Equals("ReadMe.txt", StringComparison.OrdinalIgnoreCase));

                if (readme == null)
                {
                    readme = files.FirstOrDefault(
                    (file) => file.Path.IndexOf("ReadMe.txt", StringComparison.OrdinalIgnoreCase) >= 0);
                }

                string text = null;

                if (readme != null)
                {
                    try
                    {
                        using (var stream = readme.GetStream())
                        {
                            using (var reader = new StreamReader(stream))
                            {
                                text = reader.ReadToEnd();
                            }
                        }

                        if (!string.IsNullOrWhiteSpace(text))
                        {
                            var tempFilePath = Path.GetTempFileName();

                            lock (_lock)
                            {
                                if (!_cleanupAdded)
                                {
                                    var dispatcher = TryGetDispatcher();

                                    if (dispatcher != null)
                                    {
                                        dispatcher.BeginInvoke(DispatcherPriority.Normal, (Action)AddExitCleanUp);
                                    }
                                }
                            }

                            File.WriteAllText(tempFilePath, text);

                            filePath = tempFilePath;

                            lock (_lock)
                            {
                                _tempFilesToDelete.Add(filePath);
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        Debug.Fail(ex.ToString());
                    }
                }
            }

            if (filePath != null)
            {
                _webMatrixHost.ShowNotification(message, Resources.ClickForReadme, () => ShowReadMe(filePath, true));
            }
            else
            {
                _webMatrixHost.ShowNotification(message);
            }
        }

 private static IEnumerable<Tuple<IPackageFile, string>> GetFiles(IPackage package)
 {
     if (package.GetLibFiles().IsEmpty() && package.GetContentFiles().IsEmpty()) {
         foreach (var packageFile in package.GetFiles()) {
             yield return new Tuple<IPackageFile, string>(packageFile, packageFile.Path);
         }
     } else {
         // TODO: net40 is hard-coded. Some day more frameworks should be supported
         foreach (var packageFile in package.GetLibFiles()) {
             yield return new Tuple<IPackageFile, string>(packageFile, packageFile.Path.Substring(@"lib\net40\".Length));
         }
         foreach (var packageFile in package.GetContentFiles()) {
             yield return new Tuple<IPackageFile, string>(packageFile, packageFile.Path.Substring(@"content\".Length));
         }
     }
 }