Arquivo

Archive for Novembro, 2010

Serialization .NET

23 de Novembro de 2010 Deixe um comentário

Olá pessoal, hoje eu vou falar sobre serialização de dados com o .NET. Para quem não sabe oque é serialização pense na seguinte situação, você precisa transferir uma coleção de objetos de sua aplicação para outra aplicação através da rede. Para fazer isso você precisaria transformar sua coleção em um XML e enviar para a outra aplicação. Este processo de transformação da coleção de objetos para um XML pode ser considerado uma serialização.

Dentro do namespace System.Runtime.Serialization.Formatters.Binary você tem a classe BinaryFormatter que nos permite transformar dados de nossa aplicação (string, coleção de objetos e etc.) em um arquivo binário serializado. Segue abaixo um exemplo de como serializar uma string.

  1. FileStream fileStream = new FileStream("ArquivoBinarioSerializado", FileMode.CreateNew);
  2. BinaryFormatter binFtr = new BinaryFormatter();
  3. binFtr.Serialize(fileStream, "franciscogoncalves.wordpress.com");
  4. fileStream.Close();

Na primeira linha eu criei um FileStream para criar um arquivo com o nome de “ArquivoBinarioSerializado”. Na segunda linha eu instanciei a classe BinaryFormatter. Na terceira linha é que a serialização realmente acontece. Estou dizendo para que a string “franciscogoncalves.wordpress.com” seja serializada dentro do arquivo que estou criando com o FileStream. Na última linha apenas chamo o método close do FileStream. Se você pode verificar na pasta raiz de seu projeto que um arquivo com dados serializados foi criado. E para deserializar utilize o seguinte exemplo.

  1. FileStream fileStream = new FileStream("ArquivoBinarioSerializado", FileMode.Open);
  2. BinaryFormatter binFtr = new BinaryFormatter();
  3. string data = (string)binFtr.Deserialize(fileStream);
  4. fileStream.Close();
  5. Console.WriteLine(data);

A diferença entre o primeiro trecho de código e o segundo é que no segundo o FileStream está com o FileMode configurado para abrir um arquivo ao invés de criar. Na terceira linha estou chamando o método Deserialize passando como parâmetro o FileStream. É muito importante que você saiba qual é o tipo do conteúdo do arquivo. No caso eu sei que o conteúdo do arquivo é uma string, por isso eu faço um cast para string. E na última linha eu exibo o resultado. Você pode verificar que o conteúdo é exatamente o mesmo que eu havia serializado no exemplo anterior.

A serialização binária é muito útil quando precisamos trafegar dados entre aplicações .NET, porém quando precisamos trafegar informações para outro tipo de plataforma utilizamos a serialização Soap que é baseado em XML. Para utilizar adicione o assembly  System.Runtime.Serialization.Formatters.Soap e utilize os seguintes exemplos para para:

Serializar

  1. FileStream fileStream = new FileStream("ArquivoSoapSerializado", FileMode.CreateNew);
  2. SoapFormatter soapFtr = new SoapFormatter();
  3. soapFtr.Serialize(fileStream, "franciscogoncalves.wordpress.com");
  4. fileStream.Close();

Deserializar

  1. FileStream fileStream = new FileStream("ArquivoSoapSerializado", FileMode.Open);
  2. SoapFormatter soapFtr = new SoapFormatter();
  3. string data = (string)soapFtr.Deserialize(fileStream);
  4. fileStream.Close();
  5. Console.WriteLine(data);

Você pode perceber que o arquivo gerado tem uma formatação diferente quando utilizamos o SoapFormatter.

Você também pode serializar suas próprias classes, basta que você a decore com o atributo Serializable. Segue abaixo um exemplo.

  1. [Serializable]
  2. public class Pessoa
  3. {
  4.     public int idPessoa { get; set; }
  5.     public string nome { get; set; }
  6.     public int idade { get; set; }
  7.     public int anoNascimento { get; set; }
  8. }

E para você serializar ou deserializar basta usar os exemplos acima trocando a string pela seu objeto.

