Eduardo Spaki

FTP + Powershell

2011-11-16T15:30:00.000-02:00

Bem, como já relatado em outros posts, é possível utilizar classes do .NET Framework no Powershell. Com isso em mente, podemos utilizar uma simples requisição com um WebRequest para estabelecer conexão com um servidor FTP.

Vejamos esse exemplo de como copiar um diretório (seus arquivos e subpastas) para um servidor FTP (mantendo a mesma estrutura).

function DoLogFTP($tamanhoBytes, $fullName)
{
    if($tamanhoBytes -eq $null)
    {
        return;
    }

    $tamanho = $tamanhoBytes/1024;
    $unidade = "KB";

    if($tamanho -ge 1024.0)
    {
        $tamanho = $tamanho/1024;
        $unidade = "MB";
    }

    $mensagem = [string]::Format("FTP: copiando ({0:0.00} {1}) '{2}' ... ", $tamanho, $unidade, $fullName);

    Write-Host $mensagem;
}

function InstanciarFTPClient([string] $enderecoFTP, [string] $ftpUser, [string] $ftpPassword)
{
    $ftp = [System.Net.WebRequest]::Create($enderecoFTP);
    $ftp.Credentials = New-Object System.Net.NetworkCredential($ftpUser, $ftpPassword);

    return $ftp;
}

function CriarDiretorioFTP([string] $enderecoFTP, [string] $ftpUser, [string] $ftpPassword, [string] $nomeDoDiretorio)
{
    $ftp = InstanciarFTPClient ($enderecoFTP+$nomeDoDiretorio) $ftpUser $ftpPassword;
    $ftp.Method = [System.Net.WebRequestMethods+FTP]::MakeDirectory;
    $ftp.GetResponse();
}

function EnviarDiretorioViaFTP([string] $diretorioOrigem, [string] $enderecoFTP, [string] $ftpUser, [string] $ftpPassword)
{
    # -> Define um nome do diretório que será criado no servidor FTP.
    $nomeDoDiretorio = $diretorioOrigem.Substring($diretorioOrigem.LastIndexOf('\') + 1, $diretorioOrigem.Length - $diretorioOrigem.LastIndexOf('\') - 1) #(Get-Item $diretorioOrigem).Name; #(New-Object System.IO.DirectoryInfo $diretorioOrigem).Name;
    $nomeDoDiretorio += (Get-Date).ToString(" - dd-MM-yyyy - HH-mm-ss");
    $global:diretorioCriadoNoServidor = $nomeDoDiretorio;

    CriarDiretorioFTP $enderecoFTP $ftpUser $ftpPassword $nomeDoDiretorio;

    $diretorioFTP += $enderecoFTP + $nomeDoDiretorio + "/";
    $itensDoDiretorio = Get-ChildItem $diretorioOrigem -recurse;

    foreach($item in $itensDoDiretorio)
    {
        $nomeItem = [System.IO.Path]::GetFullPath($item.FullName).SubString($diretorioOrigem.Length + 1);

        DoLogFTP $item.Length $item.FullName;

            if ($item.Attributes -eq "Directory")
            {
            CriarDiretorioFTP $diretorioFTP $ftpUser $ftpPassword $nomeItem;
            continue;
            }

        $ftp = InstanciarFTPClient ($diretorioFTP+$nomeItem) $ftpUser $ftpPassword;
        $ftp.Method = [System.Net.WebRequestMethods+FTP]::UploadFile
        $ftp.KeepAlive = $false;
        $ftp.UseBinary = $true ;
        $ftp.UsePassive = $false;

        $responseStream = $ftp.GetRequestStream();
            $bytesFile = [System.IO.File]::ReadAllBytes($item.FullName);

        $responseStream.Write($bytesFile, 0, $bytesFile.Length);
        $responseStream.Close();
        $responseStream.Dispose();
    }
}

Espero que tenham gostado da dica!

Twitter + Silverlight ou WPF

2011-11-15T18:31:00.001-02:00

Vamos fazer um cliente de Twitter???

Vamos!

Ebaaa...

Ok ok, comemorações a parte vamos iniciar.

A ideia aqui é usar a API do Twitter, fazendo simples requisições web, e aproveitar o potencial do XAML, a linguagem de interface por trás do Silverlight (inclusive do Windows Phone) e do WPF.

Então crie uma aplicação utilizando uma dessas tecnologias chamada de “MeuClienteDeTwitter”.

No exemplo foi utilizado WPF. Nossa UI ficará da seguinte maneira:

No “.xaml” principal/inicial (no caso do WPF o “MainWindow.xaml”), desenhe uma tela, arrastando os controles da Toolbox para a tela, com os seguintes controles:

TextBlock: Ao topo servindo de título para a aplicação. Altere a propriedade “Text” (para definir o valor do mesmo) e as propriedades de fonte, para deixar esse texto mais destacado. Esse controle funciona como uma Label do ASP.NET ou Windows Forms.
TextBox: Caixa de texto editável. Defina o nome dela como “txtUsuario”, acompanhe na imagem a seguir:
Button: Botão para fazer a requisição e listar os tweets do usuário informado. Defina seu nome como “btnCarregar”.
ListBox: Lista de itens. Montaremos um layout para os itens que listaremos. Por hora nomeie-o como “lstConteudo”, e deixe seu fundo transparente, como na imagem abaixo:

Curiosidade: O controle Label existe tanto no WPF como no Silverlight. Mas ele é um ContentControl, o que significa que ele pode conter “qualquer coisa” dentro delae não ficando limitado somente a texto puro e simples. Podemos adicionar um vídeo e imagem dentro da mesma Label, por exemplo. Como nesse exemplo queremos apenas texto para o título, optei pelo TextBlock.

Uma coisa importante quando definimos layout de telas com XAML é ficar atento ao painel de layout. Pois todos os controles são aninhados e organizados em um ou mais painéis. Há vários painéis, cada um com uma forma de organizar o layout diferente. Nesse caso, todos esses controles ficam dentro de uma Grid.

Essa Grid “não tem nada haver” com as conhecidas “DataGrids”, que montam tabelas com linhas e colunas proveniente de uma coleção de dados.

A Grid do XAML é um painel que se orienta por distancia das margens. Por exemplo: se colocarmos um botão em uma Grid, e definirmos ele com uma margem de 20 pixels na esquerda e 20 pixels na direita, não interessa o tamanho da janela ou o quanto ela for redimensionada, o controle se adaptará para manter a distancia das margens, sempre em 20 pixels próximo as bordas laterais.

A Grid pode ser dividida, criando bordas internas. Nesse exemplo, foi definida uma borda logo abaixo do botão e do campo de texto, para separar a ListBox dos demais controles. Assim, após colocar a ListBox na parte inferior, defini as margens dela como zero para todos os lados, logo ela acompanhará o tamanho da janela tanto em largura como em altura.

Bem, o intuito aqui não é ficar discutindo sobre esses painéis, em outra oportunidade eu falo mais dos mesmos.

Vejamos como ficou o XAML então:

<Window x:Class="MeuClienteDeTwitter.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="MainWindow" Height="484" Width="385">
    
    <Window.Background>
        <LinearGradientBrush EndPoint="1,0.5" StartPoint="0,0.5">
            <GradientStop Color="LightBlue" Offset="0" />
            <GradientStop Color="White" Offset="1" />
        </LinearGradientBrush>
    </Window.Background>
    <Grid>
        
        <Grid.RowDefinitions>
            <RowDefinition Height="80" />
            <RowDefinition Height="*" />
        </Grid.RowDefinitions>

        <Label Content="Meu Cliente de Twitter" Height="28" HorizontalAlignment="Left" Margin="12,12,0,0" Name="label1" VerticalAlignment="Top" FontWeight="Bold" FontSize="16" FontFamily="Verdana" />
        <TextBox Height="23" HorizontalAlignment="Left" Margin="12,46,0,0" Name="txtUsuario" VerticalAlignment="Top" Width="213" />
        <Button Content="Carregar o Twitter" Height="23" HorizontalAlignment="Left" Margin="231,46,0,0" Name="btnCarregar" VerticalAlignment="Top" Width="124" Click="btnCarregar_Click" />

        <ListBox Grid.Row="1" Name="lstConteudo" BorderBrush="{x:Null}" Background="{x:Null}">
            
            <ListBox.ItemTemplate>
                <DataTemplate>
                    
                    <StackPanel Orientation="Horizontal" Height="132">
                        <Image Source="{Binding UrlFoto}" Height="73" Width="73" VerticalAlignment="Top" Margin="0,10,8,0" />
                        <StackPanel Width="370">
                            <TextBlock Text="{Binding Usuario}" Foreground="#FFC8AB14" FontSize="28"/>
                            <TextBlock Text="{Binding Conteudo}" TextWrapping="Wrap" FontSize="23"/>
                        </StackPanel>
                    </StackPanel>
                </DataTemplate>
            </ListBox.ItemTemplate>
        </ListBox>
    </Grid>
</Window>

Para fazer o fundo em gradiente, utilizamos o LinearGradientBrush com duas cores definidas para a Janela.

A primeira linha da Grid, que separa a ListBox dos demais controles do “cabeçalho”, tem 80 pixels de altura, o restante, definido como “*”, fica para a segunda linha que é onde está a ListBox.

Agora vem uma parte importante, a definição do layout dos itens que forem carregados no ListBox. Para isso temos que criar um painel de Layout, dentro do template de dados da ListBox.

Nesse caso o painel de layout utilizado foi o StackPanel, ou painel empilhador. Ele empilha os controles, um sobre o outro, seja na vertical ou na horizontal.

Dentro desse painel, colocamos um controle Image, para exibir a foto do usuário, com altura e largura de 73 pixels. Colocamos também dois TextBlock, um para o nome do usuário, com fonte um pouco maior, e outro para o tweet em si, com a quebra de linha ativada (propriedade “TextWrapping="Wrap"”).

Uma outra curiosidade: se você vem do desenvolvimento Windows Forms e quer uma maneira de organizar layout semelhante aos “bons e velhos” formulários, opte pelo painel chamado Canvas.

Ao analisar o XAML uma coisa deve estar te deixando cmo a pulga atrás da orelha: O que são aqueles “bindings”.

O pessoal do ASP.NET deve até desconfiar.

Bem, os bindings são definições de vinculo. Ou seja, nesse caso, passaremos uma lista de objetos para o ListBox. Esses objetos serão do tipo ItemTwitter, que criaremos mais adiante. Ou melhor, vamos cria-lo agora. Clique com o botão direito no projeto > Add > Class. Veja na imagem abaixo:

O nome dela será “ItemTwitter”, o código fonte está abaixo:

namespace MeuClienteDeTwitter
{
    public class ItemTwitter
    {
        public string UrlFoto { get; set; }
        public string Usuario { get; set; }
        public string Conteudo { get; set; }
    }
}

Basicamente três propriedades string estão definidas.

Voltando ao binding, quando passarmos para o ListBox uma lista do tipo ItemTwitter, para cada objeto da lista será criado um item no ListBox. Mas como vincular o layout com as informações dos itens da lista? Definindo um binding no controle e propriedade desejados. No caso da foto, colocaremos no controle Image, na propriedade Source (pois vincularemos a URL da foto do usuário). Nos TextBlocks a propriedade de vinculo será a Text.

No futuro falarei especificamente de binding.

Faltou definir a codificação para tudo funcionar. Então volte para o modo de desing e dê um duplo click no botão, assim será criado o evento click do mesmo.

Em seu click definiremos o seguinte código:

using System;
using System.Linq;
using System.Net;
using System.Windows;
using System.Xml.Linq;

namespace MeuClienteDeTwitter
{
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
        }

        // -> Método do evento de click do botão para carregar os tweets.
        private void btnCarregar_Click(object sender, RoutedEventArgs e)
        {
            // -> Criamos um objeto que fará uma requisição web para a API do Twitter.
            var requisicao = new WebClient();

            // -> Concatenando o nome do usuário digitado na txtUsuario na URL da API do Twitter.
            var url = string.Format("http://api.twitter.com/1/statuses/user_timeline.xml?screen_name={0}", txtUsuario.Text);

            /*
             -> Faremos a requisição web de forma assincrona, ou seja,
             * a requisição é disparada a aplicação não ficará travada até ela responder.
             * Mas quando ela responder, deve responder para a aplicação com um evento.
             * Então temos que definir o evento que ela responderá "requisicao_DownloadStringCompleted".
             * Agora podemos fazer a requisição assincrona, passando a URL da API, atravéz da classe URI.
             */
            requisicao.DownloadStringCompleted += new DownloadStringCompletedEventHandler(requisicao_DownloadStringCompleted);
            requisicao.DownloadStringAsync(new Uri(url));
        }

        void requisicao_DownloadStringCompleted(object sender, DownloadStringCompletedEventArgs e)
        {
            // -> Todo o retorno do prossessamento da requisição virá na variável "e".

            // -> Verificamos se houve algum erro.
            if (e.Error != null)
                return;

            // -> o Retorno da requisição é um XML. Teste no seu navegador para averiguar.
            //      Então fazemos um parse nele para utilizar o LINQ.
            var tweets = XElement.Parse(e.Result);

            // -> Usando o LINQ, tranformamos os nós do XML em uma lista de objetos "ItemTwitter"
            var results = from tweet in tweets.Descendants("status")
                          select new ItemTwitter
                          {
                              UrlFoto= tweet.Element("user").Element("profile_image_url").Value,
                              Conteudo = tweet.Element("text").Value,
                              Usuario = tweet.Element("user").Element("screen_name").Value
                          };

            // -> Alimenta a ListBox.
            lstConteudo.ItemsSource = results.ToList();
        }
    }
}

Percebam que a API do Twitter nada mais é do que uma chamada HTTP que retorna um XML. Faça o teste no seu Navegador.

Após isso, utilizamos o LINQ para criar objetos, a partir do XML, e com eles alimentamos a ListBox, e está pronto nosso leitor de Tweets.

É praticamente a mesma coisa fazer essa App em Silverlight, inclusive coloca-la dentro de seu Windows Phone, veja aqui o Scott Gu fazendo isso:
http://weblogs.asp.net/scottgu/archive/2010/03/18/building-a-windows-phone-7-twitter-application-using-silverlight.aspx

Espero que tenham gostado.

Arquivos de Texto com Powershell

2011-09-26T10:20:00.000-03:00

Rapidinho irei demonstrar como é fácil manipular arquivos de texto com Powershell, veja o código:

#region Manipulação de arquivos texto

    function LerTxt([string] $caminhoArquivo)
    {
        if(Test-Path $caminhoArquivo)
        {
            return Get-Content $caminhoArquivo;
        }
    }

    function EscreverTxt($caminhoArquivo, $conteudo)
    {
        New-Item $caminhoArquivo -type file -Force;
        Add-Content $caminhoArquivo $conteudo;
    }

#endregion

A única observação é que o código para gerar um arquivo de texto é recriado com o “new-item –force”. Caso desejem apenas adicionar conteúdo, desconsiderem essa linha.

Por hora fica essa dica the flash.

Mandando e-mail com Powershell

2011-09-09T22:00:00.000-03:00

Quer algo mais cômodo do que você automatizar rotinas nos servidores e receber um aviso, status ou até mesmo log das operações no seu e-mail!?

Seu chefe desconfia que as rotinas estão rodando nos servidores? Coloque ele na cópia dos e-mails ! (Like a boss)

Ok, então fica registrado aqui uma função Powershell para envio de e-mails.

function SendMail([string] $smtpServer, [string] $smtpUser, [string] $smtpPassword, [string] $to, [string] $title, [string] $body)
{
    # -> Instancia um cliente SMTP.
    $smtp = new-object System.Net.Mail.SmtpClient;

    # -> Host do servidor SMTP.
    $smtp.Host = $smtpServer;

    # -> Autenticação no servidor SMTP.
    $smtp.Credentials = New-Object System.Net.NetworkCredential($smtpUser, $smtpPassword);

    # -> Instancia uma mensagem de e-mail.
    $message = New-Object System.Net.Mail.MailMessage;

    # -> Formata a mensagem para receber HTML.
    $message.IsBodyhtml = $true;
    $message.Body = $body;
    $message.Subject = $title;

    # -> Define o endereço de origem como o usuário que autenticou no servidor SMTP.
    $message.From = New-Object System.Net.Mail.MailAddress $smtpUser;

    # -> Quebra os endereços de destino de acordo com as separações (";").
    $toItems = $to.Split(";");

    foreach($toItem in $toItems)
    {
        # -> Adiciona os e-mails válidos de destino.
        if($toItem -ne $null -and $toItem.Trim() -ne "")
        {
            $toAdress = New-Object System.Net.Mail.MailAddress $toItem;
            $message.To.Add($toAdress);
        }
    }

    # -> Envia o e-mail.
    $smtp.Send($message);
}

Sem mais complicações, como já citei em outras oportunidades, o Powershell dispõe do poder das classes .NET. Então bata usá-las para essa tarefa

Be happy!

Arranjo, Combinação e Permutação

2011-09-08T18:51:00.001-03:00

Essas três palavrinhas fazem parte de clássicos da computação e matemática. então resolvi explicá-las e demonstrar com a linguagem C.

Arranjo: são grupos sem repetição, ou seja, se eu tenho os elementos 1, 2 e 3, eu posso agrupá-los em dupla (conjuntos de dois elementos) para formar os seguintes números: 12, 13, 21, 23, 31, 32.

O arranjo é a base da Combinação e da permutação. Sua fórmula é descrita assim:

A n,p = n!/(n-p)!

Onde “n” é o quantidade de elementos e “p” o tamanho do grupo.

No exemplo mencionado temos 3 elementos (quantidade) colocados em par (tamanho do grupo = 2).

A 3,2 = 3!/(3-2)! = 3.2.1/1! = 6

Agora que já entendemos a base, vamos para o próximo, a Combinação.

Combinação: é um Arranjo onde deveremos ignoramos os grupos que contenha os mesmo elementos, independente da ordem.

No exemplo do Arranjo, nós consideramos conjuntos distintos os números 12 e 21, porque numericamente são diferentes.

Mas imagine o caso onde temos um João e uma Maria. Tanto faz se o conjunto é (João, Maria) ou (Maria, João), pois formam o mesmo casamento . Então essa é a Combinação: Arranjos que desconsideramos demais conjuntos que contenham o mesmo elemento independente da ordem.

C n,p = A n,p/p! = n!/p!(n-p)!

Percebam que é possível compor a fórmula da Combinação se baseando na fórmula do Arranjo.

Vamos ver um exemplo: Qual a quantidade de duplas possíveis com as pessoas Adriana, Xenofreuda e Tonha.

C 3,2 = 3!/2!(3-2)! = 3.2.1/2.1.1! = 3

E finalmente a Permutação.

Permutação: Arranjos onde a quantidade de elementos é igual ao tamanho do grupo, utilizado muito em anagramas. Anagramas são as variações possíveis de se fazer com as letras de uma palavra, por exemplo a palavra “mel”: mle, lme, lem, eml, elm.

Sua formula é um simples fatorial:

P n = n!

Para o exemplo:

P 3 = 3! = 3.2.1 = 6

Uma vez que entendemos a teoria, vamos colocá-la na pratica dentro da computação com a linguagem C.

Para isso, usei conceitos de Recursividade e Números Fatoriais.

// -> Para poder usar o "wcout" e o cout
#include<iostream>
using namespace std;

long double CalcularFatorial(int numero)
{
    if(numero < 2)
        return numero;

    return numero * CalcularFatorial(numero - 1);
}

long double CalcularArranjo(int quantidadeElementos, int tamanhoGrupo)
{
    return CalcularFatorial(quantidadeElementos)/CalcularFatorial(quantidadeElementos - tamanhoGrupo);
}

long double CalcularCombinacao(int quantidadeElementos, int tamanhoGrupo)
{
    return CalcularArranjo(quantidadeElementos, tamanhoGrupo)/CalcularFatorial(tamanhoGrupo);
}

long double CalcularPermutacao(int quantidadeElementos)
{
    return CalcularFatorial(quantidadeElementos);
}

void main()
{
    setlocale(LC_ALL, "Portuguese"); // -> Permitir acentos.

    while(true)
    {
        // -> Limpa a tela.
        system("cls");

        // -> Monta o menu de opções.
        wcout << "Qual operação deseja realizar?" << endl;
        wcout << "\t1-) Fatorial" << endl;
        wcout << "\t2-) Arranjo" << endl;
        wcout << "\t3-) Combinação" << endl;
        wcout << "\t4-) Permutação" << endl;
        wcout << "\t5-) Sair" << endl;
        wcout << "\tOpção: ";

        int opcao, quantidadeElementos, tamanhoGrupo;
        long double resultado;

        scanf("%i", &opcao);

        switch (opcao)
        {
            case 1:
                wcout << "Infome um número para calcular seu fatorial: ";
                scanf("%i", &quantidadeElementos);

                resultado = CalcularFatorial(quantidadeElementos);
                break;
            case 2:
                wcout << "Cálculo de Arranjo" << endl;
                wcout << "Infome a quantidade de elementos: ";
                scanf("%i", &quantidadeElementos);
                wcout << "Infome o tamanho do grupo: ";
                scanf("%i", &tamanhoGrupo);

                resultado = CalcularArranjo(quantidadeElementos, tamanhoGrupo);
                break;
            case 3:
                wcout << "Cálculo de Combinação" << endl;
                wcout << "Infome a quantidade de elementos: ";
                scanf("%i", &quantidadeElementos);
                wcout << "Infome o tamanho do grupo: ";
                scanf("%i", &tamanhoGrupo);

                resultado = CalcularCombinacao(quantidadeElementos, tamanhoGrupo);
                break;
            case 4:
                wcout << "Cálculo de Permutação" << endl;
                wcout << "Infome a quantidade de elementos: ";
                scanf("%i", &quantidadeElementos);

                resultado = CalcularPermutacao(quantidadeElementos);
                break;
        }

        if(opcao > 4) // -> Encerra a aplicação
            break;

        wcout << endl << "Resultado: " << resultado << endl << endl;
        wcout << "Pressione enter para continuar...";
        fflush(stdin);
        getchar();
    }

    wcout << endl << "Fim!";
    /*fflush(stdin);
    getchar();*/
}

Percebam que, como vimos na teoria, é possível aproveitar o Arranjo para compor a formula da Combinação, e fiz exatamente isso na função CalcularCombinacao().

Outro ponto é que, para os resultados eu tive que apelar para o tipo long double (96 bits), pois quando falamos em fatoriais, os números podem crescer freneticamente.

Acompanhe alguns testes:

É isso daí pessoal.

Já calcularam qual o números de combinações possíveis de maquiagem de maquiagem da sua namorada, mulher ou enrolada?

Você irá se surpreender O.o

Manipulando IIS com Powershell

2011-09-07T21:24:00.001-03:00

Ultimamente tenho trabalhado bastante com ~~Powerhell~~ Powershell devido a uma consultoria no módulo de Build do TFS. O legal desse módulo é que você pode interagir com scripts Powershell e variáveis do Work Flow que o TFS utiliza durante um build.

O Powershell é muito poderoso, isso se deve ao fato dele usufruir das classes .NET, utilizar o Windows Remote Management (WinRM) para execução remota de scripts, e comandos nativos das versões mais atuais do prompt, como o ROBOCOPY.

Assim como no .NET, nós podemos instalar módulos adicionais, e até mesmo importar os já instalados. No caso do IIS devemos importar o módulo “WebAdministration” . Então segue alguns scripts para manipulação do IIS.

Import-Module WebAdministration;

