Eres libre de usar la forma que veas por conveniente, pero a simple vista para tu caso sencillo donde quieres que no se salga del programa hasta que se presione Enter debería bastar con:

while (Console.ReadKey(true).Key != ConsoleKey.Enter);

Lo que dice Daniel es cierto cuando el  bucle es infinito por diseño: while(true), Así que ahí dependes del cuerpo del while para salir del bucle.

Si nos vamos a las entrañas de una aplicación en .net descompilándolo a IL tenemos:

Caso 1:

while (Console.ReadKey(true).Key != ConsoleKey.Enter);

.method private hidebysig static void  Main() cil managed
{
  .entrypoint
  // Code size       29 (0x1d)
  .maxstack  2
  .locals init ([0] valuetype [mscorlib]System.ConsoleKeyInfo CS$0$0000,
           [1] bool CS$4$0001)
  IL_0000:  nop
  IL_0001:  br.s       IL_0003
  IL_0003:  ldc.i4.1
  IL_0004:  call       valuetype [mscorlib]System.ConsoleKeyInfo [mscorlib]System.Console::ReadKey(bool)
  IL_0009:  stloc.0
  IL_000a:  ldloca.s   CS$0$0000
  IL_000c:  call       instance valuetype [mscorlib]System.ConsoleKey [mscorlib]System.ConsoleKeyInfo::get_Key()
  IL_0011:  ldc.i4.s   13
  IL_0013:  ceq
  IL_0015:  ldc.i4.0
  IL_0016:  ceq
  IL_0018:  stloc.1
  IL_0019:  ldloc.1
  IL_001a:  brtrue.s   IL_0003
  IL_001c:  ret
} // end of method Program::Main

Caso 2:

while (true) {
  if (Console.ReadKey(true).Key == ConsoleKey.Enter) { break; }
}

.method private hidebysig static void  Main() cil managed
{
  .entrypoint
  // Code size       38 (0x26)
  .maxstack  2
  .locals init ([0] valuetype [mscorlib]System.ConsoleKeyInfo CS$0$0000,
           [1] bool CS$4$0001)
  IL_0000:  nop
  IL_0001:  br.s       IL_0021
  IL_0003:  nop
  IL_0004:  ldc.i4.1
  IL_0005:  call       valuetype [mscorlib]System.ConsoleKeyInfo [mscorlib]System.Console::ReadKey(bool)
  IL_000a:  stloc.0
  IL_000b:  ldloca.s   CS$0$0000
  IL_000d:  call       instance valuetype [mscorlib]System.ConsoleKey [mscorlib]System.ConsoleKeyInfo::get_Key()
  IL_0012:  ldc.i4.s   13
  IL_0014:  ceq
  IL_0016:  ldc.i4.0
  IL_0017:  ceq
  IL_0019:  stloc.1
  IL_001a:  ldloc.1
  IL_001b:  brtrue.s   IL_0020
  IL_001d:  nop
  IL_001e:  br.s       IL_0025
  IL_0020:  nop
  IL_0021:  ldc.i4.1
  IL_0022:  stloc.1
  IL_0023:  br.s       IL_0003
  IL_0025:  ret
} // end of method Program::Main
 

- He resaltado la parte que es idéntica en ambos casos (los nop se ignoran porque no hacen nada (NOP = No Operation)), solo queda analizar que hace la parte no resaltada del segundo caso:

En la línea 21 del primer caso y 22 del segundo caso hacen el salto si la tecla presionada es Enter, es decir, eso debería de hacer que se salga del bucle

- En el primer caso salta a IL_0003 que es el inicio del bucle así que es muy sencillo entender que el bucle se volverá a ejecutar, si no salta, simplemente hace un RET para salir del bucle

- En el segundo caso salta a IL_0020 que es un NOP, este no hace nada, así que pasamos a la siguiente instrucción IL_0021,  IL_0022 y IL_0023 donde ponen en la memoria (stack) 1, luego recuperan ese 1, y finalmente saltan incondicionalmente (si o si porque no comprueban nada) a IL_003 que es el inicio del bucle.

