C# IProjectService.AddToFolderFromTemplate方法代码示例

        /// <summary>
        /// Adds the converter.
        /// </summary>
        /// <param name="projectService">The project service.</param>
        /// <param name="templatesPath">The templates path.</param>
        /// <param name="messages">The messages.</param>
        /// <param name="templateInfo">The template info.</param>
        internal void AddConverter(
            IProjectService projectService, 
            string templatesPath, 
            List<string> messages, 
            ItemTemplateInfo templateInfo)
        {
            TraceService.WriteLine("ConvertersService::AddConverters adding from template path " + templatesPath + " template=" + templateInfo.FileName);

            string fileName = templateInfo.FriendlyName + ".cs";

            projectService.AddToFolderFromTemplate("Converters", templateInfo.FileName, fileName, false);

            IProjectItemService projectItemService = projectService.GetProjectItem(fileName);

            //// if we find the project item replace the text in it.
            if (projectItemService != null)
            {
                projectItemService.ReplacePattern("MvvmCross." + templateInfo.FriendlyName, projectService.Name);
                projectItemService.Save();
            }

            messages.Add(@"Converters\" + fileName + " added to project " + projectService.Name + ".");
        }

        /// <summary>
        /// Adds the project plugins.
        /// </summary>
        /// <param name="projectService">The project service.</param>
        /// <param name="plugins">The plugins.</param>
        /// <param name="folderName">Name of the folder.</param>
        /// <param name="extensionName">Name of the extension.</param>
        /// <param name="addTemplates">if set to <c>true</c> [add templates].</param>
        /// <returns>The added plugins.</returns>
        public IEnumerable<Plugin> AddProjectPlugins(
            IProjectService projectService,
            IEnumerable<Plugin> plugins,
            string folderName,
            string extensionName,
            bool addTemplates)
        {
            TraceService.WriteLine("PluginsService::AddProjectPlugins folder=" + folderName);

            List<Plugin> addedPlugins = new List<Plugin>();

            if (projectService != null)
            {
                this.settingsService.PluginsToAdd = string.Empty;

                //// set the project to be the active project!
                this.settingsService.ActiveProject = projectService.Name;

                foreach (Plugin plugin in plugins)
                {
                    bool added = this.pluginService.AddProjectPlugin(
                                                            projectService,
                                                            folderName,
                                                            extensionName,
                                                            plugin);

                    //// we keep a list of plugins that really got added
                    //// assume if we have a nuget command they will be added via nuget!
                    if (added || plugin.NugetCommands.Any())
                    {
                        addedPlugins.Add(plugin);

                        this.Messages.AddRange(this.pluginService.Messages);
                    }
                }

                if (addTemplates)
                {
                    projectService.AddToFolderFromTemplate("MvvmCross.Plugin.zip", "Ninja");
                }
            }

            return addedPlugins;
        }

        /// <summary>
        /// Adds the service.
        /// </summary>
        /// <param name="visualStudioService">The visual studio service.</param>
        /// <param name="projectService">The project service.</param>
        /// <param name="templateInfo">The template info.</param>
        /// <returns>True or false.</returns>
        internal bool AddService(
            IVisualStudioService visualStudioService,
            IProjectService projectService,
            ItemTemplateInfo templateInfo)
        {
            TraceService.WriteLine("ServicesService::AddServices");

            //// put at the top of the stack!
            if (this.settingsService.UseNugetForPlugins)
            {
                IEnumerable<string> messages = this.nugetService.GetInitNugetMessages(NinjaMessages.ServicesViaNuget);
                this.Messages.AddRange(messages);
            }

            string fileName = templateInfo.FriendlyName + ".cs";

            try
            {
                projectService.AddToFolderFromTemplate(templateInfo.FileName, fileName);

                CodeConfig codeConfig = this.codeConfigFactory.GetServiceConfig(templateInfo.FriendlyName);

                if (codeConfig != null)
                {
                    this.ProcessConfig(
                        visualStudioService,
                        projectService,
                        codeConfig);
                }

                return true;
            }
            catch (Exception exception)
            {
                string message = "AddToFolderFromTemplate error:-" + exception.Message;

                TraceService.WriteError(message);
                this.messageBoxService.Show(
                    message,
                    "Ninja Code for MvvmCross - Add Service",
                    this.settingsService.BetaTesting,
                    Theme.Light,
                    this.settingsService.ThemeColor);

                throw new NinjaCoderServiceException
                {
                    NinjaMessage = "Ninja exception :-" + message,
                    FileName = templateInfo.FileName,
                };
            }
        }

        /// <summary>
        /// Adds the service.
        /// </summary>
        /// <param name="visualStudioService">The visual studio service.</param>
        /// <param name="projectService">The project service.</param>
        /// <param name="templatesPath">The templates path.</param>
        /// <param name="templateInfo">The template info.</param>
        /// <returns>True or false.</returns>
        internal bool AddService(
            IVisualStudioService visualStudioService,
            IProjectService projectService,
            string templatesPath,
            ItemTemplateInfo templateInfo)
        {
            TraceService.WriteLine("ServicesService::AddServices adding from template path " + templatesPath + " template=" + templateInfo.FileName);

            //// put at the top of the stack!
            if (this.settingsService.UseNugetForPlugins)
            {
                IEnumerable<string> messages = this.nugetService.GetInitNugetMessages(NinjaMessages.ServicesViaNuget);
                this.Messages.AddRange(messages);
            }

            string fileName = templateInfo.FriendlyName + ".cs";

            try
            {
                projectService.AddToFolderFromTemplate("Services", templateInfo.FileName, fileName, false);

                string configFile = string.Format(@"{0}\Services\Config.{1}.xml", this.settingsService.ConfigPath, templateInfo.FriendlyName);

                if (this.fileSystem.File.Exists(configFile))
                {
                    this.ProcessConfig(
                        visualStudioService,
                        projectService,
                        configFile);
                }

                return true;
            }
            catch (Exception exception)
            {
                string message = "AddToFolderFromTemplate error:-" + exception.Message;

                TraceService.WriteError(message);
                this.messageBoxService.Show(message, "Ninja Code for MvvmCross - Add Service");

                throw new NinjaCoderServiceException
                {
                    NinjaMessage = "Ninja exception :-" + message,
                    FileName = templateInfo.FileName,
                    FolderName = templateInfo.FolderName
                };
            }
        }

        /// <summary>
        /// Adds the project plugins.
        /// </summary>
        /// <param name="projectService">The project service.</param>
        /// <param name="plugins">The plugins.</param>
        /// <param name="addBootstrapFile">if set to <c>true</c> [add bootstrap file].</param>
        /// <returns>
        /// The added plugins.
        /// </returns>
        internal void AddProjectPlugins(
            IProjectService projectService,
            IEnumerable<Plugin> plugins,
            bool addBootstrapFile)
        {
            TraceService.WriteLine("PluginsService::AddProjectPlugins");

            if (projectService != null)
            {
                this.settingsService.PluginsToAdd = string.Empty;

                //// set the project to be the active project!
                this.settingsService.ActiveProject = projectService.Name;

                foreach (Plugin plugin in plugins)
                {
                    this.pluginService.AddProjectPlugin(
                        projectService,
                        plugin);

                    this.Messages.Add("Plugin " + plugin.FriendlyName + " added to " + projectService.Name + " project.");
                }

                if (addBootstrapFile)
                {
                    projectService.AddToFolderFromTemplate("MvvmCross.Plugin.zip", "Ninja");
                }
            }
        }

        /// <summary>
        /// Builds the source file.
        /// </summary>
        /// <param name="projectService">The project service.</param>
        /// <param name="extensionSource">The extensionSource.</param>
        /// <param name="extensionDestination">The extension destination.</param>
        /// <param name="friendlyName">Name of the friendly.</param>
        internal void BuildSourceFile(
            IProjectService projectService,
            string extensionSource,
            string extensionDestination,
            string friendlyName)
        {
            TraceService.WriteLine("PluginsService::BuildSourceFile " + friendlyName);

            try
            {
                string message = string.Format("BuildSourceFile Project Name={0} friendlyName={1}", projectService.Name, friendlyName);

                TraceService.WriteLine(message);

                string sourceFile = friendlyName + "PluginBootstrap.cs";

                //// now we need to sort out the item template!
                projectService.AddToFolderFromTemplate("Bootstrap", "MvvmCross.Plugin.zip", sourceFile, false);

                this.Messages.Add(string.Format(@"Bootstrap\{0} added to {1} project.", sourceFile, projectService.Name));

                IProjectItemService projectItemService = projectService.GetProjectItem(sourceFile);

                //// if we find the project item replace the text in it.

                if (projectItemService.ProjectItem != null)
                {
                    this.FixUpFile(projectService, friendlyName, projectItemService);
                }
            }
            catch (Exception exception)
            {
                TraceService.WriteError("BuildSourceFile " + exception.Message);
            }
        }