Archive for the ‘Code Utilities’ Category.

## C# Linq: Find Missing Values in a Sequence of Numbers and Other Sequence Related lists as IEnumerable Extensions I recently had a need to determine if a sequence of integers was solid, not broken, and whether it contained a gap of any missing numbers to report to the end user. I researched the issue and was dismayed that the examples found on the internet seemed to have unnecessary overheads of copied arrays or other artifacts and were too cumbersome for my needs. From that I wrote these C# extensions which work for any .Net above 3.5. Below I document the extension methods to get the missing numbers of a sequence, quickly determine if a sequence is broken and finally report where the existing numbers before the break of the sequence. See the end for the whole extension class for easier copying.

### Problem Definition

If one has a set of numbers say

{ 2, 4, 7, 9 }

it has a broken sequence because there are missing numbers from the set 2-9. Those missing numbers are:

{ 3, 5, 6, 8 }

### Find Missing Numbers In a Sequence

This method is the one I created first. It uses the Linq Aggregate extension to enumerate over the numbers in the set. If there is a gap which is greater than 1 between the numbers (the difference below is > 0 but same concept) then it reports the numbers missing between the two.

```public static IEnumerable<int> SequenceFindMissings(this IList<int> sequence)
{

var missing = new List<int>();

if ((sequence != null) && (sequence.Any()))
{
sequence.Aggregate((seed, aggr) =>
{
var diff = (aggr - seed) - 1;

if (diff > 0)
missing.AddRange(Enumerable.Range((aggr - diff), diff));

return aggr;
});
}

return missing;
}```

### Quickly Determine Broken Sequence

Is the sequence broken from the first number to the last in the set?

```public static bool IsSequenceBroken(this IEnumerable<int> sequence)
{
bool broken = false;

if (sequence != null)
{
var sequenceAsList = sequence.ToList();

if (sequenceAsList.Any())
{
int lastValue = sequence.First();

broken = sequence.Any(value =>
{
if ((value - lastValue) > 1)
return true;

lastValue = value;

return false;
});
}
}

return broken;
}```

### Report Last Valid Number Before The Break

This is useful in situations where one needs to report where the break happens, say the user is editing in a grid and one highlights the existing number which precedes the missing number(s).

Example here returns a 2 and 5 which are the numbers which precede the break.

`   (new List() { 1, 2, 4, 5, 7, 8}).SequenceReportMissingsBreakStarts()`

Here is the method:

```public static IEnumerable<int> SequenceReportMissingsBreakStarts(this IList<int> sequence)
{

var breaks = new List<int>();

if ((sequence != null) && (sequence.Any()))
{

sequence.Aggregate((seed, aggr) =>
{
var diff = (aggr - seed) - 1;

if (diff > 0)
return aggr;
});
}

return breaks;
}```

### Full Extension Source With Comments

Here is the code for an easier copy

```public static class SequenceExtensions
{
/// <summary>
/// Take a sequence of numbers and if there are any gaps greater than 1 between the numbers,
/// report true.
/// </summary>
/// <param name="sequence">A set of numbers to check.</param>
/// <returns>True if the there is a break in the sequence of numbers.</returns>
public static bool IsSequenceBroken(this IEnumerable<int> sequence)
{
bool broken = false;

if (sequence != null)
{
var sequenceAsList = sequence.ToList();

if (sequenceAsList.Any())
{
int lastValue = sequence.First();

broken = sequence.Any(value =>
{
if ((value - lastValue) > 1)
return true;

lastValue = value;

return false;
});
}
}

return broken;
}

/// <summary>
/// Take a sequence of numbers and report the missing numbers. Stop at first break found.
/// </summary>
/// <param name="sequence">Set of Numbers</param>
/// <returns>True of sequence has missing numbers</returns>
public static IEnumerable<int> SequenceFindMissings(this IList<int> sequence)
{

var missing = new List<int>();

if ((sequence != null) && (sequence.Any()))
{
sequence.Aggregate((seed, aggr) =>
{
var diff = (aggr - seed) - 1;

if (diff > 0)
missing.AddRange(Enumerable.Range((aggr - diff), diff));

return aggr;
});
}

return missing;

}

/// <summary>
/// A missing break start in a sequence is where the drop off occurs in the sequence.
/// For example 3, 5, has a missing break start of the #3 for #4 is the missing.
/// </summary>
/// <param name="sequence">Set of Numbers</param>
/// <returns>The list of break numbers which exist before the missing numbers.</returns>
public static IEnumerable<int> SequenceReportMissingsBreakStarts(this IList<int> sequence)
{

var breaks = new List<int>();

if ((sequence != null) && (sequence.Any()))
{

sequence.Aggregate((seed, aggr) =>
{
var diff = (aggr - seed) - 1;

if (diff > 0)
return aggr;
});
}

return breaks;

}
}```

Hope this helps!

## C#: Combine Two Values Together From a List Into Pairs

Sometimes in C# .Net (see Notes section on usage for before .Net 4)  one might have a list of items and want to make them into pairs. Possibly to take those pairs and place the them into a dictionary. If the items are in a list, that list is linear by nature and using linq is not an option when using the extension ToDictionary.

I have created extension methods to create paired values from any list and those methods are named AsPairs and AsPairsSafe. If the list is odd in length, the final number will be combined with the system default for that type as handled in the method AsPairs. If that is not desired then call AsPairsSafe which will skip the last odd value.

Here is the usage of the AsPairs extension on integers and strings:

```var ints = new List<int> { 1, 2, 3, 4, 5 };

IEnumerable<Tuple<int,int>> asTuplePairs = ints.AsPairs();

/* asTuplePairs looks like this(Note value 5 is paired with a default value of 0)
1,2
3,4
5,0
*/

var strings = new List<string> { "Alpha", "Beta", "Gamma", "Delta", "Omega" };

IEnumerable<Tuple<string,string>> asTuplePairsStrings = strings.AsPairs();

/* asTuplePairsStrings (note Omega is paired a default value of Null)
Alpha, Beta
Gamma, Delta
Omega, NULL

Whereas the call to AsPairsSafe would return without Omega:
Alpha, Beta
Gamma, Delta
*/
```

Here are the extension methods:

```public static class MyExtensions
{
// Create Pairs from a list. If the list is odd add a default value for the final pair.
public static IEnumerable<Tuple<T, T>> AsPairs<T>(this List<T> list)
{
int index = 0;

while (index < list.Count())
{
if (index + 1 > list.Count())
yield break;

if (index + 1 == list.Count())
yield return new Tuple<T,T>(list[index++],  default(T));
else
yield return new Tuple<T,T>(list[index++],  list[index++]);
}
}

// Create Pairs from a list. Note if the list is not even in count, the last value is skipped.
public static IEnumerable<Tuple<T, T>> AsPairsSafe<T>(this List<T> list)
{
int index = 0;

while (index < list.Count())
{
if (index + 1 >= list.Count())
yield break;

yield return new Tuple<T,T>(list[index++],  list[index++]);
}

}
}```

### Notes

Tuple is a .Net 4 item. If you are using a previous version of .Net use the KeyValuePair structure instead.

## C#: Access a Resource .resx File and a Corresponding Enum To Create a Dictionary (Update 5/16/2011: Fixed mispelling)
I ran across a situation where the code I was working on had an enum with values and I needed to display a user friendly text which was related to the enum but not the enum’s actual text value.

The standard way of mapping values across cultures is to create a localized resource file(s) (.resx) and to put in string key and a string value, where the value will be shown. The code can then do an if check to map between the two; but that gets laborious real quick. It would be better to have a dictionary where the enum is the key and the value is the value of the resources file.

The following snippet of code takes in an enum and its corresponding resource resx data and creates that dictionary. See the section Steps to Test for an example of its usage.

```/// <summary>
/// Take an enum and a created corresponding resx resource file and join the two together
/// into a dictionary. The dictionaries key is the actual enum and the value is the user readable text
/// found in the value of the resource file.
/// </summary>
/// <typeparam name="T">The Enum type which contains the target enums</typeparam>
/// <param name="rm">The .resx resource's manager which contains the mapped text</param>
/// <returns>A dictionary whose key is the enum and the result is the mapped text in the resource file.</returns>
public static Dictionary<T, string> LoadResourceEnumMappings<T>( ResourceManager rm )
{
T[] eValues = (T[])System.Enum.GetValues( typeof( T ) ); // Gets the actual values of the enum (T) type

// Puts those into a local dictionary/hash for use in later.
var dictEnum = eValues.ToDictionary( it => it.ToString(), it => it );

// Work through the key value pairs (KVP) of the resource set and marry them
// to a new dictionary where the key is the enum and the value output is the user string
// as found in the resource's value of its kvp.
.OfType<DictionaryEntry>()
.ToDictionary( kvp => dictEnum[kvp.Key.ToString()], kvp => kvp.Value.ToString() );

}```
###### NOTES
• One can have more resource keys than enums and the above will work. But if there are more enums than resource keys, the above code will throw a KeyNotFound exception.
###### Enumerate the Embedded Resource

The above code uses the ability to enumerate or iterate the resource file by calling GetResourceSet. That calls returns a Dictionary entry which has the key value pair of the resource file and could be used with a foreach.

###### Steps To Test
1. Create console application
2. Create enum named MappedValues with these enums : Alpha, Beta, Gamma.
```public enum MappedValues
{
Alpha,
Beta,
Gamma
}```
3. Create Resource File named UserText.Resx with these values: Test as such with this code by calling EnumMapper.Usage():

```public static class EnumMapper
{
/// <summary>
/// This is just for show and not meant for production.
/// </summary>
public static void Usage()
{
try
{
Console.WriteLine( "Load resource and show: " + UserText.Alpha );

Dictionary<MappedValues, string> mapped = LoadResourceEnumMappings<MappedValues>( UserText.ResourceManager );

Console.WriteLine( mapped[MappedValues.Alpha] );

Console.WriteLine( mapped[MappedValues.Beta] );

Console.WriteLine( mapped[MappedValues.Gamma] );
}
catch ( KeyNotFoundException )
{
Console.WriteLine("The Resource File has a key which is not found in the enum.");
}

/* outputs (Note "first value" was shown to initialize the ResourceManager otherwise it would be null from GetResourceSet)
Load resource and show: First Value
First Value
Second Item
Third Wave
*/
}

/// <summary>
/// Take an enum and a created corresponding resx resource file and join the two together
/// into a dictionary. The dictionaries key is the actual enum and the value is the user readable text
/// found in the value of the resource file.
/// </summary>
/// <typeparam name="T">The Enum type which contains the target enums</typeparam>
/// <param name="rm">The .resx resource's manager which contains the mapped text</param>
/// <returns>A dictionary whose key is the enum and the result is the mapped text in the resource file.</returns>
public static Dictionary<T, string> LoadResourceEnumMappings<T>( ResourceManager rm )
{
T[] eValues = (T[])System.Enum.GetValues( typeof( T ) ); // Gets the actual values of the enum (T) type

// Puts those into a local dictionary/hash for use in later.
var dictEnum = eValues.ToDictionary( it => it.ToString(), it => it );

// Work through the key value pairs (KVP) of the resource set and marry them
// to a new dictionary where the key is the enum and the value output is the user string
// as found in the resource's value of its kvp.