DoNetExtensions 0.0.4

The project aims to provide hundreds of fully-documented, tested, and useful extension methods to existing standard .NET classes, which we have accumulated through the years.

We have been coding with .NET for more than ten years, and we notice many standard classes (like array, list, dictionary, etc.) lack rich methods to facilitate their use and quick development. Although each piece extension method in this library is not much, we believe as a whole they bring great convenience and help enhance producitivity for other .NET programmers.

Initial Release

This initial release includes several extensions for arrays and collections as shown below. Currently all methods are under the same namespace as the classes they extend. Therefore, the usage is to just add reference to the extension library and then benefit from the added methods.

1. The "In" Method

Instead of "a.Contains(b)", we provide an alternative "b.In(a)", where "a" is a collection, and "b" is an element to check.

var a = new[] {1,2,3};
var b = 1;
if (b.In(a))
  Do something.

In: returns true if the element to check is contained in an array/list/collection.

2. Collection to Array Conversion

var list = new List<int>();
var arr = list.ToArrayOrNull(); // returns a null reference
list.Add(1);
list.Add(2);
arr = list.ToArrayOrNull(); // returns an array [1,2]
arr = list.ToArrayThenClear(); // returns an array [1,2] and clears the list
arr = list.ToArrayOrNull(); // returns a null reference because list has been cleared.

ToArrayOrNull: returns a null reference if the collection is empty (rather than returns an empty array by the build-in ToArray() method), or otherwise works like build-in ToArray() method.

ToArrayThenClear: works like the build-in ToArray() method, but clears the collection after the elements are output to the array.

ToArrayOrNullThenClear: works like the ToArrayOrNull() method, but clears the collection after the elements are output to the array.

All added methods support conversion starting at a specified index.

3. Unified Emptiness Check

Although incredibly useful, the emptiness of an array or a collection has to be checked in a clumsy way, even for today after 10 years.

var arr = new int[] {1,2,3};
if (arr != null && arr.Length != 0) // NOTE: the new syntax "arr?.Length != 0" will not do the check as desired!
  Do something...
  
var list = new List<int> {1,2,3};
if (list != null && arr.Count != 0) // NOTE: have to use a different property "Count"
  Do something...

Now with the extension, above can be greatly simplified and more readable. The method is added to both arrays and collections.

var arr = new int[] {1,2,3};
if (arr.IsNotNullOrEmpty())
  Do something...
  
var list = new List<int> { 1,2,3};
if (list.IsNotNullOrEmpty())
  Do something...
  
var dict = new Dictionary<string, int> { { "a", 1 } }
if (dict.IsNotNullOrEmpty())
  Do something...

IsNullOrEmpty: Returns true if a collection is a null reference or is an empty collection.

IsNotNullOrEmpty: Returns true if a collection is not a null reference or is not an empty collection.

IsEmpty: Returns true if a collection is an empty collection (throws an NullReferenceException if it is a null reference).

IsNotEmpty: Returns true if a collection is not an empty collection (throws an NullReferenceException if it is a null reference).

4. Collection to Concatenated String

ToConcatString: Outputs a concatenated string representation for elements in a collection. For each element, their ToString() method is used.

var arr = new int[] {1,2,3};
Console.WriteLine(arr.ToConcatString(',')); // prints "1,2,3"
Console.WriteLine(arr.ToConcatString("--")); // prints "1--2--3"

5. Basic Operations on Array

It is not uncommon that we might need to just add/remove one specified item to/from an array, and return a new array with the item added/removed (for example, such addition/removal is rarely used by the client, and it is not desirable to complicate the code design with other data structure like list or linked list).

var arr = new int[] {1,2,3};
var arr2 = arr.Remove(2); // returns a new array instance [1,3]
var arr3 = arr.RemoveAt(2); // returns a new array instance [1,2]
var arr4 = arr.AddFirst(0); // returns a new array instance [0,1,2,3]
var arr5 = arr.AddLast(4); // returns a new array instance [1,2,3,4]
var arr6 = arr.Insert(18, index:2); // returns a new array [1,2,18,3], with 18 inserted at position 2
var arr7 = arr.Insert(arr, index:2); // returns a new array [1,2,1,2,3,3], with "1,2,3" inserted at position 2

var merged = (new[] { arr, arr2, arr3, arr4, arr5, arr6, arr7}).Merge(); // merges all above arrays into on single array.

AddFirst: Returns a new array with one or more elements appended at the beginning of the current array.

AddLast: Returns a new array with one or more elements appended at the end of the current array.

Remove: Returns a new array with the specified element(s) removed.

RemoveAt: Returns a new array with the element at the specified index(es) removed.

Insert: Returns a new array with one or more elements inserted at the specified index.

Merge: Merges a collection of arrays into a single array.