Demonstra Passo a passo: Estender a implantação de projeto de banco de dados para analisar o plano de implantação
Você pode criar os colaboradores de implantação para executar ações personalizadas quando você implanta um projeto de banco de dados. Você pode criar um DeploymentPlanModifier ou um DeploymentPlanExecutor. Use um DeploymentPlanModifier para alterar o plano, antes que ele seja executado e um DeploymentPlanExecutor para executar operações enquanto o plano é executado. Esta explicação passo a passo, você pode criar um DeploymentPlanExecutor chamado DeploymentUpdateReportContributor que cria um relatório sobre as ações que são executadas quando você implanta um projeto de banco de dados. Porque este Colaborador de compilação aceita um parâmetro para o controle se o relatório é gerado, você deve executar uma etapa adicional necessária.
Esta explicação passo a passo, você irá realizar as seguintes tarefas principais:
Criar o tipo de DeploymentPlanExecutor de Colaborador de implantação
Instalar o colaborador de implantação
Teste seu colaborador de implantação
Pré-requisitos
Para completar este passo a passo, são necessários os seguintes componentes:
Visual Studio 2010 Premiumou Visual Studio 2010 Ultimate instalado no seu computador.
Um projeto de banco de dados que contém objetos de banco de dados
Uma instância de SQL Server para o qual você pode implantar um projeto de banco de dados
Observação |
---|
Esta explicação passo a passo destina-se a usuários que já estejam familiarizados com os recursos de banco de dados do Visual Studio. Você também deve estar familiarizado com o basic Visual Studio os conceitos, como criar uma biblioteca de classe e de como usar o editor de código para adicionar código para uma classe. |
Criar um colaborador de implantação
Para criar um colaborador de implantação, você deve executar as seguintes tarefas:
Crie um projeto de biblioteca de classe e adicionar referências necessárias
Definir uma classe chamada DeploymentUpdateReportContributor que herda deDeploymentPlanExecutor
Substitua os métodos OnPopulateArguments e OnExecute.
Adicionar uma classe auxiliar particular
Compilar o assembly resultante
Para criar um projeto de biblioteca de classe
Criar um Visual Basic ou Visual C#, o projeto de biblioteca de classe denominado MyDeploymentContributor.
No Solution Explorer, clique com o botão direito do referências pasta e clique em Adicionar referência de.
Clique na .NET guia.
Realce o Microsoft.Data.Schema e Microsoft.Data.Schema.Sql entradas e clique em OK.
Em seguida, inicie a adicionar código à classe.
Para definir a classe DeploymentUpdateReportContributor
No editor de código, atualizar o arquivo Class1. cs para coincidir com o seguinte using ou Imports instruções:
using System; using System.Collections.Generic; using System.Text; using Microsoft.Data.Schema.Build; using Microsoft.Data.Schema.Extensibility; using Microsoft.Data.Schema.Sql; using System.IO; using Microsoft.Data.Schema.SchemaModel; using System.Xml; using Microsoft.Data.Schema; using Microsoft.Data.Schema.Sql.Build;
Imports System Imports System.Collections.Generic Imports System.Text Imports Microsoft.Data.Schema.Build Imports Microsoft.Data.Schema.Extensibility Imports Microsoft.Data.Schema.Sql Imports System.IO Imports Microsoft.Data.Schema.SchemaModel Imports System.Xml Imports Microsoft.Data.Schema Imports Microsoft.Data.Schema.Sql.Build
Atualize a definição de classe para coincidir com o seguinte:
[DatabaseSchemaProviderCompatibility(typeof(SqlDatabaseSchemaProvider))] class DeploymentUpdateReportContributor : DeploymentPlanExecutor { }
''' <summary> ''' The DeploymentUpdateReportContributor class demonstrates ''' how you can create a class that inherits DeploymentPlanExecutor ''' to perform actions when you execute the deployment plan ''' for a database project. ''' </summary> <DatabaseSchemaProviderCompatibility(GetType(SqlDatabaseSchemaProvider))> Public Class DeploymentUpdateReportContributor Inherits DeploymentPlanExecutor End Class
Agora você ter definido seu colaborador de compilação e usado o atributo para indicar que este colaborador é compatível com qualquer provedor de esquema de banco de dados que herda de SqlDatabaseSchemaProvider.
Em seguida, adicione o seguinte membro que você usará para habilitar esse provedor aceitar um parâmetro de linha de comando:
private const string GenerateUpdateReport = "GenerateUpdateReport";
Dim GenerateUpdateReport As String = "GenerateUpdateReport"
Este membro permite ao usuário especificar se o relatório deve ser gerado usando a opção GenerateUpdateReport.
Em seguida, substituir o OnPopulateArguments método para criar a lista de argumentos para passar para o colaborador de implantação.
Para substituir o OnPopulateArguments
Adicione que o seguinte método à classe DeploymentUpdateReportContributor de substituir:
/// <summary> /// Override the OnPopulateArgument method to build a list of arguments from the input /// configuration information. /// </summary> protected override IList<ContributorArgumentConfiguration> OnPopulateArguments() { List<ContributorArgumentConfiguration> args = new List<ContributorArgumentConfiguration>(); // Generate reports when in debug configuration args.Add(new ContributorArgumentConfiguration( GenerateUpdateReport, "true", "'$(Configuration)' == 'Debug'")); return args; }
''' <summary> ''' Override the OnPopulateArgument method to build a list of arguments from the input ''' configuration information. ''' </summary> Protected Overloads Overrides Function OnPopulateArguments() As IList(Of ContributorArgumentConfiguration) Dim args As New List(Of ContributorArgumentConfiguration)() ' Generate reports when in debug configuration args.Add(New ContributorArgumentConfiguration(GenerateUpdateReport, "true", "'$(Configuration)' == 'Debug'")) Return args End Function
Você cria um ContributorArgumentConfiguration o objeto e adicioná-lo à lista de argumentos. Por padrão, o relatório é gerado quando você gera uma compilação de depuração.
Em seguida, você pode substituir o método OnExecute para adicionar o código que você deseja executar quando um projeto de banco de dados é implantado.
Para substituir o OnExecute
Adicione o seguinte método à sua classe de DeploymentUpdateReportContributor:
/// <summary> /// Override the OnExecute method to perform actions when you execute the deployment plan for /// a database project. /// </summary> protected override void OnExecute(DeploymentPlanContributorContext context) { // determine whether the user specified a report is to be generated bool generateReport = false; string generateReportValue; if (context.Arguments.TryGetValue(GenerateUpdateReport, out generateReportValue) == false) { // couldn't find the GenerateUpdateReport argument, so do not generate generateReport = false; } else { // GenerateUpdateReport argument was specified, try to parse the value if (bool.TryParse(generateReportValue, out generateReport)) { // if we end up here, the value for the argument was not valid. // default is false, so do nothing. } } if (generateReport == false) { // if user does not want to generate a report, we are done return; } // We will output to the same directory where the deployment script // is output or to the current directory string reportPrefix = context.Options.TargetDatabaseName; string reportPath; if (string.IsNullOrEmpty(context.DeploymentScriptPath)) { reportPath = Environment.CurrentDirectory; } else { reportPath = Path.GetDirectoryName(context.DeploymentScriptPath); } FileInfo summaryReportFile = new FileInfo(Path.Combine(reportPath, reportPrefix + ".summary.xml")); FileInfo detailsReportFile = new FileInfo(Path.Combine(reportPath, reportPrefix + ".details.xml")); // Generate the reports by using the helper class DeploymentReportWriter DeploymentReportWriter writer = new DeploymentReportWriter(context); writer.WriteReport(summaryReportFile); writer.IncludeScripts = true; writer.WriteReport(detailsReportFile); string msg = "Deployment reports ->" + Environment.NewLine + summaryReportFile.FullName + Environment.NewLine + detailsReportFile.FullName; DataSchemaError reportMsg = new DataSchemaError(msg, ErrorSeverity.Message); base.PublishMessage(reportMsg); }
''' <summary> ''' Override the OnExecute method to perform actions when you execute the deployment plan for ''' a database project. ''' </summary> Protected Overloads Overrides Sub OnExecute(ByVal context As DeploymentPlanContributorContext) ' output the names and values for any provided arguments For Each arg As KeyValuePair(Of String, String) In context.Arguments Dim argMsg As New DataSchemaError((arg.Key & "=") + arg.Value, ErrorSeverity.Message) Me.PublishMessage(argMsg) Next ' determine whether the user specified a report is to be generated Dim generateReport As Boolean = False Dim generateReportValue As String If context.Arguments.TryGetValue(GenerateUpdateReport, generateReportValue) = False Then ' couldn't find the GenerateUpdateReport argument, so do not generate generateReport = False Else ' GenerateUpdateReport argument was specified, try to parse the value If Boolean.TryParse(generateReportValue, generateReport) Then ' if we end up here, the value for the argument was not valid. ' default is false, so do nothing. End If End If If generateReport = False Then ' if user does not want to generate a report, we are done Exit Sub End If ' We will output to the same directory where the deployment script ' is output or to the current directory Dim reportPrefix As String = context.Options.TargetDatabaseName Dim reportPath As String If String.IsNullOrEmpty(context.DeploymentScriptPath) Then reportPath = Environment.CurrentDirectory Else reportPath = Path.GetDirectoryName(context.DeploymentScriptPath) End If Dim summaryReportFile As New FileInfo(Path.Combine(reportPath, reportPrefix & ".summary.xml")) Dim detailsReportFile As New FileInfo(Path.Combine(reportPath, reportPrefix & ".details.xml")) ' Generate the reports by using the helper class DeploymentReportWriter Dim writer As New DeploymentReportWriter(context) writer.WriteReport(summaryReportFile) writer.IncludeScripts = True writer.WriteReport(detailsReportFile) Dim msg As String = ("Deployment reports ->" & Environment.NewLine) + summaryReportFile.FullName + Environment.NewLine + detailsReportFile.FullName Dim reportMsg As New DataSchemaError(msg, ErrorSeverity.Message) MyBase.PublishMessage(reportMsg) End Sub
O método OnExecute é passado um DeploymentPlanContributorContext especificado do objeto que fornece acesso a qualquer argumentos, origem e modelo de banco de dados de destino, as propriedades de compilação e arquivos de extensão. Neste exemplo, podemos obter o modelo e, em seguida, chamar funções auxiliares para a saída de informações sobre o modelo. Também é passado para o método um ErrorManager para usar para relatar quaisquer erros que ocorram.
Tipos adicionais e métodos de interesse incluem: DataSchemaModel, ModelStore, ModelComparisonResult , DatabaseSchemaProvider , DeploymentPlanHandle , and SchemaDeploymentOptions.
Em seguida, você pode definir a classe auxiliar que analisam os detalhes do plano de implantação.
Para adicionar a classe auxiliar que gera o corpo do relatório
Primeiro, adicione os esqueletos da classe auxiliar e seus métodos, adicionando o seguinte código:
/// <summary> /// This class is used to generate a deployment /// report. /// </summary> private class DeploymentReportWriter { /// <summary> /// The constructor accepts the same context info /// that was passed to the OnExecute method of the /// deployment contributor. /// </summary> public DeploymentReportWriter(DeploymentPlanContributorContext context) { } /// <summary> /// Property indicating whether script bodies /// should be included in the report. /// </summary> public bool IncludeScripts { get; set; } /// <summary> /// Drives the report generation, opening files, /// writing the beginning and ending report elements, /// and calling helper methods to report on the /// plan operations. /// </summary> internal void WriteReport(FileInfo reportFile) { } /// <summary> /// Writes details for the various operation types /// that could be contained in the deployment plan. /// Optionally writes script bodies, depending on /// the value of the IncludeScripts property. /// </summary> private void ReportPlanOperations(XmlWriter xmlw) { } /// <summary> /// Returns the category of the specified element /// in the source model /// </summary> private string GetElementCategory(IModelElement element) { } /// <summary> /// Returns the name of the specified element /// in the source model /// </summary> private string GetElementName(IModelElement element) { } }
''' <summary> ''' This class is used to generate a deployment ''' report. ''' </summary> Private Class DeploymentReportWriter Public Sub New(ByVal context As DeploymentPlanContributorContext) End Sub Private _includeScripts As Boolean ''' <summary> ''' Property indicating whether script bodies ''' should be included in the report. ''' </summary> Public Property IncludeScripts() As Boolean Get IncludeScripts = _includeScripts End Get Set(ByVal value As Boolean) _includeScripts = value End Set End Property ''' <summary> ''' Drives the report generation, opening files, ''' writing the beginning and ending report elements, ''' and calling helper methods to report on the ''' plan operations. ''' </summary> Friend Sub WriteReport(ByVal reportFile As FileInfo) End Sub ''' <summary> ''' Writes details for the various operation types ''' that could be contained in the deployment plan. ''' Optionally writes script bodies, depending on ''' the value of the IncludeScripts property. ''' </summary> Private Sub ReportPlanOperations(ByVal xmlw As XmlWriter) End Sub ''' <summary> ''' Returns the category of the specified element ''' in the source model ''' </summary> Private Function GetElementCategory(ByVal element As IModelElement) As String Return "" End Function ''' <summary> ''' Returns the name of the specified element ''' in the source model ''' </summary> Private Function GetElementName(ByVal element As IModelElement) As String Return "" End Function End Class
Salve as alterações Class1. cs.
Em seguida, você pode adicionar membros de classe e corpos de método..
Para adicionar os membros de classe
No editor de código, adicione o seguinte código à classe DeploymentReportWriter:
readonly DataSchemaModel _sourceModel; readonly ModelComparisonResult _diff; readonly DeploymentStep _planHead;
ReadOnly _sourceModel As DataSchemaModel ReadOnly _diff As ModelComparisonResult ReadOnly _planHead As DeploymentStep
Tipos de interesse incluem o seguinte: DataSchemaModel, ModelComparisonResult , and DeploymentStep .
Em seguida, você deve adicionar o corpo do construtor de classe.
Para adicionar o corpo do método do construtor
Adicione o seguinte código no corpo do construtor:
if (context == null) { throw new ArgumentNullException("context"); } // save the source model, source/target differences, // and the beginning of the deployment plan. _sourceModel = context.Source; _diff = context.ComparisonResult; _planHead = context.PlanHandle.Head;
If context Is Nothing Then Throw New ArgumentNullException("context") End If ' save the source model, source/target differences, ' and the beginning of the deployment plan. _sourceModel = context.Source _diff = context.ComparisonResult _planHead = context.PlanHandle.Head
Em seguida, você deve adicionar o corpo do método para o método WriteReport.
Para adicionar o corpo do método para o método WriteReport
Adicione o seguinte código no corpo do método WriteReport:
// Assumes that we have a valid report file if (reportFile == null) { throw new ArgumentNullException("reportFile"); } // set up the XML writer XmlWriterSettings xmlws = new XmlWriterSettings(); // Indentation makes it a bit more readable xmlws.Indent = true; FileStream fs = new FileStream(reportFile.FullName, FileMode.Create, FileAccess.Write, FileShare.ReadWrite); XmlWriter xmlw = XmlWriter.Create(fs, xmlws); try { xmlw.WriteStartDocument(true); xmlw.WriteStartElement("DeploymentReport"); // Summary report of the operations that // are contained in the plan. ReportPlanOperations(xmlw); // You could add a method call here // to produce a detailed listing of the // differences between the source and // target model. xmlw.WriteEndElement(); xmlw.WriteEndDocument(); xmlw.Flush(); fs.Flush(); } finally { xmlw.Close(); fs.Dispose(); }
' Assumes that we have a valid report file If reportFile Is Nothing Then Throw New ArgumentNullException("reportFile") End If ' set up the XML writer Dim xmlws As New XmlWriterSettings() ' Indentation makes it a bit more readable xmlws.Indent = True Dim fs As New FileStream(reportFile.FullName, FileMode.Create, FileAccess.Write, FileShare.ReadWrite) Dim xmlw As XmlWriter = XmlWriter.Create(fs, xmlws) Try xmlw.WriteStartDocument(True) xmlw.WriteStartElement("DeploymentReport") ' Summary report of the operations that ' are contained in the plan. ReportPlanOperations(xmlw) ' You could add a method call here ' to produce a detailed listing of the ' differences between the source and ' target model. xmlw.WriteEndElement() xmlw.WriteEndDocument() xmlw.Flush() fs.Flush() Finally xmlw.Close() fs.Dispose() End Try
Tipos de interesse são XmlWriter e XmlWriterSettings.
Em seguida, você deve adicionar o corpo do método ReportPlanOperations.
Para adicionar o corpo do método para o método ReportPlanOperations
Adicione o seguinte código no corpo do método ReportPlanOperations:
// write the node to indicate the start // of the list of operations. xmlw.WriteStartElement("Operations"); // Loop through the steps in the plan, // starting at the beginning. DeploymentStep currentStep = _planHead; while (currentStep != null) { // Report the type of step xmlw.WriteStartElement(currentStep.GetType().Name); // based on the type of step, report // the relevant information. // Note that this procedure only handles // a subset of all step types. if (currentStep is SqlRenameStep) { SqlRenameStep renameStep = (SqlRenameStep)currentStep; xmlw.WriteAttributeString("OriginalName", renameStep.OldName); xmlw.WriteAttributeString("NewName", renameStep.NewName); xmlw.WriteAttributeString("Category", GetElementCategory(renameStep.RenamedElement)); } else if (currentStep is SqlMoveSchemaStep) { SqlMoveSchemaStep moveStep = (SqlMoveSchemaStep)currentStep; xmlw.WriteAttributeString("OrignalName", moveStep.PreviousName); xmlw.WriteAttributeString("NewSchema", moveStep.NewSchema); xmlw.WriteAttributeString("Category", GetElementCategory(moveStep.MovedElement)); } else if (currentStep is SqlTableMigrationStep) { SqlTableMigrationStep dmStep = (SqlTableMigrationStep)currentStep; xmlw.WriteAttributeString("Name", GetElementName(dmStep.SourceTable)); xmlw.WriteAttributeString("Category", GetElementCategory(dmStep.SourceElement)); } else if (currentStep is CreateElementStep) { CreateElementStep createStep = (CreateElementStep)currentStep; xmlw.WriteAttributeString("Name", GetElementName(createStep.SourceElement)); xmlw.WriteAttributeString("Category", GetElementCategory(createStep.SourceElement)); } else if (currentStep is AlterElementStep) { AlterElementStep alterStep = (AlterElementStep)currentStep; xmlw.WriteAttributeString("Name", GetElementName(alterStep.SourceElement)); xmlw.WriteAttributeString("Category", GetElementCategory(alterStep.SourceElement)); } else if (currentStep is DropElementStep) { DropElementStep dropStep = (DropElementStep)currentStep; xmlw.WriteAttributeString("Name", GetElementName(dropStep.TargetElement)); xmlw.WriteAttributeString("Category", GetElementCategory(dropStep.TargetElement)); } // If the script bodies are to be included, // add them to the report. if (this.IncludeScripts) { string tsqlBody = currentStep.Action(); if (string.IsNullOrEmpty(tsqlBody) == false) { xmlw.WriteCData(tsqlBody); } } // close off the current step xmlw.WriteEndElement(); currentStep = currentStep.Next; } xmlw.WriteEndElement();
' write the node to indicate the start ' of the list of operations. xmlw.WriteStartElement("Operations") ' Loop through the steps in the plan, ' starting at the beginning. Dim currentStep As DeploymentStep = _planHead While currentStep IsNot Nothing ' Report the type of step xmlw.WriteStartElement(currentStep.[GetType]().Name) ' based on the type of step, report ' the relevant information. If TypeOf currentStep Is SqlRenameStep Then Dim renameStep As SqlRenameStep = DirectCast(currentStep, SqlRenameStep) xmlw.WriteAttributeString("OriginalName", renameStep.OldName) xmlw.WriteAttributeString("NewName", renameStep.NewName) xmlw.WriteAttributeString("Category", GetElementCategory(renameStep.RenamedElement)) ElseIf TypeOf currentStep Is SqlMoveSchemaStep Then Dim moveStep As SqlMoveSchemaStep = DirectCast(currentStep, SqlMoveSchemaStep) xmlw.WriteAttributeString("OrignalName", moveStep.PreviousName) xmlw.WriteAttributeString("NewSchema", moveStep.NewSchema) xmlw.WriteAttributeString("Category", GetElementCategory(moveStep.MovedElement)) ElseIf TypeOf currentStep Is SqlTableMigrationStep Then Dim dmStep As SqlTableMigrationStep = DirectCast(currentStep, SqlTableMigrationStep) xmlw.WriteAttributeString("Name", GetElementName(dmStep.SourceTable)) xmlw.WriteAttributeString("Category", GetElementCategory(dmStep.SourceElement)) ElseIf TypeOf currentStep Is CreateElementStep Then Dim createStep As CreateElementStep = DirectCast(currentStep, CreateElementStep) xmlw.WriteAttributeString("Name", GetElementName(createStep.SourceElement)) xmlw.WriteAttributeString("Category", GetElementCategory(createStep.SourceElement)) ElseIf TypeOf currentStep Is AlterElementStep Then Dim alterStep As AlterElementStep = DirectCast(currentStep, AlterElementStep) xmlw.WriteAttributeString("Name", GetElementName(alterStep.SourceElement)) xmlw.WriteAttributeString("Category", GetElementCategory(alterStep.SourceElement)) ElseIf TypeOf currentStep Is DropElementStep Then Dim dropStep As DropElementStep = DirectCast(currentStep, DropElementStep) xmlw.WriteAttributeString("Name", GetElementName(dropStep.TargetElement)) xmlw.WriteAttributeString("Category", GetElementCategory(dropStep.TargetElement)) End If ' If the script bodies are to be included, ' add them to the report. If Me.IncludeScripts Then Dim tsqlBody As String = currentStep.Action() If String.IsNullOrEmpty(tsqlBody) = False Then xmlw.WriteCData(tsqlBody) End If End If ' close off the current step xmlw.WriteEndElement() currentStep = currentStep.[Next] End While xmlw.WriteEndElement()
Tipos de interesse incluem o seguinte: DeploymentStep, SqlRenameStep , SqlMoveSchemaStep , SqlTableMigrationStep , CreateElementStep , AlterElementStep , and DropElementStep . Os seguintes tipos de etapa são tipos de etapa adicional que não são mostrados neste exemplo: BeginPostDeploymentScriptStep, BeginPreDeploymentScriptStep , DeploymentScriptDomStep , DeploymentScriptStep , EndPostDeploymentScriptStep , and EndPreDeploymentScriptStep . Você também pode procurar a SQL Server-etapas específicas: SqlBeginAltersStep, SqlBeginDropsStep , SqlBeginPreservationStep , SqlBeginTransactionStep , SqlEndAltersStep , SqlEndDropsStep , SqlEndPreservationStep , SqlEndTransactionStep , SqlFinalizeDatabaseAccessStep , SqlMoveSchemaStep , SqlPrintStep , SqlRenameStep , and SqlTableMigrationStep .
Em seguida, você pode adicionar o corpo do método GetElementCategory.
Para adicionar o corpo do método para o método GetElementCategory
Adicione o seguinte código no corpo do método GetElementCategory:
return _sourceModel.DatabaseSchemaProvider.UserInteractionServices.GetElementTypeDescription( element.ElementClass);
Return _sourceModel.DatabaseSchemaProvider.UserInteractionServices.GetElementTypeDescription(element.ElementClass)
Tipos e métodos de interesse incluem o seguinte: DataSchemaModel, DatabaseSchemaProvider , UserInteractionServices , and GetElementTypeDescription .
Em seguida, você pode adicionar o corpo do método GetElementName.
Para adicionar o corpo do método para o método GetElementName
Adicione o seguinte código no corpo do método GetElementName:
return _sourceModel.DatabaseSchemaProvider.UserInteractionServices.GetElementName( element, ElementNameStyle.FullyQualifiedName);
Return _sourceModel.DatabaseSchemaProvider.UserInteractionServices.GetElementName(element, ElementNameStyle.FullyQualifiedName)
Tipos e métodos de interesse incluem o seguinte: DataSchemaModel, DatabaseSchemaProvider , UserInteractionServices , GetElementName , and ElementNameStyle .
Para salvar as alterações à classe. Em seguida, você pode criar a biblioteca de classes.
Para assinar e compilar o assembly
Sobre o projeto menu, clique em Propriedades de MyDeploymentContributor.
Clique na guia Signing.
Clique em Sign the assembly.
Em Choose a strong name key file, clique em <New>.
No Create Strong Name Key na caixa nome do arquivo de chave, tipo MyRefKey.
(opcional) Você pode especificar uma senha para seu arquivo de chave de nome forte.
Clique em OK.
No menu File, clique em Save All.
Sobre o Build menu, clique em Build Solution.
Em seguida, você deve instalar e registrar o assembly para que ele será carregado quando você implantar projetos de banco de dados.
Instalar um colaborador de implantação
Para instalar um colaborador de implantação, você deve executar as seguintes tarefas:
Copie o assembly e o arquivo. PDB de associados para a pasta de extensões
Criar um arquivo de Extensions.xml para registrar o colaborador de implantação para que ele é carregado quando você os projetos de banco de dados de implantação
Para instalar o conjunto de MyDeploymentContributor
Crie uma pasta chamada MyExtensions na pasta % do programa Files%\Microsoft Visual Studio 10.0\VSTSDB\Extensions.
Copie o assembly assinado (MyDeploymentContributor.dll) e o arquivo. PDB de associados (MyDeploymentContributor.pdb) para a pasta de 10.0\VSTSDB\Extensions\MyExtensions de Visual Studio do programa Files%\Microsoft %.
Observação Recomendamos não copie os arquivos XML diretamente para a pasta de 10.0\VSTSDB\Extensions de Visual Studio do programa Files%\Microsoft %. Se você usar uma subpasta em vez disso, você evitará que alterações acidentais feitas para os arquivos que são fornecidos com Visual Studio Premium.
Em seguida, você deve registrar o assembly, o que é um tipo de a extensão de recurso, de modo que ele aparecerá na Visual Studio Premium.
Para registrar o assembly de MyDeploymentContributor
No Exibir menu, clique em Other Windowse em seguida, clique em Janela de comando para abrir o comando janela.
No comando janela, digite o seguinte código. Para FilePath, substitua o caminho e o nome do arquivo. dll de compilado. Inclua as aspas ao redor do caminho e nome de arquivo.
Observação Por padrão, o caminho do seu arquivo compilado. dll é YourSolutionPath\bin\Debug ou YourSolutionPath\bin\Release.
? System.Reflection.Assembly.LoadFrom(@"FilePath").FullName
? System.Reflection.Assembly.LoadFrom("FilePath").FullName
Pressione Enter.
Copie a linha resultante para a área de transferência. A linha deve ser semelhante ao seguinte:
"MyDeploymentContributor, Version=1.0.0.0, Culture=neutral, PublicKeyToken=nnnnnnnnnnnnnnnn"
Abra um editor de texto sem formatação, como, por exemplo, o bloco de notas.
Importante Em Windows Vista e a Microsoft Windows Server 2008, abra o editor como um administrador para que você pode salvar o arquivo em sua pasta de arquivos de programa.
Forneça as informações a seguintes, especificando o seu próprio nome de assembly, o token de chave pública e o tipo de extensão:
<?xml version="1.0" encoding="utf-8" ?> <extensions assembly="" version="1" xmlns="urn:Microsoft.Data.Schema.Extensions" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="urn:Microsoft.Data.Schema.Extensions Microsoft.Data.Schema.Extensions.xsd"> <extension type="MyDeploymentContributor.DeploymentUpdateReportContributor" assembly="MyDeploymentContributor, Version=1.0.0.0, Culture=neutral, PublicKeyToken=<enter key here>" enabled="true" /> </extensions>
Você usa este arquivo XML para registrar a classe que herda de DeploymentPlanExecutor.
Salve o arquivo como MyDeploymentContributor.extensions.xml na pasta % do programa Files%\Microsoft Visual Studio 10.0\VSTSDB\Extensions\MyExtensions.
Close Visual Studio.
Em seguida, você irá implantar um projeto de banco de dados para testar seu colaborador.
Teste seu colaborador de implantação
Para testar seu colaborador de implantação, você deve executar as seguintes tarefas:
Adicionar uma propriedade para o arquivo de .dbproj que você planeja implantar
Implantar o projeto de banco de dados usando o MSBuild e fornecer o parâmetro apropriado
Adicionar propriedades para o projeto de banco de dados (.dbproj) o arquivo
Se você deseja usar este Colaborador de implantação de MSBuild, você deve modificar o projeto de banco de dados para permitir aos usuários passar um parâmetro por meio de MSBuild. Para atualizar seu projeto de banco de dados, abra-o no editor de sua preferência e adicione as seguintes instruções para o arquivo de .dbproj entre o último </ItemGroup> o nó no arquivo e o final </Project> nó:
<ItemGroup>
<DeploymentContributorArgument Include="GenerateUpdateReport=$(GenerateUpdateReport)" />
</ItemGroup>
Depois de atualizar o arquivo .dbproj, você pode usar MSBuild passar os parâmetros para compilações de linha de comando.
Implantar o projeto de banco de dados
Para implantar o seu projeto de banco de dados e gerar um relatório de implantação
Abrir um Visual Studio o Prompt de comando. No Iniciar menu, clique em Todos os programas, clique em 2010 do Microsoft Visual Studio, clique em Visual Studio Toolse clique em Prompt de comando Visual Studio (2010).
No prompt de comando, navegue até a pasta que contém o seu projeto de banco de dados.
No prompt de comando, digite a seguinte linha de comando:
MSBuild /t:Rebuild MyDatabaseProject.dbproj /p:OutDir=.\
Substitua MyDatabaseProject com o nome do projeto de banco de dados que você deseja criar. Se você alterou o projeto após a última compilação, você poderia usar /t:Build em vez de /t: Rebuild.
No prompt de comando, digite a seguinte linha de comando:
MSBuild /t:Deploy MyDatabaseProject.dbproj /p:GenerateUpdateReport=true
Substitua MyDatabaseProject com o nome do projeto de banco de dados que você deseja implantar.
Será exibida uma saída como o seguinte:
Microsoft (R) Build Engine Version 4.0.20817.0
[Microsoft .NET Framework, Version 4.0.20817.0]
Copyright (C) Microsoft Corporation 2007. All rights reserved.
Build started 8/26/2009 3:12:43 PM.
Project "C:\Users\UserName\Documents\Visual Studio 2010\Projects\MyDatabaseProject\Dep
TestToo\MyDatabaseProject.dbproj" on node 1 (Deploy target(s)).
DspDeploy:
GenerateUpdateReport=true
Deployment reports ->
C:\Users\UserName\Documents\Visual Studio 2010\Projects\MyDatabaseProject\MyDatabaseProject\sql\debug\MyTargetDatabase.summary.xml
C:\Users\UserName\Documents\Visual Studio 2010\Projects\MyDatabaseProject\MyDatabaseProject\sql\debug\MyTargetDatabase.details.xml
Deployment script generated to:
C:\Users\UserName\Documents\Visual Studio 2010\Projects\MyDatabaseProject\MyDatabaseProject\sql\debug\MyDatabaseProject.sql
Done Building Project "C:\Users\UserName\Documents\Visual Studio 2010\Projects\MyDatabaseProject\MyDatabaseProject\MyDatabaseProject.dbproj" (Deploy target(s)).
Build succeeded.
0 Warning(s)
0 Error(s)
Time Elapsed 00:00:04.02
Abra MyTargetDatabase.summary.xml e examine o conteúdo.
O arquivo é semelhante ao exemplo a seguir mostra uma nova implantação de banco de dados:
<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<DeploymentReport>
<Operations>
<DeploymentScriptStep />
<DeploymentScriptDomStep />
<DeploymentScriptStep />
<DeploymentScriptDomStep />
<DeploymentScriptStep />
<DeploymentScriptStep />
<DeploymentScriptStep />
<DeploymentScriptStep />
<DeploymentScriptDomStep />
<DeploymentScriptDomStep />
<DeploymentScriptDomStep />
<DeploymentScriptDomStep />
<DeploymentScriptStep />
<DeploymentScriptDomStep />
<BeginPreDeploymentScriptStep />
<DeploymentScriptStep />
<EndPreDeploymentScriptStep />
<SqlBeginPreservationStep />
<SqlEndPreservationStep />
<SqlBeginDropsStep />
<SqlEndDropsStep />
<SqlBeginAltersStep />
<SqlPrintStep />
<CreateElementStep Name="Sales" Category="Schema" />
<SqlPrintStep />
<CreateElementStep Name="Sales.Customer" Category="Table" />
<SqlPrintStep />
<CreateElementStep Name="Sales.PK_Customer_CustID" Category="Primary Key" />
<SqlPrintStep />
<CreateElementStep Name="Sales.Orders" Category="Table" />
<SqlPrintStep />
<CreateElementStep Name="Sales.PK_Orders_OrderID" Category="Primary Key" />
<SqlPrintStep />
<CreateElementStep Name="Sales.Def_Customer_YTDOrders" Category="Default Constraint" />
<SqlPrintStep />
<CreateElementStep Name="Sales.Def_Customer_YTDSales" Category="Default Constraint" />
<SqlPrintStep />
<CreateElementStep Name="Sales.Def_Orders_OrderDate" Category="Default Constraint" />
<SqlPrintStep />
<CreateElementStep Name="Sales.Def_Orders_Status" Category="Default Constraint" />
<SqlPrintStep />
<CreateElementStep Name="Sales.FK_Orders_Customer_CustID" Category="Foreign Key" />
<SqlPrintStep />
<CreateElementStep Name="Sales.CK_Orders_FilledDate" Category="Check Constraint" />
<SqlPrintStep />
<CreateElementStep Name="Sales.CK_Orders_OrderDate" Category="Check Constraint" />
<SqlPrintStep />
<CreateElementStep Name="Sales.uspCancelOrder" Category="Procedure" />
<SqlPrintStep />
<CreateElementStep Name="Sales.uspFillOrder" Category="Procedure" />
<SqlPrintStep />
<CreateElementStep Name="Sales.uspNewCustomer" Category="Procedure" />
<SqlPrintStep />
<CreateElementStep Name="Sales.uspPlaceNewOrder" Category="Procedure" />
<SqlPrintStep />
<CreateElementStep Name="Sales.uspShowOrderDetails" Category="Procedure" />
<SqlEndAltersStep />
<DeploymentScriptStep />
<BeginPostDeploymentScriptStep />
<DeploymentScriptStep />
<EndPostDeploymentScriptStep />
<DeploymentScriptDomStep />
<DeploymentScriptDomStep />
<DeploymentScriptDomStep />
</Operations>
</DeploymentReport>
Observação |
---|
Se você implantar um projeto de banco de dados é idêntico ao banco de dados de destino, o relatório resultante não será muito significativo. Para obter resultados mais significativos, implantar alterações em um banco de dados ou implantar um novo banco de dados. |
Abra MyTargetDatabase.details.xml e examine o conteúdo.
Uma pequena seção do arquivo de detalhes mostra as entradas e um script que cria o esquema de vendas, o que imprimir uma mensagem sobre a criação de uma tabela e que criar a tabela:
<CreateElementStep Name="Sales" Category="Schema"><![CDATA[CREATE SCHEMA [Sales]
AUTHORIZATION [dbo];
]]></CreateElementStep>
<SqlPrintStep><![CDATA[PRINT N'Creating [Sales].[Customer]...';
]]></SqlPrintStep>
<CreateElementStep Name="Sales.Customer" Category="Table"><![CDATA[CREATE TABLE [Sales].[Customer] (
[CustomerID] INT IDENTITY (1, 1) NOT NULL,
[CustomerName] NVARCHAR (40) NOT NULL,
[YTDOrders] INT NOT NULL,
[YTDSales] INT NOT NULL
);
]]></CreateElementStep>
Analisando o plano de implantação como ele é executado, você pode relatar qualquer informação contida na implantação e pode realizar ações adicionais, com base nas etapas no plano.
Próximas etapas
Você pode criar ferramentas adicionais para executar o processamento dos arquivos XML de saída. Este é apenas um exemplo de um DeploymentPlanExecutor. Você também pode criar um DeploymentPlanModifier para alterar o plano de implantação antes que ele seja executado.
Consulte também
Conceitos
Estender os recursos de banco de dados de Visual Studio