Roslyn e o futuro

Uma das perguntas que ficaram no ar quando escrevi sobre projeto Roslyn em um post anterior foi: qual a real utilidade do projeto; qual a motivação; o que podemos fazer com ele? É mais um daqueles clichês que dizem que não estávamos encontrando a resposta certa por não estar fazendo a pergunta certa. Talvez a pergunta certa esteja na necessidade e não no objetivo.

Acredito que, em certo ponto, a Microsoft percebeu que para evoluir com C# e Visual Basic seria melhor recomeçar, reescrever o compilador, utilizar uma nova abordagem (CaaS – compiler as a service). É muito provável que o grande beneficiado pelo projeto Roslyn será a própria linguagem (o que ela será capaz de suportar em termos de features) do que propriamente o ferramental que será construído em volta do compilador.

Uma grande luz para essa questão está na apresentação The Future of C# [e Visual Basic] que aconteceu no BUILD 2014. Se você ainda está um pouco confuso sobre os reais benefícios que virão com o projeto Roslyn, sugiro fortemente assistir essa apresentação. A primeira parte é feita por Dustin Campbell, onde ele demonstra um pouco de como a IDE vai ser beneficiada com o projeto Roslyn. A segunda parte da apresentação (~ 31:00) é feita por Mads Torgersen, onde ele mostra como as linguagens poderão evoluir graças ao projeto.

the-future-of-csharp

Anúncios

O que é o projeto Roslyn

O projeto Roslyn é uma forma de repensar o compilador do C# e VB de forma modularizada. Dessa forma, o compilador deixa de ser uma caixa preta e passa a transparecer todos os processos de compilação. Desenvolvedores passam a ter acesso a todas as bibliotecas utilizadas pelo compilador. Literalmente, esses compiladores estão sendo reescritos. Por exemplo, o código fonte do projeto csc.exe que está sendo reescrito no projeto Roslyn (rcsc.exe) pode ser encontrado aqui. É o compilador de C# escrito em C#.

Indiretamente, podemos esperar novas ferramentas surgindo para análise de código e refatoração; talvez um Visual Studio mais inteligentes, quem sabe? Você poderia citar mais exemplos?

O código fonte está sendo distribuído através da licença Apache License 2.0 e está disponível no codeplex.

Roslyn é apenas um codinome para o projeto, já deu para perceber que a Microsoft chamará esse conjunto de bibliotecas e ferramentas de .NET Compiler Platform.

Exemplo

Como exemplo, criei um projeto Console em C# e adicionei o pacote NuGet para o Roslyn da seguinte forma:

PM> Install-Package Microsoft.CodeAnalysis -Pre

Depois adicionei o seguinte trecho de código:

using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;

