none
Using "Console.Write(...)" to write special characters RRS feed

  • Pergunta

  • I'm using VS2013, I wanted to use the Console to print letters like (ç, ã, á) with the method " Console.Write(...) ". When using Form Projects I never had problem using those special characters at VS2013, but in Console Projects I'm not being able to use those characters correctly. Would some of you know what to do?
    quinta-feira, 2 de janeiro de 2014 12:21

Respostas

  • Você copiou a classe estática Kernel32?

    Deve ter faltado copiar alguma coisa ai, pois eu postei o código todo na íntegra...


    Herbert Lausmann

    • Marcado como Resposta Nicpeterl sábado, 4 de janeiro de 2014 00:38
    sexta-feira, 3 de janeiro de 2014 14:13

Todas as Respostas

  • Hello Nicpeterl,

    This is the MSDN-BR forun and the used language here is Portuguese - BR. This make the foruns a better place for Brazilian users and makes easier to understand your problem, since not everybody here speaks english

    If you you need or prefer to ask questions in english, please use the MSDN - US or another MSDN forun with use the English Language.

    Answering your question, what are being returned to you when you try to print these characteres?

    Using the following code i'm able to print specials characters in c# console application:
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    
    namespace ConsoleApplication31
    {
        class Program
        {
            static void Main(string[] args)
            {
                Console.Write("á, ç");
                Console.ReadKey();
            }
        }
    }

    Regards,


    Giovani Cruzara – Microsoft Contingent Staff

    Esse conteúdo é fornecido sem garantias de qualquer tipo, seja expressa ou implícita.

    Msdn Community Support

    Por favor, lembre-se de “Marcar como Resposta” as respostas que resolveram o seu problema. Essa é uma maneira comum de reconhecer aqueles que o ajudaram e fazer com que seja mais fácil para os outros visitantes encontrarem a resolução mais tarde.

    quinta-feira, 2 de janeiro de 2014 13:35
  • Olá! Desculpe por escrever em um forum PT-BR, eu consigo entender português também. Então, a seguinte instrução no VS2013: Retona caracteres gregos minúsculos.

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    
    namespace ConsoleApplication31
    {
        class Program
        {
            static void Main(string[] args)
            {
                Console.Write("á, ç");
                Console.ReadKey();
            }
        }
    }

    quinta-feira, 2 de janeiro de 2014 14:47
  • Olá,

    Pelo jeito é a codificação definida no console que está errada. Veja se assim funciona:

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    
    namespace ConsoleApplication31
    {
        class Program
        {
            static void Main(string[] args)
            {
                Console.OutputEncoding = Encoding.UTF8;
                Console.Write("á, ç");
                Console.ReadKey();
            }
        }
    }

    Espero ter ajudado.


    Herbert Lausmann

    quinta-feira, 2 de janeiro de 2014 14:53
  • Olá, gerou outros caracteres, mas não é o desejado ainda. Eles se parecem com " |-í, |-ú ".

    quinta-feira, 2 de janeiro de 2014 14:57
  • Experimenta outras condificações. Exemplo:

    Console.OutputEncoding = Encoding.UTF8;
    
    Console.OutputEncoding = Encoding.BigEndianUnicode;
    
    Console.OutputEncoding = Encoding.Unicode;
    
    Console.OutputEncoding = Encoding.UTF32;
    
    Console.OutputEncoding = Encoding.UTF7;
    
    Console.OutputEncoding = Encoding.ASCII;

    Não me lembro qual é a codificação certa. Teste cada uma e veja se funciona.

    Dê uma olhada neste link também.


    Herbert Lausmann


    quinta-feira, 2 de janeiro de 2014 15:06
  • Testei logo que em seguida e 2 geraram outros tipos de caracteres enquanto outras 4 deixaram nada escrito na saída.
    quinta-feira, 2 de janeiro de 2014 15:07
  • é essa 

    Console.OutputEncoding = Encoding.Unicode;


    Fulvio Cezar Canducci Dias

    quinta-feira, 2 de janeiro de 2014 15:24
  • Sei que deveria ser esta, mas simplesmente estes caracteres são os que aparecem quando sem especificar o tipo de output saem pelo método. Carateres gregos aqui são apresentados seja sem o

    Console.OutputEncoding = Encoding.Unicode;

    ou mesmo com ele.

    Enquanto aos demais, nenhum resolve esta saída.

    Imagino que isto seja alguma configuração padrão do VS2013, mas não tenho pplena certeza, afinal fazia certo tempo que não usava projetos em Console.

    quinta-feira, 2 de janeiro de 2014 15:35
  • Sei que deveria ser esta, mas simplesmente estes caracteres são os que aparecem quando sem especificar o tipo de output saem pelo método. Carateres gregos aqui são apresentados seja sem o

    Console.OutputEncoding = Encoding.Unicode;

    ou mesmo com ele.

    Enquanto aos demais, nenhum resolve esta saída.

    Imagino que isto seja alguma configuração padrão do VS2013, mas não tenho pplena certeza, afinal fazia certo tempo que não usava projetos em Console.

    No meu console ficou certo !!!

    Fulvio Cezar Canducci Dias

    quinta-feira, 2 de janeiro de 2014 15:37
  • O que poderia ser senão fosse isto?Achas que a reinstalação do VS2013 seja necessária?

    Fato é que mudei para ele faz 1 mês e não alterei nenhuma configuração padrão de seu funcionamento.

    quinta-feira, 2 de janeiro de 2014 15:41
  • O que poderia ser senão fosse isto?Achas que a reinstalação do VS2013 seja necessária?

    Fato é que mudei para ele faz 1 mês e não alterei nenhuma configuração padrão de seu funcionamento.

    Poderia tentar uma nova instalação!

     mas, sei lá!!!

    Se tem o código?


    Fulvio Cezar Canducci Dias

    quinta-feira, 2 de janeiro de 2014 15:52
  • Sim, eu o tenho mas não é nada de diferente.

    Na realidade eu criei um Projeto Console antes e então observei que meus caracteres especiais estavam estranhos, mas unicamente ao usar o Console (Outros projetos e outras linguagens etavam sem problemas).

    Então criei um Projeto qualqwuer para pesquisar a solução ontem, mas não parece ser um problema comum de se acontecer pois não encontrei quase nenhuma informação sobre este tipo de problema.

    O código exato segue abaixo:

    using System;using System.Collections.Generic;using System.Linq;

    using System.Text;

    using System.Threading.Tasks;

    namespace ConsoleApplication1

    { class Program

    {

    static void Main(string[] args)

    {

    Console.OutputEncoding = Encoding.Unicode;           

    Console.Write("teste: ç, ã");           

    Console.ReadKey();       

    }   

    }

    }


    quinta-feira, 2 de janeiro de 2014 15:59
  • O que poderia ser senão fosse isto?Achas que a reinstalação do VS2013 seja necessária?

    Fato é que mudei para ele faz 1 mês e não alterei nenhuma configuração padrão de seu funcionamento.

    Definitivamente, não!

    Acabei de descobrir o que é: A fonte usada pelo console não suporta caracteres especiais. A codificação correta seria a Unicode ou UTF8, mas é preciso alterar a fonte do console para que os caracteres sejam exibidos corretamente.


    Herbert Lausmann

    quinta-feira, 2 de janeiro de 2014 16:02
  • O que poderia ser senão fosse isto?Achas que a reinstalação do VS2013 seja necessária?

    Fato é que mudei para ele faz 1 mês e não alterei nenhuma configuração padrão de seu funcionamento.

    Definitivamente, não!

    Acabei de descobrir o que é: A fonte usada pelo console não suporta caracteres especiais. A codificação correta seria a Unicode ou UTF8, mas é preciso alterar a fonte do console para que os caracteres sejam exibidos corretamente.


    Herbert Lausmann

    Verdade ... tem isso também!


    Fulvio Cezar Canducci Dias

    quinta-feira, 2 de janeiro de 2014 16:03
  • Entendo, como devo proceder para alterar a fonte de meu console?
    quinta-feira, 2 de janeiro de 2014 16:04
  • Entendo, como devo proceder para alterar a fonte de meu console?

    Cara,

    Vai ser preciso chamar uma função da API do Windows. A SetCurrentConsoleFontEx.

    E tem mais, só vai funcionar no Windows Vista ou mais novo.

    No caso, a fonte correta para a exibição dos caracteres é a Consolas.



    Herbert Lausmann


    • Editado Herbert Lausmann quinta-feira, 2 de janeiro de 2014 16:17 Complementação
    quinta-feira, 2 de janeiro de 2014 16:08
  • Tens certeza da aplicação desta função em C#?

    A sintaxe apenas diz como implementar em VSC++.

    quinta-feira, 2 de janeiro de 2014 16:21
  • É isso aí mesmo.

    Estou com um tempo livre agora, vou tentar implementar o uso dela em C#. Quando eu tiver alguma coisa eu posto aqui.


    Herbert Lausmann

    quinta-feira, 2 de janeiro de 2014 16:31
  • Obrigado pela ajuda cara.
    quinta-feira, 2 de janeiro de 2014 16:32
  • Boas amigo,

    Consegui implementar o código em C#. Funcionou perfeitamente aqui (Uso o Windows 7 Home Basic)

    Adicione um arquivo de código em branco no seu projeto e cole o código abaixo:

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Runtime.InteropServices;
    
    // Useful Links
    //http://www.pinvoke.net/default.aspx/kernel32/SetCurrentConsoleFontEx.html
    //http://www.pinvoke.net/default.aspx/kernel32.GetStdHandle
    //http://www.pinvoke.net/default.aspx/Constants/INVALID_HANDLE_VALUE.html
    //http://www.pinvoke.net/default.aspx/kernel32/GetCurrentConsoleFontEx.html
    
    //http://social.msdn.microsoft.com/Forums/vstudio/en-US/2bffea84-e5a0-4fde-bd24-53cbcf1e3025/set-font-text-in-console-application?forum=vclanguage
    //http://msdn.microsoft.com/en-us/library/windows/desktop/ms683177(v=vs.85).aspx
    //http://msdn.microsoft.com/en-us/library/windows/desktop/ms686200(v=vs.85).aspx
    //http://msdn.microsoft.com/en-us/library/windows/desktop/ms682069(v=vs.85).aspx
    //http://msdn.microsoft.com/en-us/library/windows/desktop/ms683231(v=vs.85).aspx
    
    public static class ConsoleFont
    {
    
        #region P/Invoke
    
        [DllImport("kernel32.dll", SetLastError = true)]
        private static extern bool SetCurrentConsoleFontEx(
            [In] IntPtr hConsoleOutput,
            [In] bool bMaximumWindow,
            [In, Out] ref CONSOLE_FONT_INFOEX lpConsoleCurrentFont
            );
    
        [DllImport("kernel32.dll", SetLastError = true)]
        private static extern IntPtr GetStdHandle([In] int nStdHandle);
    
        [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
        private extern static bool GetCurrentConsoleFontEx([In] IntPtr hConsoleOutput, [In] bool bMaximumWindow, [In, Out] ref CONSOLE_FONT_INFOEX lpConsoleCurrentFont);
    
        [StructLayout(LayoutKind.Sequential)]
        private struct COORD
        {
            public short X;
            public short Y;
    
            public COORD(short X, short Y)
            {
                this.X = X;
                this.Y = Y;
            }
        };
    
        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
        private struct CONSOLE_FONT_INFOEX
        {
            public uint cbSize;
            public uint nFont;
            public COORD dwFontSize;
            public uint FontFamily;
            public uint FontWeight;
    
            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
            public string FaceName;
        }
    
        private const int STD_OUTPUT_HANDLE = -11;
    
        private const int STD_INPUT_HANDLE = -10;
    
        private const int STD_ERROR_HANDLE = -12;
    
        private const int INVALID_HANDLE_VALUE = -1;
    
        #endregion
    
        #region Public Members
    
        /// <summary>
        /// Set console font.
        /// </summary>
        /// <param name="Name">The name of font. Can be Consolas or Lucida Console.</param>
        /// <param name="X">The Width of font</param>
        /// <param name="Y">The Height of font</param>
        /// <returns>If fails, returns false.</returns>
        public static bool SetConsoleFont(string Name, short X, short Y, bool Bold)
        {
            IntPtr handle = GetStdHandle(STD_OUTPUT_HANDLE);
    
            if ((handle.ToInt64() == INVALID_HANDLE_VALUE) || (handle.ToInt32() == STD_ERROR_HANDLE)) return false;
    
            CONSOLE_FONT_INFOEX fontInfo = new CONSOLE_FONT_INFOEX();
            fontInfo.cbSize = (uint)Marshal.SizeOf(typeof(CONSOLE_FONT_INFOEX));
    
            bool sucessed = GetCurrentConsoleFontEx(handle, false, ref fontInfo);
    
            if (sucessed == false) return false;
    
            fontInfo.FontWeight = 400;
            if (Bold) fontInfo.FontWeight = 700;
    
            fontInfo.dwFontSize = new COORD(X, Y);
            fontInfo.FaceName = Name;
    
            return SetCurrentConsoleFontEx(handle, false, ref fontInfo);
        }
    
        #endregion
    
    }

    Abaixo um exemplo de como usar o código:

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    
    namespace Special_Characters_Console
    {
        class Program
        {
            static void Main(string[] args)
            {
                Console.OutputEncoding = Encoding.Unicode;
                ConsoleFont.SetConsoleFont("Consolas", 8, 12, false);
                Console.WriteLine("Testando 123");
                Console.WriteLine("ã â @$#%¨&*()&¨%$#");
                Console.ReadKey();
            }
        }
    }

    Veja se funciona ai. Lembrando que só irá funcionar no Windows Vista e mais novos.


    Herbert Lausmann

    quinta-feira, 2 de janeiro de 2014 20:00
  • Olá amigo, deu trabalho isto, não?

    Infelizmente o VS2013 não reconheceu a instrução:

    " DllImport " nem " Struct Layout " e " MarshalAs".

    Uso Windows 7 Profissional - 32 bits.

    quinta-feira, 2 de janeiro de 2014 23:49
  • Você deve ter esquecido de incluir a diretiva using System.Runtime.InteropServices; no topo do arquivo...

    Eu continuei brincando com esse troço a título de curiosidade, e melhorei um pouco o código:

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Runtime.InteropServices;
    
    // Links úteis
    //http://www.pinvoke.net/default.aspx/kernel32/SetCurrentConsoleFontEx.html
    //http://www.pinvoke.net/default.aspx/kernel32.GetStdHandle
    //http://www.pinvoke.net/default.aspx/Constants/INVALID_HANDLE_VALUE.html
    //http://www.pinvoke.net/default.aspx/kernel32/GetCurrentConsoleFontEx.html
    
    //http://social.msdn.microsoft.com/Forums/vstudio/en-US/2bffea84-e5a0-4fde-bd24-53cbcf1e3025/set-font-text-in-console-application?forum=vclanguage
    //http://msdn.microsoft.com/en-us/library/windows/desktop/ms683177(v=vs.85).aspx
    //http://msdn.microsoft.com/en-us/library/windows/desktop/ms686200(v=vs.85).aspx
    //http://msdn.microsoft.com/en-us/library/windows/desktop/ms682069(v=vs.85).aspx
    //http://msdn.microsoft.com/en-us/library/windows/desktop/ms683231(v=vs.85).aspx
    
    public static class ConsoleHelper
    {
    
        #region P/Invoke
    
        public static class Kernel32
        {
    
            [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
            public static extern bool SetCurrentConsoleFontEx(
                [In] IntPtr hConsoleOutput,
                [In] bool bMaximumWindow,
                [In, Out] ref CONSOLE_FONT_INFOEX lpConsoleCurrentFont
                );
    
            [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
            public static extern IntPtr GetStdHandle([In] int nStdHandle);
    
            [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
            public extern static bool GetCurrentConsoleFontEx([In] IntPtr hConsoleOutput, [In] bool bMaximumWindow, [In, Out] ref CONSOLE_FONT_INFOEX lpConsoleCurrentFont);
    
            [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
            public struct COORD
            {
                public short X;
                public short Y;
    
                public COORD(short X, short Y)
                {
                    this.X = X;
                    this.Y = Y;
                }
            };
    
            [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
            public struct CONSOLE_FONT_INFOEX
            {
                public uint cbSize;
                public uint nFont;
                public COORD dwFontSize;
                public uint FontFamily;
                public uint FontWeight;
    
                [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
                public string FaceName;
            }
    
            public const int STD_OUTPUT_HANDLE = -11;
    
            public const int STD_INPUT_HANDLE = -10;
    
            public const int STD_ERROR_HANDLE = -12;
    
            public const int INVALID_HANDLE_VALUE = -1;
        }
    
        #endregion
    
        #region Public Members
    
        /// <summary>
        /// Altera a fonte do Console
        /// </summary>
        /// <param name="Font">A nova fonte</param>
        /// <returns>Retorna true se conseguir, e false se falhar.</returns>
        public static bool SetConsoleFont(ConsoleFont Font)
        {
            IntPtr handle = Kernel32.GetStdHandle(Kernel32.STD_OUTPUT_HANDLE);
    
            if ((handle.ToInt32() == Kernel32.INVALID_HANDLE_VALUE) || (handle.ToInt32() == Kernel32.STD_ERROR_HANDLE)) return false;
    
            Kernel32.CONSOLE_FONT_INFOEX fontInfo = new Kernel32.CONSOLE_FONT_INFOEX();
            fontInfo.cbSize = (uint)Marshal.SizeOf(typeof(Kernel32.CONSOLE_FONT_INFOEX));
    
            bool sucessed = Kernel32.GetCurrentConsoleFontEx(handle, false, ref fontInfo);
    
            if (sucessed == false) return false;
    
            fontInfo.FaceName = Font.Name;
            fontInfo.nFont = Font.Index;
            fontInfo.FontFamily = Font.Family;
            fontInfo.FontWeight = Font.Weight;
    
            fontInfo.dwFontSize.X = Font.Width;
            fontInfo.dwFontSize.Y = Font.Height;
    
            return Kernel32.SetCurrentConsoleFontEx(handle, false, ref fontInfo);
        }
    
        /// <summary>
        /// Pegar a fonte atual do console
        /// </summary>
        /// <returns>Retorna a fonte em um objeto do tipo ConsoleFont</returns>
        public static ConsoleFont GetConsoleFont()
        {
            IntPtr handle = Kernel32.GetStdHandle(Kernel32.STD_OUTPUT_HANDLE);
    
            if ((handle.ToInt32() == Kernel32.INVALID_HANDLE_VALUE) || (handle.ToInt32() == Kernel32.STD_ERROR_HANDLE)) return null;
    
            Kernel32.CONSOLE_FONT_INFOEX fontInfo = new Kernel32.CONSOLE_FONT_INFOEX();
            fontInfo.cbSize = (uint)Marshal.SizeOf(typeof(Kernel32.CONSOLE_FONT_INFOEX));
    
            bool sucessed = Kernel32.GetCurrentConsoleFontEx(handle, false, ref fontInfo);
    
            if (sucessed == false) return null;
    
            return ConsoleFont.Create(fontInfo);
        }
    
        public class ConsoleFont
        {
            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
            private string _Name;
    
            private uint _Index;
            private uint _Family;
    
            public string Name { get { return _Name; } }
            public uint Index { get { return _Index; } }
            public uint Family { get { return _Family; } }
    
            public short Width { get; set; }
            public short Height { get; set; }
            public uint Weight { get; set; }
    
            private ConsoleFont(string Name, uint Index, uint Family, short Width, short Height, uint Weight)
            {
                this._Name = Name;
                this._Index = Index;
                this._Family = Family;
                this.Width = Width;
                this.Height = Height;
                this.Weight = Weight;
            }
    
            public static ConsoleFont Create(Kernel32.CONSOLE_FONT_INFOEX INFO)
            {
                return new ConsoleFont(INFO.FaceName, INFO.nFont, INFO.FontFamily, INFO.dwFontSize.X, INFO.dwFontSize.Y, INFO.FontWeight);
            }
    
            public static ConsoleFont Consolas { get { return new ConsoleFont("Consolas", 5, 54, 6, 12, 400); } }
            public static ConsoleFont Terminal { get { return new ConsoleFont("Terminal", 7, 48, 7, 12, 400); } }
            public static ConsoleFont LucidaConsole { get { return new ConsoleFont("Lucida Console", 11, 54, 7, 12, 400); } }
        }
    
        #endregion
    
    }

    Ai, o exemplo ficou assim:

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    
    namespace Special_Characters_Console
    {
        class Program
        {
            static void Main(string[] args)
            {
                Console.OutputEncoding = Encoding.Unicode;
                ConsoleHelper.SetConsoleFont(ConsoleHelper.ConsoleFont.Consolas);
                Console.WriteLine("Testando 123 ! @ # $ % ¨ & *");
                Console.ReadKey();
            }
        }
    }
    


    Herbert Lausmann

    sexta-feira, 3 de janeiro de 2014 10:53
  • Olá!Bom você está certo, mas:

    public static bool SetConsoleFont(ConsoleFont Font) { IntPtr handle = Kernel32.GetStdHandle(Kernel32.STD_OUTPUT_HANDLE); if ((handle.ToInt32() == Kernel32.INVALID_HANDLE_VALUE) || (handle.ToInt32() == Kernel32.STD_ERROR_HANDLE)) return false; Kernel32.CONSOLE_FONT_INFOEX fontInfo = new Kernel32.CONSOLE_FONT_INFOEX(); fontInfo.cbSize = (uint)Marshal.SizeOf(typeof(Kernel32.CONSOLE_FONT_INFOEX)); bool sucessed = Kernel32.GetCurrentConsoleFontEx(handle, false, ref fontInfo); if (sucessed == false) return false; fontInfo.FaceName = Font.Name; fontInfo.nFont = Font.Index; fontInfo.FontFamily = Font.Family; fontInfo.FontWeight = Font.Weight; fontInfo.dwFontSize.X = Font.Width; fontInfo.dwFontSize.Y = Font.Height; return Kernel32.SetCurrentConsoleFontEx(handle, false, ref fontInfo); }

    No VS é apresentado erros neste treçho informando que certos itens não existem no contexto public static bool tais como " GetStdHandle(STD_OUTPUT_HANDLE) ".

    sexta-feira, 3 de janeiro de 2014 13:57
  • Você copiou a classe estática Kernel32?

    Deve ter faltado copiar alguma coisa ai, pois eu postei o código todo na íntegra...


    Herbert Lausmann

    • Marcado como Resposta Nicpeterl sábado, 4 de janeiro de 2014 00:38
    sexta-feira, 3 de janeiro de 2014 14:13