Customise your list by overriding Collection of T with C# .NET

December 5, 2016 3 Comments

Imagine that you’d like to build a list type of collection where you want to restrict the insertion and/or deletion of items in some way. Let’s say we need an integer list with the following rules:

  • The allowed range of integers is between 0 and 10 inclusive
  • A user should not be able to remove an item at index 0
  • A user should not be able to remove all items at once

One possible solution is to derive from the Collection of T class. The generic Collection of T class in the System.Collections.ObjectModel namespace provides virtual methods that you can override in your custom collection.

The virtual InsertItem and SetItem methods are necessary to control the behaviour of the Collection.Add and the way items can be modified through an indexer:

Read more of this post

Filed under .NET, C# language features, Generics Tagged with ,

Flatten sequences with the C# LINQ SelectMany operator

November 29, 2016 1 Comment

Suppose that we have an object with a collection of other objects, like a customer with order items. Then we can also have a sequence of customers where each customer will have her own list of orders. It happens that we want to analyse all orders regardless of the customer, like how many of product A have been sold. There are several options to collect all orders from all customers and place them into one unified collection for further analysis.

The C# SelectMany operator has been specifically designed to extract collections of objects and flatten those collections into one. This post will provide a couple of examples to demonstrate its usage.

Read more of this post

Filed under .NET, C# language features, LINQ Tagged with , ,

Creating a read-only collection from an array in C#

November 25, 2016 Leave a comment

The Array class has a number of interesting methods. One of them allows you to easily convert an array of T into a read-only collection of T:

string[] bands = new string[5] { "Queen", "ACDC", "Metallica", "Genesis", "INXS" };
IReadOnlyCollection<string> readOnlyBands = Array.AsReadOnly<string>(bands);

Note that readOnlyBands is, well, read-only, so there’s no Add or Remove method that otherwise are often available on lists.

View all various C# language feature related posts here.

Filed under .NET, C# language features Tagged with

Extension methods in C#

November 23, 2016 Leave a comment

Introduction

Extension methods in C# allow you to extend the functionality of types that you didn’t write and don’t have direct access to. They look like integral parts of any built-in classes in .NET, e.g.:

DateTime.Now.ToMyCustomDate();
string.ToThreeLetterAbbreviation();

You can extend the following types in C#:

  • Classes
  • Structs
  • Interfaces

You can extend public types of 3rd party libraries. You can also extend generic types, such as List of T and IEnumerable of T. You cannot extend sealed classes.

Read more of this post

Filed under .NET, C# language features Tagged with ,

A summary of new features in C# 6

November 22, 2016 2 Comments

Here’s a short list of new features in C# 6 and a link to a blog post explaining their usage:

View all various C# language feature related posts here.

Filed under .NET, C# language features Tagged with ,

Using the StringComparer class for string equality with C# .NET

November 16, 2016 Leave a comment

In this post we saw how to use the generic IEqualityComparer of T interface to indicate equality for our custom types. If you need a similar comparer for strings then there’s a ready-made static class called StringComparer which can construct string comparers for you.

The StringComparer class provides comparers for the common string comparison scenarios: ordinal, locale specific and invariant culture comparisons. This is a good MSDN article on the differences between these.

Read more of this post

Filed under .NET, C# language features Tagged with ,

Join custom objects into a concatenated string in .NET C#

November 11, 2016 Leave a comment

Say you have the following Customer object with an overridden ToString method:

public class Customer
{
	public int Id { get; set; }
	public string Name { get; set; }
	public string City { get; set; }

	public override string ToString()
	{
		return string.Format("Id: {0}, name: {1}, city: {2}", Id, Name, City);
	}
}

Read more of this post

Filed under .NET, C# language features Tagged with ,

Checking for arithmetic overflow in C# .NET

November 10, 2016 Leave a comment

As you know primitive numeric types in C# – and other modern programming languages – have maximum and minimum values that can be stored in memory. If you’re trying to store a larger number in the variable then you’ll get an overflow with unexpected results.

Let’s see an example with the “byte” type. It is actually not one of the primitive types, like int or long, but simply a keyword for an integral type to store the numbers 0-255. Why 255? 1 byte consists of 8 bits and 8 bits in the computer’s memory allows us to store 255 as the highest number. 255 in binary is all 1’s for all 8 bits:

11111111

What happens if we add 1 to that? On paper we can easily solve it by some basic binary maths:

11111111
+ 00000001
===========
100000000

Read more of this post

Filed under .NET, C# language features Tagged with

Keyword function arguments in C#

November 9, 2016 Leave a comment

In this post we’ll quickly go through positional vs. keyword function arguments in C#.

Say you have the following function:

public string GetContent(bool base64encode, bool compress, bool withUniqueId, string filename, int maxSize)
{
	return string.Empty;
}

You’ll learn very early in your programming class that you can call a function by supplying the arguments in exactly the same order as they are listed in the method signature. Here’s an example:

Read more of this post

Filed under .NET, C# language features Tagged with

Combinable enumerations in C# .NET

November 8, 2016 Leave a comment

You’ve probably encountered cases with combined enum values using the pipe character, i.e. the “bitwise or” operator ‘|’:

Size.Large | Size.ExtraLarge

Let’s see an example of how to create such an enum.

The enumeration is decorated with the Flags attribute like in the following example:

Read more of this post

Filed under .NET, C# language features Tagged with ,

← Older posts

Newer posts →

Elliot Balynn's Blog

A directory of wonderful thoughts

Software Engineering

Web development

Disparate Opinions

Various tidbits

chsakell's Blog

WEB APPLICATION DEVELOPMENT TUTORIALS WITH OPEN-SOURCE PROJECTS

Once Upon a Camayoc

ARCHIVED: Bite-size insight on Cyber Security for the not too technical.