Conhecendo o Microsoft “Roslyn” CTP – Parte 1 – Criando um REPL para C#

Olá pessoal. Tudo certo!?

Há alguns anos, falar sobre compilação implicava unicamente em tratar da conversão de arquivos com código-fonte, em determinada linguagem, para outro formato, geralmente executável. O processo de compilação, propriamente dito, era uma “caixa-preta” para a maioria dos desenvolvedores.

Com o advento das IDEs modernas, etapas do processo de compilação começaram a ser executadas antecipadamente. Recursos como “Go To Definition” e “Refactoring” (extremamente populares no Visual Studio) acabam executando operações que fazem parte do processo de compilação. Outro aspecto significativo é a adoção, cada vez mais frequente, de scripting. 

Nesse cenário, surge o projeto Roslyn, da Microsoft. A idéia desse é prover um “Compiler-As-A-Service”. Ou seja, fornecer processamento do compilador e suas estruturas de dados para que o programador possa “interferir” no processo.

O post de hoje é apenas o primeiro de uma série tratando desse projeto.

O que é o Microsoft “Roslyn” CTP?

Trata-se de um projeto que dá uma “idéia” de como será a próxima geração de modelos de objetos para geração, análise, refactoring, scripting e uso interativo para Visual Basic e C#.

Até aqui, para funcionar, precisa do Visual Studio 2010 SP1 instalado, juntamente com seu SDK.

Importante destacar que trata-se de um “technology preview”. Logo, possui uma série de limitações conhecidas e que serão superadas em breve.

Instalação

Se você já está com o Visual Studio 2010 SP1 instalado em seu computador. Certifique-se de seguir os seguintes passos para utilizar o “Roslyn”:

1. Instale o SDK do Visual Studio 2010 SP1;
2. Instale o Microsoft “Roslyn” CTP (com versão de outubro de 2011 no momento em que esse post está sendo escrito).

Primeiros passos

A primeira mudança que irá perceber no seu Visual Studio é o surgimento de alguns novos “protótipos de projeto”. Observe:

Outra mudança importante é o surgimento de um console REPL para C#. Para acessar, clique em View –> Other Windows –> C# Interactive Window.

Bacana, não?!

Repare que, como o “Roslyn” ainda está em desenvolvimento, não oferece suporte para todas as características do C#. Entre as ausências principais, podemos perceber falta de suporte para (fonte no msdn):

• Anonymous types
• Async
• Attributes (full support)
• Base call support
• Checked and unchecked expressions and blocks
• Collection initializers
• Dynamic
• Embedded Interop Types (no-PIA)
• Events
• Expression trees
• Extern aliases
• Finalizers
• Generic constraints
• Indexers
• Iterators
• Lock statements
• Multi-dimensional arrays
• Multi-targeting
• Named and optional parameters
• Nullable types
• Object initializers
• Operator overloading
• Param array parameters
• Partial methods
• Query expressions
• Switch statements
• Type forwarders
• Unsafe code
• User-defined conversions
• Using statement
• WinRT support
• XML documentation file generation

Programando com “Roslyn”

Como disse, o “Roslyn” oferece um conjunto de APIs para diversas fases do processo de compilação. Nesse post, apenas para ilustrar o pontencial do Roslyn, construiremos um pequeno REPL (semelhante ao que acompanha a IDE). Observe:

using System;

using Roslyn.Compilers;
using Roslyn.Scripting.CSharp;
using Roslyn.Scripting;

namespace Roslyn_001
{
    class Program
    {
        static void Main(string[] args)
        {
            var engine = new ScriptEngine();

            var session = Session.Create();
            session.AddReference(
                MetadataReference.Create("System"));
            session.AddReference(
                MetadataReference.Create("System.Core"));
            session.AddReference(
                MetadataReference.Create("System.Data"));
            session.AddReference(
                MetadataReference.Create("System.Data.DataSetExtensions"));

            Console.WriteLine("Roslyn REPL for C#");

            while (true)
            {
                Console.Write(">");
                try
                {
                    var result = engine.Execute(Console.ReadLine(), session);
                    if (result != null)
                        Console.WriteLine("{0}\n", result);
                }
                catch (Exception m)
                {
                    Console.WriteLine("{0}\n", m.ToString());
                }
            }
        }
    }
}

Algumas considerações:

• Utilizei o template “Console Application” do Roslyn. Entretanto, poderia ter começado um projeto padrão adicionando referências para:
• Microsoft.CSharp;
• Roslyn.Compilers;
• Roslyn.Compilers.CSharp.
• Para “interpretar” o código C# que vamos escrever no REPL, utilizamos um objeto ScriptEngine;
• O objeto Session serve para gerenciar o contexto (compartilhar escopo, inclusive);
• O método AddReference serve para possamos adicionar referências para os binários que desejamos utilizar;
• A execução do código ocorre através do método Execute.

Executando,

Era isso.