Happy People

Rifattorizza facilmente

Riduci la complessità del tuo codice, migliorane la leggibilità e rendilo estensibile senza modificarne il comportamento esterno. Rifattorizzare il codice legacy, il codice ereditato o la prima versione del proprio lavoro.

Accedi ai comandi di rifattorizzazione

I comandi di rifattorizzazione sono disponibili in menu accessibili da tastiera e mouse, il cui contenuto varia a seconda del contesto. Il refactoring è disponibile nelle finestre degli strumenti di Visual Assist e nell'editor di testo su simboli, selezioni e spazi bianchi.

Apri un menu di azioni rapide e di refactoring per il simbolo corrente, con la scorciatoia predefinita Maiusc+Alt+Q.

context aware refactoring menu

Ottieni un elenco completo dei comandi di rifattorizzazione nel menu contestuale dell'editor di testo.

Obtain a complete list of refactoring commands in the context menu

Passando il mouse su un simbolo, Visual Assist mostra un'icona quando il refactoring è disponibile. Fare clic sull'icona per aprire un menu contestuale.

Hover over a symbol and Visual Assist displays an icon when refactoring is available


Modifica della firma

Modificare la firma di un metodo da qualsiasi riferimento, implementazione o dichiarazione.

Aggiorna la firma di un metodo o di una funzione in una semplice finestra di dialogo, e Visual Assist deduce le differenze tra la firma originale e quella nuova. Riordina, rinomina, aggiunge ed elimina parametri con questo potente refactoring che aggiorna anche tutti i riferimenti al metodo. Quando si rinomina un parametro, anche i riferimenti ad esso all'interno del metodo vengono rinominati.

Modifica una o tutte le seguenti parti di una firma:

  • Nome del metodo
  • Tipo di ritorno
  • Visibilità
  • Nomi dei parametri
  • Tipi di parametri
  • Ordine dei parametri
  • Numero di parametri
  • Qualificatori

In modo simile alla rifattorizzazione con rinominazione, si imposta l'ambito della modifica e si visualizza l'anteprima dell'insieme di riferimenti che verranno rifattorizzati.

x


Conversione tra puntatore e istanza

Cambia i puntatori di oggetti in riferimenti a oggetti e viceversa.

Convertire rapidamente il tipo in una dichiarazione, scambiare "." e "->" nei riferimenti e correggere "*" e "&" come opportuno.

Change object reference to object pointer


Incapsula il campo

Creare accessi a un campo membro incapsulando il campo stesso.

Limita le azioni su un campo membro con il refactoring Encapsulate Field. Gli accessi vengono creati e nominati automaticamente e il campo originale non viene toccato, nel caso in cui sia necessario compilare il codice legacy quando si aggiornano i riferimenti. Se si incapsula un nuovo campo, lo si rende immediatamente privato per limitare l'accesso futuro.

Create accessors to a member field by encapsulating the field

In C/C++, i metodi di accesso vengono creati adiacenti a una dichiarazione in un file di intestazione e possono rimanere nel file di intestazione per essere eseguiti in linea.

In C/C++, accessor methods are created adjacent to a declaration in a header file

Se si preferisci che le implementazioni siano in un file sorgente, a seguito di Incapsula campo si può procedere a un'altra rifattorizzazione per spostare le implementazioni in un file sorgente corrispondente.

Move the implementations to a corresponding source file


Estrarre Metodo

Sposta un segmento di codice in un metodo separato e sostituisce il segmento con una chiamata al metodo estratto.

Rendi i metodi lunghi più facili da leggere e condividi blocchi di codice comuni con il refactoring Extract Method. Estrae più righe o un segmento di esse. Il valore di ritorno e i parametri del metodo estratto vengono determinati per te.

Move a segment of code into a separate method, and replace the segment with a call to the extracted method

In C/C++, il refactoring crea un metodo inline in un file di intestazione o estrae l'implementazione direttamente nel sorgente.

In C/C++, the refactoring creates an inline method in a header file


Introduci variabile

Sostituisci un'espressione con una variabile che spieghi lo scopo del codice sostituito.

