Mar 28, 2018

Recursos para se manter atualizado com a linguagem C#

Read this post in English.

Olá

É surpreendente a quantidade de informações que temos a nossa disposição atualmente. Quando eu comecei a estudar programação (a alguns anos atrás :) ), informação sobre programação era muito limitada (morar em uma pequena cidade do interior de São Paulo e não ser capaz de ler nada em Inglês não ajudava muito).

A situação não melhorou muito quando entrei na universidade (3 ~ 4 anos após meu primeiro contato com um clone do Apple IIe); sem dúvida eu tinha acesso a mais livros, mas os mesmos eram em inglês (que eu ainda tinha muita dificuldade em ler por sinal) e também não cobriam uma ampla gama de assuntos da área.

Para nossa sorte (ou não), atualmente temos tanta informação disponível que temos dificuldade para acompanhar as novidades o que nos traz ao tema deste post: Neste mar de informações disponíveis temos que nos concentrar nas que podem nos proporcionar o melhor retorno pelo nosso investimo.

Se tratando da linguagem C#, para mim, do ponto de vista do desenvolvimento da mesma, todos desenvolvedor C# deveriam, pelo menos, conhecer o repositório https://github.com/dotnet/csharplang, o qual se auto denomina, o "repositório oficial para o design da linguagem C#"

Neste repositório você pode encontrar documentação relativa a funcionalidades existentes, e mais importante (em minha opinião), ainda em desenvolvimento (por exemplo, recentemente documentos referentes a algumas 
funcionalides da próxima versão da linguagem (7.3)  foram publicados). 

Lá você também encontra documentos sobre as várias reuniões de design da linguagem.(aqui você pode ver um vídeo, em inglês, descrevendo o processo de design e como você pode usar este repositório).

O mais interessante é que não estamos limitados a apenas consumir passivamente o conteúdo deste o repositório; como o mesmo é aberto qualquer um pode enviar sugestões de novas funcionalidades para a linguagem bem como participar de discussões sobre os vários recursos em desenvolvimento.

Happy coding ;)

Adriano

Keeping up with C# development

Leia este post em português

Hi

it is amazing how much information we have available nowadays. I remember when I started studding programming (some 30 years ago :) ), it was really hard to find information (ok, I used to live in a small city in Brazil and could not read English at all, but still, there were not a lot of information available about computers / programming). 

The situation did not improve much when I went to college (3 ~ 4 years after my first contact with an amazing Apple II clone); surely I had access to more books but unfortunately most of them were in English, and did not cover much ground (at least the ones I had available).

Luckily, nowadays we have plenty of information available (actually much more than what any single person can imagine consuming), which bring us to the topic of this post: As a C# developers we have some great resources at our disposal; from the language development perspective, in my opinion, every C# developer should, at least, be aware  of https://github.com/dotnet/csharplang, in their own words, the "official repo for C# language design"

In that repository you can find documentation about existing and, most interesting, 
under development, language features. As an example, recently design documents for the upcoming C# 7.3 version have been pushed). There we can also find documents for each of the Design Meetings which can be invaluable information for those interested in following the language evolution more closely (here you can find a video describing the design process and how that repo is used).

Notice that you are not limited to consuming information. Since that repository is open, anyone can participate and add his/her own suggestions.

To summarize, if you are interested in following the development of C#, you should definitely keep an eye on that.

Happy codding.

Adriano

Mar 22, 2018

Experimentando com código C# online

Read this post in english

Olá

Se você trabalha com C# é provável que, assim como eu, você acabe criando vários projetos apenas para testar o comportamento de certos trechos de código. Se este é o seu  caso,  recomendo fortemente utilizar um Compilador C# Online, basicamente uma página na Web onde você pode digitar trechos de código C# e o mesmo será compilado / executado.

Dentre várias opções existentes, uma que me impressionou (e continua a impressionar) é o sharplab.io o qual possui várias funcionalidades (as quais descrevo brevemente abaixo) além do básico compilar/executar programas C# .

Seleção de versão do compilador a utilizar (baseado nas branches do github)

Se você acompanha o a evolução da linguagem C# este recurso é realmente útil já que o mesmo permite experimentar funcionalidades ainda em desenvolvimento simplesmente selecionando qual versão do compilador utilizar.

