Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez aussi afficher la version anglaise dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte.
Traduction
Anglais
Nous recommandons d’utiliser Visual Studio 2017

Comment : contrôler l'éditeur de code (Visual C#)

Les compléments Visual Studio sont déconseillés dans Visual Studio 2013. Vous devriez mettre vos compléments à niveau vers des extensions VSPackage. Pour plus d'informations sur les mises à jour, consultez FAQ : conversion de compléments en extensions VSPackage.

L'éditeur de code Visual Studio est un éditeur de texte qui inclut des services de langage tels que Visual Basic, Visual C++ et Visual C#. Le texte est écrit dans une mémoire tampon qui s'affiche dans un document texte. À l'aide des objets du modèle Automation Editor de Visual Studio, vous pouvez manipuler le texte en arrière-plan dans la mémoire tampon du texte ou dans la vue.

Les quatre principaux objets utilisés pour contrôler du texte dans l'éditeur de code sont les suivants :

Nom de l'objet

Description

TextSelection

Utilisé pour manipuler du texte dans une vue. L'objet TextSelection représente le point d'insertion (ou signe insertion) ou le texte sélectionné dans le document visible.

TextPoint

Position fixe dans la mémoire tampon du texte.

EditPoint2

Semblable à l'objet TextPoint, mais peut être déplacé et peut modifier du texte dans la mémoire tampon.

VirtualPoint

Semblable à l'objet TextPoint, si ce n'est qu'il contient une fonctionnalité supplémentaire permettant de localiser des positions de texte dans l'espace virtuel.

Les deux principaux objets que vous utilisez pour manipuler l'éditeur de code sont les objets TextSelection et EditPoint2. Les principales différences qui existent entre eux sont les suivantes :

  • TextSelection représente la sélection de texte visible. Lorsque sa position change, la sélection dans la vue change également. Un objet EditPoint2 n'est lié à aucun composant de l'interface utilisateur. Par conséquent, la modification de sa position n'a aucun effet dans la vue.

  • Étant donné que l'objet TextSelection représente la sélection visible, il n'existe qu'un seul objet TextSelection par document. S'il est tout à fait possible d'avoir plusieurs objets TextSelection dans un document, ils font tous référence à la même sélection visible et ont tous la même position. Vous pouvez avoir autant d'objets EditPoint2 que vous le souhaitez, et ils peuvent tous avoir des positions différentes.

  • Les méthodes de l'objet TextSelection sont conçues pour avoir une correspondance un à un avec les actions de l'utilisateur, contrairement aux méthodes de EditPoint2. Par conséquent, certaines méthodes de l'objet EditPoint2 effectuent des opérations qu'aucune méthode TextSelection ne peut effectuer seule, tandis que d'autres méthodes EditPoint2 ont un rôle plus complet que les méthodes de l'objet TextSelection. C'est également pourquoi l'objet TextSelection est plus riche en propriétés et méthodes que l'objet EditPoint2.

À l'aide de ces objets, vous pouvez :

  • sélectionner, ajouter, supprimer et déplacer du texte dans la mémoire tampon ou dans la vue ;

  • déplacer le point d'insertion dans la mémoire tampon ou dans la vue ;

  • mettre du texte en retrait dans la mémoire tampon ou dans la vue ;

  • insérer, supprimer et atteindre des signets ;

  • ajouter ou supprimer du texte, y compris un espace blanc ;

  • rechercher ou remplacer du texte correspondant à un modèle spécifié ;

  • créer une section en mode Plan dans le code et le texte ;

  • demander des informations sur le texte, telles que la position du texte, le début et la fin du document, les plages de texte sélectionnées, etc.

Les exemples de compléments suivants illustrent la façon de référencer les différents membres du modèle Automation Editor et de les utiliser. Pour plus d'informations sur l'exécution de l'exemple, consultez Comment : compiler et exécuter les exemples de code du modèle objet Automation.

