Microsoft Visual C#

Pegar o nome do mês

Abdul Hade — Sat, 13 Jun 2009 17:39:18 GMT

Vou ser rápido nessa, então vamos lá. Quando queremos saber o nome do mês basta usar a seguinte função:

Usamos a NameSpace:

using System.Globalization;

Comando:

DateTimeFormatInfo.CurrentInfo.GetMonthName(numero do mês);

Rápido não?! Nessa classe CurrentInfo podemos também trazer outras informações como, por exemplo,

abreviatura de mês, calendários, dias da semana, obter formatos e muitas outras coisas.

Pegar o MacAddress

Abdul Hade — Sat, 13 Jun 2009 17:16:44 GMT

Estou tentando fazer isso desde que eu comecei a programar, e agora de tanto pesquisar sobre o assunto, consegui material suficiente para o artigo!

Primeiro adicione a namespace System.Management, pelo seguinte modo: Project/Add Reference. Abaixo o código para pegar o endereço físico da sua máquina:

// Através deles podemos consultar informações sobre aplicações , serviços e dispositivos do sistema.
// A classe ManagementClass serve para consultar as informações sobre aplicações, serviços e
// dispositivos do sistema relacionados ao WMI, nesse caso eu estou usando para
// consultar a classe "Win32_NetworkAdapterConfiguration"
ManagementClass MgnClss = new ManagementClass("Win32_NetworkAdapterConfiguration");

// A Classe ManagementObjectCollection serve para o obter a coleção de instancias do objeto acima
ManagementObjectCollection MgnObjtColtn = MgnClss.GetInstances();

//Ele percorre a coleção de objetos e mostra o MAC ADDRESS do primeiro adaptador de rede encontrado.

//Você pode achar muitas outras informações: saiba mais!
foreach (ManagementObject MgnObjt in MgnObjtColtn) {

//Mostra a mensagem com o MAC ADRESS
MessageBox.Show(MgnObjt["MacAddress"].ToString());
break; }

Eu aconselho, se tiver dúvidas, por que também tive, testar se é mesmo o seu MAC ADRESS, abrindo o DOS e digitando ipconfig /all. Nunca se sabe né...rsrs...até próxima!.

Validando Arquivos

Abdul Hade — Sat, 13 Jun 2009 17:01:00 GMT

‘Hoje, graças ao avanço da tecnologia, temos muitas facilidades para guardar nossos arquivos na Internet, como por exemplo, SkyDrive da Microsoft, que é um HD virtual de 25 Gigabytes , você pode guardar seus arquivos.

A única dificuldade disso tudo é você ter que validar isso, os controles do Visual Studio 2005 e 2008, não contém parâmetros para você poder configurar limite de tamanho, tipos de arquivos e outras coisas que você tem fazer no código.

E para ajudar vocês nisso, eu irei colocar alguns métodos que fazem várias validações.

Irei começar falando sobre MimeType do arquivo, ou seja, o tipo dele.

Primeiro, irei criar parâmetros que me ajudaram a validar isso. Criarei eles no Web.Config, na parte de AppSettings, por que lá conseguimos alterar seu valor, mesmo quando a aplicação já esta em produção, ou seja, caso queira mudar alguma especificação do arquivo, basta mudar.

Segue os parâmetros:

colecaoMimeType - Colocaremos os tipos de arquivos separando por (;).
Value - Application/exe

sizeFile - Aqui será o valor do tamanho máximo permitido do arquivo.
Value- 1048576

NoChars - Caracteres não permitidos nas imagens.
Value - "+=´`~^º°;:,!@#$%¨*()-?:{}][ÄÅÁÂÀÃäáâàãÉÊËÈéêëèÍÎÏÌíîïìÖÓÔÒÕöóôòõÜÚÛüúûùÇçñÑ"

YesChars -Caracteres que serão usa do para substituir os de cima.
Value = "___________________________AAAAAAaaaaaEEEEeeeeIIIIiiiiOOOOOoooooUUUuuuuCcnN_"

Depois iremos criar os seguintes métodos:

        /// <summary>
        /// Valida o tipo do arquivo
        /// </summary>
        /// <param name="tipoM">recebe o tipo de arquivo</param>
        /// <returns>retorna se o tipo é valido de acordo a appSettings no web.config</returns>
        protected bool validaTipoArquivo(string tipo)
        {

            bool eValido = true;

            string[] arrayMimeType = ConfigurationManager.AppSettings["colecaoMimeType"].Split(';');

            foreach (string mimeType in arrayMimeType)
            {
                if (tipoMime == mimeType)
                {
                    eValido = false;
                    break;
                }
            }
            return eValido;

        }
        /// <summary>
        /// Valida o tamanho da imagem
        /// </summary>
        /// <param name="tamanhoArquivo">recebe o tamanho da imagem</param>
        /// <returns>retorna se o tamanho é valido de acordo a appSettings no web.config</returns>
        protected bool validaTamanhoArquivo(int tamanhoArquivo)
        {

            bool eValido = false;
            int sizeLimit = int.Parse(ConfigurationManager.AppSettings["sizeFile"]);

            if (fileSize < sizeLimit)
                eValido = true;

            return eValido;

        }


        /// <summary>
        /// Substitui o caracteres especiais, por caracteres normais ou válidos.
        /// </summary>
        /// <param name="word">recebe o nome da imagem</param>
        /// <returns>retorna a imagem com os caracteres especiais substituidos</returns>
        public static string validaNomeArquivo(string nomeArquivo)
        {

            string forbidden = ConfigurationManager.AppSettings["NoChars"];
            string allowed = ConfigurationManager.AppSettings["YesChars"];
    //Substitui caracteres inválidos pelos válidos.
            for (int i = 0; i < forbidden.Length; i++)
            {
                word = word.Replace(forbidden.ToString(), allowed.ToString()).Trim();
            }

            return word;

        }

Serializando Arquivos Xml com Namespace

Marcos Sabino Filho — Mon, 08 Jun 2009 20:53:00 GMT

Olá pessoal,

Semana passada recebi um desafio muito interessante, e que gostaria de compartilhar com todos. O desafio foi que não estávamos conseguindo serializar objetos com Namespaces. Uma definição para Namespace em arquivos Xml segundo o w3schools é que eles servem para eliminar a duplicidade dos elementos.

Para quem não sabe o que é o namespace em um arquivo xml, aqui vai um exemplo (destacado pelo quadrado vermelho):

Agora que já sabemos o que é e para que serve, vamos criar um modelo do documento acima.
Para isso precisamos seguir alguns passos:

Criar um projeto do tipo Console Application
Adicionar à solution um projeto do tipo Class Library.
1. Adicionar a classe Perguntas
2. Adicionar a classe Pergunta

A codificação para o arquivo Perguntas.cs deverá ser a seguinte:

[Serializable]
[XmlRoot(ElementName = "Perguntas")]
public class Perguntas {

    private int _id;
    private List<Pergunta> _pergunta;

    public Perguntas() {
        _pergunta = new List<Pergunta>();
    }

    [XmlAttribute(AttributeName = "ID")]
    public int ID {
        get { return _id; }
        set { _id = value; }
    }

    [XmlElement(ElementName = "Pergunta")]
    public List<Pergunta> Pergunta {
        get { return _pergunta; }
        set { _pergunta = value; }
    }

}

A codificação para o arquivo Pergunta.cs deverá ser a seguinte:

[Serializable]
[XmlRoot(ElementName = "Pergunta")]
public class Pergunta {

    private string _TextoPergunta;
    private string _resposta;

    public Pergunta() {
        // EMPTY CONSTRUCTOR
    }

    public Pergunta(string pergunta, string resposta) {
        _TextoPergunta = pergunta;
        _resposta = resposta;
    }

    [XmlElement(ElementName = "TextoPergunta")]
    public string TextoPergunta {
        get { return _TextoPergunta; }
        set { _TextoPergunta = value; }
    }

    [XmlElement(ElementName = "Resposta")]
    public string Resposta {
        get { return _resposta; }
        set { _resposta = value; }
    }

}

Depois de deixar a estrutura pronta. Vamos até o arquivo Program.cs do projeto Console Application.
Com a classe aberta vamos codificar o seguinte:

static void Main(string[] args) {

    Perguntas perguntas = new Perguntas();
    perguntas.Pergunta.Add(new Pergunta("1- Como devo fazer isso?", "Você não pode fazer isso."));
    perguntas.Pergunta.Add(new Pergunta("2- E se eu não conseguir?", "Tente de outra forma."));

    XmlDocument documento = new XmlDocument();

    string respostaXml = Serializar(perguntas);

    documento.LoadXml(respostaXml);

    documento.Save(@"c:\temp\xmlNameSpace.xml");
}

/// <summary>
/// CLASSE RESPONSÁVEL PARA SERIALIZAR OS OBJETOS
/// </summary>
/// <param name="objeto">Uma variável do tipo Referência</param>
/// <returns>Retorna uma string contendo o objeto serializado. (formato XML)</returns>
public static string Serializar(object objeto) {
    StringWriter result = new StringWriter();
    XmlSerializer xmlTrace = new XmlSerializer(objeto.GetType());

    try {
        xmlTrace.Serialize(result, objeto);
    } catch (Exception ex) {
        xmlTrace.Serialize(result, ex);
    } finally {
        result.Close();
    }

    return result.ToString();
}

Com tudo codificado, vamos agora executar a aplicação. E se o processo ocorreu sem problemas, vamos até a pasta “c:\temp” e abrir o arquivo xmlNameSpace.xml. Ele deverá estar exatamente igual a primeira imagem deste artigo.

Até agora fizemos o simples. Como podemos deixar o arquivo com prefixos igual à imagem abaixo?

Para isso, devemos adicionar dois namespace. O namespace é composto principalmente de duas coisas:

A url de definição e
Um Prefixo.

O primeiro passo é avisar para a função de serialização que serão adicionados dois namespaces ao processo. Para isso devemos ir na função serializar e deixá-la da seguinte forma:

public static string Serializar(object objeto) {
    StringWriter result = new StringWriter();
    XmlSerializer xmlTrace = new XmlSerializer(objeto.GetType());

    /*
     * NAMESPACES DE VALIDAÇÃO
     */
    XmlSerializerNamespaces ser = new XmlSerializerNamespaces();
    ser.Add("marcos", "http://www.marcossabino.com");
    ser.Add("sabino", "http://marcossabinofilho.spaces.live.com");
    /*
     * ADICIONANDO O "" NO NAMESPACES, É ELIMINADO O LIXO DO PROCESSO
     */
    ser.Add("", ""); 

    try {
        xmlTrace.Serialize(result, objeto, ser);
    } catch (Exception ex) {
        xmlTrace.Serialize(result, ex);
    } finally {
        result.Close();
    }

    return result.ToString();
}

O próximo passo é ir na classe Pergunta e adicionar o seguinte parâmetro nas propriedades:

Agora é só rodar e ver o resultado:

Essa técnica de usar os namespace, pode ser usado direto com os elementos, tanto para os atributos do Node.

Agora que eu já tive um desafio, que tal passar vocês tentarem deixar o arquivo xml igual o abaixo?

Referência

[ W3Schools – Xml Namespaces ]

Espero que tenham gostado,
[]’s

Auto Complete com Highlight no ASP .NET AJAX

Abdul Hade — Tue, 02 Jun 2009 12:38:00 GMT

O ASP .NET AJAX nos trouxe um leque de facilidades para deixar nossas aplicações com uma melhor experiência do usuário. E o mais legal de tudo, é que conseguimos agregar mais funcionalidades a ele, alterando seu código fonte e criando uma nova versão da DLL. No meu caso, foi um pouco diferente. Eu precisava fazer com que, conforme a pessoa iria digitando, na lista abaixo, o texto ficasse em negrito, e para isso eu apenas criei um JavaScript, não precisando gerar outra DLL do AJAX. Para entender melhor, veja a imagem abaixo:

Figura 01

Note na Figura 01, que conforme eu vou digitando, o mesmo texto fica em negrito, e é isso que iremos fazer agora.

Vamos supor que você já tenha criado o seu projeto, adicionado o seu controle AutoCompleteExtender, configurado seu Webservice, ou seja, o necessário para que ele funcione corretamente.

Finalizando isso, iremos adicionar a seguinte classe na CSS:

.AutoComplete_ListItemHighlightText {
    font-weight:bold;
}

E depois iremos adicionar os seguintes métodos em “JavaScript”:

function ClientPopulated(source, eventArgs) {

    if (source._currentPrefix != null) {

        var list = source.get_completionList();
        var search = source._currentPrefix.toLowerCase();

        for (var i = 0; i < list.childNodes.length; i++) {

            var text = list.childNodes.innerHTML; 
            var index = RetiraAcentos(text).toLowerCase().
                    indexOf(RetiraAcentos(search).toLowerCase());

            if (index != -1) {

                var value = text.substring(0, index);
                value += '<span class="AutoComplete_ListItemHighLightText">';
                value += text.substr(index, search.length);
                value += '</span>';
                value += text.substring(index + search.length);

                list.childNodes.innerHTML = value;

            }

        }
    
    }

}

O método acima aplica a classe AutoComplete_ListItemHighLightText nos itens da lista que contenham o texto procurado.

A função abaixo apenas regulariza o texto, substituindo as letras com acento para as sem acento. Ela é necessária, por que nem sempre os itens listados no AutoComplete estão com acento, ou seja, escritos corretamente. Voltando na Figura 01, podemos perceber que mesmo digitando apenas a palavra “sao”, a função destaca também os “são”, e é graças a esse método que isso acontece.

function RetiraAcentos(txt) {

    var Acentos = "áàãââÁÀÃÂéêÉÊíÍóõôÓÔÕúüÚÜçÇabcdefghijklmnopqrstuvxwyz";
    var Traducao ="AAAAAAAAAEEEEIIOOOOOOUUUUCCABCDEFGHIJKLMNOPQRSTUVXWYZ";
    var Posic, Carac;
    var TempLog = "";
    var value = txt.toUpperCase();

    for (var i=0; i < txt.length; i++) {
        
        Carac = value.charAt(i);
        Posic = Acentos.indexOf(Carac);

        if (Posic > -1)
            TempLog += Traducao.charAt(Posic);
        else
            TempLog += value.charAt(i);
    }

    return TempLog;

}

E essa trata o conteudo selecionado, ou seja, preenche o campo com o item selecionado.

function itemSelected(source, ev) {

    var index = source._selectIndex;
    var dd = source.get_completionList().childNodes[index]._value;
    source.get_element().value = dd;
}

E agora iremos atribuir o método ClientPopulated no evento OnClientPopulated e itemSelected no evento OnClientItemSelected do controle AutoCompleteExtender.

Pronto! Seu controle está mais completo. Agora é esperar que nas futuras versões isso seja agregado ao Framework do ASP .NET AJAX.

.NET Framework – Parte II: Entendendo um pouco mais

Abdul Hade — Tue, 02 Jun 2009 12:27:00 GMT

Já vimos para o que é utilizada a ferramenta, como ela funciona e agora iremos ver o que é cada componente no artigo .NET Framework – Parte I.

Common Language Specification

Como tudo deve ter um padrão e regras a serem cumpridas, as linguagens suportadas pela ferramenta também tem, e por isso que, quando temos duas aplicações feitas em linguagens diferentes, não temos problemas em conseguir usar os recursos desenvolvidos em uma na outra. E esses padrões e regras são baseados no CTS (Common Type System). No CTS podemos encontrar regras de nomenclatura, definições para letras maiúsculas e minúsculas, palavra-chave, tipos, métodos, propriedades, eventos, interfaces, matrizes, Enumerações, genéricos e etc.

Tipos de Soluções

Windows Forms – São aplicações desenvolvidas para ambientes locais, ou seja, totalmente instaladas no computador do usuário, como por exemplo, aplicações Cliente/Servidor. Nesse tipo não há necessidade de requisições ao servidor, a não ser quando existe um servidor de base de dados, pelo qual o sistema acessa as informações para ser mostrada nos formulários, fora isso, toda execução é feita dentro do computador onde está instalado. Sua interface é baseada em controles prontos e pré-configurados. Esses controles, além de serem usados para visualização de informações trazidas de uma base de dados, podem servir como entrada de texto ou na necessidade de relacionamento entre qualquer outro controle, como por exemplo, os objetos DataGridView, utilizado para mostrar, consultar ou inserir/editar/excluir as informações, e ComboBox. Também temos as caixas de texto, caixa de multi seleção, caixa de opções, entre muitos outros objetos. Alguns desses controles servem apenas para melhorar a interface do aplicativo.

Hoje, o Windows Forms nos trás muitas facilidades na hora de criar sua versão de instalação. Com apenas alguns cliques você consegue cria - lá, e ainda podemos publicar em algum lugar onde os usuários de uma rede possam acessar as futuras versões, por que a atualização é feita automaticamente antes ou depois da aplicação ser aberta.

Web Forms – com certeza a evolução na interface de páginas de Web. Muito parecido com o Windows Forms, ele foi criado para o ASP .NET, e é formado por HTML estático e/ou controles ASP .NET. Da mesma forma que o Windows Forms, ele também separa o design (HTML da página) do código-fonte, e usa o arrastar e soltar, para criar os controles dentro das páginas, onde eles também já estão pré-configurados. Hoje, esse tipo de aplicação nos das inúmeras possibilidades, onde podemos desde poder arrastar controles na página em tempo de execução, mudar as cores da página de acordo com o gosto do usuário, até fazer requisições ao servidor da aplicação sem ter que recarregar a página inteira, tornando esse tipo de aplicação sem limites de recursos, mais rica, intuitiva e muito mais fácil de usar.