namespace RoslynConsole
{
    class Program
    {
        static void Main(string[] args)
        {
            SyntaxTree tree = CSharpSyntaxTree.ParseText(@"
using System;
using System.Collections.Generic;
using System.Text; 

namespace HelloWorld  {
    class Program {
        static void Main(string[] args) {
            Console.WriteLine(""Hello, World!"");
        }
    }
}");

            var root = tree.GetRoot() as CompilationUnitSyntax;

            var compilation = CSharpCompilation.Create("HelloWorld")
                .AddReferences(new MetadataFileReference(typeof(object).Assembly.Location))
                .AddSyntaxTrees(tree);

            var semanticModel = compilation.GetSemanticModel(tree);
        }
    }
}

Note que foi necessário adicionar uma referência ao assembly mscorelib.dll através da expressão:

typeof(object).Assembly.Location

O objeto root (CompilationUnitSyntax) representa a árvore sintática do código. Você pode usar para navegar pelo código: quais os namespaces, quais classes estão dentro desse namespace, quais métodos da classe, etc.

O objeto compilation (CSharpCompilation) representa uma compilação do código e através dele é possível ter acesso a análise semântica do código (semanticModel). Segundo a documentação, é possível responder perguntas tais como: quais membros são acessíveis a partir de algum método?

Uma observação interessante é que o objeto compilation é imutável, e funciona sob demanda. A partir do momento que você vai acessando suas propriedades ele vai compilando o que for necessário. Não é possível alterar o compilation, apenas criar um novo a partir de um existente, o que possibilita reutilizar o que for possível.

Esse exemplo que coloquei é apenas um pedaço do exemplo citado no artigo Getting Started: Semantic Analysis. Leia lá para mais detalhes.

StyleCop no Visual Studio 2013

Update – 25.11.2013

andyr liberou, nesse final de semana, mais uma versão do StyleCop. Agora, com suporte oficial ao Visual Studio 2013.

Update – 30.10.2013

O usuário csdahlberg criou uma branch do StyleCop que da suporte ao Visual Studio 2013. Ele disponibiliza uma versão compilada nesse link.

StyleCop

StyleCop é uma ferramenta desenvolvida por um funcionário da Microsoft chamado Jason Allor com o intuito de ajudar a padronizar o estilo de escrita de código C#.  Hoje a Microsoft não responde mais pela ferramenta e essa responsabilidade foi delegada para a comunidade. As regras do StyleCop incluem documentação de código, nomenclaturas, espaçamento, entre outras. A lista completa com todas as regras podem ser encontradas aqui.

Manter o código organizado e padronizado quando você trabalha sozinho pode ser possível, com um time de duas ou três pessoas pode ser viável, mas com qualquer número maior que esse, fatalmente você vai acabar precisando de uma ferramenta como o StyleCop. Com ela, a validação da qualidade do código pode ser feita de forma automática.

StyleCop no Visual Studio 2013

Infelizmente, ainda não está disponível uma extensão do StyleCop para Visual Studio 2013 Preview. Mas, felizmente, você pode integrar ao projeto utilizando um pacote do NuGet chamado StyleCop.MSBuild. Basta adicionar ao projeto como você faria com qualquer outro pacote e na próxima vez que você tentar compilar o projeto o Visual Studio apresentará todos os warnings referentes ao StyleCop.

stylecop2

O StyleCop acompanha um arquivo de settings que contém todas as regras que você deseja utilizar no seu projeto, você pode facilmente editar esse arquivo utilizando uma ferramenta chamada StyleCop Settings Editor. Quando você baixar o pacote a ferramenta ficará instalada em “.\packages\StyleCop.MSBuild.4.7.45.0\tools\”. Basta executar a ferramenta passando o arquivo de configuração como parâmetro da seguinte forma:

> StyleCopSettingsEditor.exe Settings.StyleCop

stylecopPara mim, a melhor forma é copiar o arquivo de configuração da pasta packages para o mesmo nível do arquivo da solução. Dessa forma você pode subi-lo para o controle de versão, uma vez que o pacote do NuGet não precisa ficar versionado. Se você precisar de regras específicas para cada projeto, basta copiar o arquivo para dentro da pasta do projeto, assim você terá um arquivo de settings diferente para cada projeto.

Visual Studio 2013 IDE

Programa Visual Studio Toolbox do Channel 9 mostrando o que está vindo de novidade na IDE do Visual Studio.

visual studio ide video preview

Vale salientar que já é possível baixar a versão 2013 Preview. Por ser um preview, você pode baixar qualquer edição (Professional, Premium, etc) mesmo sem ter a assinatura MSDN, mas também já está disponível a versão Express que continuará sendo gratuita.

Visual Studio 2012 Update 2

CoffeeScript no Visual Studio 2010

UPDATE: Instale o Mindscape Web Workbench e seja feliz! No entanto, a última dica ainda está valendo!

CoffeScript é realmente uma linguagem de programação fantástica. Ela permite gerar códigos JavaScript eficientes, sem erros, elegantes e que passam sem nenhum aviso no JSLint. Eu não pretendo ensinar nada aqui sobre CoffeeScript, meu intuito é economizar um pouco de esforço da sua parte caso pretenda utilizar CoffeScript com o Visual Studio 2010. Já existe muito material na internet. Gostei muito do curso da CodeSchool.

Considerações sobre o Visual Studio com o CoffeeScript

1) A IDE não oferece suporte nativo;
2) Existe um plugin chamado Chirpy, mas ele ainda está na versão beta e apresenta MUITOS problemas;
3) O formato de codificação do arquivo do Visual Studio não é suportado pelo CoffeeScript (vou explicar).

