Update Cadru.UnitTest.Framework to support using more fluent extension methods on the standard MS Test Assert (and related) classes. This will keep unit testing code more consistent, so you don't have to know when to use a Cadru specific class (like ConditionAssert) to write code like

var int i1 = 5;
var int i2 = 4;
ConditionAssert.Greater(i1, i2);

Instead, just include the Cadru.UnitTest.Framework namespace and you can write it as

var int i1 = 5;
var int i2 = 4;
Assert.That.Greater(i1, i2);

Some LINQ expressions, like Distinct don't accept lambdas but rather expect an instance of an IEqualityComparer<T>. It would be nice to provide a class that can encapsulate creating an IEqualityComparer<T> that uses a key selector function that can be passed in line to those LINQ expressions which expect one.

Although types support a GetInterfaces() method and a GetInterface() method (which isn't available to PCLs), there isn't an easy way to simply determine if a type implements a given interface.

The standard Enum class in the framework provides a strongly typed TryParse method but not a strongly typed Parse method. Add a strongly typed Enum<T> class which provides a strongly typed Parse method and pass-through methods for the other methods of Enum (and strongly type those that can be).

The additional string extension methods need to be added:

• bool EndsWithAny(this string source, IEnumerable<string> values)
• bool EndsWithAny(this string source, IEnumerable<string> values, StringComparison comparisonType)
• bool EqualsAny(this string source, IEnumerable<string> values)
• bool EqualsAny(this string source, IEnumerable<string> values, StringComparison comparisonType)
• bool StartsWithAny(this string source, IEnumerable<string> values)
• bool StartsWithAny(this string source, IEnumerable<string> values, StringComparison comparisonType)

Add a new extension method to DateTime and DateTimeOffset that returns a string representation of the date as a relative string.

For example, DateTime.Today.ToRelativeDateString() should return Today, 12:00 AM, DateTime.Today.AddDays(-1).ToRelativeDateString() should return Yesterday and so on.

Add a version of the Where filter methods on an enumerable which take a bool which can control if the filter is applied or not.

The test class QueryStringParametersDictionaryTests should have the ExcludeCodeCoverage attribute applied.

The Requires and Assumes classes should provide methods to check if a parameter is of a given Type and if it is an Enum.

The CountryCodes enum in Cadru.Core needs Display, EnumDescription, and UIHint attributes. This requires updating the projects to support .NET Standard 1.1 as the minimum.

Localization attributes, such as DisplayAttribute provide an easy mechanism to retrieve a localized value, but DisplayAttribute is sealed and the LocalizableString class is internal. Provide something similar to LocalizableString so other attributes can be made localization aware easily.

Rewrite Cadru.Postal to support the Razor SDK.

When creating a new UrlBuilder using a URI string that already has a query string, the resulting URL no longer contains the query string.

For example, the following code will create a UrlBuilder whose Query property is empty. It should contain "?foo=bar".

var query = "http://example.com/?foo=bar";
var builder = new UrlBuilder(query);

Investigate using docfx to create static API documentation.

The LeftSubstring and RightSubstring methods should have additional overloads for extracting a substring indexed by char that allows the indexing character value to be excluded or included. The default should be that the character is included.

The AppVeyor builds are failing because it's not targeting C#6. The .sln file has # Visual Studio 14 header (not # Visual Studio 2013); otherwise AppVeyor will force MSBuild 12.0.

The unit test in Cadru.Data.Tests is failing because it relies on a local file. Need to figure out how to do this through AppVeyor.

Enum should have methods to retrieve the value of an EnumDescription attribute applied to an Enum member. It should also have a method which returns a collection of descriptions.

Similarly, the GetDescription method in EnumExtensions should be updated to behave in a similar manner as the one in Enum.

The namespaces in Cadru.AspNetCore still refer to it as Cadru.AspNet and need to be refactored to more closely match the Microsoft.AspNetCore namespaces.

The ExceptionAssert class should have a way to verify that the inner exception of a given exception is of a certain type.

The BoleanExtensions.TryParseAsBoolean extension method currently only supports the following literals:

• False - false, f, no, n
• True - true, t, yes, y

The literals should be expanded to:

• False - false, f, no, n, 0, na, n/a
• True - true, t, yes, y, 1

Add a class which allows easy creation of a range of values. The range should be similar to a mathematical interval and should be able to include or exclude either endpoint (using standard interval notation), provide intersection and union operations, and be enumerable using a default enumeration function or a custom function.

When adding query string parameters to a UriBuilder's QueryParameters dictionary, any existing parameters should be preserved.

The QueryStringParametersDictionary should gain an additional constructor which allows an existing query string to be passed in. The Query property should also be settable.

https://ci.appveyor.com/project/scottdorman/cadru/builds/31867403

Some of the Cadru.Core unit tests are failing due to a missing string resource.

Combine remaining functionality in Cadru.IO into Cadru.Extensions.FileProviders and retire it.

The Cadru.Data.Dapper project needs the <LangVersion>latest</LangVersion> element to be added.

Add a method which returns a slice (or segment) of an enumerable based on a starting and ending index.

When the ExcelDataReader tries to access a field that is a nullable DateTime field and the original value comes in as an empty string, the parsing fails and throws a NullReferenceException rather than returning a null value.

Add an extension method for DateTime and DateTimeOffset which checks if the current date is between two other dates, optionally including the time as part of the check.

The methods in Contracts.Requires should satisfy CA1062 (validate parameters of publicly accessible methods) but some of them don't have the necessary [ValidatedNotNull] attribute so it recognizes that the parameter being passed in is properly being validated.

https://ci.appveyor.com/project/scottdorman/cadru/builds/31867495

Add a method which partitions an enumerable into a collection of smaller enumerable collections all of a certain size. This is different from Slice, which returns a segment, in that

int[] numbers = { 0, 30, 20, 15, 90, 85, 40, 75 };
var partitions = numbers.Partition(3).ToArray();

Assert.AreEqual(3, partitions.Length);
CollectionAssert.AreEqual(new[] { 0, 30, 20 }, partitions[0].ToArray());
CollectionAssert.AreEqual(new[] { 15, 90, 85 }, partitions[1].ToArray());
CollectionAssert.AreEqual(new[] { 40, 75 }, partitions[2].ToArray());

The 'licenseUrl' element will be deprecated. Consider using the 'license' element instead.

A CreateMessage extension method on HttpClient needs to be created so that a MessageRequest can be created with query string parameters. This allows a MessageRequest, and more specifically the Uri of the request to be easily created with query string parameters to get around the limitations of Uri and the HttpClient.GetAsync method.

Useful for debugging and logging purposes, add Json serializers for HttpResponseMessage and HttpRequestMessage.

Add an extension method HasCustomAttribute to Cadru.Core\Extensions\TypeExtensions which simplifies testing a type to test if it contains a custom attribute.

This enum is not a Flags enum and should be renamed to RelativeDateFormatting. This is a breaking change.

Add a new ComparisonComparer(T) that reverses the comparison operation.

While CsvReader had a good run, it makes more sense to use a dedicated CSV parser that is up to date. We're dropping the CsvReader, and all it's associated classes, in favor of using something like CsvHelper or TinyCsvParser

Even though it's simple to just use .AddDays(1) or .AddDays(-1), that isn't as easily recognizable in context as Tomorrow() or Yesterday().