Console.WindowLeft Console.WindowLeft Console.WindowLeft Console.WindowLeft Property

Définition

Obtient ou définit la position la plus à gauche de la zone de la fenêtre de console par rapport à la mémoire tampon d'écran.Gets or sets the leftmost position of the console window area relative to the screen buffer.

public:
 static property int WindowLeft { int get(); void set(int value); };
public static int WindowLeft { get; set; }
member this.WindowLeft : int with get, set
Public Shared Property WindowLeft As Integer

Valeur de propriété

Position de la fenêtre de console la plus à gauche mesurée en colonnes.The leftmost console window position measured in columns.

Exceptions

Dans une opération ensembliste, la valeur à affecter est inférieure à zéro.In a set operation, the value to be assigned is less than zero.

- ou --or- Suite à l’affectation, WindowLeft plus WindowWidth dépasseraient BufferWidth.As a result of the assignment, WindowLeft plus WindowWidth would exceed BufferWidth.

Erreur de lecture ou d’écriture des informations.Error reading or writing information.

L’opération ensembliste est invoquée sur un système d’exploitation autre que Windows.The set operation is invoked on an operating system other than Windows.

Exemples

L’exemple suivant ouvre une fenêtre de console de 80 colonnes et définit une zone de mémoire tampon d’une largeur de 120 colonnes.The following example opens an 80-column console window and defines a buffer area that is 120 columns wide. Il affiche des informations sur la taille de la fenêtre et de la mémoire tampon, puis attend que l’utilisateur appuie sur la touche de direction gauche ou sur la touche de direction droite.It displays information on window and buffer size, and then waits for the user to press either the LEFT ARROW key or the RIGHT ARROW key. Dans le premier cas, il décrémente la valeur de la WindowLeft propriété d’une unité si le résultat est une valeur légale.In the former case, it decrements the value of the WindowLeft property by one if the result is a legal value. Dans ce dernier cas, elle augmente la valeur de la WindowLeft propriété d’une unité si le résultat est légal.In the latter case, it increases the value of the WindowLeft property by one if the result would be legal. Notez que l’exemple n’a pas besoin de gérer ArgumentOutOfRangeExceptionun, car il vérifie que la valeur à assigner WindowLeft à la propriété n’est pas négative et n' WindowLeft entraîne pas le dépassement WindowWidth BufferWidth de la somme des propriétés et. valeur de la propriété.Note that the example does not have to handle an ArgumentOutOfRangeException, because it checks that the value to be assigned to the WindowLeft property is not negative and does not cause the sum of the WindowLeft and WindowWidth properties to exceed the BufferWidth property value.

using namespace System;

void ShowConsoleStatistics()
{
   Console::WriteLine("Console statistics:");
   Console::WriteLine("   Buffer: {0} x {1}", Console::BufferHeight, Console::BufferWidth);
   Console::WriteLine("   Window: {0} x {1}", Console::WindowHeight, Console::WindowWidth);
   Console::WriteLine("   Window starts at {0}.", Console::WindowLeft);
   Console::WriteLine("Press <- or -> to move window, Ctrl+C to exit.");
}

int main()
{
   ConsoleKeyInfo key;
   bool moved = false;

   Console::BufferWidth = 120;
   Console::Clear();

   ShowConsoleStatistics();
   
   do {
      key = Console::ReadKey(true);
      if (key.Key == ConsoleKey::LeftArrow)
      {
         int pos = Console::WindowLeft - 1;
         if (pos >= 0 && pos + Console::WindowWidth <= Console::BufferWidth)
         { 
            Console::WindowLeft = pos;
            moved = true;
         }       
      } 
      else if (key.Key == ConsoleKey::RightArrow)
      {
            int pos = Console::WindowLeft + 1;
            if (pos + Console::WindowWidth <= Console::BufferWidth)
            { 
               Console::WindowLeft = pos;
               moved = true;
            }
      }
      if (moved)
      { 
         ShowConsoleStatistics(); 
         moved = false;
      }   
      Console::WriteLine();
   } while (true);
}
using System;

public class Example
{
   public static void Main()
   {
      ConsoleKeyInfo key;
      bool moved = false;
            
      Console.BufferWidth += 4;
      Console.Clear();
      
      ShowConsoleStatistics();
      do 
      {
         key = Console.ReadKey(true);
         if (key.Key == ConsoleKey.LeftArrow)
         {
            int pos = Console.WindowLeft - 1;
            if (pos >= 0 && pos + Console.WindowWidth <= Console.BufferWidth)
            { 
               Console.WindowLeft = pos;
               moved = true;
            }       
         } 
         else if (key.Key == ConsoleKey.RightArrow)
         {
            int pos = Console.WindowLeft + 1;
            if (pos + Console.WindowWidth <= Console.BufferWidth)
            { 
               Console.WindowLeft = pos;
               moved = true;
            }
         }
         if (moved)
         { 
            ShowConsoleStatistics(); 
            moved = false;
         }   
         Console.WriteLine();
      } while (true);
   }

