Skip to main content

C# 2.0 - Tipos Parciais

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 framework, e por isso é várias vezes sobrescrita.  Este é um padrão bastante utilizado pelo .Net. O Entity Framework utliza isto também nos seus templates T4. Por defeito são criadas classes parciais para cada entidade e depois podemos criar mais partes de cada uma das entidades evitando assim perder as nossas alterações a cada classe, quando os templates gerarem de novo a definição.
  • Não existe nenhuma penalização em termos de performance por utilizarmos tipos parciais, porque todas as partes serão unificadas após compilação. Esta feature é apenas para conveniência do programador.
Também podemos criar interfaces, structs e métodos parciais (não tenho a certeza se estes foram introduzidos no C# 2.0). No caso dos métodos, obrigatoriamente não podem devolver nenhum valor.

Abaixo estão listadas algumas inconveniências de utilizar tipos parciais:
  • Um tipo parcial geralmente tem a sua lógica ou definição espalhadas pelas suas partes, por isso pode dificultar a parte do código que queremos (este é um argumento fraco, porque as IDE's de hoje tornam a pesquisa fácil)
  • Quando utilizamos tipos parciais, por vezes pode tornar-se complicado perceber todos os atributos que os seus membros têm, ou quais as interfaces que um tipo implementa (o mesmo que antes, as IDE's são poderosas o suficiente para ultrapassar este problema.
Um tipo parcial é sempre a soma dos seus atributos, interfaces implementadas, generic parameters, documentação, etc. Vamos ver um exemplo:


Isto é equivalente a:

Para usar um tipo parcial, tenham em conta que as declarações das partes têm que estar no mesmo namespace.

Obrigado por lerem, o próximo post será sobre nullable types!

Disclaimer: Por vezes existem termos que eu traduzo nestes posts e outros não. Isto tem a ver com o quão confortável me sinto com cada tradução que faço. Consigo sentir-me confortável o suficiente para dizer tipos parciais, mas não tipos nulos, ou algo similar. Por vezes isto leva a inconsistências, mas qualquer dúvida sobre o conteúdo do post poderá ser respondida!

Comments

Popular posts from this blog

The repository's repository

Ever since I started delving into architecture,  and specifically service oriented architecture, there has been one matter where opinions get divided. Let me state the problem first, and then take a look at both sides of the barricade. Given that your service layer needs to access persistent storage, how do you model that layer? It is almost common knowledge what to do here: use the Repository design pattern. So we look at the pattern and decide that it seems simple enough! Let's implement the shit out of it! Now, let's say that you will use an ORM - here comes trouble. Specifically we're using EF, but we could be talking about NHibernate or really any other. The real divisive theme is this question: should you be using the repository pattern at all when you use an ORM? I'll flat out say it: I don't think you should... except with good reason. So, sharpen your swords, pray to your gods and come with me to fight this war... or maybe stay in the couch?

The evolution of C# - Part III - C# 2.0 - Iterators

It's been a while since i wrote the last post, but i did not forget my purpose of creating a series that shows the evolution of C#. Today i came here to talk about one of the most useful features of C#, even if you dont know you're using it. Let's talk about iterators ! What is an iterator? For those of you who didn't read about the iterator pattern somewhere in the internet or in the "Gang of Four" book, you can read a description  here . The iterator is a class/object/whatever which knows how to traverse a structure. So, if you have a list or collection of objects, an iterator would have the knowledge of how to traverse that collection and access each element that it contains. The iterator is a well known design pattern and is behind many of the wonderful that we have nowadays in .NET (Linq comes to mind). Why is it a feature? Truth be told, an iterator is a concept well known way before .NET even existed. Being an OO Design Pattern, the iterator has

My simplest and most useful type

I have been doing some introspection on the way I write code to find ways that I need to improve. I consider this a task that one must do periodically so that we keep organized. There is a very, very simple problem that occurs in every application I know: How to return the results of an operation to the user? I've seen many implementations. Some return strings, some throw exceptions, some use out parameters, reuse the domain classes and have extra properties in there, etc. There is a myriad of ways of accomplishing this. This is the one I use. I don't like throwing exceptions. There are certainly cases where you have no choice, but I always avoid that. Throughout my architectures there is a single prevalent type that hasn't changed for years now, and I consider that a sign of stability. It is so simple, yet so useful everywhere. The name may shock you, take a look: Yes, this is it. Take a moment to compose yourself. Mind you, this is used everywhere , in every