Mais uma dica simples, utilizando um recurso adicionado no .NET 4.0, para saber se o Sistema Operacional é 64 bits, ou o processo que está executando nossa lógica é 64 bits temos jeitos simples para fazer isso.

Para descobrir se o sistema operacional é 64 bits é só fazer:

Environment.Is64BitOperatingSystem

E para saber se o processo é 64 bits:

Environment.Is64BitProcess

Ambas as propriedades retornam um booleano.

Por enquanto é isso.

Abraços.

Trabalho criando ferramentas e frameworks pra outros desenvolvedores, e nem sempre quando disponibilizamos alguma API para utilização, podemos sair removendo métodos por exemplo, não sabemos quem utilizou, e se em alguma possível atualização o software vai parar de funcionar ou não, e o atributo Obsolete pode nos ajudar nesse cenário, informando o que está obsoleto na API e será descartado em breve, ou simplesmente recomendando uma alternativa melhor!

A utilização do atributo é simples, vou pegar o código do BasicIoC e criar um método obsoleto de propósito, só preciso informar a mensagem que será mostrada para quem for utilizar o método.

[Obsolete("This method is obsolete; use method Register instead.")]
public Container Map<T>()
{
    _baseType = typeof (T);
    return this;
}

E o interessante é que o Intellisense já ajuda o desenvolvedor mostrando que o método é obsoleto.

Isso não impede a utilização do método, mas mostra avisos quando compilamos que utilizamos um método obsoleto.

Mas podemos adicionar um segundo parâmetra booleano quando configuramos o atributo, forçando um erro de compilação caso existe algum código utilizando um método ou classe obsoleta.

[Obsolete("This method is obsolete; use method Register instead.", true)]
public Container Map<T>()
{
    _baseType = typeof (T);
    return this;
}

Agora o código não compila mais, no lugar de um aviso um erro de compilação é mostrado, mostrando que estamos utilizando um método obsoleto.

Por hoje é isso.

Até o próximo post.

Não sei se já perceberam que a tradução das mensagens do .NET Framework para pt-br não é muito confiável, para não falar horrível :), geralmente não querem dizer muita coisa, e hoje fiquei sabendo do site Unlocalize.

A idéia do site é simples, pegue uma mensagem de erro do .NET em qualquer idioma, e ele mostra essa mensagem em outros idiomas, então segue abaixo a imagem do texto do erro em pt-br e o texto em en-us marcado, site favoritado já :D.

Abraços e até o próximo post.

Nem lembro quando foi a última vez que escrevi sobre Windows Forms, a maioria dos desenvolvedores de aplicações para Windows ainda estão com projetos em Windows Forms, então hoje vou mostrar uma dica simples e útil.

Quando trabalhamos com Windows Forms, é comum a utilização do controle ListView, principalmente pelas várias forms de visualização dos dados, em lista, colunas, entre outras formas.

Quando possuimos um ListView com muitos itens, o controle ganha uma barra de rolagem, até ai tudo bem, agora imagine um ListView que possua 20 itens, mas apenas 12 itens estão visíveis sem o usuário precisar rolar a barra de rolagem.

Só que por algum motivo, o sistema irá selecionar sozinho um dos itens do ListView, por exemplo o último item, abaixo o código para carregar os itens e o código para selecionar o último item do ListView.

private void Form1_Load(object sender, EventArgs e)
{
    CarregarItens();
}

private void CarregarItens()
{
    for (int i = 1; i <= 20; i++)
    {
        Lista.Items.Add(string.Format("Item {0}", i));
    }
}

private void SelecionarUltimoItem_Click(object sender, EventArgs e)
{
    var ultimoItemDaLista = Lista.Items[Lista.Items.Count - 1];
    ultimoItemDaLista.Selected = true;
    Lista.Select();
}

O item será selecionado corretamente, mas o usuário vai precisar rolar manualmente a barra de rolagem para ver o item selecionado, o que não é o ideal, o usuário precisa descobrir sozinho que existe algo selecionado, ao invés do sistema ajudá-lo já mostrando que algo foi selecionado.

Para resolver esse problema utilizamos o método EnsureVisible() que está disponível na classe ListViewItem, dessa forma, o item ficará visível após selecionado, caso precise rolar a barra de rolagem isso será feito automaticamente. Só precisamos adicionar uma linha no código.

private void SelecionarUltimoItem_Click(object sender, EventArgs e)
{
    var ultimoItemDaLista = Lista.Items[Lista.Items.Count - 1];
    ultimoItemDaLista.Selected = true;
    ultimoItemDaLista.EnsureVisible();
    Lista.Select();
}

Uma dica simples mas extremamente útil, independente do sistema o mesmo deve ajudar o usuário, e não esperar que o usuário adivinhe o que está acontecendo.

A partir de hoje, todos os códigos mostrados nos artigos estarão nog GitHub, criei um repositório de Artigos lá, então quem estiver interessado no código fonte do projeto é só clicar no link abaixo.

Código fonte do projeto.

Abraços.

Antes de continuar falando das Strings, vamos entender os tipos de dados no .NET, basicamente temos dois tipos que são classificados como Value Types e Reference Types. Vamos começar com os Value Types ou tipos de valor.

Value Types

O .NET Framework disponibiliza mais de 300 Value Types, são considerados Value Types tipos primitivos, que são os numéricos e booleanos, abaixo uma lista para ver alguns Value Types.

• bool
• byte
• char
• decimal
• double
• enum
• float
• int
• long

Existem mais, mas com a lista acima já da para ter uma idéia de quem são os Value Types. Mais um detalhe é que os Value Types herdam de System.ValueType.

Agora o mais importante é entender como os Value Types são armazenados na memória e como acessamos o valor armazenado.

Segundo a documentação na MSDN, os Value Types são armazenados em uma área da memória chamada Stack e os Reference Types em uma área chamada Heap, para não complicar o artigo aqui, quem quiser entender melhor essa parte recomendo o artigo do Eric Lippert.

Então uma variável do tipo Value Types acessa diretamente o valor armazenado no Heap.

static void Main(string[] args)
{
    int minhaIdade;
    int idadeDaMinhaNamorada = 27; 

    minhaIdade = idadeDaMinhaNamorada;
    idadeDaMinhaNamorada = 26; 

    Console.WriteLine("Minha Idade: {0}", minhaIdade);
    Console.WriteLine("Idade da minha namorada: {0}", idadeDaMinhaNamorada);
}

O resultado desse código é que eu possuo 27 anos, e minha namorada 26, quando eu falei minhaIdade = idadeDaMinhaNamorada; a variável minhaIdade recebe uma cópia do valor que está na variável idadeDaMinhaNamorada, por isso consigo alterar o valor da variável idadeDaMinhaNamorada sem afetar no valor recebido anteriormente pela variável minhaIdade.

Reference Types

Os Reference Types armazenam os valores em uma área da memória chamada Heap, e na Stack existe uma referência de onde o valor daquela variável está armazenada dentro do Heap.

Para identificarmos quem são os Reference Types ao invés de listar alguns, vamos ver a lista de keywords utilizadas na declaração desses tipos.

• class
• interface
• delegate
• dynamic
• object
• string

Vamos ao código de exemplo.

class Posicao
{
public int X { get; set; }
public int Y { get; set; }
}

class Program
{
    static void Main(string[] args)
    {
        var posicao = new Posicao {X = 0, Y = 0};
        var novaPosicao = posicao;
        novaPosicao.X = 10;
        novaPosicao.Y = 15;

        Console.WriteLine("Posição X: {0} Posição Y: {1}", posicao.X, posicao.Y);
    }
}

Criei uma classe chamada posição que armazena os valores para X e Y,  quando eu criei uma nova instância da classe Posição, definir os valores 0 para X e Y.

Logo após eu fiz var novaPosicao = posicao; é nesse ponto que existe a diferênça entre Value Types e Reference Types. Ao invés de novaPosicao receber o valor uma cópia do valor armazenado no Heap ele também vai apontar para a mesma referência do Stack que aponta para o valor armazenado no Heap. Então qualquer alteração feita em qualquer das duas classes, será refletida para a outra, já que elas não acessam diretamente o valor, mas sim a referência de onde o valor está armazenado.

Strings

Depois de tudo isso, agora vamos as Strings, vimos que Strings fazem parte dos Reference Types, porém ela se comporta de uma forma diferente, vamos ao código.

static void Main(string[] args)
{
    string nome = "Márcio";
    string novoNome = nome;
    novoNome = "Márcio Althmann";

    Console.WriteLine("Nome: {0}", nome);
    Console.WriteLine("Novo nome: {0}", novoNome);
}

No resultado da para ver que, mesmo atribuindo nome a novoNome se eu alterar o valor da variável novoNome o valor da nome não é alterado.

No momento em que eu fiz novoNome = nome; a string “Marcio” foi duplicada na memória e atribuida a novoNome.

No momento em que eu fiz novoNome = “Marcio Althmann”, uma nova string foi criada na memória e atribuida ao novoNome, então até o momento eu possuo 3 strings na memória.

• “Márcio”
• “Márcio”
• “Márcio Althmann”

Legal Márcio, mas porque isso acontece? Bom no .NET Strings são imutáveis, ou seja não alteramos o valor depois de criado, digo no .NET porque nem todas as linguagens ou frameworks strings são imutáveis.

No .NET existe strings mutáveis, é só utilizar StringBuilder.

O que mudaria no .NET com strings mutáveis, vamos ao código.

static void Main(string[] args)
{
    string nome = "Márcio Fábio Althmann";

    // Seria possível com strings mutáveis
    // ToLower() não teria retorno
    nome.ToLower();

    // Tem que ser feito assim já que o ToLower() retorna a
    // outra string.
    nome = nome.ToLower();
}

Me agrada a idéia de funcionar só com nome.ToLower() mas não é o caso do .NET x).

Muito bem, e porque strings são imutáveis?

Bom se alguém achar alguma documentação a respeito eu aceito uma cópia, nunca encontrei uma resposta clara sobre o assunto, ai resolvi conversar com o Elemar Jr, o cara é excelente programador, e tem um ótimo conhecimento de linguagens de baixo nível C/C++.

Strings são imutáveis por vários motivos, mas o mais simples e diria até mais preocupante é desempenho.

Imagine uma string em memória com o meu nome “Márcio Althmann”, e eu falo que é para inserir um “F.” após o “Márcio” e antes do “Althmann”, seria muito mais trabalhoso para o framework reposicionar todos os chars da strings e adicionar o “F.” do que simplesmente criar uma strings nova já no formato que eu quero.

Vale lembrar que strings podem possuir muitos caracteres, e quanto maior a string, mais trabalho para o framework.

Tabela de Strings

Antes de encerrar o artigo, vamos ver mais um assunto interessante de como o Framework é inteligente! Vamos voltar ao código que mostrei anteriormente.

static void Main(string[] args)
{
    string nome = "Márcio";
    string novoNome = nome;

    Console.WriteLine("Nome: {0}", nome);
    Console.WriteLine("Novo nome: {0}", novoNome);
}

Fiz uma pequena modificação, não estou mais atribuindo um novo valor para novoNome.

Seguindo o que vimos até agora eu tenho duas strings em memória, correto? Errado!

Felizmente é errado, simplificando, se eu tenho duas variáveis do tipo string, as duas com o mesmo valor “Marcio”, porque eu teria duas alocações de memória? Internamente o CLR controla isso, se no seu sistema você possui, por exemplo, aqueles N botões sair, 1 em cada formulário, cada botão desse, está apontando para a mesma referencia que possui o valor “Sair”.

Esse conceito chama String Interning onde eu tenho somente uma cópia para cada string diferente em memória.

Agora como podemos validar isso? A class String possui métodos que ajudam a definir e validar essa parte, que são String.Intern() e String.IsInterned() mas vamos testar isso de uma forma mais divertida =].

Para testar vamos utilizar o método abaixo.

public static unsafe void ToUpper(string valor)
{
    fixed (char* pfixed = valor)
        for (char* p = pfixed; *p != 0; p++)
            *p = char.ToUpper(*p);
}

Um código um pouco diferente não é =], onde cada char da string recebe um ToUpper(), não vou entrar em muitos detalhes sobre as keywords fixed e unsafe, resumindo:

• unsafe: Quando precisamos trabalhar com ponteiros.
• fixed: Previne que o Garbage Collector vai realocar a variável, e só pode ser utilizado em blocos unsafe.

Um detalhe para quem vai testar, para rodar códigos com unsafe, é preciso habilitar nas propriedades do projeto, veja na imagem.

Voltando ao código, agora completo.

class Program
{
    static void Main(string[] args)
    {
        string nome = "Márcio";
        string novoNome = nome;

        ToUpper(nome);

        Console.WriteLine("Nome: {0}", nome);
        Console.WriteLine("Novo nome: {0}", novoNome);
    }

    public static unsafe void ToUpper(string valor)
    {
        fixed (char* pfixed = valor)
            for (char* p = pfixed; *p != 0; p++)
                *p = char.ToUpper(*p);
    }
}

Repare que eu só passo a variável nome para o método ToUpper() criado, e depois escrevo as duas variáveis na tela, o resultado é que as duas ficaram maiusculas, já que alterei diretamente a única string com o valor “Marcio” em memória, e as duas variáveis apontam para esse valor em memória.

Sem todo esse trabalho com unsafe, não seria possível fazer isso, porque eu teria que escrever algo do tipo nome = nome.ToUpper(); e nesse momento seria criada uma nova string em memória com o valor “MARCIO” que é diferente de “Marcio” =].

Um pouco extenso o post, mas tem o que precisamos entender sobre o funcionamento dos tipos de dados do .NET, e como as strings se comportam, e é interessante estudar como o Framework trabalha, ver como é inteligente para resolver problemas, e as otimizações que ele faz, bons estudos para todos e até o próximo post.

Abraços.

O MongoDB é só um de vários bancos de dados que seguem o modelo NoSQL, segue alguns links para entendermos melhor como seria um banco de dados não relacional, e o que tem de legal nesse movimento NoSQL.

Henrique Lobo Weissmann – Introdução ao MongoDB
André Nobre – O movimento NoSQL

Instalação

Para começar a brincadeira, faça download do MongoDB aqui, é um arquivo .zip com vários programas, não tem nenhum instalador como estamos acostumados =].

Agora um detalhe, crie a pasta data\db no C:\, então é no C:\data\db que o arquivo com nossos dados serão armazenados.

Após a criação da pasta é só executar o mongod.exe que veio no arquivo .zip e o MongoDB será iniciado!

Integração com .NET e LINQ

Agora para facilitar o desenvolvimento, existe uma biblioteca chamada Norm que deveremos adicionar a referência ao nosso projeto.

A biblioteca está disponível aqui no GitHub. O legal é que podemos utilizar LINQ então vai facilitar muito o desenvolvimento.

O projeto de teste

Para esse teste, criei um projeto web com MVC 3, mas pode criar o que achar melhor, fiz isso que já é uma forma de estudar e ver os novos recursos do MVC 3.

O primeiro passo então é adicionar referência a .dll do Norm.

Feito isso vamos criar nossa classe que vai fazer a comunicação com o MongoDB. Criei uma classe chamada MongoDB que terá algumas operações básicas para acesso a dados, depois nos próximos artigos vamos melhorar essa classe.

using System;
using System.Linq;
using Norm;

namespace MongoDB.Models
{
    public class MongoDB
    {
        private const string StringDeConexao = "mongodb://localhost/EstudoMongoDB";

        public T Obter<T>(Func<T, bool> expressao) where T : class
        {
            using (var mongo = Mongo.Create(StringDeConexao))
            {
                return mongo.GetCollection<T>().AsQueryable().Where(expressao).SingleOrDefault();
            }
        }

        public IQueryable<T> ObterTodos<T>() where T : class
        {
            using (var mongo = Mongo.Create(StringDeConexao))
            {
                return mongo.GetCollection<T>().AsQueryable();
            }
        }

        public void Incluir<T>(T objeto) where T : class
        {
            using (var mongo = Mongo.Create(StringDeConexao))
            {
                mongo.GetCollection<T>().Insert(objeto);
            }
        }

        public void Excluir<T>(T objeto) where T : class
        {
            using (var mongo = Mongo.Create(StringDeConexao))
            {
                mongo.GetCollection<T>().Delete(objeto);
            }
        }

        public void Salvar<T>(T objeto) where T : class
        {
            using (var mongo = Mongo.Create(StringDeConexao))
            {
                mongo.GetCollection<T>().Save(objeto);
            }
        }
    }
}

Um detalhe nessa classe é a StringDeConexao o /EstudoMongoDB será nome do nosso banco de dados, se nunca foi criado a primeira vez que for executado será criado.

O resto da classe é um trabalho simples com Generics, utilizando as classes disponíveis no Norm, ai tem tudo que precisamos para fazer nosso primeiro cadastro com o MongoDB.

Vamos fazer um cadastro de Estilo Musical, então criamos a class EstiloMusical que tem os últimos detalhes para o MongoDB funcionar.

using Norm;

namespace MongoDB.Models
{
    public class EstiloMusical
    {
        [MongoIdentifier]
        public ObjectId Id { get; set; }

        public string Nome { get; set; }
    }
}

O Id do nosso objeto será do tipo ObjectId que está disponível no Norm, e também precisa ser decorado com oo atributo [MongoIdentifier].

Agora segue o código pronto do EstiloMusicalController.

using System.Web.Mvc;
using MongoDB.Models;
using Norm;

namespace MongoDB.Controllers
{
    public class EstiloMusicalController : Controller
    {
        private Models.MongoDB mongoDb = new Models.MongoDB();

        //
        // GET: /EstiloMusical/

        public ActionResult Index()
        {
            return View(mongoDb.ObterTodos<EstiloMusical>());
        }

        //
        // GET: /EstiloMusical/Incluir

        public ActionResult Incluir()
        {
            return View();
        }

        //
        // POST: /EstiloMusical/Incluir

        [HttpPost]
        public ActionResult Incluir(EstiloMusical estiloMusical)
        {
            try
            {
                // TODO: Add insert logic here
                mongoDb.Incluir(estiloMusical);

                return RedirectToAction("Index");
            }
            catch
            {
                return View();
            }
        }

        //
        // GET: /EstiloMusical/Editar/1

        public ActionResult Editar(ObjectId id)
        {
            return View(mongoDb.Obter<EstiloMusical>(e => e.Id.Equals(id)));
        }

        //
        // POST: /EstiloMusical/Editar/1

        [HttpPost]
        public ActionResult Editar(EstiloMusical estiloMusical)
        {
            try
            {
                // TODO: Add update logic here
                mongoDb.Salvar(estiloMusical);

                return RedirectToAction("Index");
            }
            catch
            {
                return View();
            }
        }

        //
        // GET: /EstiloMusical/Excluir/1

        public ActionResult Excluir(ObjectId id)
        {
            return View(mongoDb.Obter<EstiloMusical>(e => e.Id.Equals(id)));
        }

        //
        // POST: /EstiloMusical/Excluir/1

        [HttpPost]
        public ActionResult Excluir(EstiloMusical estiloMusical)
        {
            try
            {
                // TODO: Add delete logic here
                mongoDb.Excluir(estiloMusical);

                return RedirectToAction("Index");
            }
            catch
            {
                return View();
            }
        }
    }
}

Outra classe sem segredo, não fiz validações nem regras de negócio nesse primeiro exemplo, então está tudo muito simples! Um detalhe é que quando vamos Editar ou Excluir precisamos receber um ObjectId e não um int como geralmente é feito.

Antes de continuar algumas imagens da aplicação funcionando.

Como eu disse anteriormente, se o banco de dados não existe, ele será criado automaticamente a primeira vez que for utilizado, isso pode ser visto nas imagens abaixo.

Agora que já possuimos a aplicação funcionando, o banco criado, e temos documentos do tipo EstiloMusical cadastrados, vem a melhor parte, e se criarmos mais propriedades na nossa classe EstiloMusical? E o banco? Sem problemas, novos documentos serão salvos com as propriedades a mais, e os antigos continuarão funcionando perfeitamente.

A classe agora ficou assim.

public class EstiloMusical
{
    [MongoIdentifier]
    public ObjectId Id { get; set; }

    public string Nome { get; set; }
    public string Descricao { get; set; }
}

Veja funcionando com um cadastro novo, e editando um Estilo Musical cadastrado anteriormente, mas agora adicionando valor a nova propriedade.

Posso estar muito empolgado, mas achei incrível não precisar ficar mapeando tabelas e classes como nos ORM´s, é um novo mundo, outro conceito, é tudo novo, mas que tem um poder incrível!

Hoje me perguntaram se seria só para projetos pequenos ou também funcionaria com projetos grandes, para responder isso é só olhar aqui a lista de projetos que utilizam o MongoDB.

Clique aqui para pegar o código fonte desse projeto e bons estudos.

Abraços.

A classe StringBuilder ganhou um método chamado Clear que limpa todos os caracteres da sua instância, mais simples impossível x) !

Vamos ao exemplo.

static void Main(string[] args)
{
    var stringBuilder = new System.Text.StringBuilder();
    stringBuilder.Append("www.marcioalthmann.net");
    stringBuilder.Append("www.silverlightplanet.net.br");

    Console.WriteLine("Total de caracteres: {0}", stringBuilder.Length);
    stringBuilder.Clear();
    Console.WriteLine("Total de caracteres após Clear: {0}", stringBuilder.Length);

    Console.Read();
}