Pour obtenir d'autres exemples illustrant l'utilisation du modèle Automation Editor, consultez la macro du correcteur orthographique ainsi que d'autres exemples sur des exemples Automation pour le site Web Visual Studio (http://www.microsoft.com/downloads/details.aspx?familyid=3ff9c915-30e5-430e-95b3-621dccd25150&displaylang=en).

Remarque Remarque

Les boîtes de dialogue et les commandes de menu qui s'affichent peuvent être différentes de celles qui sont décrites dans l'aide, en fonction de vos paramètres actifs ou de l'édition utilisée. Ces procédures ont été développées avec les paramètres de développement généraux actifs. Pour modifier vos paramètres, sélectionnez Importation et exportationde paramètres dans le menu Outils. Pour plus d'informations, consultez Paramètres Visual Studio.

HTMLWindow3, vsHTMLPanes et vsHTMLViews ont été ajoutés avec l'introduction du mode Fractionné dans l'éditeur HTML de Visual Studio 2008. Le mode Fractionné sépare les onglets des éléments d'affichage de la fenêtre d'édition HTML. Le changement de mode (Design ou Source) n'implique pas nécessairement un changement d'onglet (Design/Fractionné/Source). Par exemple, lorsque vous cliquez sur l'onglet Fractionné, le basculement entre les modes Design et Source n'entraîne pas de changement d'onglet mais active ou désactive simplement les volets Design et Source en mode Fractionné.

Cet exemple de complément montre comment utiliser ActivePoint. Cet exemple illustre également l'utilisation de StartOfLine, DisplayColumn et EndOfLine. Avant d'exécuter cet exemple, ouvrez un fichier de code ou un document texte dans Visual Studio, ajoutez-y du texte, puis sélectionnez-en une partie.

// Add-in example.
using System.Windows.Forms;
public void OnConnection(object application, ext_ConnectMode
 connectMode, object addInInst, ref Array custom)
{
    _applicationObject = (DTE2)application;
    _addInInstance = (AddIn)addInInst;

// Pass the applicationObject member variable to the code example.
    ActivePointExample(_applicationObject); 
}

public void ActivePointExample( DTE2 dte ) 
{ 
    // Before running this example, open a text document.
    TextSelection objSel = (TextSelection )
(dte.ActiveDocument.Selection ); 
    VirtualPoint objActive = objSel.ActivePoint; 
    // Collapse the selection to the beginning of the line.
    objSel.StartOfLine( (EnvDTE.vsStartOfLineOptions)(0), false ); 
    // objActive is "live", tied to the position of the actual 
    // selection, so it reflects the new position.
    long iCol = objActive.DisplayColumn; 
    // Move the selection to the end of the line.
    objSel.EndOfLine( false );
            
    MessageBox.Show( "The length of the insertion point line is " + 
( objActive.DisplayColumn - iCol ) + " display characters."); 
}

Cet exemple de complément montre comment utiliser AnchorPoint. Cet exemple illustre également l'utilisation de DisplayColumn, Line, StartOfDocument et EndOfDocument. Avant d'exécuter cet exemple, ouvrez un fichier de code ou un document texte dans Visual Studio, ajoutez-y du texte, puis sélectionnez-en une partie.

// Add-in example.
Using System.Windows.Formms;
public void OnConnection(object application, ext_ConnectMode
 connectMode, object addInInst, ref Array custom)
{
    _applicationObject = (DTE2)application;
    _addInInstance = (AddIn)addInInst;

// Pass the applicationObject member variable to the code example.
    AnchorPointExample(_applicationObject); 
}

public void AnchorPointExample( DTE2 dte ) 
{ 
// Before running this example, open a text document.
    TextSelection objSel = ( EnvDTE.TextSelection )(
 dte.ActiveDocument.Selection ); 
    VirtualPoint objAnchor = objSel.AnchorPoint; 
    // objAnchor is "live", tied to the position of the actual 
    // selection, so it reflects changes. iCol and iRow are 
    // created here to save a "snapshot" of the anchor point's 
    // position at this time.
    long iCol = objAnchor.DisplayColumn; 
    long iRow = objAnchor.Line; 
    // As the selection is extended, the active point moves but the 
    // anchor point remains in place.
    objSel.StartOfDocument( true ); 
    objSel.EndOfDocument( true ); 

    if ( ( iCol == objAnchor.DisplayColumn & iRow == objAnchor.Line ) ) 
        { 
           MessageBox.Show
( "The anchor point has remained in place at row "
 + iRow + ", display column " + iCol); 
        } 
}

Cet exemple de complément montre comment utiliser Insert. Cet exemple illustre également l'utilisation de IsEmpty, WordLeft, WordRight, Text, Delete et MoveToPoint. Avant d'exécuter cet exemple, ouvrez un fichier de code ou un document texte dans Visual Studio et ajoutez-y du texte.

// Add-in example.
using System.Windows.Forms;
public void OnConnection(object application, ext_ConnectMode
 connectMode, object addInInst, ref Array custom)
{
    _applicationObject = (DTE2)application;
    _addInInstance = (AddIn)addInInst;

// Pass the applicationObject member variable to the code example.
    InsertExample (_applicationObject); 
}
public void InsertExample( DTE2 dte ) 
{ 
// Before running this example, open a code file.
    TextSelection objSel = ( EnvDTE.TextSelection )(
 dte.ActiveDocument.Selection ); 
    if ( objSel.IsEmpty ) 
    { 
    // If there is no text selected, swap the words before and after 
    // the insertion point. Begin by selecting the word before 
    // the insertion point.
        objSel.WordLeft( true, 1 ); 
        if ( !( objSel.IsEmpty ) ) 
        { 
        // The example can continue only if the selection was not 
        // already at the beginning of the document.
            string strBefore = objSel.Text; 
                    
            // The text is saved in strBefore; now delete it and move 
            // past the following word.
            objSel.Delete( 1 ); 
            objSel.WordRight( true, 1 ); 
            if ( objSel.Text.StartsWith( " " )) 
                { 
                // The previous call to WordRight may have skipped 
                // some white space instead of an actual word. In that 
                // case, we should call it again.
                objSel.WordRight( true, 1 ); 
            } 

        // Insert the new text at the end of the selection.
        objSel.Insert( strBefore, System.Convert.ToInt32(
 vsInsertFlags.vsInsertFlagsInsertAtEnd ) ); 
        } 
    } 
    else 
    { 
    // If some text is selected, replace the following word with the 
    // selected text.
    string strSelected = objSel.Text; 

        objSel.MoveToPoint( objSel.BottomPoint, false ); 
        objSel.WordRight( true, 1 ); 
        if ( objSel.Text.StartsWith( " " )) 
        { 
             // The previous call to WordRight may have skipped some 
             // white space instead of an actual word. In that case, 
            // we should call it again.
            objSel.WordRight( true, 1 ); 
        } 

        // Insert the text, overwriting the existing text and leaving 
        // the selection containing the inserted text.
    objSel.Insert( strSelected, System.Convert.ToInt32( vsInsertFlags.vsInsertFlagsContainNewText ) ); 
    }
}

Cet exemple de complément montre comment utiliser FindPattern. Cet exemple illustre également l'utilisation de SelectLine. Avant d'exécuter cet exemple, ouvrez un fichier de code ou un document texte dans Visual Studio et ajoutez-y le terme « sub » entre deux espaces blancs.

// Add-in example.
using System.Windows.Forms;
public void OnConnection(object application, ext_ConnectMode
 connectMode, object addInInst, ref Array custom)
{
    _applicationObject = (DTE2)application;
    _addInInstance = (AddIn)addInInst;

// Pass the applicationObject member variable to the code example.
    FindPatternExample (_applicationObject); 
}

public void FindPatternExample( DTE2 dte ) 
{ 
// Before running this example, open a text document
// with the text " Sub ".
    TextSelection objSel = (EnvDTE.TextSelection)(dte.ActiveDocument.Selection ); 

    string srchPattern1 = " Sub ";
    EnvDTE.TextRanges textRanges = null;

    // Advance to the next Visual Basic function beginning or end by 
    // searching for  "Sub" with white space before and after it.
    objSel.FindPattern( srchPattern1, 0, ref textRanges );
    { 
        //  Select the entire line.
        objSel.SelectLine(); 
    } 
}

Cet exemple de complément montre comment utiliser OutlineSection. Cet exemple illustre également l'utilisation de StartOfDocument, Line, LineCharOffset, FindPattern, SwapAnchor, MoveToLineAndOffset et LineDown. Avant d'exécuter cet exemple, dans Visual Studio, ouvrez un document de code contenant un bloc #if _DEBUG…#endif.

// Add-in example for.
public void OnConnection(object application,
 Extensibility.ext_ConnectMode connectMode, object addInInst,
 ref System.Array custom)
{
    _applicationObject = (DTE2)application;
    _addInInstance = (AddIn)addInInst;
    //  Pass the applicationObject member variable to the code example.
    OutlineSectionExample(_applicationObject ); 
}

public void OutlineSectionExample( DTE2 dte ) 
{ 
    // Before running this example, open a code document
    // containing a #if _DEBUG…#endif block.
    TextSelection objSel = ( EnvDTE.TextSelection )(
 dte.ActiveDocument.Selection ); 
    string srchPattern1 = "#if _DEBUG";
    string srchPattern2 = "#endif";
    EnvDTE.TextRanges textRanges = null;

    //Move to the beginning of the document so we can iterate 
    // over the whole thing.
    objSel.StartOfDocument( false ); 
 
    while ( objSel.FindPattern( srchPattern1, 0, ref textRanges) ) 
    { 
        //  If it's the beginning of a debug-only section, 
        // save the position.
        long lStartLine = objSel.TopPoint.Line; 
        long lStartColumn = objSel.TopPoint.LineCharOffset; 

        //  Look for the end.
        if ( objSel.FindPattern(srchPattern2 , 0,ref textRanges) ) 
        { 
            //  Select the entire section and outline it.
            objSel.SwapAnchor(); 
            objSel.MoveToLineAndOffset( System.Convert.ToInt32
( lStartLine ), System.Convert.ToInt32( lStartColumn ), true ); 
            objSel.OutlineSection(); 
            objSel.LineDown( false, 1 ); 
        } 
    } 
}

Cet exemple de complément ouvre un document texte et génère une liste de toutes les commandes disponibles dans ce document.

RemarqueRemarque

Ce complément répertorie toutes les commandes de l'IDE de Visual Studio. Selon la configuration de votre ordinateur, son exécution peut prendre plusieurs minutes.

// Add-in example.
// This generates a text document listing all available command names.

public void OnConnection(object application,
 Extensibility.ext_ConnectMode connectMode, object addInInst,
 ref System.Array custom)
{
_applicationObject = (DTE2)application;
_addInInstance = (AddIn)addInInst;
//  Pass the applicationObject member variable to the code example.
CommandNamesCollapseExample(_applicationObject ); 
}
public void CommandNamesCollapseExample( DTE2 dte ) 
{ 
    Command Cmd = null; 
    Commands Commands = dte.Commands; 
    ProjectItem PrjItem = null; 
    Document Doc = null; 
    TextDocument TxtDoc = null; 
    dte.ItemOperations.NewFile( @"General\Text File", "", 
"{00000000-0000-0000-0000-000000000000}" ); 
    Doc = dte.ActiveDocument; 
    TxtDoc = (EnvDTE.TextDocument )(Doc.Object( "TextDocument" )); 
    foreach ( EnvDTE.Command tempCmd in Commands ) 
    { 
        Cmd = tempCmd; 
        if ( ( Cmd.Name != "" ) ) 
        { 
            TxtDoc.Selection.Text = Cmd.Name +"\n"; 
            TxtDoc.Selection.Collapse(); 
        } 
    }
}
Afficher: