Extended the framework to support DataTemplateSelectors.

Now, DataTemplateSelectors can be created using lambda functions in similar manner as the ValueConverters and MultiValueConverters.
Unlike the converters, the selectors have no interfaces to implement against. Hence, in the implementation the created classes had to derive from the DataTemplateSelector base class. However, this is only an internal implementation detail and won't bother the consumers of this framework too much as it will make minor differences in usage compared to the converters.

Signed-off-by: Dima Enns <[email protected]>

Author: Yeah69

Sources/LambdaConverters.Wpf/EventSource.cs

@@ -13,6 +13,7 @@ internal sealed class EventSource : System.Diagnostics.Tracing.EventSource
         public static class Keywords
         {
             public const EventKeywords Converters = (EventKeywords)0x4;
+            public const EventKeywords Selectors = (EventKeywords)0x8;
         }
 
         [NotNull]
@@ -451,5 +452,63 @@ public void UnableToCastToParameterTypeForBackConversion(
                     memberName,
                     sourceFilePath,
                     sourceLineNumber);
+
+        /// <summary>
+        /// The {0} is null, conversion result is a value according to the specified error strategy ({1}).
+        /// </summary>
+        [Conditional("TRACE")]
+        [Event(
+            22,
+            Version = 0,
+            Message = "The {0} is null, conversion result is a value according to the specified error strategy ({1}).",
+            Level = EventLevel.Warning,
+            Keywords = Keywords.Selectors,
+            Opcode = EventOpcode.Info,
+            Channel = EventChannel.Operational
+        )]
+        public void MissingSelectTemplateFunction(
+            string callback,
+            string errorStrategy,
+            [CallerMemberName] string memberName = null,
+            [CallerFilePath] string sourceFilePath = null,
+            [CallerLineNumber] int sourceLineNumber = 0)
+            =>
+                WriteEvent(
+                    22,
+                    callback,
+                    errorStrategy,
+                    memberName,
+                    sourceFilePath,
+                    sourceLineNumber);
+
+        /// <summary>
+        /// The value ({0}) cannot be cast to the specified input type ({1}), conversion result is a value according to the specified error strategy ({2}).
+        /// </summary>
+        [Conditional("TRACE")]
+        [Event(
+            23,
+            Version = 0,
+            Message = "The value ({0}) cannot be cast to the specified input type ({1}), conversion result is a value according to the specified error strategy ({2}).",
+            Level = EventLevel.Warning,
+            Keywords = Keywords.Selectors,
+            Opcode = EventOpcode.Info,
+            Channel = EventChannel.Operational
+        )]
+        public void UnableToCastToItemType(
+            string itemType,
+            string inputType,
+            string errorStrategy,
+            [CallerMemberName] string memberName = null,
+            [CallerFilePath] string sourceFilePath = null,
+            [CallerLineNumber] int sourceLineNumber = 0)
+            =>
+                WriteEvent(
+                    23,
+                    itemType,
+                    inputType,
+                    errorStrategy,
+                    memberName,
+                    sourceFilePath,
+                    sourceLineNumber);
     }
 }

Sources/LambdaConverters.Wpf/LambdaConverters.Wpf.csproj

@@ -57,7 +57,9 @@
     <Reference Include="WindowsBase" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Selector.cs" />
     <Compile Include="Converter.cs" />
+    <Compile Include="SelectorErrorStrategy.cs" />
     <Compile Include="ConverterErrorStrategy.cs" />
     <Compile Include="EventSource.cs" />
     <Compile Include="MultiValueConverter.cs" />
@@ -66,13 +68,17 @@
     <Compile Include="MultiValueConverterArgs[T].cs" />
     <Compile Include="MultiValueConverterArgs[T].IEquatable[MultiValueConverterArgs[T]].cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="TemplateSelector.cs" />
     <Compile Include="ValueConverter.cs" />
     <Compile Include="ValueConverterArgs[T,P].cs" />
     <Compile Include="ValueConverterArgs[T,P].IEquatable[ValueConverterArgs[T,P]].cs" />
+    <Compile Include="TemplateSelectorArgs[T].cs" />
     <Compile Include="ValueConverterArgs[T].cs" />
+    <Compile Include="TemplateSelectorArgs[T].IEquatable[DataTemplateSelectorArgs[T]].cs" />
     <Compile Include="ValueConverterArgs[T].IEquatable[ValueConverterArgs[T]].cs" />
   </ItemGroup>
   <ItemGroup>
+    <None Include="ClassDiagram1.cd" />
     <None Include="packages.config" />
     <None Include="Properties\LambdaConverters.public.snk" />
   </ItemGroup>

Sources/LambdaConverters.Wpf/Properties/AssemblyInfo.cs

@@ -9,7 +9,7 @@
 [assembly: AssemblyConfiguration("")]
 [assembly: AssemblyCompany("")]
 [assembly: AssemblyProduct("LambdaConverters")]
-[assembly: AssemblyCopyright("© 2016 Michael Damatov.")]
+[assembly: AssemblyCopyright("© 2017 Michael Damatov.")]
 [assembly: AssemblyTrademark("")]
 [assembly: AssemblyCulture("")]
 

Sources/LambdaConverters.Wpf/Selector.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Windows;
+using JetBrains.Annotations;
+
+namespace LambdaConverters
+{
+    internal abstract class Selector : System.Windows.Controls.DataTemplateSelector
+    {
+        internal Selector(
+            SelectorErrorStrategy errorStrategy,
+            object defaultInputTypeValue,
+            [NotNull] Type inputType,
+            bool isConvertFunctionAvailable)
+        {
+            ErrorStrategy = errorStrategy;
+            DefaultInputTypeValue = defaultInputTypeValue;
+            InputType = inputType;
+            IsSelectFunctionAvailable = isConvertFunctionAvailable;
+        }
+
+        internal SelectorErrorStrategy ErrorStrategy { get; }
+
+        internal object DefaultInputTypeValue { get; }
+
+        [NotNull]
+        internal Type InputType { get; }
+
+        internal bool IsSelectFunctionAvailable { get; }
+
+        [Pure]
+        internal DataTemplate GetErrorValue(DataTemplate defaultValue)
+        {
+            switch (ErrorStrategy)
+            {
+                case SelectorErrorStrategy.ReturnDefaultValue:
+                    return defaultValue;
+
+                case SelectorErrorStrategy.ReturnNewEmptyDataTemplate:
+                    return new DataTemplate();
+
+                default:
+                    throw new NotSupportedException();
+            }
+        }
+    }
+}

Sources/LambdaConverters.Wpf/SelectorErrorStrategy.cs

@@ -0,0 +1,21 @@
+using System.Windows.Controls;
+using System.Windows.Data;
+
+namespace LambdaConverters
+{
+    /// <summary>
+    /// Defines the selector error strategy.
+    /// </summary>
+    public enum SelectorErrorStrategy
+    {
+        /// <summary>
+        /// Null is returned.
+        /// </summary>
+        ReturnDefaultValue,
+
+        /// <summary>
+        /// A new and empty data template is returned.
+        /// </summary>
+        ReturnNewEmptyDataTemplate
+    }
+}

Sources/LambdaConverters.Wpf/TemplateSelector.cs

@@ -0,0 +1,103 @@
+using System;
+using System.Diagnostics;
+using System.Windows;
+using System.Windows.Controls;
+using JetBrains.Annotations;
+
+namespace LambdaConverters
+{
+    /// <summary>
+    /// A factory class used to create lambda-based instances of the <see cref="DataTemplateSelector"/> class.
+    /// </summary>
+    public static class TemplateSelector
+    {
+        abstract class Selector : LambdaConverters.Selector
+        {
+            protected Selector(
+                SelectorErrorStrategy errorStrategy,
+                object defaultInputTypeValue,
+                [NotNull] Type inputType,
+                bool isSelectorFunctionAvailable)
+                : base(
+                    errorStrategy,
+                    defaultInputTypeValue,
+                    inputType,
+                    isSelectorFunctionAvailable) { }
+
+            protected abstract DataTemplate SelectTemplateInternal(object item, DependencyObject container);
+
+            public override DataTemplate SelectTemplate(object item, DependencyObject container)
+            {
+                if (!IsSelectFunctionAvailable)
+                {
+                    EventSource.Log.MissingSelectTemplateFunction("selectFunction", ErrorStrategy.ToString());
+
+                    return GetErrorValue(default(DataTemplate));
+                }
+
+                return SelectTemplateInternal(item, container);
+            }
+        }
+
+        sealed class Selector<I> : Selector
+        {
+            readonly Func<TemplateSelectorArgs<I>, DataTemplate> selectFunction;
+
+            internal Selector(
+                Func<TemplateSelectorArgs<I>, DataTemplate> selectFunction,
+                SelectorErrorStrategy errorStrategy)
+                : base(errorStrategy, default(I), typeof(I), selectFunction != null)
+            {
+                this.selectFunction = selectFunction;
+            }
+
+            protected override DataTemplate SelectTemplateInternal(object item, DependencyObject container)
+            {
+                I inputValue;
+                try
+                {
+                    inputValue = (I)item;
+                }
+                catch (SystemException e) when (e is InvalidCastException || e is NullReferenceException)
+                {
+                    EventSource.Log.UnableToCastToInputType(item?.GetType().Name ?? "null", typeof(I).Name, ErrorStrategy.ToString());
+
+                    return GetErrorValue(default(DataTemplate));
+                }
+
+                Debug.Assert(selectFunction != null);
+
+                return selectFunction(new TemplateSelectorArgs<I>(inputValue, container));
+            }
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DataTemplateSelector" /> interface.
+        /// </summary>
+        /// <typeparam name="I">The item type.</typeparam>
+        /// <param name="selectFunction">The <see cref="DataTemplateSelector.SelectTemplate" /> method.</param>
+        /// <param name="errorStrategy">The error strategy.</param>
+        /// <returns>An <see cref="DataTemplateSelector" /> object.</returns>
+        /// <exception cref="ArgumentOutOfRangeException">
+        ///     <paramref name="errorStrategy"/> is not a valid <see cref="SelectorErrorStrategy"/> value.
+        /// </exception>
+        [Pure]
+        [NotNull]
+        public static DataTemplateSelector Create<I>(
+            Func<TemplateSelectorArgs<I>, DataTemplate> selectFunction = null,
+            SelectorErrorStrategy errorStrategy = SelectorErrorStrategy.ReturnDefaultValue)
+        {
+            switch (errorStrategy)
+            {
+                case SelectorErrorStrategy.ReturnDefaultValue:
+                case SelectorErrorStrategy.ReturnNewEmptyDataTemplate:
+                    break;
+
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(errorStrategy));
+            }
+
+            return new Selector<I>(selectFunction, errorStrategy);
+        }
+    }
+}

Sources/LambdaConverters.Wpf/TemplateSelectorArgs[T].IEquatable[DataTemplateSelectorArgs[T]].cs

@@ -0,0 +1,33 @@
+using System;
+using System.Collections.Generic;
+
+namespace LambdaConverters
+{
+    partial struct TemplateSelectorArgs<T> : IEquatable<TemplateSelectorArgs<T>>
+    {
+        /// <summary>
+        /// Implements the operator <c>==</c>.
+        /// </summary>
+        /// <param name="x">The left operand.</param>
+        /// <param name="y">The right operand.</param>
+        /// <returns>The result of the operator.</returns>
+        public static bool operator ==(TemplateSelectorArgs<T> x, TemplateSelectorArgs<T> y) => Equals(x.Item, y.Item) && Equals(x.Container, y.Container);
+
+        /// <summary>
+        /// Implements the operator <c>!=</c>.
+        /// </summary>
+        /// <param name="x">The left operand.</param>
+        /// <param name="y">The right operand.</param>
+        /// <returns>The result of the operator.</returns>
+        public static bool operator !=(TemplateSelectorArgs<T> x, TemplateSelectorArgs<T> y) => !Equals(x.Item, y.Item) || !Equals(x.Container, y.Container);
+
+        /// <inheritdoc />
+        public override int GetHashCode() => EqualityComparer<T>.Default.GetHashCode(Item) ^ (Container?.GetHashCode() ?? 0);
+
+        /// <inheritdoc />
+        public override bool Equals(object obj) => obj is TemplateSelectorArgs<T> && Equals((TemplateSelectorArgs<T>)obj);
+
+        /// <inheritdoc />
+        public bool Equals(TemplateSelectorArgs<T> other) => this == other;
+    }
+}

Sources/LambdaConverters.Wpf/TemplateSelectorArgs[T].cs

@@ -0,0 +1,27 @@
+using System.Windows;
+
+namespace LambdaConverters
+{
+    /// <summary>
+    /// Provides data for selecting data templates.
+    /// </summary>
+    /// <typeparam name="T">The item type.</typeparam>
+    public partial struct TemplateSelectorArgs<T>
+    {
+        internal TemplateSelectorArgs(T item, DependencyObject container)
+        {
+            Item = item;
+            Container = container;
+        }
+
+        /// <summary>
+        /// Gets the item.
+        /// </summary>
+        public T Item { get; }
+
+        /// <summary>
+        /// Gets the container.
+        /// </summary>
+        public DependencyObject Container { get; }
+    }
+}