E o resultado.

Dica rápida, até o próximo post.

Abraços.

Sempre precisamos verificar o valor de alguma propriedade, controle de tela, se ele foi informado ou não, até a versão 3.5 do .net poderíamos fazer esse tipo de validação de uma forma mais elegante com String.IsNullOfEmpty() que verificar se é null ou não possui valor. Veja abaixo.

var nome = "";

// Não gosto assim!
if(nome == "")
    Console.WriteLine("Nome não informado");

// Muito melhor agora!
if(String.IsNullOrEmpty(nome))
    Console.WriteLine("Nome não informado");

Agora vamos imaginar uma aplicação, e se o usuário apertou a barra de espaço, nossas validações não vão funcionar, afinal espaço não é vazio nem null, então teríamos que fazer por exemplo um .Trim() para remover os espaços e ai sim validar.

var nome = " ";

// Não gosto assim!
if(nome.Trim() == "")
    Console.WriteLine("Nome não informado");

// Muito melhor agora!
if(String.IsNullOrEmpty(nome.Trim()))
    Console.WriteLine("Nome não informado");

Agora com o String.IsNullOrWhiteSpace() também temos a verificação se o conteúdo possui somente espaços.

var nome = " ";

// Não gosto assim!
if(nome.Trim() == "")
    Console.WriteLine("Nome não informado");

// Muito melhor agora!
if(String.IsNullOrEmpty(nome.Trim()))
    Console.WriteLine("Nome não informado");

// Perfeito!
if(String.IsNullOrWhiteSpace(nome))
    Console.WriteLine("Nome não informado");

Se você já usava IsNullOrEmpty aproveite o IsNullOrWhiteSpace, se nunca utilizou já está na hora =] lembrando que só para .net 4.0.

Abraços.

Uma dica rápida, hoje o Felipe Pocchini apareceu desesperado no MSN (falei que falaria sobre você no post hehueue) perguntando como criar um Setup pelo Visual Studio, mas usar automaticamente a pasta AppData do usuário automaticamente.

Bom pra quem nunca viu, com o Visual Studio conseguimos criar projetos de Setup, agora na versão 2010, também tem uma versão do InstallShield, mas como não testei ainda fica para depois um review do mesmo.

O Felipe estava com problema porque ele precisava fazer a instalação de um Gadget, aqueles que ficam no desktop, e os Gadgets precisam ser instalado na pasta C:\Users\{usuariologado}\AppData\Local\Microsoft\Windows Sidebar\Gadgets.

O primeiro problema, e o maior deles é pegar a pasta específica do usuário que está instalando a aplicação, quando estamos criando um projeto de instalação, existe uma pasta chamada Application Folder, onde vamos jogar os arquivos que serão instalados, e essa pasta tem uma propriedade chamada DefaultLocation que é o diretório padrão onde a aplicação será instalada.

Felizmente existem uma lista de palavras chave que indicam pastas especiais do sistema, e utilizando [LocalAppDataFolder] o instalador pega automaticamente a pasta AppData\Local do usuário.

A propriedade DefaultLocation na instalação do Gadget ficaria assim [LocalAppDataFolder]\Microsoft\Windows Sidebar\Gadgets\MeuGadget.

Além da LocalAppDataFolder temos várias outras palavras, segue a lista e documentação oficial.

• AdminToolsFolder
• AppDataFolder
• CommonAppDataFolder
• CommonFiles64Folder
• CommonFilesFolder
• DesktopFolder
• FavoritesFolder
• FontsFolder
• LocalAppDataFolder
• MyPicturesFolder
• PersonalFolder
• ProgramFiles64Folder
• ProgramFilesFolder
• ProgramMenuFolder
• SendToFolder
• StartMenuFolder
• StartupFolder
• System16Folder
• System64Folder
• SystemFolder
• TempFolder
• WindowsFolder
• WindowsVolume

Abraços e até o próximo artigo.

Um amigo estava querendo usar LINQ para obter o valor máximo de um array de strings, ele possuia os valors 90, 120 e 150, o problema de fazer isso com strings é que ela considera 90 o maior valor, para resolver isso no LINQ é simples, veja o código abaixo.

string[] numeros = {"90", "120", "150"};
numeros.Max(x => int.Parse(x));

Abraços.