Merge branch 'feature/release-finalization'

Author: michael-damatov

CONTRIBUTING.md

@@ -5,4 +5,6 @@
 - For typos and spelling mistakes feel free to provide a fix and they will be merged as long they comply with the owner's style guide.
 - For code changes always open an issue first. This will allow to determine whether or not the change should take place. The issue should be used to discuss the change.
 
-- If the pull request is accepted the project collaborators preserve the right to fix the code style before merging the changes
+- If the pull request is accepted the project collaborators preserve the right to fix the code style before merging the changes.
+
+- Pull requests must target the `develop` branch. Pull requests to the `master` branch will be declined.

README.md

@@ -1,6 +1,8 @@
-# Lambda Converters [![NuGet](https://img.shields.io/nuget/v/LambdaConverters.svg)](https://www.nuget.org/packages/LambdaConverters) [![ReSharper-Gallery](https://img.shields.io/badge/resharper--gallery-v1.0.0-lightgrey.svg)](https://resharper-plugins.jetbrains.com/packages/LambdaConverters.Annotations)
+# Lambda Converters [![NuGet](https://img.shields.io/nuget/v/LambdaConverters.svg)](https://www.nuget.org/packages/LambdaConverters) [![ReSharper-Gallery](https://img.shields.io/badge/resharper--gallery-v3.0.0-lightgrey.svg)](https://resharper-plugins.jetbrains.com/packages/LambdaConverters.Annotations)
 
-The library allows to create `IValueConverter` and `IMultiValueConverter` objects with the most convenient syntax available, ideally, using the lambda expressions.
+The library allows to create `IValueConverter`, `IMultiValueConverter`, `DataTemplateSelector`, and `ValidationRule` objects with the most convenient syntax available, ideally, using the lambda expressions.
+
+## Lambda Value Converters
 
 First create a (static) class and define your converters as static fields (or properties):
 
@@ -26,19 +28,93 @@ You're done! Just reference the converters with the `x:Static` expressions from
 <TextBlock Text="{Binding model.Heading, Converter={x:Static c:Converters.ToUpperCase}}" />
 ```
 
-## Features
+### Features
 - *strongly-typed* converters
 - resource declaration not needed, just use the `x:Static` expressions
 - separate class for each converter not needed anymore
 - no redundant declarations: if you do not need the `ConvertBack` method, don't define it; otherwise, just put the second lambda expression
 - full support for the remaining parameters of the `Convert` and `ConvertBack` methods: the `culture` and the `parameter` (also strongly-typed) are accessible as well
 - if the conversion fails due to unexpected value types the optional [error strategy](Sources/LambdaConverters.Wpf/ConverterErrorStrategy.cs) can be specified
 
-:bulb: *ReSharper users*: use the Extension Manager to install the external annotations for the library.
+## Lambda Data Template Selectors
+
+The library also allows to create `DataTemplateSelector` objects in the same convenient way as value converters. In order to define a selector simply write a static field (or property) similar to this snippet:
+
+```csharp
+internal static class TemplateSelector
+{
+    public static DataTemplateSelector AlternatingText =
+        LambdaConverters.TemplateSelector.Create<int>(
+            e => e.Item % 2 == 0
+                ? (DataTemplate) ((FrameworkElement) e.Container)?.FindResource("BlackWhite")
+                : (DataTemplate) ((FrameworkElement) e.Container)?.FindResource("WhiteBlack"));
+}
+```
+Use your Lambda DataTemplateSelectors by referencing it with the `x:Static` markup extention (assuming that `s` is the namespace definition for the `TemplateSelector` class):
+
+```xml
+<UserControl.Resources>
+    <DataTemplate x:Key="BlackWhite">
+        <TextBlock Text="{Binding}" Foreground="Black" Background="White" />
+    </DataTemplate>
+    <DataTemplate x:Key="WhiteBlack">
+        <TextBlock Text="{Binding}" Foreground="White" Background="Black" />
+    </DataTemplate>
+</UserControl.Resources>
+<DockPanel>
+    <ListBox ItemsSource="{Binding IntNumbers}"
+             ItemTemplateSelector="{x:Static s:TemplateSelector.AlternatingText}">
+    </ListBox>
+</DockPanel>
+```
+
+Tada! All even numbers from `IntNumbers` are displayed with black font and white background and the odd numbers get the inverse font and background colors.
+
+### Features
+- *strongly-typed* Selectors
+- resource declaration not needed, just use the `x:Static` expressions
+- separate class for each selector not needed anymore
+- full support for the remaining parameter `container`. For example, if you need to grab a `DataTemplate` from where the selector is use (see the example above).
+
+## Lambda Validation Rules
+
+Furthermore, you'll get Lambda ValidationRules on top. By now you know "the drill". First, define a `ValidationRule`object like this:
+
+```csharp
+public static class Rule
+{
+    public static ValidationRule IsNumericString =
+        LambdaConverters.Validator.Create<string>(
+            e => e.Value.All(char.IsDigit)
+                ? ValidationResult.ValidResult
+                : new ValidationResult(false, "Text has non-digit characters!"));
+}
+```
+And then reference your new rule in vour `View` (assuming that `r` is the namespace definition for the `Rule` class):
+```xml
+<TextBox>
+    <TextBox.Text>
+        <Binding Path="Text" UpdateSourceTrigger="PropertyChanged">
+            <Binding.ValidationRules>
+                <x:Static Member="r:Rule.IsNumericString"/>
+            </Binding.ValidationRules>
+        </Binding>
+    </TextBox.Text>
+</TextBox>
+```
+Now, you made sure that only strings which consists of digits are passed to your `ViewModel`.
+
+### Features
+- *strongly-typed* rules
+- resource declaration not needed, just use the `x:Static` expressions
+- separate class for each rule not needed anymore
+- full support for the remaining parameter `culture`
 
 ## Installation
 Use the NuGet package manager to install the package.
 
+:bulb: *ReSharper users*: use the Extension Manager to install the external annotations for the library.
+
 ## Limitations
 The library currently supports the WPF only.