Conversando com algumas pessoas que usam CoffeeScript em projetos reais, verifiquei que a maioria resolveu sair da IDE e escrever o código em outra ferramenta. Como sou cabeça dura, continuei tentando e acredito ter achado o maior problema: a codificação do arquivo (encoding).

Resolvendo o problema da codificação do arquivo

Por padrão o Visual Studio salva seus arquivos no formato UTF-8 com assinatura (UTF-8 with signature). Esse tipo de codificação coloca um caractere no início do arquivo que faz o CoffeeScript se perder. Então, por exemplo, se você começar o código com a palavra reservada class, ele não vai reconhecer que class é uma palavra reservada e vai pensar que você esta tentando chamar uma função chamada class. Estranho, não? Mas isso acontece.

Para resolver o problema, você precisa alterar a forma que o arquivo está sendo salvo. Isso é possível através do menu File > Advanced Save Options. Nessa janela você pode escolher que quer salvar o arquivo no formato UTF-8 without  signature. Isso resolve o problema de possibilitar a edição do arquivo dentro do próprio Visual Studio.

Resolvendo o problema da falta de Syntax Highlighting

Esse problema é fácil de resolver, basta instalar uma extensão do Visual Studio chamada CoffeeLite. Ele pode ser instalado através do menu Tools > Extension Manager.

Resolvendo o problema da compilação

Testei várias soluções, a que me pareceu mais viável foi utilizar o compilador oficial, instalado da forma tradicional. Isso mesmo, instala o NodeJS, instala o NPM (Node Package Manager) e usa o NPM para instalar o CoffeeScript. É a melhor forma, mais segura e você sempre vai estar atualizado. É melhor seguir as instruções no site.

Uma vez que você tenha o CoffeeScript rodando e devidamente configurado, vamos acoplá-lo ao Visual Studio. Bom, não exatamente! Bem, nós não vamos. Existe uma forma mais leve e menos custosa para a IDE e para nós mesmo. Se você tiver uma solução melhor, ficarei muito feliz em saber.

O CoffeeScript tem um comando que permite monitorar uma pasta do sistema de arquivos e toda vez que um arquivo for alterado (quando você clicar ctrl+s no Visual Studio) esse arquivo vai ser processado pelo CoffeeScript e será gerado o devido arquivo .js a partir do .coffee. Qual é esse comando? Se você executar ele a partir da raiz do projeto, ele se parecerá com o seguinte:

coffee -o ./Scripts -cw ./Scripts/

Se você quiser ser prático, pode encapsular esse comando dentro de um arquivo monitor.cmd. Com isso, sempre que você for editar seus arquivos .coffee, você pode por esse comando para rodar e deixa ele executando em background. Lembre-se de adicionar o arquivo .js gerado para fazer parte do projeto, assim como o arquivo .coffee. Isso só precisa ser feito uma vez, claro.

Como resolver o problema da hierarquia de arquivos

Se você for uma pessoa organizada, não vai querer deixar seus arquivo .coffee e .js desvinculados, como se não existisse nenhuma relação entre eles. Para resolver esse problema, podemos fazer uso de um recurso do arquivo de projeto chamado DependentUpon. É um tag XML do arquivo de projeto que permite criar uma hierarquia entre os arquivos. Edite seu arquivo de projeto (exemplo: algumacoisa.csproj), localize onde o arquivo .js está adicionado e altere para que ele se pareça com o seguinte:

Observe que não precisa colocar o caminho completo do arquivo .coffee, apenas o nome do arquivo com a extensão.  A IDE já sabe que eles precisam estar na mesma pasta. Uma vez que o arquivo de projeto tenha sido alterado, ele vai se parecer bastante com isso no seu Solution Explorer.

Dica extra

Se quiser mais uma dica, lá vai. Muitas pessoas gostam de ir digitando o código CoffeeScript e ir acompanhando o código .js sendo gerado a medica que ele é salvo. Se você tentar deixar o arquivo aberto no Visual Studio, toda vez que ele for alterado a IDE vai ficar enchendo seu saco com uma mensagem avisando que o arquivo foi alterado. E você vai ter que ficar perdendo o foco para clicar em OK.

Felizmente o Visual Studio tem uma opção que permite que você desabilite essa mensagem, deixando que o arquivo seja carregado “automagicamente”. Onde fica essa opção? Fica no menu Tools > Options, lá dentro vai em Environment > Documents. A imagem a seguir ilustra onde fazer essa configuração.

Agora você pode ser um desenvolvedor CoffeScript, que usa Visual Studio e é feliz.

Abraço!

Tempo de compilação no Visual Studio

O Visual Studio utiliza o msbuild para compilação dos projetos e soluções. Essa ferramenta possibilita que seja exibido o tempo de compilação de cada projeto separadamente. Vou mostrar onde você pode configurar o Visual Studio para habilitar essa opção e como fazer para exibir o tempo total de compilação da solução.

EXIBINDO O TEMPO DE COMPILAÇÃO PARA CADA PROJETO

Navegue no menu Tools > Options e abra o painel Projects and Solutions > Build and Run. Lá dentro você encontrará o nível de detalhamento da mensagem na janela de saída. O padrão é Minimal, se você alterar para Normal o msbuild passará a exibir uma quantidade maior de informações sobre a compilação, entre elas a duração.

EXIBINDO O TEMPO DE COMPILAÇÃO DA SOLUÇÃO

Infelizmente o msbuild não traz uma forma pronta para exibir o tempo total de compilação da solução. No entanto, consegui encontrar uma alternativa no stackoverflow que faz uso das macros do Visual Studio. Basta acrescentar um código a uma macro já existente e a IDE passará a exibir “automagicamente” o tempo gasto para compilar toda a solução conforme ilustrado abaixo.

Para adicionar o código a macro, você precisar abrir a IDE através do menu Tools > Macros > Macros IDE.

No projeto MyMacros, clique o botão direito e adicione uma referência a System.Windows.Forms. Agora basta copiar o código informado abaixo e colar no arquivo EnvironmentEvents no local informado no figura.

    Dim buildStart As Date

    Private Function IsBuild(ByVal scope As EnvDTE.vsBuildScope, ByVal action As EnvDTE.vsBuildAction) As Boolean
        Return scope = vsBuildScope.vsBuildScopeSolution AndAlso (action = vsBuildAction.vsBuildActionBuild OrElse action = vsBuildAction.vsBuildActionRebuildAll)
    End Function

    Private Sub BuildEvents_OnBuildBegin(ByVal Scope As EnvDTE.vsBuildScope, ByVal Action As EnvDTE.vsBuildAction) Handles BuildEvents.OnBuildBegin
        If (IsBuild(Scope, Action)) Then
            buildStart = Date.Now
        End If
    End Sub

    Private Sub BuildEvents_OnBuildDone(ByVal Scope As EnvDTE.vsBuildScope, ByVal Action As EnvDTE.vsBuildAction) Handles BuildEvents.OnBuildDone
        If (IsBuild(Scope, Action)) Then
            Dim buildTime = Date.Now - buildStart
            WriteToBuildWindow(System.Environment.NewLine)
            WriteToBuildWindow(String.Format("Build time: {0}", buildTime.ToString))
            WriteToBuildWindow(System.Environment.NewLine)
        End If
    End Sub

    Private Sub WriteToBuildWindow(ByVal message As String)
        Dim win As Window = DTE.Windows.Item(EnvDTE.Constants.vsWindowKindOutput)
        Dim ow As OutputWindow = CType(win.Object, OutputWindow)
        For Each owPane As OutputWindowPane In ow.OutputWindowPanes
            If (owPane.Name.Equals("Build")) Then
                owPane.OutputString(message)
                Exit For
            End If
        Next
    End Sub
%d blogueiros gostam disto: