Vinicius Quaiato

Tecnologia e algo mais…

Asp.Net Ajax Library é uma nova biblioteca JavaScript que nos permite criar aplicações orientadas a dados de forma simples e prática.

Ela difere do Ajax Control Toolkit no sentido de que todos os seus controles e funcionalidades rodam inteiramente no client, ou seja, é possível utilizar o Ajax Library em páginas 100% html, nenhum code behind, nenhum arquivo .aspx e nenhum arquivo .cs (é possível trabalhar com .aspx e codebehind, só não é obrigatório).

Para realizarmos este exemplo vamos fazer o download da biblioteca no CodePlex neste link: http://ajax.codeplex.com/

Neste exemplo veremos como gerar uma tabela de dados contendo o nome de algumas bandas e suas respectivas fotos.
Não utilizaremos ainda acesso a webservices, trabalharemos com dados locais.

Para isso criaremos um projeto Asp.Net WebSite vazio, e adicionaremos um arquivo html, chamado Default.htm (Sim, nossa aplicação toda executará em um arquivo .htm).
Vamos adicionar ao projeto os arquivos .js que fazem parte da biblioteca, como mostra a imagem abaixo:

Adicionando arquivos js Asp.Net Ajax Library 4.0

Feito isso adicionarei os trechos de código abaixo na página Default.html. Separei em dois blocos para mostrar primeiro o código JavaScript e depois o código HTML, no final colocarei o código completo da página.

1
2
3
4
5
6
7
8
9
10
11
12
13

<script src="Scripts/Start.js" type="text/javascript"></script>
<script type="text/javascript">
    Sys.require([Sys.components.dataView],
        function () {
            var bandas = [
                { Nome: 'Metallica', Foto: 'metallica.jpg' },
                { Nome: 'The Smiths', Foto: 'smiths.jpg' },
                { Nome: 'Depeche Mode', Foto: 'depeche.jpg' },
                { Nome: 'Los hermanos', Foto: 'hermanos.jpg' }
            ];
            Sys.create.dataView("#corpo",{data: bandas});
        });  
</script>

Como pode ser visto na linha 1 estou adicionando uma referência para o arquivo Start.js, que faz parte do Asp.Net Ajax Library, e adicionamos no nosso projeto.
Na linha 3 começa a acontecer a “mágica”. Chamamos o método require que recebe neste caso dois parâmetros. O primeiro é uma biblioteca a ser carregada, neste caso o Sys.components.dataView. o segundo parâmetro é uma função a ser executada depois que a biblioteca foi carregada, ou seja, seus recursos já estão disponíveis.
Um dos principais recursos para a exibição de dados é o DataView. DataView é basicamente um template, criamos marcações HTML e então pedimos para o Ajax Library transformar em um dataview.
Da linha 5 até linha 10 eu crio um objeto utilizando notação JSON, contendo o nome de uma banda, e o nome de um arquivo com a imagem da banda, bastante simples. Este objeto será nossa fonte de dados.
Na linha 11 ocorre o bind dos dados. Utilizando o Sys.create.dataView passamos como primeiro parâmetro o id de um elemento HTML onde deve ser criado o dataview. E como segundo parâmetro dizemos que o objeto bandas deve ser usado como fonte de dados.
Bastante simples.

Abaixo está o código HTML, onde definimos o elemento que será o dataView:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

<table>
    <thead>
        <tr>
            <th>Banda</th>
            <th>Foto</th>
        </tr>
    </thead>
    <tbody id="corpo" class="sys-template">
        <tr>
            <td>
                <span>{{Nome}}</span>
            </td>
            <td>
                <img sys:src="{{Foto}}" width="100" height="100" />
            </td>
        </tr>
    </tbody>
</table>

Apenas criamos uma table, simples. Na linha 8 está um detalhe importante pois utilizamos uma class chamada sys-template. Esta class é necessária para que o Ajax Library reconheça este elemento como um template com o qual ele poderá trabalhar.
Na linha 11 criamos um span e como valor do span utilizamos a marcação {{Nome}} que diz para o Ajax Library que ali deve ser colocado o campo Nome da fonte de dados que passamos para ele.
Na linha 14 fazemos quase a mesma coisa, a diferença é que ao invés de utilizarmos o atributo src do elemento img, utilizamos sys-src, pois o valor deste atributo {{Foto}} está entre as aspas, e é com o sys-src que o Ajax Library consegue fazer o bind corretamente.

Pronto! Agora temos nossa aplicação funcionando, realizando o bind da nossa fonte de dados, e exibindo tudo da maneira desejada. Como mostra a figura abaixo:

Página usando Asp.Net Ajax Library

O código completo da página Default.html está aqui:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
    <head>
        <title></title>
        <script src="Scripts/Start.js" type="text/javascript"></script>
        <script type="text/javascript">
            Sys.require([Sys.components.dataView],
                function () {
                    var bandas = [
                        { Nome: 'Metallica', Foto: 'metallica.jpg' },
                        { Nome: 'The Smiths', Foto: 'smiths.jpg' },
                        { Nome: 'Depeche Mode', Foto: 'depeche.jpg' },
                        { Nome: 'Los hermanos', Foto: 'hermanos.jpg' }
                    ];
                    Sys.create.dataView("#corpo",
                     {
                         data: bandas
                     });
                });  
        </script>
    </head>
    <body>
        <table>
            <thead>
                <tr>
                    <th>Banda</th>
                    <th>Foto</th>
                </tr>
            </thead>
            <tbody id="corpo" class="sys-template">
                <tr>
                    <td>
                        <span>{{Nome}}</span>
                    </td>
                    <td>
                        <img sys:src="{{Foto}}" width="100" height="100" />
                    </td>
                </tr>
            </tbody>
        </table>
    </body>
</html>

Bom pessoal, por hoje é isso. O Asp.Net Ajax Library possui uma série de recursos e controles incríveis. São 3 tipos diferentes de bindings, e os bindings podem ser feitos de maneiras variadas.
Pretendo ir dando mais detalhes e informações por aqui, na medida do possível.
Alguns How To podem ser vistos aqui.

Comentário, críticas e sugestões são bem vindos.

Att,
Vinicius Quaiato.

Fala galera. Vou abordar um pouco do PLINQ neste post.

Parallel LINQ, ou PLINQ, é uma implementação do padrão LINQ que trabalha de forma paralela sobre qualquer fonte de dados em memória que implemente IEnumerable ou IEnumerable<T>, possuindo ainda a execução adiada até o momento em que a query é enumerada, ou seja, de fato utilizada.

Umas das novidades é o extension AsParallel que está disponível em IEnumerable e IEnumerable<T>. AsParallel diz que à partir daquele momento as operações realizadas sobre aquela fonte de dados serão executas de forma paralela, é bem simples. O código abaixo demonstra isso:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

static void Main(string[] args)
{
    var numeros = Enumerable.Range(0, 10);
 
    var dobrados = from n in numeros.AsParallel()
                   select Dobro(n);
 
    foreach (var dobro in dobrados)
        Console.WriteLine(dobro);
 
    Console.ReadKey();
}
 
private static int Dobro(int numero)
{
    Thread.Sleep(500);
    return numero * 2;
}

Como vemos na linha 5 estamos chamando o método AsParallel na nossa coleção de números. Então apenas chamamos um método passando o número como parâmetro. Este método apenas congela a thread por meio segundo para que possamos notar como os valores são executados de forma paralela. Na imagem abaixo temos o resultado:

Enumerando com AsParallel do PLINQ

O PLINQ também permite de forma simples e fácil especificar quantos processadores queremos utilizar para executar as operações paralelas. É possível especificar até um máximo de 64 processadores (ô loco meu!).
Abaixo segue a alteraçãono código anterior especificando 2 processadores a serem utilizados (só tenho 2):

5
6

    var dobrados = from n in numeros.AsParallel().WithDegreeOfParallelism(2)
                   select Dobro(n);

Na linha 5 do nosso código adicionamos uma chamada para a extensão WithDegreeOfParallelism e passamos como parâmetro o total de processadores a ser utilizado. No mais o código permanece exatamente igual.

Outro recurso bastante interessante é realizar o processamento paralelo e conseguir que o resultado seja ordenado. Isso é possível utilizando a extension AsOrdered.
No código anterior poderíamos utilziar AsParallel e continuar realizando o processamento de forma paralela mas mantendo a saída ordenada, como pode ser visto abaixo:

5
6

    var dobrados = from n in numeros.AsParallel().AsOrdered()
                   select Dobro(n);

A saída pode ser vista na imagem abaixo:

PLINQ usando AsParallel com AsOrdered

Existem ainda diversos recursos no PLINQ. Em breve abordarei mais sobre eles aqui.
Uma boa documentação está disponível no MSDN aqui, aqui e aqui.

Comentários, críticas e sugestões, basta escrever.

Att,
Vinicius Quaiato.

O IronRuby é um port da linguagem Ruby para ser executada juntamente com o .Net Framework.
Atualmente o IronRuby está em release candidate(versão 1.0 – RC1), e em algum tempo devemos ter a versão oficial.

A idéia aqui não é descrever em pormenores os detalhes da linguagem Ruby, pois inúmeras referências podem ser encontradas na web: Ruby on Br é uma delas.

Vou demonstrar como começar a utilizar o IronRuby juntamente com as bibliotecas do .Net e como produzir algum código.

Vamos iniciar instalando o IronRuby, e para isso faça o download no site oficial do Ironruby no CodePlex aqui. Eu utilizei a versão Windows Installer.
Execute este instalador após o download, ele irá extrair os arquivos para uma pasta especificada.

Assim como a maioria das linguagens dinâmicas o IronRuby possui um console interativo, onde podemos escrever código e testar seu uso. E é desta forma que trabalharemos neste primeiro momento.

Execute o console do IronRuby, que deve ser encontrado na [pasta de instalação]\bin\ir.exe.

Você deverá ver uma tela semelhante a esta:

IronRuby Console

Agora já podemos começar a escrever nosso código Ruby/IronRuby.
Como nosso primeiro código, vamos criar uma classe que terá apenas um método, um famoso Olá Mundo:

class OlaIronRuby
    def DigaOi
	puts "Olá Mundo IronRuby!"
    end
end

Quando digitarmos esse código no console do IronRuby esta classe estará disponível para uso, e a utilizaremos assim:

instancia = OlaIronRuby.new

E fazemos a chamada para o método assim:

instancia.DigaOi

Abaixo vocês conferem todo o código no console do IronRuby:

Criando instancia de classe no IronRuby

Agora vamos criar uma nova classe que irá trabalhar com bibliotecas do framework.
Para referenciarmos um assembly no console, vamos utilizar o require ‘nome do assembly’, como pode ser visto no código abaixo, onde utilizamos o WindowsForms.MessageBox para exibir uma mensagem usando o IronRuby:

require 'System.Windows.Forms'
 
System::Windows::Forms::MessageBox.show "Olá MessageBox!"

E o resultado podemos ver aqui:

Usando MessageBox com IronRuby

Podemos ainda criar aplicações WPF por exemplo. Para isso vamos digitar nosso código em um arquivo e salvá-lo como WpfIronRuby.rb, o código pode ser visto abaixo:

require 'wpf'
include Wpf
 
janela = Wpf::Window.new
janela.Title = 'WPF com IronRuby'
janela.content = Wpf::TextBlock.new
janela.content.text = "Janela WPF usando IronRuby!"
janela.content.font_size = 60
 
app = Application.new
app.run janela

Para este código funcionar eu copiei o arquivo wpf.rb da pasta [instalação do ironruby]\Samples\Tutorial\app\wpf.rb para [instalação do ironruby]\Lib\ironruby

Para executar a aplicação eu abri o command do windows e naveguei a até a pasta onde salvei o arquivo, no meu caso o Desktop e digitei: ir.exe WpfIronRuby.rb como pode ser visto na imagem abaixo:

Rodando aplicação Wpf com IronRuby

Bom galera, é isso.
O ironRuby ainda está saindo do forno, e com certeza será(e já é) uma grande soma para o .Net Framework.

Qualquer dúvida, mail-me ou comentem.

Abraços,
Vinicius Quaiato.

Continuando a falar de dynamic no .NET 4.0, vamos falar um pouco sobre DynamicObject.

