Console.WindowTop Console.WindowTop Console.WindowTop Console.WindowTop Property

Definition

Ruft die oberste Position des Konsolenfensterbereichs im Verhältnis zum Bildschirmpuffer ab oder legt diese fest.Gets or sets the top position of the console window area relative to the screen buffer.

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

Eigenschaftswert

Die oberste Konsolenfensterposition in Zeilen.The uppermost console window position measured in rows.

Ausnahmen

In einem SET-Vorgang ist der zuzuweisende Wert kleiner als 0 (null).In a set operation, the value to be assigned is less than zero.

- oder --or- Als Ergebnis der Zuweisung würde WindowTop plus WindowHeight den Wert für BufferHeight überschreiten.As a result of the assignment, WindowTop plus WindowHeight would exceed BufferHeight.

Fehler beim Lesen oder Schreiben von Informationen.Error reading or writing information.

Der set-Vorgang wird unter einem anderen Betriebssystem als Windows aufgerufen.The set operation is invoked on an operating system other than Windows.

Beispiele

Im folgenden Beispiel werden die WindowLeftEigenschaften WindowTop, WindowWidth, WindowHeight, BufferWidth, BufferHeight, und CursorVisible veranschaulicht, und SetWindowPosition, SetBufferSizeund. ReadKey anzuwenden.The following example demonstrates the WindowLeft, WindowTop, WindowWidth, WindowHeight, BufferWidth, BufferHeight, and CursorVisible properties; and the SetWindowPosition, SetBufferSize, and ReadKey methods. Im Beispiel wird ein Raster Muster basierend auf der Bildschirm Puffer Breite im Bildschirm Puffer gezeichnet.The example draws a grid pattern in the screen buffer based on the screen buffer width. Im Beispiel wird das Konsolenfenster in Reaktion darauf verschoben, welche der nach-oben-Taste, nach-unten-Taste, nach-links-Taste oder nach-rechts-Taste gedrückt wird.Then the example moves the console window in response to which of the UP ARROW, DOWN ARROW, LEFT ARROW, or RIGHT ARROW console keys is pressed. Mit dem Raster Muster können Sie die Bewegung des Konsolenfensters relativ zum Bildschirm Puffer erkennen.The grid pattern helps you see the movement of the console window relative to the screen buffer.

// This example demonstrates the Console.WindowLeft and
//                               Console.WindowTop properties.
using namespace System;
using namespace System::Text;
using namespace System::IO;

//
int saveBufferWidth;
int saveBufferHeight;
int saveWindowHeight;
int saveWindowWidth;
bool saveCursorVisible;

//
int main()
{
   String^ m1 = "1) Press the cursor keys to move the console window.\n"
   "2) Press any key to begin. When you're finished...\n"
   "3) Press the Escape key to quit.";
   String^ g1 = "+----";
   String^ g2 = "|    ";
   String^ grid1;
   String^ grid2;
   StringBuilder^ sbG1 = gcnew StringBuilder;
   StringBuilder^ sbG2 = gcnew StringBuilder;
   ConsoleKeyInfo cki;
   int y;
   
   //
   try
   {
      saveBufferWidth = Console::BufferWidth;
      saveBufferHeight = Console::BufferHeight;
      saveWindowHeight = Console::WindowHeight;
      saveWindowWidth = Console::WindowWidth;
      saveCursorVisible = Console::CursorVisible;
      
      //
      Console::Clear();
      Console::WriteLine( m1 );
      Console::ReadKey( true );
      
      // Set the smallest possible window size before setting the buffer size.
      Console::SetWindowSize( 1, 1 );
      Console::SetBufferSize( 80, 80 );
      Console::SetWindowSize( 40, 20 );
      
      // Create grid lines to fit the buffer. (The buffer width is 80, but
      // this same technique could be used with an arbitrary buffer width.)
      for ( y = 0; y < Console::BufferWidth / g1->Length; y++ )
      {
         sbG1->Append( g1 );
         sbG2->Append( g2 );

      }
      sbG1->Append( g1, 0, Console::BufferWidth % g1->Length );
      sbG2->Append( g2, 0, Console::BufferWidth % g2->Length );
      grid1 = sbG1->ToString();
      grid2 = sbG2->ToString();
      Console::CursorVisible = false;
      Console::Clear();
      for ( y = 0; y < Console::BufferHeight - 1; y++ )
      {
         if ( y % 3 == 0 )
                  Console::Write( grid1 );
         else
                  Console::Write( grid2 );

      }
      Console::SetWindowPosition( 0, 0 );
      do
      {
         cki = Console::ReadKey( true );
         switch ( cki.Key )
         {
            case ConsoleKey::LeftArrow:
               if ( Console::WindowLeft > 0 )
                              Console::SetWindowPosition( Console::WindowLeft - 1, Console::WindowTop );
               break;

            case ConsoleKey::UpArrow:
               if ( Console::WindowTop > 0 )
                              Console::SetWindowPosition( Console::WindowLeft, Console::WindowTop - 1 );
               break;

            case ConsoleKey::RightArrow:
               if ( Console::WindowLeft < (Console::BufferWidth - Console::WindowWidth) )
                              Console::SetWindowPosition( Console::WindowLeft + 1, Console::WindowTop );
               break;

            case ConsoleKey::DownArrow:
               if ( Console::WindowTop < (Console::BufferHeight - Console::WindowHeight) )
                              Console::SetWindowPosition( Console::WindowLeft, Console::WindowTop + 1 );
               break;
         }
      }
      while ( cki.Key != ConsoleKey::Escape );
   }
   catch ( IOException^ e ) 
   {
      Console::WriteLine( e->Message );
   }
   finally
   {
      Console::Clear();
      Console::SetWindowSize( 1, 1 );
      Console::SetBufferSize( saveBufferWidth, saveBufferHeight );
      Console::SetWindowSize( saveWindowWidth, saveWindowHeight );
      Console::CursorVisible = saveCursorVisible;
   }

} // end Main


/*
This example produces results similar to the following:

1) Press the cursor keys to move the console window.
2) Press any key to begin. When you're finished...
3) Press the Escape key to quit.

...

+----+----+----+-
|    |    |    |
|    |    |    |
+----+----+----+-
|    |    |    |
|    |    |    |
+----+----+----+-

*/
// This example demonstrates the Console.WindowLeft and
//                               Console.WindowTop properties.
using System;
using System.Text;
using System.IO;
//
class Sample 
{
    public static int saveBufferWidth;
    public static int saveBufferHeight;
    public static int saveWindowHeight;
    public static int saveWindowWidth;
    public static bool saveCursorVisible;
//
    public static void Main() 
    {
    string m1 = "1) Press the cursor keys to move the console window.\n" +
                "2) Press any key to begin. When you're finished...\n" +
                "3) Press the Escape key to quit.";
    string g1 = "+----";
    string g2 = "|    ";
    string grid1;
    string grid2;
    StringBuilder sbG1 = new StringBuilder();
    StringBuilder sbG2 = new StringBuilder();
    ConsoleKeyInfo cki;
    int y;
//
    try 
    {
    saveBufferWidth  = Console.BufferWidth;
    saveBufferHeight = Console.BufferHeight;
    saveWindowHeight = Console.WindowHeight;
    saveWindowWidth  = Console.WindowWidth;
    saveCursorVisible = Console.CursorVisible;
//
    Console.Clear();
    Console.WriteLine(m1);
    Console.ReadKey(true);

// Set the smallest possible window size before setting the buffer size.
    Console.SetWindowSize(1, 1);
    Console.SetBufferSize(80, 80);
    Console.SetWindowSize(40, 20);

// Create grid lines to fit the buffer. (The buffer width is 80, but
// this same technique could be used with an arbitrary buffer width.)
    for (y = 0; y < Console.BufferWidth/g1.Length; y++)
        {
        sbG1.Append(g1);
        sbG2.Append(g2);
        }
    sbG1.Append(g1, 0, Console.BufferWidth%g1.Length);
    sbG2.Append(g2, 0, Console.BufferWidth%g2.Length);
    grid1 = sbG1.ToString();
    grid2 = sbG2.ToString();

    Console.CursorVisible = false;
    Console.Clear();
    for (y = 0; y < Console.BufferHeight-1; y++)
        {
        if (y%3 == 0)
            Console.Write(grid1);
        else
            Console.Write(grid2);
        }

    Console.SetWindowPosition(0, 0);
    do
        {
        cki = Console.ReadKey(true);
        switch (cki.Key) 
            {
            case ConsoleKey.LeftArrow:
                if (Console.WindowLeft > 0) 
                    Console.SetWindowPosition(
                            Console.WindowLeft-1, Console.WindowTop);
                break;
            case ConsoleKey.UpArrow:
                if (Console.WindowTop > 0) 
                    Console.SetWindowPosition(
                            Console.WindowLeft, Console.WindowTop-1);
                break;
            case ConsoleKey.RightArrow:
                if (Console.WindowLeft < (Console.BufferWidth-Console.WindowWidth)) 
                    Console.SetWindowPosition(
                            Console.WindowLeft+1, Console.WindowTop);
                break;
            case ConsoleKey.DownArrow:
                if (Console.WindowTop < (Console.BufferHeight-Console.WindowHeight)) 
                    Console.SetWindowPosition(
                            Console.WindowLeft, Console.WindowTop+1);
                break;
            }
        } 
    while (cki.Key != ConsoleKey.Escape);  // end do-while
    } // end try
    catch (IOException e) 
        {
        Console.WriteLine(e.Message);
        }
    finally 
        {
        Console.Clear();
        Console.SetWindowSize(1, 1);
        Console.SetBufferSize(saveBufferWidth, saveBufferHeight);
        Console.SetWindowSize(saveWindowWidth, saveWindowHeight);
        Console.CursorVisible = saveCursorVisible;
        }
    } // end Main
} // end Sample
/*
This example produces results similar to the following:

1) Press the cursor keys to move the console window.
2) Press any key to begin. When you're finished...
3) Press the Escape key to quit.

...

+----+----+----+-
|    |    |    |
|    |    |    |
+----+----+----+-
|    |    |    |
|    |    |    |
+----+----+----+-

*/
' This example demonstrates the Console.WindowLeft and
'                               Console.WindowTop properties.
Imports System.IO
Imports System.Text

