Set of extension methods to help with Arrays.

Method to obtain the next object in the array by passing the current index. Note: Idea obtained from TaroDev's video on things to do in Unity - https://youtu.be/Ic5ux-tpkCE?t=302

• array: T[]
• currentIndex: ref int

• CurrentIndex - The index we're currently on inside the array passed as reference so we can automatically assign to it the next index

Utility class for benchmarking code execution time.

BenchmarkUtility.Start("MyBenchmark");
// Code to benchmark
BenchmarkUtility.Stop("MyBenchmark");
var results = BenchmarkUtility.GetResults("MyBenchmark");

Records the execution time of the provided action and returns the elapsed time in milliseconds.

• actionToRecord: Action

var time = BenchmarkUtility.Record(() =>
{
    // Code to benchmark
});

Console.WriteLine($"Elapsed time: {time} ms");

Records the execution time of the provided action, saves it under the given key, and returns the elapsed time in milliseconds.

• key: string
• actionToRecord: Action

var time = BenchmarkUtility.RecordAndSaveToResults("MyBenchmark", () =>
{
    // Code to benchmark
});

Console.WriteLine($"Elapsed time: {time} ms");

var results = BenchmarkUtility.GetResults("MyBenchmark");

var averageTime = results.Average();
Console.WriteLine($"Average time: {averageTime} ms");

Starts or restarts the stopwatch for the given key.

• key: string

Stops the stopwatch for the given key and records the elapsed time.

• key: string

Retrieves the list of recorded times for the given key.

• key: string

Clears all recorded benchmark results.

Retrieves all recorded benchmark results.

Provides extension methods for the float data type.

Rounds a float value to the specified number of decimal places.

• value: float
• digits: int

• value: The float value to round.
• digits: The number of decimal places to round to. Default is 2.

var originalValue = 3.14159f;
var roundedValue = originalValue.Round(2); // roundedValue will be 3.14

Rounds a float value to the nearest integer and returns it as an int.

• value: float

• value: The float value to round.

var originalValue = 3.14159f;
var roundedValue = originalValue.RoundToInt(); // roundedValue will be 3

Extension methods for IList to provide additional functionalities such as swapping, replacing, random selection, and shuffling.

Swaps the elements at the specified indices in the list.

• list: IList<T>
• indexA: int
• indexB: int

• list: The list in which to swap elements.
• indexA: The index of the first element to swap.
• indexB: The index of the second element to swap.

var myList = new List<int> { 1, 2, 3, 4 };
myList.Swap(0, 2); // myList is now { 3, 2, 1, 4 }

Swaps the elements at the specified indices in the list.

• list: IList<T>
• itemA: T
• itemB: T

• list: The list in which to swap elements.
• indexA: The index of the first element to swap.
• indexB: The index of the second element to swap.

var myList = new List<int> { 1, 2, 3, 4 };
myList.Swap(0, 2); // myList is now { 3, 2, 1, 4 }

Replaces the first occurrence of a specified value in the list with a new value.

• list: IList<T>
• originalValue: T
• valueToReplace: T

• list: The list in which to replace an element.
• originalValue: The value to be replaced.
• valueToReplace: The new value to insert.

var myList = new List<int> { 1, 2, 3, 4 };
myList.Replace(2, 5); // myList is now { 1, 5, 3, 4 }

Selects a random element from the list.

• list: IList<T>

• list: The list from which to select a random element.

var myList = new List<int> { 1, 2, 3, 4 };
var randomElement = myList.Random(); // randomElement could be any of 1, 2, 3, or 4

Selects a specified number of unique random elements from the list.

• list: IList<T>
• count: int

• list: The list from which to select random elements.
• count: The number of unique random elements to select.

var myList = new List<int> { 1, 2, 3, 4 };
var randomElements = myList.Random(2); // randomElements could be any two of 1, 2, 3, or 4

Method to obtain the next object in the list by passing the current index.

• array: List<T>
• currentIndex: ref int

• CurrentIndex - The index we're currently on inside the list passed as reference so we can automatically assign to it the next index

var myList = new List<int> { 1, 2, 3,4 };
var currentIndex = 0;
var nextItem = myList.Next(ref currentIndex); // nextItem will be 1, currentIndex will be 1
var nextItem2 = myList.Next(ref currentIndex); // nextItem2 will be 2, currentIndex will be 2

Shuffles the elements of the list in place using a cryptographic random number generator.

Code obtained from https://stackoverflow.com/a/1262619

• list: IList<T>

• list: The list to be shuffled.

var myList = new List<int> { 1, 2, 3, 4 };
myList.Shuffle(); // myList could now be { 3, 1, 4, 2 } (example output)

A generic base class that ensures only one instance of a derived class exists at any time.

• T: The type of the derived class.

public class MySingleton : InstancedObject<MySingleton> 
{ 
    // Your class implementation here
}

Provides extension methods for mathematical operations.

Calculates the average of a list of integers, returning 0 if the list is empty.

• list: IEnumerable<int>

• list: The list of integers to calculate the average from.

var numbers = new List<int> { 1, 2, 3, 4 };
int average = numbers.AverageWithNullValidation(); // average will be 2 (rounded down)
var emptyList = new List<int>();
int averageEmpty = emptyList.AverageWithNullValidation(); // averageEmpty will be 0

Calculates the average of a list of doubles, returning 0.0 if the list is empty.

