Analiza kodu za pomocą LINQ to chyba esencja Roslyn.  Bez Roslyn, kod był dla nas jak zwykły tekst (string) i w przypadku jakiejkolwiek analizy, musieliśmy sami parsować tekst i rozpoznawać odpowiednie fragmenty.

Najpierw tworzymy SyntaxTree za pomocą zwykłego tekstu:

SyntaxTree tree = CSharpSyntaxTree.ParseText(@"
    public class Class1
    {
        public void TestMethod1()
        {
        }
    }
public class Class2
    {
        public void TestMethod2()
        {
        }
    }
");

SyntaxNode root = tree.GetRoot();

Metoda DescendantNodes zwraca wszystkich potomków, również tych niebezpośrednich. Jeśli chcemy zwrócić wszystkie klasy wystarczy szukać węzłów typu ClassDecelarionSyntax:

foreach (ClassDeclarationSyntax classDeclarationSyntax in root.DescendantNodes().OfType<ClassDeclarationSyntax>())
{

    Console.WriteLine(classDeclarationSyntax.Identifier);
}

Analogicznie, w celu wyświetlenia metod wystarczy:

foreach(ClassDeclarationSyntax classDeclarationSyntax in root.DescendantNodes().OfType<ClassDeclarationSyntax>())
{
    Console.WriteLine(classDeclarationSyntax.Identifier);

    foreach (var method in classDeclarationSyntax.DescendantNodes().OfType<MethodDeclarationSyntax>())
    {
        Console.WriteLine("\t{0}",method.Identifier);
    }
}

Jak wspomniałem, DescendantNodes zwraca wszystkich potomków więc możemy wyświetlić metody bezpośrednio korzystając z korzenia:

foreach (MethodDeclarationSyntax methodDeclarationSyntax in root.DescendantNodes().OfType<MethodDeclarationSyntax>())
{

    Console.WriteLine(methodDeclarationSyntax.Identifier);       
}

Jeśli chcemy tylko bezpośrednich potomków (czyli dzieci) wtedy korzystamy z ChildNodes:

foreach (MethodDeclarationSyntax methodDeclarationSyntax in root.ChildNodes().OfType<MethodDeclarationSyntax>())
{
    Console.WriteLine(methodDeclarationSyntax.Identifier);       
}

Zmodyfikujmy trochę kod, aby zawierał metodę z parametrami:

SyntaxTree tree = CSharpSyntaxTree.ParseText(@"
    public class Class1
    {
        public void TestMethod1()
        {
        }

         public void TestMethod1(string a, string b, int c)
        {
        }
    }
");

Zapytanie zwracające wszystkie metody, które zawierają parametry to:

SyntaxNode root = tree.GetRoot();

MethodDeclarationSyntax methodWithPars = root.DescendantNodes().OfType<MethodDeclarationSyntax>().First(n => n.ParameterList.Parameters.Any());
Console.WriteLine(methodWithPars.Identifier);

Wyświetlenie parametrów sprowadza się do prostej pętli:

foreach (var par in methodWithPars.ParameterList.Parameters)
{
    Console.WriteLine(par.ToString());
}

Często potrzebujemy pójść w drugą strony, to znaczy mamy wskaźnik na potomka, ale chcemy znaleźć rodzica. Do dyspozycji mamy metodę Ancestors:

foreach (var par in methodWithPars.ParameterList.Parameters)
{
    string className = par.Ancestors().OfType<ClassDeclarationSyntax>().Single().Identifier.ToString();
    Console.WriteLine("{0}:{1}",className,par.ToString());
}

Za pomocą LINQ możemy uzyskać dostęp do każdego fragmentu kodu, nie tylko deklaracji. Możemy np. wylistować IF”Y:

            SyntaxTree tree = CSharpSyntaxTree.ParseText(@"
    public class Class1
    {
        public void TestMethod1()
        {
        }

         public void TestMethod1(string a, string b, int c)
        {
            if(c==5
            {
            }
        }
    }
");

SyntaxNode root = tree.GetRoot();

var ifStatements = root.DescendantNodes().OfType<IfStatementSyntax>();

foreach (var ifStatementSyntax in ifStatements)
{
    Console.WriteLine(ifStatementSyntax.ToString());
}

Analogicznie sprawa wygląda z wywołaniami metod, klauzulami using, switch\case, pętlami, zwracaniem wartości jak i z KAŻDYM elementem kodu. Innymi słowy drzewo jest na tyle szczegółowe, że “bez problemu” możemy napisać konwerter z C# na jakikolwiek inny język np. JavaScript, bez konieczności ręcznego parsowania kodu C#.

W poprzednim wpisie, w dużym skrócie przedstawiłem po co powstał Roslyn i komu może przydać się. W kilku kolejnych postach, zaprezentuję w praktyce jego najważniejsze funkcje.

Zaczynami od scripting API.  APi szczególnie przydatne w przypadku edytorów do gier czy bardziej zaawansowanych reguł biznesowych. Zacznijmy od klasycznego “hello world”:

CSharpScript.Run("System.Console.WriteLine(\"Hello world\")");

Nie trudno domyślić się, że Run wykona kod przekazany jako String – w tym przypadku jest to po prostu wyświetlenie napisu na ekranie.

Zwykle chcemy jednak zmodyfikować jakieś zmienne:

ScriptState result=CSharpScript.Run("int a=5;int b=5; int c=a+b;");

foreach (ScriptVariable scriptVariable in result.Variables)
{
    Console.WriteLine(string.Format("{0}:{1}", scriptVariable.Name, scriptVariable.Value));
}

Pole Variable będzie zawierać wszelkie zmienne stworzone w skrypcie, wraz z ich wartościami. W tym przypadku będzie to “a:5,b:5,c:10”.

Możliwe jest również przekazywanie parametrów do skryptu. Stwórzmy dowolną strukturę:

public class Data
{
    public int Number = 5;
}

Następnie wykonanie skryptu będzie wyglądać następująco:

var data = new Data();

CSharpScript.Run("Number=Number*2", data);

Console.WriteLine(data.Number);

Zmienna Number zostanie przekazana z wartością 5, a potem w skrypcie zostanie zmieniona na 10 i zwrócona na zewnątrz. W skrócie jest to argument wejściowo-wyjściowy.

Inna przydatna funkcja to Eval. Uruchamia ona po prostu skrypt i zwraca od razu to co znajduje się w nim na wyjściu. Na przykład, poniższy kod zwróci losowo wygenerowaną liczbę:

object result = CSharpScript.Eval("new Random().Next()");

Console.WriteLine(result.ToString());

To samo można oczywiście osiągnąć za pomocą Run, ale Eval w wielu sytuacjach jest bardziej intuicyjny w użyciu. Zarówno do Eval jak i Run można przekazać ScriptOptions. Bardzo często skrypty potrzebują referencji do zewnętrznych bibliotek i wtedy możemy:

ScriptOptions options = ScriptOptions.Default
    .AddReferences(Assembly.GetAssembly(typeof(Path)))
    .AddNamespaces("System.IO");
var currentDir = CSharpScript.Eval(@"Path.GetCurrentDirectory()", options);

Bardzo ciekawą opcją jest skompilowanie skryptu i użycie potem go jako zwykłej delegaty:

ScriptState state = CSharpScript.Run("int Add(int x,int y) { return x +y; }");
var add = state.CreateDelegate<Func<int, int,int>>("Add");
var sum = add(5, 10);
Console.Write(sum);  // 15

O projekcie Roslyn od dawna już słychać, ale jeszcze nigdy nie miałem okazji z niego poważnie korzystać, ani wspomnieć o tym na blogu.

Czym jest więc Roslyn? W skrócie pisząc jest to “compiler as service”. Roslyn dostarcza API za pomocą, którego możemy komunikować się kompilatorem.  Możemy zatem pisać programy, które rozpoznają kod (C#) i mogą go dynamicznie wykonywać. Innymi słowy, dzięki Roslyn jesteśmy w stanie załadować kod w formie czystego tekstu i w pamięci analizować go  już jako strukturę danych czyli drzewo. Dzięki temu odczytanie jakiekolwiek elementu kodu (nazwa klasy, warunek, modyfikator) jest bardzo proste i sprowadza się do wyrażenia LINQ na tej strukturze danych.

Załóżmy, że mamy następujący kod:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Policy;
using System.Text;
using System.Threading.Tasks;

namespace ClassLibrary1
{
    public class Class1
    {
        public void Test(int argument)
        {
            if (argument > 10)
            {

            }
            else
            {
                throw new Exception();
            }
        }
    }
}

Instalując Roslyn, Visual Studio zostanie zintegrowany również z Roslyn Syntaax Visualizer – proste narzędzie wyświetlające kod w formie drzewa. Dla powyższego kodu, drzewo wygląda następująco:

Widzimy, że każdy nawet najmniejszy element posiada własną strukturę typu ClassDeclartion czy UsingDirective. Za pomocą LINQ możemy odczytać każdy szczegół.

Podczas pracy z Roslyn, pojawi się wiele terminów określających powyższe węzły. Pierwszym z nich jest SyntaxTree czyli wspomniane drzewo prezentujące dany fragment kodu (np. plik cs).

SyntaxNode to z kolei węzeł typu ClassDeclaration czy MethodDeclaration. Klasa czyli “class NazwaKlasy” stanowi ClassDeclarion. Analogicznie sygnatura metody to MethodDeclartion.

SyntaxToken to jeszcze mniejszy element drzewa. Technicznie jest to liść czyli węzeł bez dzieci. Jak wspomniałem, ClassDeclartion to np. “class NazwaKlasy {“ z kolei SyntaToken  dla tego węzła to “class”, “NazwaKlasy” oraz “{“. Widzimy, że SyntaToken to najdrobniejszy element i nie da go robić się na mniejsze.

SyntaxTrivia z kolei to najmniej znaczący element i może być nim spacja, koniec linii czy komentarz.

Za pomocą Roslyn, możemy zatem robić wszystko z kodem, co wymagało wcześniej własnego parsera czyli analizowanie kodu, wykonywanie poszczególnych części czy nawet odczytywanie konkretnych projektów w solucji (tzw. Workspaces API). Roslyn Scripting API dostarcza mechanizm  dynamicznego wykonywania kodu. Możemy przekazać po prostu kod jako tekst i zostanie on wykonany.

Nie wszystkim jednak Roslyn przyda się. Oczywiście największą grupą odbiorców będą twórcy narzędzi programistycznych. Liczenie metryk kodu czy analiza jakości kodu (CodeAnalysis, nDepend) zostanie uproszczona. Analogicznie wszelkie generatory kodu będą mogły teraz być tworzone za pomocą API.

Również aplikacje wykorzystujące C# jako język skryptowy staną się dużo łatwiejsze w implementacji. Na przykład twórcy gier komputerowych często wymagają podobnej funkcjonalności w edytorach dla AI.

Moim zdaniem dla większości programistów jest to ciekawostka, która jednak będzie miały ogromny wpływ na .NET jak i narzędzia, które będą powstawać. W aplikacjach biznesowych używanie Roslyn w czystej postaci raczej nie będzie zbyt częstym scenariuszem, aczkolwiek jestem w stanie wyobrazić sobie wiele sytuacji, gdzie jest to bardzo przydatne (np. silniki reguł biznesowych). Jak wspomniałem jednak, zwykle te aplikacje biznesowe korzystają z gotowych komponentów, które z kolei bardzo prawdopodobne będą bazowały na Roslyn.

W kolejnych postach, przyjrzyjmy się szczegółom API…