Base Class Library Enhancements
Randomization
Related class: RandomExtensions
Extension methods for random data generation extends both classes Random and RandomNumberGenerator.
Random string generation
Provides a way to generate random string of the given length and set of allowed characters.
using DotNext;
using System;
var rand = new Random();
var password = rand.NextString("abc123", 10);
//now password has 10 characters
//each character is equal to 'a', 'b', 'c', '1', '2' or '3'
The same extension method is provided for class RandomNumberGenerator.
Random boolean generation
Provides a way to generate boolean value with the given probability
using DotNext;
var rand = new Random();
var b = rand.NextBoolean(0.3D); //0.3 is a probability of TRUE value
The same extension method is provided for class RandomNumberGenerator.
String extensions
Related class: StringExtensions.
Reverse string
Extension method Reverse allows to reverse string characters and returns a new string:
using DotNext;
var str = "abc".Reverse(); //str is "cba"
Trim by length
Extension method TrimLength limits string length:
using DotNext;
var str = "abc".TrimLength(2); //str is "ab"
str = "abc".TrimLength(4); //str is "abc"
Raw Data
Extension method GetRawData allows to obtain managed pointer to the underlying char buffer referenced by the string instance. This method can be used in performance-critical paths in your code
using DotNext;
ref readonly char ch = ref "str".GetRawData(); //now ch points to the first string character of 's'
Returned managed pointer is immutable because instantiated string cannot be modified at runtime.
Delegates
Related classes: DelegateHelpers, Func, Converter, Predicate.
Change type of delegate
Different types of delegates can refer to the same method. For instance, Func<string, string>
represents the same signature as Converter<string, string>
. It means that the delegate instance can be converted into another delegate type if signature matches.
using DotNext;
Func<string, int> lengthOf = str => str.Length;
Converter<string, int> lengthOf2 = lengthOf.ChangeType<Converter<string, int>>();
Create delegate instance
Statically-typed version of delegate creation method shipped with .NET Standard.
using DotNext;
var parseInt = typeof(int).GetMethod(nameof(int.Parse)).CreateDelegate<Func<string, int>>();
Specialized delegate converters
Conversion between mostly used delegate types: Predicate<T>, Func<T, TResult> and Converter<TInput, TOutput>.
using DotNext;
Predicate<string> isEmpty = str => str.Length == 0;
Func<string, bool> isEmptyFunc = isEmpty.AsFunc();
Converter<string, bool> isEmptyConv = isEmpty.AsConverter();
Predefined delegates
Cached delegate instances for mostly used delegate types: Predicate<T>, Func<T, TResult> and Converter<TInput, TOutput>.
using DotNext;
Func<int, int> identity = Func.Identity<int>(); //identity delegate which returns input argument without any changes
Predicate<string> truePredicate = Predicate.True<string>(); // predicate which always returns true
Predicate<object> falsePredicate = Predicate.False<string>(); //predicate which always returns false
Predicate<string> nullCheck = Predicate.IsNull<string>(); //predicate checking whether the input argument is null
Predicate<string> notNullCheck = Predicate.IsNotNull<string>(); //predicate checking whether the input argument is not null
Logical operators for Predicate
Extension methods implementation logical operators for Predicate delegate instances:
using DotNext;
Predicate<string> predicate = str => str.Length == 0;
predicate = predicate.Negate();
predicate = predicate.And(str => str.Length > 2);
predicate = predicate.Or(str => str.Length % 2 == 0);
predicate = predicate.Xor(Predicate.IsNull<string>());
Comparable data types
Related class: Comparable
Min/max value
Generic methods for comparable data types:
using DotNext;
var str = "ab".Max("bc"); //str == "bc"
str = "ab".Min("bc");
Range check
Checks whether the given value is in specific range.
using DotNext;
var b = 10.Between(5, 11, BoundType.Closed); //b == true
b = 10.Between(0, 4); //b == false
var i = 5.Clamp(4, 10); //i == 5
i = 5.Clamp(6, 10); //i == 6
i = 5.Clamp(0, 4); //i == 4
Equality check
Related classes: ObjectExtensions, ValueTypeExtensions.
Extension method IsOneOf allows to check whether the value is equal to one of the given values.
using DotNext;
var b = 42.IsOneOf(0, 5, 42, 3); //b == true
b = "a".IsOneOf("b", "c", "d"); //b == false
Array extensions
Related classes: OneDimensionalArray.
Extension methods for slicing, iteration, conversion, element insertion and fast equality check between elements of two arrays.
Equality check
BitwiseEquals extension method performs bitwise equality between two regions of memory referenced by the arrays. Element type of these arrays should be of unmanaged value type, e.g. int
, long
, System.Guid
.
var array2 = new int[] { 1, 2, 3 };
array2.BitwiseEquals(new [] {1, 2, 4}); //false
This method is faster than naive implementation using foreach
iteration and comparison by index. Read Benchmarks for more information.
Functional iteration
Extension method ForEach
allows to iterate over array elements and, optionally, modify array element.
var array = new string[] {"ab", "bc" };
array.ForEach((long index, ref string element) => {
if(element == "ab")
element = "";
});
Insertion and Removal
Extension methods Insert, Slice, RemoveLast and RemoveFirst allow to return modified array according with semantics of chosen method:
var array = new string[] {"a", "b"};
array = array.Insert("c", 2); //array == new []{"a", "b", "c"}
array = array.RemoveLast(2); //array == new []{"a"}
array = new string[] {"a", "b", "c"};
array = array.RemoveFirst(2); //array == new []{"c"}
array = new string[]{"a", "b", "c", "d"};
array = array.Slice(1, 2); //array == new []{"b", "c"}
Extensions for IntPtr
and UIntPtr
Natural-sized integer data types IntPtr and UIntPtr have no arithmetic, bitwise, and comparison operators as other numeric types in .NET standard library. This is fixed by .NEXT library which provides implementation of these operators in the form of extension methods available for both types from ValueTypeExtensions class.
These methods are implemented as intrinsics using inline IL code so they can be replaced by equivalent assembly instruction by JIT compiler. As a result, they the methods have the same performance as natively supported operators for regular numeric types.
The following example demonstrates how to use these methods:
using DotNext;
var i = new IntPtr(40);
i = i.Add(new IntPtr(2)); //i == 42
if(i.GreaterThan(IntPtr.Zero))
i = i.Subtract(new IntPtr(10));
else
i = i.OnesComplement(); //equivalent to operator ~
Timestamp
Timestamp value type can be used as allocation-free alternative to Stopwatch when you need to measure time intervals.
using DotNext.Diagnostics;
using System;
var timestamp = Timestamp.Current;
//long-running operation
Console.WriteLine(current.Elapsed);
Elapsed
property returning value of TimeSpan type which indicates the difference between timestamp
and the current point in time.
This type should not be used as unique identifier of some point in time. The created time stamp may identify the time since the start of the process, OS, user session or whatever else.