-- Si la tecla no fue Enter ejecutamos IL_001d que nuevamente es un NOP así que pasamos a IL_001e el cual es un salto incondicional a IL_0025, ahora bien, en IL_0025 está el RET para salir del bucle

Conclusión: El caso 1 es exactamente igual al caso dos, el caso dos es lo mismo salvo que hace otras otras inútiles, como NOP, poner valores en el stack, recuperarlas pero no hace absolutamente nada con ellas, salta a otros sitios que tampoco hacen nada, es decir, solo tiene código extra de relleno.

Por cierto he utilizado ildasm.exe para abrir el .exe generado y obtener su código IL que es al final lo que interpreta .NET, en mi caso lo tengo en C:\Program Files\Microsoft SDKs\Windows\v6.0A\bin\ildasm.exe

Si todo lo anterior resulta un poquito complicado de entender se puede usar una herramienta más amigable para obtener el código IL que va a interpretar finalmente .NET, por ejemplo ILSpy: https://github.com/icsharpcode/ILSpy para mi siguiente ejemplo usaré una versión más viejita: https://github.com/icsharpcode/ILSpy/releases/download/v7.2.1/ILSpy_binaries_7.2.1.6856.zip que es compatible con .NET 4.7, las nuevas versiones requieren .NET 8

Los siguientes casos son como interpreta ILSpy el .exe generado, para estos casos obviare el IL puro porque ya lo expliqué antes, solo me centraré a la decompilación C# que obtiene ILSpy:

Caso 1 por ILSpy:

// cprb.Program
using System;
 
private static void Main()
{
	while (Console.ReadKey(intercept: true).Key != ConsoleKey.Enter)
	{
	}
}
 

Caso 2 por ILSpy:

// cprb.Program
using System;
 
private static void Main()
{
	do
	{
		bool flag = true;
	}
	while (Console.ReadKey(intercept: true).Key != ConsoleKey.Enter);
}
 

- Bueno, es obvio que el primer caso se parece más al ejemplo que entrega Microsoft con las {} al final, aunque el código original del caso uno no los tiene y en su lugar le puse ;

- El segundo caso, se interpreta como un do while, PERO el cuerpo de este no hace nada, es decir, crea una variable flag que pone a true pero no hace nada con ella, luego está la condicional del do while que es exáctamente igual al Caso 1.

---
Como extra también pongo las instrucciones finales C# interpretado y IL para el aporte que acaba de por Aincrad:

Original:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace cprb {
  class Program {
    static void Main() {
      Menu();
    }
 
    private static bool Menu() {
      if (Console.ReadKey(true).Key == ConsoleKey.Enter) {
        return true;
      } else {
        return Menu();
      }
    }
 
  }
}
 

Interpretación C# por ILSpy:

using System;
 
internal class Program
{
	private static void Main()
	{
		Menu();
	}
 
	private static bool Menu()
	{
		if (Console.ReadKey(intercept: true).Key == ConsoleKey.Enter)
		{
			return true;
		}
		return Menu();
	}
}
 

Decompilación IL por ILSpy:

