Pas de sortie de console lors de l'utilisation d'AllocConsole et de l'architecture cible x86

J'ai un projet WinForms, et si l'utilisateur veut une console de débogage, j'alloue une console avec AllocConsole().

Toutes les sorties de la console fonctionne normalement avec l'architecture cible définie sur "any CPU", mais quand je l'ai changer pour "x86" il n'a pas de sortie du tout (Console.Read() fonctionne toujours comme prévu). Si j'ouvre le fichier EXE directement les, la sortie fonctionne. Il ressemble à Visual Studio de la réutiliser dans une "Sortie" de la fenêtre.

J'ai aussi essayé cette réponse, mais il ne fonctionne pas, j'ai aussi essayé Console.SetOut(GetStdHandle(-11))qui ne fonctionne pas non plus.

Réglage de l'architecture cible de "any CPU" est pas une option pour moi.

Voici donc mes deux questions:

  • Pourquoi est-ce seulement le cas lorsque l'architecture cible est définie sur x86?
  • Comment puis-je sortie de ma console lors de l'exécution à l'intérieur de Visual Studio?

source d'informationauteur teamalpha5441

  1. 24

    Activer le débogage de code natif" est activée, les sorties de consoles emballé avec AllocConsole est redirigé vers la fenêtre de sortie de débogage à la place.

    La raison pour laquelle cela se produit seulement dans les architectures x86 et pas AnyCPU est parce que vous ne pouvez déboguer du code natif dans un x86 application.

    Notez que ce problème se produit uniquement avec les consoles créé avec AllocConsole. Une application de console de sortie n'est pas redirigé.

    EDIT: L'autre raison pour que la console ne sorte pas de texte, c'est quand vous avez écrit dans la console avant d'appeler AllocConsole.

    Quelle que soit la raison, ce code permettra de restaurer sortie si il a été redirigé, et rouvrez la console dans le cas où il est invalide. Il utilise le nombre magique 7, qui est ce que la poignée de stdout est généralement.

    using System;
using System.IO;
using System.Runtime.InteropServices;

public static class ConsoleHelper
{
    public static void CreateConsole()
    {
        AllocConsole();

        //stdout's handle seems to always be equal to 7
        IntPtr defaultStdout = new IntPtr(7);
        IntPtr currentStdout = GetStdHandle(StdOutputHandle);

        if (currentStdout != defaultStdout)
            //reset stdout
            SetStdHandle(StdOutputHandle, defaultStdout);

        //reopen stdout
        TextWriter writer = new StreamWriter(Console.OpenStandardOutput()) 
        { AutoFlush = true };
        Console.SetOut(writer);
    }

    //P/Invoke required:
    private const UInt32 StdOutputHandle = 0xFFFFFFF5;
    [DllImport("kernel32.dll")]
    private static extern IntPtr GetStdHandle(UInt32 nStdHandle);
    [DllImport("kernel32.dll")]
    private static extern void SetStdHandle(UInt32 nStdHandle, IntPtr handle);
    [DllImport("kernel32")]
    static extern bool AllocConsole();
}

    Voir Comment détecter si la Console.(Stdin) a été redirigée?
    pour une autre façon de détecter si la console gère avez été redirigé.

  2. 5

    La suite travaillé pour moi de vs 2015, aucun n'a fonctionné à partir d'autres réponses:

    Source: https://social.msdn.microsoft.com/profile/dmitri567/?ws=usercard-mini

    using System;   