Class Sample
   Public Shared saveBufferWidth As Integer
   Public Shared saveBufferHeight As Integer
   Public Shared saveWindowHeight As Integer
   Public Shared saveWindowWidth As Integer
   Public Shared saveCursorVisible As Boolean
   
   Public Shared Sub Main()
      Dim m1 As String = _
          "1) Press the cursor keys to move the console window." & vbCrlf & _
          "2) Press any key to begin. When you're finished..."   & vbCrlf & _
          "3) Press the Escape key to quit."
      Dim g1 As String = "+----"
      Dim g2 As String = "|    "
      Dim grid1 As String
      Dim grid2 As String
      Dim sbG1 As New StringBuilder()
      Dim sbG2 As New StringBuilder()
      Dim cki As ConsoleKeyInfo
      Dim y As Integer
      '
      Try
         saveBufferWidth = Console.BufferWidth
         saveBufferHeight = Console.BufferHeight
         saveWindowHeight = Console.WindowHeight
         saveWindowWidth = Console.WindowWidth
         saveCursorVisible = Console.CursorVisible
         '
         Console.Clear()
         Console.WriteLine(m1)
         Console.ReadKey(True)
         
         ' Set the smallest possible window size before setting the buffer size.
         Console.SetWindowSize(1, 1)
         Console.SetBufferSize(80, 80)
         Console.SetWindowSize(40, 20)
         
         ' Create grid lines to fit the buffer. (The buffer width is 80, but
         ' this same technique could be used with an arbitrary buffer width.)
         For y = 0 To (Console.BufferWidth / g1.Length) - 1
            sbG1.Append(g1)
            sbG2.Append(g2)
         Next y
         sbG1.Append(g1, 0, Console.BufferWidth Mod g1.Length)
         sbG2.Append(g2, 0, Console.BufferWidth Mod g2.Length)
         grid1 = sbG1.ToString()
         grid2 = sbG2.ToString()
         
         Console.CursorVisible = False
         Console.Clear()
         For y = 0 To (Console.BufferHeight - 2)
            If y Mod 3 = 0 Then
               Console.Write(grid1)
            Else
               Console.Write(grid2)
            End If
         Next y 
         '
         Console.SetWindowPosition(0, 0)
         Do
            cki = Console.ReadKey(True)
            Select Case cki.Key
               Case ConsoleKey.LeftArrow
                  If Console.WindowLeft > 0 Then
                     Console.SetWindowPosition(Console.WindowLeft - 1, Console.WindowTop)
                  End If
               Case ConsoleKey.UpArrow
                  If Console.WindowTop > 0 Then
                     Console.SetWindowPosition(Console.WindowLeft, Console.WindowTop - 1)
                  End If
               Case ConsoleKey.RightArrow
                  If Console.WindowLeft < Console.BufferWidth - Console.WindowWidth Then
                     Console.SetWindowPosition(Console.WindowLeft + 1, Console.WindowTop)
                  End If
               Case ConsoleKey.DownArrow
                  If Console.WindowTop < Console.BufferHeight - Console.WindowHeight Then
                     Console.SetWindowPosition(Console.WindowLeft, Console.WindowTop + 1)
                  End If
            End Select
         Loop While cki.Key <> ConsoleKey.Escape
      ' end do-while
      ' end try
      Catch e As IOException
         Console.WriteLine(e.Message)
      Finally
         Console.Clear()
         Console.SetWindowSize(1, 1)
         Console.SetBufferSize(saveBufferWidth, saveBufferHeight)
         Console.SetWindowSize(saveWindowWidth, saveWindowHeight)
         Console.CursorVisible = saveCursorVisible
      End Try
   End Sub 'Main ' end Main