.class private auto ansi beforefieldinit cprb.Program
	extends [mscorlib]System.Object
{
	// Methods
	.method private hidebysig static 
		void Main () cil managed 
	{
		// Method begins at RVA 0x2050
		// Header size: 1
		// Code size: 8 (0x8)
		.maxstack 8
		.entrypoint
 
		IL_0000: nop
		IL_0001: call bool cprb.Program::Menu()
		IL_0006: pop
		IL_0007: ret
	} // end of method Program::Main
 
	.method private hidebysig static 
		bool Menu () cil managed 
	{
		// Method begins at RVA 0x205c
		// Header size: 12
		// Code size: 42 (0x2a)
		.maxstack 2
		.locals init (
			[0] bool,
			[1] valuetype [mscorlib]System.ConsoleKeyInfo,
			[2] bool
		)
 
		IL_0000: nop
		IL_0001: ldc.i4.1
		IL_0002: call valuetype [mscorlib]System.ConsoleKeyInfo [mscorlib]System.Console::ReadKey(bool)
		IL_0007: stloc.1
		IL_0008: ldloca.s 1
		IL_000a: call instance valuetype [mscorlib]System.ConsoleKey [mscorlib]System.ConsoleKeyInfo::get_Key()
		IL_000f: ldc.i4.s 13
		IL_0011: ceq
		IL_0013: ldc.i4.0
		IL_0014: ceq
		IL_0016: stloc.2
		IL_0017: ldloc.2
		IL_0018: brtrue.s IL_001f
 
		IL_001a: nop
		IL_001b: ldc.i4.1
		IL_001c: stloc.0
		IL_001d: br.s IL_0028
 
		IL_001f: nop
		IL_0020: call bool cprb.Program::Menu()
		IL_0025: stloc.0
		IL_0026: br.s IL_0028
 
		IL_0028: ldloc.0
		IL_0029: ret
	} // end of method Program::Menu
 
	.method public hidebysig specialname rtspecialname 
		instance void .ctor () cil managed 
	{
		// Method begins at RVA 0x2092
		// Header size: 1
		// Code size: 7 (0x7)
		.maxstack 8
 
		IL_0000: ldarg.0
		IL_0001: call instance void [mscorlib]System.Object::.ctor()
		IL_0006: ret
	} // end of method Program::.ctor
 
} // end of class cprb.Program

---
Una vez Tachikomaia preguntó sobre la optimización de su código o porque no le funcionaban bien algunas instrucciones que requieren redondeo, en su caso el usa Flash 5 y yo comenté que podría usar JPEXS Free Flash Decompiler https://github.com/jindrapetrik/jpexs-decompiler para obtener el código final interpretado y el P-Code de sus .swf, esto es lo mismo que usar ILSpy para los .exe de .NET, con estos programas se puede ver que es lo que se ejecuta finalmente

El While usa una condición, es decir,  ya tiene un "if" incluido, al menos yo no creo que haya problemas con eso.

Si lo que quieres es tal cual han entendido Daniel y Tachikomaia te debería bastar con:

while (Console.ReadKey(true).Key != ConsoleKey.Enter);

- Nótese que no lleva cuerpo ({...}) y directamente termina con ;
- Ese es el ejemplo que muestra la ayuda de mi viejo Visual Studio 2008

En la Ayuda actual https://learn.microsoft.com/es-es/dotnet/api/system.console.readkey?view=net-8.0 muestra como ejemplo:

while (Console.ReadKey(true).Key != ConsoleKey.Enter) {}

- De todas maneras también utiliza la forma que yo comenté un poquito más abajo, en otro ejemplo muestra:

do {
  // ...
} while (cki.Key != ConsoleKey.Escape);

Así que yo estimo que ambas formas están bien, yo me quedo con el ; al final en lugar de las dos llaves, porque siempre debe haber una u otra, sino interpretará como cuerpo del while la siguiente línea. Los siguientes ejemplo son válido y se usa cuando el cuerpo de la estructura (while, do while, for, if, etc) solo consta de una sola instrucción/línea:

Ejemplo 1:

while (Console.ReadKey(true).Key != ConsoleKey.Enter) Console.Write("No has tecleado Enter");
Console.Write("Ya estás fuera del While");

- Lo anterior se ve bastante en if sencillos como si fuera el operador ternario, estas dos líneas hacen exactamente lo mismo:

if(x != 0.0) s = Math.Sin(x)/x; else s = 1.0;
 
s = x != 0.0 ? Math.Sin(x)/x : 1.0;

Ejemplo 2:

while (Console.ReadKey(true).Key != ConsoleKey.Enter)
  Console.Write("No has tecleado Enter");
Console.Write("Ya estás fuera del While");

- Lo anterior se ve bastante en for anidados como los típicos para aplicar fuerza bruta, recorrer arrays dentro de arrays,