#region Manipulação do IIS

    function PararPool([string] $poolName)
    {
        Stop-WebAppPool -Name $poolName;
    }

    function IniciarPool([string] $poolName)
    {
        Start-WebAppPool -Name $poolName;
    }

    function PararSite([string] $siteName)
    {
        $site = GetSite $siteName;
        $site.Stop();
    }

    function IniciarSite([string] $siteName)
    {
        $site = GetSite $siteName;
        $site.Start();
    }

    function GetSite($siteName)
    {
        $site = Get-Item IIS://Sites/$siteName -ErrorAction SilentlyContinue;
        return $site;
    }

    function GetDirectorySite($site)
    {
        (Get-Item IIS://Sites/$site).PhysicalPath;
    }

    function GetPoolSite($site)
    {
        $objSite = Get-Item IIS://Sites/$site;
        return $objSite.ApplicationPool;
    }

    function CriarSite([string] $siteName, [string] $caminho)
    {
        New-Item IIS:\AppPools\$siteName;
        New-Item IIS:\Sites\$siteName -bindings @{protocol="http";bindingInformation=":80:$siteName"} -physicalPath $caminho;
        Set-ItemProperty IIS:\Sites\$siteName -name applicationPool -value $siteName;
    }

#endregion

Os scripts foram testados no IIS 7 e 7.5.

É lógico que existem mil e uma maneiras de ~~preparar neston~~ atingir um objetivo.

É possível utilizar o Active Directory Service Interfaces (ADSI), ou até mesmo o Windows Management Instrumentation (WMI). Acompanhe como reciclaríamos um determinado pool do IIS com o ADSI:

function ReciclarPool([string] $server, [string] $poolName)
{
([adsi]"IIS://$server/W3SVC/AppPools/$poolName").Recycle();
}

Uma última dica por hora, para editar e depurar scripts powershell, estou usando o programa PowerGUI.

É isso daí pessoal. Por hora é só, espero que tenham gostado!

Deletar arquivo do dia anterior

2011-08-03T19:52:00.001-03:00

Dica rápida…

A alguns dias dias atrás a equipe de desenvolvimento com a qual estava trabalhando decidiu persistir o Viewstate do ASP.NET no HD do servidor.

Após implantar as configurações, rotinas e afins, ficou a dúvida se as rotinas de exclusão dos viewstates antigos estava funcionando corretamente.

Um desenvolvedor deu a ideia de criar um .exe que excluísse os arquivos do dia anterior. Logo pensei: que mania de desenvolvedor de achar que o mundo pode ser resolvido com um .exe. (Falo isso com toda a autoridade de ser um desenvolvedor também!)

Então eu intervi, dizendo que apenas persistissem, e eu agendaria uma tarefa no servidor Windows para apagar os viewstates do dia anterior.

Mas… #comofaz?

Como estou trabalhando bastante com Poweshell ultimamente, pensei que não seria difícil desenvolver um script assim.

Após pesquisar um pouco descobri o comando "forfiles" do prompt do Windows mesmo. Essa belezinha lista arquivos, podendo aplicar alguns filtros. O filtro para os dias é o parametro "D", onde nesse caso, defini –1, veja:

#Maravawonderfull, listei os arquivos, mas e agora, como deletá-los? Já pensou que agonia, colocá-los em variáveis de script basic/bat!?

#Esgurmita!

Puxei um help do comando e loco descobri que havia como passar um comando para aplicar a cada item listado.

Com mais alguns parâmetros consegui gerar um .bat e agendar no Windows a rotina para executá-lo diariamente:

forfiles /P "C:\Users\Spoky\AppData\Local\Temp" /S /M *.txt /D -1 /C "cmd /c del @file"

Onde:

P: Diretório da da listagem.
S: Busca recursiva pelos diretórios a dentro.
M: Aplica a máscara *.txt.
D: Data da modificação.
C: Aplica algum comando para cada resultado da listagem.

Então #FicaDica

Auditoria no TFS - PT II

2011-07-25T21:24:00.001-03:00

Antes de continuar com as dicas de auditoria, gostaria de ratificar que a dica prestada no post "Auditoria no TFS - PT I" só é possível usando o TFS Power Tools, um conjunto de ferramentas que aprimoram a experiência e interação com o TFS. Valeu @wsilva81 por ter me lembrado desse detalhe.

E aqui vai mais uma dica de outra ferramenta que auxilia na auditoria do TFS. É o TFS Membership Visualizer. Ele monta um gráfico, baseado no gráfico de dependência do Visual Studio 2010, com informações de Team Projects de uma collection. É possível adicionar o plug-in no Visual Studio como nas imagens abaixo:

Após instalado, siga os seguintes passos para gerar o gráfico:

Assim obtemos o seguinte resultado:

Quem merece atenção no gráfico são as imagens roxas, que indicam os logins e grupos que tem acesso aos Team Projects. Mas também auxiliam em outras situações para visualização da collection, team projects, source controls etc.

#FicaDica

Transformation de web.config

2011-07-23T18:30:00.000-03:00

Transformation de arquivos de configuração é uma feature que surgiu com o Visual Studio de 2010. São arquivos de configurações que complementam o arquivo de configuração original. Esse complemento pode ser a adição, remoção e a transformação de tags do arquivo original.

Esses complementos são bem vindos quando precisamos gerar builds para ambientes distintos. Se sua empresa trabalha com cenários de testes, homologação, produção, etc… Pode gerar um transformation para cada um desses cenários, alterando a tag de connection string com o banco de dados por exemplo.

Ao criarmos um projeto web no Visual Studio, temos de cara as configurações de debug e release.

Ao abrir o arquivo de release, podemos ver que, diferentemente do web.config, o web.release.config não tem tantas tags, apenas instruções para as transformações das tags desejadas.

Para criamos mais uma variação do web.config, primeiro criamos um cenário:

Durante a criação definiremos o nome do ambiente, e também podemos definir se ele se baseará em um ambiente existente.

Com o ambiente criado, podemos adicionar o arquivo de configuração desse ambiente.

Vamos abrir o arquivo original e adicionarmos algumas configurações.

Observe a origem do web.config original. Ele já veio com connection string, e adicionei duas "appSettings".

Agora, definiremos o arquivo web.teste.config assim:

<?xml version="1.0"?>
 
<configuration xmlns:xdt="http://schemas.microsoft.com/XML-Document-Transform">   <connectionStrings>     <add xdt:Transform="RemoveAll" />   </connectionStrings>   <appSettings>     <add key="Numero1" value="2" xdt:Transform="Replace" xdt:Locator="Match(key)"/>     <add key="Numero2" value="3" xdt:Transform="Replace" xdt:Locator="Match(key)"/>   </appSettings>   <system.web>     <compilation xdt:Transform="RemoveAttributes(debug)" />   </system.web>    </configuration>

Regras para o tranformation:

Sempre respeite a hierarquia da tag, no exemplo das tags "Numero1" e "Numero2", elas tem que estar dentro da tag "appSettings".

Para aplicar o transformation tem que usar o atributo "xdt:Transform".

Clique aqui para obter vários exemplos de sua aplicação.

No exemplo citado foram removidas qualquer connection string pelo "RemoveAll" e alteradas ("Replace") algumas configurações do "appSettings", que foram localizadas pelo atributo "key" ("Match(key)").

Vamos gerar o build para ver se funciona?

Então gere uma publicação:

Reparem na imagem acima, que a build configuration é a Teste, que acabamos de criar.

Após publicarmos, olhem o resultado:

Temos um novo web.config transformado/mesclado.

E isso se reproduz quando utilizamos o mecanismo de build do TFS. Mas esse caso fica para a próxima!

Fonética + SQL Server

2011-07-21T22:36:00.001-03:00

fonética
(francês phonétique)

s. f.

1. [Linguística] Parte da linguística que trata dos sons articulados, considerados do ponto de vista físico, acústico e articulatório, como elementos dos vocábulos.

Essa é a definição do dicionário, mas basicamente a fonética é um "ramo" que estuda a pronuncia de uma palavra, visto que há diferenças entre a escrita e a pronuncia. Por exemplo, quantas maneiras podemos escrever o nome Wilham?

Wilian, Willian, Uyliam… Ainda mais no Brasil, e por falar nisso aqui há uma "limitação", a fonética é fortemente vinculada a língua. No brasil o som da letra "i" é um, nos EUA é outro… Ai!

Voltando aos nomes, no exemplo citado o som pode ser "fielmente" definido como "uiliam", então, na teoria, teríamos que bolar algum algoritmo para gerar o fonema da palavra, e nesse caso, independente da maneira como o nome for escrito, o resultado fonético seria o mesmo.

Complicado não!? Mas a boa notícia é que existem inúmeros estudos para gerar essa solução. Um deles é o Soundex. Criado em 1918, por Robert C. Russell e Margaret K. Odell. Esse algoritmo gera uma chave baseada na primeira letra e três números, "calculados" pelas letras na sequencia. Nesse algoritmo, o nosso Willian, viraria W450, e suas variações também.

O SQL Server já implementa nativamente o Soundex. Veja os exemplos a seguir:

Mas como "alegria de pobre dura pouco"… Há alguns poréns, primeiramente o Soundex é um algoritmo que funciona muito bem com a língua inglesa. Como disse anteriormente a fonética é extremamente ligada a sua língua. Palavras compostas e alguns casos da língua portuguesa não se dão muito bem com essa implementação do Soundex. Veja:

Vamos superar esse #mimimi!? Primeiramente vamos implementar o Soundex em C# e depois implementar adaptações necessárias para a nossa língua.

A base para isso foi tirada da revista Mundo .NET número 26, Casos de sucesso – Pesquisa Fonética em português; Tribunal de Justiça de Mato Grosso do Sul. Nesse caso o tribunal tinha problemas em localizar pessoas no sistema pelo nome. Antes da solução era preciso de informar o nome exato para o sistema buscar as informações.

Vamos definir alguns métodos para a implementação básica do Soundex:

    // -> Obtem o soudex de uma string
    private static string GetSoundex(string value)
    {
        value = value.ToUpper(); // -> Normaliza letras em Maiuscula
        var result = new StringBuilder();

        foreach (char item in value)
            if (char.IsLetter(item)) // -> Limpa String
                AddCharacter(result, item); // -> Adiciona um char Soudex

        // -> Limpa as exceções geradas
        result.Replace(".", string.Empty);
        // -> Arruma o tamanho no padrão soudex 
        //      4 caracteres.
        FixLength(result);

        return result.ToString();
    }

    // -> Preenche com 0 nos casos menor q quatro,
    //      ou pega os 4 primeiros caracteres.
    private static void FixLength(StringBuilder result)
    {
        var length = result.Length;

        if (length < 4)
            result.Append(new string('0', 4 - length));
        else
            result.Length = 4;
    }

    // -> Adiciona o caractere soudex, cuidando para não repetir.
    private static void AddCharacter(StringBuilder result, char item)
    {
        if (result.Length == 0)
        {
            result.Append(item);
        }
        else
        {
            var code = GetSoundexDigit(item);

            if (code != result[result.Length - 1].ToString())
                result.Append(code);
        }
    }

    // -> Algoritmo de substituição padrão Soudex.
    private static string GetSoundexDigit(char item)
    {
        var charString = item.ToString();

        if ("BFPV".Contains(charString))
            return "1";
        else if ("CGJKQSXZ".Contains(charString))
            return "2";
        else if ("DT".Contains(charString))
            return "3";
        else if ("L".Contains(charString))
            return "4";
        else if ("MN".Contains(charString))
            return "5";
        else if ("R".Contains(charString))
            return "6";
        else
            return ".";
    }

Como a língua portuguesa dispões de muita ~~sujeira e quinquilharia~~ acentos e símbolos, temos de tratá-las com as funções a seguir:

    // -> Recebe várias letras, separadas por virgula, para serem substituídas por uma letra específica.
    private static string ReplaceMultiplo(string value, string from, string to)
    {
        var fromPattern = string.Format("({0})", string.Join(")|(", from.Split(','))).Replace(".", @"\.");
        return Regex.Replace(value, fromPattern, to);
    }

    private static string GetSoundexBR(string value)
    {
        value = value.ToUpper();
        value = ReplaceMultiplo(value, "Á,À,Ã,Â,Ä", "A");
        value = ReplaceMultiplo(value, "É,È,Ê,Ë", "E");
        value = ReplaceMultiplo(value, "Í,Ì,Î,Ï", "I");
        value = ReplaceMultiplo(value, "Ó,Ò,Ö,Õ,Ô", "O");
        value = ReplaceMultiplo(value, "Ú,Ù,Û,Ü", "U");
        value = ReplaceMultiplo(value, ".,-,", string.Empty);
        value = ReplaceMultiplo(value, "0,1,2,3,4,5,6,7,8,9,0", string.Empty);
        value = ReplaceMultiplo(value, "Y", "I");
        value = ReplaceMultiplo(value, "PH", "F");
        value = ReplaceMultiplo(value, "GE", "JE");
        value = ReplaceMultiplo(value, "GI", "JI");
        value = ReplaceMultiplo(value, "CA", "KA");
        value = ReplaceMultiplo(value, "CE", "SE");
        value = ReplaceMultiplo(value, "CI", "SI");
        value = ReplaceMultiplo(value, "CO", "KO");
        value = ReplaceMultiplo(value, "CU", "KU");
        value = ReplaceMultiplo(value, "Ç", "S");
        value = ReplaceMultiplo(value, "WAS", "WS");
        value = ReplaceMultiplo(value, "WA", "VA");
        value = ReplaceMultiplo(value, "WO", "VO");
        value = ReplaceMultiplo(value, "WU", "VU");
        value = ReplaceMultiplo(value, "WI", "UI");

        // -> Depois de tratar a lingua portuguesa
        //      Geramos o soudex padrão.
        value = GetSoundex(value); 
        return value;
    }

Agora vem uma parte legal, vamos implementar isso diretamente no SQL Server, usando a CLR do SQL Server, ou seja, a vantagem do SQL Server utilizar o .NET Framework.

Para tal, vamos habilitar a execução da CLR executando os comando a seguir no SQL Server:

sp_configure 'clr', 1
go
RECONFIGURE
go

Em seguida crie no Visual Studio um projeto para o SQL Server:

Após isso o Visual Studio pede para se conectar a base onde a CLR será implantada:

O projeto já vem estruturado para o SQL Server e com exemplos de teste:

Nesse projeto existem várias opções prontas para implementar muitas das funcionalidades do banco de dados. Aqui usaremos uma Function:

Cada método que deverá ser função tem que ser decorado com o atributo "[Microsoft.SqlServer.Server.SqlFunction]". Outro ponto importante é que é possível trabalhar com os tipos do SQL Server. Eles são fundamentais para receber entradas e devolver as saídas.

Resta fazer os métodos que serão reconhecidas pelo SQL Server, ou seja, decoradas com o atributo citado acima. A classe final fica assim:

using System.Data.SqlTypes;
using System.Text.RegularExpressions;
using System.Text;
using System.Linq;

public partial class UserDefinedFunctions
{
    /*
     para ligar o clr no sql server:
        sp_configure 'clr', 1
        go
        RECONFIGURE
        go     
     */

    [Microsoft.SqlServer.Server.SqlFunction]
    public static SqlString SoundexBR(SqlString value)
    {
        StringBuilder palavras = new StringBuilder();
        value = NormalizarEspacos(value);
        
        var valorNormalizado = value.ToString();

        // -> Gera o Soundex de cada palavra da string
        valorNormalizado.Split(' ').ToList().ForEach(palavra => palavras.Append(string.Format("{0} ", GetSoundexBR(palavra))));

        // -> Retorna o tipo string do SQL Server
        return new SqlString(palavras.ToString().Trim());
    }

    // -> Retira espaços excedentes.
    [Microsoft.SqlServer.Server.SqlFunction]
    public static SqlString NormalizarEspacos(SqlString value)
    {
        var result = value.ToString().Trim();

        while (result.Contains("  "))
            result = result.Replace("  ", " ");

        return new SqlString(result);
    }

    // -> Recebe várias letras, separadas por virgula, para serem substituídas por uma letra específica.
    private static string ReplaceMultiplo(string value, string from, string to)
    {
        var fromPattern = string.Format("({0})", string.Join(")|(", from.Split(','))).Replace(".", @"\.");
        return Regex.Replace(value, fromPattern, to);
    }

    private static string GetSoundexBR(string value)
    {
        value = value.ToUpper();
        value = ReplaceMultiplo(value, "Á,À,Ã,Â,Ä", "A");
        value = ReplaceMultiplo(value, "É,È,Ê,Ë", "E");
        value = ReplaceMultiplo(value, "Í,Ì,Î,Ï", "I");
        value = ReplaceMultiplo(value, "Ó,Ò,Ö,Õ,Ô", "O");
        value = ReplaceMultiplo(value, "Ú,Ù,Û,Ü", "U");
        value = ReplaceMultiplo(value, ".,-,", string.Empty);
        value = ReplaceMultiplo(value, "0,1,2,3,4,5,6,7,8,9,0", string.Empty);
        value = ReplaceMultiplo(value, "Y", "I");
        value = ReplaceMultiplo(value, "PH", "F");
        value = ReplaceMultiplo(value, "GE", "JE");
        value = ReplaceMultiplo(value, "GI", "JI");
        value = ReplaceMultiplo(value, "CA", "KA");
        value = ReplaceMultiplo(value, "CE", "SE");
        value = ReplaceMultiplo(value, "CI", "SI");
        value = ReplaceMultiplo(value, "CO", "KO");
        value = ReplaceMultiplo(value, "CU", "KU");
        value = ReplaceMultiplo(value, "Ç", "S");
        value = ReplaceMultiplo(value, "WAS", "WS");
        value = ReplaceMultiplo(value, "WA", "VA");
        value = ReplaceMultiplo(value, "WO", "VO");
        value = ReplaceMultiplo(value, "WU", "VU");
        value = ReplaceMultiplo(value, "WI", "UI");

        // -> Depois de tratar a lingua portuguesa
        //      Geramos o soudex padrão.
        value = GetSoundex(value); 
        return value;
    }

    // -> Obtem o soudex de uma string
    private static string GetSoundex(string value)
    {
        value = value.ToUpper(); // -> Normaliza letras em Maiuscula
        var result = new StringBuilder();

        foreach (char item in value)
            if (char.IsLetter(item)) // -> Limpa String
                AddCharacter(result, item); // -> Adiciona um char Soudex

        // -> Limpa as exceções geradas
        result.Replace(".", string.Empty);
        // -> Arruma o tamanho no padrão soudex 
        //      4 caracteres.
        FixLength(result);

        return result.ToString();
    }

    // -> Preenche com 0 nos casos menor q quatro,
    //      ou pega os 4 primeiros caracteres.
    private static void FixLength(StringBuilder result)
    {
        var length = result.Length;

        if (length < 4)
            result.Append(new string('0', 4 - length));
        else
            result.Length = 4;
    }

    // -> Adiciona o caractere soudex, cuidando para não repetir.
    private static void AddCharacter(StringBuilder result, char item)
    {
        if (result.Length == 0)
        {
            result.Append(item);
        }
        else
        {
            var code = GetSoundexDigit(item);

            if (code != result[result.Length - 1].ToString())
                result.Append(code);
        }
    }

    // -> Algoritmo de substituição padrão Soudex.
    private static string GetSoundexDigit(char item)
    {
        var charString = item.ToString();

        if ("BFPV".Contains(charString))
            return "1";
        else if ("CGJKQSXZ".Contains(charString))
            return "2";
        else if ("DT".Contains(charString))
            return "3";
        else if ("L".Contains(charString))
            return "4";
        else if ("MN".Contains(charString))
            return "5";
        else if ("R".Contains(charString))
            return "6";
        else
            return ".";
    }
};

Pronto. Para testar coloque a chamada SQL no arquivo "Test.sql", veja:

"Dá o play macaco" #Cruj… E começa o deploy no banco de dados, veja o resultado:

Como podemos observar na imagem acima, o fonema é apresentado na janela de output, e como a dll já está instalada no SQL Server podemos testar diretamente nele:

Podemos aplicá-la em tabelas e views normalmente! O desempenho é muito superior comparada a uma implementação onde os dados são recuperados e processados por uma aplicação externa. Códigos .NET rodando diretamente na CLR do SQL Server são muito eficazes.

O Soundex é uma dos estudos disponíveis. Existe também o algoritmo BuscaBR, mas esse fica para uma outra oportunidade

Obrigado, abraços.

Gerenciando Workspaces no TFS

2011-07-20T22:06:00.001-03:00

Pessoal, estou aproveitando essa minha volta ao blog para torná-lo mais constante, com mais postagens. Para fazer isso estou escrevendo dicas sobre o trabalho que executo como arquiteto de software na área de ALM com a plataforma do Microsoft Visual Studio Team Foundation (TFS). E estou escrevendo essas dicas de uma forma mais objetiva e resumida, com textos mais curtos e focados.

Antes a perfeição pelos textos longos e complexos abatia meu entusiasmo, e como dizem: o perfeito é inimigo do bom. Agora que superei isso, lá vai:

Workspace, como o nome já diz, são espaços de trabalho que o Version Control vincula a um usuário e máquina. Assim quando o usuário "empresa\Astoufo" baixa um código fonte no computador com nome "EstacaoTrabalho22", será criado esse workspace: "EstacaoTrabalho22;empresa\Astoufo". É possível que um usuário tenha vários workspaces:

Assim, toda vez que for necessário baixar um código do Source Control para uma máquina diferente, é criado esse espaço de mapeamento local, onde os arquivos estarão disponíveis para o trabalho, e depois de tudo pronto, as alterações serão sincronizadas com o servidor (check-in). Esse local é um workspace.

Hoje no trabalho, um colaborador da equipe de desenvolvimento me procurou. Ele me relatou que estava assumindo uma antiga máquina, de um desenvolvedor que já havia se desligado, e ao tentar baixar o código fonte do projeto para a máquina, houve um conflito de workspace, pois o workspace do antigo funcionário estava vinculado para aquela máquina. Algo como isso:

Nessa hora entra em ação esses dois comandos do TFS:

tf workspaces: mostra informações dos workspaces.
tf workspace: manipula workspaces (cria, apaga etc.).

É necessário estar no prompt do Visual Studio para executar esses comandos, onde são carregados funcionalidades inerentes ao TFS.

Então executamos o seguinte comando para listar os workspaces de um determinado login:

tf workspaces /owner:domínio\usuário

Após analisar a lista, exclua os workspaces necessários com esse comando:

tf workspace /delete /collection:http://servidordotfs:8080/tfs/defaultcollection NOME_DO_COMPUTADOR;domínio\usuário

Assim temos um usuário satisfeito, nesse caso o desenvolvedor, e a limpa do(s) workspace(s) necessário(s), como mostrado na próxima imagem:

Repare pela seta na parte inferior da imagem, que é possível verificar se há pendencias (arquivos que ainda estão em "check-out"). Nesse caso não havia, mas caso houvesse é possível "liberar" as pendências… Mas isso fica para um futuro post

Novidades

2011-07-18T22:51:00.001-03:00

Pessoal, após um longo hiato, estou de volta com o blog, e espero que ele ganhe cada vez mais folego!

Depois de postar meu currículo por aqui, grandes oportunidades surgiram e surgem a cada dia, e com tudo isso foi difícil conciliar todas as novidades.

Ainda estou lidando com muitas transições, mas para quem acompanha a revista Mundo .NET já pode perceber que voltei a ativa na comunidade. Nela estou no grupo de revisores técnicos e volta e meia com artigos inovadores.

Agora estou morando em Curitiba/PR. Saindo de Maringá/PR, após um agradável trabalho desenvolvido na WRA, e muitas aulas empolgantes no CESUMAR, agora busco novos desafios na TechResult. Estou muito ligado nos trabalhos envolvendo Arquitetura de Software, ALM e a plataforma TFS.

Por uma lado "perdi" o mestrado da UEM. Acredito que na verdade foi um rumo que minha carreira tomou, onde o mercado exigiu o conhecimento que já tinha de imediato e me ofereceu boas oportunidades, recompensas e perspectivas por isso.

Mas agora eu tenho novas ideias, estou estudando muito, e assuntos diferentes. O mais legal é que a minha maneira de estudar é justamente expondo o que aprendo, e como o intuito do blog é esse, tudo canalizará aqui. Por isso vou passar um tempo reformulando-o, agora com a "cara mais eduardo spaki".

É isso daí, vamos crescer juntos

Auditoria no TFS - PT I

2011-07-18T20:58:00.001-03:00

Um dos recursos e premissas mais interessantes do TFS é sua auditoria, pois maioria das operações sobre a plataforma são salvas e versionadas.

O Version Control é o pilar do TFS responsável pelo controle, versionamento e distribuição dos arquivos, principalmente códigos, dos projetos de software.

Durante o dia-a-dia de administração de servidores TFS, as pessoas me abordam com perguntas similares a estas:

Quais são os arquivos que estão alocados/bloqueados de um projeto?
Quais arquivos estão alocados/bloqueados para um determinado usuário?

Geralmente para responder essas perguntas eu sigo os passos a seguir:

Abrir o Source Control do projeto, pela janela do Team Explorer.

Após encontrar a pasta do projeto, clico com o botão direito na mesma clico em "Find in Source Control" > "Status".

As duas opções acima (Status e Wildcard) remetem a mesma tela.
Para exibir todos os arquivos que estão alocados para algum usuário, configuro a opção "Display all checked out".

O resultado aponta cinco arquivos com dois usuários. Todas as informações necessárias para "destravar" os arquivos, caso necessário, estão disponíveis no resultado dessa busca.

Para encontrar os arquivos alocados para um determinado usuário, e que contenha a sequencia de letras "pro" em seu nome, configure a tela de acordo com a figura a seguir. Observe que o usuário deve ser informado com o domínio.

E novamente temos o resultado filtrado.

Quando se administra um ambiente de desenvolvimento sobre o TFS é importante ter respostas para as perguntas acima, e espero ter explorado algumas formas de respondê-las.

Até a próxima.

Currículo

2011-01-10T16:02:00.001-02:00

Aproveitando as novas oportunidade e o ano novo, segue meu currículo:

Download Aqui!

Currículo Eduardo

Árvores pt III: Teoria, Introdução, Binárias e AVL.

2010-10-19T20:22:00.001-02:00

Continuando a abordagem da estrutura de dados “Árvore” (já abordadas neste e neste post), vamos explorar desta vez as árvores AVL.

Ás árvores AVL, são árvores binarias, mas com um diferencial: Elas são balanceadas!

Mas o que vem a ser árvores balanceadas? São árvores que tendem a ter a mesma altura à direita e à esquerda! Formalmente, considerasse que uma árvore é balanceada quando, para cada nó, a altura da sub-árvore da esquerda não difere da altura da sub-árvore direita em mais de uma unidade.

Abaixo, um exemplos de árvores balanceadas e não balanceadas:

Quais as vantagens de uma árvore balanceada? Bem, quando a árvore está balanceada, podemos dar menos saltos para atingir o item procurado. No último exemplo da figura acima, para encontrar o item “B”, precisaríamos de 4 saltos, enquanto no penúltimo exemplo apenas 1 salto seria necessário.

Então pare e pense: As árvores de pesquisa são construídas de modo a tornar mais eficiente a tarefa de procura dos elementos, visando que o elemento deve ser procurado à esquerda (caso seja menor que o item atual), ou procurado à direita (caso seja maior do que o item atual), mas nunca em ambos os lados, nada melhor do que a árvore estar balanceada.

Mas por que AVL? Isto é porque os matemáticos russos Adelson-Velskii e Landis que fizeram a proposta deste modelo.

Várias são as estratégias de balanceamento, podemos balancear ao inserir um elemento, ao excluir um elemento, disparar um comando manualmente para balanceá-la etc.

Para determinar a necessidade do balanceamento, teremos de calcular o Fator de Balanceamento. Para uma árvore balanceada, o módulo deste fator não pode ser maior do que 1. Lembrando que cada vértice tem de ter seu Fator de Balanceamento calculado. Dizemos que:

Se o Fator de Balanceamento for igual a –1: Sub-árvore da esquerda é mais alta.
Se o Fator de Balanceamento for igual a 0: Os dois lados tem a mesma altura.
Se o Fator de Balanceamento for igual a 1: Sub-árvore da direita é mais alta.
O Fator de Balanceamento de uma folha é sempre 0!

… E como dito anteriormente, dentro destes limites, ainda não é necessário balancear a árvore.

Para calcular o Fator de Balanceamento (FB) de um vértice temos:

FB(vértice v) = altura(sub-árvore direita v) - altura(sub-árvore esquerda v)

Observe a árvore (balanceada) abaixo com os fatores calculados:

Se o fator extrapolar o intervalo (-1, 1) , significa que a árvore está desbalanceada! Então temos de dar início ao processo de balanceamento em árvores AVL.

Vamos pensar em um processo para a inserção.

Inserimos um novo elemento na árvore.
A inserção deste novo elemento pode ou não violar a propriedade de balanceamento.
Se a inserção não violar a propriedade de balanceamento, podemos continuar inserindo novos elementos.
Se a inserção violar temos de dar início nas Rotações da Árvore.

A Rotação da Árvore é um algoritmo que visa ajustar o balanceamento, trocando elementos de posição em “girando os elementos pelos seus lugares”. Pode ser usado para qualquer caso de balanceamento AVL. Temos quatro tipos de rotação: Rotação simples à esquerda, rotação simples à direita, Rotação dupla à esquerda, Rotação dupla à direita.

Rotação Simples

Observe a seguinte evolução da árvore, ao inserirmos o elemento “3” no exemplo a seguir:

Percebam que o elemento “2”, que inicialmente estava com FB (Fator de Balanceamento) igual a 0 no primeiro estágio, ganhou um FB de 1 por conta do elemento “3” inserido à direita. Calculando o FB do elemento “8”, temos que somar, em módulo, o FB de suas sub-árvores.

Aqui vai um macete, quando tivermos o sinal negativo a rotação (ao menos a primeira) deve ser à direita (pois ó sinal negativo indica maior peso/altura para a esquerda). Se o sinal for positivo, então a rotação deve ser efetuada para a esquerda.

Outro macete, quando os sinais dos FBs (pai e filho) são iguais (elemento “8” tem FB = –2 e o elemento “4” tem o FB = –1, ambos são negativos), a rotação é simples. Caso sejam diferente a rotação deverá ser dupla (seguindo o macete do sinal).

Então, o elemento “4”, que está à esquerda do elemento “8” sobe para a direita, só que isso faria com que ele tivesse três filhos (6, 8, 10), então passamos um filho, nesse caso o maior (da direita) para a sub-árvore do elemento “8”.

Rotação Dupla

Observe a evolução dos exemplos a seguir quando inserimos o elemento “5” na primeira árvore da imagem abaixo:

Percebam que o vértice “8” ficou com FB = –2, porém o sinal do seu filho esquerdo é positivo, sendo assim, o sinal é inverso, resultando em rotação dupla. Porém tenha calma.

Um terceiro macete: a rotação começa de baixo para cima! Nesse exemplo, o vértice desbalanceado é o “8”, como a rotação é dupla, vamos rotacionar primeiro o seu filho desbalanceado para a esquerda (jogando o elemento “4” para baixo).

Para concluir, bastaria rotacionar, na posição oporta (direita) o vértice “8”.

Para compreender: a rotação define qual lado o elemento com FB alterado deve prosseguir.

Observe a generalização dos processos abaixo:

Para tal, teremos dois vértices especiais:

P – Vértice ancestral mais próximo do elemento inserido, cujo o FB fica fora do intervalo (-1, 1);
Q – Filho de P na sub-árvore onde ocorreu a inserção.

Os triângulos representam as sub-árvores, eventualmente presentes na árvore.

Rotação simples à esquerda

Neste caso o vértice Q sobe para a posição anteriormente ocupada pelo vértice P. A sub-árvore com o elemento 2 (estava à esquerda de Q, portanto constituída de elementos menores), passa para a direita de P, cedendo assim o lugar à esquerda de Q, para que P possa ser seu filho.

Rotação simples à direita

Neste caso o vértice Q sobe para a posição anteriormente ocupada pelo vértice P. A sub-árvore com o elemento 2 (estava à direita de Q, portanto é constituída de elementos maiores), passa para a esquerda de P, cedendo assim o lugar à direita de Q, para que P possa ser seu filho.

Rotação dupla à esquerda

A rotação dupla à esquerda é constituída por duas rotações simples:

a primeira, à direita, em torno do nodo Q,
e a segunda, à esquerda, em torno do nodo P.

Rotação dupla à direita

A rotação dupla à direita é constituída por duas rotações simples:

a primeira, à esquerda, em torno do nodo Q,
e a segunda, à direita, em torno do nodo P.

Então fica mais esse macete: quando há rotação dupla, a rotação principal é a ultima que será executada, pois começamos “de baixo para cima”.

Revisão

Se o FB do vértice P for positivo, a rotação deve ser feita para a esquerda, se for negativo, para direita.
Se o FB do vértice P e o FB do vértice Q tiverem o mesmo sinal, a rotação deve ser simples, se tiverem sinais contrários, a rotação deve ser dupla.

Pseudo-código

    1. Insira o novo vértice normalmente ;

    2. Iniciando com o vértice pai do elemento recém-inserido, teste se a propriedade AVL
        é violada, ou seja, teste se o FB deste é maior do que abs(1).
        Temos aqui 2 possibilidades:

        2.1. A condição AVL foi violada

            2.1.1. Execute as operações de rotação conforme for o caso (Tipo 1 ou Tipo 2)

            2.1.2. Volte ao passo 1

        2.2. A condição AVL não foi violada.

            2.2.1. Se o vértice recém-testado não tem pai, ou seja, é a raiz da árvore,
            volte para inserir novo elemento (Passo 1)

E agora o código em C (documentado)

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>

struct Item
{
    int numero;
    Item *esquerda;
    Item *direita;
};

Item** Procurar(Item **itemAtual, int valor)
{
    if(*itemAtual == NULL)
    {
        return NULL;
    }
    else if((*itemAtual)->numero == valor)
    {
        return itemAtual;
    }
    else if(valor < (*itemAtual)->numero)
    {
        return Procurar(&(*itemAtual)->esquerda, valor);
    }
    else
    {
        return Procurar(&(*itemAtual)->direita, valor);
    }
}

bool Remover(Item **itemAtual, int valor)
{
    Item **itemProcurado = Procurar(itemAtual, valor);

    if(itemProcurado == NULL)

    {
        printf("\nItem não encontrado!\n");
        return false;
    }

    Item *temp = *itemProcurado;

    if((*itemProcurado)->direita == NULL)
    {
        // -> Não tem filho a direita.
        (*itemProcurado) = (*itemProcurado)->esquerda;
    }
    else if((*itemProcurado)->esquerda == NULL)
    {
        // -> Não tem filho a esquerda.
        (*itemProcurado) = (*itemProcurado)->direita;
    }
    else
    {
        // -> Tem os dois filhos.
        Item *anterior = NULL;

        temp = (*itemProcurado)->esquerda;

        while (temp->direita != NULL)
        {
            anterior = temp;
            temp = temp->direita;
        }

        (*itemProcurado)->numero = temp->numero;

        if(anterior == NULL)
        {
            (*itemProcurado)->esquerda = temp->esquerda;
        }
        else
        {
            (*itemProcurado)->direita = temp->esquerda;
        }
    }

    free(temp);
    return true;
}

void ListarPreOrdem(Item *itemAtual)
{
    if (itemAtual != NULL)
    {
        printf("%i; ", itemAtual->numero);
        ListarPreOrdem(itemAtual->esquerda);
        ListarPreOrdem(itemAtual->direita);
    }
}

void ListarInOrdem(Item *itemAtual)
{
    if (itemAtual != NULL)
    {
        ListarInOrdem(itemAtual->esquerda);
        printf("%i; ", itemAtual->numero);
        ListarInOrdem(itemAtual->direita);
    }
}

void ListarPosOrdem(Item *itemAtual)
{
    if (itemAtual != NULL)
    {
        ListarPosOrdem(itemAtual->esquerda);
        ListarPosOrdem(itemAtual->direita);
        printf("%i; ", itemAtual->numero);
    }
}

void Listar(Item *itemAtual)
{
    printf( "Listando... \n\n");
    ListarPreOrdem(itemAtual);
    printf("\n\n");
}

int CalcularAltura(Item *itemAtual)
{
    int esquerda;
    int direita;

    if (itemAtual == NULL)
    {
        return 0;
    }
    else
    {
        esquerda = CalcularAltura(itemAtual->esquerda);
        direita = CalcularAltura(itemAtual->direita);

        if (esquerda > direita)
        {
            return esquerda + 1;
        }
        else
        {
           return direita + 1;
        }
    }
}

int CalcularFatorDeBalanceamento(Item *itemAtual)
{
    if (itemAtual == NULL)
    {
      return 0;
    }
    else
    {
        int fator = CalcularAltura(itemAtual->direita) - CalcularAltura(itemAtual->esquerda);
        return fator;
    }
}

void RotacionarParaEsquerda(Item **itemAtual)
{
    Item *temp;

    printf ("Rotacao para esquerda de %i\n", (*itemAtual)->numero);

    temp = *itemAtual;
    *itemAtual = (*itemAtual)->direita;
    temp->direita = (*itemAtual)->esquerda;
    (*itemAtual)->esquerda = temp;
}

void RotacionarParaDireita(Item **itemAtual)
{
    Item *temp;

    printf ("Rotacao para direita de %i\n", (*itemAtual)->numero);

    temp = *itemAtual;
    *itemAtual = (*itemAtual)->esquerda;
    temp->esquerda = (*itemAtual)->direita;
    (*itemAtual)->direita = temp;
}

bool InserirAVL(Item **itemAtual, int valor)
{
    // -> Se o nó for nulo então o item alocado é colocado nele.
    if(*itemAtual == NULL)
    {
        // -> Aloca memória para o novo item
        Item *novo = (Item *)malloc(sizeof(Item));

        // -> Checa se foi alocado memória corretamente.
        if (novo != NULL)
        {
            // -> Define e inicializa os valores.
            novo->numero = valor;
            novo->esquerda = NULL;
            novo->direita = NULL;
        }
        else
        {
            return false;
        }

        *itemAtual = novo;
    }
    else // -> Decisão: Esquerda ou Direita?
    {
        // -> valor menor que o atual vai para a esquerda.
        if(valor < (*itemAtual)->numero)
        {
            InserirAVL(&(*itemAtual)->esquerda, valor);

            // -> Após inserir, temos de verificar se há necessidade de balanceamento.
            // -> Como inserimos na esquerda, vamos balancear apenas a direita, pois a esquerda pode pesar.
            int fatorDeBalanceamentoItemAtual = CalcularFatorDeBalanceamento(*itemAtual);

            if(abs(fatorDeBalanceamentoItemAtual) > 1)
            {
                int fatorDeBalanceamentoItemEsquerda = CalcularFatorDeBalanceamento((*itemAtual)->esquerda);

                // -> Define se vai ocorrer rotação dupla
                if(fatorDeBalanceamentoItemAtual * fatorDeBalanceamentoItemEsquerda < 0)
                {
                    printf("rotacao dupla (%i, %i)\n", fatorDeBalanceamentoItemAtual, fatorDeBalanceamentoItemEsquerda);

                    RotacionarParaEsquerda(&(*itemAtual)->esquerda);
                    RotacionarParaDireita(itemAtual);
                }
                else
                {
                    printf("rotacao simples (%i, %i)\n", fatorDeBalanceamentoItemAtual, fatorDeBalanceamentoItemEsquerda);

                    RotacionarParaDireita(itemAtual);
                }
            }

        }
        else // -> valor maior que o atual vai para a direita.
        {
            InserirAVL(&(*itemAtual)->direita, valor);

            // -> Após inserir, temos de verificar se há necessidade de balanceamento.
            // -> Como inserimos na direita, vamos balancear apenas a esquerda, pois a direita pode pesar.
            int fatorDeBalanceamentoItemAtual = CalcularFatorDeBalanceamento(*itemAtual);

            if(abs(fatorDeBalanceamentoItemAtual) > 1)
            {
                int fatorDeBalanceamentoItemDireita = CalcularFatorDeBalanceamento((*itemAtual)->direita);

                // -> Define se vai ocorrer rotação dupla
                if(fatorDeBalanceamentoItemAtual * fatorDeBalanceamentoItemDireita < 0)
                {
                    printf("rotacao dupla (%i, %i)\n", fatorDeBalanceamentoItemAtual, fatorDeBalanceamentoItemDireita);
                    RotacionarParaDireita(&(*itemAtual)->direita);

                    RotacionarParaEsquerda(itemAtual);
                }
                else
                {
                    printf("rotacao simples (%i, %i)\n", fatorDeBalanceamentoItemAtual, fatorDeBalanceamentoItemDireita);

                    RotacionarParaEsquerda(itemAtual);
                }
            }
        }
    }
    return true;
}

void Menu()

{
    printf( "Digite a sua escolha: \n"
        "    1 para inserir um elemento na arvore \n"
        "    2 para remover um elemento da arvore \n"
        "    3 para finalizar \n"
        "? ");
}

void main()
{
    Item *raiz = NULL;

    int opcao;
    int numero;

    Menu();
    scanf("%i", &opcao);

    while (opcao != 3)
    {
        switch (opcao)
        {
            case 1:
                printf( "Digite um numero: ");
                scanf("\n%i", &numero);
                InserirAVL(&raiz, numero);
                Listar(raiz);
                break;

            case 2:
                printf( " Digite o numero a ser removido: ");
                scanf( "\n%i", &numero);
                Remover(&raiz, numero);
                Listar(raiz);
                break;

            default:
                printf( "Escolha invalida.\n\n");
                Menu();
                break;
        }

        scanf("%i", &opcao);
    }
    printf("Fim do programa.\n");
}

Resultado do código, listando em pré-ordem:

Bem, após todos estes ensinamentos, dicas e macetes, me resta deixar algumas tarefas:

Implementar o balanceamento na exclusão.
Retirar o balanceamento automático (quando um elemento é inserido e/ou excluido) e implementar o balanceamento via comando.
Após concluído os exercícios anteriores, implementá-los em uma árvore de alunos, se baseando no RA do aluno como indice para a árvore.
Após concluído os exercícios anteriores, implementá-los em uma árvore de alunos, se baseando no Nome do aluno como indice para a árvore.

Espero que tenham, gostado boa sorte!!!

Zero é Par?

2010-10-07T11:59:00.000-03:00

Sim!, más há alguns porém!

Me preocupei em responder primeiro, para não ficar aquela coisa de ler tudo e ver a resposta, ou pior: leia e tire suas conclusões!

Mas que fique claro que esta é minha opinião baseada no fato de que: na maioria dos experimentos e teorias a conclusão foi que o número Zero (0) é par! Porém, como demsontrarei abaixo, existem contextos em que isso não corresponde.

E tudo começou ha tempos atrás. Mas se intensificou a discussão com alunos nas faculdades.

Então venho conversando com físicos e matemáticos, e colhei basicamente as informações abaixo, mas descritas pelo site: http://razaok.blogspot.com/2009/01/zero-nmero-par-pares-impares-e-neutros.html

Vamos para algumas explicações então:

Definição de Par e Ímpar:

Par n = 2k
Impar n = 2k + 1

Tal que n, k є I.

Então, caso fosse impar:
0 = 2k + 1
k = - 1/2 (não é 0)

Logo, k é par:
0 = 2k
k = 0

Propriedade da Soma:

A soma de números iguais, em módulo, é sempre par.

par1 + par2 = par

I) -2k - 2k = 2(-2k) = 2n