DynamicObject é uma classe abstrata que permite definir quais operações podem ser feitas em um objeto dynamic e como estas operações são realizadas.

Falei um pouco sobre ExpandoObject aqui, que é um tipo de objeto dynamic.

Para não dizer que esta é uma das novas features e que ela é inútil, estou envolvido em um projeto e se esta feature já estivesse disponível em versão realease, eu já estaria utilizando a mesma por necessidades do projeto.

Bom para dar um exemplo, vamos imaginar que estamos implementando um provider customizado para sessões em nossa aplicação.
Muitas vezes não queremos ter que escrever algo como minhaSessao["Usuario"], afinal se sabemos que sempre haverá um Usuario na sessão ele poderia ser uma propriedade. Com DynamicObject podemos fazer isso (primeiro vou escrever os testes):

[TestMethod]
public void Deve_Criar_Uma_Propriedade_Nome_No_Objeto_Dinamico()
{
    dynamic sessaoDinamica = new SessaoDinamica();
    sessaoDinamica.Nome = "Vinicius";
 
    Assert.AreEqual(sessaoDinamica.Nome, "Vinicius");
}

E a classe SessaoDinamica:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public class SessaoDinamica : DynamicObject
{
    private Dictionary<string, object> sessionItems = new Dictionary<string, object>();
 
    public override bool TrySetMember(SetMemberBinder binder, object value)
    {
        sessionItems[binder.Name.ToLower()] = value;
 
        return true;
    }
 
    public override bool TryGetMember(GetMemberBinder binder, out object result)
    {
        return sessionItems.TryGetValue(binder.Name.ToLower(), out result);
    }
}

Podemos notar na linha 1 que nossa classe herda de DynamicObject, que como foi dito é uma classe abstrata.
Na linha 3 definimos um dicionário para ser a coleção de itens da nossa sessão.
Nas linhas 5 a 10 fazemos um override em um dos métodos da classe DynamicObject. O método TrySetMember é que fará toda a mágica. Quando uma propriedade for chamada no objeto dynamic o .net irá verificar se esta propriedade existe de fato e caso ela não exista o método TrySetMember será então chamado. Dentro deste método estamos atribuindo o nome da propriedade chamada à uma chave do nosso dicionário, e o valor que foi atribuído a ela para o valor do item do dicionário.
Pronto! Com isso já é possível chamar qualquer propriedade na nossa sessão.
Nas linhas 13 a 15 fazemos o mesmo mas para um get. Sempre que tentar obter um valor de uma propriedade em um objeto dynamic o .net irá verificar se a propriedade existe, e caso não exista será chamado o método TryGetMember.

Com isso podemos executar o código do teste abaixo:

1
2
3
4
5
6
7
8
9
10

[TestMethod]
public void Deve_Criar_Uma_Propriedade_Nome_E_outra_Sobrenome()
{
    dynamic sessaoDinamica = new SessaoDinamica();
    sessaoDinamica.Nome = "Vinicius";
    sessaoDinamica.Sobrenome = "Quaiato";
 
    Assert.AreEqual(sessaoDinamica.Nome, "Vinicius");
    Assert.AreEqual(sessaoDinamica.sobrenome, "Quaiato");
}

Nas linhas 5 e 6 estamos setando duas propriedade que “não existem” definidas na nossa classe SessaoDinamica, mas o TrySetMember está fazendo a mágica “por baixo dos panos”.
E nas linhas 8 e 9 estamos obtendo o valor das duas propriedades e o TryGetMember está fazendo a mágica também.
Note que na linha 9 usamos a propriedade com letra minúscula, podendo trabalhar com elas de modo case-sensitive ou case-insensitive.

É isso galera.
Tenho certeza que as capacidades dinâmicas do .net 4 irão fornecer base para muitos trabalhos interessantes, tanto em projetos na comunidade quanto em projetos particulares.

Qualquer dúvida é só postar aqui ou escrever um email.

Abraços,
Vinicius Quaiato.

Fala galera, hoje vamos falar um pouco sobre dynamic no .NET 4.0.

Dynamic é um novo tipo introduzido no .net framework 4.0, é um tipo estático assim como os outros tipos do framework, no entanto ele ignora as verificações estáticas em tempo de compilação.
Deve-se prestar atenção, então, aos erros que podem acontecer em runtime, pois um código que não existe e seja chamado gerará um erro em tempo de execução.

Alguns podem achar que isso é um problema, esse papo todo de runtime e etc, eu já não enxergo desta maneira, vejo como uma oportunidade para novas criações.
Diversas empresas e projetos que trabalham com .net se deparam em situações onde a equipe diz:
“Ah se isso fosse diferente… Poderíamos fazer de forma mais simples ou legível…”.
Isso não é uma coisa ruim, é um sinal de que em algumas situações necessitamos de algo mais dinâmico do que o que o .net proporciona (proporcionava) até então.

Bom vamos falar um pouco do ExpandoObject.
ExpandoObject é um objeto que pode ter membros adicionados ou removidos dinâmicamente. Com ele é possível definirmos métodos e propriedades em tempo de execução.
Talvez muitos de nós não vejamos vantagens neste tipo de feature logo de início, mas para muitos será uma feature muito interessante e que proporcionará um grande avanço.

Vamos imaginar o seguinte cenário para a utilização do ExpandoObject:
Um sistema consome diversos webservices de empresas distintas de um mesmo segmento, porém, para cada usuário do sistema configuramos uma permissão diferente aos serviços oferecidos por estes webservices.
Vejamos um código de exemplo (lembrando que você precisa do Visual Studio 2010 beta 2).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

using System;
using System.Dynamic;
 
namespace ExpandoObjectApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            dynamic objetoDinamico = new ExpandoObject();
            dynamic Sistema1 = new ExpandoObject();
            dynamic Sistema2 = new ExpandoObject();
 
            Sistema1.PodeAcessar = false;
            Sistema1.AlgumaAcao = (Func<string>)(() =>
            {
                if (Sistema1.PodeAcessar)
                    return "AlgumaAcao no Sistema1";
                else
                    return "Você não pode acessar este serviço";
            });
            objetoDinamico.Sistema1 = Sistema1;
 
            Sistema2.PodeAcessar = true;
            Sistema2.OutraAcao = (Func<int>)(() =>
            {
                if (Sistema2.PodeAcessar)
                    return 1 + 1;
                else
                    throw new Exception("Você não pode acessar este serviço");
            });
            objetoDinamico.Sistema2 = Sistema2;
 
            Console.WriteLine("objetoDinamico.Sistema1.AlgumaAcao: {0}", objetoDinamico.Sistema1.AlgumaAcao());
 
            Console.WriteLine("objetoDinamico.Sistema2.OutraAcao: {0}", objetoDinamico.Sistema2.OutraAcao());
 
            Console.ReadKey();
        }
    }
}

Na linha 2 incluímos uma referência para System.Dynamic, necessário para utilizar o ExpandoObject.
nas linhas 10, 11 e 12 criamos 3 objetos dynamic do tipo ExpandoObject. O primeiro objeto será nosso objeto de permissões. Os objetos Sistema1 e Sistema2 serão cada um a permissão e o acesso ao serviço de terceiros.
Na linha 14 nós criamos uma propriedade em Sistema1 e setamos o seu valor para false.
Nas linhas 15 a 21 estamos definindo um método para o objeto Sistema1. Este método verifica se a propriedade PodeAcessar está com o valor true e então executa o corpo do método.
Na linha 22 dizemos que a propriedade Sistema1 do objeto objetoDinamico é do tipo ExpandoObject, e setamos o seu valor atribuindo a ela o objeto Sistema1.
Nas linhas 24 a 32 fazemos as mesmas coisas para o objeto Sistema2.

O resultado pode ser conferido na imagem a seguir:

Resultado ExpandoObject

Uma das desvantagens para quem está acostumado com o Visual Studio é que os objetos dynamic não possuem intellisense. Talvez isso não seja algo ruim, ou talvez seja, depende bastante do cenário em que é utilizado.

Dynamic object intellisense

É isso galera, um outro exemplo do uso de ExpandoObject pode ser visto aqui.

Att,
Vinicius Quaiato.