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

Why is the Single Responsability Principle important?

The Single Responsability Principle is one of the five S.O.L.I.D. principles in which i base my everyday programming. It tells us how a method or class should have only one responsability. Not a long time ago i was designing a reporting service with my colleague Nuno for an application module we were redoing and we had a method that was responsible for being both the factory method of a popup view and showing it to the user. You can see where this is going now... I figured out it would not be a that bad violation of the principle, so we moved on with this design. The method was called something like "ShowPrintPopup" and it took an IReport as an argument. All this was fine, but then we got to a point where we needed to have a permissions system to say if the user was able to export the report to Excel, Word, PDF, etc... The problem was the print popup would need to know beforehand if it would allow the user to export the report or not, so that it could show it's UI a...

From crappy to happy - refactoring untestable code - an introduction

I started testing my code automatically a couple of years in after starting my career. Working in a small company, there weren't really incentives for us to automate testing and we were not following any kind of best practices. Our way of working was to write the code, test it manually and then just Release It ™ , preferably on a Friday of course. I'm sure everyone can relate to this at some point in their career, because this is a lot more common than the Almighty Programming Gods of the Internet make us believe. I find that the amount of companies that actually bother writing tests for their production code is a fraction of the whole universe. I know some friends who work in pretty big companies with big names in the industry and even there the same mindset exists. Of course, at some point in time our code turned into a big pile of shit . Nobody really knew what was going on and where. We had quantum-level switcheroo that nobody really wanted to touch, and I suspect it i...

From crappy to happy - dependency what, now?

Following the introduction on this series on a previous post, we will now talk about dependency injection and how it has the effect of allowing for more testable code. Sometimes when I talk about this concept it is difficult to explain the effect that applying it might have on the tests. For that reason I think it is better to demonstrate with a near-real-world situation. Obviously, keep in mind this is not real code, so don't worry about the design or implementation details that don't contribute to the point being discussed. The code As you can see, it is simple. There's a class called ShipManager (what else?) that receives position updates for the ships. It keeps the last position reported from each ship and does some calculation to see how much the ship moved. It assigns some values to the update and finally it persists the final version of the update. How do we start testing? When you think about it, tests are dead simple. A test either passes or it doesn...