2016-07-12 81 views
5

Durante il debug in Visual Studio, come posso inserire espressioni multilinea in Watch Window, in modo che ogni riga non venga suddivisa in un'espressione di orologio INVALID separata. Questo è davvero frustrante perché ho molte espressioni che si estendono su più linee che devo guardare. Nota che sia Pin to Source che Immediate Window non funzionano per tracciare più valori da molte posizioni nel codice sorgente.Visual Studio: inserimento di espressioni multilinea nella finestra di controllo durante il debug

ad es.

PyFunc1(Py.kw("var1", var1), 
     Py.kw("var2", var2)) 

viene rotto a:

PyFunc1(Py.kw("var1", var1), 

e

Py.kw("var2", var2)) 
+1

C'è un motivo per cui non è possibile rimuovere le nuove righe prima di incollare le espressioni nella finestra di controllo? – Cameron

+0

perché VS deve farlo per me :) – denfromufa

+1

Prova invece a incollare nella finestra Immediata. Tende a funzionare meglio per le espressioni più lunghe. –

risposta

6

Repro

non penso che questo è "By-Design", il suo solo non disponibile "out-of la scatola".

Sono d'accordo, sarebbe meglio il comportamento per il multi-riga chiama da aggiungere alla finestra di controllo con terminatori di linea invece di nuove linee:

enter image description here


Research

Ho trovato questa domanda simile con alcuni "soluzioni alternative" tra cui scegliere: Multi-Line Watch Window in Visual Studio 2010?

Ho trovato questo commento nello MSDN Forums by a MSFT Engineer:

Ho paura che non sia supportato, spesso li modificiamo uno per uno. Forse si potrebbe presentare tale richiesta di funzionalità: http://visualstudio.uservoice.com/forums/121579-visual-studio


rotolare il proprio Visual Studio Add-in

Così ho avuto un andare a me stesso, questo è affatto codice produzione ma mostra come farlo:

(clicca sull'immagine per ingrandire)

enter image description here

namespace AddinMultiLineWatch 
{ 
public class Connect : IDTExtensibility2, IDTCommandTarget 
{ 
    //ADD THESE MEMBER VARIABLES 
    //private DebuggerEvents _debuggerEvents = null; 
    //private _dispDebuggerEvents_OnEnterBreakModeEventHandler DebuggerEvents_OnEnterBreakMode; 
    private Window _watchWindow = null; 
    private CommandEvents _objCommandEvents; 
    private bool _isRecursive = false; 
    public Connect() 
    { 
    } 

    public void OnConnection(object application, ext_ConnectMode connectMode, object addInInst, ref Array custom) 
    { 
     _applicationObject = (DTE2)application; 
     _addInInstance = (AddIn)addInInst; 

     //SET THE MEMBER VARIABLES 
     //_debuggerEvents = _applicationObject.Events.DebuggerEvents; 
     //_debuggerEvents.OnEnterBreakMode += new _dispDebuggerEvents_OnEnterBreakModeEventHandler(BreakHandler); 
     //var watchWindow = _applicationObject.Windows.Item(EnvDTE.Constants.vsWindowKindWatch); 
     _objCommandEvents = _applicationObject.Events.CommandEvents; 
     _objCommandEvents.BeforeExecute += new _dispCommandEvents_BeforeExecuteEventHandler(BeforeExecute); 

     if(connectMode == ext_ConnectMode.ext_cm_UISetup) 
     { 
      object []contextGUIDS = new object[] { }; 
      Commands2 commands = (Commands2)_applicationObject.Commands; 
      string toolsMenuName = "Tools"; 

      Microsoft.VisualStudio.CommandBars.CommandBar menuBarCommandBar = ((Microsoft.VisualStudio.CommandBars.CommandBars)_applicationObject.CommandBars)["MenuBar"]; 
ar: 
      CommandBarControl toolsControl = menuBarCommandBar.Controls[toolsMenuName]; 
      CommandBarPopup toolsPopup = (CommandBarPopup)toolsControl; 

      try 
      { 
       Command command = commands.AddNamedCommand2(_addInInstance, "AddinMultiLineWatch", "AddinMultiLineWatch", "Executes the command for AddinMultiLineWatch", true, 59, ref contextGUIDS, (int)vsCommandStatus.vsCommandStatusSupported+(int)vsCommandStatus.vsCommandStatusEnabled, (int)vsCommandStyle.vsCommandStylePictAndText, vsCommandControlType.vsCommandControlTypeButton); 

       if((command != null) && (toolsPopup != null)) 
       { 
        command.AddControl(toolsPopup.CommandBar, 1); 
       } 
      } 
      catch(System.ArgumentException) 
      { 
      } 
     } 
    } 

    //ADD THIS METHOD TO INTERCEPT THE DEBUG.ADDWATCH COMMAND 
    public void BeforeExecute(string Guid, int ID, object CustomIn, object CustomOut, ref bool CancelDefault) 
    { 
     EnvDTE.Command objCommand = default(EnvDTE.Command); 
     try 
     { 
      objCommand = _applicationObject.Commands.Item(Guid, ID); 
     } 
     catch (Exception ex) 
     { 
     } 

     if ((objCommand != null)) 
     { 
      if (objCommand.Name == "Debug.AddWatch") 
      { 
       //if (_isRecursive) return; 
       //_isRecursive = true; 
       TextSelection selection = (TextSelection)_applicationObject.ActiveDocument.Selection; 
       //TODO make selection goto next semi-colon/Line Terminator... 
       var selText = selection.Text; 

       if (string.IsNullOrEmpty(selText)) return; 
       //Only intercept multi-line Add Watch commands      
       if (selText.Contains(Environment.NewLine)) 
       { 
        //THE BLACK MAGIC: make it fit in one line! lol 
        selText = selText.Replace(Environment.NewLine, string.Empty);    
        //THIS CALL IS RECURSIVE, I'LL LEAVE IT TO THE READER AS AN EXERCISE TO SOLVE.. 
       _applicationObject.ExecuteCommand("Debug.AddWatch", selText); 
       } 
      } 
     } 
    } 
  1. Creare un nuovo progetto> Altri Tipi progetto> estensibilità> Visual Studio Add-In> nome è AddinMultiLineWatch

  2. Passare attraverso la procedura guidata

  3. aggiungere il codice qui sopra per la classe Connect.cs - vedi i miei commenti // MAIUSCOLO con quali elementi aggiungere.

  4. mettere un punto di interruzione sulla linea TextSelection selection = (TextSelection)_applicationObject.ActiveDocument.Selection;

  5. Premere F5 e una nuova istanza di VS lancerà> scegliere Nuovo progetto> Console App> nome è TestMultilineAddWatch

  6. Nei Program.cs di App Console, specificare una chiamata codice oltre 2 righe e mettere un punto di interruzione su di esso, come mostrato nella schermata, ad esempio:

    Add(1,   //Breakpoint here and select both lines 
         2); 
    } 
    
    static int Add(int i, int j) 
    { 
        return i + j; 
    } 
    
  7. F5 in modo TestMultilineAddWatch luzione e quando le fermate di controllo il codice su punto di rottura> selezionare/evidenziare le due linee Add(1, \r\n 2)> tasto destro> Aggiungi controllo

  8. Cliccando Aggiungi controllo nel menu contestuale di debug VS IDE fa sì che la soluzione VS AddinMultiLineWatch per intercettare la chiama e attiva, fermandosi al punto di interruzione .... dove vedrai la della magia nera di sostituendo il codice multi-linea in una riga singola inviata alla finestra di controllo.

Il comando di Visual Studio EXEC che si fa chiamare rende questo metodo ricorsivo, se si esegue il debug di esso, uscendo fuori dalla ricorsione manualmente vedrete i risultati come per il mio screenshot.

Buon debug!

3

Si potrebbe farlo utilizzando AutoHotkey e una chiave personalizzata vincolante (ad esempio Alt + Shift + V)

+ v significa Alt + Shift + V

La macro di seguito:! Se in devenv.exe , e premi Alt + Maiusc + V, modifica il contenuto degli appunti, rimuovi/r/n e sostituiscile con nulla, quindi premi Ctrl + V per incollare

Ho provato questo tagliando e incollando in un documento di testo in visual studio.

#IfWinActive ahk_exe devenv.exe 
!+v:: 
FixString = %clipboard% 
StringReplace, FixString, FixString,`r`n,,A 
Clipboard := FixString 
Send, ^v 
Problemi correlati