Visualizar / navegar na AST do código

Funcionalidade similar à janela Syntax Visualizer do Visual Studio (note que o .NET Compiler Platform SDK  deve estar instalado para esta janela ficar disponível no Visual Studio). Muito útil para entender um pouco mais sobre o Roslyn.

Mostrar o código IL

Acredito que esta funcionalidade não seja muito útil para a maioria dos desenvolvedores C# mas certamente a mesma é muito útil para uma parcela de desenvolvedores que lidam com IL no seu dia a dia. Além disso é uma ótima ferramenta para aprender um pouco mais sobre os detalhes de como .NET funciona. Altamente recomendado.



Visualizar o código assembly de métodos JITed

Se a funcionalidade anterior não é muito útil para uma ampla gama de desenvolvedores, o público alvo desta é ainda mais restrito (particularmente eu usei a mesma 1 ou 2 vezes). Quando esta opção é selecionada temos como resultado o código assembly gerado  pelo JIT o que nos permite estudar como o código C# é convertido para código de máquina.

Boa diversão ;)

Adriano

Mar 1, 2018

Online C# compilers

Leia esta post em Português

Hi

If you develop using C# and you like to experiment with code you should try using one of the online C# compilers (there are a bunch of them). They allow you to quickly test assumptions about the C# code, test how code behaves, etc.

Among those, one that I grew to love is sharplab.io which besides allowing you to play with C# code, also has a set of really nice features, which I'll briefly describe bellow.

Branch/Feature selection

If you are following C# language development (you should ;)) this feature is really useful; it allows one to choose which compiler (built from various feature branches), to use, i.e, you can experiment with features under development by simply selecting which compiler to use.

Display compiler Syntax Trees

This is similar to  the Roslyn Syntax Visualizer window in Visual Studio (this window will only be available if you install .NET Compiler Platform SDK in Visual Studio). Very useful if you are playing with Roslyn.

Display Generated IL

This is the type of feature that most C# developers will never need, but for those who actually need, this is really powerful. Want to see how some piece of C# code is translated to IL? simply type the code and select IL in the dropbox and voialá. 

Show generated JITed/ASM code

If the previous feature was not for most C# developers, this one is even more restricted, but  it can really help developers that need to check how some piece of C# code is translated to actual machine code (this can be very useful when you are trying to better understand how your C# code runs in the processor)

That's it.

Have fun

Adriano

Aug 25, 2017

Surprises in C#

Ok, after a long period of silence I decided to take some time to write about one detail of C# that stroke me yesterday. Given the following C# snipped, what you expect as the output ? (ok, I hand picked this example which I see as an extreme corner case)



To my surprise the middle one invokes the generic version of M (now that I've thought more about it, it makes sense).

The outcome of this little experiment is that I feel even more compelled to stay away from introducing generic/non generic versions of a method.

Happy codding

Jun 21, 2016

To infinity and beyond : more powerful .NET Metadata querying with LINQPad custom drivers and Mono.Cecil

In my last post I discussed how we can use LINQPad to query .NET metadata using .NET reflection. 

Even though that alone was already quite useful it has its own drawbacks:
  • No nice integration with LINQPad, requiring the user to load the assembly manually (even worse, forcing users to type the full assembly path)
  • No way to inspect / dump method bodies (so it is not possible, for instance, to find all methods that call into an specific method)
In order to overcome those limitations I decided to write a custom LINQPad driver for .NET assemblies (as we saw before this is not strictly necessary to use LINQ to explore .NET metadata, but it definitely can help to make the experience more pleasant/enabling some scenarios by, for instance, exposing some predefined Sources like all public typesmembers and the like).

You can read more about custom LINQPad drivers here, but in summary I created a static driver that exposes the following predefined query sources:
  • Types : A collection of all types (irrespective to accessibility and/or whether the type in question is a top level / inner type) from the assembly's main module.
  • PublicTypesA collection of all public types from the assembly's main module.
In addition to that I've also introduced some convenience functions that can be used in the queries:
  • AsString(method): An extension method for MethodBody that converts a method body into a formatted string with it's IL instructions.
  • Calls(method): An extension method for a MethodDefinition / MethodBody that takes a method (either as a MethodInfo or a MethodReference) and returns true if the method in question is being called in the method body.
  • References(type)An extension method for a MethodDefinition / MethodBody that takes a type (either as a string, a TypeInfo or a TypeReference) and returns true if the type in question is being referenced in the method body.
  • Property(name): An extension method (for TypeDefinition) that returns a property definition if the type has a matching one or null otherwise.
  • Event(name): An extension method (for TypeDefinition) that returns an event definition if the type has a matching one or null otherwise.
  • Field(name): An extension method (for TypeDefinition) that returns a field definition if the type has  a matching one or null otherwise.
You can have a glimpse of those features in the following screenshot:


If you are interested in using this, all you need to do is to download Cecil.LINQPad.Driver.lpx and install it in LINQPad by clicking Add connection "link" then "View more drivers...", then "Browse" and finally selecting Cecil.LINQPad.Driver.lpx file

Of course you can also grab the source code from GitHub and build it for yourself ;)