   private static void ShowConsoleStatistics()
   {
      Console.WriteLine("Console statistics:");
      Console.WriteLine("   Buffer: {0} x {1}", Console.BufferHeight, Console.BufferWidth);
      Console.WriteLine("   Window: {0} x {1}", Console.WindowHeight, Console.WindowWidth);
      Console.WriteLine("   Window starts at {0}.", Console.WindowLeft);
      Console.WriteLine("Press <- or -> to move window, Ctrl+C to exit.");
   }
}
Module Example
   Public Sub Main()
      Dim key As ConsoleKeyInfo
      Dim moved As Boolean = False
            
      Console.BufferWidth = 120
      Console.Clear()
      
      ShowConsoleStatistics()
      Do While True
         key = Console.ReadKey(True)
         If key.Key = ConsoleKey.LeftArrow Then
            Dim pos As Integer = Console.WindowLeft - 1
            If pos >= 0 And pos + Console.WindowWidth <= Console.BufferWidth Then 
               Console.WindowLeft = pos
               moved = True
            End If       
         ElseIf key.Key = ConsoleKey.RightArrow Then
            Dim pos As Integer = Console.WindowLeft + 1
            If pos + Console.WindowWidth <= Console.BufferWidth Then 
               Console.WindowLeft = pos
               moved = True
            End If
         End If
         If moved Then ShowConsoleStatistics() : moved = False
         Console.WriteLine()
      Loop
   End Sub
   
   Private Sub ShowConsoleStatistics()
      Console.WriteLine("Console statistics:")
      Console.WriteLine("   Buffer: {0} x {1}", Console.BufferHeight, Console.BufferWidth)
      Console.WriteLine("   Window: {0} x {1}", Console.WindowHeight, Console.WindowWidth)
      Console.WriteLine("   Window starts at {0}.", Console.WindowLeft)
      Console.WriteLine("Press <- or -> to move window, Ctrl+C to exit.")
   End Sub
End Module

Remarques

La console représente une fenêtre rectangulaire dans une zone de mémoire tampon rectangulaire plus grande.The console represents a rectangular window into a larger rectangular buffer area. La fenêtre et la mémoire tampon sont mesurées verticalement en fonction de leur nombre de lignes et horizontalement en fonction de leur nombre de colonnes.Both the window and the buffer are measured vertically by their number of rows and horizontally by their number of columns. Les dimensions de la zone de mémoire tampon sont définies BufferHeight par BufferWidth les propriétés et.The dimensions of the buffer area are defined by the BufferHeight and BufferWidth properties. Les dimensions de la zone de la console sont définies WindowHeight par WindowWidth les propriétés et.The dimensions of the console area are defined by the WindowHeight and WindowWidth properties. La WindowLeft propriété détermine quelle colonne de la zone de mémoire tampon est affichée dans la première colonne de la fenêtre de console.The WindowLeft property determines which column of the buffer area is displayed in the first column of the console window. La valeur de la WindowLeft propriété peut être comprise BufferWidthentre 0 et - . WindowWidthThe value of the WindowLeft property can range from 0 to BufferWidth - WindowWidth. Toute tentative de définition d’une valeur en dehors de cette plage lève ArgumentOutOfRangeExceptionune.Attempting to set it to a value outside that range throws an ArgumentOutOfRangeException.

Quand une fenêtre de console s’ouvre pour la première fois, WindowLeft la valeur par défaut de la propriété est zéro, ce qui indique que la première colonne indiquée par la console correspond à la première colonne (la colonne à la position zéro) dans la zone de mémoire tampon.When a console window first opens, the default value of the WindowLeft property is zero, which indicates that the first column shown by the console corresponds to the first column (the column at position zero) in the buffer area. La largeur par défaut de la fenêtre de console et de la zone de mémoire tampon est de 80 colonnes.The default width of both the console window and the buffer area is 80 columns. Cela signifie que la WindowLeft propriété ne peut être modifiée que si la fenêtre de console est rendue plus étroite ou si la zone tampon est rendue plus large.This means that the WindowLeft property can be modified only if the console window is made narrower or the buffer area is made wider.

Notez que si la largeur de la zone de mémoire tampon dépasse la largeur de la fenêtre de console, la WindowLeft valeur de la propriété est ajustée automatiquement lorsque l’utilisateur utilise la barre de défilement horizontale pour définir la relation de la fenêtre avec la zone de mémoire tampon.Note that if the width of the buffer area exceeds the width of the console window, the value of the WindowLeft property is automatically adjusted when the user uses the horizontal scroll bar to define the window's relationship to the buffer area.

Toute tentative de définition de la valeur WindowLeft de la propriété lorsque la sortie est redirigée IOException lève une exception.Attempting to set the value of the WindowLeft property when output is redirected throws an IOException exception. Pour éviter l’exception, vous pouvez définir la valeur de cette propriété uniquement si la IsOutputRedirected propriété retourne false.To prevent the exception, you can set the value of this property only if the IsOutputRedirected property returns false.

S’applique à