{"id":243,"date":"2014-04-03T16:00:00","date_gmt":"2014-04-04T00:00:00","guid":{"rendered":"https:\/\/blogs.msdn.microsoft.com\/vbteam\/2014\/04\/03\/taking-a-tour-of-roslyn\/"},"modified":"2024-07-05T12:38:24","modified_gmt":"2024-07-05T19:38:24","slug":"taking-a-tour-of-roslyn","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/vbteam\/taking-a-tour-of-roslyn\/","title":{"rendered":"Taking a tour of Roslyn"},"content":{"rendered":"

It\u2019s a big day for us on the Managed Languages team! As announced at the \/\/BUILD conference earlier today, and as posted by Soma on his blog<\/a>, we are not just delivering a new preview of Roslyn to all of you, but are in fact moving all of the compiler code to open source<\/a>! The code will be released and maintained by MS Open Tech<\/a>, who are our partners in this endeavor. <\/p>\n

The goal of open-sourcing the compilers is something that we\u2019ve been working towards for just over a year, and we\u2019re really excited that it\u2019s finally time to make the \u201cbig reveal.\u201d (Best of all, we no longer have to try to keep a poker face every time we\u2019re asked about whether or not the compilers will ever be open sourced!) And as this momentous day drew closer, I found myself struggling a bit to write a blog post which could capture the enormity of this moment on behalf of our team. Although Microsoft has actively embraced openness as a part of day-to-day operations for quite some time now, it\u2019s nevertheless very difficult to put into words how exciting this<\/i> particular change is for us, given how it takes our participation in the world of open source to an entirely new level. <\/p>\n

In a vain effort to capture all of that emotion, I inflicted (which is really the only word for it) several drafts on my team and my management, none of which really added anything to the basic facts already planned to be revealed in Soma\u2019s blog. Finally, Jay Schmelzer (our PM director) took me aside and wisely said, \u201cLook, we\u2019ve got your back on the \u2018big reveal;\u2019 don\u2019t worry about that. Why don\u2019t you take everyone the rest of the way and show us how it actually works<\/i>?\u201d<\/p>\n

Of course, he was exactly right, and so, here we go\u2026<\/p>\n

Installing the preview<\/h2>\n

Before jumping into the open source code, you should first install the Roslyn preview. To do this, follow these steps:<\/p>\n

(1) Browse to the preview site<\/a>. You\u2019ll be asked to sign in with a Microsoft account (and will have the opportunity to create a free one if you don\u2019t have one already).<\/p>\n

(2) Once you are signed in, you\u2019ll be taken to a survey page, where you will just need to fill in your name, preferred e-mail address, and country \u2013 this is just so we can stay in touch with folks installing the preview in order to get feedback from them and send new information to them.<\/p>\n

(3) After filling out the survey, your Microsoft account will be given permission to access the preview. A \u201cThank you\u201d page will appear; click the Go to .NET Compiler Platform (\u201cRoslyn\u201d)<\/b> link that appears on it, as shown here:<\/p>\n

\"clip_image001\"<\/a><\/p>\n

(4) The .NET Compiler Platforms (\u201cRoslyn\u201d) main page will be presented to you with a couple of options, as shown here:<\/p>\n

\"clip_image002\"<\/a><\/p>\n

Click the \u201cDownload\u201d button. This will take you to a standard Connect download details page that describes the download and shows the options for obtaining it. Click the Download button on that page to actually download the preview.<\/p>\n

\"clip_image003\"<\/a><\/p>\n

(5) Once downloaded, now you can install it! The team has worked hard to make the installation as absolutely quick and painless as possible. After downloading & running it, you\u2019ll be presented with the following dialog:<\/p>\n

\"clip_image004\"<\/a><\/p>\n

Clicking \u201cInstall\u201d will cause the older compiler & IDE pieces in Visual Studio to be turned off and the Roslyn versions to be installed and turned on in their place. This takes mere seconds to complete. (The old pieces are not deleted, so if you choose to uninstall the VSIX, you\u2019ll safely revert back to using them.)<\/p>\n

(6) Once the installation is finished, you\u2019ll need to restart your instance of Visual Studio (assuming it was open during the installation).<\/p>\n

\"clip_image005\"<\/a><\/p>\n

After installing & relaunching Visual Studio, you should now be able to see Roslyn-specific improvements. For example, consider the following reasonably-common code in C#:<\/p>\n

        <\/span>static void <\/span>Main(<\/span>string<\/span>[] args)\r\n        {\r\n            <\/span>int <\/span>n1;\r\n            <\/span>if <\/span>(<\/span>int<\/span>.TryParse(args[0], <\/span>out <\/span>n1))\r\n            {\r\n                <\/span>Console<\/span>.WriteLine(n1);\r\n            }\r\n        }<\/span><\/pre>\n
Using one of the new language features in Roslyn (inline declaration expressions), you can now simplify this to:<\/p>\n
        <\/span>static void <\/span>Main(<\/span>string<\/span>[] args)\r\n        {\r\n            <\/span>if <\/span>(<\/span>int<\/span>.TryParse(args[0], <\/span>out var <\/span>n1))\r\n            {\r\n                <\/span>Console<\/span>.WriteLine(n1);\r\n            }\r\n        }\r\n    }<\/span><\/pre>\n
An example for VB which demonstrates a new feature would be:<\/p>\n
\n
    <\/span>Sub <\/span>Main()\r\n        <\/span>Dim <\/span>s <\/span>As String <\/span>= <\/span>\"This is a multiline\r\n            string literal.\"\r\n    <\/span>End Sub<\/span><\/pre>\n<\/blockquote>\n
which was impossible using the old VB compiler.<\/p>\n
Your older projects should build fine against the new compilers (obviously, speak up if they don\u2019t!), though you should be aware that any changes you make to them which use the new language features won\u2019t work if you uninstall the preview.<\/p>\n
Beyond examples of how the language is evolving, the Roslyn preview also showcases many examples of how we are using the new Roslyn compilers to provide stronger IDE functionality. One of my personal favorites is inline renaming: select any symbol or method name, right-click and choose Rename<\/b> (or just press F2), and start typing a new name right in the program file. Your name changes will be reflected instantly throughout all uses of that name in your solution, all at once, without affecting any other symbols\/methods that coincidentally have the same name but in a different context.<\/p>\n
\"clip_image006\"<\/a><\/p>\n
In this case, there is no guessing about which names refer to the same symbol; that information is known and exposed, without having to resort to string comparisons bolted on top of the text buffer (as used to be the case), all thanks to the new compilers.<\/p>\n
Here\u2019s the fine print: please be aware the set of features that end up in the final version is subject to change before an official version is released \u2013 features can and will be added, removed, or modified in the interim, often due to getting feedback from you<\/i> as to what works and what needs to be improved (see the end of this post for details on how to give feedback). Similarly, the language features showcased in the preview are not locked down, and should be viewed as examples of things that are being considered for the final version. Finally, you may sometimes notice that one language might showcase an IDE or language feature in the preview while the other language doesn\u2019t. You shouldn\u2019t worry about that; although it might be because a given feature simply doesn\u2019t make sense for the other language, it\u2019s far more likely that the developers just haven\u2019t gotten around to it yet, as such things are generally implemented serially from one language to the other. (FWIW, I\u2019m already planning to go into more detail as to how features are vetted and scheduled in a future blog post, in case anyone is curious about that.)<\/p>\n
Enlisting in the open source project<\/h2>\n
Now, if you\u2019d like to take it a step further, you can enlist in the open source project to view and experiment with the code yourself. Here are a couple of important points:<\/p>\n