using System.Windows.Forms;   
using System.Text;   
using System.IO;   
using System.Runtime.InteropServices;   
using Microsoft.Win32.SafeHandles;   
namespace WindowsApplication   
{   
static class Program   
{   
[DllImport("kernel32.dll",   
EntryPoint = "GetStdHandle",   
SetLastError = true,   
CharSet = CharSet.Auto,   
CallingConvention = CallingConvention.StdCall)]   
private static extern IntPtr GetStdHandle(int nStdHandle);   
[DllImport("kernel32.dll",   
EntryPoint = "AllocConsole",   
SetLastError = true,   
CharSet = CharSet.Auto,   
CallingConvention = CallingConvention.StdCall)]   
private static extern int AllocConsole();   
private const int STD_OUTPUT_HANDLE = -11;   
private const int MY_CODE_PAGE = 437;   
static void Main(string[] args)   
{   
Console.WriteLine("This text you can see in debug output window.");   
AllocConsole();   
IntPtr stdHandle=GetStdHandle(STD_OUTPUT_HANDLE);   
SafeFileHandle safeFileHandle = new SafeFileHandle(stdHandle, true);   
FileStream fileStream = new FileStream(safeFileHandle, FileAccess.Write);   
Encoding encoding = System.Text.Encoding.GetEncoding(MY_CODE_PAGE);   
StreamWriter standardOutput = new StreamWriter(fileStream, encoding);   
standardOutput.AutoFlush = true;   
Console.SetOut(standardOutput);   
Console.WriteLine("This text you can see in console window.");   
MessageBox.Show("Now I'm happy!");   
}   
}   
}
  3. 4

    J'ai aussi eu ce problème. Chaque fois que j'ai essayé de déboguer mon application, la console était vide. Étrangement, le lancement de l'exe sans le débogueur a bien fonctionné.

    J'ai trouvé que j'avais à Enable the Visual Studio hosting process du projet Debug menu.

    Stephen est exact que Enable native code debugging ne redirection de la console de la fenêtre de Sortie. Cependant, quel que soit le natif de débogage de code paramètre, j'ai vu absolument aucune sortie dans un lieu jusqu'à ce que j'ai activé le processus d'hébergement Visual Studio.

    Ce qui pourrait avoir été la raison que le simple fait de désactiver le débogage de code natif ne parvenez pas à résoudre votre problème.

  4. 0

    Aucune des précédentes réponses a bien fonctionné pour moi avec VS2017 et Windows 10 (par exemple ils n'ont pas si lancer l'application en mode debug).

    Ci-dessous vous pouvez trouver un peu améliorée code. L'idée est la même, mais les nombres magiques sont supprimés (Ceztko déjà mentionné) et tout le nécessaire\des cours d'eau sont initialisés.

    Ce code fonctionne pour moi si créer une nouvelle console (alwaysCreateNewConsole = true).

    Fixation à la console de processus parent (alwaysCreateNewConsole = false) comporte plusieurs inconvénients. Pour exemple, j'ai été incapable de complètement imiter le comportement de l'application console lancé à partir de cmd. Et je ne suis pas sûr qu'il est possible à tous.

    Et le plus important: après la révision de Console de classe j'ai reconsidéré idée générale de l'utilisation de la Console de classe avec créé manuellement la console. Il fonctionne bien (je l'espère) pour la plupart des cas, mais peut apporter beaucoup de douleur dans l'avenir.

        static class WinConsole
{
static public void Initialize(bool alwaysCreateNewConsole = true)
{
bool consoleAttached = true;
if (alwaysCreateNewConsole
|| (AttachConsole(ATTACH_PARRENT) == 0
&& Marshal.GetLastWin32Error() != ERROR_ACCESS_DENIED))
{
consoleAttached = AllocConsole() != 0;
}
if (consoleAttached)
{
InitializeOutStream();
InitializeInStream();
}
}
private static void InitializeOutStream()
{
var fs = CreateFileStream("CONOUT$", GENERIC_WRITE, FILE_SHARE_WRITE, FileAccess.Write);
if (fs != null)
{
var writer = new StreamWriter(fs) { AutoFlush = true };
Console.SetOut(writer);
Console.SetError(writer);
}
}
private static void InitializeInStream()
{
var fs = CreateFileStream("CONIN$", GENERIC_READ, FILE_SHARE_READ, FileAccess.Read);
if (fs != null)
{
Console.SetIn(new StreamReader(fs));
}
}
private static FileStream CreateFileStream(string name, uint win32DesiredAccess, uint win32ShareMode,
FileAccess dotNetFileAccess)
{
var file = new SafeFileHandle(CreateFileW(name, win32DesiredAccess, win32ShareMode, IntPtr.Zero, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, IntPtr.Zero), true);
if (!file.IsInvalid)
{
var fs = new FileStream(file, dotNetFileAccess);
return fs;
}
return null;
}
#region Win API Functions and Constants
[DllImport("kernel32.dll",
EntryPoint = "AllocConsole",
SetLastError = true,
CharSet = CharSet.Auto,
CallingConvention = CallingConvention.StdCall)]
private static extern int AllocConsole();
[DllImport("kernel32.dll",
EntryPoint = "AttachConsole",
SetLastError = true,
CharSet = CharSet.Auto,
CallingConvention = CallingConvention.StdCall)]
private static extern UInt32 AttachConsole(UInt32 dwProcessId);
[DllImport("kernel32.dll",
EntryPoint = "CreateFileW",
SetLastError = true,
CharSet = CharSet.Auto,
CallingConvention = CallingConvention.StdCall)]
private static extern IntPtr CreateFileW(
string lpFileName,
UInt32 dwDesiredAccess,
UInt32 dwShareMode,
IntPtr lpSecurityAttributes,
UInt32 dwCreationDisposition,
UInt32 dwFlagsAndAttributes,
IntPtr hTemplateFile
);
private const UInt32 GENERIC_WRITE = 0x40000000;
private const UInt32 GENERIC_READ = 0x80000000;
private const UInt32 FILE_SHARE_READ = 0x00000001;
private const UInt32 FILE_SHARE_WRITE = 0x00000002;
private const UInt32 OPEN_EXISTING = 0x00000003;
private const UInt32 FILE_ATTRIBUTE_NORMAL = 0x80;
private const UInt32 ERROR_ACCESS_DENIED = 5;
private const UInt32 ATTACH_PARRENT = 0xFFFFFFFF;
#endregion
}