Alternativa alle macro in Visual Studio 2012

Uso estesamente le macro per le proprietà ViewModel nello sviluppo XAML . Li uso ancora di più in WCF per generare proprietà Message e DataContract.

Con mia delusione, i macro che ho creato non saranno utilizzabili in Visual Studio 2012.

Un esempio di ciò di cui sto parlando, per una VM, vorrei inserire qualcosa di simile.

int id; string name; 

Seleziona entrambe le linee, esegui una macro e finisci con

 private int _id; private string _name; public int Id { get {return _id;} set { if(_id != value) { _id = value; RaisePropertyChanged("Id"); } } public string Name { if(_name != value) { _name = value; RaisePropertyChanged("Name"); } } 

Sto cercando idee di altre soluzioni per quanto riguarda la perdita di macro.

    La più semplice alternativa alle macro è la creazione di componenti aggiuntivi . Lo so, lo so, non ne ero entusiasta, ma in realtà è sorprendentemente facile. Ci sono tre semplici parti:

    1. Crea il progetto macro, passando attraverso l’interfaccia utente della procedura guidata.
    2. Scrivi il tuo codice
    3. Copiare i file .addin e .dll della macro nella directory dei componenti aggiuntivi di Visual Studio.

    Prendiamo una semplice macro che ho scritto per mostrare la pagina iniziale dopo aver chiuso una soluzione e trasformarla in un componente aggiuntivo.

    Crea il progetto macro

    • Esegui VS 2012 e crea un nuovo progetto.
    • Passare a Modelli> Altri tipi di progetto> Estensibilità e selezionare il componente aggiuntivo di Visual Studio .
    • Dagli un nome, come ShowStartPage.
    • Clicca OK. Questo fa apparire la procedura guidata del componente aggiuntivo.
    • Passa attraverso la procedura guidata, scegliendo:
      • Linguaggio di programmazione: useremo C #
      • Host dell’applicazione: VS 2012 deve essere selezionato
      • Nome e descrizione per il componente aggiuntivo
      • Nella pagina delle opzioni del componente aggiuntivo, selezionare solo la seconda opzione (“Desidero caricare il componente aggiuntivo all’avvio dell’applicazione host”)
      • Passare per il contenuto della casella Informazioni per ora e fare clic su Fine.

    Ora hai un progetto aggiuntivo. Ecco cosa fai con questo:

    Scrivi il codice

    Apri il file Connect.cs . (Potrebbe essere già aperto. Alcune delle cose “DTE” dovrebbero sembrare familiari).

    Aggiungi questo codice a livello di class:

     SolutionEvents solutionEvents; 

    Aggiungi questo codice al metodo OnConnection , subito dopo _addInInstance = (AddIn)addInInst; linea:

     solutionEvents = _applicationObject.Events.SolutionEvents; solutionEvents.AfterClosing += () => { _applicationObject.ExecuteCommand("View.StartPage"); }; 

    Premi il pulsante “Esegui” per testare il tuo codice. Viene avviata una nuova istanza di Visual Studio 2012 con il componente aggiuntivo caricato. Ora prova il componente aggiuntivo e assicurati che funzioni. (Apri una soluzione, quindi chiudila, la pagina iniziale dovrebbe tornare quando lo fai.)

    Distribuilo

    Una volta che il componente aggiuntivo funziona, per utilizzarlo regolarmente con Visual Studio 2012, è necessario solo distribuire due file:

    • ShowStartPage.AddIn (dalla tua directory principale del progetto)
    • ShowStartPage.dll (dalla directory di costruzione del progetto, ad esempio bin \ Debug o bin \ Release)

    Inserisci questi due file nella tua directory dei componenti aggiuntivi di VS 2012, probabilmente qui:

    C:\Users\[your user name]\Documents\Visual Studio 2012\Addins

    Quindi esci e riavvia Visual Studio e dovresti vedere il tuo componente aggiuntivo funzionare. Dovresti anche vederlo elencato quando vai su Strumenti> Gestione componenti aggiuntivi.

    Mentre questo è un po ‘più fastidioso che aprire l’editor di macro e incollare il tuo codice macro lì, ha il vantaggio di poter usare qualsiasi lingua tu voglia, invece di essere bloccato con l’editor di VB piuttosto squilibrato in versioni precedenti di Visual Studio.

    L’estensione Visual Commander (sviluppata da me) è un’alternativa ai macro in Visual Studio 2012/2013/2015. È anche ansible riutilizzare il codice di macro di Visual Studio esistente in nuovi comandi VB.

    Continuerò a tagliare il testo in Notepad ++ e ad usare i macro lì, quindi incollare indietro. È un peccato che la funzionalità non sia più presente in Visual Studio 2012 …

    C’è un componente aggiuntivo, VSScript , per Visual Studio che sostituisce la funzionalità di macro mancante. Sebbene non utilizzi Visual Basic, ma il linguaggio di scripting Lua , potresti volerlo provare.

    C’è un registratore, una finestra di editor di codici macro con IntelliSense e un semplice debugger. Il componente aggiuntivo supporta anche le versioni precedenti di Visual Studio, quindi se si preferisce il linguaggio Lua piuttosto che Visual Basic, è ansible utilizzare invece le macro originali di Visual Studio.

    Ero molto triste nel vedere anche Macros. Puoi avvicinarti alle sostituzioni usando la ricerca di espressioni regolari e sostituiscila all’interno di Visual Studio 2012. Nel tuo caso:

    Trova:

     (.*) (.*); 

    Sostituirlo con:

     private $1 _$2;\npublic $1 $2\n{\n get {return _$2;}\n set\n {\n if(_$2 = value;\n RaisePropertyChanged("$2");\n }\n}\n 

    Ciò ti porterà tutto eccetto la capitalizzazione dei nomi di proprietà per i quali sarebbe meglio utilizzare il Macros.

    Ma un vantaggio dell’approccio di espressione regolare è quando l’input non è così semplice (es. Istruzioni DDL della tabella di database).

    Ecco alcuni link utili da MSDN:

    Sostituzioni nelle espressioni regolari

    Utilizzo di espressioni regolari in Visual Studio

    Uso Notepad ++ con espressioni regolari come questa:

    Trova:

     public (.\*) (.)(.*) \\{ get; set; \\} 

    Sostituire:

     private \1 \l(\2)\3; \r\n public \1 \2\3 \\{ get \\{ return \l(\2)\3; \\} \r\n set \\{ \l(\2)\3 = value; OnPropertyChanged\(para => this\.\2\3\); \\}\\} 

    Controlla http://devexpress.com/coderush

    La funzione di modelli fa praticamente quello che vuoi.

    Esiste anche una versione “Express” gratuita.

    La mancanza di macro di Visual Studio 2012 mi ha messo in crisi, dato che ne ho alcune che uso letteralmente tutto il tempo per inserire piccoli bit di testo standard con un singolo tasto. Così ho scritto un pacchetto di estensibilità per script molto semplice, VSScripts , che consente la manipolazione della selezione corrente da un programma a riga di comando.

    Questo non pretende di essere un completo riassembly completo per il vecchio sistema macro, e non fornisce macro di tastiera, ma rende ansible ricreare molti tipi di macro di manipolazione del testo.

    Ecco cosa ho fatto per mantenere la mia funzionalità macro …

    1. Scarica e installa l’SDK di Visual Studio 2012 qui (contiene il modello “Pacchetto Visual Studio”)
    2. Nuovo progetto -> Installed.Templates.Visual C # .Extensibility.Visual Studio Package

      Procedura guidata pagina 1 di 7

       language = C# gen new key is fine, or use another if you have one 

      procedura guidata pagina 3 di 7

       check "menu command" 

      Procedura guidata pagina 7 di 7

       uncheck both integration and unit test project options 

      Fare clic su Fine

    3. Nel file .cs:

       using EnvDTE; using EnvDTE80; ... private void MenuItemCallback(object sender, EventArgs e) { MenuCommand cmd = sender as MenuCommand; // This should start to look like familiar macro code... EnvDTE80.DTE2 dte2 = Package.GetGlobalService(typeof(EnvDTE.DTE)) as DTE2; TextSelection selection = (TextSelection)dte2.ActiveDocument.Selection; dte2.UndoContext.Open("macro command replacement"); selection.Text = "inserted from macro replacement"; selection.NewLine(1); dte2.UndoContext.Close(); ... 
    4. Esegui il progetto. Una nuova istanza di Visual Studio inizierà con il pacchetto caricato.
    5. Trova il tuo comando come prima voce nella parte superiore del menu Strumenti. Fare clic per vedere se funziona.
    6. Per l’installazione vera, andare nella directory bin \ debug (/ release) e fare doppio clic sul file .vsix
    7. Dovrebbe essere installato per la prossima volta che si esegue
    8. Vai al menu Strumenti -> Opzioni … -> environment.keyboard e mappa un tasto sul tuo strumento

       Mapping theme : Visual C# 2005 Command : Tool.yourFunctionName (functions defined in the .vsct file) 

    Se vuoi più di un comando, dovrai aggiungere gli id ​​del menu in PkgCmdID.cs, Guids in Guids.cs, i layout in .vsct e una funzione nel * package.cs (e il pulsante (MenuCommand) nel Funzione di inizializzazione) per ciascuno. Tutto può essere fatto nello stesso progetto.

    Ho usato questo progetto per creare diversi nuovi “strumenti” con il mio vecchio codice macro, quindi mappato le mie chiavi su di essi. È molto più lavoro (e mal di testa) in primo piano, ma non ha il tempo di ritardo che hanno le macro.

    C’è probabilmente un modo per farlo senza aver bisogno di aprire i menu degli strumenti. Ho iniziato a guardare questa scorsa notte e finalmente ho funzionato, quindi ho finito per ora (almeno fino a quando Microsoft deciderà di abbandonare anche questo).

    Personalmente mi piace questo: l’ estensione Visual Commander ti consente di automatizzare le attività ripetitive in Visual Studio