Vinicius Quaiato

Tecnologia e algo mais…

Fala galera, recebi algumas dúvidas por e-mail e vamos resolver aqui.
Vamos trabalhar com relações many-to-many utilizando POCO e o Entity Framework 4.0.
Para ver como trabalhar com POCO no EF4 veja este post aqui.

Vamos fazer um exemplo bem simples, trabalhando com produtos e lojas. Cada produto poderá estar em muitas lojas, e uma loja poderá conter muitos produtos.
Abaixo temos o desenho de nosso modelo inicial:

Modelo de Classes Entity Framework 4.0

Feito isso vamos criar uma associação entre nossas entidades, como pode ser visto abaixo:

Criando associação no modelo do EF 4.0

Definindo a Associacao Many-To_Many no EF 4.0

Feito isso basta salvarmos nosso modelo e gerar o banco de dados. Lembrando de desmarcar a opção de geração de código no modelo (veja aqui como fazer isso).

Nossas classes ficarão simples, como não poderia deixar de ser.
Abaixo vemos a classe Produto, que como pode-se notar não possui nenhuma dependência do entity Framework e nem conhece nada relacionado com banco de dados:

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

public class Produto
{
    public virtual int Id { get; set; }
    public virtual string Nome { get; set; }
    public virtual decimal ValorSugerido { get; set; }
    private IList<Loja> lojasOndeVende = new List<Loja>();
    public virtual IList<Loja> LojasOndeVende
    {
        get
        {
            return this.lojasOndeVende;
        }
        set
        {
            this.lojasOndeVende = value;
        }
    }
}

Abaixo temos a classe Loja:

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

public class Loja
{
    public virtual int Id { get; set; }
    public virtual string Nome { get; set; }
    public virtual string Cidade { get; set; }
    private IList<Produto> produtosQueVende = new List<Produto>();
    public virtual IList<Produto> ProdutosQueVende
    {
        get
        {
            return this.produtosQueVende;
        }
        set
        {
            this.produtosQueVende = value;
        }
    }
}}

E aqui temos nossa classe de contexto do Entity Framework, que também criamos, de forma bastante simples:

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

public class EF4Context : ObjectContext
{
    public EF4Context()
        : base("name=ModeloManyToManyContainer", "ModeloManyToManyContainer") { }
 
    private IObjectSet<Produto> produtos;
    public IObjectSet<Produto> Produtos
    {
        get
        {
            if (produtos == null)
                produtos = CreateObjectSet<Produto>();
 
            return produtos;
        }
    }
 
    private IObjectSet<Loja> lojas;
    public IObjectSet<Loja> Lojas
    {
        get
        {
            if (lojas == null)
                lojas = CreateObjectSet<Loja>();
 
            return lojas;
        }
    }
}

E isto é tudo que precisamos. Já podemos trabalhar com nossas entidades de forma a terem a relação Many-to-Many feita e funcionando.
Criei uma aplicação console para demonstrar isso. O método abaixo faz algumas inserções no banco, e o resultado da consulta pode ser visto na imagem a seguir:

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

private static void InserirNovosProdutosELojas()
{
    var contexto = new EF4Context();
 
    var produto = new Produto();
    produto.Nome = "Produto de Soja";
    produto.ValorSugerido = 10;
 
    var produto2 = new Produto();
    produto2.Nome = "Produto de tofu";
    produto2.ValorSugerido = 10;
 
    var loja = new Loja();
    loja.Nome = "Loja do Vinicius";
    loja.Cidade = "São Paulo";
    loja.ProdutosQueVende.Add(produto);
 
    var loja2 = new Loja();
    loja2.Nome = "Loja Vegetariana";
    loja2.Cidade = "São Paulo";
    loja2.ProdutosQueVende.Add(produto);
    loja2.ProdutosQueVende.Add(produto2);
 
    contexto.AddObject("Produtos", produto);
    contexto.AddObject("Produtos", produto2);
    contexto.AddObject("Lojas", loja);
    contexto.AddObject("Lojas", loja2);
 
    contexto.SaveChanges();
 
    Console.ReadKey();
}

Reparem que apenas adicionamos os produtos nas lojas, e não precisamos adicionar as lojas aos produtos também. O Entity Framework é esperto para fazer essa associação.

Aqui podemos ver uma saída gráfica das nossas relações:

Resultado da relação Many-to-Many

Bom pessoal, éisso aê. A relação Many-to-Many com POCOs no Entity Framework 4.0 é bastante simples e natural. Não requer passos adicionais e nem complicados.

Qualquer dúvida, crítica ou sugestão, deixem seus comentários ou podem escrever email.

Att,
Vinicius Quaiato.

Fala galera!
Dia 10 de fevereiro, se não me engano, tivemos a liberação da versão RC (Release Candidate) do Visual Studio 2010 para download.

O link para download é este: http://www.microsoft.com/downloads/details.aspx?FamilyID=457bab91-5eb2-4b36-b0f4-d6f34683c62a&displaylang=en

Você pode obter mais informações sobre esta versão aqui: http://msdn.microsoft.com/pt-br/vstudio/dd582936.aspx

Algumas informações (comentários, bugs e melhorias) podem ser vistas aqui no blog do Scott Guthrie.

Estou preparando mais alguns posts sobre funcionalidades do VS2010, e logo mais estarão por aqui.

É isso, espero que utilizem, dêem seu feedback, e se divirtam!

Att,
Vinicius Quaiato.

Fala galera, de buenas? Resolvi escrever um pouco sobre o Entity Framework 4.0 (na verdade é a versão 2 do EF mas para acompanhar o .NET 4.0 ele será chamado assim também).

Hoje vou mostrar uma característica bem interessante, que é o model first trabalhando com POCOs.
Model First diz respeito a primeiro criar suas entidades, ou seja, suas classes, e somente depois modelar o banco de dados – e é isto que queremos fazer quando desenvolvemos aplicações usando Orientação a Objetos, não é?
POCOs são classes simples, que não herdam nem implementam nenhuma outra classes/interface específica de frameworks, dizendo respeito exclusivamente ao nosso domínio e contendo apenas o necessário ao nosso domínio.

Para começar vamos criar um projeto de testes e adicionar um arquivo .edmx como mostra a figura abaixo:

Criando o arquivo edmx

Selecionando o empty model

Pronto!
Vamos então adicionar duas entidades ao nosso design surface. Estas serão nossas entidades POCO, ou seja, não terão nenhuma dependência do Entity Framework, nem do Linq, nem de nada, é apenas o nosso modelo de classes, vamos ainda desabilitar a geração de código do Visual Studio, para que ele não “polua” as classes:

edmx com 2 entidades

E então clicamos na parte branca do design e abrimos a janela de propriedades para desabilitar a geração de código:

desabilitando geração de código no EF 4.0

Estamos a meio caminho andado. Pode parecer muito trabalho a ser feito, mas isso não leva mais do que 2 minutos. É realmente simples e os resultados são muito bons.
Agora vamos para a parte bacana, codificar nossas classes.
Vamos iniciar codificando as classes Pedido e ItemPedido, que são classes realmente bastante simples:

public class Pedido
{
    public virtual int Id { get; set; }
    private IList<ItemPedido> itens = new List<ItemPedido>();
    public virtual IList<ItemPedido> Itens
    {
        get { return this.itens; }
        set { this.itens = value; }
    }
}
 
public class ItemPedido
{
    public virtual int Id { get; set; }
    public virtual string Produto { get; set; }
    public virtual int Quantidade { get; set; }
    public virtual Pedido Pedido { get; set; }
}

Os virtuais que usamos nas nossas classes são para que o Entity Framework possa fazer o “tracking” dos nossos objetos. Internamente ele criará proxies para nossas classes. Em um primeiro momento basta colocarmos as propriedades como virtual e ele se encarregará de tudo, isso ainda ajudará no Lazy Loading.

Agora, como desabilitamos a geração de código, precisamos também criar o nosso contexto do EF. Isso é bastante simples, e neste cenário nos obrigará a escrever apenas umas 10 linhas de código, como pode ser visto abaixo:

public class EF4Context : ObjectContext
{
    public EF4Context()
        : base("name=EF4Container", "EF4Container") { }
 
    private IObjectSet<Pedido> pedidos;
    public IObjectSet<Pedido> Pedidos
    {
        get
        {
            if (pedidos == null)
                pedidos = CreateObjectSet<Pedido>();
 
            return pedidos;
        }
    }
}

Feito isso nos resta apenas gerar o banco de dados. Como dissemos, geramos primeiro nossas classes, sem nos preocupar em como estes dados seriam armazenados, conseguimos focar puramente no nosso domínio e no nosso modelo, afinal estamos pensando em classes e objetos, e não em linhas/tuplas de banco, chaves, índices, etc.
O Visual Studio irá gerar o código necessário para nosso banco de dados veja abaixo:

gerar banco de dados usando o modelo do EF 4.0

Agora é só executar o SQL gerado:

executando SQL gerado pelo EF 4.0

Se vocês fizeram tudo certinho até o momento, devem ser capazes de executar os seguintes códigos de testes com sucesso:

[TestMethod]
public void Deve_Adicionar_Um_Pedido_No_DB_Usando_Contexto_E_Poco()
{
    var contexto = new EF4Context();
 
    var pedido = new Pedido();
 
    pedido.Itens.Add(new ItemPedido
    {
        Produto = "Novo Produto",
        Quantidade = 5,
        Pedido = pedido
    });
 
    contexto.AddObject("PedidoSet", pedido);
    contexto.SaveChanges();
}

Depois este:

[TestMethod]
public void Deve_Obter_Todos_Os_Pedidos_Do_Banco_Usando_Contexto_E_Pocos()
{
    var contexto = new EF4Context();
 
    var pedidos = contexto.Pedidos.ToList();
 
    Assert.IsTrue(pedidos.Count > 0);
}

E por fim este:

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

[TestMethod]
public void Deve_Selecionar_1_Pedido_Do_Banco_Usando_Contexto_E_Pocos()
{
    var contexto = new EF4Context();
    contexto.ContextOptions.LazyLoadingEnabled = true;
 
    var pedido = contexto.Pedidos
                            .Where(p => p.Id == 1).Single();
 
    Assert.AreEqual(1, pedido.Id);
    Assert.IsTrue(pedido.Itens.Count > 0);
    Assert.AreEqual("Novo Produto", pedido.Itens[0].Produto);
}

Percebam como na linha 5 habilitamos o lazy loading para que as propriedades sejam carregadas no momento em que forem chamadas apenas.

E se fizermos uma consulta no banco de dados, veremos que de fato os dados estão lá:

dados armazenados no banco pelo EF 4.0 usando Pocos

Bom pessoal, é isso.
Esta é uma das funcionalidades presentes no Entity Framework 4.0. É claro que existe muita coisa a ser explorada ainda, e existem muitas coisas a serem feitas ainda, mas é um enorme avanço poder trabalhar com POCOs e utilizar os recursos de uma ferrmenta ORM como o EF. Poder dar “tchau” para os SqlConnection, SqlCommand, ExecuteScalar, etc, é algo realmente incrível.

Espero que tenham gostado. Dúvidas, críticas e sugestões me enviem email ou comentários.

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.

Fala galera, beleza?

Dia 18 a Microsoft anunciou o Silverlight 4 beta, no PDC09. De fato existem muitas features novas nesta versão do Silverlight e uma destas novas features é a captura de Webcam (todas as informações podem ser vistas aqui), e vamos realizar aqui um exemplo básico, baseado no vídeo do Tim Heuer que pode ser visto aqui.

Antes de começarmos vamos instalar as ferramentas necessárias:

Visual Studio 2010 beta 2 - http://msdn.microsoft.com/en-us/vstudio/dd582936.aspx
ou
Visual Web Developer Express beta 2 – http://go.microsoft.com/fwlink/?LinkID=167874

Microsoft Expression Blend para .NET 4 – http://go.microsoft.com/fwlink/?LinkId=169446

Silverlight Beta Tools para Visual Studio 2010 – http://go.microsoft.com/fwlink/?LinkID=177508

Vamos lá pessoal, vamos começar.

Primeiro vou abrir o Blend e então criar um novo projeto silverlight, como mostra a figura abaixo:

Criando projeto Silverlight Blend 4 (ampliar)

Agora vamos criar uma página bem simples, o resultado pode ser visto na imagem abaixo e logo em seguida o código XAML necessário:

Resultado da pagina XAML (ampliar)

<UserControl
	xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
	xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
	x:Class="Teste_com_webcam.MainPage"
	Width="640" Height="480">
 
	<Grid x:Name="LayoutRoot" Background="White">
		<Grid.RowDefinitions>
			<RowDefinition  Height="1*" />
			<RowDefinition Height="7*" />
			<RowDefinition Height="1*" />
		</Grid.RowDefinitions>
 
		<TextBlock Grid.Row="0" FontSize="40" HorizontalAlignment="Center">Webcam</TextBlock>
 
		<Border Background="Black" Grid.Row="1" Width="500" Height="350" CornerRadius="20">
			<Rectangle x:Name="WebCam" Grid.Row="1" Width="480" Height="330"></Rectangle>
		</Border>
 
		<Button x:Name="btnStart"
				Content="Iniciar" 
				Grid.Row="2" 
				Width="100" 
				FontSize="20" />
	</Grid>
</UserControl>

Agora podemos abrir o projeto silverlight no Visual Studio 2010 para que possamos editar o código, conforme mostra a figura abaixo:

Abrir projeto Silverlight no Visual Studio (ampliar)

Agora vamos adicionar o código necessário para que nossa webcam seja capturada. Vamos abrir o arquivo MainPage.xaml.cs e então criar o seguinte código:

CaptureSource captureSource = null;
private void Initialize()
{
    var videoDevice = CaptureDeviceConfiguration.GetAvailableVideoCaptureDevices()[0];
 
    if (captureSource == null)
        captureSource = new CaptureSource();
 
    captureSource.VideoCaptureDevice = videoDevice;
}

Neste código estamos criando um objeto CaptureSource que será responsável por realizar a nossa captura da webcam.
Na linha 4 pegamos o device de captura de vídeo disponível. Como eu só tenho uma webcam, eu vou pegar o primeiro device.
Na linha 9 eu atribuo o meu device para a propriedade de video device do objeto CaptureSource.

Agora precisamos “pintar” nossa webcam dentro da área onde ela será exibida, no nosso caso um simples retângulo no nosso XAML:

private void FillCamera()
{
    var videoBrush = new VideoBrush();
    videoBrush.SetSource(captureSource);
 
    WebCam.Fill = videoBrush;
}

O que fazemos no código acima é criar um VideoBrush que irá utilizar nosso CaptureSource. Então preenchemos nosso rectangle com o videoBrush. Bem simples.

Até agora se rodarmos nosso código nada acontecerá, pois a mágica acontece neste método:

private void StartCamera()
{
    if (CaptureDeviceConfiguration.AllowedDeviceAccess || CaptureDeviceConfiguration.RequestDeviceAccess())
    {
        if (captureSource.State != CaptureState.Started)
            captureSource.Start();
    }
}

Tudo o que fazemos aqui é dizer ao Silverlight para pedir permissão para usar a câmera com o RequestDeviceAccess().
Depois executamos o comando Start() dentro do nosso captureSource, e neste momento o Silverlight irá pedir permissão para o usuário do site e então irá iniciar a exibição do vídeo.

Agora precisamos apenas fazer a chamada para os nossos métodos.
Vamos criar um evento para nosso botão iniciar, para isso faremos uma alteração no contrutor da nossa página e criaremos um método para responder ao evento click do botão, conforme mostrado abaixo:

public MainPage()
{
    InitializeComponent();
    btnStart.Click += new RoutedEventHandler(btnStart_Click);
}
void btnStart_Click(object sender, RoutedEventArgs e)
{
    Initialize();
    FillCamera();
    StartCamera();
}

E podemos ver o resultado nas imagens abaixo:

Silverlight pedindo permissao para usar webcam (ampliar)

Resultado Webcam com silverlight 4 (ampliar)

É isso aê pessoal, qualquer dúvida é só entrar em contato.
Em breve postarei mais informações sobre a nova versão do silverlight.

Att,
Vinicius Quaiato.

Fala Galera!

Alguns de vocês já conheciam os as Parallels Extensions do .NET que eram distribuídas para testes.

Agora no Visual Studo 2010 as Parallels Extensions estão disponívels no framework 4.0.

Vejam abaixo como é simples realizar um laço for de maneira paralela, ou seja, cada iteração do laço será disparada paralelamente à outra:

using System.Threading.Tasks;
 
Parallel.For(0, 100,
        (int i) =>
        {
            Console.WriteLine(i.ToString());
        }
    );

O que acontece é bem simples, passamos o primeiro valor para a iteração (0) e passamos o último valor (100) [note que o 0 é inclusivo e o 100 é exclusivo!].
Como terceiro parâmetro passamos uma Action, que neste caso utilizamos uma lambda que será o corpo do laço.

Simples!

Existem outras ferramentas de suporte à programação paralela. E em breve passarei aqui mais informações!

Algumas outras informações podem ser encontradas aqui: http://channel9.msdn.com/posts/DanielMoth/VS2010-Parallel-Computing-Features-Tour

Faça o Download do Visual Studio 2010 beta 2: http://msdn.microsoft.com/pt-br/vstudio/dd582936.aspx

Abraços,
Vinicius Quaiato.

Fala galera!
Aqui vai mais uma feature incrível no VS2010: Generate from usage.

Para quem realmente gosta e pratica TDD essa é uma mão na roda.

Quando estamos criando nossos testes às vezes os fazemos antes de nossas classes existirem, e o intellisense nas versões anteriores acabavam nos atrapalhando sugerindo classes totalmente sem sentido.
Com o Visual Studio 2010 no momento em que fazemos = new o instellisense já coloca a nossa classe lá, sem ela nem existir veja abaixo:

Generate from usage class stub (clique para ampliar)

Generate menu (clique para ampliar)

É isso aê.
Também é possível fazer exatamente o mesmo com métodos.

Espero ter sido útil!

Faça o Download do Visual Studio 2010 beta 2: http://msdn.microsoft.com/pt-br/vstudio/dd582936.aspx

Abraços,
Vinicius Quaiato.

Fala galera!
Há uma semana estou testando o Visual Studio 2010 beta 2 e em apenas um dia já fiquei fascinado com o mesmo.

Em primeiro lugar o design ficou muito atrativo. Chega daquelas janelas quadradas, cinzas, no estilo windows 98! Agora a coisa é em WPF, moderna, arrojada e com cores mais bonitas e bordas arredondadas.

Gostaria de falar de um recurso muito interessante: Docking de Janelas!
Agora é possível trabalhar com as janelas desplugadas do Visual Studio. Tá, e daí?!
Junte isso com o esquema de docking do Windows 7 e veja abaixo que maravilha é possível fazer:

Janelas dockadas fora do Visual Studio 2010 (clique para ampliar)

Imaginem trabalhar com 2 monitores e 4 dockings desse. É muito código pra ver!!!

É isso aê pessoal, espero que esta dica seja útil e ajude a todos.

Faça o Download do Visual Studio 2010 beta 2: http://msdn.microsoft.com/pt-br/vstudio/dd582936.aspx

Abraços,
Vinicius Quaiato.