Demonstra Passo a passo: Criando um novo tipo de banco de dados de refatoração para alterar as maiúsculas e minúsculas
Neste tópico passo a passo, você irá criar, instalar, registrar e testar um novo tipo de a refatoração de banco de dados. Esta operação de refatoração converterá o primeiro caractere do nome do objeto especificado em maiúsculas, e ele atualiza todas as referências a esse nome atualizado.
Essa explicação passo a passo ilustra as seguintes tarefas:
Crie um novo assembly que contém as classes de um tipo personalizado de refatoração.
Instalar e registrar o assembly, para que o tipo de refatoração está disponível em Visual Studio Premium ou Visual Studio Ultimate.
Criar um simples o projeto de banco de dados para testar se o tipo de refatoração funciona conforme esperado.
Pré-requisitos
Para completar este passo a passo, são necessários os seguintes componentes:
Você deve ter instalado Visual Studio 2010 Premium ou Visual Studio 2010 Ultimate.
Você também deve ter o Visual Studio 2010 Software Development Kit (SDK) instalado no seu computador. Para baixar esse kit, consulte esta página no site da Microsoft: SDK de 2010 Visual Studio.
Criando um Assembly com um personalizado refatoração de tipo
Para criar um tipo personalizado de refatoração que pode converter a primeira letra do nome de um objeto para letras maiúsculas e atualizar todas as referências a esse objeto, você deve implementar seis classes:
CasingRefactoringCommand — Essa classe fornece o nome do comando no menu de refatoração, especifica quais elementos de modelo, seu tipo de refatoração está disponível e chama a operação de refatoração quando o usuário clica no comando.
CasingRefactoringOperation — Essa classe especifica como a operação de refatoração interage com a janela de visualização, especifica as propriedades que descrevem a operação e cria a classe CasingContributorInput.
CasingContributorInput — Essa classe armazena os dados de entrada para a classe CasingSymbolContributor.
CasingSymbolContributor — Essa classe cria a lista de propostas de alteração para o símbolo renomeado e ele também cria a classe CasingReferenceContributorInput para manipular Atualizando as referências ao objeto cujo nome está sendo alterado.
CasingReferenceContributorInput — Essa classe armazena os dados de entrada para a classe CasingReferenceContributor.
CasingReferenceContributor — Essa classe cria a lista de propostas de alteração associada à atualização de referências para o símbolo renomeado.
Antes de criar essas classes, irá criar uma biblioteca de classe, adicionar referências necessárias e adicione algum código auxiliar que simplifica a parte do código que você codificará posteriormente nesta explicação passo a passo.
Para criar o código de biblioteca e o auxiliar de classe
Crie um novo C# classe projeto de biblioteca e nomeie- CasingRefactoringType.csproj.
Adicione referências para as bibliotecas de classes a seguir:
Microsoft.Data.Schema.dll
Microsoft.Data.Schema.ScriptDom.dll
Microsoft.Data.Schema.ScriptDom.SQL.dll
Microsoft.Data.Schema.SQL.dll
Microsoft.VisualStudio.Data.Schema.Package.dll
Microsoft.VisualStudio.Data.Schema.Package.SQL.dll
Adicione referências aos assemblies seguintes a partir do Visual Studio 2010 Software Development Kit (SDK):
Microsoft.VisualStudio.OLE.Interop.dll
Microsoft.VisualStudio.Shell.10.0.dll
Microsoft.VisualStudio.Shell.Interop.dll
Microsoft.VisualStudio.Shell.Interop.8.0.dll
Microsoft.VisualStudio.Shell.Interop.9.0.dll
Microsoft.VisualStudio.Shell.Interop.10.0.dll
Microsoft.VisualStudio.TextManager.Interop.dll
Em Solution Explorer, renomeie Class1. cs para SampleHelper.cs.
Clique duas vezes em SampleHelper.cs para abri-lo no editor de código.
Substitua o conteúdo do editor de código com o seguinte código:
using System; using System.Collections.Generic; using System.Diagnostics; using System.IO; using System.Runtime.InteropServices; using Microsoft.Data.Schema.SchemaModel; using Microsoft.Data.Schema.ScriptDom.Sql; using Microsoft.VisualStudio; using Microsoft.VisualStudio.Data.Schema.Package.Refactoring; using Microsoft.VisualStudio.Data.Schema.Package.UI; using Microsoft.VisualStudio.Shell.Interop; using Microsoft.VisualStudio.TextManager.Interop; namespace MySamples.Refactoring { internal static class SampleHelper { public static String GetModelElementName(IModelElement modelElement) { SampleHelper.CheckNullArgument(modelElement, "modelElement"); return modelElement.ToString(); } /// <summary> /// Given a model element, returns its simple name. /// </summary> public static String GetModelElementSimpleName(IModelElement modelElement) { String separator = "."; String simpleName = String.Empty; String fullName = modelElement.ToString(); String[] nameParts = fullName.Split(separator.ToCharArray(), StringSplitOptions.RemoveEmptyEntries); if (nameParts.Length > 0) { simpleName = nameParts[nameParts.Length - 1]; // last part } if (simpleName.StartsWith("[") && simpleName.EndsWith("]")) { simpleName = simpleName.Substring(1, simpleName.Length - 2); } return simpleName; } /// <summary> /// Find all files in the project with the specified file extension /// </summary> public static List<string> GetAllFilesInProject(IVsHierarchy solutionNode, string fileExtension, bool visibleNodesOnly) { List<string> files = new List<string>(); if (null != solutionNode) { EnumProjectItems(solutionNode, fileExtension, files, VSConstants.VSITEMID_ROOT, // item id of solution root node 0, // recursion from solution node true, // hierarchy is Solution node visibleNodesOnly); // visibleNodesOnly } return files; } /// <summary> /// Enumerates recursively over the hierarchy items. /// </summary> /// <param name="hierarchy">hierarchy to enmerate over.</param> /// <param name="fileExtension">type of files we need to collect from the project</param> /// <param name="files">list of file paths</param> /// <param name="itemid">item id of the hierarchy</param> /// <param name="recursionLevel">Depth of recursion. e.g. if recursion started with the Solution /// node, then : Level 0 -- Solution node, Level 1 -- children of Solution, etc.</param> /// <param name="hierIsSolution">true if hierarchy is Solution Node. </param> /// <param name="visibleNodesOnly">true if only nodes visible in the Solution Explorer should /// be traversed. false if all project items should be traversed.</param> private static void EnumProjectItems(IVsHierarchy hierarchy, string fileExtension, List<string> files, uint itemid, int recursionLevel, bool hierIsSolution, bool visibleNodesOnly) { int hr; IntPtr nestedHierarchyObj; uint nestedItemId; Guid hierGuid = typeof(IVsHierarchy).GUID; // Check first if this node has a nested hierarchy. hr = hierarchy.GetNestedHierarchy(itemid, ref hierGuid, out nestedHierarchyObj, out nestedItemId); if (VSConstants.S_OK == hr && IntPtr.Zero != nestedHierarchyObj) { IVsHierarchy nestedHierarchy = Marshal.GetObjectForIUnknown(nestedHierarchyObj) as IVsHierarchy; Marshal.Release(nestedHierarchyObj); if (nestedHierarchy != null) { EnumProjectItems(nestedHierarchy, fileExtension, files, nestedItemId, recursionLevel, false, visibleNodesOnly); } } else { // Check if the file extension of this node matches string fileFullPath; hierarchy.GetCanonicalName(itemid, out fileFullPath); if (CompareExtension(fileFullPath, fileExtension)) { // add matched file paths into the list files.Add(fileFullPath); } recursionLevel++; //Get the first child node of the current hierarchy being walked object pVar; hr = hierarchy.GetProperty(itemid, ((visibleNodesOnly || (hierIsSolution && recursionLevel == 1) ? (int)__VSHPROPID.VSHPROPID_FirstVisibleChild : (int)__VSHPROPID.VSHPROPID_FirstChild)), out pVar); ErrorHandler.ThrowOnFailure(hr); if (VSConstants.S_OK == hr) { // Use Depth first search so at each level we recurse to check if the node has any children // and then look for siblings. uint childId = GetItemId(pVar); while (childId != VSConstants.VSITEMID_NIL) { EnumProjectItems(hierarchy, fileExtension, files, childId, recursionLevel, false, visibleNodesOnly); hr = hierarchy.GetProperty(childId, ((visibleNodesOnly || (hierIsSolution && recursionLevel == 1)) ? (int)__VSHPROPID.VSHPROPID_NextVisibleSibling : (int)__VSHPROPID.VSHPROPID_NextSibling), out pVar); if (VSConstants.S_OK == hr) { childId = GetItemId(pVar); } else { ErrorHandler.ThrowOnFailure(hr); break; } } } } } /// <summary> /// Gets the item id. /// </summary> /// <param name="pvar">VARIANT holding an itemid.</param> /// <returns>Item Id of the concerned node</returns> private static uint GetItemId(object pvar) { if (pvar == null) return VSConstants.VSITEMID_NIL; if (pvar is int) return (uint)(int)pvar; if (pvar is uint) return (uint)pvar; if (pvar is short) return (uint)(short)pvar; if (pvar is ushort) return (uint)(ushort)pvar; if (pvar is long) return (uint)(long)pvar; return VSConstants.VSITEMID_NIL; } /// <summary> /// Check if the file has the expected extension. /// </summary> /// <param name="filePath"></param> /// <param name="extension"></param> /// <returns></returns> public static bool CompareExtension(string filePath, string extension) { bool equals = false; if (!string.IsNullOrEmpty(filePath)) { equals = (string.Compare(System.IO.Path.GetExtension(filePath), extension, StringComparison.OrdinalIgnoreCase) == 0); } return equals; } /// <summary> /// Read file content from a file /// </summary> /// <param name="filePath"> file path </param> /// <returns> file content in a string </returns> internal static string ReadFileContent(string filePath) { // Ensure that the file exists first. if (!File.Exists(filePath)) { Debug.WriteLine(string.Format("Cannot find the file: '{0}'", filePath)); return string.Empty; } string content; using (StreamReader reader = new StreamReader(filePath)) { content = reader.ReadToEnd(); reader.Close(); } return content; } /// <summary> /// Check null references and throw /// </summary> /// <param name="obj"></param> /// <param name="?"></param> public static void CheckNullArgument(object obj, string objectName) { if (obj == null) { throw new System.ArgumentNullException(objectName); } } /// <summary> /// Get offset of the fragment from an Identifier if the identifier.value matches the /// name we are looking for. /// </summary> /// <param name="identifier"></param> /// <param name="expectedName"></param> public static RawChangeInfo AddOffsestFromIdentifier( Identifier identifier, String expectedName, String newName, Boolean keepOldQuote) { RawChangeInfo change = null; if (identifier != null && String.Compare(expectedName, identifier.Value, true) == 0) { if (keepOldQuote) { QuoteType newQuote = QuoteType.NotQuoted; newName = Identifier.DecodeIdentifier(newName, out newQuote); newName = Identifier.EncodeIdentifier(newName, identifier.QuoteType); } change = new RawChangeInfo(identifier.StartOffset, identifier.FragmentLength, expectedName, newName); } return change; } public static IList<ChangeProposal> ConvertOffsets( string projectFullName, string fileFullPath, List<RawChangeInfo> changes, bool defaultIncluded) { // Get the file content into IVsTextLines IVsTextLines textLines = GetTextLines(fileFullPath); int changesCount = changes.Count; List<ChangeProposal> changeProposals = new List<ChangeProposal>(changesCount); for (int changeIndex = 0; changeIndex < changesCount; changeIndex++) { int startLine = 0; int startColumn = 0; int endLine = 0; int endColumn = 0; RawChangeInfo currentChange = changes[changeIndex]; int startPosition = currentChange.StartOffset; int endPosition = currentChange.StartOffset + currentChange.Length; int result = textLines.GetLineIndexOfPosition(startPosition, out startLine, out startColumn); if (result == VSConstants.S_OK) { result = textLines.GetLineIndexOfPosition(endPosition, out endLine, out endColumn); if (result == VSConstants.S_OK) { TextChangeProposal changeProposal = new TextChangeProposal(projectFullName, fileFullPath, currentChange.NewText); changeProposal.StartLine = startLine; changeProposal.StartColumn = startColumn; changeProposal.EndLine = endLine; changeProposal.EndColumn = endColumn; changeProposal.Included = defaultIncluded; changeProposals.Add(changeProposal); } } if (result != VSConstants.S_OK) { throw new InvalidOperationException("Failed to convert offset"); } } return changeProposals; } /// <summary> /// Get IVsTextLines from a file. If that file is in RDT, get text buffer from it. /// If the file is not in RDT, open that file in invisible editor and get text buffer /// from it. /// If failed to get text buffer, it will return null. /// </summary> /// <param name="fullPathFileName">File name with full path.</param> /// <returns>Text buffer for that file.</returns> private static IVsTextLines GetTextLines(string fullPathFileName) { System.IServiceProvider serviceProvider = DataPackage.Instance; IVsTextLines textLines = null; IVsRunningDocumentTable rdt = (IVsRunningDocumentTable)serviceProvider.GetService(typeof(SVsRunningDocumentTable)); if (rdt != null) { IVsHierarchy ppHier = null; uint pitemid, pdwCookie; IntPtr ppunkDocData = IntPtr.Zero; try { rdt.FindAndLockDocument((uint)(_VSRDTFLAGS.RDT_NoLock), fullPathFileName, out ppHier, out pitemid, out ppunkDocData, out pdwCookie); if (pdwCookie != 0) { if (ppunkDocData != IntPtr.Zero) { try { // Get text lines from the doc data IVsPersistDocData docData = (IVsPersistDocData)Marshal.GetObjectForIUnknown(ppunkDocData); if (docData is IVsTextLines) { textLines = (IVsTextLines)docData; } else { textLines = null; } } catch (ArgumentException) { // Do nothing here, it will return null stream at the end. } } } else { // The file is not in RDT, open it in invisible editor and get the text lines from it. IVsInvisibleEditor invisibleEditor = null; TryGetTextLinesAndInvisibleEditor(fullPathFileName, out invisibleEditor, out textLines); } } finally { if (ppunkDocData != IntPtr.Zero) Marshal.Release(ppunkDocData); } } return textLines; } /// <summary> /// Open the file in invisible editor in the running /// documents table (RDT), and get text buffer from that editor. /// </summary> /// <param name="fullPathFileName">File name with full path.</param> /// <param name="spEditor">The result invisible editor.</param> /// <param name="textLines">The result text buffer.</param> /// <returns>True, if the file is opened correctly in invisible editor.</returns> private static bool TryGetTextLinesAndInvisibleEditor(string fullPathFileName, out IVsInvisibleEditor spEditor, out IVsTextLines textLines) { System.IServiceProvider serviceProvider = DataPackage.Instance; spEditor = null; textLines = null; // Need to open this file. Use the invisible editor manager to do so. IVsInvisibleEditorManager spIEM; IntPtr ppDocData = IntPtr.Zero; bool result; Guid IID_IVsTextLines = typeof(IVsTextLines).GUID; try { spIEM = (IVsInvisibleEditorManager)serviceProvider.GetService(typeof(IVsInvisibleEditorManager)); spIEM.RegisterInvisibleEditor(fullPathFileName, null, (uint)_EDITORREGFLAGS.RIEF_ENABLECACHING, null, out spEditor); if (spEditor != null) { int hr = spEditor.GetDocData(0, ref IID_IVsTextLines, out ppDocData); if (hr == VSConstants.S_OK && ppDocData != IntPtr.Zero) { textLines = Marshal.GetTypedObjectForIUnknown(ppDocData, typeof(IVsTextLines)) as IVsTextLines; result = true; } else { result = false; } } else { result = false; } } finally { if (ppDocData != IntPtr.Zero) Marshal.Release(ppDocData); } return result; } } }Sobre o arquivo menu, clique em Salvar SampleHelper.cs.
Adicionar uma classe chamada RawChangeInfo ao seu projeto.
No editor de código, atualize o código de acordo com o seguinte:
using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace MySamples.Refactoring { /// <summary> /// Helper class to encapsulate StartOffset, FragmentLength and change string from /// parser and SchemaAnalzyer. /// </summary> internal sealed class RawChangeInfo { private int _startOffset; private int _length; private string _oldText; private string _newText; public RawChangeInfo(int startOffset, int length, string oldText, string newText) { _startOffset = startOffset; _length = length; _oldText = oldText; _newText = newText; } public int StartOffset { get { return _startOffset; } set { _startOffset = value; } } public int Length { get { return _length; } } public string OldText { get { return _oldText; } } public string NewText { get { return _newText; } set { _newText = value; } } } }Sobre o arquivo menu, clique em Salvar RawChangeInfo.cs.
Em seguida, você definirá a classe CasingRefactoringCommand.
Para definir a classe CasingRefactoringCommand
Adicionar uma classe chamada CasingRefactorCommand ao seu projeto.
No editor de código, atualizar usando as instruções para coincidir com o seguinte:
using Microsoft.Data.Schema.Extensibility; using Microsoft.Data.Schema.SchemaModel; using Microsoft.Data.Schema.SchemaModel.Abstract; using Microsoft.Data.Schema.Sql; using Microsoft.Data.Schema.Sql.SchemaModel; using Microsoft.VisualStudio.Data.Schema.Package.Project; using Microsoft.VisualStudio.Data.Schema.Package.Refactoring;Altere o namespace para MySamples.Refactoring:
namespace MySamples.RefactoringAtualize a definição de classe para coincidir com o seguinte:
[DatabaseSchemaProviderCompatibility(typeof(SqlDatabaseSchemaProvider))] internal class CasingRefactorCommand : RefactoringSchemaViewNodeCommand { }O atributo é usado para especificar o provedores do esquema de banco de dados com que esse tipo de refatoração é compatível. Neste exemplo, o novo tipo de refatoração funcionará com qualquer provedor que é derivada de SqlDatabaseSchemaProvider . Sua classe herda RefactoringSchemaViewNodeCommand . Herdam essa classe base indica que o seu tipo de refatoração está disponível em nós especificados em Visualização Esquema. Outros tipos de refatoração podem ser definidos para operar em nós de arquivo e projeto.
Em seguida, adicione que o seguinte método à sua classe de substituir:
public override void Execute(IDatabaseProjectNode currentProject, IModelElement selectedModelElement) { CasingRefactorOperation operation = new CasingRefactorOperation(currentProject, selectedModelElement); operation.DoOperation(); }Este método fornece o comportamento quando o usuário aplica o comando de refatoração em Visualização Esquema.
Em seguida, adicione que o seguinte método à sua classe de substituir:
public override QueryStatusResult QueryStatus(IModelElement selectedModelElement) { if (selectedModelElement is IDatabaseColumnSource || selectedModelElement is ISqlSimpleColumn || selectedModelElement is ISqlProcedure || selectedModelElement is ISqlFunction || selectedModelElement is ISqlIndex || selectedModelElement is ISqlConstraint) { return QueryStatusResult.Enabled; } else { return QueryStatusResult.Invisible; } }Este método determina em quais nós Visualização Esquema o comando de refatoração está disponível.
Finalmente, adicione que o seguinte método à sua classe de substituir:
public override string Text { get { return "Make First Letter Uppercase"; } }Este método fornece o nome amigável para o comando de refatoração que aparece no menu de refatoração.
Sobre o arquivo menu, clique em Salvar CasingRefactoringCommand.cs.
Em seguida, você definirá a classe CasingRefactoringOperation.
Para definir a classe CasingRefactoringOperation
Adicionar uma classe chamada CasingRefactoringOperation ao seu projeto.
No editor de código, atualizar usando as instruções para coincidir com o seguinte:
using System; using System.Diagnostics; using System.Globalization; using Microsoft.Data.Schema.SchemaModel; using Microsoft.Data.Schema.Sql.SchemaModel; using Microsoft.VisualStudio.Data.Schema.Package.Project; using Microsoft.VisualStudio.Data.Schema.Package.Refactoring;Altere o namespace para MySamples.Refactoring:
namespace MySamples.RefactoringAtualize a definição de classe para coincidir com o seguinte:
internal class CasingRefactorOperation : RefactoringOperation { }Sua classe deve herdar de RefactoringOperation.
Adicione as seguintes declarações de variáveis membro e de constante para sua classe:
#region Const private const string CasingRefactorOperationName = @"Make First Letter Uppercase"; private const string OperationDescription = @"Make First Letter Uppercase"; private const string OperationTextViewDescription = @"Preview changes:"; private const string PreviewDialogTitle = @"Preview Changes - {0}"; private const string ConfirmButtonText = @"&Apply"; private const string CasingUndoDescription = @"Make first letter uppercase - {0}"; #endregion private string _operationName; private PreviewWindowInfo _previewWindowInfo; private ISqlModelElement _modelElement;As constantes particulares fornecem informações sobre esta operação que será exibida na janela de visualização.
Adicione o construtor de classe:
public CasingRefactorOperation(IDatabaseProjectNode currentProject, IModelElement selectedModelElement) : base(currentProject) { _operationName = CasingRefactorOperationName; if (selectedModelElement as ISqlModelElement != null) { _modelElement = selectedModelElement as ISqlModelElement; } }O construtor inicializa o nome da operação e o elemento de modelo, se eles forem especificados.
Substituir o PreviewWindowInfo a propriedade para obter os valores que serão exibidas na janela de visualização quando o usuário aplica o tipo de refatoração:
/// <summary> /// Preview dialog information for this RenameRefactorOperation. /// </summary> protected override PreviewWindowInfo PreviewWindowInfo { get { if (_previewWindowInfo == null) { _previewWindowInfo = new PreviewWindowInfo(); _previewWindowInfo.ConfirmButtonText = ConfirmButtonText; _previewWindowInfo.Description = OperationDescription; _previewWindowInfo.HelpContext = String.Empty; _previewWindowInfo.TextViewDescription = OperationTextViewDescription; _previewWindowInfo.Title = string.Format(CultureInfo.CurrentCulture,PreviewDialogTitle, CasingRefactorOperationName); } return _previewWindowInfo; } }Fornece definições de propriedade adicionais:
protected override string OperationName { get { return _operationName; } } /// <summary> /// Undo Description used in undo stack /// </summary> protected override string UndoDescription { get { return string.Format(CultureInfo.CurrentCulture, CasingUndoDescription, SampleHelper.GetModelElementName(this.ModelElement)); } } /// <summary> /// SchemaIdentifier of currently selected schema object /// </summary> public ISqlModelElement ModelElement { get { return _modelElement; } set { _modelElement = value; } }Finalmente, substituir o OnGetContributorInput método:
/// <summary> /// According to different selected node, create different CasingContributorInput /// </summary> /// <returns></returns> protected override ContributorInput OnGetContributorInput() { ContributorInput input = null; SqlSchemaModel dataSchemaModel = this.CurrentDataSchemaModel as SqlSchemaModel; // You might choose to throw an exception here if // schemaModel is null. Debug.Assert(dataSchemaModel != null, "DataSchemaModel is null."); // create contributor input used in this operation input = new CasingContributorInput(this.ModelElement); return input; }Esse método cria o ContributorInput que é passado para os colaboradores de refatoração para este tipo de refatoração.
Sobre o arquivo menu, clique em Salvar CasingRefactoringOperation.cs.
Em seguida, você definirá a classe CasingContributorInput.
Para definir a classe CasingContributorInput
Adicionar uma classe chamada CasingContributorInput ao seu projeto.
No editor de código, atualizar usando as instruções para coincidir com o seguinte:
using System; using Microsoft.Data.Schema.Sql.SchemaModel; using Microsoft.VisualStudio.Data.Schema.Package.Refactoring;Altere o namespace para MySamples.Refactoring:
namespace MySamples.RefactoringAtualize a definição de classe para coincidir com o seguinte:
internal class CasingContributorInput: ContributorInput { }Sua classe deve herdar de ContributorInput.
Defina uma variável de membro de particular adicionais:
private ISqlModelElement _modelElement;Esse membro é usado para controlar o elemento de modelo no qual você está operando.
Adicione o construtor da classe:
public CasingContributorInput(ISqlModelElement modelElement) { _modelElement = modelElement; }O construtor inicializa o elemento de modelo.
Adicione uma propriedade pública de somente leitura para o elemento de modelo:
/// <summary> /// Selected model element /// </summary> public ISqlModelElement ModelElement { get { return _modelElement; } }O método de substituição é igual a fornece uma comparação que determina se dois objetos de CasingContributorInput são os mesmos:
/// <summary> /// Override Equals /// </summary> /// <param name="obj"></param> /// <returns></returns> public override bool Equals(object obj) { CasingContributorInput other = obj as CasingContributorInput; return _modelElement.Equals(other.ModelElement); }Para este colaborador, as entradas serão consideradas o mesmo se aplicarem ao mesmo elemento de modelo.
Substitua o método GetHashCode:
/// <summary> /// Override GetHashCode /// </summary> /// <returns></returns> public override int GetHashCode() { Int32 hash = _modelElement.GetHashCode(); return hash; }Sobre o arquivo menu, clique em Salvar CasingContributorInput.cs.
Em seguida, você definirá a classe CasingSymbolContributor.
Para definir a classe CasingSymbolContributor
Adicionar uma classe chamada CasingSymbolContributor ao seu projeto.
No editor de código, atualizar usando as instruções para coincidir com o seguinte:
using System; using System.Collections.Generic; using System.Diagnostics; using System.Globalization; using Microsoft.Data.Schema.Extensibility; using Microsoft.Data.Schema.SchemaModel; using Microsoft.Data.Schema.ScriptDom.Sql; using Microsoft.Data.Schema.Sql.SchemaModel; using Microsoft.Data.Schema.Sql; using Microsoft.VisualStudio; using Microsoft.VisualStudio.Data.Schema.Package.Refactoring;Altere o namespace para MySamples.Refactoring:
namespace MySamples.RefactoringAtualize a definição de classe para coincidir com o seguinte:
[DatabaseSchemaProviderCompatibility(typeof(SqlDatabaseSchemaProvider))] internal class CasingSymbolContributor : RefactoringContributor<CasingContributorInput> { }Especifica o atributo para declarar que este colaborador é compatível com qualquer provedores de esquema de banco de dados que são derivados de SqlDatabaseSchemaProvider. Sua classe deve herdar de RefactoringContributor para sua turma de CasingContributorInput.
Defina variáveis de membro privado e de constantes adicionais:
#region Const private const string PreviewGroupFriendlyName = @"Schema Objects"; private const string PreviewDescription = @"Uppercasing the first letter of schema object name and all references to this schema object."; private const string PreviewWarning = @"Changing casing of the schema object name may cause errors and warnings when your project is using case-sensitive collations. "; #endregion private RefactoringPreviewGroup _previewGroup;As constantes fornecem informações que aparecerão na janela de visualização. O membro adicional é usado para controlar o grupo de visualização.
Adicione o construtor da classe:
#region ctor public CasingSymbolContributor() { _previewGroup = new RefactoringPreviewGroup(PreviewGroupFriendlyName); _previewGroup.Description = PreviewDescription; _previewGroup.WarningMessage = PreviewWarning; _previewGroup.EnableChangeGroupUncheck = false; _previewGroup.IncludeInCurrentProject = true; // the default icon will be used if do not register and icon for your file extensions //RefactoringPreviewGroup.RegisterIcon("sql", "SqlFileNode.ico"); //RefactoringPreviewGroup.RegisterIcon(".dbproj", "DatabaseProjectNode.ico"); // For some contributors, you might register a // language service here. //_previewGroup.RegisterLanguageService(".sql", ); base.RegisterGeneratedInputType(typeof(CasingReferenceContributorInput)); } #endregionO construtor inicializa o elemento de modelo, criando um novo grupo de visualização e inicialização de suas propriedades. Você também pode registrar ícones aqui a ser exibido na janela de visualização para extensões de nome de arquivo específico e você pode registrar um serviço de linguagem que é usado para fornecer a coloração de sintaxe para arquivos que têm uma extensão especificada.
Substituir o PreviewGroup propriedade para retornar o grupo que foi criado quando este colaborador foi criado:
#region overrides /// <summary> /// Preview group for schema object files /// </summary> public override RefactoringPreviewGroup PreviewGroup { get { return _previewGroup; } set { _previewGroup = value; } }Substituir o ContributeChanges(Boolean) método para retornar uma lista de propostas de alteração:
/// <summary> /// Contribute to the change proposals /// </summary> /// <param name="input">contributor input</param> /// <returns>List of change proposals with corresponding contributor inputs</returns> protected override Tuple<IList<ChangeProposal>, IList<ContributorInput>> ContributeChanges(CasingContributorInput input) { CasingContributorInput casingInput = input as CasingContributorInput; if (casingInput == null) { throw new ArgumentNullException("input"); } string projectFullName; casingInput.RefactoringOperation.CurrentProjectHierarchy.GetCanonicalName(VSConstants.VSITEMID_ROOT, out projectFullName); Tuple<IList<ChangeProposal>, IList<ContributorInput>> changes = GetChangesFromCurrentSymbolScript( projectFullName, casingInput, casingInput.ModelElement, true); return changes; } #endregionEm seguida, criar outro tipo de ContributorInput:
/// <summary> /// Create a CasingReferenceContributorInput according to passed in CasingContributorInput /// </summary> /// <param name="orginalInput"></param> /// <returns></returns> internal ContributorInput CreateCasingReferenceInput(ContributorInput orginalInput) { CasingContributorInput casingInput = orginalInput as CasingContributorInput; Debug.Assert(casingInput != null, "casingInput is null"); CasingReferenceContributorInput referenceInput = new CasingReferenceContributorInput(casingInput.ModelElement); referenceInput.SchemaObjectsPreviewGroup = this.PreviewGroup; referenceInput.RefactoringOperation = casingInput.RefactoringOperation; return referenceInput; }Esse tipo adicional de ContributorInput é usado para tratar todas as referências ao elemento cujo símbolo foi atualizado. Esse método será chamado pelo próximo método.
Adicione um método para criar uma lista de alterações para o script que contém a definição do símbolo que está sendo refatorado:
public Tuple<IList<ChangeProposal>, IList<ContributorInput>> GetChangesFromCurrentSymbolScript( string projectFullName, ContributorInput input, ISqlModelElement modelElement, Boolean defaultChecked) { SampleHelper.CheckNullArgument(input, "input"); SampleHelper.CheckNullArgument(modelElement, "modelElement"); SqlSchemaModel dataSchemaModel = input.RefactoringOperation.CurrentDataSchemaModel as SqlSchemaModel; Debug.Assert(dataSchemaModel != null, "DataSchemaModel is null."); List<ChangeProposal> allChanges = new List<ChangeProposal>(); // list to hold all side effect contributor inputs List<ContributorInput> inputs = new List<ContributorInput>(); string fileFullPath = null; ISourceInformation elementSource = modelElement.PrimarySource; if (elementSource != null) { fileFullPath = elementSource.SourceName; } if (!string.IsNullOrEmpty(fileFullPath)) { List<RawChangeInfo> changes = AnalyzeScript(dataSchemaModel, modelElement); // Convert the offsets returned from parser to the line based offsets allChanges.AddRange(SampleHelper.ConvertOffsets(projectFullName, fileFullPath, changes, defaultChecked)); // Create a CasingReferenceContributorInput, anything reference this schema object // need to contribute changes for this input. inputs.Add(CreateCasingReferenceInput(input)); } return new Tuple<IList<ChangeProposal>, IList<ContributorInput>>(allChanges, inputs); }Este método chama o método AnalyzeScript para processar os elementos de script.
Adicione o método AnalyzeScript:
public static List<RawChangeInfo> AnalyzeScript(SqlSchemaModel dataSchemaModel, ISqlModelElement modelElement) { SampleHelper.CheckNullArgument(dataSchemaModel, "dataSchemaModel"); // get element source ISourceInformation elementSource = modelElement.PrimarySource; if (elementSource == null) { throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, "Cannot retrieve element source of {0}", SampleHelper.GetModelElementName(modelElement))); } // get sql fragment TSqlFragment fragment = elementSource.ScriptDom as TSqlFragment; if (fragment == null) { throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, "Cannot retrieve script fragment of {0}", SampleHelper.GetModelElementName(modelElement))); } List<RawChangeInfo> changes = new List<RawChangeInfo>(); Identifier id = null; if (fragment is CreateTableStatement) // Table { id = ((CreateTableStatement)fragment).SchemaObjectName.BaseIdentifier; } else if (fragment is CreateViewStatement) // View { id = ((CreateViewStatement)fragment).SchemaObjectName.BaseIdentifier; } else if (fragment is ColumnDefinition) // Column { id = ((ColumnDefinition)fragment).ColumnIdentifier; } else if (fragment is CreateProcedureStatement) // Proc { ProcedureReference procRef = ((CreateProcedureStatement)fragment).ProcedureReference; if (procRef != null) { id = procRef.Name.BaseIdentifier; } } else if (fragment is CreateFunctionStatement) // Function { id = ((CreateFunctionStatement)fragment).Name.BaseIdentifier; } else if (fragment is CreateIndexStatement) // Index { id = ((CreateIndexStatement)fragment).Name; } else if (fragment is Constraint) // inline constraint { id = ((Constraint)fragment).ConstraintIdentifier; } else if (fragment is AlterTableAddTableElementStatement) // default/check constraints { IList<Constraint> constraints = ((AlterTableAddTableElementStatement)fragment).TableConstraints; Debug.Assert(constraints.Count == 1, string.Format("Only one constraint expected, actual {0}", constraints.Count)); id = constraints[0].ConstraintIdentifier; } else // anything NYI { Debug.WriteLine(string.Format("Uppercasing symbol of type {0} is not implemented yet.", fragment.GetType().Name)); } string oldName = SampleHelper.GetModelElementSimpleName(modelElement); if (id != null && oldName.Length > 0) { string newName = oldName.Substring(0, 1).ToUpper() + oldName.Substring(1); // upper casing the first letter if (string.CompareOrdinal(oldName, newName) != 0) { RawChangeInfo change = SampleHelper.AddOffsestFromIdentifier(id, oldName, newName, true); if (change != null) { changes.Add(change); } } } return changes; }Esse método adquire o script de origem para o elemento que está sendo refatorado. O método, em seguida, recupera o fragmento SQL para esse script de origem. O método cria uma nova lista de alteração, determina o identificador do elemento (com base no tipo de fragmento) e adiciona a nova alteração para a lista de alterações.
Sobre o arquivo menu, clique em Salvar CasingSymbolContributor.cs.
Em seguida, você definirá a classe CasingReferenceContributorInput.
Para definir a classe CasingReferenceContributorInput
Adicionar uma classe chamada CasingReferenceContributorInput ao seu projeto.
No editor de código, atualizar usando as instruções para coincidir com o seguinte:
using System; using Microsoft.Data.Schema.Sql.SchemaModel; using Microsoft.VisualStudio.Data.Schema.Package.Refactoring;Altere o namespace para MySamples.Refactoring:
namespace MySamples.RefactoringAtualize a definição de classe para coincidir com o seguinte:
internal class CasingReferenceContributorInput: ContributorInput { }Sua classe deve herdar de ContributorInput.
Defina variáveis de membros de particulares adicionais:
private ISqlModelElement _modelElement; private RefactoringPreviewGroup _previewGroup;Esses membros são usados para controlar o elemento de modelo no qual você está operando e o grupo de visualizar as alterações que pertencem.
Adicione o construtor da classe:
public CasingReferenceContributorInput(ISqlModelElement modelElement) { _modelElement = modelElement; }O construtor inicializa o elemento de modelo.
Adicione uma propriedade pública de somente leitura para o elemento de modelo:
/// <summary> /// Selected model element /// </summary> public ISqlModelElement ModelElement { get { return _modelElement; } }Defina um grupo de visualização adicionais para as alterações sejam identificadas por este Colaborador:
/// <summary> /// Preview group that change proposals belong to /// </summary> public RefactoringPreviewGroup SchemaObjectsPreviewGroup { get { return _previewGroup; } set { _previewGroup = value; } }O método de substituição é igual a fornece uma comparação que determina se dois objetos de CasingReferenceContributorInput são os mesmos:
/// <summary> /// Override Equals /// </summary> /// <param name="obj"></param> /// <returns></returns> public override bool Equals(object obj) { CasingContributorInput other = obj as CasingContributorInput; return _modelElement.Equals(other.ModelElement); }Para este colaborador, as entradas serão consideradas o mesmo se aplicarem ao mesmo elemento de modelo.
Substitua o método GetHashCode:
/// <summary> /// Override GetHashCode /// </summary> /// <returns></returns> public override int GetHashCode() { Int32 hash = _modelElement.GetHashCode(); return hash; }Sobre o arquivo menu, clique em Salvar CasingReferenceContributorInput.cs.
Em seguida, você definirá a classe CasingReferenceContributor.
Para definir a classe CasingReferenceContributor
Adicionar uma classe chamada CasingReferenceContributor ao seu projeto.
No editor de código, atualizar usando as instruções para coincidir com o seguinte:
using System; using System.Collections.Generic; using System.Diagnostics; using Microsoft.Data.Schema.Extensibility; using Microsoft.Data.Schema.SchemaModel; using Microsoft.Data.Schema.ScriptDom.Sql; using Microsoft.Data.Schema.Sql.SchemaModel; using Microsoft.Data.Schema.Sql; using Microsoft.VisualStudio; using Microsoft.VisualStudio.Data.Schema.Package.Refactoring;Altere o namespace para MySamples.Refactoring:
namespace MySamples.RefactoringAtualize a definição de classe para coincidir com o seguinte:
[DatabaseSchemaProviderCompatibility(typeof(SqlDatabaseSchemaProvider))] internal class CasingReferenceContributor : RefactoringContributor<CasingReferenceContributorInput> { }Especifica o atributo para declarar que este colaborador é compatível com qualquer provedores de esquema de banco de dados que são derivados de SqlDatabaseSchemaProvider. Sua classe deve herdar de RefactoringContributor para sua turma de CasingReferenceContributorInput.
Defina variáveis de membro privado e de constantes adicionais:
#region Const private const string PreviewGroupFriendlyName = @"Schema Objects"; private const string PreviewDescription = @"Uppercasing the name of this schema object and all references to this schema object."; private const string PreviewWarning = @"Changing casing of the schema object name may cause errors and warnings when your project is using case-sensitive collations. "; #endregion private RefactoringPreviewGroup _previewGroup;As constantes fornecem informações que aparecerão na janela de visualização. O membro adicional é usado para controlar o grupo de visualização.
Adicione o construtor da classe:
public CasingReferenceContributor() { }Substituir o PreviewGroup propriedade para retornar o grupo que foi criado quando este colaborador foi criado:
#region overrides /// <summary> /// Preview group for text files /// </summary> public override RefactoringPreviewGroup PreviewGroup { get { return _previewGroup; } set { _previewGroup = value; } } #endregionSubstituir o ContributeChanges(Boolean) método para retornar uma lista de propostas de alteração:
/// <summary> /// Contribute to the change proposals /// </summary> /// <param name="input">contributor input</param> /// <returns>List of change proposals with corresponding contributor inputs</returns> protected override Tuple<IList<ChangeProposal>, IList<ContributorInput>> ContributeChanges(CasingReferenceContributorInput input) { // cast input into reference input CasingReferenceContributorInput casingReferenceInput = input as CasingReferenceContributorInput; if (casingReferenceInput == null) { throw new ArgumentNullException("input"); } // Make sure CasingReferenceContributor and CasingSymbolContributor for a same refactoring operation // share the same preview group instance. if (casingReferenceInput.SchemaObjectsPreviewGroup != null) { _previewGroup = casingReferenceInput.SchemaObjectsPreviewGroup; } string projectFullName; casingReferenceInput.RefactoringOperation.CurrentProjectHierarchy.GetCanonicalName(VSConstants.VSITEMID_ROOT, out projectFullName); Tuple<IList<ChangeProposal>, IList<ContributorInput>> changes = GetChangesFromReferencedSymbolScripts( projectFullName, casingReferenceInput, casingReferenceInput.ModelElement, true ); return changes; }O ContributeChangesMethod chama o método de GetChangesFromReferencedSymbolScripts.
Implemente o método GetChangesFromReferencedSymbolScripts para retornar uma lista de propostas de alteração em scripts que contêm referências para o símbolo que está sendo atualizado:
public static Tuple<IList<ChangeProposal>, IList<ContributorInput>> GetChangesFromReferencedSymbolScripts( string projectFullName, ContributorInput input, ISqlModelElement modelElement, bool defaultChecked // if the preview group is by default checked in the preview window ) { SampleHelper.CheckNullArgument(input, "input"); SqlSchemaModel dataSchemaModel = input.RefactoringOperation.CurrentDataSchemaModel as SqlSchemaModel; Debug.Assert(dataSchemaModel != null, "The DataSchemaModel is null for current Database project."); // Get all the changes for these schema objects that referencing the changed IModelElement. List<ChangeProposal> allChanges = new List<ChangeProposal>(); Dictionary<string, List<RawChangeInfo>> fileChanges = new Dictionary<string, List<RawChangeInfo>>(); List<RelationshipEntrySource> relationshipEntrySources = GetDependentEntries(dataSchemaModel, modelElement, true, true); foreach (var entry in relationshipEntrySources) { string fileFullPath = entry.Item1.SourceName; if (!string.IsNullOrEmpty(fileFullPath)) { IList<RawChangeInfo> result = AnalyzeRelationshipEntrySource(dataSchemaModel, modelElement, entry.Item2, entry.Item1); if (result != null) { List<RawChangeInfo> fileChange = null; if (!fileChanges.TryGetValue(fileFullPath, out fileChange)) { fileChange = new List<RawChangeInfo>(); fileChanges.Add(fileFullPath, fileChange); } fileChange.AddRange(result); } } } // Convert the offsets returned from ScriptDom to the line based offsets foreach (string fileFullPath in fileChanges.Keys) { allChanges.AddRange(SampleHelper.ConvertOffsets(projectFullName, fileFullPath, fileChanges[fileFullPath], defaultChecked)); } // Change propagation is not considered in this sample. // Thus the second value in the returned Tuple is set to null return new Tuple<IList<ChangeProposal>, IList<ContributorInput>>(allChanges, null); }Este método recupera uma lista de todas as dependências do símbolo atualizado. Ele chama o método AnalyzeRelationshipEntrySource para cada referência identificar quaisquer alterações adicionais necessárias.
Adicione o método AnalyzeRelationshipEntrySource:
public static IList<RawChangeInfo> AnalyzeRelationshipEntrySource( SqlSchemaModel dataSchemaModel, ISqlModelElement modelElement, ISourceInformation relationshipEntrySource) { SampleHelper.CheckNullArgument(dataSchemaModel, "dataSchemaModel"); List<Identifier> identifiers = new List<Identifier>(); TSqlFragment fragment = relationshipEntrySource.ScriptDom as TSqlFragment; // handle expressions if (fragment is SelectColumn) { Expression exp = ((SelectColumn)fragment).Expression;// as Expression; fragment = exp as TSqlFragment; } else if (fragment is ExpressionWithSortOrder) { Expression exp = ((ExpressionWithSortOrder)fragment).Expression; // as Expression; fragment = exp as TSqlFragment; } else if (fragment is ExpressionGroupingSpecification) { Expression exp = ((ExpressionGroupingSpecification)fragment).Expression; // as Expression; fragment = exp as TSqlFragment; } // handle different fragment if (fragment is Identifier) { identifiers.Add((Identifier)fragment); ; } else if (fragment is Column) { identifiers.AddRange(((Column)fragment).Identifiers); } else if (fragment is ColumnWithSortOrder) { identifiers.Add(((ColumnWithSortOrder)fragment).ColumnIdentifier); } else if (fragment is SchemaObjectName) { identifiers.Add(((SchemaObjectName)fragment).BaseIdentifier); } else if (fragment is SchemaObjectTableSource) { identifiers.Add(((SchemaObjectTableSource)fragment).SchemaObject.BaseIdentifier); } else if (fragment is SchemaObjectDataModificationTarget) { identifiers.Add(((SchemaObjectDataModificationTarget)fragment).SchemaObject.BaseIdentifier); } else if (fragment is FunctionCall) { FunctionCall funcCall = (FunctionCall)fragment; IdentifiersCallTarget identsCallTarget = funcCall.CallTarget as IdentifiersCallTarget; if (identsCallTarget != null) { identifiers.AddRange(identsCallTarget.Identifiers); } identifiers.Add(funcCall.FunctionName); } else if (fragment is ProcedureReference) { SchemaObjectName procRefName = ((ProcedureReference)fragment).Name; if (procRefName != null) { identifiers.Add(procRefName.BaseIdentifier); } } else if (fragment is TriggerObject) { SchemaObjectName triggerName = ((TriggerObject)fragment).Name; if (triggerName != null) { identifiers.Add(triggerName.BaseIdentifier); } } else if (fragment is FullTextIndexColumn) { identifiers.Add(((FullTextIndexColumn)fragment).Name); } else if (fragment is SecurityTargetObject) { identifiers.AddRange(((SecurityTargetObject)fragment).ObjectName.Identifiers); } else // other types of fragments are not handled in this sample { Debug.WriteLine(string.Format("Uppercasing referencing object of type {0} is not implemented yet.", fragment.GetType().Name)); } List<RawChangeInfo> changes = new List<RawChangeInfo>(); string oldName = SampleHelper.GetModelElementSimpleName(modelElement); if (identifiers.Count > 0 && oldName.Length > 0) { string newName = oldName.Substring(0, 1).ToUpper() + oldName.Substring(1); // upper casing the first letter if (string.CompareOrdinal(oldName, newName) != 0) { // list of changes for this relationship entry RawChangeInfo change = null; foreach (Identifier idf in identifiers) { change = SampleHelper.AddOffsestFromIdentifier(idf, oldName, newName, true); if (change != null) { changes.Add(change); } } } } return changes; }Este método recupera uma lista de alterações que devem ser feitas para fragmentos de script que dependem do símbolo atualizado.
Adicione o método GetDependentEntries:
/// <summary> /// Get all relating relationship entries for the model element and its composing and hierarchical children /// </summary> internal static List<System.Tuple<ISourceInformation, IModelRelationshipEntry>> GetDependentEntries( SqlSchemaModel dataSchemaModel, ISqlModelElement modelElement, bool ignoreComposedRelationship, bool includeChildDependencies) { SampleHelper.CheckNullArgument(dataSchemaModel, "dataSchemaModel"); SampleHelper.CheckNullArgument(modelElement, "modelElement"); var dependencies = new List<System.Tuple<ISourceInformation, IModelRelationshipEntry>>(); List<IModelRelationshipEntry> relatingRelationships = new List<IModelRelationshipEntry>(); GetDependentEntries(modelElement, dataSchemaModel, new Dictionary<IModelElement, Object>(), relatingRelationships, includeChildDependencies); foreach (IModelRelationshipEntry entry in relatingRelationships) { ModelRelationshipType relationshipType = entry.RelationshipClass.ModelRelationshipType; if (!ignoreComposedRelationship || (relationshipType != ModelRelationshipType.Composing)) { ISqlModelElement relatingElement = entry.FromElement as ISqlModelElement; Debug.Assert(relatingElement != null, "Relating element got from ModelStore is null."); foreach (var si in relatingElement.GetRelationshipEntrySources(entry)) { dependencies.Add(new System.Tuple<ISourceInformation, IModelRelationshipEntry>(si, entry)); } } } return dependencies; } private static void GetDependentEntries( IModelElement modelElement, DataSchemaModel dataSchemaModel, Dictionary<IModelElement, Object> visitElement, List<IModelRelationshipEntry> relationshipEntries, Boolean includeChildDependencies) { if (modelElement != null && !visitElement.ContainsKey(modelElement)) { visitElement[modelElement] = null; IList<IModelRelationshipEntry> relatingRelationships = modelElement.GetReferencingRelationshipEntries(); relationshipEntries.AddRange(relatingRelationships); if (includeChildDependencies) { // First loop through all composed children of this element, and get their relationship entries as well foreach (IModelRelationshipEntry entry in modelElement.GetReferencedRelationshipEntries()) { if (entry.RelationshipClass.ModelRelationshipType == ModelRelationshipType.Composing) { GetDependentEntries(entry.Element, dataSchemaModel, visitElement, relationshipEntries, includeChildDependencies); } } // Then loop through all hierarchical children of this element, add their dependents to the list. foreach (IModelRelationshipEntry entry in relatingRelationships) { if (entry.RelationshipClass.ModelRelationshipType == ModelRelationshipType.Hierarchical) { GetDependentEntries(entry.FromElement, dataSchemaModel, visitElement, relationshipEntries, includeChildDependencies); } } } } }Sobre o arquivo menu, clique em Salvar CasingReferenceContributor.cs.
Em seguida, você irá configurar e compilar o assembly.
Para assinar e compilar o assembly
Sobre o projeto menu, clique em Propriedades de CasingRefactoringType.
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á exibido como uma disponível condição de teste.
Instalar e registrar o Assembly.
Para instalar o conjunto de CasingRefactoringType
Crie uma pasta chamada MyExtensions na pasta % do programa Files%\Microsoft Visual Studio 10.0\VSTSDB\Extensions.
Copie o assembly assinado (CasingRefactoringType.dll) para a pasta de 10.0\VSTSDB\Extensions\MyExtensions de Visual Studio do programa Files%\Microsoft %.
.gif "Observação")
ObservaçãoRecomendamos 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 para os outros arquivos fornecidos com o Visual Studio.
Em seguida, você deve registrar seu assembly, um tipo de a extensão de recurso, de modo que ele aparecerá na Visual Studio.
Para registrar o assembly de CasingRefactoringType
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çãoPor 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").FullNamePressione Enter.
Copie a linha resultante para a área de transferência. A linha deve ser semelhante ao seguinte:
"GeneratorAssembly, Version=1.0.0.0, Culture=neutral, PublicKeyToken=nnnnnnnnnnnnnnnn"Abra um editor de texto sem formatação, como, por exemplo, o bloco de notas.
.gif "Observação importante")
ImportanteEm Windows Vista e 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="MySamples.Refactoring.CasingRefactorCommand" assembly=" CasingRefactoringType, Version=1.0.0.0, Culture=neutral, PublicKeyToken=<enter key here>" enabled="true" /> <extension type="MySamples.Refactoring.CasingSymbolContributor" assembly="CasingRefactoringType, Version=1.0.0.0, Culture=neutral, PublicKeyToken=<enter key here>" enabled="true" /> <extension type="MySamples.Refactoring.CasingReferenceContributor" assembly="CasingRefactoringType, 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 RefactoringCommand e todas as classes relacionadas que são derivadas de RefactoringContributor.
Salve o arquivo como CasingRefactoringType.extensions.xml na pasta % do programa Files%\Microsoft Visual Studio 10.0\VSTSDB\Extensions\MyExtensions.
Close Visual Studio.
Em seguida, você irá criar um projeto de banco de dados muito simples para testar o novo tipo de refatoração.
Teste o novo tipo de refatoração
Para criar um projeto de banco de dados
Sobre o arquivo , aponte para nova e clique em projeto.
Em Modelos instalados expandir o banco de dados nó e clique o SQL Server nó.
Na lista de modelos, clique em Projeto de banco de dados de 2008 do SQL Server.
Clique em OK para aceitar o nome de projeto padrão e criar o projeto.
O projeto de banco de dados vazio é criado.
Para adicionar uma tabela com uma chave primária
Sobre o Exibir menu, clique em Visualização do esquema de banco de dados.
Em Visualização Esquema, expandir o esquemas nó, expanda o dbo nó, com o botão direito do tabelas nó, aponte para Adicionare clique em tabela.
No Add New Item na caixa nome, tipo funcionário.
ObservaçãoIntencionalmente, você está usando uma letra minúscula para começar o nome da tabela.
Clique em OK.
Expanda o tabelas nó, com o botão direito do funcionário nó, aponte para Adde clique em Chave primária.
No Add New Item na caixa nome, tipo PK_Employee_column_1.
Clique em OK.
Em seguida, você usará o novo tipo de refatoração para alterar a tabela de nome e todas as referências a ele.
Para usar o novo tipo de refatoração para atualizar o nome da tabela
Em Visualização Esquema, o botão direito do mouse no nó da tabela de funcionários, aponte para Refactore clique em Fazer primeira letra maiúscula.
Você definiu um novo tipo de refatoração nesta explicação.
No Visualizar alterações caixa de diálogo, examine as alterações e, em seguida, clique em Aplicar.
O nome da tabela é atualizado para ser funcionário. A referência à tabela na chave primária também é atualizada.
Próximas etapas
Você pode criar seus próprios tipos adicionais de refatoração de banco de dados. Você também pode adicionar mais colaboradores para habilitar um tipo existente de refatoração para operar em outros tipos de arquivos ou objetos de banco de dados.
Consulte também
Tarefas
Conceitos
Criar banco de dados personalizado refatoração tipos ou destinos