Feel free to comment, make suggestions, report issues, ask questions, etc.

Have fun!

Para o infinito e além: consultas ainda mais poderosas sob metadados NET com drivers parta LINQPad e Mono.Cecil

No post anterior mostrei como usar o LINQPad para executar consultas em metadados .NET usando .NET Reflection, técnica que, apesar de muito útil, possui algumas limitações:
  • Zero integração com LINQPad, exigindo que o assembly seja carregado manualmente (ainda pior é fato de termos que digitar o caminho completo do assembly),
  • Como o .Net Reflection não expõe o corpo (instruções) de métodos, não é possível por exemplo, encontrar todos os métodos que executam algum outro método específico ou que acessem uma propriedade, etc.
Felizmente o LINQPad nos permite desenvolver / utilizar custom drivers que se integram muito mais naturalmente com o mesmo. No meu caso eu escrevi um que usa o Mono.Cecil (ao invés de .Net Reflection) para expor algumas fontes pré-definidas para consultas:
  • Types : Uma lista com todos os tipos (independentemente do tipo ser público ou não e/ou ser uma inner class) definidos no módulo principal do assembly.
  • PublicTypes: Uma lista composta por todos os tipos definidos publicamente.
Também introduzi as seguintes extensões (extension methods):
  • AsString(): Método que estende MethodBody retornando as instruções que compõe o corpo do método na forma de uma string.
  • Calls(method): Método que estende MethodDefinition / MethodBody retornando verdadeiro (true) caso o método passado como parâmetro seja executado pelo corpo do método estendido.
  • References(type)Método que estende MethodDefinition / MethodBody retornando verdadeiro (true) se o tipo passado como parâmetro for referenciado pelas instruções do corpo do método estendido.
  • Property(name): Método que estende TypeDefinition retornando a propriedade especificada pelo parâmetro (caso o tipo possua uma propriedade com o mesmo nome) ou null.
  • Event(name): Método que estende TypeDefinition retornando o evento que possua o nome igual ao passado como parâmetro ou null caso o tipo em questão não possua um evento com este nome.
  • Field(name): Método que estende TypeDefinition retornando o campo que possua o nome igual ao especificado no parâmetro ou null caso o tipo em questão não possua um campo com este nome.
Você pode ver um exemplo da utilização de tais métodos na imagem abaixo:


Para usar este Custom Driver você pode baixar o arquivo Cecil.LINQPad.Driver.lpx e instalar o mesmo no LINQPad clicando na opção Add connection,  depois em "View more drivers...", "Browse" e finalmente selecionando o arquivo que você acabou de baixar (Cecil.LINQPad.Driver.lpx)

É claro que você também pode baixar o source do mesmo do GitHub e compilar / instalar ;)


Uma vez instalado, o mesmo aparecerá na lista de opções de drivers disponíveis:



Pressione o botão Next e, a seguir selecione o assembly que você deseja fazer consultas. Lembre-se de, após abrir o assembly, clicar no dropdown "Connection" para selecionar a conexão que o LINQPad deve usar para rodar as consultas, ou seja, qual assembly deve ser usado como fonte nas consultas. No exemplo abaixo o assembly Boo.Lang.Parser.dll será usado:

Pronto. Agora você já pode rodar suas consultas LINQ!

Have fun!