• list: IEnumerable<double>

• list: The list of doubles to calculate the average from.

var numbers = new List<double> { 1.5, 2.5, 3.5 };
double average = numbers.AverageWithNullValidation(); // average will be 2.5
var emptyList = new List<double>();
double averageEmpty = emptyList.AverageWithNullValidation(); // averageEmpty will be 0.0

Calculates the average of a list of floats, returning 0.0f if the list is empty.

• list: IEnumerable<float>

• list: The list of floats to calculate the average from.

var numbers = new List<float> { 1.5f, 2.5f, 3.5f };
float average = numbers.AverageWithNullValidation(); // average will be 2.5f
var emptyList = new List<float>();
float averageEmpty = emptyList.AverageWithNullValidation(); // averageEmpty will be 0.0f

Dictionary like class created to make it easier to display dictionaries in game engines like Unity

Tries to get the value from the NeoDictionary for the given key.

• key: TKey
• value: out TValue

Tries to get the value from the NeoDictionary at the given index.

• index: int
• value: out TValue

Adds a new NeoDictionaryItem to the NeoDictionary.

• key: TKey
• value: TValue

Adds a range of NeoDictionaryItems from another NeoDictionary to the NeoDictionary.

• values: NeoDictionary<TKey, TValue>

Adds a range of NeoDictionaryItems to the NeoDictionary.

• values: IEnumerable<NeoDictionaryItem<TKey, TValue>>

Checks if the NeoDictionary has any items.

Checks if any item in the NeoDictionary satisfies a condition.

• predicate: Func<NeoDictionaryItem<TKey, TValue>, bool>

Filters the NeoDictionary items based on a predicate.

• predicate: Func<NeoDictionaryItem<TKey, TValue>, bool>

Returns the first item of the NeoDictionary or a default value if the NeoDictionary is empty.

Returns the first item of the NeoDictionary that satisfies a condition or a default value if no such item is found.

• predicate: Func<NeoDictionaryItem<TKey, TValue>, bool>

Returns the last item of the NeoDictionary or a default value if the NeoDictionary is empty.

Returns the last item of the NeoDictionary that satisfies a condition or a default value if no such item is found.

• predicate: Func<NeoDictionaryItem<TKey, TValue>, bool>

Projects each item of the NeoDictionary into a new form.

• selector: Func<NeoDictionaryItem<TKey, TValue>, NeoDictionaryItem<TKey, TValue>>

Returns the index of the given NeoDictionaryItem.

• selector: NeoDictionaryItem<TKey, TValue>

Removes the item with the given key.

• key: TKey

Removes the item at the given index.

• index: int

Replaces the value for the given key if it exists.

• key: TKey
• value: TValue

Checks if the NeoDictionary contains the given key.

• key: TKey

Clears all items from the NeoDictionary.

Sorts the NeoDictionary items using the given comparison.

• comparison: Comparison<NeoDictionaryItem<TKey, TValue>>

Returns the number of items in the NeoDictionary.

Performs the given action on each item in the NeoDictionary.

• action: Action<NeoDictionaryItem<TKey, TValue>>

Converts the NeoDictionary items to a List.

Creates a shallow copy of the NeoDictionary.

Reverses the order of the items in the NeoDictionary.

Inserts an item at the given index.

• index: int
• key: TKey
• value: TValue

Inserts a range of items starting from the given index.

• index: int
• values: IEnumerable<NeoDictionaryItem<TKey, TValue>>

Removes a range of items starting from the given index.

• index: int
• count: int

Removes all items matching the given predicate.

• predicate: Func<NeoDictionaryItem<TKey, TValue>, bool>

Finds the index of the first item matching the given predicate.

• predicate: Func<NeoDictionaryItem<TKey, TValue>, bool>

Finds the first item matching the given predicate.

• predicate: Func<NeoDictionaryItem<TKey, TValue>, bool>

Finds all items matching the given predicate.

• predicate: Func<NeoDictionaryItem<TKey, TValue>, bool>

Merges another NeoDictionary into this one, ignoring duplicate keys.

• other: NeoDictionary<TKey, TValue>

Converts the NeoDictionary to a standard Dictionary while safely handling duplicate keys by ignoring them.

Provides extension methods for the string data type.

Truncates the string to a specified maximum number of characters, appending '...' if truncation occurs.

• value: string
• maxChars: int

• value: The string to truncate.
• maxChars: The maximum number of characters allowed before truncation.

var longString = "This is a very long string that needs to be truncated.";
var truncatedString = longString.Truncate(20); // truncatedString will be "This is a very long..."

Checks if the string is null or empty.

• str: string

• str: The string to check.

string myString = "";
bool isNullOrEmpty = myString.IsNullOrEmpty(); // isNullOrEmpty will be true

Checks if the string is not null or empty.

• str: string

• str: The string to check.

string myString = "Hello";
bool isNotNullOrEmpty = myString.IsNotNullOrEmpty(); // isNotNullOrEmpty will be true

Checks if the string matches any of the provided search strings, ignoring case.

• str: string
• search: string[]

• str: The string to check.
• search: An array of strings to match against.

string myString = "Hello";
bool matches = myString.AnyMatch("hi", "hello", "greetings"); // matches will be true

Reverses the characters in the string.

• str: string

• str: The string to reverse.

string myString = "Hello";
string reversedString = myString.Reverse(); // reversedString will be "olleH"