Introduci variabile definisce una variabile temporanea nell'ambito più interno della selezione, inizializza la variabile temporanea con il codice sostituito e sostituisce una o più occorrenze dell'espressione con la variabile temporanea.

Replace an expression with a variable that explains the purpose of the replaced code.


In C/C++, sposta facilmente l'implementazione di un metodo dal sorgente a un file di intestazione o a una dichiarazione di classe.

Questo refactoring colloca le implementazioni nei file di intestazione per l'esecuzione in linea. Il refactoring sposta anche l'implementazione di un metodo in una dichiarazione di classe, vicino ad altri metodi della stessa classe. Definire il formato delle implementazioni con uno Snippet VA.

Move Implementation to Header File


Sposta l'implementazione nel file sorgente

In C/C++, sposta l'implementazione di un metodo dal file di intestazione al file sorgente.

Questo refactoring viene spesso avviato dopo altri refactoring che collocano le implementazioni in file di intestazione per l'esecuzione in linea, ad esempio Incapsula campo. Il refactoring crea una dichiarazione nell'intestazione e sposta l'implementazione vicino a quella di altri metodi della stessa classe.

Move Implementation to Source File


Sposta le implementazioni dei metodi nel file sorgente

In C/C++, sposta tutte le implementazioni dal file di intestazione al file sorgente in un'unica operazione.

A complemento del comando di refactoring che sposta una singola implementazione, questa versione plurale sposta tutti i metodi da un file di intestazione a una classe. Invoca il comando dal nome di una classe, non da uno dei suoi membri. Viene visualizzata una finestra di dialogo in cui puoi selezionare le implementazioni da spostare.

Move Method Implementations to Source File


Sposta la selezione in un nuovo file

Sposta il codice in un nuovo file di intestazione o in un file sorgente e il nuovo file viene aggiunto automaticamente al progetto attivo.

Il refactoring crea il nuovo file nella stessa directory del documento attivo. Definisci il formato del nuovo file con uno Snippet VA. In C/C++, Visual Assist può sostituire la selezione nel documento attivo con un #include se la selezione viene spostata in un file di intestazione.

Move code to a new header file or source file


Rinomina

Rinomina i simboli in modo rapido e preciso, nel progetto attivo e in tutta la soluzione.

Questo refactoring, spesso utilizzato, rinomina la definizione e la dichiarazione di un simbolo, tutti i riferimenti ad esso e, facoltativamente, le occorrenze nei commenti e nelle stringhe. Viene sempre mostrata un'anteprima di tutti gli obiettivi da rinominare, in modo da essere sicuri che la rinominazione faccia ciò che ci si aspetta. Deseleziona i riferimenti che non si vogliono toccare e annulla l'intera operazione se si commette un errore.

Rinomina è disponibile per:

  • Classi
  • Enum
  • Campi
  • Macro
  • Metodi
  • Parametri dei metodi
  • Variabili

Seleziona Rinomina ("Rename") da uno qualsiasi dei menu di refactoring, specifica un nuovo nome e imposta le opzioni. L'anteprima delle modifiche distingue le occorrenze in sola lettura da quelle scrivibili.

Select Rename from any of the refactoring menus


Rinomina i file

Rinomina il documento attivo senza interrompere la compilazione.

Rinomina il documento attivo e i file corrispondenti in modo semplice, senza interrompere il flusso o interrompere la compilazione. Visual Assist aggiorna automaticamente i file, i progetti e le soluzioni, propagando poi la ridenominazione attraverso i sistemi di controllo sorgente che si integrano con Microsoft Visual Studio.

In C/C++, i file di intestazione e i file sorgente vengono rinominati a coppie e la rinominazione di un file di intestazione aggiorna automaticamente tutte le direttive che includono il file di intestazione. In C#, i file di progettazione e di code-behind vengono rinominati simultaneamente.

Rename your active document without breaking the build


Semplificare la dichiarazione di istanza

Rendi più comprensibili le dichiarazioni degli oggetti.

Elimina l'impostazione estranea di un oggetto a una nuova istanza del suo tipo.

Simplify an instance declaration

Dopo aver invocato il refactoring, l'oggetto viene creato e inizializzato in una dichiarazione più semplice, ma equivalente.

Simplified instance declaration