Skip to main content

C# 2.0 - Partial Types

For those of you interested, i found a very interesting list of features that were introduced in C# in here. This is a very complete list that contains all the features, and i'm explaining them one by one in this post series. We've talked about Generics and Iterators. Now it's time for some partial types.

A partial type is a type which definition is spread across one or more files. It doesn't have to be in multiple separated files, but can be. This is a very simple concept that can give us many benefits, let's see:
  • If a type is partial, multiple developers can work on every part of it. This allows a more organized way of working and can lead to production improvement. 
  • Winforms, for example, generates a partial class for the form so that the client can separately edit other parts it. This way, a part contains information about the design and the other contains the logic of the form. In fact, this is a very spread pattern across .Net. Entity Framework uses this too. The T4 Template by default creates partial classes for each entity and then we can create other parts of the same class to include our business logic without worrying with it getting overwritten. 
  • There is virtually no performance penalty in using partial types, because at compile time the parts will be unified. So, this is really just a convenience feature.
We can also create partial interfaces, structs and methods (not sure if this was introduced in 2.0). In case of methods, we need to be sure that they return void.

Below are some inconveniences of using partial types:
  • A partial type generally has it's logic or definition spread across it's parts, so it can be difficult to find the piece of code you want (this is arguably a bad argument, because today's IDE's overcome this problem.).
  • When using a partial type, sometimes may become hard to know every attribute a class implements, or every interface (also, the same as before).
To be clear, a partial type is always the sum of it's attributes, implemented interfaces, generic type parameters, documentation, etc. Let's see an example:

This is equivalent to:

To use a partial type, keep in mind that the partial declarations must obviously be in the same namespace.

Thank you for reading, next time i'll talk about nullable types!
Labels:

Comments

Post a Comment

Popular posts from this blog

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...
Post a Comment
Read more

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...
Post a Comment
Read more

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 ...
Post a Comment
Read more