Conhecendo a classe System.Environment do .NET Framework

Introdução

A classe estática System.Environment, introduzida na versão 1.0 do .NET Framework e aperfeiçoada nas versões posteriores, fornece informações e métodos para se acessar as principais informações sobre o ambiente de trabalho da aplicação, como versão do sistema operacional e diretório do executável, por exemplo.

Na documentação dessa classe ela possui a seguinte descrição:

“Provides information about, and means to manipulate, the current environment and platform. This class cannot be inherited.”.

Essa classe é de grande utilidade para sistemas dos mais variados tipos, em situações como:

• Quando se precisa, por exemplo, verificar a existência de arquivos no diretório do sistema operacional (geralmente C:\Windows\system32), como DLL’s;
• Tomar decisões com base na versão do sistema operacional e na arquitetura utilizada (32 ou 64 bits);
• Obter o nome do usuário atualmente conectado no Windows (por exemplo para realizar algum tipo de integração com o sistema de autenticação da aplicação própria);

Essas são apenas algumas das possíveis situações onde a classe System. Environment pode ser mostrar como solução, mas qualquer um pode encontrar nessa classe utilidades que vão além de qualquer exemplo dado nesse artigo.

Aqui daremos ênfase às propriedades dessa classe, as quais serão explicadas e, na medida do possível, serão utilizadas em um exemplo prático para facilitar a compreensão por parte do leitor.

Propriedades da classe System.Environment

• CommandLine (string): essa propriedade possui a linha de comando utilizada para executar a aplicação. No caso de aplicações que não necessitem de parâmetros em linha de comando (muito utilizados quando a aplicação é executada via prompt de comando), essa propriedade possui apenas o caminho do executável.
• CurrentDirectory (string): como o nome sugere, a propriedade CurrentDirectory representa o diretório do executável da aplicação. Esse valor é muito utilizado quando se precisa carregar arquivos que devam estar junto do arquivo executável, como arquivos de configuração.
• CurrentManagedThreadId (int): um valor inteiro que identifica unicamente a thread corrente da aplicação.
• ExitCode (int): valor inteiro que representa um código de saída da aplicação. Por exemplo, se a aplicação for finalizada corretamente, o valor dessa propriedade será zero (que é o valor padrão). O programador pode atribuir valores (1, 2, 3...) a essa propriedade para indicar problemas específicos no encerramento da aplicação
• HasShutdownStarted (bool): retorna true ou false, indicando se o CLR (Common Language Runtime) está sendo encerrado. Em caso positivo, alguns objetos da aplicação podem também estar sendo destruídos e o acesso a eles passa a não ser confiável, o que acontece com as propriedades estáticas.
• Is64BitOperatingSystem (bool): retorna true ou false, respectivamente, indicando se a arquitetura do processador/sistema operacional utilizada é de 64 bits.
• Is64BitsProccess (bool): semelhante à anterior, mas indica se o processo atual é de 64 bits. A arquitetura/plataforma utilizada pela aplicação pode ser configurada através do menu “Project -> [NomeDoProjeto] Properties -> guia Build -> atributo “Platform target”.
• MachineName (string): obtém o nome do computador em que está sendo executada a aplicação.
• NewLine (string): retorna um string representando uma quebra de linha. Essa propriedade é utilizada para evitar incompatibilidades entre os ambientes onde a aplicação pode ser utilizada. Por exemplo, um ambiente pode utilizar o #13 como quebra de linha, enquanto em outro esse valor pode ser \n.
• OSVersion (string): retorna o nome do sistema operacional definido pelo fabricante. Esse valor pode não ser a descrição mais comum do SO, como “Windows 7” ou “Windows 8” e geralmente indica a versão como ela é controlada pelo fabricante, por exemplo, “Microsoft Windows NT 6.2.9200.0”.
• ProcessorCount (int): trata-se de um valor inteiro indicando a quantidade de processadores (núcleos) presente na máquina. Por exemplo, em uma máquina com um processador Intel i3 de 3.30GHz, esse valor é 4, ou seja, quatro núcleos.
• StackTrace (string): obtém a Stack Trace da thread atual, ou seja, informações sobre o processo em execução.
• SystemDirectory (string): possui o caminho do diretório de sistema do Windows, geralmente é “C:\Windows\System32”.
• SystemPageSize (int): tamanho em bytes do arquivo de paginação do sistema operacional
• TickCount (int): retorna o tempo (em milissegundos) decorrido desde que o sistema foi iniciado.
• UserDomainName (string): obtém o nome do domínio de rede ao qual o usuário está conectado atualmente.
• UserInteractive (bool): essa propriedade indica se a aplicação está sendo executada no modo de interação com o usuário, ou seja, se existe interface com a qual o usuário pode interagir.
• UserName (string): nome do usuário do Windows atualmente conectado.
• Version (Version): retorna um objeto do tipo Version contendo as informações de versão (major version, minor version, build, etc) do CLR (Common Language Runtime).
• WorkingSet (long): um valor inteiro de 64 bits representando a quantidade de memória alocada para o processo principal da aplicação.

Exemplo de uso

O exemplo abaixo (Console Application) faz uso da propriedade faz uso de algumas das propriedades vistas acima para verificar a existência de um arquivo (Sistema.txt) no diretório da aplicação. Caso esse arquivo não exista, o usuário tem a opção de cria-lo e, em seguida, o seu conteúdo é apresentado na tela (nome do computador e do usuário conectado no Windows).

Listagem 1: Exemplo de uso da classe system.Environment

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            string nome_arquivo = System.Environment.CurrentDirectory + "\\Sistema.txt";

            if(!File.Exists(nome_arquivo))
            {
                Console.WriteLine("O arquivo de configuração não foi localizado.");
                Console.WriteLine("Arquivo: {0}", nome_arquivo);
                Console.WriteLine("Deseja criá-lo agora? S - Sim | N - Não");
                string resposta = Console.ReadLine().ToUpper();
                if (resposta.Equals("S"))
                {
                    StreamWriter sw = new StreamWriter(nome_arquivo);
                    sw.WriteLine("Estação de trabalho: {0}", System.Environment.MachineName);
                    sw.WriteLine("Usuário: {0}", System.Environment.UserName);
                    sw.Close();

                    Console.WriteLine("Arquivo criado com sucesso.");
                    Console.WriteLine("-".PadLeft(50, '-'));
                    StreamReader sr = new StreamReader(nome_arquivo);
                    Console.WriteLine(sr.ReadToEnd());
                    sr.Close();

                }
            }

            Console.ReadLine();
        }
    }
}

O resultado da execução desse código é apresentado na Figura 1, a seguir.

Figura 1: Exemplo em execução

Conclusão

Como já foi dito, existem diversas situações onde essa classe pode ser utilizada. O exemplo acima mostrou o uso de apenas três de suas propriedades de forma combinada. Outros procedimentos mais avançados como criação de arquivos de log ou situações onde se usa arquivos mapeados podem também ter o desenvolvimento facilitado pelo uso dessa importante classe.

Então finalizamos por aqui esse artigo. Até a próxima.