II) 2k + 2k = 4k = 2(2k) = 2n

III) 2k - 2k = 2(k - k) = 2(0) = 2n = 0

impar1 + impar2 = par

I) -2k - 1 - 2k - 1 = -4k - 2 = 2(-2k - 1) = 2n

II) 2k + 1 + 2k + 1 = 4k + 2 = 2(2k + 1) = 2n

III) 2k + 1 - 2k - 1 = 2(k - k) = 2(0) = 2n = 0

Não existe uma soma de resultado impar que se resulte em zero.

Divisibilidade:

Uma definição também para par é que o número é divisivel por 2.

Pois n = 2k, logo n/2 = k

0 = 2.0

0/2 = 1.0 = 0

ou seja:

0/2 = 2.Inteiro + zero de resto

- Caso fosse impar isso se resulta em absurdo.

n = 2k + 1

0/2 = 2. Inteiro + 1 de resto

0 = 4.k + 2

4k = -2

k = -1/2 (não é 0)

A Soma de 2 Números Pares

Como já visto, a soma de dois números pares é sempre par.

E a soma de dois números impares é sempre par também.

2 números pares

0 + 2k = 2k

0 + 8 = 8

2 números impares

0 + 2k + 1 = 2k + 1

0 + 1 = 1

(logo é uma soma de um par com um impar)

- aqui também fica a questão da propriedade do elemento neutro das aditivas.

- consequencia dessa propriedade, multriplicação de pares por impares se resulta em par.

Multiplicação Par x Impar:

2k.(2y + 1) = 4ky + 2 = 2(ky + 1) = 2n

Logo,

0.impar ou 0.par = par

Pares Perfeitos

Números pares são números que correspondem a uma associação igual entre dois números sem ter resto.

Ou seja, podemos representar da seguinte forma:

7 = | | | | | | |

Pegando seus pares e os removendo, ou seja, dividindo por 2. Temos traço sem par, ou seja, houve o resto de 1.

4= | | | |

Assim, se tem 2 pares e com resto zero.

0 = ?

Aí entra um problema, pois não há pares em zero; porém o resto é zero. Mas não há o par.

Logo, nessa definição zero não é par. Ou seja, quando se tem o número associado como quantidade o zero é puramente neutro e não adquire propriedade como par, nem impar.

Confusão de Conceitos

Talvez a grande questão que leva a confusão seja um problema quanto alguns conceitos quanto as caracteristicas de um número.

Característica 1:

Conjunto - Um número pode ser Racional ou Irracional, num dominio Real.

Característica 2:

Primaridade - Número primo são os números que apenas são divisiveis por 1 e por ele mesmo. Até hoje não se encontrou uma equação ou formulação certa para isso.

Quanto a isso, os números são classificados como primo ou não-primo.

Característica 3:

Opostos/Inversos e Neutros - Neutro = associação de opostos ou inversos

0 = 1 + (-1)

0 = 4 + (-4)

1 = 2^0 = 2/2 = 1 = 2.(1/2)

1 = 7^0 = 7/7 = 1 = 7.(1/7)

Característica 4:

Pariedade - Números divisiveis por 2 são pares.

Ou seja, um número pode possuir uma ou mais caracteristicas. E não se pode dizer assim, se ele tem a caracteristica de neutro então não pode possuir outra. Caso fosse assim. Se o (-2) é oposto de 2, então não podemos dizer que ele é par?

Quocientes, númeradores e restos:

Vamos pensar no 4,4 no 2,2 e no 1,1. Eles são pares?

No conjunto dos racionais são, no dos inteiros não?

4,4 : 2 = 2,2 + 0

Ou seja, resto 0? Não. Pois 4,4 / 2 = 2 + 0,2

2,2 / 2 = 1,1 + 0

É assim? Ou é 2,2 / 2 = 1 + 0,1 ?

1,1 / 2 = 0,55

Um dos problemas é que muitos esquecem que decimais são frações, não é um resto zero. Ou então, associam qualquer número com finais (a última casa à direita) 0, 2, 4, 6 e 8 como sendo par. Em geral, são alguns vicios de se trabalhar com tais algarismos pares, de modo a identificar o número como par devido a isso. E com isso, é comum olhar números pares com final zero, como 10, 50, 100, e, devido a isso, considerarem o zero como sendo um número par. Sim, se pode dizer que quando o ultimo algarismo do número for par, o número é par; mas afirmar que devido a isso o zero é par; é esquecer da propriedade do que define um número sendo par. Porém, esquecem de uma propriedade de dizima periódica: Qualquer número racional tem dizima periódica.

Tanto o 3 quanto o 3,3 quanto o 3,33...

3 = 3,0000000000000000000... (dizima em zero)

3,3 = 3,3000000000000000000... (dizima em zero)

3,33.... = 3,3333333333333333333... (dizima em 3)

- Algum deles é par? E os seguintes?

2 = 2,0000000000000000000... (dizima em zero)

2,2 = 2,2222222222222222222222... (dizima em dois)

2,22222222222222 = 2,222222222222220000000... (dizima em zero)

Pois muitas vezes se faz uma confusão quanto a diferenciar o que é parte inteira e parte decimal.Exemplos:

2,2 = (2 + 0,2) = 2 + 2.10^(-1) = 2 + 2/10

Tem a parte inteira e a parte decimal. A parte inteira pode ser classificada se é par ou impar. A parte decimal não, nela, apenas podemos dizer qual algarismo é par ou impar.

0,5 é par?

e

1/2 é par?

e

5/10?

10/20?

40/80?

Percebeu qual é realmente o significado de número inteiro e de resto zero? O que se deve levar conta para considerar o zero como par?

A Régua:

Por fim, um exemplo simples. Numa reta, os pontos representam sua posição no espaço. Quanto as casas dos centimetros. Sempre segue uma ordem par, impar, par, impar... contatos a partir de uma referência. A regua começa normalmente com 0, 1, 2, 3, 4, ... (par, impar, par, impar...). Apenas no 1 se tem a unidade. Logo toda unidade tem tamanho 1. Como é impar, é uma associação de um par com um impar: par - impar = 1

1 - 0 = 1

2 - 1 = 1

3 - 2 = 1

Agora mude a régua. Arraste de modo que a régrua seja: -1, 0, 1, 2, 3, ... (e aí mudou alguma coisa?) Não, a propriedade continuou igual. Note que a ordem contiuna: (impar, par, impar, par...) É o algarismo que representa se é par ou imparO ponto zero representa a unidade 1. Ou seja, continua a mesma história, do tamanho, do módulo:

0 - (-1) = 1

par - impar = impar

1 - 0 = 1

Espero que tenham gostado de filosofar um pouco de matemática comigo

Até mais.

#TechEdBr 2010: Uma visão mais técnica

2010-10-06T08:00:00.000-03:00

Bem, já fiz este post sobre o TechEd Brasil 2010. Nele dei um overview sobre o evento. Agora vou compartilhar um pouco da minha visão de acordo com as trilhas técnicas que participei.

Desenvolvendo para Azure:

Uma boa palestra que abriu minha mente para como grandes sistemas funcionam (facebook, twitter, meu blog etc.). Essa façanha se dá graças a algumas estratégias de armazenamento e replicação de informação. E foi mostrado como o Azure faz isso, através de seus storages (Drives, Blobs, Tables e Filas). Vejamos algumas anotações:

Windows Azure: SO que gerencia a grande malha de servidores dos Data Centers na Nuvem. Cuida do balanceamento, da seleção de máquinas e tolerância a falhas.
Se paga pelo que usa (igual a conta de água e luz).
App Fabric (Malha de aplicações)
Web Role (uma aplicação web por exemplo)
Work Role (Um processamento de enconding de vídeo por exemplo)
A app fica pronta em +- 5min após o deploy.
VS gerencia o Azure pelo Server Explorer
Há um emulador de Azure para testes.
Projeto Azure no VS descreve como executar uma app no Azure.
É preciso uma SDK (baixar no site do Azure).
Storages: Blobs (Arquivos com metadados, nome únicos, acessíveis por URI, divisível em blocos e páginas; Tables (Armazenamento estrutural, escalável, manipulável por LINQ e REST); Drive (NTFS, Declarável, compartilhado, utiliza Blob por baixo dos panos, muito utilizado para migração de apps).
Filas: Mensagens entre as apps.

Desenvolvendo para C# no Mundo Moderno:

Palestra básica sobre novidades do C# 4. Basicamente tirei minha dúvida: Porque um objeto Anônimo, quando é passado como dynamic para outra camada, fica inacessível? Tipos anônimos são privados!

Tudo que você precisa saber sobre Scrum, ALM e Visual Studio:

Consegui extrair apenas alguns pontos interessantes dessa palestra:

Cone de incerteza da NASA (Imagem acima).
Scrum: Transparência, inspeção, adaptação. Framework, não metodologia.
“Nenhum planejamento de guerra vai além da primeira batalha”.
Diagrama de dependência (VS 2010): Quanto mais larga a flecha, maior a dependência.
VS 2010 trabalha com UML 2.1
Existe uma extensão para o VS 2010 gerar código a partir do diagrama de classes da UML.
Possibilidade de gerar testes de UI (“Macros”) no VS 2010.

SQL Azure:

Essa palestra deixou mais claro a forma transparente e as regras do SQL Server nas Nuvens. Anotações:

Usa Transact SQL Normalmente.
Conecta normalmente pelo Server Explorer do VS.
Não suporta manipular várias bases de uma vez (key word “USE”).
Suporta o SQL Management Studio, mas para mudar de base é preciso desconectar e re-conectar.
Duas versões: Web Edition (Mais “limitada”); Business Edition.
Tem uma versão de teste gratuita.
Tem uma ferramenta de TCO Calculator.
Não é possível subir um backup local para a nuvem. Mas há um exportador de base.
Somente SQL Authentication.
Tem Firewall.
BCP Upload.
SQLCat.
Suporta LINQ to SQL.

Meu site anda meio lento:

Essa track foi show de bola, mostrou a estratégia dos principais players do mercado (Google, Yahoo, Microsoft, Twitter etc.). De cara uma coisa ficou evidente: temos que nos preocupar muito com detalhes no front-end (html gerado, css, javascript, imagens).

A velocidade depende da expectativa e percepção do usuário.
Deve ser levada uma experiência ao usuário, como uma barra de progresso de upload, para “acalmá-lo”.
O Browser é relevante.
Fiddler (Proxy Sniffer): coleta informações de rede sobre a requisição de um site.
o IE tem 50mb de cache, o Chrome 200mb.
Usar GZip.
Usar Sprites (Imagem acima).
Tomar cuidado com espaços em branco no HTML, javascript etc.
Antecipar resolução de DNS~.
Evitar o uso de “@Import” no CSS (é sequencial).
Quando possível: Styles (CSS) no cabeçalho, Scripts no final da página (pois o seu processamento pode “travar momentaneamente” a renderização.
Utilizar o “var” no javascript, assim o interpretador não vai varrer todo o código para localizar sua declaração inicial.
Netmoon: analisador de pacotes.
webpagetest.org

Team Foundation Server:

Palestra do meu amigo Ramon Durães, basicamente muitos assuntos, e perguntas dos espectadores, que já eram do meu domínio. Mas foi legal ver a facilidade que o TFS trouxe, na parte de instalação e configuração, seja para grandes empresas ou apenas um usuário. Apenas uma questão ficou no ar que é “quando um grupo desenvolve sobre um usuário do proxy, eu perco a rastreabilidade!?”. No mais: Sharepoint e Reporting Services são opcionais para o TFS 2010. E o Firewall tem de ser muito bem configurado para o Home office.

Desenvolvendo uma app Silverlight em 75 minutos:

Outra excelente trila, onde aprendi bastante coisa sobre o Blend, WCF Ria Services, Resolução de Timeline, Path Lista Box (Layout path (ex: Elipse)).

WCF:

Basicamente só observei as estratégias de endpoint do WCF.

MVVM:

Pattern(Receita de bolo) super interessante para desenvolver com bind em WPF e Silverlight, onde separamos os dados da visualização.

Model <-> ViewModel <-> View

Não é um framework (embora exista alguns de apoio).
Validação fica na view.
Executa commands, e não eventos.
ViewModel: ICommand; INotifyPropertyChanged; IDataErrorInfo; DataContext da View;
Testável.

MEF:

Uma das melhores palestras que assisti, com uma didática fora do comum!

MEF é um framework que ajuda a criar plug-ins para uma aplicação, e assim extendê-la.

O Exemplo que foi dado foi de uma calculadora, onde cada operação era um plug-in/extensão/dll. Simplesmente era colocada a dll gerada na pasta de plug-ins

Funciona no .NET 4 e Silverlight 4
Apps abertas para extensão, fechadas para modificação.
Plug-in: componente de software para acrescentar funcionalidades. Assim reduzindo o tamanho da APP principal, mas é possível extendê-la conforme a necessidade (bastando um contrato/padrão de implementação).
Carrega sobre descoberta e dinamicamente.
Transforma apps estaticamente compiladas em dinamicamente composta.
Exportação + Importação = Composição
Catálogos: Diretório, assembly, etc.
Contratos por Interfaces.
Suporta Lazy<>.

RIA, Silverlight e WCF:

Track onde foi demonstrada que Ria Services elimina um pouco da responsabilidade do desenvolvedor de lidar com as chamadas assíncronas no Silverlight. O WCF RIA Services suporta JSON e precisa dos namespaces:

System.ServiceModel.DomainServices.Client
System.ServiceModel.DataAnotation
System.ServiceModel.Web

Windows Phone 7:

Nada muito técnico, apenas exemplos de apps e games rodando sobre um protótipo do aparelho, mesmo assim impressionante, principalmente o SO e seu HUB (Atividades, Conteúdos, Games, Social Network, etc.)

Curiosidade sobre os botões, que na ordem são: Back, Start, Busca.

WIF (Windows Identity Foudation):

E a última palestra, também sensacional, do Israel Aece, sobre autenticação única com este framework de autenticação, que funciona sobre WCF, Web, Desktop etc. Foi mostrado um exemplo de dois sites distintos e uma única autenticação (+- como o Google faz com Orkut e Gmail). Porém ela foi bem complexa, segue anotações:

1º Autenticação.
2º Autorização (regras de acesso por exemplo).
IdentityProvider (Security Token Service)
Realying Party (Aplicação).
Subject (Emissão de tokens).
Claims (informações de autorizações).
Microsoft.IdentityModel (Namespace).

Conclusão:

Bem, foi isso, tecnicamente peguei sim algumas poucas palestras fracas, mas consegui pegar muita coisa útil para trazer junto comigo na bagagem profissional, agora é estudar mais e aplicar

Espero que tenha gostado e quem sabe em breve estarei mais eventos, absorvendo mais conhecimento, e compartilhando-os com vocês.

E como já disse no outro post sobre o TechEd Brasil, o evento foi ótimo, correria total, mais ótimo!

Até mais.

Um pouco sobre ADO.NET

2010-09-28T08:00:00.000-03:00

Como se conectar a um banco de dados com o C# ou outra linguagem da plataforma .NET?

Bem, a maioria das aplicações comerciais desenvolvidas precisam de interação com uma base de dados, para persistir informações, processá-las conforme a necessidade e disponibilizá-las posteriormente.

Dentro do .NET Framework (Plataforma com bibliotecas por trás do C#), temos um subconjunto de bibliotecas, ou um outro framework conhecido como ADO.NET (ActiveX Data Objects). Ele é responsável pela comunicação com alguma base de dados, seja em nível mais primitivo ou robusto.

Como ele faz isso? Através de classes simples e intuitivas, de fácil utilização. Também é possível plugar drivers de conexão com banco de dados nele. Isso o torna bem extensível, ou seja, é possível eu conectar com qualquer base de dados que tenha um driver escrito para o ADO.NET. Na maioria das vezes o fabricante da base de dados acaba fornecendo esse driver.

O driver é o conjunto de bibliotecas necessárias para se comunicar com a base de dados. Apesar dos bancos de dados serem os mais variados possíveis, o ADO.NET impõe um padrão, então apenas alguns detalhes irão mudar nos acessos. No geral o padrão é o mesmo. Mas o ADO.NET expande bastante esse conceito de drivers, e pela imposição do padrão, dentro do .NET eles acabam se tornando nossos Provedores (Providers) de dados.

Os provedores de dados ficam responsáveis por fornecer meio de conexão, leitura e “escrita” em um banco de dados.

Há duas formas básicas (primitivas) de se obter dados de uma consulta a uma base de dados. Uma delas é com DataSet. A outra é com DataReader.

O DataSet é um mapeamento em memória das tabelas, relacionamentos e linhas solicitada na consulta. Ele mantém um controle sobre o estado dos objetos na memória, logo ele tem a capacidade de persistir as mudanças no banco de dados.

O DataReader é um leitor de item a item (linha a linha) retornada da consulta. Ele é mais rápido por não mantém todos os metadados que o DataSet mantém. Porém é somente leitura.

No .NET temos alguns provedores nativos. São eles:

SQL Server (System.Data.SqlClient),
OLE DB (System.Data.OleDb),
ODBC (System.Data.Odbc),
Oracle (System.Data.OracleClient – Apenas até o VS 2008/.NET 3.5).

Como já comentado antes, esse provedores são expansíveis, uma prova disso é que a própria Oracle tem um provedor para o ADO.NET (e como eles conhecem melhor o caminho das pedras da base de dados deles, acaba sendo mais eficiente o provedor nativo).

Na figura abaixo é exposto a estrutura básica de um provedor:

Os objetos principais de um provedor são:

Connection: Gerencia a conexão com a fonte de dados.
Command: Executa comados na fonte de dados, podendo ser utilizado para recuperar um DataSet ou um DataReader.
DataReader: Lê as informações (item a item) de uma consulta na fonte de dados.
DataAdapter: Utilizado para preencher um DataSet após uma consulta. Como já dito anteriormente, ele também tem a capacidade de replicar a atualização dos dados (após as manipulações necessárias) na fonte de dados.

Observe que o DataSet não está citado acima, pois ele é o mesmo objeto para qualquer provedor. Como? Ele só mantem em memória os dados fornecidos pelo DataAdapter, desconhecendo assim o banco de dados, e deixando essa responsabilidade a cargo do DataAdapter.

Vejamos alguns exemplos de conexão com banco de dados:

Importante observar três coisas na figura acima:

A primeira são os namespaces que foram incluídos. Um para cada provedor.

A segunda é a string de conexão. Esta é responsável por localizar o banco de dados e passar as credenciais de conexão. Para compreendermos melhor o conceito de string de conexão, imagine o seguinte: para você se conectar a um site, você tem de informar a URL do mesmo, talvez passar alguns parâmetros pela URL, e em algum momento se autenticar no site. A string de conexão faz isso! para saber mais sobre strings de conexão do ADO.NET acesse: http://www.connectionstrings.com/

A terceira é o fato do padrão de nomenclatura.

Vamos trabalhar com um exemplo simples, porém mais concreto. Após instalar o Visual Studio e SQL server em uma máquina, abra o Visual Studio e localize a window “Server Explorer”:

Esta window do Visual Studio gerencia as conexões as bases de dados que você informar. Vamos criar uma nova base de dados no SQL Server, clicando com o Botão direito em “Data Connections” > “Create new SQL Server Database”:

Configure a janela que aparecer com o nome da sua instância de SQL Server, e o nome da base que será criada.

Após criar a base vamos adicionar uma Tabela “Pessoa”. Clique com o botão direito na pasta “Table” > “Add New Table”.

Crie as colunas com os tipos da imagem abaixo. Na coluna “Codigo”, clique com o botão direito em Set Primary Key, para definir esta coluna como chave primária.

Para tornar a coluna código Auto-Incremento, selecione-a e na window de “Column Properties”, defina “Is Identity = Yes”, como na imagem abaixo:

Quando for salvar defina o nome “Pessoa”:

Vamos inserir algumas linhas nessa tabela, para isso, clique com o botão direito sobre a tabela e selecione “New Query”:

Em seguida digite alguns comandos de “insert” e clique no ponto de exclamação em vermelho, como indicado na figura:

Após inserir alguns dados, vamos criar uma aplicação de console que irá se conectar na base de dados. Neste primeiro exemplo, iremos listar os dados usando o objeto DataReader, observe:

Explicando:

Na linha 16 é definida a variável que representa a string de conexão com o SQL Server, ou seja, qual o caminho para eu conectar na base de dados, com suas devidas configurações e parâmetros de autenticação. Basicamente ela é composta de servidor (podendo ser um IP, assim, poderíamos ter o SQL server em outra máquina que não a de desenvolvimento) com instância do SQL Server, a base de dados inicial e o tipo de autenticação.

Na linha 14 é criado o objeto de conexão com SQL Server passando a string de conexão no construtor. Perceba o uso da palavra reservada “using”. Ela faz o descarte automático do objeto de conexão quando o bloco que ela define for totalmente executado. Isso significa que ela desconecta da base de dados e retira todas as informações desnecessárias da memória, pois abrir e manter uma conexão com uma base de dados é muito custoso. E fica a dica: É possível utilizar o “using” em qualquer objeto que implementa a interface IDisposable, ou seja, todo objeto que pode ser descartado da memória.

Chegou a hora de eu passar o comando SQL criado, para isso utilizamos a classe SqlCommand, passando a string com a instrução SQL, e o objeto de conexão, na linha 18.

Agora que esta tudo pronto para executar o comando, vamos abrir a conexão com o método “Open()”, na linha 20, e resgatar o DataReader (linha 22).

E, enquanto for possível ler linhas que a instrução retornou (linha 24), imprimimos isto na tela, obtendo os dados pelo tipo e índice da coluna (linha 26). Fica registrado que há várias formas de obter a coluna de um DataReader, fique à vontade para explorá-los.

Sendo assim, eis nosso resultado:

Agora um exemplo utilizando DataSet:

Antes de mais nada a classe DataSet fica no namespace “System.Data”, como na linha 3 indicada na figura acima.

Agora, na linha 19, aparece o DataAdapter recebendo a instrução SQL e a conexão. Ele é que será responsável em recuperar as informações e preencher o DataSet.

Na linha 21 é criado o DataSet, abaixo é aberta a conexão e o DataAdapter preenche o DataSet (linha 24).

Para listar os dados no console, foi feito um “foreach”, obtendo um DataRow (objeto do DataSet que representa uma linha). Percebam que o DataSet tem a capacidade de gerenciar várias tabelas em memória, então, como só temos uma tabela mapeada, pegamos as linhas (Rows) da tabela de índice “0”.

Recuperada a linha, para selecionar a coluna, da linha, é só passar o nome, por string entre colchetes, para o objeto que representa a linha (“item”).

O resultado é o mesmo.

Podemos disponibilizar estes dados facilmente na web. Para tal vamos adicionar uma ASP.NET Web Application na solução:

Agora, na pagina Default.aspx vamos adicionar um controle que esta apto para receber uma coleção de registros, proveniente da base de dados. Para tal, escolhi a GridView.

Basicamente, uma vez que fornecermos uma fonte de dados (coleção de registros) para a GridView, ela irá renderizar uma tabela HTML com as informações. Para forneceremos as informações, vamos para o code behind da página Default.aspx, e no evento Page_Load podemos conectar no banco de dados, resgatar os registros com um select, e de alguma forma fornecer esta coleção para a GridView.

Com o DataSet é mais fácil, apenas atribuímos ele na propriedade DataSouce da GridView, e realizar um DataBind(), método responsável por renderizar a informação vinculada.

Alguns detalhes importantes, para acessar o code behind, abra o arquivo Default.aspx.cs:

Temos de tornar esta aplicação a principal, pois o console não nos interessa mais, para isso clique com o botão direito no projeto web > “Set as StartUp Project”:

Após estes detalhes, resta a codificação. Vejamos o exemplo da codificação e seu resultado:

Podemos trabalhar também com o DataReader, porém temos de criar uma lista de objetos. O papel da lista será armazenar os registros em memória e atribuí-la no DataSource da GridView.

Vamos adicionar uma classe “Pessoa” que modelará os objetos da lista,

Agora entramos em um conceito interessante: A interação de um sistema, baseado em linguagem Orientada a Objetos, com uma base de dados relacional.

Já temos nossa classe, resta criar uma lista e os objetos para cada linha recuperada do banco de dados, e adicioná-los em uma Lista tipada (List<>). Vejamos:

Visualmente, o resultado é o mesmo, mas lembrando que performaticamente o DataReader é mais ágil.

Não foi muito diferente do exemplo no console, a diferença é que não utilizamos o Console.WriteLine().

Para concluir, vamos voltar na aplicação console, pois agora é hora de explicar como efetuar um comando na base de dados, ganhando assim o poder de inserir, atualizar e apagar registros da base.

Para qualquer que seja o comando que deverá ser executado na base de dados (insert, delete, update), devemos utilizar um objeto SqlCommand e o seu método “ExecuteNonQuery()”, que retornará o número de linhas afetadas pelo comando.

Acompanhe o exemplo abaixo:

Uma instrução de insert esta definida na linha 17. Perceba que ela não recebe diretamente os valores que serão inseridos no banco de dados, pois ela esta recebendo parâmetros. Estes são importantes para evitarmos problema de SQL Injection (injeção de comandos indesejados na string do comando). Então nas linhas 21 e 22 são adicionados parâmetros ao comando, provenientes da classe SqlParameter, passando, no construtor, o nome do parâmetro (com “@”, uma característica do SQL Server, podendo variar a maneira de passar parâmetro, dependendo do Provedor de Dados), e seu valor. O valor é tratado pelo parâmetro, assim evitando dados truncados (no caso de uma Data e Hora) e injeção indevida de SQL (SQL Injection).

Finalmente, na linha 25 executamos o “ExecuteNonQuery()”, inserindo assim mais um registro no SQL Server.

Lembrando que o “ExecuteNonQuery()” da suporte para os comandos de delete e update também.

Para comprovar, podemos voltar no exemplo web, que está com o select, e executar a aplicação.

Percebam que o registro inserido, no exemplo acima, esta na linha de Codigo 4.

Espero que tenham gostado, pois o objetivo aqui, foi dar um overview do ADO.NET, focando na conectividade nativa e primitiva do mesmo.

Para quem quiser se aprofundar no assunto, o ADO.NET suporta uma série de frameworks que ajudam a abstrair a camada de dados, e facilitar a interação com o mundo das linguagens Orientadas a Objeto, como o Entity Framework, LINQ to SQL, NHibernate etc… Inclusive DataSets Tipados.

E fica a dica: pense como disponibilizar registros e conectividade com o banco de dados após explorar este artigo de arquitetura, seja de forma primitiva, ou explorando uma solução/framework mais robusto. Se achar que de primeira está difícil, tente criar funções ou classes com métodos que generalizam e o ajudariam com a base de dado.

E este foi um grande overview sobre a base do ADO.NET… Abraços, até mais

Um pouco de Arquitetura de Software

2010-09-27T08:00:00.000-03:00

Muitas pessoas se perguntam o que é, ou se de fato existe a “Arquitetura de Software”. Para ajudar a compreender, é importante analisarmos alguns players na concepção de um software, bem como seus papéis:

Programador: Bem, este dispensa apresentações, é o criador de códigos, componentes, artefatos do software. Compreende e domina as linguagens de programação, frameworks, etc. Altamente técnico.
Testador: Profissional responsável pelas rotinas de testes do software. Os testes, para os softwares modernos, são fundamentais. Estes profissionais tem de compreender um pouco de programação em algumas circunstancias, para escreverem programas que testam programas, macros e até mesmo códigos que testam códigos.

Até aqui é interessante observar uma perspectiva natural do mundo do Software: estes profissionais são muito técnicos e “estão em um mundo diferente” dos usuários do software. Pode parecer exagero meu. Mas ao pé da letra é assim! O que acontece é que em muitos casos, no desenvolvimento de um software, nós acabamos assumindo mais de um papel, e algum deles contém um contato maior com o usuário do software. E, tanto é verdade o que eu digo, que eu quero que tentem responder uma pergunta: vocês conhecem algum programador que fez parte da codificação do Windows? E do GMail?

Continuando…

Engenheiro de Software: Esse profissional é responsável em mapear o material coletado com o usuário (e pode não ser ele quem coleta o material) e transformar em documentação (técnica) para os desenvolvedores e testadores.
Analista (de sistemas ou até mesmo de negócios): É um típico coletor de informações das necessidades do usuário com relação ao software.
Arquiteto de Software: Profissional responsável por pegar as informações levantadas, requisitos do sistema e montar uma solução de software. Ele vai decidir como o software será concebido. Isso envolve linguagens, protocolos, requisitos de hardware e comunicação entre as partes do software. Ele tem a visão macro da coisa.

Vamos analisar um exemplo pratico: o Twitter.

Eu considero que o Twitter é um caso de sucesso em sua arquitetura. Isso porque ele é um sistema relativamente novo, e podemos usar o front-end que desejarmos (inclusive desenvolver um próprio) para ele. A arquitetura do Twitter é baseada em um core que se tornou uma API altamente difundida. Com isso vemos que o site oficial, o site mobile, apps Java para celular, apps desktop ,dentre outras, simplesmente consomem suas APIs. Se desejarmos desenvolver uma aplicação para o Twitter é só entrar no site deles e ler a documentação da API.

Toda essa flexibilidade do Twitter só foi possível graças a sua concepção arquitetural.

Agora me responda, seu software, é possível eu plugá-lo na web? E no celular?

Deixa eu adivinhar, não é possível pois toda a regra de negócios está no “click” do botão salvar (com mais de 500 linhas, e alguns SQLs) do seu app desenvolvido em Delphi 7.

Este é um dos benefícios expostos por um bom estudo de arquitetura de software. Já ouviram falar em Entity Framework? JPA? Hibernate?

Agora me respondam, tentaram usar algum por que eles são orientados a objetos? Estão na moda? São fáceis? Não é preciso se preocupar com SQL?

Pois bem, na verdade a premissa principal de frameworks como esses é: Abstração de banco de dados, ou seja, não é preciso se preocupar se a base de dados será Oracle, SQL Server, MySQL etc.

Agora juntem as possibilidades: múltiplas interfaces, múltiplos bancos, e, com uma boa arquitetura, é fácil fazer módulos, plug-ins… enfim, tornar a aplicação bem extensível e plugável.

O arquiteto de software tem de ser capaz de planejar, documentar e decidir quais tecnologias estarão envolvidas na concepção do software (isso inclui linguagem de programação e framework), e até mesmo a infra-estrutura necessária para abrigar e processar o software.

Isso só representa benefícios ao software: o torna modular, testável, expansível. Ajuda a compreender seu funcionamento juntamente com a infra-estrutura e tecnologias envolvidas.

Importante observar que o arquiteto de software não tem uma visão detalhista de software, pois não é do interesse dele saber como que o analista ou engenheiro definiram o cálculo de juros para o programador. Ele tem uma visão de cima, macro, de como o software passa as informações processadas de um lado para o outro. Por isso ele também é um dos primeiros na concepção do software (lembrando que concepção é diferente de planejamento). Ou seja, após feita a análise e levantado os requisitos, o arquiteto vai gerar um projeto (ou solução) de software que irá abrigar o software. Ele vai definir camadas, por exemplo: Camada visual, Camada de Banco de dados, Repositórios; e como elas devem se comunicar, e o que é preciso para elas funcionarem; Depois disso ele repassa essa carcaça/esqueleto montado para os desenvolvedores codificarem.

Vamos ver isso um pouco na prática: Vamos fazer uma calculadora com as quatro operações básicas. Porém ela deve rodar na Web, Desktop e Console. Este projeto será concebido no Visual Studio.

Para isso nós teremos o seguinte gráfico de camadas e dependências:

Crie no Visual Studio a seguinte solução com os seguintes projetos:

CalculadoraBase (Class Library)
ConsoleCalculadora (Console)
WindowsCalculadora (Windows Forms)
WebCalculadora (Web Application)

Segundo o diagrama de dependência, os projetos de interface (web, windows e console) devem referenciar o projeto CalculadoraBase, para isso dê um “Add Reference” nos projetos:

No projeto CalculadoraBase, vamos adicionar e implementar a classe Calculadora:

Feito isso, podemos instanciá-la nos outros projetos e consumir suas regras, veja:

Pronto! temos aí uma prova de conceito. Centralizamos a regra em um projeto e distribuímos as funcionalidades (já prontas) em três frentes!

Agora imagine que você pode fazer isso com sua aplicação… Comercial por exemplo. Vamos pensar: Uma aplicação comercial Orientada a Objetos, tem que ter objetos mapeados da base de dados. Além disso, ela tem as regras de negócio, o próprio banco de dados, e uma interface. Nessa linha de raciocínio, teríamos:

Com esse modelo, caso fosse desejado/necessário plugar uma outra interface gráfica, bastaria referenciar a regra de negócios e o mapeamento do banco de dados. E outras possibilidades também podem ser viabilizadas. Além do que este é um modelo básico. A arquitetura pode ir muito além disso, como por exemplo rodar webservices em servidores externos com pré-requisitos de SO e Hardware. Enfim, não há receita de bolo, o arquiteto tem de planejar (para não dizer arquitetar).

O arquiteto deve se preocupar com baixo acoplamento, se o desenvolvimento e a manutenção dos elementos também é facilitado, possibilitar o desenvolvimento independente, mudanças terem menor impacto.

Vejamos mais alguns pontos/ideias da Arquitetura de Software:

Relacionamento com softwares externos
Comunicação entre os envolvidos no software
Reuso
Confiabilidade
Segurança
Escalonamento
Usabilidade
Visão funcional/lógico.
Visão organizacional de código
Design Patterns
Estrutura do software
Melhor controle de concorrência/processo/thread
Visão de protocolos
Sincronização
Geração de componentes de software, e até mesmo uso de componentes, adequados ao contexto, de terceiros.

O arquiteto deve responder perguntas como:

A solução é Web ou Windows?
Qual linguagem usar?
Qual impacto na atualização de uma tecnologia utilizada no software?
Qual SO?
E o servidor?
Como o software deve ser atualizado?
E a segurança?
Como vai ocorrer a autenticação?
Como vai ocorrer sincronizações?
Quais os protocolos envolvidos?
Quais os designs patterns envolvidos?

Concluindo, um bom planejamento arquitetural de seu software é fundamental no mundo contemporâneo de software. Isso ajuda a modularizar, testar, manter e estender seu software. Além do que, fazer software vai além da escolha de algoritmos e estrutura de dados. Pois essa questão envolverá também decisões sobre as estruturas que formarão o sistema, a estrutura global de controle será usada, protocolos de comunicação, sincronização e acesso a dados, atribuição de funcionalidade a elementos do sistema, ou ainda sobre distribuição física dos elementos do sistema.

E finalmente, isso foi meio que uma visão geral de arquitetura, não disse tudo, a intensão nem é esta. apenas exemplifiquei algumas coisas, mas este é um universo bem maior.

Espero que tenham gostado

Linq to SQL com Transaction

2010-09-23T09:56:00.001-03:00

Para quem não se lembra, quando estamos trabalhando com banco de dados, há casos em que temos que realizar uma série de manipulações de dados (inserts, updates, deletes etc). Mas e se algo der errado no meio do caminho? Teríamos como “desfazer” as operações realizadas anteriormente?

…Tendo em mente que um conjunto de operações em um banco de dados só fará sentido se todas as instruções forem executadas com sucesso.

Imagine o caso da matricula de um aluno: temos de gravar o aluno no banco de dados, gerar parcelas, grade de aulas. E se na hora de gerara as parcelas ocorrer algum problema? Vou deixar o aluno cadastrado sem parcelas? Nesse caso seria interessante “voltar no tempo”, desfazer o cadastro do aluno para que o usuário tentasse novamente.

Não é preciso fazer isso na mão. Os bancos de dados tem o recurso de transação. Quando abrimos uma transação, todos os dados manipulados só são efetivados no banco de dados após a confirmação de que tudo está ok. Para isso damos o nome de “commit”.

Caso algo de errado dentro de uma transação nós temos a opção de “desfazer tudo” automaticamente. Para isso damos o nome de “rollback”.

Mas isso é noção básica de banco de dados, caso se interessem mais é interessante estudar esse assunto. Ele é de extrema importância no desenvolvimento de software com banco de dados, e resolve uma boa quantidade de problemas de forma simples.

No Linq to SQL, apesar de “não ocorrer uma interação direta” com os objetos nativos de interação com o banco de dados, é possível realizar transactions normalmente, acompanhe o código a seguir:

dc.Connection.Open();

using (DbTransaction transaction = dc.Connection.BeginTransaction(IsolationLevel.ReadCommitted))
{
    dc.Transaction = transaction;
    try
    {
        // do database things
        dc.SubmitChanges();
        transaction.Commit();
    }
    catch (Exception ex)
    {
        transaction.Rollback();
        Console.WriteLine("Exception caught; transaction rolled back.");
        Console.WriteLine(ex.ToString());
    }
}

É importante lembrar que o try catch é um aliado imenso nesse tipo de situação.

Espero ter ajudado, até mais

Árvores pt II: Teoria, Introdução, Binárias e AVL.

2010-09-21T13:43:00.001-03:00

No post passado sobre árvores, foram explanados os conceitos que cercam uma árvore computacional, principalmente as árvores binárias e AVL.

Neste post pretendo explicar o código de uma árvore binária de elementos inteiros, e principalmente as maneiras de listar os elementos de uma árvore (pré-ordem, in-ordem, pós-ordem).

Vamos ao código:

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>

struct Item
{
    int numero;
    Item *esquerda;
    Item *direita;
};

bool Inserir(Item **itemAtual, int valor)
{
    Item *novo;

    // -> Aloca memória para o novo item
    novo = (Item *)malloc(sizeof(Item));

    // -> Checa se foi alocado memória corretamente.
    if (novo != NULL)
    {
        // -> Define e inicializa os valores.
        novo->numero = valor;
        novo->esquerda = NULL;
        novo->direita = NULL;

        // -> Se o nó for nulo então o item alocado é colocado nele.
        if(*itemAtual == NULL)
        {
            *itemAtual = novo;
        }
        else
        {
            if(valor < (*itemAtual)->numero)
            {
                // -> valor menor que o atual vai para a esquerda.
                Inserir(&(*itemAtual)->esquerda, valor);
            }
            else
            {
                // -> valor maior que o atual vai para a direita.
                Inserir(&(*itemAtual)->direita, valor);
            }
        }
        return true;
    }
    else
    {
        return false;
    }
}

Item** Procurar(Item **itemAtual, int valor)
{
    if(*itemAtual == NULL)
    {
        return NULL;
    }
    else if((*itemAtual)->numero == valor)
    {
        return itemAtual;
    }
    else if(valor < (*itemAtual)->numero)
    {
        return Procurar(&(*itemAtual)->esquerda, valor);
    }
    else
    {
        return Procurar(&(*itemAtual)->direita, valor);
    }
}

bool Remover(Item **itemAtual, int valor)
{
    Item **itemProcurado = Procurar(itemAtual, valor);

    if(itemProcurado == NULL)
    {
        printf("\nItem não encontrado!\n");
        return false;
    }

    Item *temp = *itemProcurado;

    if((*itemProcurado)->direita == NULL)
    {
        // -> Não tem filho a direita.
        (*itemProcurado) = (*itemProcurado)->esquerda;
    }
    else if((*itemProcurado)->esquerda == NULL)
    {
        // -> Não tem filho a esquerda.
        (*itemProcurado) = (*itemProcurado)->direita;
    }
    else
    {
        // -> Tem os dois filhos.
        Item *anterior = NULL;
        temp = (*itemProcurado)->esquerda;

        while (temp->direita != NULL)
        {
            anterior = temp;
            temp = temp->direita;
        }

        (*itemProcurado)->numero = temp->numero;

        if(anterior == NULL)
        {
            (*itemProcurado)->esquerda = temp->esquerda;
        }
        else
        {
            (*itemProcurado)->direita = temp->esquerda;
        }
    }

    free(temp);
    return true;
}

void ListarPreOrdem(Item *itemAtual)
{
    if (itemAtual != NULL)
    {
        printf("%i; ", itemAtual->numero);
        ListarPreOrdem(itemAtual->esquerda);
        ListarPreOrdem(itemAtual->direita);
    }
}

void ListarInOrdem(Item *itemAtual)
{
    if (itemAtual != NULL)
    {
        ListarInOrdem(itemAtual->esquerda);
        printf("%i; ", itemAtual->numero);
        ListarInOrdem(itemAtual->direita);
    }
}

void ListarPosOrdem(Item *itemAtual)
{
    if (itemAtual != NULL)
    {
        ListarPosOrdem(itemAtual->esquerda);
        ListarPosOrdem(itemAtual->direita);
        printf("%i; ", itemAtual->numero);
    }
}

void Listar(Item *itemAtual)
{
    printf( "Listando... \n\n");
    ListarPreOrdem(itemAtual);
    printf("\n\n");
}

void Menu()
{
    printf( "Digite a sua escolha: \n"
        "    1 para inserir um elemento na arvore \n"
        "    2 para remover um elemento da arvore \n"
        "    3 para finalizar \n"
        "? ");
}

void main()
{
    Item *raiz = NULL;
    int opcao;
    int numero;

    Menu();
    scanf("%i", &opcao);

    while (opcao != 3)
    {

        switch (opcao)
        {
            case 1:
                printf( "Digite um numero: ");
                scanf("\n%i", &numero);

                Inserir(&raiz, numero);

                Listar(raiz);

                break;
            case 2:
                printf( " Digite o numero a ser removido: ");
                scanf( "\n%i", &numero);
                Remover(&raiz, numero);
                Listar(raiz);

                break;

            default:
                printf( "Escolha invalida.\n\n");
                Menu();
                break;
        }

        scanf("%i", &opcao);
    }
    printf("Fim do programa.\n");
}

Resultado:

Começando pela struct Item: Ela contém o elemento inteiro que será armazenado, e um ponteiro “para a esquerda” e outro “para a direita”. Lembrando que, conceitualmente, uma árvore binária tem os elementos menores (que o elemento atual) armazenados a esquerda do elemento atual, e os maiores que o elemento atual à direita (do elemento atual).

Inserir: Basicamente temos de seguir a regra para saber se o elemento que esta sendo inserido é maior ou menor que o atual. O atual começa pela raiz da árvore e se estende pelos filhos, até que se encontre um nó nulo. Imagine que temos uma árvore que só tem um elemento, o número 5. Esse elemento será a raiz, e ao inserirmos um número 3, por ele ser menor, terá de ser inserido no ponteiro da “esquerda”. ao inserirmos o elemento 4, ele irá verificar a raiz, sendo menor que ela, o número 4 terá de ir para a “esquerda” e encontrará o elemento 3. 4 é maior que o 3 ele e terá que ficar no ponteiro da “direita” de 3! Para isso é alocado um novo elemento, e é verificado se o item atual é nulo. Se for, ele é referenciado. Se não é verificado com o número do Item atual se o item atual terá de ser o que está a esquerda ou a direita do nó.

Procurar: Faz um processo similar ao do Inserir. Se o elemento atual for nulo, quer dizer que o elemento procurado não foi encontrado! Se o número for igual ao procurado então a referencia para o Item é retornada. Se o elemento for maior do que o atual, devemos ir para a direita, caso contrário: esquerda neles! Usaremos para encontrar o nó que será removido.

Remover: Essa função é um pouco crítica, pois ao removermos um nó, temos que manter seus filhos vinculados na árvore. Após encontrar o elemento que será removido, verificamos se há filhos maiores (à direita). Se o elemento removido não tiver filhos à direita, o nó da esquerda é vinculado ao ponteiro de seu pai. O processo inverso, com a esquerda, também é feito caso tenha filhos à direita. Se o elemento tiver filho à esquerda e à direita, então é localizado o maior elemento (à direita) para substituí-lo. A última linha da função libera a memória do nó removido.

As listagens eu vou explicar com imagens:

Nas listagens, basicamente o que se muda é onde imprimimos o elemento. Lembrando que as funções são recursivas.

Só para fixar melhor o conceito das “ordens”, para somarmos o número 2 no número 3, teríamos a seguinte notação:

Pré-Ordem: + 2 2
In-Ordem: 2 + 2
Pós-Ordem: 2 2 +

Agora vamos à parte divertida da coisa, exercícios:

Fazer uma árvore para armazenar alunos (Nome, RA e Ano de Nascimento). O Índice da árvore deve ser baseado no ano do nascimento do aluno. Na listagem o usuário deve escolher qual ordem listar!

Boa sorte, e continuarei falando mais sobre árvores em outro post!

#CommunityZone: Eu Fui!

2010-09-21T10:58:00.001-03:00

Um grande evento que propicia as pessoas mais influentes nas plataformas Microsoft se conhecerem e se divertirem, bem como conhecer mais as comunidades, se aproximar delas e planejar o futuro do conhecimento e tecnologia!

Este é o Community Zone, que aconteceu dias 16 e 17 de Setembro, no Hotel Rancho Silvestre.

O lugar onde foi realizado o evento é show e as pessoas são gente fina! Quando chegamos na quinta-feira (dia 16) tivemos a oportunidade de descansar, após a correria do TechEd, e nos divertir, com churrasco, piscina, ping-pong, sinuca, boliche, Rock Bando no Xbox, amigos… enfim, só alegria.

Além disso, tive a oportunidade de novamente interagir com velhos amigos, e criar novas amizades com as pessoas mais influentes e inteligentes da comunidade.

Parabéns pela Microsoft, pela iniciativa, e pelos que foram pro proporcionar mais conhecimento, interação diversão e excelentes papos .

Esse foi um verdadeiro upgrade no meu networking, e aguardo o e-mail de vocês com nome e twitter para eu divulgar aqui em!

Foi minha primeira vez em um evento deste e espero ir muitas vezes mais.

Além disso tive a oportunidade de interagir em inglês com os gringos lá presentes.

Fiquem com as fotos:

Community Zone 2010

EXIBIR APRESENTAÇÃO DE SLIDES

BAIXAR TUDO

#TechEdBR: Eu Fui!

2010-09-21T10:12:00.001-03:00

Bem, minha vez de contar como foi este fascinante evento.Vou diferenciar um pouco meu post, trazendo mais para o lado da aventura pessoal que ele representou. Foi realmente o evento dos feras! Apesar de prós e contras, foi meu primeiro evento deste porte e fiquei maravilhado em ir em um dos maiores eventos de tecnologia do país!

obs: no final do post esta uma compilação de fotos que juntei do TechEd.

Gostaria de adiantar o quanto é importante um evento desse, não só pelas suas trilhas técnicas, mas também pelo networking, possibilidade de novas amizades e contatos com pessoas excepcionais, além de um contato direto e humano com MVPs, Evangelistas e outros profissionais tão brilhantes quanto, e re-encontrar velhos amigo é claro.

Foi legal conhecer pessoalmente pessoas que mantenho contato no mundo virtual, pelas redes sociais, blogs e twitters da vida. Parabéns a todos!

Viagem TechEd - CommunityZone 2010

EXIBIR APRESENTAÇÃO DE SLIDES

BAIXAR TUDO

A começar pela viagem, cheguei em São Paulo no domingo (dia 14) pela manhã, após viajar com o pessoal da @wrati. Após tomar um maravilhoso café, na casa da tia do @wagner_kondo, e almoçar no shopping. Fomos para um hotel, o qual não nos agradou… bem o que esperar de um hotel que a porta do banheiro sai na sua mão?

No dia seguinte estava lá eu, com mala, mochila e tudo mais, no Expo Center Norte, uma estrutura imensa abrigando o excepcional TechEd. Tínhamos um regado café da manhã a disposição e dei inicio ao networking... e a comilança.

Pouco depois das 9h da manhã, começou a general session, a abertura do evento, bem divertida por sinal. Particularmente gostei do Remote FX (Tecnologia de Remote Desktop com interação Rica de multimídia), que o pessoal jogou Guitar Hero remotamente sem delay!

E nos finalmentes o tão esperado Kinect:

O que me surpreendeu foi o Kinect funcionar perfeitamente no palco, mesmo com toda a poluição visual e térmica que o ambiente gerava!

Outro ponto importante e impressionante da general session, que foi reforçado em uma palestra que presenciei, foi o Windows Phone 7… e eu preciso disso!

Depois disso, fui almoçar rapidão, e ir para a maratona de palestras. O almoço estava muito bom, era servido no local, e estava incluso no passaporte para o evento, com direito a sobremesa .

Enfim, toda a estrutura do evento é sensacional! A wireless oferecida de vez em quando tinha oscilações, e a Internet do meu celular pifou logo no inicio do evento, o que prejudicou minha cobertura sobre o mesmo.

Nas palestras, mais um show de organização, slides, telão e som impecáveis. Agenda impressa no crachá, e TVs informando quais eram as palestras dos auditórios.

Depois vou fazer um post, trilhando minha opinião sobre as palestras que presenciei.

Um ponto quente do evento foi a noite de terça (dia 14) no Ask The Experts, onde dei uma apertada nos MVPs e Evangelistas com minhas dúvidas .

Uma sugestão minha: os organizadores e patrocinadores não tem obrigação nenhuma de fornecer brindes, mas estes mimos só me fazem mais feliz e falar melhor ainda do evento. Achei fraco os agrados pelo tamanho do evento.

De momento quero agradecer a WRA gestão em TI e ao seu diretor Mauricio Real Prado que viabilizaram para que eu ficasse uma semana em São Paulo para o Tech Ed e Community Zone.

Gostaria de agradecer também à Microsoft Brasil que viabilizou minha estadia no TechEd e CommunityZone. Bem como o pessoal da produção do evento, por mais este TechEd.

Finalmente, obrigado a todos os profissionais que tive a oportunidade de conhecer e interagir. Gostaria que me mandassem um e-mail com nome e twitter para eu publicar aqui no blog essa fantástica networking e agradecê-los. (o e-mail está no menu do blog ou clicando aqui)

Fiquem com as fotos, obrigado… fui!

TechEd 2010

EXIBIR APRESENTAÇÃO DE SLIDES

BAIXAR TUDO

Árvores pt I: Teoria, Introdução, Binárias e AVL.

2010-08-31T19:13:00.001-03:00

Árvores são estruturas de dados que nos proporcionam controles otimizados sobre uma coleção de dados. Podemos usá-la para prover uma pesquisa mais rápida de um determinado elemento, bem como apresentações diferenciadas dos dados (listagens em pré-ordem, in-ordem e pós-ordem). Depois analisaremos isto com mais detalhes.

As árvores proporcionam vantagens tanto na listagem, e em alguns casos na remoção e inserção de elementos também(quando a mesma não for balanceada a cada operação).

Então, ela nada mais é do que um conjunto de elementos denominados vértices. Na verdade há muito o que conhecer sobre seus elementos e estrutura, e é isto que eu pretendo explicar neste post.

Mas antes vejamos algumas aplicações da mesma:

Banco de Dados
Inteligência Artificial
Avaliação de expressões Lógicas e/ou Matemáticas

Seus elementos:

Raiz: Elemento mais ao alto, o primeiro elemento de referência da árvore.
Nó ou Vértice: o elemento da árvore.
Folha: últimos elementos, os mais profundos, e que não tem filhos.
Aresta: Conector dos elementos, indicando sua relação.
Pai: Elemento que contém vértices conectados a ele em profundidade mais elevada.
Filho: Elemento que contém um vértice superior vinculado a ele.

Sua estrutura:

Sub-árvore: Um pedaço de uma árvore analisado separadamente.
Floresta: Conjunto de árvores e/ou sub-árvores.
Altura: Quantidade de nós máxima ao seguir por um caminho (se nos referirmos a altura de uma árvore, então considerasse o maior caminho da mesma).
Profundidade: Quantidades de arestas até um determinado nó (se nos referirmos a uma árvore, então considerasse o maior caminho da mesma).
Grau: quantidade de filhos de uma vértice.

Árvore Binária: É caracterizada por vértices que podem ter no máximo dois filhos. Por padrão, se o filho for menor do que o pai ele deve ser alocado à esquerda. Se o filho for maior que o pai, então é alocado a direita. Com isso ganhamos agilidade ao procurar e inserir um elemento, pois temos um caminho mais otimizado para percorrer!

Árvore AVL: É uma árvore binária, porém balanceada, ou seja, tentando fazer com que o caminho até suas folhas sejam menores possíveis e de alturas e profundidades parecidas.

Ambas as árvores (Binária e AVL) tratarei mais detalhadamente em outro post.

Por hora, fica o resumo da ópera em slides:

Árvores por Eduardo Spaki

Ficam alguns exercícios conceituais:

Dada a figura ao acima:

Qual a altura da árvore?
Qual o filho à esquerda do nó “b” ?
Qual o filho à direita do nó “a”?
Qual a profundidade do nó “i”?
Quem são as folhas?
Quem nós são pais de que nós?
Qual é o grau de cada nó?
Qual é a altura da árvore?
Admita que o vértice “e” é a raiz, e redesenhe a árvore com a raiz em cima.
Admita que o vértice “f” é a raiz, e redesenhe a árvore com a raiz em cima.
Esta árvore é binária?

Espero que tenham gostado :)

BubbleSort com Strings no C/C++

2010-08-24T19:58:00.001-03:00

Esta aqui o algoritmo base para o exercício proposto no post sobre BubbleSort.

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <string.h>

const int TAMANHO = 5;
const int TAMANHO_NOME = 50;

void BubbleSort(char vetor[TAMANHO][TAMANHO_NOME])
{
    for (int i = TAMANHO - 1; i > 0; i--)
    {
        for (int j = 0; j < i; j++)
        {
            if (strcmp(vetor[j], vetor[j + 1]) == 1)
            {
                char aArray[TAMANHO];

                strcpy(aArray, vetor[j]);
                printf("\n\n%i", *aArray);
                getch();
                strcpy(vetor[j], vetor[j + 1]);
                strcpy(vetor[j + 1], aArray);
                free(aArray);
            }
        }
    }
}

void Listar(char vetor[TAMANHO][TAMANHO_NOME])
{
    for (int i = 0; i < TAMANHO; i++)
    {
        printf("%d - %s\n", i + 1, vetor[i]);
    }
}

void main()
{
    char vetor[TAMANHO][TAMANHO_NOME];

    strcpy(vetor[0], "RUDSON");
    strcpy(vetor[1], "GUSTAVO");
    strcpy(vetor[2], "ERIK");
    strcpy(vetor[3], "ALAN");
    strcpy(vetor[4], "ZIDANE");

    Listar(vetor);
    printf("__________________\n");
    BubbleSort(vetor);
    Listar(vetor);
    getch();

}

A base das strings é que na linguagem C elas são vetores de char, e vetores devem ser manipulados por funções, pois alguns operadores não se aplicam a eles.

Então a sacada aqui é utilizar as funções:

stcmp (string compare): compara strings, retornando -1 para o primeiro parâmetro menor do que o segundo, 0 para strings iguais, 1 para o primeiro parâmetro maior do que o segundo.
strcpy (string copy): copia o conteúdo do segundo parâmetro para o primeiro parâmetro.

Espero ser de ajuda para os outros algoritmos também.

E só para complementar e fixar:

Implemente o mesmo algoritmo com strings, porém ordenando de forma decrescente.

Quick Sort – Faz da ordenação uma alegria :)

2010-08-23T23:16:00.001-03:00

e
(Quik, faz do leite uma alegria!)

É fazendo esse trocadilho com o produto da foto acima, antigo, que começo explicando o Quick Sort, pois o mesmo foi concebido aproximadamente em 1962, quando Charles Antony Richard Hoare visitou a Universidade de Moscovo. Naquela época, Hoare trabalhou em um projeto de tradução de máquina para o National Physical Laboratory. Ele criou o Quicksort ao tentar traduzir um dicionário de inglês para russo, ordenando as palavras, tendo como objetivo reduzir o problema original em subproblemas que possam ser resolvidos mais fácil e rapidamente.

O QuickSort, como o MergeSort, é baseado em uma estratégia de dividir para conquistar e é um dos algoritmos de ordenação mais populares. Veja na figura abaixo um pouco de seu funcionamento.

O método baseia-se na divisão da tabela em duas sub-tabelas, dependendo do pivô, normalmente o 1º elemento da tabela. Uma das sub-tabelas contém os elementos menores que o pivô enquanto a outra contém os maiores. O pivô é colocado entre ambas, ficando na posição correta. As duas sub-tabelas são ordenadas de forma idêntica, até que se chegue à tabela com um só elemento.

Seus passos são:

Escolha um elemento da lista, denominado pivô;
Rearranje a lista de forma que todos os elementos anteriores ao pivô sejam menores que ele, e todos os elementos posteriores ao pivô sejam maiores que ele. Ao fim do processo o pivô estará em sua posição final e haverá duas sub-listas não ordenadas. Essa operação é denominada partição;
Recursivamente ordene a sub-lista dos elementos menores e a sub-lista dos elementos maiores;

Apesar de ser um dos métodos mais rápidos de ordenação, suas partições, às vezes, poderem conduzir a uma ordenação lenta., então cuidado com vetores pequenos e ordenados de forma inversa. É interessante notar o uso do conceito de recursividade.

Reparem no vídeo a seguir como os pivôs delimitam as partições:

QuickSort

Recomendo também, estudarem através do já citado aqui MDA.

Agora vamos a uma breve implementação:

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <time.h>

const int tamanho = 5;

void Trocar(int *a, int *b)
{
    int temp;
    temp = *a;
    *a = *b;
    *b = temp;
}

int Repartir(int vetor[], int inicio, int fim)
{
    int k = inicio;

    for (int i = inicio + 1; i <= fim; i++)
    {
        if (vetor[i] < vetor[inicio])
        {
            k++;
            Trocar(&vetor[k], &vetor[i]);
        }
    }

    Trocar(&vetor[inicio], &vetor[k]);

    return k;
}

void QuickSort(int vetor[], int inicio, int fim)
{
    if (fim > inicio)
    {
        int parte = Repartir(vetor, inicio, fim);
        QuickSort(vetor, inicio, parte - 1);
        QuickSort(vetor, parte + 1, fim);
    }
}

void Listar(int vetor[])
{
    for (int i = 0; i < tamanho; i++)
    {
        printf("%i\n", vetor[i]);
    }
}

void main()
{
    srand(time(NULL));

    int vetor[tamanho];

    /*for(int i = 0; i < tamanho; i++)
    {
        vetor[i] = rand() % 100;
    }*/

    vetor[0] = 3;
    vetor[1] = 2;
    vetor[2] = 7;
    vetor[3] = 1;
    vetor[4] = 4;

    printf("Vetor Gerado:\n");
    Listar(vetor);

    QuickSort(vetor, 0, tamanho - 1);
    printf("__________________\n");
    printf("Vetor Ordenado:\n");
    Listar(vetor);

    system("pause");
}

E para exercitar a mesma ideia dos exercícios anteriores:

Implemente um programa, utilizando a linguagem C, que leia 5 ou 11 alunos (composto por: RA, Nome, Ano de Nascimento). Após ler, o usuário irá escolher um tipo de relatório/listagem em tela, podendo ser ordenado por cada um dos atributos do aluno de forma crescente ou decrescente.

Bubble Sort

2010-08-16T23:15:00.001-03:00

Bubble Sort, ou ordenação da bolha, é um algoritmo de ordenação, baseado em trocas. É de fácil implementação e relativo desempenho satisfatório em pequenas coleções de dados. Porém pode gerar muitas computações em grandes coleções de dados, pois ele tem que analisar elemento por elemento, de forma exponencial, para verificar se é necessário realizar a troca.

Sua ideia consiste em analisar elemento a elemento de forma a colocar o extremo em seu lugar, e desconsiderá-lo na próxima varredura. Por exemplo, se a implementação tiver como base analisar pares de forma a descobrir o maior elemento, o maior elemento pode ser jogado para o fim da coleção, sendo desconsiderado na próxima iteração.

“A ideia é percorrer um vetor diversas vezes,e a cada passagem fazer flutuar, para o topo, o maior elemento da sequência. Essa movimentação lembra a forma como as bolhas em um tanque de água procuram seu próprio nível, e disso vem o nome do algoritmo.”

Veja no vídeo a seguir um pouco da ilustração de seu funcionamento:

O bubble sort tem os seguintes passos:

Compara elementos adjacentes. Se o primeiro é maior do que o segundo, troca eles.
Faz isto para cada par de elementos adjacentes, começando com os dois primeiros e terminando com os dois últimos. Neste ponto o último elemento deve ser o maior de todos.
Repete os passos para todos os elementos exceto para o último.
Continua repetindo, cada vez com um elemento a menso, até não existam mais pares para se comparar.

Uma breve implementação:

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <time.h>

const int tamanho = 10;

void BubbleSort(int vetor[])
{
    for (int i = tamanho - 1; i > 0; i--)
    {
        for (int j = 0; j < i; j++)
        {
            if (vetor[j] > vetor[j + 1])
            {
                int temp = vetor[j];
                vetor[j] = vetor[j+1];
                vetor[j+1] = temp;
            }
        }
    }
}

void Listar(int vetor[])
{
    for (int i = 0; i < tamanho; i++)
    {
        printf("%i\n", vetor[i]);
    }
}

void main()
{
    srand(time(NULL));

    int vetor[tamanho];

    for(int i = 0; i < tamanho; i++)
    {
        vetor[i] = rand();
    }

    printf("Vetor Gerado:\n");
    Listar(vetor);

    BubbleSort(vetor);
    printf("__________________\n");
    printf("Vetor Ordenado:\n");
    Listar(vetor);

    system("pause");
}

Percebam que é bem simples, sem recursividade, ponteiro ou qualquer outro artifício mais complexo. Bastam dois for. O mais abrangente limita as comparações, deixando de fora sempre o ultimo item ordenado, tendo em vista que ele foi o maior. O for de dentro compara os pares e faz a troca se necessário.

E vamos ao exercícios:

Implemente um programa, utilizando a linguagem C, que leia 5 ou 11 alunos (composto por: RA, Nome, Ano de Nascimento). Após ler, o usuário irá escolher um tipo de relatório/listagem em tela, podendo ser ordenado por cada um dos atributos do aluno de forma crescente ou decrescente.

Espero que tenham gostado

Merge Sort

2010-08-16T22:44:00.000-03:00

O Merge Sort é um algoritmo de ordenação, onde sua fundamentação esta na junção, ou melhor, na possibilidade de mesclar vetores.

Mas antes de mesclar vetores, temos de quebrar o vetor original no meio, e continuando a repartí-lo até chegarmos em vetores de uma única posição, isolando cada elemento. Uma vez com cada elemento isolado, temos de compará-los com o seu par e agrupá-los de forma ordenada em um vetor temporário. Então mesclamos os vetores, sempre comparando seus elementos, de forma que o novo vetor criado seja sempre ordenado.

Antes de destruir o vetor temporário ordenado (que deve ser criado usando alocação dinâmica de memória com o malloc(), e liberado com o free(), pois não sabemos quantos e quais os tamanhos dos vetores temporários que serão criados), devemos copiar os itens para o vetor original.

A vantagem deste método é que, ao criamos um vetor, garantimos que os elementos menores sempre sejam os últimos, gastando menos tempo na hora de mesclar dois vetores, gerando menos computação.

Acompanhe seu funcionamento no vídeo a seguir:

Este algoritmo recursivo que é classificado como “dividir para conquistar”. Para essa afirmação temos:

Dividir os dados em subseqüências pequenas.
Conquistar, ou seja, classifica as duas metades recursivamente.
Combinar as duas metades em um único conjunto ordenado.

Foi criado por Von Neumann em 1945.

O Legal nele é que exploramos a alocação de memória e a recursividade.

Veja um exemplo de sua implmentação:

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <time.h>

void Merge(int vetor[], int tamanho)
{
    // -> cria um novo vetor com tamanho compatível
    int* temp = (int*) malloc(tamanho * sizeof(int));

    int meio = tamanho / 2;
    int i = 0;
    int j = meio;
    int k = 0;

    // -> troca os itens entre as metades
    while (i < meio && j < tamanho)
    {
        if (vetor[i] < vetor[j])
        {
            temp[k] = vetor[i];
            ++i;
        }
        else
        {
            temp[k] = vetor[j];
            ++j;
        }
        ++k;
    }

    if (i == meio) // -> termina de copiar a segunda metade
    {
        while (j < tamanho)
        {
            temp[k] = vetor[j];
            ++j;
            ++k;
        }
    }
    else // -> termina de copiar o início
    {
        while (i < meio)
        {
            temp[k] = vetor[i];
            ++i;
            ++k;
        }
    }

    // -> copia os itens ordenados para o vetor original
    for (i = 0; i < tamanho; ++i)
    {
        vetor[i] = temp[i];
    }

    // -> Libera a mamórtia do vetor temporário
    free(temp);
}

void MergeSort(int vetor[], int tamanho)
{
    if (tamanho > 1)
    {
        int meio = tamanho / 2; // -> divide o vetor no meio
        MergeSort(vetor, meio); // -> passa a primeira metade
        MergeSort(vetor + meio, tamanho - meio); // -> passa a segunda metade
        Merge(vetor, tamanho); // -> ordena e mescla
    }
}

void Listar(int vetor[], int tamanho)
{
    for (int i = 0; i < tamanho; i++)
    {
        printf("%i\n", vetor[i]);
    }
}

void main()
{
    srand(time(NULL));

    const int TAMANHO_TOTAL = 11;
    int vetor[TAMANHO_TOTAL];

    for(int i = 0; i < TAMANHO_TOTAL; i++)
    {
        vetor[i] = rand();
    }

    printf("Vetor Gerado:\n");
    Listar(vetor, TAMANHO_TOTAL);

    MergeSort(vetor, TAMANHO_TOTAL);
    printf("__________________\n");
    printf("Vetor Ordenado:\n");
    Listar(vetor, TAMANHO_TOTAL);

    system("pause");
}

Bem, agora fica o exercício:

Implemente um programa, utilizando a linguagem C, que leia 5 ou 11 alunos (composto por: RA, Nome, Ano de Nascimento). Após ler, o usuário irá escolher um tipo de relatório/listagem em tela, podendo ser ordenado por cada um dos atributos do aluno de forma crescente ou decrescente.

Monitorando o Servidor com C#

2010-08-05T14:19:00.001-03:00

Um aluno me questionou se é possível fazer uma aplicação que monitore um servidor, através da resposta do mesmo a um ping.

Aceitei o desafio, e escrevi uma simples e didática aplicação que realiza este monitoramento, utilizando, de maneira simples, as classes de rede do .NET Framework.

1º temos de construir uma classe “Monitor”. ela conterá duas propriedades:

IP: Uma string com o IP do servidor que será monitorado, ex: 10.1.1.5.
Status: Um enumerador IPStatus, que contém todos os status do resultado de um ping, ex: Success, TimedOut, DestinationNetworkUnreachable, etc. Esta por sua vez é somente leitura, então só implementamos o “get” dela.

E finalmente um metodo “Monitorar()”, que executará o ping, com espera de no máximo 4s (4000 milisegundos), com intervalos de 1 segundo (1000 milisegundos) entre um disparo e outro. A execução desse método se da enquanto o retorno do pingo for igual a “Success”.

Acompanhe a classe implementada abaixo:

// –> Utilizar o namespace: System.Net.NetworkInformation;

public class Monitor
{
    string ip;

    public string IP
    {
        get { return ip; }
        set { ip = value; }
    }

    IPStatus status;

    public IPStatus Status
    {
        get { return status; }
    }

    public void Monitorar()
    {
        Ping ping = new Ping();
        PingReply resposta;

        do
        {
            resposta = ping.Send(ip, 4000);
            Console.WriteLine(string.Format("Ping: {0}; Tempo de Resposta: {1}; Status: {2};", resposta.Address, resposta.RoundtripTime, resposta.Status));
            Thread.Sleep(1000);
        } while (resposta.Status == IPStatus.Success);

        status = resposta.Status;
    }
}

Agora que já temos um monitor, vamos implementar uma classe responsável pelo envio de e-mail. Esse e-mail será enviado quando o monitor parar de monitorar, ou seja, quando o ping parar de responder.

Para esta classe “Email” temos três propriedades string, representando o e-mail de destino, título do e-mail e mensagem (corpo) do email.

Ela contém também um método “Enviar()”. Este por sua vez, criará a mensagem de envio com as propriedades informadas, mais o e-mail de origem. Finalmente configurará um objeto de SMTP, com os dados de um servidor de e-mail SMTP. Depois é só disparar o email. Acompanhe:

// –> Utilizar os namespaces: System.Net.Mail; System.Net;

public class Email
{
    private string emailDestino;

    public string EmailDestino
    {
        get { return emailDestino; }
        set { emailDestino = value; }
    }

    private string titulo;

    public string Titulo
    {
        get { return titulo; }
        set { titulo = value; }
    }

    private string mensagem;

    public string Mensagem
    {
        get { return mensagem; }
        set { mensagem = value; }
    }

    public void Enviar()
    {
        MailMessage email = new MailMessage();
        email.From = new MailAddress("seuemail@seuprovedor.com");
        email.To.Add(emailDestino);
        email.Subject = titulo;
        email.Body = mensagem;

        SmtpClient smtp = new SmtpClient("smtp.seuhostsmtp.com.br");
        smtp.Credentials = new NetworkCredential("usuário", "senha");
        smtp.Send(email);
    }
}

Com tudo o que precisamos resgistrado na orientação a objetos, basta consumi-los, olhe o exemplo do uso das classes:

class Program
{
    static void Main(string[] args)
    {
        string ip;

        Console.WriteLine("Informe o IP do servidor que será monitorado: ");
        ip = Console.ReadLine();

        Monitor monitor = new Monitor();
        monitor.IP = ip;
        monitor.Monitorar();

        Email email = new Email();
        email.EmailDestino = "destino@email.com.br";
        email.Titulo = "Servidor Parou";
        email.Mensagem = string.Format("O servidor {0} parou de responder: {1}", ip, monitor.Status);
        email.Enviar();

        Console.WriteLine("Monitoramento encerrado...");
        Console.ReadKey();
    }
}

Neste programa, é lido um ip que irá ser monitorado, criamos um objeto “monitor”, informamos este ip na sua propriedade, e mandamos monitorar. Quando ele encerrar, é porque o ping já não foi bem sucedido, então criamos um objeto “email”, “escrevemos o e-mail” e enviamos.

Aproveitem! :)

Resolução de Exercícios: Pilhas e Filas

2010-08-02T23:06:00.001-03:00

Nos posts anteriores sobre pilhas e filas dinâmicas, foram propostos a implementação das estruturas com uma struct de Aluno.

Pois bem, aqui esta com a resolução…

Pilha:

#include <stdio.h>
#include <stdlib.h>

struct Aluno
{
    int ra;
    char nome[50];
};

struct Item
{
    Aluno aluno;
    Item *proximo;
};

void Inicializar(Item **topo)
{
   *topo = NULL;
}

bool EstaVazia(Item **topo)
{
   if(*topo == NULL)
      return true;
   else
      return false;
}

void Empilhar(Item **topo, Aluno elemento)
{
    Item *novo;
    novo = (Item *)malloc(sizeof(Item));
    novo->aluno = elemento;
    novo->proximo = *topo; // -> próximo recebe o elemento que estava no topo.
    *topo = novo;
}

Aluno Desempilhar(Item **topo)
{
   Aluno result;
   Item *auxiliar;

   if(EstaVazia(topo))
   {
        printf("\n stack underflow! \n");
        exit(1);
   }
   else // -> Elemento retirado do topo
   {
       result = (*topo)->aluno;
        auxiliar = *topo;
        *topo = (*topo)->proximo;
        free(auxiliar);
        return result;
   }
}

void MostrarPilha(Item *topo)
{
    int i = 0;
    Item *item;

    printf("\n\n Listando...\n\n");
    printf("---------------------------------\n");

    if (EstaVazia(&topo))
    {
        printf ("A Pilha esta vazia!\n");
    }
    else
    {
        item = topo;

        while(item != NULL)
        {
            i++;
            printf("[%i] -> %i - %s\n", i, item->aluno.ra, item->aluno.nome);
            item = item->proximo;
        }
    }

    printf("---------------------------------\n");
}

void Menu()
{
    printf( "Digite a sua escolha: \n"
        "    1 empilhar elemento \n"
        "    2 desempilhar \n"
        "    3 para finalizar \n"
        "? ");
}

void main()
{
    Item *topo = NULL;
    int opcao;
    Aluno aluno;

    Menu();
    scanf("%i", &opcao);

    while (opcao != 3)
    {

        switch (opcao)
        {
            case 1:
                printf( "Digite um RA: ");
                scanf("\n%i", &aluno.ra);

                printf( "Digite um Nome: ");
                scanf("\n%s", &aluno.nome);

                Empilhar(&topo, aluno);
                MostrarPilha(topo);

                break;
            case 2:
                Desempilhar(&topo);
                MostrarPilha(topo);

                break;

            default:
                printf( "Escolha invalida.\n\n");
                Menu();
                break;
        }

        scanf("%i", &opcao);
    }

    system("pause");
}

Fila:

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <string.h>

struct Aluno
{
    int ra;
    char nome[50];
};

struct Item
{
    Aluno aluno;
    struct Item *proximo;
};

struct Fila
{
    Item *inicio;
    Item *fim;
};

void Inicializar(Fila **fila)
{
    // -> Recebe a fila por referencia
    //    para inicializá-la
    *fila = (Fila *) malloc(sizeof(Fila));
    (*fila)->inicio = NULL;
    (*fila)->fim = NULL;
}

int EstaVazia(Fila *fila)
{
    return fila->inicio == NULL;
}

void Inserir(Fila *fila, Aluno elemento)
{
    Item *novo;
    novo = (Item *)malloc(sizeof(Item));

    // -> Verifica se a memória foi alocada com sucesso
    if (novo != NULL)
    {
        strcpy(novo->aluno.nome, elemento.nome);
        novo->aluno.ra = elemento.ra;
        novo->proximo = NULL;

        if(EstaVazia(fila))
        {
            // -> Primeiro Item da Fila.
            fila->inicio = novo;
            fila->fim = novo;
        }
        else
        {
            // -> Ultimo item da Fila
            fila->fim->proximo = novo;
            fila->fim=novo;
        }
    }
}

void Retirar(Fila *fila)
{
    Item *item;

    if(!EstaVazia(fila))
    {
        item = fila->inicio;
        fila->inicio = item->proximo;
        free(item);

        // -> Se a fila acabou devemos atualizar o final
        if (fila->inicio == NULL)
            fila->fim = NULL;
    }
}

void MostrarFila(Fila *fila)
{
    int i = 0;
    Item *item;

    printf("\n\n Listando...\n\n");
    printf("---------------------------------\n");

    if (EstaVazia(fila))
    {
        printf ("A Fila esta vazia!\n");
    }
    else
    {
        item = fila->inicio;

        while(item != NULL)
        {
            i++;
            printf("[%i] -> %i - %s\n", i, item->aluno.ra, item->aluno.nome);
            item = item->proximo;
        }
    }

    printf("---------------------------------\n");
}

void Menu()
{
    printf( "Digite a sua escolha: \n"
        "    1 enfileirar elemento \n"
        "    2 retirar da fila \n"
        "    3 para finalizar \n"
        "? ");
}

void main()
{
    Fila *fila = NULL;
    int opcao;
    Aluno aluno;

    Inicializar(&fila);
    Menu();
    scanf("%i", &opcao);

    while (opcao != 3)
    {

        switch (opcao)
        {
            case 1:
                printf( "Digite um RA: ");
                scanf("\n%i", &aluno.ra);

                printf( "Digite um Nome: ");
                scanf("\n%s", &aluno.nome);

                Inserir(fila, aluno);
                MostrarFila(fila);

                break;
            case 2:
                Retirar(fila);
                MostrarFila(fila);

                break;

            default:
                printf( "Escolha invalida.\n\n");
                Menu();
                break;
        }

        scanf("%i", &opcao);
    }

    system("pause");
}

Vale prestar atenção nos métodos de inserção. Na pilha é copiado o elemento de uma vez, na fila é copiado item a item da struct. Isso é só para exemplificar que das duas maneira é possível. Lembrem-se: para copiar strings utilizem a função da linguagem C strcpy(destino, origem).

Agora fica o desafio:

Validem a inclusão na estrutura para que não contenha RA repetido. A busca deve ser feito com o método de retirar elementos da estrutura!

Boa sorte

Fila Dinâmica

2010-07-27T13:07:00.001-03:00

Completando a lista dinâmica e a pilha dinâmica, vejamos esta estrutura dinâmica, a fila, explorando o potencial de alocação sob demana da memória de um computador.

Lembrando: A fila é uma lista com restrição de entrada e saída, assim, só podemos retirar elementos de quem chegou primeiro (início), e os novos elementos devem ser inseridos no final.

Para isso, ao codificarmos um exemplo, precisaremos de dois ponteiros: um que aponta para o início da fila e outro para o final. Podemos criar uma estrutura (struct) para controlar estes ponteiros.

Ainda assim será necessário ter uma estrutura com o elemento e o ponteiro para o próximo elemento.

Vejamos através de imagens e vídeos a representação gráfica desta estrutura de dados:

Exemplos by: http://mda.codeplex.com/

Agora que já esta dominado este conceito, segue um breve exemplo de codificação de uma fila em C:

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>

struct Item
{
    int numero;
    struct Item *proximo;
};

struct Fila
{
    Item *inicio;
    Item *fim;
};

void Inicializar(Fila **fila)
{
    // -> Recebe a fila por referencia
    //    para inicializá-la
    *fila = (Fila *) malloc(sizeof(Fila));
    (*fila)->inicio = NULL;
    (*fila)->fim = NULL;
}

int EstaVazia(Fila *fila)
{
    return fila->inicio == NULL;
}

void Inserir(Fila *fila, int elemento)
{
    Item *novo;
    novo = (Item *)malloc(sizeof(Item));

    // -> Verifica se a memória foi alocada com sucesso
    if (novo != NULL)
    {
        novo->numero = elemento;
        novo->proximo = NULL;

        if(EstaVazia(fila))
        {
            // -> Primeiro Item da Fila.
            fila->inicio = novo;
            fila->fim = novo;
        }
        else
        {
            // -> Ultimo item da Fila
            fila->fim->proximo = novo;
            fila->fim=novo;
        }
    }
}

void Retirar(Fila *fila)
{
    Item *item;

    if(!EstaVazia(fila))
    {
        item = fila->inicio;
        fila->inicio = item->proximo;
        free(item);

        // -> Se a fila acabou devemos atualizar o final
        if (fila->inicio == NULL)
            fila->fim = NULL;
    }
}

void MostrarFila(Fila *fila)
{
    int i = 0;
    Item *item;
    printf("\n\n Listando...\n\n");
    printf("---------------------------------\n");

    if (EstaVazia(fila))
    {
        printf ("A Fila esta vazia!\n");
    }
    else
    {
        item = fila->inicio;

        while(item != NULL)
        {
            i++;
            printf("[%i] -> %i\n", i, item->numero);
            item = item->proximo;
        }
    }

    printf("---------------------------------\n");
}

void Menu()
{
    printf( "Digite a sua escolha: \n"
        "    1 enfileirar elemento \n"
        "    2 retirar da fila \n"
        "    3 para finalizar \n"
        "? ");
}

void main()
{
    Fila *fila = NULL;
    int opcao;
    int numero;

    Inicializar(&fila);
    Menu();
    scanf("%i", &opcao);

    while (opcao != 3)
    {

        switch (opcao)
        {
            case 1:
                printf( "Digite um numero: ");
                scanf("\n%i", &numero);

                Inserir(fila, numero);
                MostrarFila(fila);

                break;
            case 2:
                Retirar(fila);
                MostrarFila(fila);

                break;

            default:
                printf( "Escolha invalida.\n\n");
                Menu();
                break;
        }

        scanf("%i", &opcao);
    }

    system("pause");
}

Também é uma estrutura simples, alguns acham ela mais complexa que a pilha, por conta de lidar com dois ponteiros: o inicio e o fim. - Mas como encapsulamos estes ponteiros em uma estrutura, fica fácil manter e compreender o código.

Devemos ficar atento:

Devemos inserir os elementos no final da fila. Se for o primeiro elemento os dois ponteiros devem apontar para ele, caso contrário, o ponteiro “próximo” do ultimo elemento deve apontar para este novo elemento.
Removemos elemento sempre do início da fila, se removermos todos, o ponteiro do último também deve ser “zerado”, se não, o ponteiro do inicio deve ser o “proximo” do item inicial atual.

Um pouco confuso, por isso testem.

E para diversão fica:

Implemente a fila com uma estrutura de aluno, que tenha RA (inteiro), Nome (char de 50).

Obrigado e bons estudos :D

Pilha Dinâmica

2010-07-26T22:40:00.001-03:00

Como já demonstrado antes aqui, a linguagem C/C++ tem o potencial de alocar a memória do computador sobre demanda.

Que tal aproveitarmos este potencial para criar uma pilha dinâmica?

Para resolver isto vamos focar em alguns detalhes:

A pilha é uma lista com restrição de entrada e saída, ou seja, é acessada pelo topo.
Para inserir um elemento é necessário empilhar este elemento no topo da pilha.
Para retirar um elemento, nos desempilhamos do topo da pilha.
(… nem venham me falar que isto é redundante…)
Então precisamos de manter um ponteiro para o topo da lista.
Devemos criar uma estrutura (struct) que contenha o elemento, e um ponteiro para o próximo elemento (o que esta abaixo).

Vejamos graficamente como funciona este conceito, acompanhe a imagem e o vídeo abaixo:

Exemplos by: http://mda.codeplex.com/

Agora, com esta parte funcional esclarecida, vejamos um breve exemplo de código de uma pilha dinâmica em C, construída em cima da lista dinâmica:

#include <stdio.h>
#include <stdlib.h>

struct Item
{
    int numero;
    struct Item *proximo;
};

void Inicializar(Item **topo)
{
   *topo = NULL;
}

bool EstaVazia(Item **topo)
{
   if(*topo == NULL)
      return true;
   else
      return false;
}

void Empilhar(Item **topo, int elemento)
{
    Item *novo;
    novo = (Item *)malloc(sizeof(Item));
    novo->numero = elemento;
    novo->proximo = *topo; // -> próximo recebe o elemento que estava no topo.
    *topo = novo;
}

int Desempilhar(Item **topo)
{
   int result;
   Item *auxiliar;
   if(EstaVazia(topo))
   {
        printf("\n stack underflow! \n");
        exit(1);
   }
   else // -> Elemento retirado do topo
   {
        result = (*topo)->numero;
        auxiliar = *topo;
        *topo = (*topo)->proximo;
        free(auxiliar);
        return result;
   }
}

void MostrarPilha(Item *topo)
{
    int i = 0;
    Item *item;
    printf("\n\n Listando...\n\n");
    printf("---------------------------------\n");

    if (EstaVazia(&topo))
    {
        printf ("A Pilha esta vazia!\n");
    }
    else
    {
        item = topo;

        while(item != NULL)
        {
            i++;
            printf("[%i] -> %i\n", i, item->numero);
            item = item->proximo;
        }
    }

    printf("---------------------------------\n");
}

void Menu()
{
    printf( "Digite a sua escolha: \n"
        "    1 empilhar elemento \n"
        "    2 desempilhar \n"
        "    3 para finalizar \n"
        "? ");
}

void main()
{
    Item *topo = NULL;
    int opcao;
    int numero;

    Menu();
    scanf("%i", &opcao);

    while (opcao != 3)
    {

        switch (opcao)
        {
            case 1:
                printf( "Digite um numero: ");
                scanf("\n%i", &numero);

                Empilhar(&topo, numero);
                MostrarPilha(topo);

                break;
            case 2:
                Desempilhar(&topo);
                MostrarPilha(topo);

                break;

            default:
                printf( "Escolha invalida.\n\n");
                Menu();
                break;
        }

        scanf("%i", &opcao);
    }

    system("pause");
}

Por ser uma lista com restrição, este exemplo chega a ser bem simples perto da lista dinâmica.

Só vale ressaltar:

Para inserir, é necessário empilhar, ou seja: Alocar um novo item na memória, fazer com que o item do topo se torne o próximo do novo item, finalmente, o ponteiro do topo deve apontar para o novo elemento.
Para remover, énecessário retirar o item do topo, assim: Criamos um ponteiro auxiliar que recebe o endereço de memória do conteúdo do topo, o topo deverá receber o próximo (dele mesmo), finalmente, liberamos a memória do conteúdo da variável auxiliar.

Hora da diversão:

Implemente a pilha com uma estrutura de aluno, que tenha RA (inteiro), Nome (char de 50).

Obrigado, espero que tenha sido esclarecedor. :)

Material Didático de Apoio para Aulas de Computação em C# e C++

2010-07-22T08:54:00.001-03:00

Pesquisando um pouco para encontrar um material mais dinamico para minhas aulas, encontrei no codeplex este excelente material para aulas de algoritmos, principalmente de estrutura, pesquisa e ordenação de dados.

Foi lembrado aos professores que a sala de aula hoje está munida de projetor e computador, e que o uso desse recurso traz uma dinamica melhor nas aulas.

Tentando deixar um pouco de lado o giz, códigos, textos e desenhos maravilhosos de minha parte sobre pilhas, filhas, listas etc, tentei encontrar animações que mostrassem a dinamica destes algoritmos em seu funcionamento, trazendo uma compreensao mais visual e menos abstrata ao aluno.

Procurando esse tipo de material eu encontrei isso:

Como vocês podem ver, é uma ferramenta que demonstra graficamente, juntamente com uma depuração de código do(C# e C++), o funcionamento de algoritmos de ordenação.

Então, o MDA é um conjunto de ferramentas cujo objetivo é fornecer suporte ao ensino de alguns tópicos abordados em disciplinas de computação.
Tópicos Abrangidos

Estruturas de Dados
- Árvores Binárias de Pesquisa
- Filas
- Listas Simplesmente Encadeadas
- Pilhas

Algorítmos de Ordenação
- Bubble Sort
- Heap Sort
- Insertion Sort
- Quick Sort
- Quick Sort Randômico
- Selection Sort
- Shell Sort

Desenvolvido por Bárbara Bellaver, sob a orientação do Prof. Manuel M. Oliveira, este projeto procura fornecer ferramentas que sejam de fácil utilização e que apresentem os tópicos acima de forma didática e clara.A linguagem utilizada para o desenvolvimento é a C#.

Logo, para consegui-la, tive que entrar em contato com a Bárbara no Rio Grande do Sul, a qual me passou as informações da ferramenta e seu endereço no Codeplex: http://mda.codeplex.com/

Lá é possível, baixar a ferramenta, testá-la e acompanhar a breve implementação dos códigos e seu funcionamento, além de um comparativo de vários algoritmos rodando ao mesmo tempo :)

Parabéns pela iniciativa, estudem e divirtam-se!

Monografia – WebCrawlers: Ferramentas de Pesquisa, Catalogação e Indexação de Site

2010-07-09T22:12:00.001-03:00

Pessoal, como o prometido a muito tempo, estou abrindo minha monografia para pesquisa.

Agora no mestrado pretendo aprimorá-la como nunca. Tenho grandes ideias e projetos… Basta eu concretizá-los.

Em breve também abrirei o projeto com o código (que já está no apêndice).

Espero que seja útil, e os animem com seus TCCs, Monografias e objetos de pesquisa. Espero o feedback também, para que eu possa sempre aprimorar meu trabalho.

A monografia fala por si mesma, mas para os curiosos e ansiosos, ela explica o funcionamento do google, bing etc. Basicamente eu implementei e expliquei os crawlers, ou webcrawlers: que são programas que funcionam como um robozinho que fica visitando as páginas, colhendo seu conteúdo, e navegando pelos links da mesma.

Um fato curioso e engraçado é que, quando eu rodava uma média de 100 crawlers, eu acabava derrubando a internet do lugar, seja laboratório de informática da faculdade, ou escritório de trabalho. :D Outra curiosidade é que, na época, quando eu rodava a aplicação em casa, demorava 1h para eu colher 40000 sites. Na faculdade foram poucos minutos, o que me deixou extasiado na apresentação… Foi bem hilário também :)

Bem, agora me resta aprimorar, fazendo a catalogação do conteúdo, busca fonética e baseada na posição geográfica.

Desejem-me sorte!

Monografia - Eduardo Spaki - Final