Também nos trás muitas facilidades quando queremos trazer informações de alguma base de dados. E controles como, por exemplo, RadioButtonList, DataGrid, DataList, ListBox, podemos facilmente configurá-los, e às vezes somos obrigados a colocar algumas linhas de código, mas não se preocupe, por que o número será muito pouco.

Web Services – se hoje nós podemos criar serviços onde qualquer aplicação codificada no .NET Framework pode acessar sem nenhuma restrição, é por causa dele – o Web Services. Sua idéia principal é justamente essa - serviços Web – nos possibilitando, as aplicações se comunicarem sem qualquer limite. E para tornar isso possível, a tecnologia trabalha com SOAP (Simple Object Access Protocol), autorizada pelo W3C, é ela que torna possível a comunicação entre esses serviços, utilizando o XML como meio de transporte das informações e o HTML para transferir os dados.

Tipos de acesso a dados

E por sua causa que temos muitas facilidades e pouco tempo de desenvolvimento na hora de criarmos os objetos de acesso a dados. É ele quem torna possível a utilização de inúmeros tipos de base de dados como, por exemplo, banco de dados SQL Server, ORACLE entre outros, arquivos XML, texto ou planilhas do EXCEL, ou coleção de objetos.

Mas as reais funcionalidades não são apenas acessar esses milhares tipos de base de dados, e sim é que podemos fazer as consultas, inserção, paginação, exclusão e alteração dos dados contidos nelas, com uma facilidade imensa, tornando mais ainda rápida a forma de programá-las, deixando sua mente focada nas regras de negócio mais importantes.

Definindo melhor, podemos dizer que existem os controles de acesso a dados que fazem alguma ação para trazer essas informações. SQLDataSource, ObjectDataSource e XMLDataSource são os principais objetos de conexão a esses dados, um para apenas SQL, outro apenas para uma lista de objetos qualquer e a outra para utilizar com arquivos XML, respectivamente, como sua origem de dados. Já os controles DataList, DetailsView, DataGrid entre outros, são os responsáveis por fazer essa requisição e mostrar essas informações, independentemente do tipo da base de dados, e os quais utilizam os objetos de acesso para isso.

Biblioteca de Classes

Objetos na tela, meios de acesso a base de dados, validações em geral e/ou qualquer função ou tipo de objeto que você queira, faz parte dessa biblioteca. Na verdade, isso é a base do .NET Framework, ou seja, é por causa delas que podemos, tão rapidamente, desenvolver uma tela trazendo dados do banco, editar suas informações, fazer cálculos entre inúmeras outras coisas.

Mais abaixo, iremos falar sobre as classes mais conhecidas e usadas do .NET Framework.

Namespace	Descrição
System;	É a base de todas as classes, sem ela definida, seu código não será nada, ou seja, você não conseguirá codificar. E como vocês irão ver mais abaixo, ela é sempre a primeira a aparecer antes de chamar qualquer outra. Resumindo, ela é a namespace mãe das outras.
System.Collection;	Todo tipo de coleção, faz parte dessa namespace. Coleções de objetos, interfaces, dicionários, ou seja, qualquer coleção que você imaginar, pode procurar aqui.
System.Data;	Conexão com o banco, objetos relacionados a executar comandos de qualquer tipo ou relacionamento, componentes de gerenciamento em geral de banco de dados, ou seja, toda a estrutura do ADO .NET.
System.Diagnostics;	Permite-nos diagnosticar nossa depuração e buscar execução de código, e também nos oferece classes que atuam como contadores de desempenho, com processos do sistema operacional e log de eventos.
System.Drawing;	Mãe de todas as classes e namespaces de gráficos GDI+. Quando você quiser desenhar algo na tela, tanto em duas como em três dimensões, pense nesse grupo de classes.
System.Globalization;	Informações de linguagens, culturas, padrões de formatação, ordem de caracteres, moeda, ou seja, quando você quiser desenvolver um sistema multi linguagem, nós usaremos esse conjunto de funções para nos ajudar na configuração desses elementos.
System.IO;	Quando queremos ler ou salvar um arquivo de forma, tanto quando a origem e o destino estão sincronizados como quando não estão.
System.Media;	Iremos utilizá-la quando trabalhamos com som dentro de nossa aplicação.
System.Net;	Possibilita-nos usar de maneira fácil e rápida os vários protocolos de redes que existem hoje em dia. Também contamos com classes para envio e recebimento de e-mail.
System.Security;	É composta por classes que irão cuidar da segurança de sua aplicação.
System.Text;	Tipos de enconding, ASCII, conversores em geral e formatação de textos estão contidas nessa namespace.
System.Web;	Conjunto de classes e interfaces base de uma página Web. Podemos também encontrar classes de gerenciamento de cookies, envio de arquivos, cachê e etc.
System.Xml;	Para gerenciamento de arquivos de XML, você pode contar com esse grupo de classes.

Enfim, são inúmeras as namespaces que formam .NET Framework. Hoje, ele nos da tantas funcionalidades, que talvez seja impossível nós desenvolvedores imaginar algo que ele não possa fazer.

Common Language Runtime

Sua função é de criar uma máquina virtual toda vez que uma aplicação é executada em desenvolvimento. Quando executamos uma aplicação, todo código escrito passa pelo compilador, que é transformado em a Assembly, ou seja, ele traduz em Common Intermediate Language (CIL), e o CRL transforma em código que o sistema operacional possa entender. Explicando de forma fácil, ele é quem traduz o código, seja ele escrito em qualquer linguagem de programação suportada pelo .NET Framework, para a linguagem de máquina. E também é responsável pela possibilidade das linguagens interagirem entre si, e isso acontece por que existe um padrão chamado CLS, o qual nós já vimos.

Conclusão

Espero que todos tenham entendido como funciona cada parte do .NET Framework, continuaremos com a história dele no próximo artigo.

Explorando Data/Hora

Abdul Hade — Tue, 02 Jun 2009 11:53:00 GMT

Especificações: Visual Studio 2005 Professional; Linguagem: CSharp.

Abdul Hade
Nesse artigo mostro alguns exemplos do que pode ser feito com um campo data/hora.

Diferenças entre datas
Para obtermos intervalo entre duas datas primeiramente, criamos um novo projeto, e no formulário, adicionamos dois DateTimePicker, dois Label e um Button, de modo que fique como a Figura 1.

Figura 1.

No botão, insira o seguinte código-fonte:

//Cria uma variável do tipo DateTime a preenche ela com o valor do DateTimePicker
DateTime MesAno = Convert.ToDateTime(MesAnoDateTimePicker.Text); Total de dias de um mês especifico
É apenas uma linha. Existe uma classe para isso:
Vamos criar uma form e deixá-lo igual à Figura 2:

Figura 2.

E insira o código abaixo no botão:

Soma de Horas: Essa é um pouco complicada, mas é muito interessante. Primeiro crie um form, deixando-o como a figura3:

Figura 3.

Depois adicione a função abaixo a sua classe de negócios:

//Com o System.DateTime.DaysInMonth(Ano selecionado no objeto, Mes selecionado no objeto)
MessageBox.Show(System.DateTime.DaysInMonth(MesAno.Year, MesAno.Month).ToString());

private string SomaHoras(DateTime Data1, DateTime Data2) { Pronto! Fico por aqui, até o próximo artigo.

Conclusões
Enfim, com data e hora podemos fazer uma infinidade operações, mais para frente faremos isso.

            /*Variáveis e os valores para o cálculo */
            int Hora1 = Data1.Hour, Hora2 = Data2.Hour, Min1 = Data1.Minute,
                Min2 = Data2.Minute, Seg1 = Data1.Second, Seg2 = Data2.Second,
                TotalHoras = 0, TotalMin = 0, TotalSeg = 0;

            /*Atribui a soma dos segundos a TotalSeg*/
            TotalSeg = Seg1 + Seg2;

            /*Se o total da soma for igual ou maior o que 60, então é considerado como minuto*/
            if (TotalSeg >= 60) {

/*Se sim, é jogado o valor '1'*/
TotalMin = 1;

                /*e lhe é subtraido 60 segundos*/
                TotalSeg = TotalSeg - 60;
            }

/*Soma entre os minutos e teremos o total de minutos*/
TotalMin += Min1 + Min2;

/*Se o total da soma for igual ou maior o que 60, então é considerado como Hora*/
if (TotalMin >= 60) {

/*Se sim, é jogado o valor '1'*/
TotalHoras = 1;

/*e lhe é subtraido 60 minutos*/
TotalMin = TotalMin - 60;

}

/*Depois somamos as horas, se quizer fazer mais um if para as horas fique a vontade*/
TotalHoras += Hora1 + Hora2;

/*Retorna a soma entre as duas horas*/
return (string.Format("{0}:{1}:{2}", TotalHoras.ToString("00"), TotalMin.ToString("00"), TotalSeg.ToString("00")));

}

Agora adicione esse código ao botão:

public partial class FormDtHr : Form {

        //Declara a sua classe de negócios para acessar as funçoes.
        ClassNegocios Funcoes = new ClassNegocios();

        private void SomarButton_Click(object sender, EventArgs e) {

/*Mostra em uma mensagem o retorno da função que foi criada, passando as duas datas*/
MessageBox.Show(Funcoes.SomaHoras(Convert.ToDateTime(Vl1DateTimePicker.Text), Convert.ToDateTime(Vl2DateTimePicker.Text)).ToString());

}

//Cria uma variavel do tipo DateTime, que será preenchida com um valor da
//tabela, que será convertido em Datetime.
DateTime DTInicial = Convert.ToDateTime(IniDateTimePicker.Text);

//Cria uma variavel do tipo TimeSpan, que receberá a subtração
//DTFinal - DTInicial = DTResultado.
TimeSpan DTResultado = DTFinal.Subtract(DTInicial);

// Mostra uma mensagem intervalo entre as duas datas.
MessageBox.Show(DTResultado.ToString());

// Utilizei o DateTimePicker, por que com ele, não tenho problema com rotinas para validação de data.

Criando Log com a Enterprise Library

Marcos Sabino Filho — Tue, 02 Jun 2009 01:47:00 GMT

Olá pessoal,

Hoje vou comentar um assunto que muito me agrada no processo de desenvolvimento.
A criação de log’s. Os log’s são de extrema importância em qualquer aplicação.
Atire a primeira pedra aquele que nunca deu um Response.Write no ambiente de produção com a fonte na cor branca?

Quem já fez, com certeza deve estar morrendo de rir neste exato momento.
Quem não fez, deve estar pensando: ”Putz, como eu nunca pensei nisso antes?”.

Pensando nisso eu decidi criar um post introdutório em como usar a biblioteca
Microsoft.Practices.EnterpriseLibrary.Logging. Então vamos ao que interessa e criar uma aplicação.

O primeiro passo é criar um projeto do tipo “Web Application”. Dê um nome ao projeto que mais agrade você. Eu criei como “ArtigoLog_EL”.

Com o projeto criado, temos que adicionar 3 dll’s ao projeto:

Microsoft.Practices.EnterpriseLibrary.Common
Microsoft.Practices.EnterpriseLibrary.Logging
Microsoft.Practices.EnterpriseLibrary.Logging.Configuration.Design

O próximo passo é configurar os parâmetros do Log. Para isso clicamos com o botão direito em cima do arquivo “Web.config” e selecionar a opção ”Edit Enterprise Library Configuration”.

Essa ação irá fazer com que a tela de configuração apareça.

A tela é bem direta e simples. Nessa tela podemos configurar qualquer objeto quando se trata de Enterprise Library.

O passo seguinte será criar o bloco de configuração para log.
Para criar esse bloco, devemos clicar com o botão direito do mouse em cima da pasta de configuração, em seguida em “New” e depois em “Logging Application Block”.

Quando o logging application block é criado, uma configuração padrão é criada.
Como o nosso intuito aqui é aprender, vamos limpar toda a configuração e deixar igual à imagem abaixo:

Vocês podem notar abaixo que apenas uma configuração não foi removida, a configuração dos formatos. A imagem abaixo mostra o porque não foi apagada.

O motivo é por que ela já vem com todas as informações úteis para descobrirmos qual a origem do erro. Como tem as informações que precisamos, não vamos mudar. Como diz o ditado “Em time que está ganhando não se meche”.

O próximo passo é criar um “Trace Listeners”. Esse cara é responsável em gerar um output das informações. Ou seja, Ele vai salvar a string da mensagem template (imagem acima). Para saber quais são as formas possíveis, clique com o botão direito do mouse sobre o “Trace Listener” em seguida em “New”. Uma lista com as opções será mostrada. Para saber mais sobre as opções visite a seção “Referência” no final deste artigo. Para demonstrar o funcionamento, vou usar a opção “Flat File Trace Listener”, que nada mais é do que um txt comum.

Assim que o Trace Listener estiver criado, devemos fazer alguns ajustes nas propriedades.
Vamos ajustar as propriedades “Filename”, “Formatter” e “Name”, deixando-as igual a imagem abaixo:

Para finalizar as configurações do log, temos que criar uma referência em categorias a esse “Trace Listener” que acabamos de criar.

Clique com o botão direito em “Category Sources” –> “General”

Após a criação da referência, devemos atualizar a propriedade “ReferencedTraceListener” para “ArquivoFisico” (TraceListener criado no passo anterior).

Pronto, as configurações do LOG estão criadas. Agora vamos usá-las.

Dentro do evento “Page_Load” vamos colocar o seguinte código:

protected void Page_Load(object sender, EventArgs e) {
    LOG.LogEntry logEntry = new LOG.LogEntry();

    logEntry.Categories.Add("General");
    logEntry.Severity = TraceEventType.Information;
    logEntry.Title = "Título Log Erro";
    logEntry.Message = "Mensagem de erro que queremos logar.";

    LOG.Logger.Write(logEntry);
}

O próximo passo é executar a aplicação. Assim que a página terminar sua execução, se você abrir o arquivo de log ( como configurado para o LOG - “C:\temp\trace.log”) devemos ter o seguinte resultado:

Até a próxima pessoal.

Referência

[ MSDN – Loggin Application Block ]

Conclusão

Com essa introdução, espero que a imagem de simplificar o log dos aplicativos tenha melhorado.
Normalmente vemos o log como a fase 2 do projeto. Se essa parte do projeto for bem contruída,
com certeza o log será um show a parte do sistema.

Criptografando sessões da Web.config

Marcos Sabino Filho — Tue, 02 Jun 2009 01:46:00 GMT

Olá pessoal,

Infelizmente é de conhecimentos de poucos que o arquivo web.config é inacessível.
Quando digo inacessível, quero dizer através da url.

Tente por curiosidade acessar o arquivo web.config de uma aplicação .net.
Vocês irão notar uma mesangem de erro parecida com a imagem abaixo.

.gif" width="594" border="0" />

Mas algumas vezes esse arquivo pode cair nas mãos erradas.
Imagine se as configurações abaixo cair nas mãos erradas?
Pode ser incalculável o prejuízo.

<appSettings>
    <add key="PathXmlConfig" value="c:\config\"/>
    <add key="ChaveCriptografia" 
         value="fgnjkuit7435jksd76435437843hf78902435h"/>
</appSettings>
<connectionStrings>
    <add name="ConexaoBanco" 
        connectionString="Data Souce=192.168.0.7;
        Initial Catalog=Vendas;
        User ID=sa;
        Password=sa;"/>
</connectionStrings>

Essas são informações que normalmente estão presentes no arquivo.
Para dar mais segurança aos nossos aplicativos, vamos criptografar a sessão “ConnectionStrings”.

Para criptografar a sessão vamos usar o comando “aspnet_regiis”.
Para mais detalhes, visite a sessão “Referência” ao final deste artigo.

O comando é bem simples.

aspnet_regiis.exe -pef [Sessão] [Pasta_Web_Config]

O comando vai fazer com que a sessão “connectionStrings” fique assim:

<connectionStrings 
    configProtectionProvider="RsaProtectedConfigurationProvider">
    <EncryptedData Type="http://www.w3.org/2001/04/xmlenc#Element"
     xmlns="http://www.w3.org/2001/04/xmlenc#">
        <EncryptionMethod 
           Algorithm=http://www.w3.org/2001/04/xmlenc#tripledes-cbc />
        <KeyInfo xmlns="http://www.w3.org/2000/09/xmldsig#">
            <EncryptedKey xmlns="http://www.w3.org/2001/04/xmlenc#">
                <EncryptionMethod 
                   Algorithm="http://www.w3.org/2001/04/xmlenc#rsa-1_5"/>
                <KeyInfo xmlns="http://www.w3.org/2000/09/xmldsig#">
                    <KeyName>Rsa Key</KeyName>
                </KeyInfo>
                <CipherData>
                    <CipherValue>
                       CtnUf1Oeki4zi9VdhFooOxvU/eZ+…
                    </CipherValue>
                </CipherData>
            </EncryptedKey>
        </KeyInfo>
        <CipherData>
            <CipherValue>
                kzh5uaOfXEsrz/U3yp4gAMX1NfOdeqs+mnq0…
            </CipherValue>
        </CipherData>
    </EncryptedData>
</connectionStrings>

Eu minimizei o conteúdo da tag “CipherValue”, por que o conteúdo é muito grande.

Para fazer o caminho de volta, vamos usar o mesmo comando, só que com o parâmetro “pdf”
no lugar de “pef”. O comando ficará assim:

aspnet_regiis.exe -pdf [Sessão] [Pasta_Web_Config]

E para demonstrar que esse comando funciona em qualquer sessão, vou usá-lo na sessão appSettings.

O resultado será o seguinte:

<appSettings configProtectionProvider="RsaProtectedConfigurationProvider">
    <EncryptedData Type="http://www.w3.org/2001/04/xmlenc#Element"
     xmlns="http://www.w3.org/2001/04/xmlenc#">
        <EncryptionMethod 
            Algorithm="http://www.w3.org/2001/04/xmlenc#tripledes-cbc" />
        <KeyInfo xmlns="http://www.w3.org/2000/09/xmldsig#">
            <EncryptedKey xmlns="http://www.w3.org/2001/04/xmlenc#">
                <EncryptionMethod 
                    Algorithm="http://www.w3.org/2001/04/xmlenc#rsa-1_5"/>
                <KeyInfo xmlns="http://www.w3.org/2000/09/xmldsig#">
                    <KeyName>Rsa Key</KeyName>
                </KeyInfo>
                <CipherData>
                    <CipherValue>X4kpfxvqnVB4ET479PjsBT/Vk58xXL8…
                    </CipherValue>
                </CipherData>
            </EncryptedKey>
        </KeyInfo>
        <CipherData>
            <CipherValue>Fi5Z2wsBL6iaWNOePuK1cIoQocmZKN9AM8Mdba…
            </CipherValue>
        </CipherData>
    </EncryptedData>
</appSettings>

O código abaixo mostra aos céticos que mesmo criptografada a chave pode ser lida normalmente.
Não necessitando que o desenvolvedor descriptografe a sessão appSettings antes de ler.
O visual studio é responsável por fazer isso.

protected void Page_Load(object sender, EventArgs e) {
    Response.Write("Valor da chave <b>PathXmlConfig</b>:&nbsp;");
    Response.Write(ConfigurationManager.AppSettings["PathXmlConfig"]);
    Response.Write("<br />");
    Response.Write("Valor da chave <b>ChaveCriptografia</b>:&nbsp;");
    Response.Write(ConfigurationManager.AppSettings["ChaveCriptografia"]);
}

Podemos notar que o código tem a única e exclusica função de mostrar o conteúdo das chaves,
e não descriptografar. Esse código resulta na tela abaixo.

Até a próxima pessoal.

Conclusão

Podemos concluir que podemos criptografar qualquer sessão do web.config
com o comando aspnet_regiis. Mas tome muito cuidado. Use consciente o comando, por que quanto
mais complexa for a criptografia, mais lenta será a leitura das chaves.

Referência

MSDN - Comando aspnet_regiis

MSDN - Encrypting and Decrypting Configuration Sections

Formatando data com o comando DateTime.toString

Marcos Sabino Filho — Tue, 02 Jun 2009 01:44:00 GMT

Olá pessoal,

Nesse artigo vou demontrar como escrever uma variável do tipo DataTime de diversas formas:
abreviada, por extenso, só o dia, depois só o mês e por aí vai. Pra quem não sabe, eu comecei a programar no VB. E lá tem uma função chamada Format que se encarrega de fazer isso. Ela era usada assim:

MsgBox( Format( Now(), "dddd, yyyy mmmm dd"))

O retorno dessa função era uma caixa de mensagem com a mensagem “Quarta-Feira, 2009 Março 11”. Só que essa função não existe no C#. Para resolver isso, usamos o método .toString() das variáveis do tipo DateTime. Aqui vai um exemplo do equivalente em C# do exemplo em VB:

Console.WriteLine(DateTime.Now.ToString("dddd, yyyy MMMM dd"));

Apenas uma “grande” mudança entre as duas versões, a representação do mês. Agora ele é representado pela letra “M” maiúscula.
Existe dois tipos de formatação que podemos utilizar: padronizada ou custimizada.
A formatação padronizada consiste em uma formatação de data e hora já pronta.
O código abaixo mostra o resultado da utilização de todas as formatações padronizadas.
Para detalhes dos padrões, confira a area Referência no final deste artigo.

static void Main(string[] args) {

    DateTime data = DateTime.Now;

    // ARRAY COM TODOS AS FORMATAÇÕES PADRONIZADAS
    string[] padroes = { "d", "D", "f", "F", "g", "G", "m", "o",
                           "r", "s", "t", "T", "u", "U", "y" };

    for (int i = 0; i < padroes.Length; i++) {
        Console.WriteLine("Padrão \"{0}\", resulta em \"{1}\"",
        padroes,
        data.ToString(padroes));
    }

    Console.ReadKey();
}

A formatação customizada, é o usuário que determina quais informações deverão aparecer.
O código abaixo mostra a utilização de formatações customizadas sebdi usadas separadamente.
Para detalhes dos padrões, confira a area Referência no final deste artigo.

static void Main(string[] args) {

    DateTime data = DateTime.Now;

    // ARRAY COM TODOS AS FORMATAÇÕES PADRONIZADAS
    string[] padroes = { "d", "dd", "ddd", "dddd", 
                           "M", "MM", "MMM", "MMMM", 
                           "y", "yy", "yyy", "yyyy",
                           "HH","HHH","HHHH",
                           "mm"
                       };

    for (int i = 0; i < padroes.Length; i++) {
        Console.WriteLine("Padrão \"{0}\", resulta em \"{1}\"",
        padroes,
        data.ToString(padroes));
    }

    Console.ReadKey();
}

Esse código vai mostrar os seguintes resultados:

Bom, eu mostrei como utilizar as formatações padronizadas e as suas customizações. A formatação é realizada baseada na cultura em que ela é executada. Por exemplo, o resultado acima na cultura en-US, ficaria assim:

Pra finalizar vou mostrar outra forma de formatar a data usando quatro métodos de variáveis DateTime.

- ToShortDateString()
- ToShortTimeString()
- ToLongDateString()
- ToLongTimeString()

O código abaixo demonstra a utilização deles.

static void Main(string[] args) {

    DateTime data = DateTime.Now;

    Console.WriteLine("Comando: data.ToShortDateString(); Retorna: {0}",
                      data.ToShortDateString());
    Console.WriteLine("Comando: data.ToShortTimeString(); Retorna: {0}", 
                      data.ToShortTimeString());
    Console.WriteLine("Comando: data.ToLongDateString(); Retorna: {0}", }
                      data.ToLongDateString());
    Console.WriteLine("Comando: data.ToLongTimeString(); Retorna: {0}",
                      data.ToLongTimeString());

    Console.ReadKey();
}

Conclusão

Bom, espero que tenha demonstrado as diversas forma de escrevar uma data com mais clareza possível.
Para saber mais detalhes, não esqueçam de visitar os link’s que estão em Referência.

Referência

MSDN - Standard Date and Time Format Strings
MSDN - Custom Date and Time Format Strings

Criptografando dados com Enterprise Library

Marcos Sabino Filho — Tue, 02 Jun 2009 01:44:00 GMT

Olá pessoal,

Hoje vou comentar sobre um assunto muito importante: A criptografia.
Muitos desenvolvedores ainda confundem a criptografia com hash. A principal diferença é que no hash não há o caminho de volta, ou seja, depois de criptografado, não podemos descriptografar.

Para demonstrar como fazer criptografia de dados, não vou criar algoritmos altamente complexos e extensos.
Vou usar bibliotecas já prontas que a Microsoft disponibiliza para nós desenvolvedores. Essas bibliotecas são conhecidas como Enterprise Library. A última versão até a presente data é a 4.1. Para detalhes de como fazer o download da biblioteca, visite a sessão “Referências” ao final deste artigo. Dentro deste pacote de bibliotecas, há uma que é responsável em criptografar, o nome dela é a “Criptografy”.

Então vamos ao código:

Depois que a Enterprise Library estiver instalada, devemos criar um projeto do tipo Web Application.
Com o projeto criado, clicamos com o botão direito em cima do arquivo “Web.config” e selecionar a opção
”Edit Enterprise Library Configuration”.

Essa ação irá fazer com que a tela de configuração apareça.

A tela é bem direta e simples. Nessa tela podemos configurar qualquer objeto, quando se trata de Enterprise Library.

O passo seguinte será criar o bloco de configuração para criptografia. Para criar esse bloco, devemos clicar com o botão direito
do mouse em cima da pasta de configuração, em seguida em “New” e depois em “Criptography Application Block”.

Feito isso, o bloco de criptografia será criado com dois tipo de provedores: “Hash” e “Symmetric”.
Como o próprio nome já diz, o primeiro é para criptografia hash (onde não há o caminho de volta) e criptografia simétrica.

Como o nosso exemplo é para criptografia simetrica, vamos criar um provedor para a mesma. Para isso,
novamente devemos clicar com o botão direto do mouse em cima de “Simmetric Providers”, em “New” e “Simmetric Algorithm Provider”.

Logo em seguida uma janela solicitando o provedore de criptografia será aberto. Há vários provedores já prontos.
Você pode escolher o que melhor cabe na sua aplicação. No nosso exemplo vou usar a biblioteca “RijindaeManaged”.

O próximo passo será a escolha da chave de criptografia. Onde você poderá criar uma, usar uma já existente, ou importar uma chave protegida com senha. Vamos criar uma nova. Para isso escolhemos a primeira opção “Create a new key”.

Como vamos criar uma nova chave, devemos informar qual é a chave. Podemos criar a chave de duas formas, digitar uma nossa ou fazer com que o visual studio crie uma. No nosso caso, vamos gerar uma automaticamente. Então assim que a próxima tela se abrir, clique em “Generate” para criar um string com letras e números aleatórios, que irão se tornar a nossa chave. Escolhida a chave, clique em “Next”.

A Enterprise Library precisa de um arquivo fisico para trabalhar. Surge então a necessidade de que seja salvo um arquivo com essas informações, o que nos leva ao próximo passo. Escolha um local onde irá ficar o arquivo. De preferência escolha uma pasta dentro do próprio projeto. Assim que terminar de escolher o local do arquivo, clique em “Next”.

O quinto e último passo da configuração precisa de uma proteção. O que seria de um arquivo responsável pela criptografia, se não fosse protegido não é mesmo? Temos duas formas de fazer essa proteção:

- User mode: somente as aplicações rodando com o usuário logado terá acesso à chave para criptografar e descriptografar uma informação.
- Machine mode: qualquer aplicação rodando na máquina (e somente naquela máquina) terá acesso à chave.

Depois de escolher a proteção do arquivo, clique em “Finish”. Assim terminamos a configuração da bliblioteca para usarmos a criptografia. Agora vamos proteger nossos dados!

Nesse exemplo eu fiz um tela bem simples, onde vamos digitar um texto e clicar para criptografar. O html da página exemplo é o seguinte:

<form id="form1" runat="server">
<div>
    <div style="float: left;">
        <div style="clear: left; float: left;">
            <asp:TextBox ID="TextBox1" runat="server" Width="200px"></asp:TextBox>
            <asp:Button ID="Button1" runat="server" Text="Criptografar"
              OnClick="Button1_Click" />
        </div>
        <div style="clear: left; float: left;">
            <asp:Label ID="Label1" runat="server" Text=""></asp:Label>
        </div>
    </div>
</div>
</form>

Agora vamos programar a criptografia. Mas antes devemos adicionar duas bibliotecas que farão o processo:
- Microsoft.Practices.EnterpriseLibrary.Common e
- Microsoft.Practices.EnterpriseLibrary.Security.Cryptography.
Ambas vão estar na pasta “C:\Arquivos de programas\Microsoft Enterprise Library 4.1 - October 2008\Bin\” (pasta padrão de instalação da Enterprise Library). Agora podemos continuar com o código.

No evento click do botão, vamos colocar o código:

protected void Button1_Click(object sender, EventArgs e) {
    Label1.Text = String.Format(
        "A string do TextBox criptografada ficará assim: <br />{0}",
        Cripto.Cryptographer.EncryptSymmetric("RijndaelManaged", TextBox1.Text));
}

Agora vem a parte mais difícil, testar a aplicação. O resultado deverá ser parecido com a figura abaixo.

Pronto! Agora podemos proteger os dados. Pra finalizar com chave de ouro, vamos fazer o caminho inverso.
Devemos então trocar o código do click do botão.

protected void Button1_Click(object sender, EventArgs e) {
    string dadoCripto =
        Cripto.Cryptographer.EncryptSymmetric(
        "RijndaelManaged",
        TextBox1.Text);
    string dadoOriginal =
        Cripto.Cryptographer.DecryptSymmetric(
        "RijndaelManaged",
        dadoCripto);

    Label1.Text = String.Format(
        "A string do TextBox criptografada ficará assim: <br />" +
        "{0}<br />" +
        "A string original é: <br />" +
        "{1}",
        dadoCripto, dadoOriginal);
}

Esse código terá o seguinte resultado:

[]’s e até a próxima!

Conclusão

Mostrei apenas um dos diversos algoritmos já prontos de criptografia. O que demonstra enorme potencial dessa biblioteca.
Experimente os outros algoritmos. Depois que estiver craque, tente transformar os dados em hash.

Refências

[ Download ]

[ Microsoft Enterprise Library 4.1 – October 2008 ]

Abrindo arquivos em modo compartilhado para leitura e escrita com C#

Marcos Sabino Filho — Tue, 02 Jun 2009 01:40:00 GMT

Olá pessoal,

Hoje eu estava com um problema bem simples de se resolver. Abrir um arquivo texto. Para fazer isso escrevi o código abaixo:

protected void Page_Load(object sender, EventArgs e) {
    FileStream arquivo1 = File.Open(@"c:\temp\exemplo.txt", FileMode.Open, FileAccess.Read);

    arquivo1.Close();
    arquivo1.Dispose();
}

Bem direto o código. Só que o problema surge quando dois acessos simultâneos são feitos no arquivo.
O compilador avisa em tempo de execução que o objeto já está em uso por outro processo.

Para resolver esse problema devemos usar o terceiro construtor.
Nesse construtor conseguimos defininir o tipo de acesso ao arquivo.
Ou seja se ele vai ser compartilhado ou não. Abaixo imagem do construtor.

Ajustando o código para que o arquivo tenha vários acessos simultâneos, ficará dessa forma:

FileStream arquivo1 = 
    File.Open(@"c:\temp\exemplo.txt", FileMode.Open, FileAccess.Read, FileShare.Read);

Pronto. Acesso sem restrições para leitura no arquivo. Só que eu não sou fã de problemas fáceis. Vamos complicar um pouco.

Como escrever nesse mesmo arquivo que está em está em modo de leitura compartilhada?

Para responder essa pergunta eu vou simular dois acessos simultâneos para abertura do arquivo e uma terceira tentativa para abrir e escrever no arquivo. Vamos ao código:

protected void Page_Load(object sender, EventArgs e) {
    FileStream arquivo1 = 
        File.Open(@"c:\temp\exemplo.txt", FileMode.Open, FileAccess.Read, FileShare.Read);

    FileStream arquivo2 = 
        File.Open(@"c:\temp\exemplo.txt", FileMode.Open, FileAccess.Read, FileShare.Read);

    FileStream arquivo3 = 
        File.Open(@"c:\temp\exemplo.txt", FileMode.Open, FileAccess.Write, FileShare.Write);

    arquivo1.Close();
    arquivo1.Dispose();

    arquivo2.Close();
    arquivo2.Dispose();

    arquivo3.Close();
    arquivo3.Dispose();
}

Ao executarmos o código, o erro abaixo é retornado na execução do objeto arquivo3.

Este erro acontece, porque o arquivo “exemplo.txt” está liberado apenas para acesso no modo compartilhado de leitura.
Para resolvermos isso, devemos dar a permissão para leitura/escrita.

protected void Page_Load(object sender, EventArgs e) {
    // ABRINDO ARQUIVO PARA LEITURA/ESCRITA
    FileStream arquivo1 = 
        File.Open(@"c:\temp\exemplo.txt", FileMode.Open, FileAccess.Read, FileShare.ReadWrite);

    // ABRINDO ARQUIVO PARA LEITURA/ESCRITA
    FileStream arquivo2 =
        File.Open(@"c:\temp\exemplo.txt", FileMode.Open, FileAccess.Read, FileShare.ReadWrite);

    // ABRINDO O ARQUIVO PARA LEITURA/ESCRITA
    FileStream arquivo3 =
        File.Open(@"c:\temp\exemplo.txt", FileMode.Open, FileAccess.Write, FileShare.ReadWrite);

    // ESCREVENDO NO ARQUIVO QUE ESTÁ ABERTO POR OUTRO 2 PROCESSOS
    StreamWriter sw = new StreamWriter(arquivo3);
    sw.Write("Escrevendo em um arquivo aberto por outro processo");
    sw.Close();

    // FECHANDO ARQUIVO 1
    arquivo1.Close();
    arquivo1.Dispose();

    // FECHANDO ARQUIVO 2
    arquivo2.Close();
    arquivo2.Dispose();

    // FECHANDO ARQUIVO 3
    arquivo3.Close();
    arquivo3.Dispose();
}

O resultado dentro do arquivo exemplo.txt será este:

Technorati Tags: arquivo,compartilhado,FileMode,Open,FileAccess,Read,FileShare,FileStream,File,abrir

Programação MultiThread com C# – Parte 2

Marcos Sabino Filho — Tue, 02 Jun 2009 01:39:00 GMT

Olá pessoal,

Eu havia terminado a primeira parte do artigo respondendo a pergunta:

“Como faço para executar um código somente depois que todas as threads estiverem finalizadas?”

E respondi a pergunta usando um loop. Mas há uma outra forma de resolver esse problema ( bem mais simples diga-se de passagem ). Usando loop para esse caso vai parecer muito complicado perto do que vou explicar. Vamos à outra forma.

A classe Thread possui um método chamado Join(). O propósito dele é bem simples. Enquanto a Thread não terminar, o sistema fica bloqueado. Para exemplificar o que estou falando, vamos modificar a Main, deixando igual ao código abaixo:

static void Main(string[] args) {
    Calcula calc1 = new Calcula(2);
    Calcula calc2 = new Calcula(3);

    Thread tarefa1 = new Thread(new ThreadStart(calc1.ExecutaCalculo));
    tarefa1.Name = "Tarefa 1";

    Thread tarefa2 = new Thread(new ThreadStart(calc2.ExecutaCalculo));
    tarefa2.Name = "Tarefa 2";

    tarefa1.Start();
    tarefa2.Start();

    tarefa1.Join();

    /*
     * PARA DEMONSTRAR QUE O CÓDIGO ABAIXO SÓ É EXECUTADO
     * QUANDO A THREADS BLOQUEADA FOR FINALIZADA.
     */
    if(tarefa1.ThreadState != ThreadState.Stopped)
        Console.WriteLine("A tarefa 1 ainda não finalizou a execução.");

    if (tarefa2.ThreadState != ThreadState.Stopped)
        Console.WriteLine("A tarefa 2 ainda não finalizou a execução.");

    Console.WriteLine("Todas as threads finalizadas.");
    Console.ReadKey();
}

Se executarmos o código acima vamos obter o seguinte resultado:

Nota-se que o sistema não ficou totalmente bloqueado quando printou na tela “Todas as threads finalizadas.”. Isso aconteceu por que bloqueamos apenas a tarefa1. Quando a tarefa1 terminou sua execução, o sistema continou normalmente.

Para deixarmos o sistema totalmente bloqueado até o término de todas as threads, devemos chamar o Join() para todas as threads que foram iniciadas. Para fazermos isso, devemos deixar o código da Main igual ao abaixo:

static void Main(string[] args) {
    Calcula calc1 = new Calcula(2);
    Calcula calc2 = new Calcula(3);

    Thread tarefa1 = new Thread(new ThreadStart(calc1.ExecutaCalculo));
    tarefa1.Name = "Tarefa 1";

    Thread tarefa2 = new Thread(new ThreadStart(calc2.ExecutaCalculo));
    tarefa2.Name = "Tarefa 2";

    tarefa1.Start();
    tarefa2.Start();

    tarefa1.Join();
    tarefa2.Join();

    /*
     * PARA DEMONSTRAR QUE O CÓDIGO ABAIXO SÓ É EXECUTADO
     * QUANDO A THREADS BLOQUEADA FOR FINALIZADA.
     */
    if(tarefa1.ThreadState != ThreadState.Stopped)
        Console.WriteLine("A tarefa 1 ainda não finalizou a execução.");

    if (tarefa2.ThreadState != ThreadState.Stopped)
        Console.WriteLine("A tarefa 2 ainda não finalizou a execução.");

    Console.WriteLine("Todas as threads finalizadas.");
    Console.ReadKey();
}

O resultado será:

Bem mais fácil utilizar o método Join() no lugar do loop, não é mesmo?

Agora vou dar uma dica direta para o pessoal que pensa em utilizar MultiThread em requisições Web. Falo isso pelo simples fato de que uma requisição web pode demorar ou até mesmo travar e não retornar. E usando o Join() para esperar o término das tarefas pode não ser a melhor opção, por que o site vai ficar parado até que a requisição termine.

Para casos como esse, o Join() possui uma sobrecarga Join(int millisecondsTimeout) onde devemos informar quantos milisegundos a função principal deverá ficar esperando o término da thread. Caso esse tempo seja ultrapassado, a função principal será desbloqueada. Para demonstrar a utilização dessa sobrecarga, vou fazer uma pequena modificação na classe Calcula. A atualização está por conta do while(true) para simular uma requisoção que nunca termina. O código deve ficar igual ao abaixo.

class Calcula {

    /// <summary>
    /// Variável para controlar a quantidade de repetições
    /// </summary>
    private int _repeticoes;

    /// <summary>
    /// Construtor classe Calcula
    /// </summary>
    /// <param name="repeticoes">Quantidade de repetiçoes</param>
    public Calcula(int repeticoes) {
        this._repeticoes = repeticoes;
    }

    /// <summary>
    /// Método que irá simular um cálculo qualquer
    /// </summary>
    public void ExecutaCalculo() {
        // LOOPING INFINITO PARA SIMULAR UMA REQUISIÇÃO QUE NUNCA TERMINA.
        while (true) {
        }
    }

}

E na função principal a modificação fica por conta da utilização da sobrecarga do Join() e um tratamento de erro para as threads que permanecerem executando. O código abaixo faz essas modificações.

static void Main(string[] args) {
    Calcula calc1 = new Calcula(2);
    Calcula calc2 = new Calcula(3);

    Thread tarefa1 = new Thread(new ThreadStart(calc1.ExecutaCalculo));
    tarefa1.Name = "Tarefa 1";

    Thread tarefa2 = new Thread(new ThreadStart(calc2.ExecutaCalculo));
    tarefa2.Name = "Tarefa 2";

    tarefa1.Start();
    tarefa2.Start();

    /*
     * COLOCANDO UM TEMPO DE ESPERA PARA FICAR "BLOQUEADO".
     * SE ULTRAPASSAR O SISTEMA É DESBLOQUEADO.
     */
    tarefa1.Join(5);
    tarefa2.Join(6);

    /*
     * PARA DEMONSTRAR SE A THREAD TERMINOU SUA EXECUÇÃO.
     */
    if (tarefa1.ThreadState != ThreadState.Stopped) {
        Console.WriteLine("A tarefa 1 ainda não finalizou a execução, forçando sua finalização.");
        tarefa1.Abort();
    }

    if (tarefa2.ThreadState != ThreadState.Stopped) {
        Console.WriteLine("A tarefa 2 ainda não finalizou a execução, forçando sua finalização.");
        tarefa2.Abort();
    }

    Console.WriteLine("Todas as threads finalizadas.");
    Console.ReadKey();
}

O resultado de todas as modificações será o seguinte:

Com isso finalizamos a segunda parte do artigo. Espero vocês na terceira e última parte sobre MultiThreads, onde vou falar sobre trechos críticos.

[]’s e até a próxima.

Programação MultiThread com C# – Parte 1

Marcos Sabino Filho — Tue, 02 Jun 2009 01:38:00 GMT

Olá pessoal,

Quem não gostaria de fazer um sistema que fizesse várias requisições ao mesmo tempo?
Quem não ficaria seduzido só de escutar que há a possibilidade?

Possível com certeza é. Mas temos que tomar certos cuidados para não caírmos em algumas pegadinhas que a programação concorrente prega nos inesperientes de plantão.

A lógica é relativamente simples de ser compreendida, e já está na cabeça de muitos desenvolvedores: O fluxo seria mais ou menos assim:

Criar o objeto da classe que contém uma função;
Criar uma thread para cada classe criada no passo acima e finalmente
Mandar executar todas as threads ao mesmo tempo.

Lendo os 3 itens acima, acabo de perceber que o mundo é perfeito. Mas não é assim que o mundo da programação funciona.
O que vai acontecer se as threads criadas estiverem acessando o mesmo banco ao mesmo tempo? Com certeza irá ocorrer Dead Lock.
E se todas utilizarem uma variável compartilhadas? Com certeza o resultado final não vai ser o esperado.
E se o tempo limite de execução estorou? Com certeza não vou descobrir quando isso ocorrer.
Pensando nesses e outras centenas de problemas que acontecem no mundo corporativo, resolvi pesquisar bastante sobre o assunto, e vou apresentar uma séria o mais completa possível sobre o assunto.

A classe que será a base desse artigo será a Thread. Ela pertence ao NameSpace System.Threading.

Para demonstrar o funcionamento do MultiThread, devemos criar um projeto do tipo Console Application. Depois de criado o projeto, copiem o código da classe Calcula (definida abaixo) acima da classe Program:

class Calcula {

    /// <summary>
    /// Variável para controlar a quantidade de repetições
    /// </summary>
    private int _repeticoes;

    /// <summary>
    /// Construtor classe Calcula
    /// </summary>
    /// <param name="repeticoes">Quantidade de repetiçoes</param>
    public Calcula(int repeticoes) {
        this._repeticoes = repeticoes;
    }

    /// <summary>
    /// Método que irá simular um cálculo qualquer
    /// </summary>
    public void ExecutaCalculo(){
        for (int i = 0; i < _repeticoes; i++) {
            Thread.Sleep(500);
            Console.WriteLine(Thread.CurrentThread.Name);
        }
    }
}

class Program {

    static void Main(string[] args) {

    }
}

Essa classe será usada para ilustrar como seria uma classe real que realiza algum tipo de cálculo ou requisição à algum WebService. O passo seguinte é criar os objetos, definir as threads, e pedir para que executem ao mesmo tempo (como definimos no início do artigo). O código abaixo faz esse trabalho pra nós.

static void Main(string[] args) {
    Calcula calc1 = new Calcula(2);
    Calcula calc2 = new Calcula(3);

    Thread tarefa1 = new Thread(new ThreadStart(calc1.ExecutaCalculo));
    tarefa1.Name = "Tarefa 1";

    Thread tarefa2 = new Thread(new ThreadStart(calc2.ExecutaCalculo));
    tarefa2.Name = "Tarefa 2";

    tarefa1.Start();
    tarefa2.Start();
}

O resultado será o seguinte:

Até aqui o resultado já ajuda muitas pessoas, caso não ocorra nenhum dos problemas que citei no início.

Vamos complicar um pouco então com uma pergunta muito simples.

Como faço para executar um código somente depois que todas as threads estiverem finalizadas?

Simples! É só adicionar o código “ Console.WriteLine("Todas as threads finalizadas.");” logo depois de iniciar as threads, isso irá simular quando as tarefas finalizarem. ( Abaixo o código completo da Main).

static void Main(string[] args) {
    Calcula calc1 = new Calcula(2);
    Calcula calc2 = new Calcula(3);

    Thread tarefa1 = new Thread(new ThreadStart(calc1.ExecutaCalculo));
    tarefa1.Name = "Tarefa 1";

    Thread tarefa2 = new Thread(new ThreadStart(calc2.ExecutaCalculo));
    tarefa2.Name = "Tarefa 2";

    tarefa1.Start();
    tarefa2.Start();

    Console.WriteLine("Todas as threads finalizadas.");
}

Correto? Errado! Vejam vocês o resultado da lambança que fizemos:

O que era muito simples, acaba de se tornar uma dificuldade moderada em termos de codificação. Mas por que aconteceu isso?

Isso acontece por que a Main continua executando independente das outras threads. Por padrão ela não tem uma trava para continuar depois que as outras threads concorrentes sejam finalizadas. Se existisse uma trava, veríamos o output da Tarifa1 e depois que ela finalizasse, veríamos o output da Tarefa2. Para deixarmos essa “trava”, vamos deixar a Main da seguinte forma.

static void Main(string[] args) {
    Calcula calc1 = new Calcula(2);
    Calcula calc2 = new Calcula(3);

    Thread tarefa1 = new Thread(new ThreadStart(calc1.ExecutaCalculo));
    tarefa1.Name = "Tarefa 1";

    Thread tarefa2 = new Thread(new ThreadStart(calc2.ExecutaCalculo));
    tarefa2.Name = "Tarefa 2";

    // CRIANDO UMA LISTA DE TAREFAS, PARA QUE SEJAM GERENCIÁVEIS
    List<Thread> listaTarefas = new List<Thread>();
    listaTarefas.Add(tarefa1);
    listaTarefas.Add(tarefa2);

    // INICIANDO TODAS AS TAREFAS
    foreach (Thread tarefa in listaTarefas) {
        tarefa.Start();
    }

    // VERIFICANDO O STATUS DE CADA TAREFA
    while (listaTarefas.Count > 0) {
        Thread.Sleep(1000);

        // REMOVE AS TAREFAS JÁ FINALIZADAS.
        for (int i = listaTarefas.Count - 1; i >= 0; i--) {
            if (listaTarefas.ThreadState == ThreadState.Stopped) {
                listaTarefas.RemoveAt(i);
            }
        }
    }

    Console.WriteLine("Todas as threads finalizadas.");
    Console.ReadKey();
}

O resultado será o seguinte:

Agora sim podemos dizer que temos uma aplicação MultiThread.

Na continuação vou falar sobre timeout para as threads e trechos críticos de código.

Espero que tenham gostado e até a continuação do artigo.

Utilizando o método List.Find() – Busca em Lista Genérica

Marcos Sabino Filho — Tue, 02 Jun 2009 01:37:00 GMT

Olá pessoal,

Quem trabalha com o Visual Studio 2005 não pode usufruir do LINQ. Mas isso não é motivo para desespero, por que com o Framework 2.0 veio a Generic List. Com a Generic List podemos fazer uma lista de qualquer tipo de objeto. E veio também alguns métodos. E o método para se trabalhar com buscas em uma Generic List é método Find().

Para iniciar, vamos criar um projeto do tipo Console Application. Assim que o projeto estiver criado, vamos adicionar uma nova classe chamada Pessoa. Para fazer isso, é só clicar com o botão direito no projeto, depois em Add e em seguida Class.

O passo seguinte é nomear a classe. Dê o nome Pessoa para essa classe.

Após a criação da classe, vamos usar o seguinte código de estruturação para a classe.

public class Pessoa {

    private int _id;
    private string _nome;
    private string _cidade;

    public int ID { get { return _id; } set { _id = value; } }
    public string Nome { get { return _nome; } set { _nome = value; } }
    public string Cidade { get { return _cidade; } set { _cidade = value; } }

    public Pessoa(int id, string nome, string cidade) {
        this.ID = id;
        this.Nome = nome;
        this.Cidade = cidade;
    }

}

A classe Pessoa tem uma estrutura bem simples. Ela tem um campo de identificação (ID), um campo para o nome e outro para a cidade. O intuito aqui é fazer uma lista com esse objeto e realizar algumas buscas.

Para demonstrar a utilização, vamos usar o código abaixo da Main da aplicação:

static void Main(string[] args) {
    // CRIAÇÃO DA LISTA
    List<Pessoa> listaPessoas = new List<Pessoa>();

    // ADIÇÃO DE OBJETOS A LISTA
    listaPessoas.Add(new Pessoa(1, "Marcos", "Sao Paulo"));
    listaPessoas.Add(new Pessoa(2, "Marcelo", "Sao Jose do Rio Preto"));
    listaPessoas.Add(new Pessoa(3, "Rodrigo", "Sao Jose do Rio Pardo"));
    listaPessoas.Add(new Pessoa(4, "Adriano", "Campinas"));
    listaPessoas.Add(new Pessoa(5, "Andrea", "Garulhos"));

    // BUSCA APENAS UM OBJETO QUE TENHA A PROPRIEDADE ID IGUAL A 3
    Pessoa apenasUma = listaPessoas.Find(delegate(Pessoa p) {
        return p.ID == 3;
    });

    // ESCREVE NA TELA O USUARIO ENCONTRADO
    Console.WriteLine("Busca pelo ID");
    Console.WriteLine("-------------");
    Console.WriteLine(apenasUma.Nome + "\n");

    // BUSCA TODOS OS OBJETOS QUE TENHAM A PROPRIEDADE CIDADE INICIADA PELA PALAVRA 'SAO'
    List<Pessoa> umaLista = listaPessoas.FindAll(delegate(Pessoa p) {
        return p.Cidade.StartsWith("Sao");
    });

    // ESCREVE NA TELA TODOS AS PESSOAS ENCONTRADAS
    Console.WriteLine("Busca pela Cidade");
    Console.WriteLine("-----------------");
    foreach (Pessoa people in umaLista) {
        Console.WriteLine(people.Nome);
    }

    // ESPERA O USUÁRIO DIGITAR [ENTER] PARA ENCERRAR O APLICATIVO
    Console.ReadKey();

}

Nota-se pelos comentarios que o funcionamento é bem simples. Assim que a lista é criada, vários objetos são adicionados à ela.
Essa lista será usada como source para as buscas. Assim que o source estiver completo, é feita a primeira busca
(pela propriedade ID). A segunda busca é feita pela propriedade Cidade. O resultado final deve ser parecido com o da imagem abaixo.

É isso aí pessoal, até a próxima.