Rifattorizza codice 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.
Ottieni un elenco completo dei comandi di rifattorizzazione nel menu contestuale dell'editor di testo.
Passando il mouse su un simbolo, Visual Assist mostra un'icona quando il refactoring è disponibile. Fare clic sull'icona per aprire un menu contestuale.
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.
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.
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.
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.
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.
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.
In C/C++, il refactoring crea un metodo inline in un file di intestazione o estrae l'implementazione direttamente nel sorgente.
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.
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.
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.
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.
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.
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.
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.
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.
Dopo aver invocato il refactoring, l'oggetto viene creato e inizializzato in una dichiarazione più semplice, ma equivalente.
