Skip to main content

Truques com strings

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 para um extension method, mas como iremos ver isto não é necessário.

A nossa segunda abordagem, muito mais simples, utiliza todo o poder que LINQ nos traz. LINQ é uma daquelas tecnologias que eu adoro no .NET. Pode simplificar-vos muito a vida quando aplicado correctamente. Mas vamos ver como poderiamos fazê-lo neste caso:


Ainda assim, esta não é a nossa melhor solução. Vamos admitir, aquele uso do Aggregate e do Remove pode ser complicado de compreender à primeira vista. Na verdade, isto até fica pouco legível e temos que estar familiarizados com a forma como o Aggregate trabalha. Também veremos o quão horrivelmente lento é utilizar este método.

Vamos ver o próximo snippet:


Esta solução é simples, de fácil manutenção, fácil de compreender à primeira vista e, esperemos, com boa performance. Será mesmo? Vamos correr alguns testes e verificar! Para isso, preenchi a variável DocumentIDs com 10 000 000 ints, extraí cada uma das abordagens para um método e chamei-o 5 vezes envolvido num Stopwatch. Depois dividi o resultado em milisegundos por 5 para obter a média. Sim, eu sei que não é um benchmark de qualidade, mas serve para este exemplo.

Na altura dos testes eu tinha um Toshiba Satellite L40, Intel Pentium T2330 @ 1.6GHz e 2GB de RAM. Vamos ver os resultados:

Foreach com StringBuilder (Snippet 1): 4773 ms em média (Corri 5 vezes)

Não está mau de todo! Normalmente também nunca estaríamos a lidar com uma quantidade de dados desta natureza, mas é sempre bom ver como as várias opções se comportam sob pressão.

Aggregate com Remove (Snippet 2): acima de 1m:30s (Corri apenas uma vez. Não o deixei sequer acabar.)

Podemos ver que esta não é uma boa abordagem. Para começar, utilizar LINQ nesta situação é como matar moscas com canhões. Notem que estou a concatenar a string com o operador (+). Esta operação é extremamente lenta porque uma string é imutável e de cada vez uma nova string tem que ser instanciada. Portanto, esta não será a solução ideal.

String.Join (Snippet 3): 4670 ms em média (Corri 5 vezes)

Como podemos ver, o terceiro método é o mais rápido também. O primeiro também não lhe fica muito atrás, mas vamos manter as coisas simples. String.Join foi desenhado especificamente para estes casos, portanto vamos utilizar o que a framework nos oferece!

Se há uma lição que eu retiro deste tipo de situações é: não reinventes a roda quadrada. Todos nós o fazemos uma vez ou outra, é a nossa natureza como programadores, mas isso apenas importa se aprendermos algo com isso. Eu acredito que cada uma das abordagens tenha as suas vantagens e desvantagens. Por exemplo, consigo imaginar-me a utilizar a primeira abordagem para encapsular outro comportamente também quando o método fosse chamado, ou para formatar o output de outras formas mais personalizadas.

Sintam-se à vontade em partilhar outras formas de resolver o mesmo problema,

Obrigado pela leitura!

Links and references:
String.Join no MSDN
http://msdn.microsoft.com/en-us/library/57a79xd0.aspx

StringBuilder no MSDN
http://msdn.microsoft.com/en-us/library/system.text.stringbuilder.aspx

Aggregate no MSDN
http://msdn.microsoft.com/en-us/library/bb548651.aspx

---------------------------------------------------------------------------------
Nota de rodapé:
Ao longo do tempo vou começar a actualizar o meu blogue para também incluir os posts em Português. Esta é a minha lingua materna e considero importante também chegar a quem não tem conhecimentos de inglês. No entanto não vou traduzir todos os termos para Português porque continuo a defender que será melhor procurá-los em Inglês, que é a linguagem geralmente aceite em fóruns internacionais. Qualquer termo que precisem explicado sintam-se à vontade para perguntar.

Comments

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...

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...

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 ...