public static void Main() {
 
  int tabla, numero;
 
  for (tabla = 1; tabla <= 5; tabla++)
    for (numero = 1; numero <= 10; numero++)
      Console.WriteLine("{0} por {1} es {2}", tabla, numero, tabla*numero);
}

Claro, pero siempre depende de lo que se vaya a hacer, algunas cosas son más simples de hacer en Batch, otras con VBS y otras PowerShell, igualmente se pueden crear interfaces gráficas con VBS + MSHTA y ahora con PowerShell.

PowerShell tiene detrás a .Net con sintaxis C# así que se le puede sacar bastante, su única pega es que tarda unos segundos más en su primer arranque mientras que Batch o VBS inician inmediatamente.

En español no hay mucho material PowerShell que yo haya visto y pueda recomendar, videos en YouTube si hay bastante, yo recomendaría ver unos cuantos videos y seguir este buen libro en español, pero ojo que está traducido, la mayoría está bien pero hay algunas cositas que no debieron traducir como gato (cat), tipo (type), pie (ft), florida (fl), eco (echo), claro (clear), etc, jeje uno se da cuenta y/o siempre se puede aclarar con la versión en Inglés:

PowerShell libro versión en español:
https://riptutorial.com/download/powershell-es.pdf

PowerShell libro versión en inglés:
https://riptutorial.com/download/powershell.pdf

Solo tienes que hacer tu plantilla y contar cuadritos (caracteres) ya que estás trabajando con una fuente monoespaciada

Plantilla:


- Los porcentajes irían desde el 0 al 100, es decir 101 valores posibles
- La barra al 100% tiene 51 caracteres

Ahora en tu diseño pones un Label para las dos primeras líneas, luego pones otro Label más para la tercera línea (la barra), los cuadras para que se vea bien y listo, ya solo queda poner el código:

using System;
using System.Drawing;
using System.Threading;
using System.Windows.Forms;
 
namespace BarraDeProgreso {
  public partial class Form1 : Form {
    public Form1() {
      InitializeComponent();
    }
 
    private void Form1_Load(object sender, EventArgs e) {
      label_Barra_de_progreso.Text = ""; //Vaciar la barra
    }
 
    private void button_Enter_Click(object sender, EventArgs e) {
 
      int valor = int.Parse(textBox1.Text); //Valor introducido
      int valor_barra = valor * 51 / 101; //Cálculo del tamaño de la barra
 
      if (valor <= 15) {
        label_Barra_de_progreso.ForeColor = Color.Red;
      } else if (valor <= 40) {
        label_Barra_de_progreso.ForeColor = Color.Yellow;
      } else if (valor <= 100) {
        label_Barra_de_progreso.ForeColor = Color.Green;
      }
 
      label_Barra_de_progreso.Text = "";
      for (int i = 0; i <= valor_barra; i++) {
        label_Barra_de_progreso.Text += "@"; //Inserta un cuadrito más a la barra
        label_Barra_de_progreso.Refresh(); //Necesario refrescar para ver el cambio
        Thread.Sleep(10);
      }
 
    }
 
  }
}
 

- Reemplaza el "@" de la línea 31 por "█", GeSHi se fastidia si se le ponen caracteres raros XD
- En la línea 19 estoy utilizando los valores 51 y 101 que calculé gracias a la plantilla

  pero te lo puse en mi mensaje anterior 

Para tu último mensaje sería:

Console.WriteLine(resultadoPorcentaje.ToString("0.##") + " %.");

Saludos,

Simplemente debes formatear tu texto, me parece que ya en otro mensaje solucionaste algo similar con formato: https://foro.elhacker.net/net_c_vbnet_asp/ceros_a_la_derecha-t520083.0.html;msg2277390#msg2277390

Acá muestro una pequeña implementación que hice para hacer la prueba:






En las líneas 11 al 13 estoy utilizando Format para obtener una String que me muestre al menos un número (0), luego los decimales pueden ser dos PERO se mostraran solo si no son cero (.##)

---
GeSHi me cambia los caracteres, optaré por ponerlo como código normal

No he usado mucho Windows 7 pero que yo sepa siempre funcionó igual, Alt + Tab debería poder intercambiarte entre las dos ventanas vistas más recientemente. Puedes presionar Alt + Tab pero sin soltar el Alt para seguir presionando Tab e ir a otra ventana, entonces esto lo puedes hacer para tener como dos últimas ventanas las que quieras y el simple Alt + Tab debería intercambiar entre ellas.

Usa Alt + Tab, Tab, ... para avanzar a la siguiente/s ventanas, usa Alt + Shift + Tab, Tab, ... para retroceder entre las ventanas.

Una cosa que recuerdo haber visto en Windows 7 es que tenía una animación para intercambiar ventanas que salía con Win + Tab, puede que refieras a esa porque ahí permite mantener esa ventana y elegir con tu ratón la que quieras, en Windows 8 y 10 también funciona de forma similar pero sin animación. De todas maneras te puede servir para ver una primera ventana y luego otra para que Alt + Tab intercambie entre ellas al ser las dos más recientes

A veces suele ser más efectivo ir a la ventana desea con el ratón, ya sea en el listado de ventanas de Win + Tab o dando click en la barra de tareas, yo por ejemplo siempre tengo mi barra de tareas desagrupada para que que se agrupen en cuadritos tener que ir a dicho cuadrito para desplegarlo y elegir la ventana que quiero, muy molestoso.



Incluso pueden servirte los escritorios virtuales o darle más filas a tu barra de tareas para tener todo al alcance de un click

Tal como dice Songoku para reproducir la mayoría de archivos swf debes usar la última versión disponible:

Reproductor Flash Player 32.0.0.465 (normal)
https://fpdownload.macromedia.com/pub/flashplayer/updaters/32/flashplayer_32_sa.exe

Reproductor Flash Player 32.0.0.465 (para depurar)
https://fpdownload.macromedia.com/pub/flashplayer/updaters/32/flashplayer_32_sa_debug.exe

También con ello te proteges de fallos de seguridad hasta ese momento que puedan explotar los swf si no confías en ellos. Aunque si la seguridad no es tan importante lo ideal es usar la misma versión con la que se construyó el swf, si tienes un editor hexadecimal como HxD puedes abrir el swf y ver el cuarto byte que indica la versión de Flash que requiere el archivo, ya que hay versiones que usan características únicas de su versión que luego las quitaron, como por ejemplo la opción de crear y cualquier tipo de archivo con Flash 5, y/o el de ejecutar cualquier programa desde Flash 5

- Lo anterior puede ser una muy grave vulnerabilidad de seguridad o una funcionalidad espectacular como bien lo usa Tachikomaia para guardar y recuperar información, eso es única y exclusívamente de Flash Player 5


- 0F es el hexadecimal de 15, es decir, ese swf fue creado para Flash Player 15, lo ideal es usar esa versión para aprovechar todas las funcionalidades que pueda usar ese swf, o usar una versión superior que tiene compatibilidad para reproducir archivos de versiones anteriores PERO puede que se hayan quitado algunas características y funcionalidades seguridad, obsolescencia o malas prácticas. Si quieres reproducir archivos swf creados con versiones superiores a tu reproductor obviamente será más complicado porque es casi seguro que no soporten las nuevas funcionalidades y versiones de ActionScript

En conclusión, si la Fuente está en posición 2 y a ti te llega 220V la fuente explota XD, yo cuando veo ese interruptor entro en pánico y le echo pegamento porque varias veces ya me ha pasado de que algún gracioso lo mueve y la fuente se transforma en una bomba lacrimógena

La versión es importante para el tutorial o curso que quieras seguir porque el cambio entre ActionScript 1.0, 2.0 y 3.0 es bastante, también las capacidades. Una vez tengas el Flash que quieras avisas para pasarte material para esa versión o compatible