Udostępnij za pośrednictwem


Console.SetWindowPosition(Int32, Int32) Metoda

Definicja

Ustawia położenie okna konsoli względem buforu ekranu.

public:
 static void SetWindowPosition(int left, int top);
[System.Runtime.Versioning.SupportedOSPlatform("windows")]
public static void SetWindowPosition (int left, int top);
public static void SetWindowPosition (int left, int top);
[<System.Runtime.Versioning.SupportedOSPlatform("windows")>]
static member SetWindowPosition : int * int -> unit
static member SetWindowPosition : int * int -> unit
Public Shared Sub SetWindowPosition (left As Integer, top As Integer)

Parametry

left
Int32

Położenie kolumny w lewym górnym rogu okna konsoli.

top
Int32

Położenie wiersza lewego górnego rogu okna konsoli.

Atrybuty

Wyjątki

left wartość lub top jest mniejsza niż zero.

-lub-

left + WindowWidth wartość jest większa niż BufferWidth.

-lub-

top + WindowHeight wartość jest większa niż BufferHeight.

Użytkownik nie ma uprawnienia do wykonania tej czynności.

Wystąpił błąd we/wy.

Bieżący system operacyjny nie jest systemem Windows.

Przykłady

W poniższym przykładzie przedstawiono WindowLeftwłaściwości , WindowTop, , WindowHeightWindowWidthBufferWidth, , BufferHeighti CursorVisible , SetBufferSizeoraz SetWindowPositionmetody .ReadKey Przykład rysuje wzorzec siatki w buforze ekranu na podstawie szerokości buforu ekranu. Następnie przykład przenosi okno konsoli w odpowiedzi na naciśnięcie klawiszy konsoli STRZAŁKA W GÓRĘ, STRZAŁKA W DÓŁ, STRZAŁKA W LEWO lub STRZAŁKA W PRAWO. Wzorzec siatki pomaga zobaczyć ruch okna konsoli względem buforu ekranu.

// 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
End Class
'
'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.
open System
open System.Text
open System.IO

[<EntryPoint>]
let main argv =
    let 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."
    let g1 = "+----";
    let g2 = "|    ";
    let sbG1 = StringBuilder()
    let sbG2 = StringBuilder()


    let saveBufferWidth = Console.BufferWidth
    let saveBufferHeight = Console.BufferHeight
    let saveWindowHeight = Console.WindowHeight
    let saveWindowWidth = Console.WindowWidth
    let saveCursorVisible = Console.CursorVisible

    try
        try
            Console.Clear()
            Console.WriteLine(m1)
            Console.ReadKey(true) |> ignore

            // 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)
            for _ in 1..(Console.BufferWidth / g1.Length) do
                (sbG1.Append(g1)) |> ignore
                (sbG2.Append(g2)) |> ignore

            sbG1.Append(g1, 0, Console.BufferWidth % g1.Length) |> ignore
            sbG2.Append(g2, 0, Console.BufferWidth % g2.Length) |> ignore
            let grid1 = sbG1.ToString()
            let grid2 = sbG2.ToString()

            Console.CursorVisible <- false
            Console.Clear()
            for y in 0..(Console.BufferHeight - 1) do
                if (y % 3 = 0) then
                    Console.Write(grid1)
                else
                    Console.Write(grid2)

            Console.SetWindowPosition(0, 0)

            let interactiveKeySequence = 
                Seq.initInfinite (fun _ -> (Console.ReadKey(true)).Key)
                |> Seq.takeWhile (fun key -> key <> ConsoleKey.Escape)

            for key in interactiveKeySequence do
                match key with
                | ConsoleKey.LeftArrow ->
                    if Console.WindowLeft > 0
                    then Console.SetWindowPosition(Console.WindowLeft - 1, Console.WindowTop)
                | ConsoleKey.UpArrow ->
                    if Console.WindowTop > 0
                    then Console.SetWindowPosition(Console.WindowLeft, Console.WindowTop - 1)
                | ConsoleKey.RightArrow ->
                    if Console.WindowLeft < (Console.BufferWidth - Console.WindowWidth)
                    then Console.SetWindowPosition(Console.WindowLeft + 1, Console.WindowTop)
                | ConsoleKey.DownArrow ->
                    if Console.WindowTop < (Console.BufferHeight - Console.WindowHeight)
                    then Console.SetWindowPosition(Console.WindowLeft, Console.WindowTop + 1)
                | _ -> 
                    ()
            0
        with 
        | :? IOException as ex -> printf "%s" ex.Message; 1
    finally
        Console.Clear()
        Console.SetWindowSize(1, 1)
        Console.SetBufferSize(saveBufferWidth, saveBufferHeight)
        Console.SetWindowSize(saveWindowWidth, saveWindowHeight)
        Console.CursorVisible <- saveCursorVisible

Uwagi

W oknie systemu operacyjnego zostanie wyświetlone okno konsoli, a w oknie konsoli zostanie wyświetlona część buforu ekranu. Metoda SetWindowPosition wpływa na położenie okna konsoli względem buforu ekranu, ale nie wpływa na położenie okna systemu operacyjnego względem pulpitu.

Okna konsoli i systemu operacyjnego zazwyczaj nie wpływają na siebie. Jeśli jednak bufor ekranu nie może być wyświetlany w bieżących granicach okna konsoli, system operacyjny automatycznie dołącza paski przewijania do okna systemu operacyjnego. W takim przypadku przeniesienie pasków przewijania okna systemu operacyjnego wpływa na położenie okna konsoli, a przeniesienie okna konsoli za SetWindowPosition pomocą metody wpływa na położenie pasków przewijania okna systemu operacyjnego.

Dotyczy