Left fold

São 3 da manhã e não me apetece dormir. Estive a ajudar um amigo meu a trabalhar no código dele e estou apenas parcialmente cansado. Bem, porque não continuar com a série sobre a evolução do C#? Vamos a isso! Desta vez vamos falar de nullable types . Já todos utilizámos, mas no .NET 1.0 eles não existiam. Como é que representávamos um valor vazio? Uma string  pode conter null , supostamente é essa a representação do valor vazio. Como é que representamos um valor numérico vazio? Verificamos se é maior que 0? Bem, nalguns casos é exactamente isso que fazemos. Ou isso, ou criamos um valor constante que representa um "não valor". Mas para mim isto não é expressivo suficiente. Basicamente, um nullable type  é apenas um non-nullable type  envolvido na estrutura System.Nullable . Esta é uma estrutura genérica por isso faz uso dos G enerics  introduzidos no C# 2.0. A estrutura é bastante simples, contém apenas uma propriedade  HasValue  e Value . Ambas são muito explícitas e isto

Para quem estiver interessado, encontrei uma lista muito interessante de features que foram introduzidas no C#  aqui . Esta é uma lista muito completa que contém todas as features que vou explicando uma a uma nesta série de posts. Já falámos sobre  Generics  e  Iterators . Agora vamos falar de tipos parciais . Um tipo parcial  é considerado como tal quando a sua definição está espalhada por várias partes em um ou mais ficheiros. Não tem que ser em múltiplos ficheiros, mas poderia. Este é um conceito muito simples que nos traz alguns benefícios. Vamos ver: Se um tipo for parcial, múltiplos programadores podem trabalhar em cada uma das partes. Isto permite-nos uma forma mais organizada de trabalhar, e pode acelerar a produção. Em Winforms, por exemplo, é gerada uma classe parcial  para cada Form para que o programador possa separar a lógica. Desta forma, uma parte contém informação acerca do design e a outra parte contém a lógica do  Form . A parte do design é manipulada pela fr

Hoje vim para falar de uma das features mais úteis do C# 2.0, mesmo que muitas pessoas não saibam do que se trata. Vamos falar de iterators ! O que é um iterator? Para quem ainda não sabe o que é o padrão  iterator , podem ler a sua descrição  aqui . Um iterator  é uma classe/objecto que sabe como percorrer uma estrutura. Portanto, se tivermos uma lista de objectos, um iterator  teria o conhecimento de como percorrer essa lista e aceder cada elemento da lista. O iterator  é um design pattern  bastante conhecido e está por trás de muitas coisas fantásticas que temos hoje no .NET. (assim de repente lembro-me de LINQ ). A Microsoft definiu duas interfaces para este design pattern  chamadas IEnumerable e IEnumerator . A primeira é implementada no objecto que vamos percorrer, a segunda é no objecto que irá percorrer o primeiro. Porque é que é uma feature? Diga-se de passagem, os iterators  são um conceito bem conhecido mesmo antes do .NET existir. Sendo um design pattern  de programaç

Este é um assunto já bastante discutido pela internet fora. Todos sabemos o que são Generics , e para que são usados, certo? Não. Existe uma variedade de razões pelas quais o leitor pode não saber o que são G enerics, e algumas delas são: O leitor é novo na linguagem, O leitor não é novo na linguagem, mas nunca se deu ao trabalho de tentar aprender. Se o leitor nunca aprendeu generics, isso   não significa que nunca terá de aprender. Se reconhece este snippet, então saiba que já estamos a lidar com generics . Portanto, qual é a vantagem de utilizar generics ? Type safety Generics permite-nos apanhar erros na compilação   em vez de em  runtime,  obrigando o programador a respeitar as regras de type safety que fazem do C# uma linguagem estática. Isto leva-nos a uma produtividade acelerada porque não temos que correr o programa para saber que cometemos um erro. Por exemplo, se no snippet acima tentássemos adicionar um novo item do tipo  string, o compilador daria erro. Tip

Hoje vamos falar sobre História. Não aquela História das Guerras Mundiais, mas a história da evolução do C# como uma linguagem. Tenho em mente analisar as partes principais de uma das linguagens de programação em massa mais utilizadas no mundo. A grande parte do que vou falar é fruto de muita pesquisa, em parte porque quando o C# e o .NET foram disponibilizados eu ainda não tinha escrito uma única linha de código, por isso podemos dizer que sou novato neste mundo. No entanto, estou a esforçar-me por mudar isso, e cada nova descoberta é feita com muito entusiasmo da minha parte, e eu considero-me extremamente pro-activo, o que poderá até irritar quem está à minha volta. Uma das razões pelas quais estou a escrever este post, e já agora todo este blog, é porque eu tenho gosto em aprender coisas novas e principalmente partilhá-las com outros. Chega de conversa, vamos ao que interessa! O início do .NET A plataforma .NET traz uma nova forma de programar as nossas aplicações. A Microsof

Hoje, vamos falar uns truques simples com strings no C#. Eu sei que pode ser demasiado óbvio e repetido pela internet fora, mas ainda assim quero dar a minha opinão sobre o assunto. Vamos a isto! Imaginemos que temos uma List de qualquer type e vamos precisar dos seus valores separados por uma vírgula para serem enviados para uma stored procedure . O resultado desejado será, dada uma  List de {1,2,3,4}, uma string neste formato: "1,2,3,4". Como vamos resolver este problema? Já vi e fiz múltiplas soluções para o problema, por isso vamos ordenar as possíveis soluções (na minha cabeça) da mais complexa para a mais simples. Primeiro, podemos fazer isto: Vejam o quão complexo isto pode ser e o quão rapidamente se pode tornar insustentável. Quando repetido múltiplas vezes num projecto (imaginem ter isto repetido na vossa Camada de Acesso a Dados sempre que uma stored procedure  precisa deste input), isto pode tornar-se doloroso. Claro que poderiamos extrair este comportamento p

Let's talk about accessor's accessibility introduced in C# 2.0. This is a tiny little feature that can make your life easier in a number of ways. But first, let's define what i am talking about. Normally, a property is composed this way: So, from the example above, we can see that a property has a backfield (called _myProperty) and is composed by a getter and a setter . The getter is called whenever you get the value of that property. The setter is called when you set it's value. If we look carefully, we notice that the getter returns the value of the backfield, and the setter sets it's value, respectively. If we think about it, a property is nothing more than a wrapper around a private field. This way we can control all the access to that field's value. C#'s properties are nothing more than sintactic sugar for the following structure: This is an " old school property ". In languages where you don't really have the concept of prop