End Class 'Sample ' end Sample
'
'This example produces results similar to the following:
'
'1) Press the cursor keys to move the console window.
'2) Press any key to begin. When you're finished...
'3) Press the Escape key to quit.
'
'...
'
'+----+----+----+-
'|    |    |    |
'|    |    |    |
'+----+----+----+-
'|    |    |    |
'|    |    |    |
'+----+----+----+-
'

Hinweise

Die Konsole stellt ein rechteckiges Fenster in einem größeren rechteckigen Pufferbereich dar.The console represents a rectangular window into a larger rectangular buffer area. Sowohl das Fenster als auch der Puffer werden vertikal anhand der Anzahl der Zeilen und der horizontalen Anzahl der Spalten gemessen.Both the window and the buffer are measured vertically by their number of rows and horizontally by their number of columns. Die Abmessungen des Puffer Bereichs werden durch die BufferHeight -Eigenschaft und die- BufferWidth Eigenschaft definiert.The dimensions of the buffer area are defined by the BufferHeight and BufferWidth properties. Die Abmessungen des Konsolen Bereichs werden durch die WindowHeight -Eigenschaft und die- WindowWidth Eigenschaft definiert.The dimensions of the console area are defined by the WindowHeight and WindowWidth properties. Die WindowTop -Eigenschaft bestimmt, welche Zeile des Puffer Bereichs in der ersten Spalte des Konsolenfensters angezeigt wird.The WindowTop property determines which row of the buffer area is displayed in the first column of the console window. Der Wert WindowTop der-Eigenschaft kann zwischen 0 und BufferHeight - WindowHeightliegen.The value of the WindowTop property can range from 0 to BufferHeight - WindowHeight. Wenn versucht wird, ihn auf einen Wert außerhalb dieses Bereichs fest ArgumentOutOfRangeExceptionzulegen, wird eine ausgelöst.Attempting to set it to a value outside that range throws an ArgumentOutOfRangeException.

Wenn Sie versuchen, den Wert der WindowTop -Eigenschaft festzulegen, wenn die IOException Ausgabe umgeleitet wird, wird eine Ausnahme ausgelöst.Attempting to set the value of the WindowTop property when output is redirected throws an IOException exception. Um die Ausnahme zu verhindern, können Sie den Wert dieser Eigenschaft nur festlegen, wenn IsOutputRedirected die- falseEigenschaft zurückgibt.To prevent the exception, you can set the value of this property only if the IsOutputRedirected property returns false.

Gilt für: