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.

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.

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, 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.