O Serialization permite que você configure como a serialização da classe pode funcionar. Por exemplo, caso você tenha duas versões diferente da classe Pessoa você pode utilizar o atributo OptionalField na propriedade escolhida. Isto significa que poderá serializar/deserializar de uma classe para outra mesmo que não exista a propriedade em uma delas.

  1. [OptionalField]
  2. public int idPessoa { get; set; }

Outro atributo interessante é o NonSerialized que indica que esta propriedade não será serializada. Veja abaixo um exemplo.

  1. [NonSerialized]
  2. public int anoNascimento { get; set; }

Você também pode controlar como será a deserialização. Por exemplo: a propriedade anoNascimento não será serializada, porém eu posso calcular este valor no momento da deserialização implementando a Interface IDeserializationCallback.

  1. [Serializable]
  2. public class Pessoa : IDeserializationCallback
  3. {
  4.     public int idade { get; set; }
  5.     [NonSerialized]
  6.     public int anoNascimento { get; set; }
  7.     public void OnDeserialization(object sender)
  8.     {
  9.         anoNascimento = DateTime.Now.Year – idade;
  10.     }

 

É isso ai pessoal, espero que tenham gostado do artigo e espero que ele tenha sido útil. Até o próximo.

Advertisement
Categorias:.NET Framework Etiquetas:

Encoding .NET

15 de Novembro de 2010 Deixe um comentário

Hoje vamos falar sobre como utilizar as funções de Encoding no .NET. Para isso primeiro é necessário que tenhamos uma visão geral sobre os padrões de encoding existentes.

Você pode imaginar os padrões de encoding como se fossem uma lista com todos os caracteres possíveis dentro daquele padrão. Por exemplo: o padrão ASCII contêm somente caracteres da língua inglesa e alguns tipos de pontuação. Como o ASCII não atendia regiões além das que falam a língua inglesa foram criados outros padrões como o UTF8, UTF16 entre outros.

Dentro do namespace System.Text temos a classe Encoding que centraliza todo o trabalho que você teria que fazer quanto se utiliza Encoding. Por exemplo: para listar todos encodings suportados no seu computador utilize o seguinte código.

  1. EncodingInfo[] ei = Encoding.GetEncodings();
  2. foreach (EncodingInfo e in ei)
  3. {
  4.     Console.WriteLine(e.CodePage + "-" + e.Name + "-" + e.DisplayName);
  5. }

A classe Encoding tem um método estático GetEncodings que retorna um array de EncodingInfo. O mesmo tem algumas propriedades que podem ser utilizadas para recuperar algumas informações. No exemplo acima eu utilizei as propriedades CodePage, Name e DisplayName.

Cada caracter que você tem dentro de uma string na verdade ele corresponde a um byte de acordo com o encoding escolhido. Você pode verificar a diferença de bytes executando estas seqüencias de código.

  1. Encoding e = Encoding.GetEncoding("Korean");
  2. byte[] encoded;
  3. encoded = e.GetBytes("Gonçalves");
  4. for (int i = 0; i < encoded.Length; i++)
  5. {
  6.     Console.WriteLine("Byte {0}: {1}", i, encoded[i]);
  7. }

  1. Encoding e = Encoding.GetEncoding("IBM860");
  2. byte[] encoded;
  3. encoded = e.GetBytes("Gonçalves");
  4. for (int i = 0; i < encoded.Length; i++)
  5. {
  6.     Console.WriteLine("Byte {0}: {1}", i, encoded[i]);
  7. }

Quando você executar este código você irá perceber que o caracter “ç” é representado de maneiras diferentes dependendo do encoding utilizado. No caso IBM860 é o codePage do encoding “Portuguese”.

O muito importante você trabalhar com o encoding correto quando você estiver escrevendo ou lendo um arquivo. No exemplo abaixo eu demonstro como escrever em um arquivo de texto utilizando o encoding UTF7. E logo em seguida eu demonstro como será a leitura do mesmo utilizando o encoding correto e o encoding errado.

  1. StreamWriter sw = new StreamWriter("teste.txt", false, Encoding.UTF7);
  2. sw.WriteLine("Francisco Gonçalves");
  3. sw.Close();
  4. StreamReader sr = new StreamReader("teste.txt", Encoding.UTF7);
  5. Console.WriteLine(sr.ReadToEnd());
  6. sr.Close();
  7. StreamReader sr1 = new StreamReader("teste.txt", Encoding.UTF8);
  8. Console.WriteLine(sr1.ReadToEnd());
  9. sr1.Close();

Você pode perceber que se usarmos o encoding errado podemos ter alguns problemas na hora da leitura.

E é isso ai pessoal, espere que o artigo tenha seja útil para o seu dia-a-dia. Até a próxima.

Categorias:.NET Framework Etiquetas:

Regex .NET – Regular Expression

15 de Novembro de 2010 Deixe um comentário

Olá pessoal, neste artigo irei demonstrar como utilizar as famosas Regular Expression (Expressões Regulares) no .NET. Para quem não sabe Regular Expression de acordo com o site Wikipédia é uma forma concisa e flexível de identificar cadeias de caracteres dentro de um texto independente de plataforma. Em outras palavras significa que você pode utiliza-la quando deseja pesquisar seu texto tendo como filtro uma padrão de caracteres, ou então verificar se um formato de texto é válido e entre outras coisas. O objetivo deste artigo é demonstrar como o .NET trabalha com essas expressões regulares e não como as expressões funcionam. Para mais informações sobre Regular Expression segue abaixo alguns links.

http://pt.wikipedia.org/wiki/Express%C3%A3o_regular – Wikipédia

http://msdn.microsoft.com/en-us/library/az24scfc.aspx – Site da Microsoft

http://regexlib.com/Search.aspx – Contém uma série de expressões como cpf, cnpj e etc..

No mundo .NET nós temos o namespace System.Text.RegularExpression que permite trabalharmos com as Expressões.

Para fazer uma simples validação utilizamos o método estático IsMatch da classe Regex. Segue abaixo um exemplo.

  1. Console.WriteLine(Regex.IsMatch("12345", @"^\d{5}"));
  2. Console.WriteLine(Regex.IsMatch("1234", @"^\d{5}"));

 

Nestes dois exemplos estou utilizando a expressão “^\d{5}” que significa 5 dígitos ou mais para validar a string “12345” e a string “1234”. No primeiro caso o Regex.IsMatch retorna true já no segundo o retorno é falso, indicando que a string não passou pelo teste da expressão.

No método IsMatch você ainda tem a opção de configurar o funcionamento do mesmo utilizando o enumerador RegexOptions. Segue abaixo um exemplo de utilização, porém o enumerador tem muitas opções para você escolher.

  1. Regex.IsMatch("12345", @"^\d{5}", RegexOptions.Compiled)

Com o método Match você pode extrair partes do texto que estão de acordo com sua regular expression. Segue abaixo um exemplo:

  1. Match m = Regex.Match("Blog do: Francisco Gonçalves", "Blog do: (.*$)");
  2. Console.WriteLine(m.Groups[1]);
  3. Console.WriteLine(m.Success);

 

Na primeira linha estou passando como parâmetro a string que será verificada e como segundo parâmetro qual será o pattern de extração. Na segunda linha estou verificando o primeiro grupo que foi extraído do texto e na última linha estou verificando a propriedade que indica se a extração foi um sucesso ou não.

A classe Regex tem um método estático para substituição de string chamado Replace. Veja como utilizar.

  1. Console.WriteLine(Regex.Replace("1a2v3c", @"[\d]", "#"));

 

Neste exemplo estou substituindo todos os numerais da string “1a2v3c” por “#”.

Este foi um post pequeno, porém espero que seja útil para o seu dia-a-dia. Até o próximo.

Categorias:.NET Framework Etiquetas:,

Instrumentação .NET – WMI

14 de Novembro de 2010 Deixe um comentário

No podemos acessar uma série de informações do Windows através do Windows Management Instrumentation (WMI) como por exemplo versão do sistema operacional, temperatura do processador, nome dos HD´s instalados, quais são os Drives entre outras coisas. Para uma referência completa verifique o link “Classes WMI” no final deste artigo. Neste post irei descrever como executar as operações básicas de monitoramento.

Para se conectar ao WMI do Windows adicione o namespace System.Management e utilize o seguinte código:

  1. ManagementScope scope = new ManagementScope(@"\\localhost\root\cimv2");
  2. scope.Connect();

 

No exemplo acima estou instanciando uma classe do tipo ManagementScope e chamando o método para conectar no WMI.

O Framework nos permite utilizar uma subset do SQL chamada WMI Query Language (WQL) para realizar consultas no WMI do Windows. Para isso você terá que criar um ObjectQuery passando como parâmetro no construtor o WQL criado. Segue abaixo o exemplo.

  1. ObjectQuery query = new ObjectQuery("SELECT * FROM Win32_LogicalDisk");

 

Neste caso estou selecionando todos os drives lógicos que o Windows reconhece. Existem várias querys que podem ser realizadas, para uma referencia completa veja os links no final deste artigo.

Para realizar a consulta siga o exemplo abaixo:

  1. ManagementObjectSearcher searcher = new ManagementObjectSearcher(scope, query);
  2. ManagementObjectCollection queryCollection = searcher.Get();
  3. foreach (ManagementObject m in queryCollection)
  4. {
  5.     Console.WriteLine("{0} {1}", m["Name"].ToString(), m["Description"].ToString());
  6. }

 

Na linha 1 estou criando o objeto ManagementObjectSearcher passando como parâmetro o scope e a query. Na segunda linha eu executo a consulta chamando o método Get e retorno a coleção atribuindo ao objeto ManagementObjectCollection. Nas linhas finais eu executo um foreach através da coleção e retorno o nome e a descrição do drive passando como parâmetro suas chaves respectivamente. Para uma referencia completa das chaves, acessem os links no final deste artigo.

Outra opção é você monitorar os eventos WMI para que quando algum evento executar o seu código será chamado. Segue abaixo como fazer isso.

  1. WqlEventQuery query = new WqlEventQuery("__InstanceCreationEvent",
  2.                             new TimeSpan(0, 0, 1),
  3.                             "TargetInstance isa 'Win32_Process'");
  4. ManagementEventWatcher watcher = new ManagementEventWatcher(query);
  5. ManagementBaseObject e = watcher.WaitForNextEvent();
  6. Console.WriteLine(((ManagementBaseObject)e["TargetInstance"])["Name"]);
  7. watcher.Stop();

 

Na primeira linha estou criando o Objeto WqlEventQuery dizendo quais eventos eu quero monitorar. Na quarta linha eu crio o watcher que inicia o monitoramento. Na linha 5 eu digo para a aplicação que aguarde até que algum evento WMI seja executado. Na penúltima linha eu recupero qual o nome do processo que foi criado e na última linha eu paro o monitoramento.

Outra forma de realizar este monitoramento é através de eventos do watcher. Isto melhora sua aplicação pois a mesma não terá que ficar parada esperando que algum evento aconteça. Segue abaixo como fazer.

  1. watcher.EventArrived += new EventArrivedEventHandler(handler);
  2. watcher.Start();

 

Após criar o watcher estou associando um método ao evento EventArrived do mesmo, para que quando algum evento acontecer ele chamará automaticamente este método. Na última linha estou dizendo para o watcher começar o monitoramento.

E chegamos ao fim de mais um artigo desta série de instrumentação. Espero que tenham gostado e que seja útil para seu dia a dia.

Classes WMI : http://msdn.microsoft.com/en-us/library/aa394554.aspx

Scripts WMI: http://msdn.microsoft.com/en-us/library/aa394585(v=VS.85).aspx

Categorias:.NET Framework Etiquetas:,

Instrumentação .NET – Processos

13 de Novembro de 2010 Deixe um comentário

Fala galera. Neste artigo vou demonstrar como desenvolver a maioria das funções que você encontra no gerenciador de tarefas do Windows. Segue abaixo um print do TaskManager do Windows que você pode acessar digitando “taskmgr” no executar do menu iniciar. (Se você identificar algum vírus na minha lista de processos me avise..rs).

Nova Imagem (1)

Dentro no namespace System.Diagnostics você tem a classe Process que permite você executar um novo processo, monitorar algum existente, fechar um processo e outras coisas mais. Segue abaixo um exemplo de como executar um novo processo.

  1. Process.Start("Calc");
  2. Process.Start("Notepad", @"c:\Teste.txt");

 

No exemplo acima eu primeiro iniciei uma instancia da calculadora do Windows. Na segunda linha eu estou iniciando uma instancia do notepad do Windows passando como parâmetro o arquivo “C:\Teste.txt” para ser aberto pelo notepad.

Outra forma de iniciar um processo é utilizando a classe ProcessStartInfo que é utilizada quando você precisa realizar mais configurações para iniciar um processo ou quando você precisa criar essas configurações de modo dinâmico ou em etapas diferentes. Segue abaixo um exemplo.

  1. ProcessStartInfo psi = new ProcessStartInfo();
  2. psi.Arguments = @"c:\windows\win.ini";
  3. psi.FileName = "Notepad";
  4. Process.Start(psi);

O ProcessStarInfo tem várias propriedades que permitem você tratar a inicialização do seu processo. Abaixo eu demonstro algumas propriedades para você configurar sobre qual domínio sua propriedade ser inicializada.

  1. psi.Domain = "Dominio.com";
  2. psi.UserName = "Francisco";

 

A classe Process contém um método estático que retorna todos os processos que estão executando no computador atualmente. Para utiliza-lo chame o método GetProcesses como demonstrado no exemplo abaixo.

  1. foreach (Process p in Process.GetProcesses())
  2. {
  3.    Console.WriteLine(p.Id); //Id do Processo
  4.    Console.WriteLine(p.ProcessName); //Nome do Processo
  5.    Console.WriteLine(p.MainModule); //Módulo principal da execução
  6.    Console.WriteLine(p.Responding); //Verifica se a aplicação esta respondendo
  7.    Console.WriteLine(p.TotalProcessorTime); //Tempo de processamento
  8.    Console.WriteLine(p.VirtualMemorySize64); //Total de memória virtual
  9. }

 

Além monitorar os processos você ainda tem a opção de gerencia-los. Segue abaixo alguns exemplos.

  1. Process p = Process.Start("Notepad", @"c:\Teste.txt");
  2. p.CloseMainWindow();
  3. p.Kill();
  4. p.Start();
  5. p.WaitForExit();

Na linha 2 eu estou dizendo para que o notepad feche naturalmente, isto quer dizer que o notepad irá executar seu comportamento padrão de execução exibindo aquela tela para salvar as alterações. Na terceira linha estou matando o processo, funciona da mesma forma que o “Finalizar processo” do gerenciador de tarefas. Na quarta linha estou iniciando o processo novamente e na ultima linha eu digo para o nosso processo esperar que o notepad feche para continuarmos a execução.

A classe processo nos permite retornar todos os módulos associados ao processo utilizando o método modules. Segue o exemplo demonstrando como utilizar. 

  1. foreach (ProcessModule pm in p.Modules)
  2. {
  3.     Console.WriteLine(pm.FileName); //Arquivo do Módulo
  4.     Console.WriteLine(pm.ModuleMemorySize); //Memória utilizada
  5.     Console.WriteLine(pm.ModuleName); //Nome do Módulo
  6.     Console.WriteLine(pm.FileVersionInfo.ToString()); //Informação sobre a versão
  7. }

Espero que tenham gostado e até o próximo artigo.

Categorias:.NET Framework Etiquetas:,

Instrumentação .NET – Contadores de Performance

12 de Novembro de 2010 Deixe um comentário

Olá amigos..

Neste artigo irei demonstrar como monitorar sua aplicação com contadores de performance.

O Windows tem uma ferramenta para gerenciar contadores de performance chamada “perfmon”. Você pode acessa-la digitando “perfmon” no executar do Windows.

Nova Imagem

Nesta ferramenta você pode monitorar uma série de contadores que já estão configurados no seu computador. Utilizando o namespace System.Diagnostics você poderá criar um contador de performance para ser monitorado, você também poderá ler um contador a partir de sua aplicação. Vamos aprender como ler um contador de performance.

PerformanceCounter contadorPerformance = new PerformanceCounter(“Processor”, “% Processor Time”, “_Total”);

No código acima estou indicando que quero criar um contador de Performance baseado em um já existente no sistema operacional. No caso específico estou indicando a categoria “Processor”, Indicando o contador “% Processor Time” e a instancia “_Total”.

Depois de instanciado o contador você poderá monitora-lo. Segue abaixo um exemplo.

for (int i = 0; i < 10; i++)
{
    Thread.Sleep(1000);
    Console.WriteLine(contadorPerformance.NextValue());
}

No exemplo acima eu utilizei a propriedade NextValue para recuperar qual o valor calculado do contador.

Para criar um contador de performance você pode utilizar o seguinte exemplo:

PerformanceCounterCategory.Create(“Categoria do meu Contador”, “Ajuda da Categoria”,
                PerformanceCounterCategoryType.SingleInstance, “Meu contador”, “Ajuda do Meu contador”);

O primeiro parâmetro indica o nome da categoria a ser criada, seguido pelo parâmetro que indica o Help da mesma, o terceiro parâmetro indica a quantidade de instancias o contador poderá ter, já o quarto parâmetro indica o nome do contador e logo em seguida vem o parâmetro que indica o Help do mesmo. Segue abaixo alguns métodos interessantes para o gerenciamento de contadores.

PerformanceCounterCategory.Delete(“Categoria do meu Contador”); //Exclui uma categoria
PerformanceCounterCategory.CounterExists(“Meu contador”, “Categoria do meu Contador”); //Verifica se um contador existe
PerformanceCounterCategory.Exists(“Categoria do meu Contador”); //Verifica se uma categoria existe
PerformanceCounterCategory.GetCategories(); //Retorna todas as categorias cadastradas

Você também pode adicionar vários contadores a mesma categoria.

CounterCreationDataCollection conts = new CounterCreationDataCollection();
conts.Add(new CounterCreationData(“Contador 1”, “Ajuda do Contador 1”, PerformanceCounterType.NumberOfItems64));
conts.Add(new CounterCreationData(“Contador 2”, “Ajuda do Contador 2”, PerformanceCounterType.NumberOfItems64));
PerformanceCounterCategory.Create(“Categoria do meu Contador”, “Ajuda da Categoria”,
PerformanceCounterCategoryType.SingleInstance, conts);

Você pode verificar o parâmetro criado na ferramenta perfmon do Windows. Clique em um botão com o sinal de positivo “+” e procure o sua categoria criada e seu contador criado e adicione ao monitoramento.

PerformanceCounter contPerf = new PerformanceCounter(“Categoria do meu Contador”, “Meu contador”, false);
for (int i = 0; i < 100; i++)
{
   contPerf.Increment();
   Console.WriteLine(contPerf.NextValue());
}

No exemplo acima eu instancia o contador criado no exemplo anterior passando um parâmetro booleano como false. Este parâmetro indica que o contador não é read-only. O método “Increment” adiciona o valor 1 no contador. Você pode verificar o incremento tanto no console quanto no perfmon. Segue abaixo alguns métodos úteis para utilização do contador de performance.

contPerf.RawValue = 5; //Configura um valor para o contador
contPerf.Increment(); //Adiciona 1 ao contador. Tipo thread-Safe
contPerf.Decrement(); //Remove 1 ao contador. Tipo thread-Safe
contPerf.IncrementBy(2); //Adiciona 2 ao contador. Tipo thread-Safe
Console.WriteLine(contPerf.CategoryName); //Recupera a categoria do contador
Console.WriteLine(contPerf.CounterHelp); //Recupera o help do contador
Console.WriteLine(contPerf.CounterName); //Recupera o nome do contador
Console.WriteLine(contPerf.CounterType); //Recupera o tipo do contador
Console.WriteLine(contPerf.InstanceName); //Recupera o nome da instancia do contador

E é isso ai pessoal, espero que a partir de hoje você saiba como monitorar a performance de sua aplicação de uma forma que seja de fácil leitura para o pessoal de Infra da sua empresa.

Categorias:.NET Framework Etiquetas:,

Instrumentação .NET – Debug e Trace

2 de Novembro de 2010 Deixe um comentário

Quantas vezes nós já passamos por situações em que após realizarmos todos os testes em nossa maquina, confirmamos que o sistema esta ok, porém quando enviamos para o servidor de homologação o sistema parece outro, cheio de erros. E a pior parte é que não podemos debugar no ambiente de homologação.  Isto se resume da frase: “Na minha maquina funciona”.

Para ajudar a resolver esses problemas o .NET Framework disponibiliza as classes de Debug e Trace dentro do namespace System.Diagnostics. As duas classes são implementadas da mesma maneira e tem comportamento semelhante. A principal diferença entre elas é que a classe Trace é utilizada quando sua aplicação esta compilada em modo de release e a Debug quando esta compilada em modo de Debug. Essas classes nos permitem criar logs, mensagens, PopUp entre outros para monitorar a aplicação.

Vou demonstrar como utilizar essas classes usando como exemplo a classe Debug,  mas você pode substituir pela classe Trace caso seja necessário.

Debug.Write(“Mensagem: Debug”); //Escreve um texto.

O texto irá aparecer na janela Output do Visual Studio.

image

O texto apareceu na janela de Output porque esta configurado por padrão para fazer isso. A saída do texto pode ser configurada com ajuda dos Listeners. Segue abaixo alguns exemplos.

Debug.Listeners.Add(new DefaultTraceListener()); //Listener padrão. Exibe as mensagens na janela de output do VS.
Debug.Listeners.Add(new TextWriterTraceListener(“Teste.txt”)); // Grava as mensagens em um arquivo texto.
Debug.Listeners.Add(new XmlWriterTraceListener(“teste.xml”)); //Grava as mensagens em um arquivo xml.
Debug.Listeners.Add(new EventLogTraceListener(new EventLog(“DebugLog”, “.”, “DebugSource”))); //Grava as mensagens no log do Windows.
Debug.Listeners.Add(new ConsoleTraceListener()); //Exibe as mensagens em uma janela console.

Você também pode usar o web.config ou app.config para configurar os Listeners. Segue abaixo alguns exemplos.

<system.diagnostics>
   <trace autoflush =”true” indentsize=”4″>
     <listeners>
       <add name=”TextTraceListener”
            type=”System.Diagnostics.TextWriterTraceListener”
            initializeData=”output.txt” />
       <add name=”XmlWriterTraceListener”
            type=”System.Diagnostics.XmlWriterTraceListener”
            initializeData=”output.xml” />
       <add name=”ConsoleTraceListener”
           type=”System.Diagnostics.ConsoleTraceListener” />
       <remove name=”Default” />
     </listeners>
   </trace>
</system.diagnostics>

Segue abaixo alguns métodos e propriedades interessantes para serem utilizados.

Debug.Assert(false, “Mensagem”); //Exibe a mensagem caso a condição seja falsa.
Debug.Write(“Mensagem”); //Exibe a mensagem
Debug.WriteLine(“Mensagem”); //Exibe a mensagem e pula uma linha
Debug.WriteIf(true, “Mensagem”); //Exibe a mensagem caso a condição seja verdadeira
Debug.WriteLineIf(true, “Mensagem”); //Exibe a mensagem caso a condição seja verdadeira e pula uma linha
Debug.Fail(“ErrorMensagem”); //Exibe uma mensagem de Erro.
Debug.Flush(); //Escreve toda as mensagem que estiverem na memória.
Debug.IndentSize = 10; // Tamanho da indentação das mensagens.
Debug.IndentLevel = 1; // Nível da indentação das mensagens.
Debug.Indent(); //Adiciona um nível de indentação para as próximas mensagens
Debug.Unindent(); //Retorna um nível de indentação para as próximas mensagens

Espero ter ajudado para que os próximos problemas que você tiver em produção não seja um pânico total. Basta usar o Trace para monitorar sua aplicação

 

 

 

Categorias:.NET Framework Etiquetas:, ,
%d bloggers gostam disto: