Collections search
During interviews, we often hear — or say ourselves — that searching in an array is slower than in a hashtable. Some might even recall that array search has linear complexity, or O(n), while a hash table has constant complexity, O(1). But does this hold true in practice? What if there are situations where searching in an array turns out to be faster? Let's not rush to conclusions.
Collection initializer: List<T>
We're all used to write new List<int> { 1, 2, 3, 4 } or new int[] { 1, 2, 3, 4} to initialize collections with
values. Syntactically, they look similar, but the behavior is different, and you should be careful if you are worried
about
performance.
String of Digits
A popular task is to check if a string contains only digits. For example, you need to check if the user entered the correct phone number, index or a tax code of an organization. There are several ways to solve this task, which differ in their efficiency. Let's take a look at the most popular ones.
Any() vs Count: part 2
In Part 1, we compared Any() and Count methods for different collections and proposed optimization approaches.
List initializer
We all used to type new List<int> { 1, 2, 3, 4 } or new int[] { 1, 2, 3, 4} to initialize collections with some values. It looks similar in syntax but differs in behavior, and you should be careful if you are concerned about performance.
Harmful collection transformations. Part 3: collections
Starting with string in the first post we continue to study examples with collection transformations and how they affect our applications.
Harmful collection transformations. Part 1: string to array of chars
An array — the simplest collection. It's just a memory block with elements of one type. Arrays are often used when we need to iterate a collection, to search for elements or transform them. C# and .net evolved, many new collections were introduced, interfaces allowed to create generalized algorithms, LINQ simplified the work of programmers, but we continue to use arrays in inappropriate places and perform excess and sometimes harmful transformations. This post begins a series about collections, their features, performance and design. All posts will contain benchmarks, code examples, my opinion and recommendations.
I want to start with a string, some specific collection of .net.
LINQ: Group by byte
LINQ is a powerful tool for collection (or enumeration) operating. You use functional-like syntax for filtering, grouping, transforming data. All LINQ methods work with common interface IEnumerable<T> and usually methods do not check real type of collection, or data type. Sometimes, if you know the type of collection or generic type, you can optimize code for better performance (like in Any vs Count).
This article will show, how you can speed up grouping by specific key - byte.
LINQ: Any vs Count
This post started from discussion on SO: Why LINQ method Any does not check Count? This article shows a comparison of performance methods Any and Count = 0.