From 33c1f5083abb8998a621258e3075a71b1d3d17e8 Mon Sep 17 00:00:00 2001
From: Maksym Koshovyi <maximkoshevoi61@gmail.com>
Date: Sat, 23 Jan 2021 11:57:59 +0200
Subject: [PATCH 01/21] Create CommandHelper.shared.cs

---
 .../Helpers/CommandHelper.shared.cs           | 67 +++++++++++++++++++
 1 file changed, 67 insertions(+)
 create mode 100644 src/CommunityToolkit/Xamarin.CommunityToolkit/Helpers/CommandHelper.shared.cs

diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Helpers/CommandHelper.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Helpers/CommandHelper.shared.cs
new file mode 100644
index 000000000..94cfe4c65
--- /dev/null
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Helpers/CommandHelper.shared.cs
@@ -0,0 +1,67 @@
+using System;
+using System.Threading.Tasks;
+using Xamarin.CommunityToolkit.ObjectModel;
+using Xamarin.Forms;
+
+namespace Xamarin.CommunityToolkit.Helpers
+{
+	public static class CommandHelper
+	{
+		public static Command Create(Action execute, Func<bool> canExecute = null) =>
+			new Command(execute, canExecute ?? (() => true));
+
+		public static Command Create<TExecute>(Action<TExecute> execute, Func<bool> canExecute = null) =>
+			new Command(ConvertExecute(execute), ConvertCanExecute(canExecute));
+
+		public static Command Create<TExecute, TCanExecute>(Action<TExecute> execute, Func<TCanExecute, bool> canExecute) =>
+			new Command(ConvertExecute(execute), ConvertCanExecute(canExecute));
+
+		public static IAsyncCommand Create(
+			Func<Task> execute,
+			Func<bool> canExecute = null,
+			Action<Exception> onException = null,
+			bool continueOnCapturedContext = false,
+			bool allowsMultipleExecutions = true) =>
+			new AsyncCommand(execute, canExecute, onException, continueOnCapturedContext, allowsMultipleExecutions);
+
+		public static IAsyncCommand<TExecute> Create<TExecute>(
+			Func<TExecute, Task> execute,
+			Func<bool> canExecute = null,
+			Action<Exception> onException = null,
+			bool continueOnCapturedContext = false,
+			bool allowsMultipleExecutions = true) =>
+			new AsyncCommand<TExecute>(execute, canExecute, onException, continueOnCapturedContext, allowsMultipleExecutions);
+
+		public static IAsyncCommand<TExecute, TCanExecute> Create<TExecute, TCanExecute>(
+			Func<TExecute, Task> execute,
+			Func<TCanExecute, bool> canExecute = null,
+			Action<Exception> onException = null,
+			bool continueOnCapturedContext = false,
+			bool allowsMultipleExecutions = true) =>
+			new AsyncCommand<TExecute, TCanExecute>(execute, canExecute, onException, continueOnCapturedContext, allowsMultipleExecutions);
+
+		static Action<object> ConvertExecute<T>(Action<T> execute)
+		{
+			if (execute is null)
+				return null;
+
+			return e => execute((T)e);
+		}
+
+		static Func<object, bool> ConvertCanExecute(Func<bool> canExecute)
+		{
+			if (canExecute is null)
+				return _ => true;
+
+			return _ => canExecute();
+		}
+
+		static Func<object, bool> ConvertCanExecute<T>(Func<T, bool> canExecute)
+		{
+			if (canExecute is null)
+				return _ => true;
+
+			return e => canExecute((T)e);
+		}
+	}
+}

From 4a12da211bc48a771b347af8bd264fd6e1485b16 Mon Sep 17 00:00:00 2001
From: Maksym Koshovyi <maximkoshevoi61@gmail.com>
Date: Sat, 23 Jan 2021 12:40:06 +0200
Subject: [PATCH 02/21] Use CommandHelper in Sample app

---
 samples/XCT.Sample/Pages/AboutPage.xaml       |  6 ++++-
 samples/XCT.Sample/Pages/AboutPage.xaml.cs    | 11 ---------
 samples/XCT.Sample/Pages/Base/BasePage.cs     |  8 +++----
 .../ByteArrayToImageSourcePage.xaml           |  4 ++++
 .../ByteArrayToImageSourcePage.xaml.cs        | 10 +-------
 .../Pages/Effects/TouchEffectPage.xaml.cs     |  8 +++----
 .../TestCases/TouchEffectButtonPage.xaml.cs   | 11 +++++----
 .../XCT.Sample/ViewModels/AboutViewModel.cs   | 24 ++++++++++++-------
 .../ViewModels/Base/BaseGalleryViewModel.cs   | 13 +++++-----
 .../EventToCommandBehaviorViewModel.cs        |  9 +++----
 .../MaxLengthReachedBehaviorViewModel.cs      |  4 ++--
 .../UserStoppedTypingBehaviorViewModel.cs     |  4 ++--
 .../ByteArrayToImageSourceViewModel.cs        |  7 ++++++
 .../ItemSelectedEventArgsViewModel.cs         |  6 ++---
 .../ItemTappedEventArgsViewModel.cs           |  6 ++---
 .../Converters/ListIsNullOrEmptyViewModel.cs  |  7 +++---
 .../ViewModels/Markup/SearchViewModel.cs      | 19 +++++++++------
 .../XCT.Sample/ViewModels/SettingViewModel.cs | 16 +++++++------
 .../ViewModels/Views/BadgeViewViewModel.cs    | 15 ++++++++----
 .../ViewModels/Views/ExpanderViewModel.cs     | 22 +++++++++--------
 .../Views/GravatarImageViewModel.cs           | 16 ++++---------
 .../ViewModels/Views/StateLayoutViewModel.cs  | 21 ++++------------
 .../Views/TabItemsSourceViewModel.cs          |  8 +++++--
 23 files changed, 130 insertions(+), 125 deletions(-)

diff --git a/samples/XCT.Sample/Pages/AboutPage.xaml b/samples/XCT.Sample/Pages/AboutPage.xaml
index 8fbf440c9..9abebc964 100644
--- a/samples/XCT.Sample/Pages/AboutPage.xaml
+++ b/samples/XCT.Sample/Pages/AboutPage.xaml
@@ -14,7 +14,11 @@
     <pages:BasePage.BindingContext>
         <viewmodels:AboutViewModel />
     </pages:BasePage.BindingContext>
-    
+
+    <ContentPage.Behaviors>
+        <xct:EventToCommandBehavior EventName="Appearing" Command="{Binding PageAppearingCommand}"/>
+    </ContentPage.Behaviors>
+
     <pages:BasePage.Content>
         <StackLayout Padding="{StaticResource ContentPadding}">
             <Label Text="Thank you Xamarin Community Toolkit contributors"
diff --git a/samples/XCT.Sample/Pages/AboutPage.xaml.cs b/samples/XCT.Sample/Pages/AboutPage.xaml.cs
index b572e8a75..b4973351f 100644
--- a/samples/XCT.Sample/Pages/AboutPage.xaml.cs
+++ b/samples/XCT.Sample/Pages/AboutPage.xaml.cs
@@ -1,9 +1,4 @@
 using System;
-using System.Linq;
-using Octokit;
-using Xamarin.CommunityToolkit.Sample.ViewModels;
-using Xamarin.Essentials;
-using Xamarin.Forms;
 
 namespace Xamarin.CommunityToolkit.Sample.Pages
 {
@@ -12,12 +7,6 @@ public partial class AboutPage : BasePage
 		public AboutPage()
 			=> InitializeComponent();
 
-		protected override async void OnAppearing()
-		{
-			base.OnAppearing();
-			await ((AboutViewModel)BindingContext).OnAppearing();
-		}
-
 		async void OnCloseClicked(object sender, EventArgs e)
 			=> await Navigation.PopModalAsync();
 	}
diff --git a/samples/XCT.Sample/Pages/Base/BasePage.cs b/samples/XCT.Sample/Pages/Base/BasePage.cs
index 2be0fcda1..d5a4195b9 100644
--- a/samples/XCT.Sample/Pages/Base/BasePage.cs
+++ b/samples/XCT.Sample/Pages/Base/BasePage.cs
@@ -1,6 +1,6 @@
 using System;
 using System.Windows.Input;
-using Xamarin.CommunityToolkit.ObjectModel;
+using Xamarin.CommunityToolkit.Helpers;
 using Xamarin.CommunityToolkit.Sample.Models;
 using Xamarin.Forms;
 
@@ -8,12 +8,12 @@ namespace Xamarin.CommunityToolkit.Sample.Pages
 {
 	public class BasePage : ContentPage
 	{
-		ICommand navigateCommand;
+		public BasePage() =>
+			NavigateCommand = CommandHelper.Create<SectionModel>(sectionModel => Navigation.PushAsync(PreparePage(sectionModel)));
 
 		public Color DetailColor { get; set; }
 
-		public ICommand NavigateCommand => navigateCommand ??= new AsyncCommand<SectionModel>(sectionModel
-			=> Navigation.PushAsync(PreparePage(sectionModel)));
+		public ICommand NavigateCommand { get; }
 
 		Page PreparePage(SectionModel model)
 		{
diff --git a/samples/XCT.Sample/Pages/Converters/ByteArrayToImageSourcePage.xaml b/samples/XCT.Sample/Pages/Converters/ByteArrayToImageSourcePage.xaml
index 9626aa116..e20a5eba9 100644
--- a/samples/XCT.Sample/Pages/Converters/ByteArrayToImageSourcePage.xaml
+++ b/samples/XCT.Sample/Pages/Converters/ByteArrayToImageSourcePage.xaml
@@ -16,6 +16,10 @@
          </ResourceDictionary>
     </ContentPage.Resources>
 
+    <ContentPage.Behaviors>
+        <xct:EventToCommandBehavior EventName="Appearing" Command="{Binding PageAppearingCommand}"/>
+    </ContentPage.Behaviors>
+
     <pages:BasePage.Content>
 
         <StackLayout Orientation="Vertical" VerticalOptions="Center">
diff --git a/samples/XCT.Sample/Pages/Converters/ByteArrayToImageSourcePage.xaml.cs b/samples/XCT.Sample/Pages/Converters/ByteArrayToImageSourcePage.xaml.cs
index d210f54fa..7c8d935e3 100644
--- a/samples/XCT.Sample/Pages/Converters/ByteArrayToImageSourcePage.xaml.cs
+++ b/samples/XCT.Sample/Pages/Converters/ByteArrayToImageSourcePage.xaml.cs
@@ -1,16 +1,8 @@
-using Xamarin.CommunityToolkit.Sample.ViewModels.Converters;
-
-namespace Xamarin.CommunityToolkit.Sample.Pages.Converters
+namespace Xamarin.CommunityToolkit.Sample.Pages.Converters
 {
 	public partial class ByteArrayToImageSourcePage : BasePage
 	{
 		public ByteArrayToImageSourcePage()
 			=> InitializeComponent();
-
-		protected override async void OnAppearing()
-		{
-			base.OnAppearing();
-			await ((ByteArrayToImageSourceViewModel)BindingContext).OnAppearing();
-		}
 	}
 }
\ No newline at end of file
diff --git a/samples/XCT.Sample/Pages/Effects/TouchEffectPage.xaml.cs b/samples/XCT.Sample/Pages/Effects/TouchEffectPage.xaml.cs
index deefe1f7b..04867270d 100644
--- a/samples/XCT.Sample/Pages/Effects/TouchEffectPage.xaml.cs
+++ b/samples/XCT.Sample/Pages/Effects/TouchEffectPage.xaml.cs
@@ -1,5 +1,5 @@
 using System.Windows.Input;
-using Xamarin.Forms;
+using Xamarin.CommunityToolkit.Helpers;
 using Xamarin.Forms.Xaml;
 
 namespace Xamarin.CommunityToolkit.Sample.Pages.Effects
@@ -9,18 +9,18 @@ public partial class TouchEffectPage
 	{
 		public TouchEffectPage()
 		{
-			Command = new Command(() =>
+			Command = CommandHelper.Create(() =>
 			{
 				TouchCount++;
 				OnPropertyChanged(nameof(TouchCount));
 			});
-			LongPressCommand = new Command(() =>
+			LongPressCommand = CommandHelper.Create(() =>
 			{
 				LongPressCount++;
 				OnPropertyChanged(nameof(LongPressCount));
 			});
-			InitializeComponent();
 
+			InitializeComponent();
 		}
 
 		public ICommand Command { get; }
diff --git a/samples/XCT.Sample/Pages/TestCases/TouchEffectButtonPage.xaml.cs b/samples/XCT.Sample/Pages/TestCases/TouchEffectButtonPage.xaml.cs
index e26068c55..50e70d81a 100644
--- a/samples/XCT.Sample/Pages/TestCases/TouchEffectButtonPage.xaml.cs
+++ b/samples/XCT.Sample/Pages/TestCases/TouchEffectButtonPage.xaml.cs
@@ -1,15 +1,16 @@
 using System.Windows.Input;
-using Xamarin.Forms;
+using Xamarin.CommunityToolkit.Helpers;
 
 namespace Xamarin.CommunityToolkit.Sample.Pages.TestCases
 {
 	public partial class TouchEffectButtonPage
 	{
-		ICommand command;
-
 		public TouchEffectButtonPage()
-			=> InitializeComponent();
+		{
+			Command = CommandHelper.Create(() => DisplayAlert("Command executed ", null, "OK"));
+			InitializeComponent();
+		}
 
-		public ICommand Command => command ??= new Command(() => this.DisplayAlert("Command executed ", null, "OK"));
+		public ICommand Command { get; }
 	}
 }
\ No newline at end of file
diff --git a/samples/XCT.Sample/ViewModels/AboutViewModel.cs b/samples/XCT.Sample/ViewModels/AboutViewModel.cs
index 816d2627b..86e01efc2 100644
--- a/samples/XCT.Sample/ViewModels/AboutViewModel.cs
+++ b/samples/XCT.Sample/ViewModels/AboutViewModel.cs
@@ -3,7 +3,7 @@
 using System.Threading.Tasks;
 using System.Windows.Input;
 using Octokit;
-using Xamarin.CommunityToolkit.ObjectModel;
+using Xamarin.CommunityToolkit.Helpers;
 using Xamarin.Essentials;
 
 namespace Xamarin.CommunityToolkit.Sample.ViewModels
@@ -18,7 +18,18 @@ public class AboutViewModel : BaseViewModel
 
 		string emptyViewText = "Loading data...";
 
-		ICommand selectedContributorCommand;
+		public AboutViewModel()
+		{
+			PageAppearingCommand = CommandHelper.Create(OnAppearing);
+			SelectedContributorCommand = CommandHelper.Create(async () =>
+			{
+				if (SelectedContributor is null)
+					return;
+
+				await Launcher.OpenAsync(SelectedContributor.HtmlUrl);
+				SelectedContributor = null;
+			});
+		}
 
 		public RepositoryContributor[] Contributors
 		{
@@ -38,14 +49,9 @@ public string EmptyViewText
 			set => SetProperty(ref emptyViewText, value);
 		}
 
-		public ICommand SelectedContributorCommand => selectedContributorCommand ??= new AsyncCommand(async () =>
-		{
-			if (SelectedContributor is null)
-				return;
+		public ICommand PageAppearingCommand { get; }
 
-			await Launcher.OpenAsync(SelectedContributor.HtmlUrl);
-			SelectedContributor = null;
-		});
+		public ICommand SelectedContributorCommand { get; }
 
 		public async Task OnAppearing()
 		{
diff --git a/samples/XCT.Sample/ViewModels/Base/BaseGalleryViewModel.cs b/samples/XCT.Sample/ViewModels/Base/BaseGalleryViewModel.cs
index c8fc9da42..ad72b07aa 100644
--- a/samples/XCT.Sample/ViewModels/Base/BaseGalleryViewModel.cs
+++ b/samples/XCT.Sample/ViewModels/Base/BaseGalleryViewModel.cs
@@ -2,23 +2,24 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Windows.Input;
-using Xamarin.CommunityToolkit.ObjectModel;
+using Xamarin.CommunityToolkit.Helpers;
 using Xamarin.CommunityToolkit.Sample.Models;
-using Xamarin.Forms;
 
 namespace Xamarin.CommunityToolkit.Sample.ViewModels
 {
 	public abstract class BaseGalleryViewModel : BaseViewModel
 	{
-		ICommand filterCommand;
-
-		public BaseGalleryViewModel() => Filter();
+		public BaseGalleryViewModel()
+		{
+			Filter();
+			FilterCommand = CommandHelper.Create(Filter);
+		}
 
 		public abstract IEnumerable<SectionModel> Items { get; }
 
 		public IEnumerable<SectionModel> FilteredItems { get; private set; }
 
-		public ICommand FilterCommand => filterCommand ??= new Command(Filter);
+		public ICommand FilterCommand { get; }
 
 		public string FilterValue { private get; set; }
 
diff --git a/samples/XCT.Sample/ViewModels/Behaviors/EventToCommandBehaviorViewModel.cs b/samples/XCT.Sample/ViewModels/Behaviors/EventToCommandBehaviorViewModel.cs
index 57b8672b3..0553ae76f 100644
--- a/samples/XCT.Sample/ViewModels/Behaviors/EventToCommandBehaviorViewModel.cs
+++ b/samples/XCT.Sample/ViewModels/Behaviors/EventToCommandBehaviorViewModel.cs
@@ -1,20 +1,21 @@
 using System.Windows.Input;
-using Xamarin.Forms;
+using Xamarin.CommunityToolkit.Helpers;
 
 namespace Xamarin.CommunityToolkit.Sample.ViewModels.Behaviors
 {
 	public class EventToCommandBehaviorViewModel : BaseViewModel
 	{
-		ICommand incrementCommand;
-
 		int clickCount;
 
-		public ICommand IncrementCommand => incrementCommand ??= new Command(() => ClickCount++);
+		public EventToCommandBehaviorViewModel() =>
+			IncrementCommand = CommandHelper.Create(() => ClickCount++);
 
 		public int ClickCount
 		{
 			get => clickCount;
 			set => SetProperty(ref clickCount, value);
 		}
+
+		public ICommand IncrementCommand { get; }
 	}
 }
\ No newline at end of file
diff --git a/samples/XCT.Sample/ViewModels/Behaviors/MaxLengthReachedBehaviorViewModel.cs b/samples/XCT.Sample/ViewModels/Behaviors/MaxLengthReachedBehaviorViewModel.cs
index 87056411a..e8280eeec 100644
--- a/samples/XCT.Sample/ViewModels/Behaviors/MaxLengthReachedBehaviorViewModel.cs
+++ b/samples/XCT.Sample/ViewModels/Behaviors/MaxLengthReachedBehaviorViewModel.cs
@@ -1,6 +1,6 @@
 using System;
 using System.Windows.Input;
-using Xamarin.Forms;
+using Xamarin.CommunityToolkit.Helpers;
 
 namespace Xamarin.CommunityToolkit.Sample.ViewModels.Behaviors
 {
@@ -17,7 +17,7 @@ public string CommandExecutions
 		public ICommand MaxLengthReachedCommand { get; }
 
 		public MaxLengthReachedBehaviorViewModel()
-			=> MaxLengthReachedCommand = new Command<string>(OnCommandExecuted);
+			=> MaxLengthReachedCommand = CommandHelper.Create<string>(OnCommandExecuted);
 
 		void OnCommandExecuted(string text)
 			=> CommandExecutions += string.Format("MaxLength reached with value: '{0}'.", text) + Environment.NewLine;
diff --git a/samples/XCT.Sample/ViewModels/Behaviors/UserStoppedTypingBehaviorViewModel.cs b/samples/XCT.Sample/ViewModels/Behaviors/UserStoppedTypingBehaviorViewModel.cs
index a80440737..7aae3fecd 100644
--- a/samples/XCT.Sample/ViewModels/Behaviors/UserStoppedTypingBehaviorViewModel.cs
+++ b/samples/XCT.Sample/ViewModels/Behaviors/UserStoppedTypingBehaviorViewModel.cs
@@ -1,6 +1,6 @@
 using System;
 using System.Windows.Input;
-using Xamarin.Forms;
+using Xamarin.CommunityToolkit.Helpers;
 
 namespace Xamarin.CommunityToolkit.Sample.ViewModels.Behaviors
 {
@@ -21,7 +21,7 @@ public string PerformedSearches
 		#endregion Properties
 
 		public UserStoppedTypingBehaviorViewModel()
-			=> SearchCommand = new Command<string>(PerformSearch);
+			=> SearchCommand = CommandHelper.Create<string>(PerformSearch);
 
 		void PerformSearch(string searchTerms)
 			=> PerformedSearches += string.Format("Performed search for '{0}'.", searchTerms) + Environment.NewLine;
diff --git a/samples/XCT.Sample/ViewModels/Converters/ByteArrayToImageSourceViewModel.cs b/samples/XCT.Sample/ViewModels/Converters/ByteArrayToImageSourceViewModel.cs
index 195c042fd..91ddb97c5 100644
--- a/samples/XCT.Sample/ViewModels/Converters/ByteArrayToImageSourceViewModel.cs
+++ b/samples/XCT.Sample/ViewModels/Converters/ByteArrayToImageSourceViewModel.cs
@@ -1,7 +1,9 @@
 using System.Linq;
 using System.Net.Http;
 using System.Threading.Tasks;
+using System.Windows.Input;
 using Octokit;
+using Xamarin.CommunityToolkit.Helpers;
 
 namespace Xamarin.CommunityToolkit.Sample.ViewModels.Converters
 {
@@ -25,6 +27,11 @@ public bool IsBusy
 			set => SetProperty(ref isBusy, value);
 		}
 
+		public ICommand PageAppearingCommand { get; }
+
+		public ByteArrayToImageSourceViewModel() =>
+			PageAppearingCommand = CommandHelper.Create(OnAppearing);
+
 		public async Task OnAppearing()
 		{
 			try
diff --git a/samples/XCT.Sample/ViewModels/Converters/ItemSelectedEventArgsViewModel.cs b/samples/XCT.Sample/ViewModels/Converters/ItemSelectedEventArgsViewModel.cs
index 77f2268fa..89c12a938 100644
--- a/samples/XCT.Sample/ViewModels/Converters/ItemSelectedEventArgsViewModel.cs
+++ b/samples/XCT.Sample/ViewModels/Converters/ItemSelectedEventArgsViewModel.cs
@@ -1,6 +1,6 @@
 using System.Collections.Generic;
 using System.Windows.Input;
-using Xamarin.CommunityToolkit.ObjectModel;
+using Xamarin.CommunityToolkit.Helpers;
 using Xamarin.Forms;
 
 namespace Xamarin.CommunityToolkit.Sample.ViewModels.Converters
@@ -15,7 +15,7 @@ public class ItemSelectedEventArgsViewModel
 				new Person() { Id = 3, Name = "Person 3" }
 			};
 
-		public ICommand ItemSelectedCommand { get; private set; } = new AsyncCommand<Person>(person
-			=> Application.Current.MainPage.DisplayAlert("Item Tapped: ", person.Name, "Cancelf"));
+		public ICommand ItemSelectedCommand { get; } =
+			CommandHelper.Create<Person>(person => Application.Current.MainPage.DisplayAlert("Item Tapped: ", person.Name, "Cancelf"));
 	}
 }
\ No newline at end of file
diff --git a/samples/XCT.Sample/ViewModels/Converters/ItemTappedEventArgsViewModel.cs b/samples/XCT.Sample/ViewModels/Converters/ItemTappedEventArgsViewModel.cs
index 7f53249d1..e1e3043ea 100644
--- a/samples/XCT.Sample/ViewModels/Converters/ItemTappedEventArgsViewModel.cs
+++ b/samples/XCT.Sample/ViewModels/Converters/ItemTappedEventArgsViewModel.cs
@@ -1,6 +1,6 @@
 using System.Collections.Generic;
 using System.Windows.Input;
-using Xamarin.CommunityToolkit.ObjectModel;
+using Xamarin.CommunityToolkit.Helpers;
 using Xamarin.Forms;
 
 namespace Xamarin.CommunityToolkit.Sample.ViewModels.Converters
@@ -15,8 +15,8 @@ public class ItemTappedEventArgsViewModel
 				new Person() { Id = 3, Name = "Person 3" }
 			};
 
-		public ICommand ItemTappedCommand { get; private set; } = new AsyncCommand<Person>(person
-			=> Application.Current.MainPage.DisplayAlert("Item Tapped: ", person.Name, "Cancel"));
+		public ICommand ItemTappedCommand { get; } =
+			CommandHelper.Create<Person>(person => Application.Current.MainPage.DisplayAlert("Item Tapped: ", person.Name, "Cancel"));
 	}
 
 	public class Person
diff --git a/samples/XCT.Sample/ViewModels/Converters/ListIsNullOrEmptyViewModel.cs b/samples/XCT.Sample/ViewModels/Converters/ListIsNullOrEmptyViewModel.cs
index 392a6415a..be31939f8 100644
--- a/samples/XCT.Sample/ViewModels/Converters/ListIsNullOrEmptyViewModel.cs
+++ b/samples/XCT.Sample/ViewModels/Converters/ListIsNullOrEmptyViewModel.cs
@@ -1,4 +1,5 @@
-using Xamarin.CommunityToolkit.ObjectModel;
+using Xamarin.CommunityToolkit.Helpers;
+using Xamarin.CommunityToolkit.ObjectModel;
 using Xamarin.Forms;
 
 namespace Xamarin.CommunityToolkit.Sample.ViewModels.Converters
@@ -9,7 +10,7 @@ public class ListIsNullOrEmptyViewModel : BaseViewModel
 
 		public ListIsNullOrEmptyViewModel()
 		{
-			AddItemCommand = new Command(() =>
+			AddItemCommand = CommandHelper.Create(() =>
 			{
 				Items.Add(new Person
 				{
@@ -17,7 +18,7 @@ public ListIsNullOrEmptyViewModel()
 					Name = $"Person {Items.Count}"
 				});
 			});
-			RemoveItemCommand = new Command(() => Items.RemoveAt(0));
+			RemoveItemCommand = CommandHelper.Create(() => Items.RemoveAt(0));
 
 			// ListIsNullOrEmptyConvertor needs to know that Items are updated
 			Items.CollectionChanged += (sender, e) => OnPropertyChanged(nameof(Items));
diff --git a/samples/XCT.Sample/ViewModels/Markup/SearchViewModel.cs b/samples/XCT.Sample/ViewModels/Markup/SearchViewModel.cs
index e9c21cfed..588083a79 100644
--- a/samples/XCT.Sample/ViewModels/Markup/SearchViewModel.cs
+++ b/samples/XCT.Sample/ViewModels/Markup/SearchViewModel.cs
@@ -8,8 +8,6 @@ namespace Xamarin.CommunityToolkit.Sample.ViewModels.Markup
 {
 	public class SearchViewModel : BaseViewModel
 	{
-		ICommand backCommand, likeCommand, openTwitterSearchCommand, openHelpCommand;
-
 		public string SearchText { get; set; }
 
 		public List<Tweet> SearchResults { get; set; }
@@ -54,17 +52,24 @@ public SearchViewModel()
 					},
 				}
 			};
+
+			BackCommand = new RelayCommand(Back);
+			LikeCommand = new RelayCommand<Tweet>(Like);
+			OpenTwitterSearchCommand = new RelayCommandAsync(OpenTwitterSearch);
+			OpenHelpCommand = new RelayCommandAsync(OpenHelp);
 		}
 
-		public ICommand BackCommand => backCommand ??= new RelayCommand(Back);
+		public ICommand BackCommand { get; }
 
-		public ICommand LikeCommand => likeCommand ??= new RelayCommand<Tweet>(Like);
+		public ICommand LikeCommand { get; }
 
-		public ICommand OpenTwitterSearchCommand => openTwitterSearchCommand ??= new RelayCommandAsync(OpenTwitterSearch);
+		public ICommand OpenTwitterSearchCommand { get; }
 
-		public ICommand OpenHelpCommand => openHelpCommand ??= new RelayCommandAsync(OpenHelp);
+		public ICommand OpenHelpCommand { get; }
 
-		void Back() { }
+		void Back()
+		{
+		}
 
 		void Like(Tweet tweet) => tweet.IsLikedByMe = !tweet.IsLikedByMe;
 
diff --git a/samples/XCT.Sample/ViewModels/SettingViewModel.cs b/samples/XCT.Sample/ViewModels/SettingViewModel.cs
index dd834e376..2571125d1 100644
--- a/samples/XCT.Sample/ViewModels/SettingViewModel.cs
+++ b/samples/XCT.Sample/ViewModels/SettingViewModel.cs
@@ -6,14 +6,11 @@
 using Xamarin.CommunityToolkit.Sample.Models;
 using Xamarin.CommunityToolkit.Sample.Resx;
 using Xamarin.Essentials;
-using Xamarin.Forms;
 
 namespace Xamarin.CommunityToolkit.Sample.ViewModels
 {
 	public class SettingViewModel : BaseViewModel
 	{
-		public SettingViewModel() => LoadLanguages();
-
 		IList<Language> supportedLanguages;
 
 		public IList<Language> SupportedLanguages
@@ -32,13 +29,18 @@ public Language SelectedLanguage
 
 		public LocalizedString AppVersion { get; } = new LocalizedString(() => string.Format(AppResources.Version, AppInfo.VersionString));
 
-		ICommand changeLanguageCommand;
+		public ICommand ChangeLanguageCommand { get; }
 
-		public ICommand ChangeLanguageCommand => changeLanguageCommand ??= new Command(() =>
+		public SettingViewModel()
 		{
-			LocalizationResourceManager.Current.SetCulture(CultureInfo.GetCultureInfo(SelectedLanguage.CI));
 			LoadLanguages();
-		});
+
+			ChangeLanguageCommand = CommandHelper.Create(() =>
+			{
+				LocalizationResourceManager.Current.SetCulture(CultureInfo.GetCultureInfo(SelectedLanguage.CI));
+				LoadLanguages();
+			});
+		}
 
 		void LoadLanguages()
 		{
diff --git a/samples/XCT.Sample/ViewModels/Views/BadgeViewViewModel.cs b/samples/XCT.Sample/ViewModels/Views/BadgeViewViewModel.cs
index 0aea46870..5bddee67f 100644
--- a/samples/XCT.Sample/ViewModels/Views/BadgeViewViewModel.cs
+++ b/samples/XCT.Sample/ViewModels/Views/BadgeViewViewModel.cs
@@ -1,5 +1,5 @@
 using System.Windows.Input;
-using Xamarin.Forms;
+using Xamarin.CommunityToolkit.Helpers;
 
 namespace Xamarin.CommunityToolkit.Sample.ViewModels.Views
 {
@@ -7,12 +7,17 @@ public class BadgeViewViewModel : BaseViewModel
 	{
 		int counter;
 
-		public BadgeViewViewModel() => Counter = 3;
+		public BadgeViewViewModel()
+		{
+			Counter = 3;
+
+			IncreaseCommand = CommandHelper.Create(Increase);
+			DecreaseCommand = CommandHelper.Create(Decrease);
+		}
 
 		public int Counter
 		{
 			get => counter;
-
 			set
 			{
 				counter = value;
@@ -20,9 +25,9 @@ public int Counter
 			}
 		}
 
-		public ICommand IncreaseCommand => new Command(Increase);
+		public ICommand IncreaseCommand { get; }
 
-		public ICommand DecreaseCommand => new Command(Decrease);
+		public ICommand DecreaseCommand { get; }
 
 		void Increase() => Counter++;
 
diff --git a/samples/XCT.Sample/ViewModels/Views/ExpanderViewModel.cs b/samples/XCT.Sample/ViewModels/Views/ExpanderViewModel.cs
index 98e1d5e2d..7960fc4e5 100644
--- a/samples/XCT.Sample/ViewModels/Views/ExpanderViewModel.cs
+++ b/samples/XCT.Sample/ViewModels/Views/ExpanderViewModel.cs
@@ -1,21 +1,23 @@
 using System.Windows.Input;
-using Xamarin.Forms;
+using Xamarin.CommunityToolkit.Helpers;
 
 namespace Xamarin.CommunityToolkit.Sample.ViewModels.Views
 {
 	public partial class ExpanderViewModel : BaseViewModel
 	{
-		ICommand command;
-
-		public ICommand Command => command ??= new Command(p =>
+		public ExpanderViewModel()
 		{
-			var sender = (Item)p;
-			if (!sender.IsExpanded)
-				return;
+			Command = CommandHelper.Create<Item>(sender =>
+			{
+				if (!sender.IsExpanded)
+					return;
+
+				foreach (var item in Items)
+					item.IsExpanded = sender == item;
+			});
+		}
 
-			foreach (var item in Items)
-				item.IsExpanded = sender == item;
-		});
+		public ICommand Command { get; }
 
 		public Item[] Items { get; } = new Item[]
 		{
diff --git a/samples/XCT.Sample/ViewModels/Views/GravatarImageViewModel.cs b/samples/XCT.Sample/ViewModels/Views/GravatarImageViewModel.cs
index 4bb4d8559..89114a1b5 100644
--- a/samples/XCT.Sample/ViewModels/Views/GravatarImageViewModel.cs
+++ b/samples/XCT.Sample/ViewModels/Views/GravatarImageViewModel.cs
@@ -1,4 +1,6 @@
-using Xamarin.CommunityToolkit.UI.Views;
+using System;
+using System.Linq;
+using Xamarin.CommunityToolkit.UI.Views;
 
 namespace Xamarin.CommunityToolkit.Sample.ViewModels.Views
 {
@@ -9,17 +11,7 @@ public class GravatarImageViewModel : BaseViewModel
 		int size = 50;
 		DefaultGravatar defaultGravatar = DefaultGravatar.MysteryPerson;
 
-		public DefaultGravatar[] Defaults { get; } = new[]
-		{
-			DefaultGravatar.Blank,
-			DefaultGravatar.FileNotFound,
-			DefaultGravatar.Identicon,
-			DefaultGravatar.MonsterId,
-			DefaultGravatar.MysteryPerson,
-			DefaultGravatar.Retro,
-			DefaultGravatar.Robohash,
-			DefaultGravatar.Wavatar
-		};
+		public DefaultGravatar[] Defaults { get; } = Enum.GetValues(typeof(DefaultGravatar)).Cast<DefaultGravatar>().ToArray();
 
 		public bool EnableCache
 		{
diff --git a/samples/XCT.Sample/ViewModels/Views/StateLayoutViewModel.cs b/samples/XCT.Sample/ViewModels/Views/StateLayoutViewModel.cs
index 68b673a2c..9b0791e70 100644
--- a/samples/XCT.Sample/ViewModels/Views/StateLayoutViewModel.cs
+++ b/samples/XCT.Sample/ViewModels/Views/StateLayoutViewModel.cs
@@ -1,14 +1,12 @@
 using System.Threading.Tasks;
 using System.Windows.Input;
+using Xamarin.CommunityToolkit.Helpers;
 using Xamarin.CommunityToolkit.UI.Views;
-using Xamarin.Forms;
 
 namespace Xamarin.CommunityToolkit.Sample.ViewModels.Views
 {
 	public class StateLayoutViewModel : BaseViewModel
 	{
-		ICommand fullscreenLoadingCommand;
-		ICommand cycleStatesCommand;
 		string customState;
 		LayoutState currentState;
 		LayoutState mainState;
@@ -31,28 +29,19 @@ public string CustomState
 			set => SetProperty(ref customState, value);
 		}
 
-		public ICommand FullscreenLoadingCommand
-		{
-			get => fullscreenLoadingCommand;
-			set => SetProperty(ref fullscreenLoadingCommand, value);
-		}
+		public ICommand FullscreenLoadingCommand { get; }
 
-		public ICommand CycleStatesCommand
-		{
-			get => cycleStatesCommand;
-			set => SetProperty(ref cycleStatesCommand, value);
-		}
+		public ICommand CycleStatesCommand { get; }
 
 		public StateLayoutViewModel()
 		{
-			FullscreenLoadingCommand = new Command(async (x) =>
+			FullscreenLoadingCommand = CommandHelper.Create(async () =>
 			{
 				MainState = LayoutState.Loading;
 				await Task.Delay(2000);
 				MainState = LayoutState.None;
 			});
-
-			CycleStatesCommand = new Command(async (x) => await CycleStates());
+			CycleStatesCommand = CommandHelper.Create(CycleStates);
 		}
 
 		async Task CycleStates()
diff --git a/samples/XCT.Sample/ViewModels/Views/TabItemsSourceViewModel.cs b/samples/XCT.Sample/ViewModels/Views/TabItemsSourceViewModel.cs
index 8e08baa8c..ae0b7b8b0 100644
--- a/samples/XCT.Sample/ViewModels/Views/TabItemsSourceViewModel.cs
+++ b/samples/XCT.Sample/ViewModels/Views/TabItemsSourceViewModel.cs
@@ -1,5 +1,6 @@
 using System.Collections.ObjectModel;
 using System.Windows.Input;
+using Xamarin.CommunityToolkit.Helpers;
 using Xamarin.Forms;
 
 namespace Xamarin.CommunityToolkit.Sample.ViewModels.Views
@@ -19,13 +20,16 @@ public class TabItemsSourceViewModel : BaseViewModel
 		public TabItemsSourceViewModel()
 		{
 			LoadMonkeys();
+
+			ClearDataCommand = CommandHelper.Create(ClearData);
+			UpdateDataCommand = CommandHelper.Create(UpdateData);
 		}
 
 		public ObservableCollection<Monkey> Monkeys { get; set; }
 
-		public ICommand ClearDataCommand => new Command(ClearData);
+		public ICommand ClearDataCommand { get; }
 
-		public ICommand UpdateDataCommand => new Command(UpdateData);
+		public ICommand UpdateDataCommand { get; }
 
 		void LoadMonkeys()
 		{

From 0af797e8ccb886ddc2be4fed8d7a069210bfcb75 Mon Sep 17 00:00:00 2001
From: Maksym Koshovyi <maximkoshevoi61@gmail.com>
Date: Sat, 23 Jan 2021 15:46:35 +0200
Subject: [PATCH 03/21] Rename to CommandFactory

---
 samples/XCT.Sample/Pages/Base/BasePage.cs                     | 2 +-
 samples/XCT.Sample/Pages/Effects/TouchEffectPage.xaml.cs      | 4 ++--
 .../XCT.Sample/Pages/TestCases/TouchEffectButtonPage.xaml.cs  | 2 +-
 samples/XCT.Sample/ViewModels/AboutViewModel.cs               | 4 ++--
 samples/XCT.Sample/ViewModels/Base/BaseGalleryViewModel.cs    | 2 +-
 .../ViewModels/Behaviors/EventToCommandBehaviorViewModel.cs   | 2 +-
 .../ViewModels/Behaviors/MaxLengthReachedBehaviorViewModel.cs | 2 +-
 .../Behaviors/UserStoppedTypingBehaviorViewModel.cs           | 2 +-
 .../ViewModels/Converters/ByteArrayToImageSourceViewModel.cs  | 2 +-
 .../ViewModels/Converters/ItemSelectedEventArgsViewModel.cs   | 2 +-
 .../ViewModels/Converters/ItemTappedEventArgsViewModel.cs     | 2 +-
 .../ViewModels/Converters/ListIsNullOrEmptyViewModel.cs       | 4 ++--
 samples/XCT.Sample/ViewModels/SettingViewModel.cs             | 2 +-
 samples/XCT.Sample/ViewModels/Views/BadgeViewViewModel.cs     | 4 ++--
 samples/XCT.Sample/ViewModels/Views/ExpanderViewModel.cs      | 2 +-
 samples/XCT.Sample/ViewModels/Views/StateLayoutViewModel.cs   | 4 ++--
 .../XCT.Sample/ViewModels/Views/TabItemsSourceViewModel.cs    | 4 ++--
 .../{CommandHelper.shared.cs => CommandFactory.shared.cs}     | 2 +-
 18 files changed, 24 insertions(+), 24 deletions(-)
 rename src/CommunityToolkit/Xamarin.CommunityToolkit/Helpers/{CommandHelper.shared.cs => CommandFactory.shared.cs} (98%)

diff --git a/samples/XCT.Sample/Pages/Base/BasePage.cs b/samples/XCT.Sample/Pages/Base/BasePage.cs
index d5a4195b9..cef78e137 100644
--- a/samples/XCT.Sample/Pages/Base/BasePage.cs
+++ b/samples/XCT.Sample/Pages/Base/BasePage.cs
@@ -9,7 +9,7 @@ namespace Xamarin.CommunityToolkit.Sample.Pages
 	public class BasePage : ContentPage
 	{
 		public BasePage() =>
-			NavigateCommand = CommandHelper.Create<SectionModel>(sectionModel => Navigation.PushAsync(PreparePage(sectionModel)));
+			NavigateCommand = CommandFactory.Create<SectionModel>(sectionModel => Navigation.PushAsync(PreparePage(sectionModel)));
 
 		public Color DetailColor { get; set; }
 
diff --git a/samples/XCT.Sample/Pages/Effects/TouchEffectPage.xaml.cs b/samples/XCT.Sample/Pages/Effects/TouchEffectPage.xaml.cs
index 04867270d..f369d7c5c 100644
--- a/samples/XCT.Sample/Pages/Effects/TouchEffectPage.xaml.cs
+++ b/samples/XCT.Sample/Pages/Effects/TouchEffectPage.xaml.cs
@@ -9,12 +9,12 @@ public partial class TouchEffectPage
 	{
 		public TouchEffectPage()
 		{
-			Command = CommandHelper.Create(() =>
+			Command = CommandFactory.Create(() =>
 			{
 				TouchCount++;
 				OnPropertyChanged(nameof(TouchCount));
 			});
-			LongPressCommand = CommandHelper.Create(() =>
+			LongPressCommand = CommandFactory.Create(() =>
 			{
 				LongPressCount++;
 				OnPropertyChanged(nameof(LongPressCount));
diff --git a/samples/XCT.Sample/Pages/TestCases/TouchEffectButtonPage.xaml.cs b/samples/XCT.Sample/Pages/TestCases/TouchEffectButtonPage.xaml.cs
index 50e70d81a..9baddb264 100644
--- a/samples/XCT.Sample/Pages/TestCases/TouchEffectButtonPage.xaml.cs
+++ b/samples/XCT.Sample/Pages/TestCases/TouchEffectButtonPage.xaml.cs
@@ -7,7 +7,7 @@ public partial class TouchEffectButtonPage
 	{
 		public TouchEffectButtonPage()
 		{
-			Command = CommandHelper.Create(() => DisplayAlert("Command executed ", null, "OK"));
+			Command = CommandFactory.Create(() => DisplayAlert("Command executed ", null, "OK"));
 			InitializeComponent();
 		}
 
diff --git a/samples/XCT.Sample/ViewModels/AboutViewModel.cs b/samples/XCT.Sample/ViewModels/AboutViewModel.cs
index 86e01efc2..47df7b40a 100644
--- a/samples/XCT.Sample/ViewModels/AboutViewModel.cs
+++ b/samples/XCT.Sample/ViewModels/AboutViewModel.cs
@@ -20,8 +20,8 @@ public class AboutViewModel : BaseViewModel
 
 		public AboutViewModel()
 		{
-			PageAppearingCommand = CommandHelper.Create(OnAppearing);
-			SelectedContributorCommand = CommandHelper.Create(async () =>
+			PageAppearingCommand = CommandFactory.Create(OnAppearing);
+			SelectedContributorCommand = CommandFactory.Create(async () =>
 			{
 				if (SelectedContributor is null)
 					return;
diff --git a/samples/XCT.Sample/ViewModels/Base/BaseGalleryViewModel.cs b/samples/XCT.Sample/ViewModels/Base/BaseGalleryViewModel.cs
index ad72b07aa..694e19bf5 100644
--- a/samples/XCT.Sample/ViewModels/Base/BaseGalleryViewModel.cs
+++ b/samples/XCT.Sample/ViewModels/Base/BaseGalleryViewModel.cs
@@ -12,7 +12,7 @@ public abstract class BaseGalleryViewModel : BaseViewModel
 		public BaseGalleryViewModel()
 		{
 			Filter();
-			FilterCommand = CommandHelper.Create(Filter);
+			FilterCommand = CommandFactory.Create(Filter);
 		}
 
 		public abstract IEnumerable<SectionModel> Items { get; }
diff --git a/samples/XCT.Sample/ViewModels/Behaviors/EventToCommandBehaviorViewModel.cs b/samples/XCT.Sample/ViewModels/Behaviors/EventToCommandBehaviorViewModel.cs
index 0553ae76f..0811771f2 100644
--- a/samples/XCT.Sample/ViewModels/Behaviors/EventToCommandBehaviorViewModel.cs
+++ b/samples/XCT.Sample/ViewModels/Behaviors/EventToCommandBehaviorViewModel.cs
@@ -8,7 +8,7 @@ public class EventToCommandBehaviorViewModel : BaseViewModel
 		int clickCount;
 
 		public EventToCommandBehaviorViewModel() =>
-			IncrementCommand = CommandHelper.Create(() => ClickCount++);
+			IncrementCommand = CommandFactory.Create(() => ClickCount++);
 
 		public int ClickCount
 		{
diff --git a/samples/XCT.Sample/ViewModels/Behaviors/MaxLengthReachedBehaviorViewModel.cs b/samples/XCT.Sample/ViewModels/Behaviors/MaxLengthReachedBehaviorViewModel.cs
index e8280eeec..826080064 100644
--- a/samples/XCT.Sample/ViewModels/Behaviors/MaxLengthReachedBehaviorViewModel.cs
+++ b/samples/XCT.Sample/ViewModels/Behaviors/MaxLengthReachedBehaviorViewModel.cs
@@ -17,7 +17,7 @@ public string CommandExecutions
 		public ICommand MaxLengthReachedCommand { get; }
 
 		public MaxLengthReachedBehaviorViewModel()
-			=> MaxLengthReachedCommand = CommandHelper.Create<string>(OnCommandExecuted);
+			=> MaxLengthReachedCommand = CommandFactory.Create<string>(OnCommandExecuted);
 
 		void OnCommandExecuted(string text)
 			=> CommandExecutions += string.Format("MaxLength reached with value: '{0}'.", text) + Environment.NewLine;
diff --git a/samples/XCT.Sample/ViewModels/Behaviors/UserStoppedTypingBehaviorViewModel.cs b/samples/XCT.Sample/ViewModels/Behaviors/UserStoppedTypingBehaviorViewModel.cs
index 7aae3fecd..6f3d53a99 100644
--- a/samples/XCT.Sample/ViewModels/Behaviors/UserStoppedTypingBehaviorViewModel.cs
+++ b/samples/XCT.Sample/ViewModels/Behaviors/UserStoppedTypingBehaviorViewModel.cs
@@ -21,7 +21,7 @@ public string PerformedSearches
 		#endregion Properties
 
 		public UserStoppedTypingBehaviorViewModel()
-			=> SearchCommand = CommandHelper.Create<string>(PerformSearch);
+			=> SearchCommand = CommandFactory.Create<string>(PerformSearch);
 
 		void PerformSearch(string searchTerms)
 			=> PerformedSearches += string.Format("Performed search for '{0}'.", searchTerms) + Environment.NewLine;
diff --git a/samples/XCT.Sample/ViewModels/Converters/ByteArrayToImageSourceViewModel.cs b/samples/XCT.Sample/ViewModels/Converters/ByteArrayToImageSourceViewModel.cs
index 91ddb97c5..c06e0fd08 100644
--- a/samples/XCT.Sample/ViewModels/Converters/ByteArrayToImageSourceViewModel.cs
+++ b/samples/XCT.Sample/ViewModels/Converters/ByteArrayToImageSourceViewModel.cs
@@ -30,7 +30,7 @@ public bool IsBusy
 		public ICommand PageAppearingCommand { get; }
 
 		public ByteArrayToImageSourceViewModel() =>
-			PageAppearingCommand = CommandHelper.Create(OnAppearing);
+			PageAppearingCommand = CommandFactory.Create(OnAppearing);
 
 		public async Task OnAppearing()
 		{
diff --git a/samples/XCT.Sample/ViewModels/Converters/ItemSelectedEventArgsViewModel.cs b/samples/XCT.Sample/ViewModels/Converters/ItemSelectedEventArgsViewModel.cs
index 89c12a938..dec4ac58d 100644
--- a/samples/XCT.Sample/ViewModels/Converters/ItemSelectedEventArgsViewModel.cs
+++ b/samples/XCT.Sample/ViewModels/Converters/ItemSelectedEventArgsViewModel.cs
@@ -16,6 +16,6 @@ public class ItemSelectedEventArgsViewModel
 			};
 
 		public ICommand ItemSelectedCommand { get; } =
-			CommandHelper.Create<Person>(person => Application.Current.MainPage.DisplayAlert("Item Tapped: ", person.Name, "Cancelf"));
+			CommandFactory.Create<Person>(person => Application.Current.MainPage.DisplayAlert("Item Tapped: ", person.Name, "Cancelf"));
 	}
 }
\ No newline at end of file
diff --git a/samples/XCT.Sample/ViewModels/Converters/ItemTappedEventArgsViewModel.cs b/samples/XCT.Sample/ViewModels/Converters/ItemTappedEventArgsViewModel.cs
index e1e3043ea..7f7bb1b62 100644
--- a/samples/XCT.Sample/ViewModels/Converters/ItemTappedEventArgsViewModel.cs
+++ b/samples/XCT.Sample/ViewModels/Converters/ItemTappedEventArgsViewModel.cs
@@ -16,7 +16,7 @@ public class ItemTappedEventArgsViewModel
 			};
 
 		public ICommand ItemTappedCommand { get; } =
-			CommandHelper.Create<Person>(person => Application.Current.MainPage.DisplayAlert("Item Tapped: ", person.Name, "Cancel"));
+			CommandFactory.Create<Person>(person => Application.Current.MainPage.DisplayAlert("Item Tapped: ", person.Name, "Cancel"));
 	}
 
 	public class Person
diff --git a/samples/XCT.Sample/ViewModels/Converters/ListIsNullOrEmptyViewModel.cs b/samples/XCT.Sample/ViewModels/Converters/ListIsNullOrEmptyViewModel.cs
index be31939f8..051593e0a 100644
--- a/samples/XCT.Sample/ViewModels/Converters/ListIsNullOrEmptyViewModel.cs
+++ b/samples/XCT.Sample/ViewModels/Converters/ListIsNullOrEmptyViewModel.cs
@@ -10,7 +10,7 @@ public class ListIsNullOrEmptyViewModel : BaseViewModel
 
 		public ListIsNullOrEmptyViewModel()
 		{
-			AddItemCommand = CommandHelper.Create(() =>
+			AddItemCommand = CommandFactory.Create(() =>
 			{
 				Items.Add(new Person
 				{
@@ -18,7 +18,7 @@ public ListIsNullOrEmptyViewModel()
 					Name = $"Person {Items.Count}"
 				});
 			});
-			RemoveItemCommand = CommandHelper.Create(() => Items.RemoveAt(0));
+			RemoveItemCommand = CommandFactory.Create(() => Items.RemoveAt(0));
 
 			// ListIsNullOrEmptyConvertor needs to know that Items are updated
 			Items.CollectionChanged += (sender, e) => OnPropertyChanged(nameof(Items));
diff --git a/samples/XCT.Sample/ViewModels/SettingViewModel.cs b/samples/XCT.Sample/ViewModels/SettingViewModel.cs
index 2571125d1..c9a9c9148 100644
--- a/samples/XCT.Sample/ViewModels/SettingViewModel.cs
+++ b/samples/XCT.Sample/ViewModels/SettingViewModel.cs
@@ -35,7 +35,7 @@ public SettingViewModel()
 		{
 			LoadLanguages();
 
-			ChangeLanguageCommand = CommandHelper.Create(() =>
+			ChangeLanguageCommand = CommandFactory.Create(() =>
 			{
 				LocalizationResourceManager.Current.SetCulture(CultureInfo.GetCultureInfo(SelectedLanguage.CI));
 				LoadLanguages();
diff --git a/samples/XCT.Sample/ViewModels/Views/BadgeViewViewModel.cs b/samples/XCT.Sample/ViewModels/Views/BadgeViewViewModel.cs
index 5bddee67f..f094b1076 100644
--- a/samples/XCT.Sample/ViewModels/Views/BadgeViewViewModel.cs
+++ b/samples/XCT.Sample/ViewModels/Views/BadgeViewViewModel.cs
@@ -11,8 +11,8 @@ public BadgeViewViewModel()
 		{
 			Counter = 3;
 
-			IncreaseCommand = CommandHelper.Create(Increase);
-			DecreaseCommand = CommandHelper.Create(Decrease);
+			IncreaseCommand = CommandFactory.Create(Increase);
+			DecreaseCommand = CommandFactory.Create(Decrease);
 		}
 
 		public int Counter
diff --git a/samples/XCT.Sample/ViewModels/Views/ExpanderViewModel.cs b/samples/XCT.Sample/ViewModels/Views/ExpanderViewModel.cs
index 7960fc4e5..3e92bba63 100644
--- a/samples/XCT.Sample/ViewModels/Views/ExpanderViewModel.cs
+++ b/samples/XCT.Sample/ViewModels/Views/ExpanderViewModel.cs
@@ -7,7 +7,7 @@ public partial class ExpanderViewModel : BaseViewModel
 	{
 		public ExpanderViewModel()
 		{
-			Command = CommandHelper.Create<Item>(sender =>
+			Command = CommandFactory.Create<Item>(sender =>
 			{
 				if (!sender.IsExpanded)
 					return;
diff --git a/samples/XCT.Sample/ViewModels/Views/StateLayoutViewModel.cs b/samples/XCT.Sample/ViewModels/Views/StateLayoutViewModel.cs
index 9b0791e70..04f9c460a 100644
--- a/samples/XCT.Sample/ViewModels/Views/StateLayoutViewModel.cs
+++ b/samples/XCT.Sample/ViewModels/Views/StateLayoutViewModel.cs
@@ -35,13 +35,13 @@ public string CustomState
 
 		public StateLayoutViewModel()
 		{
-			FullscreenLoadingCommand = CommandHelper.Create(async () =>
+			FullscreenLoadingCommand = CommandFactory.Create(async () =>
 			{
 				MainState = LayoutState.Loading;
 				await Task.Delay(2000);
 				MainState = LayoutState.None;
 			});
-			CycleStatesCommand = CommandHelper.Create(CycleStates);
+			CycleStatesCommand = CommandFactory.Create(CycleStates);
 		}
 
 		async Task CycleStates()
diff --git a/samples/XCT.Sample/ViewModels/Views/TabItemsSourceViewModel.cs b/samples/XCT.Sample/ViewModels/Views/TabItemsSourceViewModel.cs
index ae0b7b8b0..bb820e98e 100644
--- a/samples/XCT.Sample/ViewModels/Views/TabItemsSourceViewModel.cs
+++ b/samples/XCT.Sample/ViewModels/Views/TabItemsSourceViewModel.cs
@@ -21,8 +21,8 @@ public TabItemsSourceViewModel()
 		{
 			LoadMonkeys();
 
-			ClearDataCommand = CommandHelper.Create(ClearData);
-			UpdateDataCommand = CommandHelper.Create(UpdateData);
+			ClearDataCommand = CommandFactory.Create(ClearData);
+			UpdateDataCommand = CommandFactory.Create(UpdateData);
 		}
 
 		public ObservableCollection<Monkey> Monkeys { get; set; }
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Helpers/CommandHelper.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Helpers/CommandFactory.shared.cs
similarity index 98%
rename from src/CommunityToolkit/Xamarin.CommunityToolkit/Helpers/CommandHelper.shared.cs
rename to src/CommunityToolkit/Xamarin.CommunityToolkit/Helpers/CommandFactory.shared.cs
index 94cfe4c65..27ccdd7c4 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Helpers/CommandHelper.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Helpers/CommandFactory.shared.cs
@@ -5,7 +5,7 @@
 
 namespace Xamarin.CommunityToolkit.Helpers
 {
-	public static class CommandHelper
+	public static class CommandFactory
 	{
 		public static Command Create(Action execute, Func<bool> canExecute = null) =>
 			new Command(execute, canExecute ?? (() => true));

From 716161f30ef789b666afe062f405c8fa6c6b56ae Mon Sep 17 00:00:00 2001
From: Maksym Koshovyi <maximkoshevoi61@gmail.com>
Date: Sat, 23 Jan 2021 20:01:07 +0200
Subject: [PATCH 04/21] Replace "is null" with "== null"

---
 samples/XCT.Sample/ViewModels/AboutViewModel.cs             | 2 +-
 .../Converters/ByteArrayToImageSourceConverter.shared.cs    | 4 ++--
 .../Converters/ListIsNotNullOrEmptyConverter.shared.cs      | 2 +-
 .../Converters/ListIsNullOrEmptyConverter.shared.cs         | 2 +-
 .../Helpers/CommandFactory.shared.cs                        | 6 +++---
 .../ObjectModel/ObservableRangeCollection.shared.cs         | 2 +-
 .../Views/CameraView/Android/CameraFragment.android.cs      | 2 +-
 .../Views/MediaElement/UWP/MediaElementRenderer.uwp.cs      | 2 +-
 8 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/samples/XCT.Sample/ViewModels/AboutViewModel.cs b/samples/XCT.Sample/ViewModels/AboutViewModel.cs
index 47df7b40a..826e6c063 100644
--- a/samples/XCT.Sample/ViewModels/AboutViewModel.cs
+++ b/samples/XCT.Sample/ViewModels/AboutViewModel.cs
@@ -23,7 +23,7 @@ public AboutViewModel()
 			PageAppearingCommand = CommandFactory.Create(OnAppearing);
 			SelectedContributorCommand = CommandFactory.Create(async () =>
 			{
-				if (SelectedContributor is null)
+				if (SelectedContributor == null)
 					return;
 
 				await Launcher.OpenAsync(SelectedContributor.HtmlUrl);
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/ByteArrayToImageSourceConverter.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/ByteArrayToImageSourceConverter.shared.cs
index 8818aa765..9782e2185 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/ByteArrayToImageSourceConverter.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/ByteArrayToImageSourceConverter.shared.cs
@@ -23,7 +23,7 @@ public class ByteArrayToImageSourceConverter : ValueConverterExtension, IValueCo
 		/// <returns>An object of type ImageSource.</returns>
 		public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
 		{
-			if (value is null)
+			if (value == null)
 				return null;
 
 			if (value is byte[] imageBytes)
@@ -34,7 +34,7 @@ public object Convert(object value, Type targetType, object parameter, CultureIn
 
 		public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
 		{
-			if (value is null)
+			if (value == null)
 				return null;
 
 			if (value is StreamImageSource streamImageSource)
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/ListIsNotNullOrEmptyConverter.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/ListIsNotNullOrEmptyConverter.shared.cs
index 18688591a..838e8998e 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/ListIsNotNullOrEmptyConverter.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/ListIsNotNullOrEmptyConverter.shared.cs
@@ -21,7 +21,7 @@ public class ListIsNotNullOrEmptyConverter : ValueConverterExtension, IValueConv
 		/// <returns>A boolean indicating if the incoming value is not null and not empty.</returns>
 		public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
 		{
-			if (value is null)
+			if (value == null)
 				return false;
 
 			if (value is IEnumerable list)
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/ListIsNullOrEmptyConverter.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/ListIsNullOrEmptyConverter.shared.cs
index a028918f4..2b75ef8d2 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/ListIsNullOrEmptyConverter.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/ListIsNullOrEmptyConverter.shared.cs
@@ -21,7 +21,7 @@ public class ListIsNullOrEmptyConverter : ValueConverterExtension, IValueConvert
 		/// <returns>A boolean indicating if the incoming value is null or empty.</returns>
 		public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
 		{
-			if (value is null)
+			if (value == null)
 				return true;
 
 			if (value is IEnumerable list)
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Helpers/CommandFactory.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Helpers/CommandFactory.shared.cs
index 27ccdd7c4..07609dd45 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Helpers/CommandFactory.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Helpers/CommandFactory.shared.cs
@@ -42,7 +42,7 @@ public static IAsyncCommand<TExecute, TCanExecute> Create<TExecute, TCanExecute>
 
 		static Action<object> ConvertExecute<T>(Action<T> execute)
 		{
-			if (execute is null)
+			if (execute == null)
 				return null;
 
 			return e => execute((T)e);
@@ -50,7 +50,7 @@ static Action<object> ConvertExecute<T>(Action<T> execute)
 
 		static Func<object, bool> ConvertCanExecute(Func<bool> canExecute)
 		{
-			if (canExecute is null)
+			if (canExecute == null)
 				return _ => true;
 
 			return _ => canExecute();
@@ -58,7 +58,7 @@ static Func<object, bool> ConvertCanExecute(Func<bool> canExecute)
 
 		static Func<object, bool> ConvertCanExecute<T>(Func<T, bool> canExecute)
 		{
-			if (canExecute is null)
+			if (canExecute == null)
 				return _ => true;
 
 			return e => canExecute((T)e);
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/ObservableRangeCollection.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/ObservableRangeCollection.shared.cs
index 9f2d99521..39c54da4d 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/ObservableRangeCollection.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/ObservableRangeCollection.shared.cs
@@ -157,7 +157,7 @@ void RaiseChangeNotificationEvents(NotifyCollectionChangedAction action, List<T>
 			OnPropertyChanged(new PropertyChangedEventArgs(nameof(Count)));
 			OnPropertyChanged(new PropertyChangedEventArgs("Item[]"));
 
-			if (changedItems is null)
+			if (changedItems == null)
 				OnCollectionChanged(new NotifyCollectionChangedEventArgs(action));
 			else
 				OnCollectionChanged(new NotifyCollectionChangedEventArgs(action, changedItems: changedItems, startingIndex: startingIndex));
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/CameraView/Android/CameraFragment.android.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/CameraView/Android/CameraFragment.android.cs
index 229e77e1f..35f1f7f48 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/CameraView/Android/CameraFragment.android.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/CameraView/Android/CameraFragment.android.cs
@@ -138,7 +138,7 @@ public override async void OnResume()
 		{
 			base.OnResume();
 			StartBackgroundThread();
-			if (texture is null)
+			if (texture == null)
 				return;
 			if (texture.IsAvailable)
 			{
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/MediaElement/UWP/MediaElementRenderer.uwp.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/MediaElement/UWP/MediaElementRenderer.uwp.cs
index 00f6e71bd..0e2fb95bc 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/MediaElement/UWP/MediaElementRenderer.uwp.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/MediaElement/UWP/MediaElementRenderer.uwp.cs
@@ -151,7 +151,7 @@ void ControlMediaOpened(object sender, RoutedEventArgs e)
 
 		void ControlCurrentStateChanged(object sender, RoutedEventArgs e)
 		{
-			if (Element is null || Control is null)
+			if (Element == null || Control == null)
 				return;
 
 			switch (Control.CurrentState)

From c1d5631e98083c84b2e2d8d35d4204a83f1b7a98 Mon Sep 17 00:00:00 2001
From: Maksym Koshovyi <maximkoshevoi61@gmail.com>
Date: Sat, 23 Jan 2021 20:03:16 +0200
Subject: [PATCH 05/21] Update GravatarImageViewModel.cs

---
 .../ViewModels/Views/GravatarImageViewModel.cs   | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

diff --git a/samples/XCT.Sample/ViewModels/Views/GravatarImageViewModel.cs b/samples/XCT.Sample/ViewModels/Views/GravatarImageViewModel.cs
index 89114a1b5..4bb4d8559 100644
--- a/samples/XCT.Sample/ViewModels/Views/GravatarImageViewModel.cs
+++ b/samples/XCT.Sample/ViewModels/Views/GravatarImageViewModel.cs
@@ -1,6 +1,4 @@
-using System;
-using System.Linq;
-using Xamarin.CommunityToolkit.UI.Views;
+using Xamarin.CommunityToolkit.UI.Views;
 
 namespace Xamarin.CommunityToolkit.Sample.ViewModels.Views
 {
@@ -11,7 +9,17 @@ public class GravatarImageViewModel : BaseViewModel
 		int size = 50;
 		DefaultGravatar defaultGravatar = DefaultGravatar.MysteryPerson;
 
-		public DefaultGravatar[] Defaults { get; } = Enum.GetValues(typeof(DefaultGravatar)).Cast<DefaultGravatar>().ToArray();
+		public DefaultGravatar[] Defaults { get; } = new[]
+		{
+			DefaultGravatar.Blank,
+			DefaultGravatar.FileNotFound,
+			DefaultGravatar.Identicon,
+			DefaultGravatar.MonsterId,
+			DefaultGravatar.MysteryPerson,
+			DefaultGravatar.Retro,
+			DefaultGravatar.Robohash,
+			DefaultGravatar.Wavatar
+		};
 
 		public bool EnableCache
 		{

From 96ab6fba43637b183a59aeb66de23aede02625ed Mon Sep 17 00:00:00 2001
From: Maksym Koshovyi <maximkoshevoi61@gmail.com>
Date: Sat, 23 Jan 2021 20:11:02 +0200
Subject: [PATCH 06/21] Update SearchViewModel.cs

---
 samples/XCT.Sample/ViewModels/Markup/SearchViewModel.cs | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/samples/XCT.Sample/ViewModels/Markup/SearchViewModel.cs b/samples/XCT.Sample/ViewModels/Markup/SearchViewModel.cs
index 588083a79..132006d9a 100644
--- a/samples/XCT.Sample/ViewModels/Markup/SearchViewModel.cs
+++ b/samples/XCT.Sample/ViewModels/Markup/SearchViewModel.cs
@@ -67,9 +67,7 @@ public SearchViewModel()
 
 		public ICommand OpenHelpCommand { get; }
 
-		void Back()
-		{
-		}
+		void Back() { }
 
 		void Like(Tweet tweet) => tweet.IsLikedByMe = !tweet.IsLikedByMe;
 

From f54c6c032afd9c4868094f984483bceabb6a0c90 Mon Sep 17 00:00:00 2001
From: Maksym Koshovyi <maximkoshevoi61@gmail.com>
Date: Tue, 26 Jan 2021 00:40:26 +0200
Subject: [PATCH 07/21] Move CommandFactory to ObjectModel

---
 .../Xamarin.CommunityToolkit.Sample.Android.csproj             | 2 +-
 samples/XCT.Sample/Pages/Base/BasePage.cs                      | 2 +-
 samples/XCT.Sample/Pages/Effects/TouchEffectPage.xaml.cs       | 2 +-
 .../XCT.Sample/Pages/TestCases/TouchEffectButtonPage.xaml.cs   | 2 +-
 samples/XCT.Sample/ViewModels/AboutViewModel.cs                | 2 +-
 samples/XCT.Sample/ViewModels/Base/BaseGalleryViewModel.cs     | 2 +-
 .../ViewModels/Behaviors/EventToCommandBehaviorViewModel.cs    | 2 +-
 .../ViewModels/Behaviors/MaxLengthReachedBehaviorViewModel.cs  | 2 +-
 .../ViewModels/Behaviors/UserStoppedTypingBehaviorViewModel.cs | 2 +-
 .../ViewModels/Converters/ByteArrayToImageSourceViewModel.cs   | 2 +-
 .../ViewModels/Converters/ItemSelectedEventArgsViewModel.cs    | 2 +-
 .../ViewModels/Converters/ItemTappedEventArgsViewModel.cs      | 2 +-
 samples/XCT.Sample/ViewModels/SettingViewModel.cs              | 1 +
 samples/XCT.Sample/ViewModels/Views/BadgeViewViewModel.cs      | 2 +-
 samples/XCT.Sample/ViewModels/Views/ExpanderViewModel.cs       | 2 +-
 samples/XCT.Sample/ViewModels/Views/StateLayoutViewModel.cs    | 2 +-
 samples/XCT.Sample/ViewModels/Views/TabItemsSourceViewModel.cs | 2 +-
 .../{Helpers => ObjectModel}/CommandFactory.shared.cs          | 3 +--
 .../Xamarin.CommunityToolkit/Xamarin.CommunityToolkit.csproj   | 3 +--
 19 files changed, 19 insertions(+), 20 deletions(-)
 rename src/CommunityToolkit/Xamarin.CommunityToolkit/{Helpers => ObjectModel}/CommandFactory.shared.cs (96%)

diff --git a/samples/XCT.Sample.Android/Xamarin.CommunityToolkit.Sample.Android.csproj b/samples/XCT.Sample.Android/Xamarin.CommunityToolkit.Sample.Android.csproj
index 8fe84cb44..27fb9082e 100644
--- a/samples/XCT.Sample.Android/Xamarin.CommunityToolkit.Sample.Android.csproj
+++ b/samples/XCT.Sample.Android/Xamarin.CommunityToolkit.Sample.Android.csproj
@@ -127,7 +127,7 @@
   <Import Project="$(MSBuildExtensionsPath)\Xamarin\Android\Xamarin.Android.CSharp.targets" />
   <ProjectExtensions>
     <VisualStudio>
-      <UserProperties XamarinHotReloadXFormsNugetUpgradeInfoBarXamarinCommunityToolkitSampleAndroidHideInfoBar="True" />
+      <UserProperties TriggeredFromHotReload="False" XamarinHotReloadXFormsNugetUpgradeInfoBarXamarinCommunityToolkitSampleAndroidHideInfoBar="True" />
     </VisualStudio>
   </ProjectExtensions>
 </Project>
\ No newline at end of file
diff --git a/samples/XCT.Sample/Pages/Base/BasePage.cs b/samples/XCT.Sample/Pages/Base/BasePage.cs
index cef78e137..8e7a5071f 100644
--- a/samples/XCT.Sample/Pages/Base/BasePage.cs
+++ b/samples/XCT.Sample/Pages/Base/BasePage.cs
@@ -1,6 +1,6 @@
 using System;
 using System.Windows.Input;
-using Xamarin.CommunityToolkit.Helpers;
+using Xamarin.CommunityToolkit.ObjectModel;
 using Xamarin.CommunityToolkit.Sample.Models;
 using Xamarin.Forms;
 
diff --git a/samples/XCT.Sample/Pages/Effects/TouchEffectPage.xaml.cs b/samples/XCT.Sample/Pages/Effects/TouchEffectPage.xaml.cs
index f369d7c5c..466cfedcb 100644
--- a/samples/XCT.Sample/Pages/Effects/TouchEffectPage.xaml.cs
+++ b/samples/XCT.Sample/Pages/Effects/TouchEffectPage.xaml.cs
@@ -1,5 +1,5 @@
 using System.Windows.Input;
-using Xamarin.CommunityToolkit.Helpers;
+using Xamarin.CommunityToolkit.ObjectModel;
 using Xamarin.Forms.Xaml;
 
 namespace Xamarin.CommunityToolkit.Sample.Pages.Effects
diff --git a/samples/XCT.Sample/Pages/TestCases/TouchEffectButtonPage.xaml.cs b/samples/XCT.Sample/Pages/TestCases/TouchEffectButtonPage.xaml.cs
index 9baddb264..61de4d00e 100644
--- a/samples/XCT.Sample/Pages/TestCases/TouchEffectButtonPage.xaml.cs
+++ b/samples/XCT.Sample/Pages/TestCases/TouchEffectButtonPage.xaml.cs
@@ -1,5 +1,5 @@
 using System.Windows.Input;
-using Xamarin.CommunityToolkit.Helpers;
+using Xamarin.CommunityToolkit.ObjectModel;
 
 namespace Xamarin.CommunityToolkit.Sample.Pages.TestCases
 {
diff --git a/samples/XCT.Sample/ViewModels/AboutViewModel.cs b/samples/XCT.Sample/ViewModels/AboutViewModel.cs
index 826e6c063..e7d242b4c 100644
--- a/samples/XCT.Sample/ViewModels/AboutViewModel.cs
+++ b/samples/XCT.Sample/ViewModels/AboutViewModel.cs
@@ -3,7 +3,7 @@
 using System.Threading.Tasks;
 using System.Windows.Input;
 using Octokit;
-using Xamarin.CommunityToolkit.Helpers;
+using Xamarin.CommunityToolkit.ObjectModel;
 using Xamarin.Essentials;
 
 namespace Xamarin.CommunityToolkit.Sample.ViewModels
diff --git a/samples/XCT.Sample/ViewModels/Base/BaseGalleryViewModel.cs b/samples/XCT.Sample/ViewModels/Base/BaseGalleryViewModel.cs
index 694e19bf5..1ca508b72 100644
--- a/samples/XCT.Sample/ViewModels/Base/BaseGalleryViewModel.cs
+++ b/samples/XCT.Sample/ViewModels/Base/BaseGalleryViewModel.cs
@@ -2,7 +2,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Windows.Input;
-using Xamarin.CommunityToolkit.Helpers;
+using Xamarin.CommunityToolkit.ObjectModel;
 using Xamarin.CommunityToolkit.Sample.Models;
 
 namespace Xamarin.CommunityToolkit.Sample.ViewModels
diff --git a/samples/XCT.Sample/ViewModels/Behaviors/EventToCommandBehaviorViewModel.cs b/samples/XCT.Sample/ViewModels/Behaviors/EventToCommandBehaviorViewModel.cs
index 0811771f2..a8973056f 100644
--- a/samples/XCT.Sample/ViewModels/Behaviors/EventToCommandBehaviorViewModel.cs
+++ b/samples/XCT.Sample/ViewModels/Behaviors/EventToCommandBehaviorViewModel.cs
@@ -1,5 +1,5 @@
 using System.Windows.Input;
-using Xamarin.CommunityToolkit.Helpers;
+using Xamarin.CommunityToolkit.ObjectModel;
 
 namespace Xamarin.CommunityToolkit.Sample.ViewModels.Behaviors
 {
diff --git a/samples/XCT.Sample/ViewModels/Behaviors/MaxLengthReachedBehaviorViewModel.cs b/samples/XCT.Sample/ViewModels/Behaviors/MaxLengthReachedBehaviorViewModel.cs
index 826080064..299e48459 100644
--- a/samples/XCT.Sample/ViewModels/Behaviors/MaxLengthReachedBehaviorViewModel.cs
+++ b/samples/XCT.Sample/ViewModels/Behaviors/MaxLengthReachedBehaviorViewModel.cs
@@ -1,6 +1,6 @@
 using System;
 using System.Windows.Input;
-using Xamarin.CommunityToolkit.Helpers;
+using Xamarin.CommunityToolkit.ObjectModel;
 
 namespace Xamarin.CommunityToolkit.Sample.ViewModels.Behaviors
 {
diff --git a/samples/XCT.Sample/ViewModels/Behaviors/UserStoppedTypingBehaviorViewModel.cs b/samples/XCT.Sample/ViewModels/Behaviors/UserStoppedTypingBehaviorViewModel.cs
index 6f3d53a99..816bc670c 100644
--- a/samples/XCT.Sample/ViewModels/Behaviors/UserStoppedTypingBehaviorViewModel.cs
+++ b/samples/XCT.Sample/ViewModels/Behaviors/UserStoppedTypingBehaviorViewModel.cs
@@ -1,6 +1,6 @@
 using System;
 using System.Windows.Input;
-using Xamarin.CommunityToolkit.Helpers;
+using Xamarin.CommunityToolkit.ObjectModel;
 
 namespace Xamarin.CommunityToolkit.Sample.ViewModels.Behaviors
 {
diff --git a/samples/XCT.Sample/ViewModels/Converters/ByteArrayToImageSourceViewModel.cs b/samples/XCT.Sample/ViewModels/Converters/ByteArrayToImageSourceViewModel.cs
index c06e0fd08..a7e7ef2bb 100644
--- a/samples/XCT.Sample/ViewModels/Converters/ByteArrayToImageSourceViewModel.cs
+++ b/samples/XCT.Sample/ViewModels/Converters/ByteArrayToImageSourceViewModel.cs
@@ -3,7 +3,7 @@
 using System.Threading.Tasks;
 using System.Windows.Input;
 using Octokit;
-using Xamarin.CommunityToolkit.Helpers;
+using Xamarin.CommunityToolkit.ObjectModel;
 
 namespace Xamarin.CommunityToolkit.Sample.ViewModels.Converters
 {
diff --git a/samples/XCT.Sample/ViewModels/Converters/ItemSelectedEventArgsViewModel.cs b/samples/XCT.Sample/ViewModels/Converters/ItemSelectedEventArgsViewModel.cs
index dec4ac58d..6569e2053 100644
--- a/samples/XCT.Sample/ViewModels/Converters/ItemSelectedEventArgsViewModel.cs
+++ b/samples/XCT.Sample/ViewModels/Converters/ItemSelectedEventArgsViewModel.cs
@@ -1,6 +1,6 @@
 using System.Collections.Generic;
 using System.Windows.Input;
-using Xamarin.CommunityToolkit.Helpers;
+using Xamarin.CommunityToolkit.ObjectModel;
 using Xamarin.Forms;
 
 namespace Xamarin.CommunityToolkit.Sample.ViewModels.Converters
diff --git a/samples/XCT.Sample/ViewModels/Converters/ItemTappedEventArgsViewModel.cs b/samples/XCT.Sample/ViewModels/Converters/ItemTappedEventArgsViewModel.cs
index 7f7bb1b62..8aa56632b 100644
--- a/samples/XCT.Sample/ViewModels/Converters/ItemTappedEventArgsViewModel.cs
+++ b/samples/XCT.Sample/ViewModels/Converters/ItemTappedEventArgsViewModel.cs
@@ -1,6 +1,6 @@
 using System.Collections.Generic;
 using System.Windows.Input;
-using Xamarin.CommunityToolkit.Helpers;
+using Xamarin.CommunityToolkit.ObjectModel;
 using Xamarin.Forms;
 
 namespace Xamarin.CommunityToolkit.Sample.ViewModels.Converters
diff --git a/samples/XCT.Sample/ViewModels/SettingViewModel.cs b/samples/XCT.Sample/ViewModels/SettingViewModel.cs
index c9a9c9148..34623cf3f 100644
--- a/samples/XCT.Sample/ViewModels/SettingViewModel.cs
+++ b/samples/XCT.Sample/ViewModels/SettingViewModel.cs
@@ -3,6 +3,7 @@
 using System.Linq;
 using System.Windows.Input;
 using Xamarin.CommunityToolkit.Helpers;
+using Xamarin.CommunityToolkit.ObjectModel;
 using Xamarin.CommunityToolkit.Sample.Models;
 using Xamarin.CommunityToolkit.Sample.Resx;
 using Xamarin.Essentials;
diff --git a/samples/XCT.Sample/ViewModels/Views/BadgeViewViewModel.cs b/samples/XCT.Sample/ViewModels/Views/BadgeViewViewModel.cs
index f094b1076..c95155981 100644
--- a/samples/XCT.Sample/ViewModels/Views/BadgeViewViewModel.cs
+++ b/samples/XCT.Sample/ViewModels/Views/BadgeViewViewModel.cs
@@ -1,5 +1,5 @@
 using System.Windows.Input;
-using Xamarin.CommunityToolkit.Helpers;
+using Xamarin.CommunityToolkit.ObjectModel;
 
 namespace Xamarin.CommunityToolkit.Sample.ViewModels.Views
 {
diff --git a/samples/XCT.Sample/ViewModels/Views/ExpanderViewModel.cs b/samples/XCT.Sample/ViewModels/Views/ExpanderViewModel.cs
index 3e92bba63..108859756 100644
--- a/samples/XCT.Sample/ViewModels/Views/ExpanderViewModel.cs
+++ b/samples/XCT.Sample/ViewModels/Views/ExpanderViewModel.cs
@@ -1,5 +1,5 @@
 using System.Windows.Input;
-using Xamarin.CommunityToolkit.Helpers;
+using Xamarin.CommunityToolkit.ObjectModel;
 
 namespace Xamarin.CommunityToolkit.Sample.ViewModels.Views
 {
diff --git a/samples/XCT.Sample/ViewModels/Views/StateLayoutViewModel.cs b/samples/XCT.Sample/ViewModels/Views/StateLayoutViewModel.cs
index 04f9c460a..d1d63e27c 100644
--- a/samples/XCT.Sample/ViewModels/Views/StateLayoutViewModel.cs
+++ b/samples/XCT.Sample/ViewModels/Views/StateLayoutViewModel.cs
@@ -1,6 +1,6 @@
 using System.Threading.Tasks;
 using System.Windows.Input;
-using Xamarin.CommunityToolkit.Helpers;
+using Xamarin.CommunityToolkit.ObjectModel;
 using Xamarin.CommunityToolkit.UI.Views;
 
 namespace Xamarin.CommunityToolkit.Sample.ViewModels.Views
diff --git a/samples/XCT.Sample/ViewModels/Views/TabItemsSourceViewModel.cs b/samples/XCT.Sample/ViewModels/Views/TabItemsSourceViewModel.cs
index bb820e98e..451391518 100644
--- a/samples/XCT.Sample/ViewModels/Views/TabItemsSourceViewModel.cs
+++ b/samples/XCT.Sample/ViewModels/Views/TabItemsSourceViewModel.cs
@@ -1,6 +1,6 @@
 using System.Collections.ObjectModel;
 using System.Windows.Input;
-using Xamarin.CommunityToolkit.Helpers;
+using Xamarin.CommunityToolkit.ObjectModel;
 using Xamarin.Forms;
 
 namespace Xamarin.CommunityToolkit.Sample.ViewModels.Views
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Helpers/CommandFactory.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.shared.cs
similarity index 96%
rename from src/CommunityToolkit/Xamarin.CommunityToolkit/Helpers/CommandFactory.shared.cs
rename to src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.shared.cs
index 07609dd45..dffed24d5 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Helpers/CommandFactory.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.shared.cs
@@ -1,9 +1,8 @@
 using System;
 using System.Threading.Tasks;
-using Xamarin.CommunityToolkit.ObjectModel;
 using Xamarin.Forms;
 
-namespace Xamarin.CommunityToolkit.Helpers
+namespace Xamarin.CommunityToolkit.ObjectModel
 {
 	public static class CommandFactory
 	{
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Xamarin.CommunityToolkit.csproj b/src/CommunityToolkit/Xamarin.CommunityToolkit/Xamarin.CommunityToolkit.csproj
index a2072552a..c6d181f27 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Xamarin.CommunityToolkit.csproj
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Xamarin.CommunityToolkit.csproj
@@ -1,8 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project Sdk="MSBuild.Sdk.Extras/2.1.2">
   <PropertyGroup>
-    <TargetFrameworks>netstandard1.0;netstandard2.0;netstandard2.1;Xamarin.iOS10;MonoAndroid10.0;Xamarin.TVOS10;Xamarin.WatchOS10;Xamarin.Mac20;tizen40</TargetFrameworks>
-    <TargetFrameworks Condition=" '$(OS)' == 'Windows_NT' ">$(TargetFrameworks);uap10.0.17763;netcoreapp3.1;net472;net471</TargetFrameworks>
+    <TargetFrameworks>netstandard2.0</TargetFrameworks>
     <AssemblyName>Xamarin.CommunityToolkit</AssemblyName>
     <RootNamespace>Xamarin.CommunityToolkit</RootNamespace>
     <PackageId>Xamarin.CommunityToolkit</PackageId>

From 1e2f2b2d888aea29eab6e929f9198f8335dd3f0d Mon Sep 17 00:00:00 2001
From: Maksym Koshovyi <maximkoshevoi61@gmail.com>
Date: Tue, 26 Jan 2021 02:35:50 +0200
Subject: [PATCH 08/21] Update ConvertExecute and ConvertCanExecute to throw
 InvalidCommandParameterException

---
 .../ObjectModel/CommandFactory.shared.cs      | 34 +++++++++++++++++--
 1 file changed, 32 insertions(+), 2 deletions(-)

diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.shared.cs
index dffed24d5..9d73c43a4 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.shared.cs
@@ -1,5 +1,7 @@
 using System;
+using System.Reflection;
 using System.Threading.Tasks;
+using Xamarin.CommunityToolkit.Exceptions;
 using Xamarin.Forms;
 
 namespace Xamarin.CommunityToolkit.ObjectModel
@@ -44,7 +46,27 @@ static Action<object> ConvertExecute<T>(Action<T> execute)
 			if (execute == null)
 				return null;
 
-			return e => execute((T)e);
+			return p => Execute(execute, p);
+		}
+
+		static void Execute<T>(Action<T> execute, object parameter)
+		{
+			switch (parameter)
+			{
+				case T validParameter:
+					execute(validParameter);
+					break;
+
+				case null when !typeof(T).GetTypeInfo().IsValueType:
+					execute((T)parameter);
+					break;
+
+				case null:
+					throw new InvalidCommandParameterException(typeof(T));
+
+				default:
+					throw new InvalidCommandParameterException(typeof(T), parameter.GetType());
+			}
 		}
 
 		static Func<object, bool> ConvertCanExecute(Func<bool> canExecute)
@@ -60,7 +82,15 @@ static Func<object, bool> ConvertCanExecute<T>(Func<T, bool> canExecute)
 			if (canExecute == null)
 				return _ => true;
 
-			return e => canExecute((T)e);
+			return p => CanExecute(canExecute, p);
 		}
+
+		static bool CanExecute<T>(Func<T, bool> canExecute, object parameter) => parameter switch
+		{
+			T validParameter => canExecute(validParameter),
+			null when !typeof(T).GetTypeInfo().IsValueType => canExecute((T)parameter),
+			null => throw new InvalidCommandParameterException(typeof(T)),
+			_ => throw new InvalidCommandParameterException(typeof(T), parameter.GetType()),
+		};
 	}
 }

From 157e438900991d883c0b77d2cedc75e9bf3365c9 Mon Sep 17 00:00:00 2001
From: Maksym Koshovyi <maximkoshevoi61@gmail.com>
Date: Tue, 26 Jan 2021 02:36:56 +0200
Subject: [PATCH 09/21] Add tests

---
 .../CommandFactory_Tests.cs                   | 223 ++++++++++++++++++
 1 file changed, 223 insertions(+)
 create mode 100644 src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_Tests.cs

diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_Tests.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_Tests.cs
new file mode 100644
index 000000000..3b77089e3
--- /dev/null
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_Tests.cs
@@ -0,0 +1,223 @@
+using System;
+using System.Threading.Tasks;
+using Xamarin.CommunityToolkit.Exceptions;
+using Xamarin.CommunityToolkit.ObjectModel;
+using Xunit;
+
+namespace Xamarin.CommunityToolkit.UnitTests.ObjectModel.ICommandTests.CommandFactoryTests
+{
+	public class CommandFactoryTests : BaseCommandTests
+	{
+		protected void NoParameterAction()
+        {
+        }
+
+		protected void IntParameterAction(int i)
+        {
+        }
+
+		[Fact]
+		public void CommandNullExecuteParameter()
+		{
+			// Arrange
+			Action execute = null;
+
+			// Act
+
+			// Assert
+			Assert.Throws<ArgumentNullException>(() => CommandFactory.Create(execute));
+		}
+
+		[Fact]
+		public void AsyncCommandNullExecuteParameter()
+		{
+			// Arrange
+			Func<Task> execute = null;
+
+			// Act
+
+			// Assert
+			Assert.Throws<ArgumentNullException>(() => CommandFactory.Create(execute));
+		}
+
+		[Fact]
+		public void CommandNullCanExecuteParameter()
+		{
+			// Arrange
+			var command = CommandFactory.Create(NoParameterAction, null);
+
+			// Act
+
+			// Assert
+			Assert.True(command.CanExecute(null));
+			Assert.True(command.CanExecute(string.Empty));
+			Assert.True(command.CanExecute(0));
+		}
+
+		[Fact]
+		public void AsyncCommandNullCanExecuteParameter()
+		{
+			// Arrange
+			var command = CommandFactory.Create(NoParameterTask, null);
+
+			// Act
+
+			// Assert
+			Assert.True(command.CanExecute(null));
+			Assert.True(command.CanExecute(string.Empty));
+			Assert.True(command.CanExecute(0));
+		}
+
+		[Fact]
+		public void IntCommandNullCanExecuteParameter()
+		{
+			// Arrange
+			var command = CommandFactory.Create<int>(IntParameterAction, null);
+
+			// Act
+
+			// Assert
+			Assert.True(command.CanExecute(null));
+			Assert.True(command.CanExecute(string.Empty));
+			Assert.True(command.CanExecute(0));
+
+			command.Execute(0);
+			Assert.Throws<InvalidCommandParameterException>(() => command.Execute(null));
+			Assert.Throws<InvalidCommandParameterException>(() => command.Execute(string.Empty));
+		}
+
+		[Fact]
+		public void IntAsyncCommandNullCanExecuteParameter()
+		{
+			// Arrange
+			var command = CommandFactory.Create<int>(IntParameterTask, null);
+
+			// Act
+
+			// Assert
+			Assert.True(command.CanExecute(null));
+			Assert.True(command.CanExecute(string.Empty));
+			Assert.True(command.CanExecute(0));
+
+			command.Execute(0);
+			Assert.Throws<InvalidCommandParameterException>(() => command.Execute(null));
+			Assert.Throws<InvalidCommandParameterException>(() => command.Execute(string.Empty));
+		}
+
+		[Fact]
+		public void IntCommandTrueCanExecuteParameter()
+		{
+			// Arrange
+			var command = CommandFactory.Create<int>(IntParameterAction, CanExecuteTrue);
+
+			// Act
+
+			// Assert
+			Assert.True(command.CanExecute(null));
+			Assert.True(command.CanExecute(string.Empty));
+			Assert.True(command.CanExecute(0));
+		}
+
+		[Fact]
+		public void IntAsyncCommandTrueCanExecuteParameter()
+		{
+			// Arrange
+			var command = CommandFactory.Create<int>(IntParameterTask, CanExecuteTrue);
+
+			// Act
+
+			// Assert
+			Assert.True(command.CanExecute(null));
+			Assert.True(command.CanExecute(string.Empty));
+			Assert.True(command.CanExecute(0));
+		}
+
+		[Fact]
+		public void IntCommandFalseCanExecuteParameter()
+		{
+			// Arrange
+			var command = CommandFactory.Create<int>(IntParameterAction, CanExecuteFalse);
+
+			// Act
+
+			// Assert
+			Assert.False(command.CanExecute(null));
+			Assert.False(command.CanExecute(string.Empty));
+			Assert.False(command.CanExecute(0));
+		}
+
+		[Fact]
+		public void IntAsyncCommandFalseCanExecuteParameter()
+		{
+			// Arrange
+			var command = CommandFactory.Create<int>(IntParameterTask, CanExecuteFalse);
+
+			// Act
+
+			// Assert
+			Assert.False(command.CanExecute(null));
+			Assert.False(command.CanExecute(string.Empty));
+			Assert.False(command.CanExecute(0));
+		}
+
+		[Fact]
+		public void IntCommandNullTypedCanExecuteParameter()
+		{
+			// Arrange
+			var command = CommandFactory.Create<int, bool>(IntParameterAction, null);
+
+			// Act
+
+			// Assert
+			Assert.True(command.CanExecute(true));
+			Assert.True(command.CanExecute(null));
+			Assert.True(command.CanExecute(string.Empty));
+			Assert.True(command.CanExecute(0));
+		}
+
+		[Fact]
+		public void IntAsyncCommandNullTypedCanExecuteParameter()
+		{
+			// Arrange
+			var command = CommandFactory.Create<int, bool>(IntParameterTask, null);
+
+			// Act
+
+			// Assert
+			Assert.True(command.CanExecute(true));
+			Assert.True(command.CanExecute(null));
+			Assert.True(command.CanExecute(string.Empty));
+			Assert.True(command.CanExecute(0));
+		}
+
+		[Fact]
+		public void IntCommandBoolCanExecuteParameter()
+		{
+			// Arrange
+			var command = CommandFactory.Create<int, bool>(IntParameterAction, CanExecuteTrue);
+
+			// Act
+
+			// Assert
+			Assert.True(command.CanExecute(true));
+			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(null));
+			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(string.Empty));
+			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(0));
+		}
+
+		[Fact]
+		public void IntAsyncCommandBoolCanExecuteParameter()
+		{
+			// Arrange
+			var command = CommandFactory.Create<int, bool>(IntParameterTask, CanExecuteTrue);
+
+			// Act
+
+			// Assert
+			Assert.True(command.CanExecute(true));
+			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(null));
+			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(string.Empty));
+			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(0));
+		}
+	}
+}
\ No newline at end of file

From 17e731a13a1e634106061e86181b7988335422e7 Mon Sep 17 00:00:00 2001
From: Maksym Koshovyi <maximkoshevoi61@gmail.com>
Date: Tue, 26 Jan 2021 02:48:29 +0200
Subject: [PATCH 10/21] Skip test in question

---
 .../ICommandTests/CommandFactoryTests/CommandFactory_Tests.cs   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_Tests.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_Tests.cs
index 3b77089e3..00cba8459 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_Tests.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_Tests.cs
@@ -175,7 +175,7 @@ public void IntCommandNullTypedCanExecuteParameter()
 			Assert.True(command.CanExecute(0));
 		}
 
-		[Fact]
+		[Fact(Skip = "AsyncCommand validates type here. Is this correct behavior?")]
 		public void IntAsyncCommandNullTypedCanExecuteParameter()
 		{
 			// Arrange

From be96b4e72d9710fc483034204227a5f9c7af7dfd Mon Sep 17 00:00:00 2001
From: Maksym Koshovyi <maximkoshevoi61@gmail.com>
Date: Tue, 26 Jan 2021 02:58:02 +0200
Subject: [PATCH 11/21] Revert Xamarin.CommunityToolkit.csproj changes

---
 .../Xamarin.CommunityToolkit/Xamarin.CommunityToolkit.csproj   | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Xamarin.CommunityToolkit.csproj b/src/CommunityToolkit/Xamarin.CommunityToolkit/Xamarin.CommunityToolkit.csproj
index c6d181f27..a2072552a 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Xamarin.CommunityToolkit.csproj
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Xamarin.CommunityToolkit.csproj
@@ -1,7 +1,8 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project Sdk="MSBuild.Sdk.Extras/2.1.2">
   <PropertyGroup>
-    <TargetFrameworks>netstandard2.0</TargetFrameworks>
+    <TargetFrameworks>netstandard1.0;netstandard2.0;netstandard2.1;Xamarin.iOS10;MonoAndroid10.0;Xamarin.TVOS10;Xamarin.WatchOS10;Xamarin.Mac20;tizen40</TargetFrameworks>
+    <TargetFrameworks Condition=" '$(OS)' == 'Windows_NT' ">$(TargetFrameworks);uap10.0.17763;netcoreapp3.1;net472;net471</TargetFrameworks>
     <AssemblyName>Xamarin.CommunityToolkit</AssemblyName>
     <RootNamespace>Xamarin.CommunityToolkit</RootNamespace>
     <PackageId>Xamarin.CommunityToolkit</PackageId>

From 0574ce3e53a536a71da7d07c7ea74a109f7e89b5 Mon Sep 17 00:00:00 2001
From: Maksym Koshovyi <maximkoshevoi61@gmail.com>
Date: Tue, 26 Jan 2021 10:32:43 +0200
Subject: [PATCH 12/21] Fix tests

---
 ...rin.CommunityToolkit.Sample.Android.csproj |  2 +-
 .../CommandFactory_Tests.cs                   | 14 +++++-----
 .../ObjectModel/CommandFactory.shared.cs      | 28 +++++++++++++++++--
 3 files changed, 33 insertions(+), 11 deletions(-)

diff --git a/samples/XCT.Sample.Android/Xamarin.CommunityToolkit.Sample.Android.csproj b/samples/XCT.Sample.Android/Xamarin.CommunityToolkit.Sample.Android.csproj
index 27fb9082e..8fe84cb44 100644
--- a/samples/XCT.Sample.Android/Xamarin.CommunityToolkit.Sample.Android.csproj
+++ b/samples/XCT.Sample.Android/Xamarin.CommunityToolkit.Sample.Android.csproj
@@ -127,7 +127,7 @@
   <Import Project="$(MSBuildExtensionsPath)\Xamarin\Android\Xamarin.Android.CSharp.targets" />
   <ProjectExtensions>
     <VisualStudio>
-      <UserProperties TriggeredFromHotReload="False" XamarinHotReloadXFormsNugetUpgradeInfoBarXamarinCommunityToolkitSampleAndroidHideInfoBar="True" />
+      <UserProperties XamarinHotReloadXFormsNugetUpgradeInfoBarXamarinCommunityToolkitSampleAndroidHideInfoBar="True" />
     </VisualStudio>
   </ProjectExtensions>
 </Project>
\ No newline at end of file
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_Tests.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_Tests.cs
index 00cba8459..2b24fb8b8 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_Tests.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_Tests.cs
@@ -170,12 +170,12 @@ public void IntCommandNullTypedCanExecuteParameter()
 
 			// Assert
 			Assert.True(command.CanExecute(true));
-			Assert.True(command.CanExecute(null));
-			Assert.True(command.CanExecute(string.Empty));
-			Assert.True(command.CanExecute(0));
+			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(null));
+			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(string.Empty));
+			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(0));
 		}
 
-		[Fact(Skip = "AsyncCommand validates type here. Is this correct behavior?")]
+		[Fact]
 		public void IntAsyncCommandNullTypedCanExecuteParameter()
 		{
 			// Arrange
@@ -185,9 +185,9 @@ public void IntAsyncCommandNullTypedCanExecuteParameter()
 
 			// Assert
 			Assert.True(command.CanExecute(true));
-			Assert.True(command.CanExecute(null));
-			Assert.True(command.CanExecute(string.Empty));
-			Assert.True(command.CanExecute(0));
+			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(null));
+			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(string.Empty));
+			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(0));
 		}
 
 		[Fact]
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.shared.cs
index 9d73c43a4..f16918dea 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.shared.cs
@@ -41,6 +41,30 @@ public static IAsyncCommand<TExecute, TCanExecute> Create<TExecute, TCanExecute>
 			bool allowsMultipleExecutions = true) =>
 			new AsyncCommand<TExecute, TCanExecute>(execute, canExecute, onException, continueOnCapturedContext, allowsMultipleExecutions);
 
+		public static IAsyncValueCommand Create(
+			Func<ValueTask> execute,
+			Func<bool> canExecute = null,
+			Action<Exception> onException = null,
+			bool continueOnCapturedContext = false,
+			bool allowsMultipleExecutions = true) =>
+			new AsyncValueCommand(execute, canExecute, onException, continueOnCapturedContext, allowsMultipleExecutions);
+
+		public static IAsyncValueCommand<TExecute> Create<TExecute>(
+			Func<TExecute, ValueTask> execute,
+			Func<bool> canExecute = null,
+			Action<Exception> onException = null,
+			bool continueOnCapturedContext = false,
+			bool allowsMultipleExecutions = true) =>
+			new AsyncValueCommand<TExecute>(execute, canExecute, onException, continueOnCapturedContext, allowsMultipleExecutions);
+
+		public static IAsyncValueCommand<TExecute, TCanExecute> Create<TExecute, TCanExecute>(
+			Func<TExecute, ValueTask> execute,
+			Func<TCanExecute, bool> canExecute = null,
+			Action<Exception> onException = null,
+			bool continueOnCapturedContext = false,
+			bool allowsMultipleExecutions = true) =>
+			new AsyncValueCommand<TExecute, TCanExecute>(execute, canExecute, onException, continueOnCapturedContext, allowsMultipleExecutions);
+
 		static Action<object> ConvertExecute<T>(Action<T> execute)
 		{
 			if (execute == null)
@@ -79,9 +103,7 @@ static Func<object, bool> ConvertCanExecute(Func<bool> canExecute)
 
 		static Func<object, bool> ConvertCanExecute<T>(Func<T, bool> canExecute)
 		{
-			if (canExecute == null)
-				return _ => true;
-
+			canExecute ??= _ => true;
 			return p => CanExecute(canExecute, p);
 		}
 

From c4fc353d419305d7cef0a999d65e78ae21788dba Mon Sep 17 00:00:00 2001
From: Maksym Koshovyi <maximkoshevoi61@gmail.com>
Date: Tue, 26 Jan 2021 10:42:11 +0200
Subject: [PATCH 13/21] Add tests for AsyncValueCommand

---
 .../CommandFactory_AsyncCommand_Tests.cs      | 113 +++++++++
 .../CommandFactory_AsyncValueCommand_Tests.cs | 115 +++++++++
 .../CommandFactory_Command_Tests.cs           | 121 ++++++++++
 .../CommandFactory_Tests.cs                   | 223 ------------------
 4 files changed, 349 insertions(+), 223 deletions(-)
 create mode 100644 src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_AsyncCommand_Tests.cs
 create mode 100644 src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_AsyncValueCommand_Tests.cs
 create mode 100644 src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_Command_Tests.cs
 delete mode 100644 src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_Tests.cs

diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_AsyncCommand_Tests.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_AsyncCommand_Tests.cs
new file mode 100644
index 000000000..1e28488c1
--- /dev/null
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_AsyncCommand_Tests.cs
@@ -0,0 +1,113 @@
+using System;
+using System.Threading.Tasks;
+using Xamarin.CommunityToolkit.Exceptions;
+using Xamarin.CommunityToolkit.ObjectModel;
+using Xunit;
+
+namespace Xamarin.CommunityToolkit.UnitTests.ObjectModel.ICommandTests.CommandFactoryTests
+{
+	public class CommandFactoryAsyncCommandTests : BaseCommandTests
+	{
+		[Fact]
+		public void NullExecuteParameter()
+		{
+			// Arrange
+			Func<Task> execute = null;
+
+			// Act
+
+			// Assert
+			Assert.Throws<ArgumentNullException>(() => CommandFactory.Create(execute));
+		}
+
+		[Fact]
+		public void NullCanExecuteParameter()
+		{
+			// Arrange
+			var command = CommandFactory.Create(NoParameterTask, null);
+
+			// Act
+
+			// Assert
+			Assert.True(command.CanExecute(null));
+			Assert.True(command.CanExecute(string.Empty));
+			Assert.True(command.CanExecute(0));
+		}
+
+		[Fact]
+		public void IntExecuteNullCanExecuteParameter()
+		{
+			// Arrange
+			var command = CommandFactory.Create<int>(IntParameterTask, null);
+
+			// Act
+
+			// Assert
+			Assert.True(command.CanExecute(null));
+			Assert.True(command.CanExecute(string.Empty));
+			Assert.True(command.CanExecute(0));
+
+			command.Execute(0);
+			Assert.Throws<InvalidCommandParameterException>(() => command.Execute(null));
+			Assert.Throws<InvalidCommandParameterException>(() => command.Execute(string.Empty));
+		}
+
+		[Fact]
+		public void IntExecuteTrueCanExecuteParameter()
+		{
+			// Arrange
+			var command = CommandFactory.Create<int>(IntParameterTask, CanExecuteTrue);
+
+			// Act
+
+			// Assert
+			Assert.True(command.CanExecute(null));
+			Assert.True(command.CanExecute(string.Empty));
+			Assert.True(command.CanExecute(0));
+		}
+
+		[Fact]
+		public void IntExecuteFalseCanExecuteParameter()
+		{
+			// Arrange
+			var command = CommandFactory.Create<int>(IntParameterTask, CanExecuteFalse);
+
+			// Act
+
+			// Assert
+			Assert.False(command.CanExecute(null));
+			Assert.False(command.CanExecute(string.Empty));
+			Assert.False(command.CanExecute(0));
+		}
+
+		[Fact]
+		public void IntExecuteNullTypedCanExecuteParameter()
+		{
+			// Arrange
+			var command = CommandFactory.Create<int, bool>(IntParameterTask, null);
+
+			// Act
+
+			// Assert
+			Assert.True(command.CanExecute(true));
+			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(null));
+			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(string.Empty));
+			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(0));
+		}
+
+		[Fact]
+		public void IntExecuteBoolCanExecuteParameter()
+		{
+			// Arrange
+			var command = CommandFactory.Create<int, bool>(IntParameterTask, CanExecuteTrue);
+
+			// Act
+
+			// Assert
+			Assert.True(command.CanExecute(true));
+			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(null));
+			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(string.Empty));
+			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(0));
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_AsyncValueCommand_Tests.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_AsyncValueCommand_Tests.cs
new file mode 100644
index 000000000..32cfd1c1e
--- /dev/null
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_AsyncValueCommand_Tests.cs
@@ -0,0 +1,115 @@
+using System;
+using System.Threading.Tasks;
+using Xamarin.CommunityToolkit.Exceptions;
+using Xamarin.CommunityToolkit.ObjectModel;
+using Xamarin.CommunityToolkit.UnitTests.ObjectModel.ICommandTests.AsyncValueCommandTests;
+using Xunit;
+
+namespace Xamarin.CommunityToolkit.UnitTests.ObjectModel.ICommandTests.CommandFactoryTests
+{
+	public class CommandFactoryAsyncValueCommandTests : BaseAsyncValueCommandTests
+	{
+
+		[Fact]
+		public void NullExecuteParameter()
+		{
+			// Arrange
+			Func<ValueTask> execute = null;
+
+			// Act
+
+			// Assert
+			Assert.Throws<ArgumentNullException>(() => CommandFactory.Create(execute));
+		}
+
+		[Fact]
+		public void NullCanExecuteParameter()
+		{
+			// Arrange
+			var command = CommandFactory.Create(NoParameterTask, null);
+
+			// Act
+
+			// Assert
+			Assert.True(command.CanExecute(null));
+			Assert.True(command.CanExecute(string.Empty));
+			Assert.True(command.CanExecute(0));
+		}
+
+		[Fact]
+		public void IntExecuteNullCanExecuteParameter()
+		{
+			// Arrange
+			var command = CommandFactory.Create<int>(IntParameterTask, null);
+
+			// Act
+
+			// Assert
+			Assert.True(command.CanExecute(null));
+			Assert.True(command.CanExecute(string.Empty));
+			Assert.True(command.CanExecute(0));
+
+			command.Execute(0);
+			Assert.Throws<InvalidCommandParameterException>(() => command.Execute(null));
+			Assert.Throws<InvalidCommandParameterException>(() => command.Execute(string.Empty));
+		}
+
+		[Fact]
+		public void IntExecuteTrueCanExecuteParameter()
+		{
+			// Arrange
+			var command = CommandFactory.Create<int>(IntParameterTask, CanExecuteTrue);
+
+			// Act
+
+			// Assert
+			Assert.True(command.CanExecute(null));
+			Assert.True(command.CanExecute(string.Empty));
+			Assert.True(command.CanExecute(0));
+		}
+
+		[Fact]
+		public void IntExecuteFalseCanExecuteParameter()
+		{
+			// Arrange
+			var command = CommandFactory.Create<int>(IntParameterTask, CanExecuteFalse);
+
+			// Act
+
+			// Assert
+			Assert.False(command.CanExecute(null));
+			Assert.False(command.CanExecute(string.Empty));
+			Assert.False(command.CanExecute(0));
+		}
+
+		[Fact]
+		public void IntExecuteNullTypedCanExecuteParameter()
+		{
+			// Arrange
+			var command = CommandFactory.Create<int, bool>(IntParameterTask, null);
+
+			// Act
+
+			// Assert
+			Assert.True(command.CanExecute(true));
+			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(null));
+			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(string.Empty));
+			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(0));
+		}
+
+		[Fact]
+		public void IntExecuteBoolCanExecuteParameter()
+		{
+			// Arrange
+			var command = CommandFactory.Create<int, bool>(IntParameterTask, CanExecuteTrue);
+
+			// Act
+
+			// Assert
+			Assert.True(command.CanExecute(true));
+			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(null));
+			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(string.Empty));
+			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(0));
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_Command_Tests.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_Command_Tests.cs
new file mode 100644
index 000000000..69f78bcc5
--- /dev/null
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_Command_Tests.cs
@@ -0,0 +1,121 @@
+using System;
+using System.Threading.Tasks;
+using Xamarin.CommunityToolkit.Exceptions;
+using Xamarin.CommunityToolkit.ObjectModel;
+using Xunit;
+
+namespace Xamarin.CommunityToolkit.UnitTests.ObjectModel.ICommandTests.CommandFactoryTests
+{
+	public class CommandFactoryCommandTests : BaseCommandTests
+	{
+		protected void NoParameterAction()
+        {
+        }
+
+		protected void IntParameterAction(int i)
+        {
+        }
+
+		[Fact]
+		public void NullExecuteParameter()
+		{
+			// Arrange
+			Action execute = null;
+
+			// Act
+
+			// Assert
+			Assert.Throws<ArgumentNullException>(() => CommandFactory.Create(execute));
+		}
+
+		[Fact]
+		public void NullCanExecuteParameter()
+		{
+			// Arrange
+			var command = CommandFactory.Create(NoParameterAction, null);
+
+			// Act
+
+			// Assert
+			Assert.True(command.CanExecute(null));
+			Assert.True(command.CanExecute(string.Empty));
+			Assert.True(command.CanExecute(0));
+		}
+
+		[Fact]
+		public void IntExecuteNullCanExecuteParameter()
+		{
+			// Arrange
+			var command = CommandFactory.Create<int>(IntParameterAction, null);
+
+			// Act
+
+			// Assert
+			Assert.True(command.CanExecute(null));
+			Assert.True(command.CanExecute(string.Empty));
+			Assert.True(command.CanExecute(0));
+
+			command.Execute(0);
+			Assert.Throws<InvalidCommandParameterException>(() => command.Execute(null));
+			Assert.Throws<InvalidCommandParameterException>(() => command.Execute(string.Empty));
+		}
+
+		[Fact]
+		public void IntExecuteTrueCanExecuteParameter()
+		{
+			// Arrange
+			var command = CommandFactory.Create<int>(IntParameterAction, CanExecuteTrue);
+
+			// Act
+
+			// Assert
+			Assert.True(command.CanExecute(null));
+			Assert.True(command.CanExecute(string.Empty));
+			Assert.True(command.CanExecute(0));
+		}
+
+		[Fact]
+		public void IntExecuteFalseCanExecuteParameter()
+		{
+			// Arrange
+			var command = CommandFactory.Create<int>(IntParameterAction, CanExecuteFalse);
+
+			// Act
+
+			// Assert
+			Assert.False(command.CanExecute(null));
+			Assert.False(command.CanExecute(string.Empty));
+			Assert.False(command.CanExecute(0));
+		}
+
+		[Fact]
+		public void IntExecuteNullTypedCanExecuteParameter()
+		{
+			// Arrange
+			var command = CommandFactory.Create<int, bool>(IntParameterAction, null);
+
+			// Act
+
+			// Assert
+			Assert.True(command.CanExecute(true));
+			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(null));
+			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(string.Empty));
+			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(0));
+		}
+
+		[Fact]
+		public void IntExecuteBoolCanExecuteParameter()
+		{
+			// Arrange
+			var command = CommandFactory.Create<int, bool>(IntParameterAction, CanExecuteTrue);
+
+			// Act
+
+			// Assert
+			Assert.True(command.CanExecute(true));
+			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(null));
+			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(string.Empty));
+			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(0));
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_Tests.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_Tests.cs
deleted file mode 100644
index 2b24fb8b8..000000000
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_Tests.cs
+++ /dev/null
@@ -1,223 +0,0 @@
-using System;
-using System.Threading.Tasks;
-using Xamarin.CommunityToolkit.Exceptions;
-using Xamarin.CommunityToolkit.ObjectModel;
-using Xunit;
-
-namespace Xamarin.CommunityToolkit.UnitTests.ObjectModel.ICommandTests.CommandFactoryTests
-{
-	public class CommandFactoryTests : BaseCommandTests
-	{
-		protected void NoParameterAction()
-        {
-        }
-
-		protected void IntParameterAction(int i)
-        {
-        }
-
-		[Fact]
-		public void CommandNullExecuteParameter()
-		{
-			// Arrange
-			Action execute = null;
-
-			// Act
-
-			// Assert
-			Assert.Throws<ArgumentNullException>(() => CommandFactory.Create(execute));
-		}
-
-		[Fact]
-		public void AsyncCommandNullExecuteParameter()
-		{
-			// Arrange
-			Func<Task> execute = null;
-
-			// Act
-
-			// Assert
-			Assert.Throws<ArgumentNullException>(() => CommandFactory.Create(execute));
-		}
-
-		[Fact]
-		public void CommandNullCanExecuteParameter()
-		{
-			// Arrange
-			var command = CommandFactory.Create(NoParameterAction, null);
-
-			// Act
-
-			// Assert
-			Assert.True(command.CanExecute(null));
-			Assert.True(command.CanExecute(string.Empty));
-			Assert.True(command.CanExecute(0));
-		}
-
-		[Fact]
-		public void AsyncCommandNullCanExecuteParameter()
-		{
-			// Arrange
-			var command = CommandFactory.Create(NoParameterTask, null);
-
-			// Act
-
-			// Assert
-			Assert.True(command.CanExecute(null));
-			Assert.True(command.CanExecute(string.Empty));
-			Assert.True(command.CanExecute(0));
-		}
-
-		[Fact]
-		public void IntCommandNullCanExecuteParameter()
-		{
-			// Arrange
-			var command = CommandFactory.Create<int>(IntParameterAction, null);
-
-			// Act
-
-			// Assert
-			Assert.True(command.CanExecute(null));
-			Assert.True(command.CanExecute(string.Empty));
-			Assert.True(command.CanExecute(0));
-
-			command.Execute(0);
-			Assert.Throws<InvalidCommandParameterException>(() => command.Execute(null));
-			Assert.Throws<InvalidCommandParameterException>(() => command.Execute(string.Empty));
-		}
-
-		[Fact]
-		public void IntAsyncCommandNullCanExecuteParameter()
-		{
-			// Arrange
-			var command = CommandFactory.Create<int>(IntParameterTask, null);
-
-			// Act
-
-			// Assert
-			Assert.True(command.CanExecute(null));
-			Assert.True(command.CanExecute(string.Empty));
-			Assert.True(command.CanExecute(0));
-
-			command.Execute(0);
-			Assert.Throws<InvalidCommandParameterException>(() => command.Execute(null));
-			Assert.Throws<InvalidCommandParameterException>(() => command.Execute(string.Empty));
-		}
-
-		[Fact]
-		public void IntCommandTrueCanExecuteParameter()
-		{
-			// Arrange
-			var command = CommandFactory.Create<int>(IntParameterAction, CanExecuteTrue);
-
-			// Act
-
-			// Assert
-			Assert.True(command.CanExecute(null));
-			Assert.True(command.CanExecute(string.Empty));
-			Assert.True(command.CanExecute(0));
-		}
-
-		[Fact]
-		public void IntAsyncCommandTrueCanExecuteParameter()
-		{
-			// Arrange
-			var command = CommandFactory.Create<int>(IntParameterTask, CanExecuteTrue);
-
-			// Act
-
-			// Assert
-			Assert.True(command.CanExecute(null));
-			Assert.True(command.CanExecute(string.Empty));
-			Assert.True(command.CanExecute(0));
-		}
-
-		[Fact]
-		public void IntCommandFalseCanExecuteParameter()
-		{
-			// Arrange
-			var command = CommandFactory.Create<int>(IntParameterAction, CanExecuteFalse);
-
-			// Act
-
-			// Assert
-			Assert.False(command.CanExecute(null));
-			Assert.False(command.CanExecute(string.Empty));
-			Assert.False(command.CanExecute(0));
-		}
-
-		[Fact]
-		public void IntAsyncCommandFalseCanExecuteParameter()
-		{
-			// Arrange
-			var command = CommandFactory.Create<int>(IntParameterTask, CanExecuteFalse);
-
-			// Act
-
-			// Assert
-			Assert.False(command.CanExecute(null));
-			Assert.False(command.CanExecute(string.Empty));
-			Assert.False(command.CanExecute(0));
-		}
-
-		[Fact]
-		public void IntCommandNullTypedCanExecuteParameter()
-		{
-			// Arrange
-			var command = CommandFactory.Create<int, bool>(IntParameterAction, null);
-
-			// Act
-
-			// Assert
-			Assert.True(command.CanExecute(true));
-			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(null));
-			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(string.Empty));
-			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(0));
-		}
-
-		[Fact]
-		public void IntAsyncCommandNullTypedCanExecuteParameter()
-		{
-			// Arrange
-			var command = CommandFactory.Create<int, bool>(IntParameterTask, null);
-
-			// Act
-
-			// Assert
-			Assert.True(command.CanExecute(true));
-			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(null));
-			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(string.Empty));
-			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(0));
-		}
-
-		[Fact]
-		public void IntCommandBoolCanExecuteParameter()
-		{
-			// Arrange
-			var command = CommandFactory.Create<int, bool>(IntParameterAction, CanExecuteTrue);
-
-			// Act
-
-			// Assert
-			Assert.True(command.CanExecute(true));
-			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(null));
-			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(string.Empty));
-			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(0));
-		}
-
-		[Fact]
-		public void IntAsyncCommandBoolCanExecuteParameter()
-		{
-			// Arrange
-			var command = CommandFactory.Create<int, bool>(IntParameterTask, CanExecuteTrue);
-
-			// Act
-
-			// Assert
-			Assert.True(command.CanExecute(true));
-			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(null));
-			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(string.Empty));
-			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(0));
-		}
-	}
-}
\ No newline at end of file

From 07a178c6ab761cfa5496c776a18ded9560a2e07a Mon Sep 17 00:00:00 2001
From: Maksym Koshovyi <maximkoshevoi61@gmail.com>
Date: Tue, 26 Jan 2021 20:07:36 +0200
Subject: [PATCH 14/21] Revert AsyncValueCommandSupport

---
 .../CommandFactory_AsyncValueCommand_Tests.cs | 115 ------------------
 .../ObjectModel/CommandFactory.shared.cs      |  24 ----
 2 files changed, 139 deletions(-)
 delete mode 100644 src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_AsyncValueCommand_Tests.cs

diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_AsyncValueCommand_Tests.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_AsyncValueCommand_Tests.cs
deleted file mode 100644
index 32cfd1c1e..000000000
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_AsyncValueCommand_Tests.cs
+++ /dev/null
@@ -1,115 +0,0 @@
-using System;
-using System.Threading.Tasks;
-using Xamarin.CommunityToolkit.Exceptions;
-using Xamarin.CommunityToolkit.ObjectModel;
-using Xamarin.CommunityToolkit.UnitTests.ObjectModel.ICommandTests.AsyncValueCommandTests;
-using Xunit;
-
-namespace Xamarin.CommunityToolkit.UnitTests.ObjectModel.ICommandTests.CommandFactoryTests
-{
-	public class CommandFactoryAsyncValueCommandTests : BaseAsyncValueCommandTests
-	{
-
-		[Fact]
-		public void NullExecuteParameter()
-		{
-			// Arrange
-			Func<ValueTask> execute = null;
-
-			// Act
-
-			// Assert
-			Assert.Throws<ArgumentNullException>(() => CommandFactory.Create(execute));
-		}
-
-		[Fact]
-		public void NullCanExecuteParameter()
-		{
-			// Arrange
-			var command = CommandFactory.Create(NoParameterTask, null);
-
-			// Act
-
-			// Assert
-			Assert.True(command.CanExecute(null));
-			Assert.True(command.CanExecute(string.Empty));
-			Assert.True(command.CanExecute(0));
-		}
-
-		[Fact]
-		public void IntExecuteNullCanExecuteParameter()
-		{
-			// Arrange
-			var command = CommandFactory.Create<int>(IntParameterTask, null);
-
-			// Act
-
-			// Assert
-			Assert.True(command.CanExecute(null));
-			Assert.True(command.CanExecute(string.Empty));
-			Assert.True(command.CanExecute(0));
-
-			command.Execute(0);
-			Assert.Throws<InvalidCommandParameterException>(() => command.Execute(null));
-			Assert.Throws<InvalidCommandParameterException>(() => command.Execute(string.Empty));
-		}
-
-		[Fact]
-		public void IntExecuteTrueCanExecuteParameter()
-		{
-			// Arrange
-			var command = CommandFactory.Create<int>(IntParameterTask, CanExecuteTrue);
-
-			// Act
-
-			// Assert
-			Assert.True(command.CanExecute(null));
-			Assert.True(command.CanExecute(string.Empty));
-			Assert.True(command.CanExecute(0));
-		}
-
-		[Fact]
-		public void IntExecuteFalseCanExecuteParameter()
-		{
-			// Arrange
-			var command = CommandFactory.Create<int>(IntParameterTask, CanExecuteFalse);
-
-			// Act
-
-			// Assert
-			Assert.False(command.CanExecute(null));
-			Assert.False(command.CanExecute(string.Empty));
-			Assert.False(command.CanExecute(0));
-		}
-
-		[Fact]
-		public void IntExecuteNullTypedCanExecuteParameter()
-		{
-			// Arrange
-			var command = CommandFactory.Create<int, bool>(IntParameterTask, null);
-
-			// Act
-
-			// Assert
-			Assert.True(command.CanExecute(true));
-			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(null));
-			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(string.Empty));
-			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(0));
-		}
-
-		[Fact]
-		public void IntExecuteBoolCanExecuteParameter()
-		{
-			// Arrange
-			var command = CommandFactory.Create<int, bool>(IntParameterTask, CanExecuteTrue);
-
-			// Act
-
-			// Assert
-			Assert.True(command.CanExecute(true));
-			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(null));
-			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(string.Empty));
-			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(0));
-		}
-	}
-}
\ No newline at end of file
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.shared.cs
index f16918dea..75dba17c3 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.shared.cs
@@ -41,30 +41,6 @@ public static IAsyncCommand<TExecute, TCanExecute> Create<TExecute, TCanExecute>
 			bool allowsMultipleExecutions = true) =>
 			new AsyncCommand<TExecute, TCanExecute>(execute, canExecute, onException, continueOnCapturedContext, allowsMultipleExecutions);
 
-		public static IAsyncValueCommand Create(
-			Func<ValueTask> execute,
-			Func<bool> canExecute = null,
-			Action<Exception> onException = null,
-			bool continueOnCapturedContext = false,
-			bool allowsMultipleExecutions = true) =>
-			new AsyncValueCommand(execute, canExecute, onException, continueOnCapturedContext, allowsMultipleExecutions);
-
-		public static IAsyncValueCommand<TExecute> Create<TExecute>(
-			Func<TExecute, ValueTask> execute,
-			Func<bool> canExecute = null,
-			Action<Exception> onException = null,
-			bool continueOnCapturedContext = false,
-			bool allowsMultipleExecutions = true) =>
-			new AsyncValueCommand<TExecute>(execute, canExecute, onException, continueOnCapturedContext, allowsMultipleExecutions);
-
-		public static IAsyncValueCommand<TExecute, TCanExecute> Create<TExecute, TCanExecute>(
-			Func<TExecute, ValueTask> execute,
-			Func<TCanExecute, bool> canExecute = null,
-			Action<Exception> onException = null,
-			bool continueOnCapturedContext = false,
-			bool allowsMultipleExecutions = true) =>
-			new AsyncValueCommand<TExecute, TCanExecute>(execute, canExecute, onException, continueOnCapturedContext, allowsMultipleExecutions);
-
 		static Action<object> ConvertExecute<T>(Action<T> execute)
 		{
 			if (execute == null)

From 7c82bc8962ef03043c2e248c7a3f3f48d32312d0 Mon Sep 17 00:00:00 2001
From: Maksym Koshovyi <maximkoshevoi61@gmail.com>
Date: Tue, 26 Jan 2021 21:55:54 +0200
Subject: [PATCH 15/21] Revert "Revert AsyncValueCommandSupport"

This reverts commit 07a178c6ab761cfa5496c776a18ded9560a2e07a.
---
 .../CommandFactory_AsyncValueCommand_Tests.cs | 115 ++++++++++++++++++
 .../ObjectModel/CommandFactory.shared.cs      |  24 ++++
 2 files changed, 139 insertions(+)
 create mode 100644 src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_AsyncValueCommand_Tests.cs

diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_AsyncValueCommand_Tests.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_AsyncValueCommand_Tests.cs
new file mode 100644
index 000000000..32cfd1c1e
--- /dev/null
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_AsyncValueCommand_Tests.cs
@@ -0,0 +1,115 @@
+using System;
+using System.Threading.Tasks;
+using Xamarin.CommunityToolkit.Exceptions;
+using Xamarin.CommunityToolkit.ObjectModel;
+using Xamarin.CommunityToolkit.UnitTests.ObjectModel.ICommandTests.AsyncValueCommandTests;
+using Xunit;
+
+namespace Xamarin.CommunityToolkit.UnitTests.ObjectModel.ICommandTests.CommandFactoryTests
+{
+	public class CommandFactoryAsyncValueCommandTests : BaseAsyncValueCommandTests
+	{
+
+		[Fact]
+		public void NullExecuteParameter()
+		{
+			// Arrange
+			Func<ValueTask> execute = null;
+
+			// Act
+
+			// Assert
+			Assert.Throws<ArgumentNullException>(() => CommandFactory.Create(execute));
+		}
+
+		[Fact]
+		public void NullCanExecuteParameter()
+		{
+			// Arrange
+			var command = CommandFactory.Create(NoParameterTask, null);
+
+			// Act
+
+			// Assert
+			Assert.True(command.CanExecute(null));
+			Assert.True(command.CanExecute(string.Empty));
+			Assert.True(command.CanExecute(0));
+		}
+
+		[Fact]
+		public void IntExecuteNullCanExecuteParameter()
+		{
+			// Arrange
+			var command = CommandFactory.Create<int>(IntParameterTask, null);
+
+			// Act
+
+			// Assert
+			Assert.True(command.CanExecute(null));
+			Assert.True(command.CanExecute(string.Empty));
+			Assert.True(command.CanExecute(0));
+
+			command.Execute(0);
+			Assert.Throws<InvalidCommandParameterException>(() => command.Execute(null));
+			Assert.Throws<InvalidCommandParameterException>(() => command.Execute(string.Empty));
+		}
+
+		[Fact]
+		public void IntExecuteTrueCanExecuteParameter()
+		{
+			// Arrange
+			var command = CommandFactory.Create<int>(IntParameterTask, CanExecuteTrue);
+
+			// Act
+
+			// Assert
+			Assert.True(command.CanExecute(null));
+			Assert.True(command.CanExecute(string.Empty));
+			Assert.True(command.CanExecute(0));
+		}
+
+		[Fact]
+		public void IntExecuteFalseCanExecuteParameter()
+		{
+			// Arrange
+			var command = CommandFactory.Create<int>(IntParameterTask, CanExecuteFalse);
+
+			// Act
+
+			// Assert
+			Assert.False(command.CanExecute(null));
+			Assert.False(command.CanExecute(string.Empty));
+			Assert.False(command.CanExecute(0));
+		}
+
+		[Fact]
+		public void IntExecuteNullTypedCanExecuteParameter()
+		{
+			// Arrange
+			var command = CommandFactory.Create<int, bool>(IntParameterTask, null);
+
+			// Act
+
+			// Assert
+			Assert.True(command.CanExecute(true));
+			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(null));
+			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(string.Empty));
+			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(0));
+		}
+
+		[Fact]
+		public void IntExecuteBoolCanExecuteParameter()
+		{
+			// Arrange
+			var command = CommandFactory.Create<int, bool>(IntParameterTask, CanExecuteTrue);
+
+			// Act
+
+			// Assert
+			Assert.True(command.CanExecute(true));
+			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(null));
+			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(string.Empty));
+			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(0));
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.shared.cs
index 75dba17c3..f16918dea 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.shared.cs
@@ -41,6 +41,30 @@ public static IAsyncCommand<TExecute, TCanExecute> Create<TExecute, TCanExecute>
 			bool allowsMultipleExecutions = true) =>
 			new AsyncCommand<TExecute, TCanExecute>(execute, canExecute, onException, continueOnCapturedContext, allowsMultipleExecutions);
 
+		public static IAsyncValueCommand Create(
+			Func<ValueTask> execute,
+			Func<bool> canExecute = null,
+			Action<Exception> onException = null,
+			bool continueOnCapturedContext = false,
+			bool allowsMultipleExecutions = true) =>
+			new AsyncValueCommand(execute, canExecute, onException, continueOnCapturedContext, allowsMultipleExecutions);
+
+		public static IAsyncValueCommand<TExecute> Create<TExecute>(
+			Func<TExecute, ValueTask> execute,
+			Func<bool> canExecute = null,
+			Action<Exception> onException = null,
+			bool continueOnCapturedContext = false,
+			bool allowsMultipleExecutions = true) =>
+			new AsyncValueCommand<TExecute>(execute, canExecute, onException, continueOnCapturedContext, allowsMultipleExecutions);
+
+		public static IAsyncValueCommand<TExecute, TCanExecute> Create<TExecute, TCanExecute>(
+			Func<TExecute, ValueTask> execute,
+			Func<TCanExecute, bool> canExecute = null,
+			Action<Exception> onException = null,
+			bool continueOnCapturedContext = false,
+			bool allowsMultipleExecutions = true) =>
+			new AsyncValueCommand<TExecute, TCanExecute>(execute, canExecute, onException, continueOnCapturedContext, allowsMultipleExecutions);
+
 		static Action<object> ConvertExecute<T>(Action<T> execute)
 		{
 			if (execute == null)

From 7b325610596e67b8fb3dff6600348f4726f25664 Mon Sep 17 00:00:00 2001
From: Maksym Koshovyi <maximkoshevoi61@gmail.com>
Date: Tue, 26 Jan 2021 22:01:32 +0200
Subject: [PATCH 16/21] Creating AsyncValueCommand using CreateValue

---
 .../CommandFactory_AsyncValueCommand_Tests.cs     | 15 +++++++--------
 .../CommandFactory_Command_Tests.cs               |  1 -
 .../ObjectModel/CommandFactory.shared.cs          |  6 +++---
 3 files changed, 10 insertions(+), 12 deletions(-)

diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_AsyncValueCommand_Tests.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_AsyncValueCommand_Tests.cs
index 32cfd1c1e..e04e422d3 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_AsyncValueCommand_Tests.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_AsyncValueCommand_Tests.cs
@@ -9,7 +9,6 @@ namespace Xamarin.CommunityToolkit.UnitTests.ObjectModel.ICommandTests.CommandFa
 {
 	public class CommandFactoryAsyncValueCommandTests : BaseAsyncValueCommandTests
 	{
-
 		[Fact]
 		public void NullExecuteParameter()
 		{
@@ -19,14 +18,14 @@ public void NullExecuteParameter()
 			// Act
 
 			// Assert
-			Assert.Throws<ArgumentNullException>(() => CommandFactory.Create(execute));
+			Assert.Throws<ArgumentNullException>(() => CommandFactory.CreateValue(execute));
 		}
 
 		[Fact]
 		public void NullCanExecuteParameter()
 		{
 			// Arrange
-			var command = CommandFactory.Create(NoParameterTask, null);
+			var command = CommandFactory.CreateValue(NoParameterTask, null);
 
 			// Act
 
@@ -40,7 +39,7 @@ public void NullCanExecuteParameter()
 		public void IntExecuteNullCanExecuteParameter()
 		{
 			// Arrange
-			var command = CommandFactory.Create<int>(IntParameterTask, null);
+			var command = CommandFactory.CreateValue<int>(IntParameterTask, null);
 
 			// Act
 
@@ -58,7 +57,7 @@ public void IntExecuteNullCanExecuteParameter()
 		public void IntExecuteTrueCanExecuteParameter()
 		{
 			// Arrange
-			var command = CommandFactory.Create<int>(IntParameterTask, CanExecuteTrue);
+			var command = CommandFactory.CreateValue<int>(IntParameterTask, CanExecuteTrue);
 
 			// Act
 
@@ -72,7 +71,7 @@ public void IntExecuteTrueCanExecuteParameter()
 		public void IntExecuteFalseCanExecuteParameter()
 		{
 			// Arrange
-			var command = CommandFactory.Create<int>(IntParameterTask, CanExecuteFalse);
+			var command = CommandFactory.CreateValue<int>(IntParameterTask, CanExecuteFalse);
 
 			// Act
 
@@ -86,7 +85,7 @@ public void IntExecuteFalseCanExecuteParameter()
 		public void IntExecuteNullTypedCanExecuteParameter()
 		{
 			// Arrange
-			var command = CommandFactory.Create<int, bool>(IntParameterTask, null);
+			var command = CommandFactory.CreateValue<int, bool>(IntParameterTask, null);
 
 			// Act
 
@@ -101,7 +100,7 @@ public void IntExecuteNullTypedCanExecuteParameter()
 		public void IntExecuteBoolCanExecuteParameter()
 		{
 			// Arrange
-			var command = CommandFactory.Create<int, bool>(IntParameterTask, CanExecuteTrue);
+			var command = CommandFactory.CreateValue<int, bool>(IntParameterTask, CanExecuteTrue);
 
 			// Act
 
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_Command_Tests.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_Command_Tests.cs
index 69f78bcc5..cb315d849 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_Command_Tests.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_Command_Tests.cs
@@ -1,5 +1,4 @@
 using System;
-using System.Threading.Tasks;
 using Xamarin.CommunityToolkit.Exceptions;
 using Xamarin.CommunityToolkit.ObjectModel;
 using Xunit;
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.shared.cs
index f16918dea..4dcf28b46 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.shared.cs
@@ -41,7 +41,7 @@ public static IAsyncCommand<TExecute, TCanExecute> Create<TExecute, TCanExecute>
 			bool allowsMultipleExecutions = true) =>
 			new AsyncCommand<TExecute, TCanExecute>(execute, canExecute, onException, continueOnCapturedContext, allowsMultipleExecutions);
 
-		public static IAsyncValueCommand Create(
+		public static IAsyncValueCommand CreateValue(
 			Func<ValueTask> execute,
 			Func<bool> canExecute = null,
 			Action<Exception> onException = null,
@@ -49,7 +49,7 @@ public static IAsyncValueCommand Create(
 			bool allowsMultipleExecutions = true) =>
 			new AsyncValueCommand(execute, canExecute, onException, continueOnCapturedContext, allowsMultipleExecutions);
 
-		public static IAsyncValueCommand<TExecute> Create<TExecute>(
+		public static IAsyncValueCommand<TExecute> CreateValue<TExecute>(
 			Func<TExecute, ValueTask> execute,
 			Func<bool> canExecute = null,
 			Action<Exception> onException = null,
@@ -57,7 +57,7 @@ public static IAsyncValueCommand<TExecute> Create<TExecute>(
 			bool allowsMultipleExecutions = true) =>
 			new AsyncValueCommand<TExecute>(execute, canExecute, onException, continueOnCapturedContext, allowsMultipleExecutions);
 
-		public static IAsyncValueCommand<TExecute, TCanExecute> Create<TExecute, TCanExecute>(
+		public static IAsyncValueCommand<TExecute, TCanExecute> CreateValue<TExecute, TCanExecute>(
 			Func<TExecute, ValueTask> execute,
 			Func<TCanExecute, bool> canExecute = null,
 			Action<Exception> onException = null,

From 3f8a517267e4c8547c65f1cbf054b5dfa45a567d Mon Sep 17 00:00:00 2001
From: Maksym Koshovyi <maximkoshevoi61@gmail.com>
Date: Tue, 26 Jan 2021 22:56:48 +0200
Subject: [PATCH 17/21] Revert "Creating AsyncValueCommand using CreateValue"

This reverts commit 7b325610596e67b8fb3dff6600348f4726f25664.
---
 .../CommandFactory_AsyncValueCommand_Tests.cs     | 15 ++++++++-------
 .../CommandFactory_Command_Tests.cs               |  1 +
 .../ObjectModel/CommandFactory.shared.cs          |  6 +++---
 3 files changed, 12 insertions(+), 10 deletions(-)

diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_AsyncValueCommand_Tests.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_AsyncValueCommand_Tests.cs
index e04e422d3..32cfd1c1e 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_AsyncValueCommand_Tests.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_AsyncValueCommand_Tests.cs
@@ -9,6 +9,7 @@ namespace Xamarin.CommunityToolkit.UnitTests.ObjectModel.ICommandTests.CommandFa
 {
 	public class CommandFactoryAsyncValueCommandTests : BaseAsyncValueCommandTests
 	{
+
 		[Fact]
 		public void NullExecuteParameter()
 		{
@@ -18,14 +19,14 @@ public void NullExecuteParameter()
 			// Act
 
 			// Assert
-			Assert.Throws<ArgumentNullException>(() => CommandFactory.CreateValue(execute));
+			Assert.Throws<ArgumentNullException>(() => CommandFactory.Create(execute));
 		}
 
 		[Fact]
 		public void NullCanExecuteParameter()
 		{
 			// Arrange
-			var command = CommandFactory.CreateValue(NoParameterTask, null);
+			var command = CommandFactory.Create(NoParameterTask, null);
 
 			// Act
 
@@ -39,7 +40,7 @@ public void NullCanExecuteParameter()
 		public void IntExecuteNullCanExecuteParameter()
 		{
 			// Arrange
-			var command = CommandFactory.CreateValue<int>(IntParameterTask, null);
+			var command = CommandFactory.Create<int>(IntParameterTask, null);
 
 			// Act
 
@@ -57,7 +58,7 @@ public void IntExecuteNullCanExecuteParameter()
 		public void IntExecuteTrueCanExecuteParameter()
 		{
 			// Arrange
-			var command = CommandFactory.CreateValue<int>(IntParameterTask, CanExecuteTrue);
+			var command = CommandFactory.Create<int>(IntParameterTask, CanExecuteTrue);
 
 			// Act
 
@@ -71,7 +72,7 @@ public void IntExecuteTrueCanExecuteParameter()
 		public void IntExecuteFalseCanExecuteParameter()
 		{
 			// Arrange
-			var command = CommandFactory.CreateValue<int>(IntParameterTask, CanExecuteFalse);
+			var command = CommandFactory.Create<int>(IntParameterTask, CanExecuteFalse);
 
 			// Act
 
@@ -85,7 +86,7 @@ public void IntExecuteFalseCanExecuteParameter()
 		public void IntExecuteNullTypedCanExecuteParameter()
 		{
 			// Arrange
-			var command = CommandFactory.CreateValue<int, bool>(IntParameterTask, null);
+			var command = CommandFactory.Create<int, bool>(IntParameterTask, null);
 
 			// Act
 
@@ -100,7 +101,7 @@ public void IntExecuteNullTypedCanExecuteParameter()
 		public void IntExecuteBoolCanExecuteParameter()
 		{
 			// Arrange
-			var command = CommandFactory.CreateValue<int, bool>(IntParameterTask, CanExecuteTrue);
+			var command = CommandFactory.Create<int, bool>(IntParameterTask, CanExecuteTrue);
 
 			// Act
 
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_Command_Tests.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_Command_Tests.cs
index cb315d849..69f78bcc5 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_Command_Tests.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_Command_Tests.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Threading.Tasks;
 using Xamarin.CommunityToolkit.Exceptions;
 using Xamarin.CommunityToolkit.ObjectModel;
 using Xunit;
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.shared.cs
index 4dcf28b46..f16918dea 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.shared.cs
@@ -41,7 +41,7 @@ public static IAsyncCommand<TExecute, TCanExecute> Create<TExecute, TCanExecute>
 			bool allowsMultipleExecutions = true) =>
 			new AsyncCommand<TExecute, TCanExecute>(execute, canExecute, onException, continueOnCapturedContext, allowsMultipleExecutions);
 
-		public static IAsyncValueCommand CreateValue(
+		public static IAsyncValueCommand Create(
 			Func<ValueTask> execute,
 			Func<bool> canExecute = null,
 			Action<Exception> onException = null,
@@ -49,7 +49,7 @@ public static IAsyncValueCommand CreateValue(
 			bool allowsMultipleExecutions = true) =>
 			new AsyncValueCommand(execute, canExecute, onException, continueOnCapturedContext, allowsMultipleExecutions);
 
-		public static IAsyncValueCommand<TExecute> CreateValue<TExecute>(
+		public static IAsyncValueCommand<TExecute> Create<TExecute>(
 			Func<TExecute, ValueTask> execute,
 			Func<bool> canExecute = null,
 			Action<Exception> onException = null,
@@ -57,7 +57,7 @@ public static IAsyncValueCommand<TExecute> CreateValue<TExecute>(
 			bool allowsMultipleExecutions = true) =>
 			new AsyncValueCommand<TExecute>(execute, canExecute, onException, continueOnCapturedContext, allowsMultipleExecutions);
 
-		public static IAsyncValueCommand<TExecute, TCanExecute> CreateValue<TExecute, TCanExecute>(
+		public static IAsyncValueCommand<TExecute, TCanExecute> Create<TExecute, TCanExecute>(
 			Func<TExecute, ValueTask> execute,
 			Func<TCanExecute, bool> canExecute = null,
 			Action<Exception> onException = null,

From ca6b60690155af2b4b569356eb9b93f56e15411b Mon Sep 17 00:00:00 2001
From: Maksym Koshovyi <maximkoshevoi61@gmail.com>
Date: Tue, 26 Jan 2021 23:02:52 +0200
Subject: [PATCH 18/21] Add Create overloads without optional parameters for
 Task to act as tiebreakers

---
 .../CommandFactory_AsyncCommand_Tests.cs       | 16 ++++++++++++++++
 .../ObjectModel/CommandFactory.shared.cs       | 18 ++++++++++++++++++
 2 files changed, 34 insertions(+)

diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_AsyncCommand_Tests.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_AsyncCommand_Tests.cs
index 1e28488c1..2fc6fbee5 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_AsyncCommand_Tests.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_AsyncCommand_Tests.cs
@@ -109,5 +109,21 @@ public void IntExecuteBoolCanExecuteParameter()
 			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(string.Empty));
 			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(0));
 		}
+
+		[Fact]
+		public void LambdaExecuteTiebreakerTest()
+		{
+			// Arrange
+			CommandFactory.Create(async () => await NoParameterTask());
+			CommandFactory.Create(async () => await NoParameterTask(), CanExecuteTrue);
+			CommandFactory.Create<int>(async p => await IntParameterTask(p));
+			CommandFactory.Create<int>(async p => await IntParameterTask(p), CanExecuteTrue);
+			CommandFactory.Create<int, bool>(async p => await IntParameterTask(p));
+			CommandFactory.Create<int, bool>(async p => await IntParameterTask(p), CanExecuteTrue);
+
+			// Act
+
+			// Assert
+		}
 	}
 }
\ No newline at end of file
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.shared.cs
index f16918dea..93901f57f 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.shared.cs
@@ -17,6 +17,12 @@ public static Command Create<TExecute>(Action<TExecute> execute, Func<bool> canE
 		public static Command Create<TExecute, TCanExecute>(Action<TExecute> execute, Func<TCanExecute, bool> canExecute) =>
 			new Command(ConvertExecute(execute), ConvertCanExecute(canExecute));
 
+		public static IAsyncCommand Create(Func<Task> execute) =>
+			new AsyncCommand(execute);
+
+		public static IAsyncCommand Create(Func<Task> execute, Func<bool> canExecute) =>
+			new AsyncCommand(execute, canExecute);
+
 		public static IAsyncCommand Create(
 			Func<Task> execute,
 			Func<bool> canExecute = null,
@@ -25,6 +31,12 @@ public static IAsyncCommand Create(
 			bool allowsMultipleExecutions = true) =>
 			new AsyncCommand(execute, canExecute, onException, continueOnCapturedContext, allowsMultipleExecutions);
 
+		public static IAsyncCommand<TExecute> Create<TExecute>(Func<TExecute, Task> execute) =>
+			new AsyncCommand<TExecute>(execute);
+
+		public static IAsyncCommand<TExecute> Create<TExecute>(Func<TExecute, Task> execute, Func<bool> canExecute) =>
+			new AsyncCommand<TExecute>(execute, canExecute);
+
 		public static IAsyncCommand<TExecute> Create<TExecute>(
 			Func<TExecute, Task> execute,
 			Func<bool> canExecute = null,
@@ -33,6 +45,12 @@ public static IAsyncCommand<TExecute> Create<TExecute>(
 			bool allowsMultipleExecutions = true) =>
 			new AsyncCommand<TExecute>(execute, canExecute, onException, continueOnCapturedContext, allowsMultipleExecutions);
 
+		public static IAsyncCommand<TExecute, TCanExecute> Create<TExecute, TCanExecute>(Func<TExecute, Task> execute) =>
+			new AsyncCommand<TExecute, TCanExecute>(execute);
+
+		public static IAsyncCommand<TExecute, TCanExecute> Create<TExecute, TCanExecute>(Func<TExecute, Task> execute, Func<TCanExecute, bool> canExecute) =>
+			new AsyncCommand<TExecute, TCanExecute>(execute, canExecute);
+
 		public static IAsyncCommand<TExecute, TCanExecute> Create<TExecute, TCanExecute>(
 			Func<TExecute, Task> execute,
 			Func<TCanExecute, bool> canExecute = null,

From 8d2344135160d0e9005c244f677874985f73869b Mon Sep 17 00:00:00 2001
From: Maksym Koshovyi <maximkoshevoi61@gmail.com>
Date: Wed, 27 Jan 2021 10:48:41 +0200
Subject: [PATCH 19/21] Add different names to "execute" parameters to provide
 another way to resolve ambiguity

---
 .../CommandFactory_AsyncCommand_Tests.cs      |  3 ++
 .../CommandFactory_AsyncValueCommand_Tests.cs | 20 ++++++++
 .../ObjectModel/CommandFactory.shared.cs      | 48 +++++++++----------
 3 files changed, 47 insertions(+), 24 deletions(-)

diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_AsyncCommand_Tests.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_AsyncCommand_Tests.cs
index 2fc6fbee5..357fbd014 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_AsyncCommand_Tests.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_AsyncCommand_Tests.cs
@@ -116,10 +116,13 @@ public void LambdaExecuteTiebreakerTest()
 			// Arrange
 			CommandFactory.Create(async () => await NoParameterTask());
 			CommandFactory.Create(async () => await NoParameterTask(), CanExecuteTrue);
+			CommandFactory.Create(executeTask: async () => await NoParameterTask(), CanExecuteTrue, null);
 			CommandFactory.Create<int>(async p => await IntParameterTask(p));
 			CommandFactory.Create<int>(async p => await IntParameterTask(p), CanExecuteTrue);
+			CommandFactory.Create<int>(executeTask: async p => await IntParameterTask(p), CanExecuteTrue, null);
 			CommandFactory.Create<int, bool>(async p => await IntParameterTask(p));
 			CommandFactory.Create<int, bool>(async p => await IntParameterTask(p), CanExecuteTrue);
+			CommandFactory.Create<int, bool>(executeTask: async p => await IntParameterTask(p), CanExecuteTrue, null);
 
 			// Act
 
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_AsyncValueCommand_Tests.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_AsyncValueCommand_Tests.cs
index 32cfd1c1e..9c63054aa 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_AsyncValueCommand_Tests.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_AsyncValueCommand_Tests.cs
@@ -111,5 +111,25 @@ public void IntExecuteBoolCanExecuteParameter()
 			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(string.Empty));
 			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(0));
 		}
+
+		[Fact]
+		public void LambdaExecuteTiebreakerTest()
+		{
+			// Arrange
+			CommandFactory.Create((Func<ValueTask>)(async () => await NoParameterTask()));
+			CommandFactory.Create(executeValueTask: async () => await NoParameterTask());
+			CommandFactory.Create(executeValueTask: async () => await NoParameterTask(), CanExecuteTrue);
+			CommandFactory.Create(executeValueTask: async () => await NoParameterTask(), CanExecuteTrue, null);
+			CommandFactory.Create<int>(executeValueTask: async p => await IntParameterTask(p));
+			CommandFactory.Create<int>(executeValueTask: async p => await IntParameterTask(p), CanExecuteTrue);
+			CommandFactory.Create<int>(executeValueTask: async p => await IntParameterTask(p), CanExecuteTrue, null);
+			CommandFactory.Create<int, bool>(executeValueTask: async p => await IntParameterTask(p));
+			CommandFactory.Create<int, bool>(executeValueTask: async p => await IntParameterTask(p), CanExecuteTrue);
+			CommandFactory.Create<int, bool>(executeValueTask: async p => await IntParameterTask(p), CanExecuteTrue, null);
+
+			// Act
+
+			// Assert
+		}
 	}
 }
\ No newline at end of file
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.shared.cs
index 93901f57f..533eda593 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.shared.cs
@@ -17,71 +17,71 @@ public static Command Create<TExecute>(Action<TExecute> execute, Func<bool> canE
 		public static Command Create<TExecute, TCanExecute>(Action<TExecute> execute, Func<TCanExecute, bool> canExecute) =>
 			new Command(ConvertExecute(execute), ConvertCanExecute(canExecute));
 
-		public static IAsyncCommand Create(Func<Task> execute) =>
-			new AsyncCommand(execute);
+		public static IAsyncCommand Create(Func<Task> executeTask) =>
+			new AsyncCommand(executeTask);
 
-		public static IAsyncCommand Create(Func<Task> execute, Func<bool> canExecute) =>
-			new AsyncCommand(execute, canExecute);
+		public static IAsyncCommand Create(Func<Task> executeTask, Func<bool> canExecute) =>
+			new AsyncCommand(executeTask, canExecute);
 
 		public static IAsyncCommand Create(
-			Func<Task> execute,
+			Func<Task> executeTask,
 			Func<bool> canExecute = null,
 			Action<Exception> onException = null,
 			bool continueOnCapturedContext = false,
 			bool allowsMultipleExecutions = true) =>
-			new AsyncCommand(execute, canExecute, onException, continueOnCapturedContext, allowsMultipleExecutions);
+			new AsyncCommand(executeTask, canExecute, onException, continueOnCapturedContext, allowsMultipleExecutions);
 
-		public static IAsyncCommand<TExecute> Create<TExecute>(Func<TExecute, Task> execute) =>
-			new AsyncCommand<TExecute>(execute);
+		public static IAsyncCommand<TExecute> Create<TExecute>(Func<TExecute, Task> executeTask) =>
+			new AsyncCommand<TExecute>(executeTask);
 
-		public static IAsyncCommand<TExecute> Create<TExecute>(Func<TExecute, Task> execute, Func<bool> canExecute) =>
-			new AsyncCommand<TExecute>(execute, canExecute);
+		public static IAsyncCommand<TExecute> Create<TExecute>(Func<TExecute, Task> executeTask, Func<bool> canExecute) =>
+			new AsyncCommand<TExecute>(executeTask, canExecute);
 
 		public static IAsyncCommand<TExecute> Create<TExecute>(
-			Func<TExecute, Task> execute,
+			Func<TExecute, Task> executeTask,
 			Func<bool> canExecute = null,
 			Action<Exception> onException = null,
 			bool continueOnCapturedContext = false,
 			bool allowsMultipleExecutions = true) =>
-			new AsyncCommand<TExecute>(execute, canExecute, onException, continueOnCapturedContext, allowsMultipleExecutions);
+			new AsyncCommand<TExecute>(executeTask, canExecute, onException, continueOnCapturedContext, allowsMultipleExecutions);
 
-		public static IAsyncCommand<TExecute, TCanExecute> Create<TExecute, TCanExecute>(Func<TExecute, Task> execute) =>
-			new AsyncCommand<TExecute, TCanExecute>(execute);
+		public static IAsyncCommand<TExecute, TCanExecute> Create<TExecute, TCanExecute>(Func<TExecute, Task> executeTask) =>
+			new AsyncCommand<TExecute, TCanExecute>(executeTask);
 
-		public static IAsyncCommand<TExecute, TCanExecute> Create<TExecute, TCanExecute>(Func<TExecute, Task> execute, Func<TCanExecute, bool> canExecute) =>
-			new AsyncCommand<TExecute, TCanExecute>(execute, canExecute);
+		public static IAsyncCommand<TExecute, TCanExecute> Create<TExecute, TCanExecute>(Func<TExecute, Task> executeTask, Func<TCanExecute, bool> canExecute) =>
+			new AsyncCommand<TExecute, TCanExecute>(executeTask, canExecute);
 
 		public static IAsyncCommand<TExecute, TCanExecute> Create<TExecute, TCanExecute>(
-			Func<TExecute, Task> execute,
+			Func<TExecute, Task> executeTask,
 			Func<TCanExecute, bool> canExecute = null,
 			Action<Exception> onException = null,
 			bool continueOnCapturedContext = false,
 			bool allowsMultipleExecutions = true) =>
-			new AsyncCommand<TExecute, TCanExecute>(execute, canExecute, onException, continueOnCapturedContext, allowsMultipleExecutions);
+			new AsyncCommand<TExecute, TCanExecute>(executeTask, canExecute, onException, continueOnCapturedContext, allowsMultipleExecutions);
 
 		public static IAsyncValueCommand Create(
-			Func<ValueTask> execute,
+			Func<ValueTask> executeValueTask,
 			Func<bool> canExecute = null,
 			Action<Exception> onException = null,
 			bool continueOnCapturedContext = false,
 			bool allowsMultipleExecutions = true) =>
-			new AsyncValueCommand(execute, canExecute, onException, continueOnCapturedContext, allowsMultipleExecutions);
+			new AsyncValueCommand(executeValueTask, canExecute, onException, continueOnCapturedContext, allowsMultipleExecutions);
 
 		public static IAsyncValueCommand<TExecute> Create<TExecute>(
-			Func<TExecute, ValueTask> execute,
+			Func<TExecute, ValueTask> executeValueTask,
 			Func<bool> canExecute = null,
 			Action<Exception> onException = null,
 			bool continueOnCapturedContext = false,
 			bool allowsMultipleExecutions = true) =>
-			new AsyncValueCommand<TExecute>(execute, canExecute, onException, continueOnCapturedContext, allowsMultipleExecutions);
+			new AsyncValueCommand<TExecute>(executeValueTask, canExecute, onException, continueOnCapturedContext, allowsMultipleExecutions);
 
 		public static IAsyncValueCommand<TExecute, TCanExecute> Create<TExecute, TCanExecute>(
-			Func<TExecute, ValueTask> execute,
+			Func<TExecute, ValueTask> executeValueTask,
 			Func<TCanExecute, bool> canExecute = null,
 			Action<Exception> onException = null,
 			bool continueOnCapturedContext = false,
 			bool allowsMultipleExecutions = true) =>
-			new AsyncValueCommand<TExecute, TCanExecute>(execute, canExecute, onException, continueOnCapturedContext, allowsMultipleExecutions);
+			new AsyncValueCommand<TExecute, TCanExecute>(executeValueTask, canExecute, onException, continueOnCapturedContext, allowsMultipleExecutions);
 
 		static Action<object> ConvertExecute<T>(Action<T> execute)
 		{

From 3c9c8d604807cfa809af5ad9d4c4f8525b477a7d Mon Sep 17 00:00:00 2001
From: Brandon Minnick <13558917+brminnick@users.noreply.github.com>
Date: Thu, 28 Jan 2021 17:48:41 -0800
Subject: [PATCH 20/21] Updated CommandFactory

- Add XML Documentation
- Separated Command.Factory.Command.shared.cs, Command.Factory.IAsyncCommand.shared.cs and Command.Factory.IAsyncValueCommand.shared.cs
- Removed unnecessary CommandFactory.Create methods
- Added missing CommandFactory.Create methods
- Updated Unit Tests
---
 .../ICommandTests/BaseCommandTests.cs         |  14 ++
 .../CommandFactory_AsyncCommand_Tests.cs      | 202 +++++++++++++++---
 .../CommandFactory_AsyncValueCommand_Tests.cs | 202 ++++++++++++++----
 .../CommandFactory_Command_Tests.cs           | 122 +++++++----
 .../CommandFactory.Command.shared.cs          |  59 +++++
 .../CommandFactory.IAsyncCommand.shared.cs    | 161 ++++++++++++++
 ...ommandFactory.IAsyncValueCommand.shared.cs |  91 ++++++++
 .../ObjectModel/CommandFactory.shared.cs      | 136 ------------
 8 files changed, 744 insertions(+), 243 deletions(-)
 create mode 100644 src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.Command.shared.cs
 create mode 100644 src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.IAsyncCommand.shared.cs
 create mode 100644 src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.IAsyncValueCommand.shared.cs
 delete mode 100644 src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.shared.cs

diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/BaseCommandTests.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/BaseCommandTests.cs
index 7731a43ab..12ac5912d 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/BaseCommandTests.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/BaseCommandTests.cs
@@ -21,6 +21,18 @@ public abstract class BaseCommandTests
 
 		protected Task ParameterImmediateNullReferenceExceptionTask(int delay) => throw new NullReferenceException();
 
+		protected void NoParameterAction()
+		{
+		}
+
+		protected void ObjectParameterAction(object parameter)
+		{
+		}
+
+		protected void IntParameterAction(int parameter)
+		{
+		}
+
 		protected async Task NoParameterDelayedNullReferenceExceptionTask()
 		{
 			await Task.Delay(Delay);
@@ -37,6 +49,8 @@ protected async Task IntParameterDelayedNullReferenceExceptionTask(int delay)
 
 		protected bool CanExecuteFalse() => false;
 
+		protected bool CanExecuteTrue(int parameter) => true;
+
 		protected bool CanExecuteTrue(bool parameter) => true;
 
 		protected bool CanExecuteTrue(string parameter) => true;
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_AsyncCommand_Tests.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_AsyncCommand_Tests.cs
index 357fbd014..6b5618c3c 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_AsyncCommand_Tests.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_AsyncCommand_Tests.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Threading.Tasks;
+using System.Windows.Input;
 using Xamarin.CommunityToolkit.Exceptions;
 using Xamarin.CommunityToolkit.ObjectModel;
 using Xunit;
@@ -9,7 +10,7 @@ namespace Xamarin.CommunityToolkit.UnitTests.ObjectModel.ICommandTests.CommandFa
 	public class CommandFactoryAsyncCommandTests : BaseCommandTests
 	{
 		[Fact]
-		public void NullExecuteParameter()
+		public void AsyncCommand_NullExecuteParameter()
 		{
 			// Arrange
 			Func<Task> execute = null;
@@ -21,112 +22,243 @@ public void NullExecuteParameter()
 		}
 
 		[Fact]
-		public void NullCanExecuteParameter()
+		public async Task AsyncCommand_NullCanExecuteParameter()
 		{
 			// Arrange
-			var command = CommandFactory.Create(NoParameterTask, null);
+			var command = CommandFactory.Create(NoParameterTask);
 
 			// Act
+			await command.ExecuteAsync();
 
 			// Assert
 			Assert.True(command.CanExecute(null));
 			Assert.True(command.CanExecute(string.Empty));
 			Assert.True(command.CanExecute(0));
+
+			Assert.IsType<AsyncCommand>(command);
+			Assert.IsAssignableFrom<IAsyncCommand>(command);
 		}
 
 		[Fact]
-		public void IntExecuteNullCanExecuteParameter()
+		public async Task AsyncCommand_ObjectCanExecuteParameter()
 		{
 			// Arrange
-			var command = CommandFactory.Create<int>(IntParameterTask, null);
+			var command = CommandFactory.Create(NoParameterTask, parameter => true);
 
 			// Act
+			await command.ExecuteAsync();
 
 			// Assert
 			Assert.True(command.CanExecute(null));
 			Assert.True(command.CanExecute(string.Empty));
 			Assert.True(command.CanExecute(0));
 
-			command.Execute(0);
-			Assert.Throws<InvalidCommandParameterException>(() => command.Execute(null));
-			Assert.Throws<InvalidCommandParameterException>(() => command.Execute(string.Empty));
+			Assert.IsType<AsyncCommand>(command);
+			Assert.IsAssignableFrom<IAsyncCommand>(command);
 		}
 
 		[Fact]
-		public void IntExecuteTrueCanExecuteParameter()
+		public void AsyncCommand_FuncBool_NullExecuteParameter()
 		{
 			// Arrange
-			var command = CommandFactory.Create<int>(IntParameterTask, CanExecuteTrue);
+			Func<Task> execute = null;
 
 			// Act
 
+			// Assert
+			Assert.Throws<ArgumentNullException>(() => CommandFactory.Create(execute, () => true));
+		}
+
+		[Fact]
+		public async Task AsyncCommand_FuncBool_NullCanExecuteParameter()
+		{
+			// Arrange
+			Func<bool> canExecute = null;
+			var command = CommandFactory.Create(NoParameterTask, canExecute);
+
+			// Act
+			await command.ExecuteAsync();
+
 			// Assert
 			Assert.True(command.CanExecute(null));
 			Assert.True(command.CanExecute(string.Empty));
 			Assert.True(command.CanExecute(0));
+
+			Assert.IsType<AsyncCommand>(command);
+			Assert.IsAssignableFrom<ICommand>(command);
+			Assert.IsAssignableFrom<IAsyncCommand>(command);
 		}
 
 		[Fact]
-		public void IntExecuteFalseCanExecuteParameter()
+		public async Task AsyncCommand_FuncBool_ValidExecuteParameter_ValidCanExecuteParameter()
 		{
 			// Arrange
-			var command = CommandFactory.Create<int>(IntParameterTask, CanExecuteFalse);
+			var command = CommandFactory.Create(NoParameterTask, () => true);
 
 			// Act
+			await command.ExecuteAsync();
 
 			// Assert
-			Assert.False(command.CanExecute(null));
-			Assert.False(command.CanExecute(string.Empty));
-			Assert.False(command.CanExecute(0));
+			Assert.True(command.CanExecute(null));
+			Assert.True(command.CanExecute(string.Empty));
+			Assert.True(command.CanExecute(0));
+
+			Assert.IsType<AsyncCommand>(command);
+			Assert.IsAssignableFrom<ICommand>(command);
+			Assert.IsAssignableFrom<IAsyncCommand>(command);
 		}
 
 		[Fact]
-		public void IntExecuteNullTypedCanExecuteParameter()
+		public void AsyncCommandT_NullExecuteParameter()
 		{
 			// Arrange
-			var command = CommandFactory.Create<int, bool>(IntParameterTask, null);
+			Func<int, Task> execute = null;
 
 			// Act
 
 			// Assert
-			Assert.True(command.CanExecute(true));
-			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(null));
-			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(string.Empty));
-			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(0));
+			Assert.Throws<ArgumentNullException>(() => CommandFactory.Create(execute));
 		}
 
 		[Fact]
-		public void IntExecuteBoolCanExecuteParameter()
+		public async Task AsyncCommandT_NullCanExecuteParameter()
 		{
 			// Arrange
-			var command = CommandFactory.Create<int, bool>(IntParameterTask, CanExecuteTrue);
+			var command = CommandFactory.Create<int>(IntParameterTask);
+
+			// Act
+			await command.ExecuteAsync(0);
+
+			// Assert
+			Assert.True(command.CanExecute(null));
+			Assert.True(command.CanExecute(string.Empty));
+			Assert.True(command.CanExecute(0));
+
+			Assert.IsType<AsyncCommand<int>>(command);
+			Assert.IsAssignableFrom<ICommand>(command);
+			Assert.IsAssignableFrom<IAsyncCommand<int>>(command);
+		}
+
+		[Fact]
+		public async Task AsyncCommandT_ObjectCanExecuteParameter()
+		{
+			// Arrange
+			var command = CommandFactory.Create<int>(IntParameterTask, parameter => true);
+
+			// Act
+			await command.ExecuteAsync(0);
+
+			// Assert
+			Assert.True(command.CanExecute(null));
+			Assert.True(command.CanExecute(string.Empty));
+			Assert.True(command.CanExecute(0));
+
+			Assert.IsType<AsyncCommand<int>>(command);
+			Assert.IsAssignableFrom<ICommand>(command);
+			Assert.IsAssignableFrom<IAsyncCommand<int>>(command);
+		}
+
+		[Fact]
+		public void AsyncCommandT_FuncBool_NullExecuteParameter()
+		{
+			// Arrange
+			Func<int, Task> execute = null;
+
+			// Act
+
+			// Assert
+			Assert.Throws<ArgumentNullException>(() => CommandFactory.Create<int>(execute, () => true));
+		}
+
+		[Fact]
+		public async Task AsyncCommandT_FuncBool_NullCanExecuteParameter()
+		{
+			// Arrange
+			Func<bool> canExecute = null;
+			var command = CommandFactory.Create<int>(IntParameterTask, canExecute);
+
+			// Act
+			await command.ExecuteAsync(0);
+
+			// Assert
+			Assert.True(command.CanExecute(null));
+			Assert.True(command.CanExecute(string.Empty));
+			Assert.True(command.CanExecute(0));
+
+			Assert.IsType<AsyncCommand<int>>(command);
+			Assert.IsAssignableFrom<ICommand>(command);
+			Assert.IsAssignableFrom<IAsyncCommand<int>>(command);
+		}
+
+		[Fact]
+		public async Task AsyncCommandT_FuncBool_ValidExecuteParameter_ValidCanExecuteParameter()
+		{
+			// Arrange
+			var command = CommandFactory.Create<int>(IntParameterTask, () => true);
+
+			// Act
+			await command.ExecuteAsync(0);
+
+			// Assert
+			Assert.True(command.CanExecute(null));
+			Assert.True(command.CanExecute(string.Empty));
+			Assert.True(command.CanExecute(0));
+
+			Assert.IsType<AsyncCommand<int>>(command);
+			Assert.IsAssignableFrom<ICommand>(command);
+			Assert.IsAssignableFrom<IAsyncCommand<int>>(command);
+		}
+
+		[Fact]
+		public void AsyncCommandTExecuteTCanExecute_NullExecuteParameter()
+		{
+			// Arrange
+			Func<int, Task> execute = null;
+
+			// Act
+
+			// Assert
+			Assert.Throws<ArgumentNullException>(() => CommandFactory.Create(execute));
+		}
+
+		[Fact]
+		public async Task AsyncCommandTExecuteTCanExecute_NullCanExecuteParameter()
+		{
+			// Arrange
+			var command = CommandFactory.Create<int, bool>(IntParameterTask, null);
 
 			// Act
+			await command.ExecuteAsync(0);
 
 			// Assert
 			Assert.True(command.CanExecute(true));
-			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(null));
-			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(string.Empty));
+
 			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(0));
+			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(string.Empty));
+
+			Assert.IsType<AsyncCommand<int, bool>>(command);
+			Assert.IsAssignableFrom<ICommand>(command);
+			Assert.IsAssignableFrom<IAsyncCommand<int, bool>>(command);
 		}
 
 		[Fact]
-		public void LambdaExecuteTiebreakerTest()
+		public async Task AsyncCommandTExecuteTCanExecute_ObjectCanExecuteParameter()
 		{
 			// Arrange
-			CommandFactory.Create(async () => await NoParameterTask());
-			CommandFactory.Create(async () => await NoParameterTask(), CanExecuteTrue);
-			CommandFactory.Create(executeTask: async () => await NoParameterTask(), CanExecuteTrue, null);
-			CommandFactory.Create<int>(async p => await IntParameterTask(p));
-			CommandFactory.Create<int>(async p => await IntParameterTask(p), CanExecuteTrue);
-			CommandFactory.Create<int>(executeTask: async p => await IntParameterTask(p), CanExecuteTrue, null);
-			CommandFactory.Create<int, bool>(async p => await IntParameterTask(p));
-			CommandFactory.Create<int, bool>(async p => await IntParameterTask(p), CanExecuteTrue);
-			CommandFactory.Create<int, bool>(executeTask: async p => await IntParameterTask(p), CanExecuteTrue, null);
+			var command = CommandFactory.Create<int, bool>(IntParameterTask, CanExecuteTrue);
 
 			// Act
+			await command.ExecuteAsync(0);
 
 			// Assert
+			Assert.True(command.CanExecute(true));
+
+			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(0));
+			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(string.Empty));
+
+			Assert.IsType<AsyncCommand<int, bool>>(command);
+			Assert.IsAssignableFrom<ICommand>(command);
+			Assert.IsAssignableFrom<IAsyncCommand<int, bool>>(command);
 		}
 	}
 }
\ No newline at end of file
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_AsyncValueCommand_Tests.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_AsyncValueCommand_Tests.cs
index 9c63054aa..2655be1e4 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_AsyncValueCommand_Tests.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_AsyncValueCommand_Tests.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Threading.Tasks;
+using System.Windows.Input;
 using Xamarin.CommunityToolkit.Exceptions;
 using Xamarin.CommunityToolkit.ObjectModel;
 using Xamarin.CommunityToolkit.UnitTests.ObjectModel.ICommandTests.AsyncValueCommandTests;
@@ -9,127 +10,256 @@ namespace Xamarin.CommunityToolkit.UnitTests.ObjectModel.ICommandTests.CommandFa
 {
 	public class CommandFactoryAsyncValueCommandTests : BaseAsyncValueCommandTests
 	{
+		[Fact]
+		public void AsyncValueCommand_NullExecuteParameter()
+		{
+			// Arrange
+			Func<Task> execute = null;
+
+			// Act
+
+			// Assert
+			Assert.Throws<ArgumentNullException>(() => CommandFactory.Create(execute));
+		}
+
+		[Fact]
+		public async Task AsyncValueCommand_NullCanExecuteParameter()
+		{
+			// Arrange
+			var command = CommandFactory.Create(NoParameterTask);
+
+			// Act
+			await command.ExecuteAsync();
+
+			// Assert
+			Assert.True(command.CanExecute(null));
+			Assert.True(command.CanExecute(string.Empty));
+			Assert.True(command.CanExecute(0));
+
+			Assert.IsType<AsyncValueCommand>(command);
+			Assert.IsAssignableFrom<IAsyncValueCommand>(command);
+		}
 
 		[Fact]
-		public void NullExecuteParameter()
+		public async Task AsyncValueCommand_ObjectCanExecuteParameter()
+		{
+			// Arrange
+			var command = CommandFactory.Create(NoParameterTask, parameter => true);
+
+			// Act
+			await command.ExecuteAsync();
+
+			// Assert
+			Assert.True(command.CanExecute(null));
+			Assert.True(command.CanExecute(string.Empty));
+			Assert.True(command.CanExecute(0));
+
+			Assert.IsType<AsyncValueCommand>(command);
+			Assert.IsAssignableFrom<IAsyncValueCommand>(command);
+		}
+
+		[Fact]
+		public void AsyncValueCommand_FuncBool_NullExecuteParameter()
 		{
 			// Arrange
 			Func<ValueTask> execute = null;
 
 			// Act
 
+			// Assert
+			Assert.Throws<ArgumentNullException>(() => CommandFactory.Create(execute, () => true));
+		}
+
+		[Fact]
+		public async Task AsyncValueCommand_FuncBool_NullCanExecuteParameter()
+		{
+			// Arrange
+			Func<bool> canExecute = null;
+			var command = CommandFactory.Create(NoParameterTask, canExecute);
+
+			// Act
+			await command.ExecuteAsync();
+
+			// Assert
+			Assert.True(command.CanExecute(null));
+			Assert.True(command.CanExecute(string.Empty));
+			Assert.True(command.CanExecute(0));
+
+			Assert.IsType<AsyncValueCommand>(command);
+			Assert.IsAssignableFrom<ICommand>(command);
+			Assert.IsAssignableFrom<IAsyncValueCommand>(command);
+		}
+
+		[Fact]
+		public async Task AsyncValueCommand_FuncBool_ValidExecuteParameter_ValidCanExecuteParameter()
+		{
+			// Arrange
+			var command = CommandFactory.Create(NoParameterTask, () => true);
+
+			// Act
+			await command.ExecuteAsync();
+
+			// Assert
+			Assert.True(command.CanExecute(null));
+			Assert.True(command.CanExecute(string.Empty));
+			Assert.True(command.CanExecute(0));
+
+			Assert.IsType<AsyncValueCommand>(command);
+			Assert.IsAssignableFrom<ICommand>(command);
+			Assert.IsAssignableFrom<IAsyncValueCommand>(command);
+		}
+
+		[Fact]
+		public void AsyncValueCommandT_NullExecuteParameter()
+		{
+			// Arrange
+			Func<int, ValueTask> execute = null;
+
+			// Act
+
 			// Assert
 			Assert.Throws<ArgumentNullException>(() => CommandFactory.Create(execute));
 		}
 
 		[Fact]
-		public void NullCanExecuteParameter()
+		public async Task AsyncValueCommandT_NullCanExecuteParameter()
 		{
 			// Arrange
-			var command = CommandFactory.Create(NoParameterTask, null);
+			var command = CommandFactory.Create<int>(IntParameterTask);
 
 			// Act
+			await command.ExecuteAsync(0);
 
 			// Assert
 			Assert.True(command.CanExecute(null));
 			Assert.True(command.CanExecute(string.Empty));
 			Assert.True(command.CanExecute(0));
+
+			Assert.IsType<AsyncValueCommand<int>>(command);
+			Assert.IsAssignableFrom<ICommand>(command);
+			Assert.IsAssignableFrom<IAsyncValueCommand<int>>(command);
 		}
 
 		[Fact]
-		public void IntExecuteNullCanExecuteParameter()
+		public async Task AsyncValueCommandT_ObjectCanExecuteParameter()
 		{
 			// Arrange
-			var command = CommandFactory.Create<int>(IntParameterTask, null);
+			var command = CommandFactory.Create<int>(IntParameterTask, parameter => true);
 
 			// Act
+			await command.ExecuteAsync(0);
 
 			// Assert
 			Assert.True(command.CanExecute(null));
 			Assert.True(command.CanExecute(string.Empty));
 			Assert.True(command.CanExecute(0));
 
-			command.Execute(0);
-			Assert.Throws<InvalidCommandParameterException>(() => command.Execute(null));
-			Assert.Throws<InvalidCommandParameterException>(() => command.Execute(string.Empty));
+			Assert.IsType<AsyncValueCommand<int>>(command);
+			Assert.IsAssignableFrom<ICommand>(command);
+			Assert.IsAssignableFrom<IAsyncValueCommand<int>>(command);
 		}
 
 		[Fact]
-		public void IntExecuteTrueCanExecuteParameter()
+		public void AsyncValueCommandT_FuncBool_NullExecuteParameter()
 		{
 			// Arrange
-			var command = CommandFactory.Create<int>(IntParameterTask, CanExecuteTrue);
+			Func<int, ValueTask> execute = null;
 
 			// Act
 
+			// Assert
+			Assert.Throws<ArgumentNullException>(() => CommandFactory.Create<int>(execute, () => true));
+		}
+
+		[Fact]
+		public async Task AsyncValueCommandT_FuncBool_NullCanExecuteParameter()
+		{
+			// Arrange
+			Func<bool> canExecute = null;
+			var command = CommandFactory.Create<int>(IntParameterTask, canExecute);
+
+			// Act
+			await command.ExecuteAsync(0);
+
 			// Assert
 			Assert.True(command.CanExecute(null));
 			Assert.True(command.CanExecute(string.Empty));
 			Assert.True(command.CanExecute(0));
+
+			Assert.IsType<AsyncValueCommand<int>>(command);
+			Assert.IsAssignableFrom<ICommand>(command);
+			Assert.IsAssignableFrom<IAsyncValueCommand<int>>(command);
 		}
 
 		[Fact]
-		public void IntExecuteFalseCanExecuteParameter()
+		public async Task AsyncValueCommandT_FuncBool_ValidExecuteParameter_ValidCanExecuteParameter()
 		{
 			// Arrange
-			var command = CommandFactory.Create<int>(IntParameterTask, CanExecuteFalse);
+			var command = CommandFactory.Create<int>(IntParameterTask, () => true);
 
 			// Act
+			await command.ExecuteAsync(0);
 
 			// Assert
-			Assert.False(command.CanExecute(null));
-			Assert.False(command.CanExecute(string.Empty));
-			Assert.False(command.CanExecute(0));
+			Assert.True(command.CanExecute(null));
+			Assert.True(command.CanExecute(string.Empty));
+			Assert.True(command.CanExecute(0));
+
+			Assert.IsType<AsyncValueCommand<int>>(command);
+			Assert.IsAssignableFrom<ICommand>(command);
+			Assert.IsAssignableFrom<IAsyncValueCommand<int>>(command);
 		}
 
 		[Fact]
-		public void IntExecuteNullTypedCanExecuteParameter()
+		public void AsyncValueCommandTExecuteTCanExecute_NullExecuteParameter()
 		{
 			// Arrange
-			var command = CommandFactory.Create<int, bool>(IntParameterTask, null);
+			Func<int, ValueTask> execute = null;
 
 			// Act
 
 			// Assert
-			Assert.True(command.CanExecute(true));
-			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(null));
-			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(string.Empty));
-			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(0));
+			Assert.Throws<ArgumentNullException>(() => CommandFactory.Create(execute));
 		}
 
 		[Fact]
-		public void IntExecuteBoolCanExecuteParameter()
+		public async Task AsyncValueCommandTExecuteTCanExecute_NullCanExecuteParameter()
 		{
 			// Arrange
-			var command = CommandFactory.Create<int, bool>(IntParameterTask, CanExecuteTrue);
+			var command = CommandFactory.Create<int, bool>(IntParameterTask, null);
 
 			// Act
+			await command.ExecuteAsync(0);
 
 			// Assert
 			Assert.True(command.CanExecute(true));
-			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(null));
-			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(string.Empty));
+
 			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(0));
+			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(string.Empty));
+
+			Assert.IsType<AsyncValueCommand<int, bool>>(command);
+			Assert.IsAssignableFrom<ICommand>(command);
+			Assert.IsAssignableFrom<IAsyncValueCommand<int, bool>>(command);
 		}
 
 		[Fact]
-		public void LambdaExecuteTiebreakerTest()
+		public async Task AsyncValueCommandTExecuteTCanExecute_ObjectCanExecuteParameter()
 		{
 			// Arrange
-			CommandFactory.Create((Func<ValueTask>)(async () => await NoParameterTask()));
-			CommandFactory.Create(executeValueTask: async () => await NoParameterTask());
-			CommandFactory.Create(executeValueTask: async () => await NoParameterTask(), CanExecuteTrue);
-			CommandFactory.Create(executeValueTask: async () => await NoParameterTask(), CanExecuteTrue, null);
-			CommandFactory.Create<int>(executeValueTask: async p => await IntParameterTask(p));
-			CommandFactory.Create<int>(executeValueTask: async p => await IntParameterTask(p), CanExecuteTrue);
-			CommandFactory.Create<int>(executeValueTask: async p => await IntParameterTask(p), CanExecuteTrue, null);
-			CommandFactory.Create<int, bool>(executeValueTask: async p => await IntParameterTask(p));
-			CommandFactory.Create<int, bool>(executeValueTask: async p => await IntParameterTask(p), CanExecuteTrue);
-			CommandFactory.Create<int, bool>(executeValueTask: async p => await IntParameterTask(p), CanExecuteTrue, null);
+			var command = CommandFactory.Create<int, bool>(IntParameterTask, CanExecuteTrue);
 
 			// Act
+			await command.ExecuteAsync(0);
 
 			// Assert
+			Assert.True(command.CanExecute(true));
+
+			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(0));
+			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(string.Empty));
+
+			Assert.IsType<AsyncValueCommand<int, bool>>(command);
+			Assert.IsAssignableFrom<ICommand>(command);
+			Assert.IsAssignableFrom<IAsyncValueCommand<int, bool>>(command);
 		}
 	}
 }
\ No newline at end of file
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_Command_Tests.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_Command_Tests.cs
index 69f78bcc5..b6e4f48d4 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_Command_Tests.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_Command_Tests.cs
@@ -1,5 +1,5 @@
 using System;
-using System.Threading.Tasks;
+using System.Windows.Input;
 using Xamarin.CommunityToolkit.Exceptions;
 using Xamarin.CommunityToolkit.ObjectModel;
 using Xunit;
@@ -8,16 +8,8 @@ namespace Xamarin.CommunityToolkit.UnitTests.ObjectModel.ICommandTests.CommandFa
 {
 	public class CommandFactoryCommandTests : BaseCommandTests
 	{
-		protected void NoParameterAction()
-        {
-        }
-
-		protected void IntParameterAction(int i)
-        {
-        }
-
 		[Fact]
-		public void NullExecuteParameter()
+		public void Action_NullExecuteParameter()
 		{
 			// Arrange
 			Action execute = null;
@@ -29,93 +21,151 @@ public void NullExecuteParameter()
 		}
 
 		[Fact]
-		public void NullCanExecuteParameter()
+		public void Action_ValidExecuteParameter()
 		{
 			// Arrange
-			var command = CommandFactory.Create(NoParameterAction, null);
+			var command = CommandFactory.Create(NoParameterAction);
 
 			// Act
+			command.Execute(null);
 
 			// Assert
 			Assert.True(command.CanExecute(null));
 			Assert.True(command.CanExecute(string.Empty));
 			Assert.True(command.CanExecute(0));
+
+			Assert.IsType<Forms.Command>(command);
+			Assert.IsAssignableFrom<ICommand>(command);
+		}
+
+		[Fact]
+		public void Action_NullCanExecuteParameter()
+		{
+			// Arrange
+
+			// Act
+
+			// Assert
+			Assert.Throws<ArgumentNullException>(() => CommandFactory.Create(NoParameterAction, null));
 		}
 
 		[Fact]
-		public void IntExecuteNullCanExecuteParameter()
+		public void Action_ValidCanExecuteParameter()
 		{
 			// Arrange
-			var command = CommandFactory.Create<int>(IntParameterAction, null);
+			var command = CommandFactory.Create(NoParameterAction, CanExecuteTrue);
 
 			// Act
+			command.Execute(null);
 
 			// Assert
 			Assert.True(command.CanExecute(null));
 			Assert.True(command.CanExecute(string.Empty));
 			Assert.True(command.CanExecute(0));
 
-			command.Execute(0);
-			Assert.Throws<InvalidCommandParameterException>(() => command.Execute(null));
-			Assert.Throws<InvalidCommandParameterException>(() => command.Execute(string.Empty));
+			Assert.IsType<Forms.Command>(command);
+			Assert.IsAssignableFrom<ICommand>(command);
 		}
 
 		[Fact]
-		public void IntExecuteTrueCanExecuteParameter()
+		public void ActionObject_NullExecuteParameter()
 		{
 			// Arrange
-			var command = CommandFactory.Create<int>(IntParameterAction, CanExecuteTrue);
+			Action<object> execute = null;
 
 			// Act
 
+			// Assert
+			Assert.Throws<ArgumentNullException>(() => CommandFactory.Create(execute));
+		}
+
+		[Fact]
+		public void ActionObject_ValidExecuteParameter()
+		{
+			// Arrange
+			var command = CommandFactory.Create(ObjectParameterAction);
+
+			// Act
+			command.Execute(null);
+
 			// Assert
 			Assert.True(command.CanExecute(null));
 			Assert.True(command.CanExecute(string.Empty));
 			Assert.True(command.CanExecute(0));
+
+			Assert.IsType<Forms.Command>(command);
+			Assert.IsAssignableFrom<ICommand>(command);
 		}
 
 		[Fact]
-		public void IntExecuteFalseCanExecuteParameter()
+		public void ActionObject_NullCanExecuteParameter()
 		{
 			// Arrange
-			var command = CommandFactory.Create<int>(IntParameterAction, CanExecuteFalse);
 
 			// Act
 
 			// Assert
-			Assert.False(command.CanExecute(null));
-			Assert.False(command.CanExecute(string.Empty));
-			Assert.False(command.CanExecute(0));
+			Assert.Throws<ArgumentNullException>(() => CommandFactory.Create(ObjectParameterAction, null));
 		}
 
 		[Fact]
-		public void IntExecuteNullTypedCanExecuteParameter()
+		public void ActionObject_ValidCanExecuteParameter()
 		{
 			// Arrange
-			var command = CommandFactory.Create<int, bool>(IntParameterAction, null);
+			var command = CommandFactory.Create(ObjectParameterAction, _ => true);
 
 			// Act
+			command.Execute(1);
+			command.Execute(null);
+			command.Execute(string.Empty);
 
 			// Assert
-			Assert.True(command.CanExecute(true));
-			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(null));
-			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(string.Empty));
-			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(0));
+			Assert.True(command.CanExecute(null));
+			Assert.True(command.CanExecute(string.Empty));
+			Assert.True(command.CanExecute(0));
+
+			Assert.IsType<Forms.Command>(command);
+			Assert.IsAssignableFrom<ICommand>(command);
+		}
+
+		[Fact]
+		public void ActionInt_NullExecuteParameter()
+		{
+			// Arrange
+			Action<int> execute = null;
+
+			// Act
+
+			// Assert
+			Assert.Throws<ArgumentNullException>(() => CommandFactory.Create<int>(execute, CanExecuteTrue));
+		}
+
+		[Fact]
+		public void ActionInt_NullCanExecuteParameter()
+		{
+			// Arrange
+
+			// Act
+
+			// Assert
+			Assert.Throws<ArgumentNullException>(() => CommandFactory.Create<int>(IntParameterAction, null));
 		}
 
 		[Fact]
-		public void IntExecuteBoolCanExecuteParameter()
+		public void ActionInt_ValidCanExecuteParameter()
 		{
 			// Arrange
-			var command = CommandFactory.Create<int, bool>(IntParameterAction, CanExecuteTrue);
+			var command = CommandFactory.Create<int>(IntParameterAction, CanExecuteTrue);
 
 			// Act
 
 			// Assert
-			Assert.True(command.CanExecute(true));
-			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(null));
-			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(string.Empty));
-			Assert.Throws<InvalidCommandParameterException>(() => command.CanExecute(0));
+			Assert.True(command.CanExecute(0));
+			Assert.False(command.CanExecute(null));
+			Assert.False(command.CanExecute(string.Empty));
+
+			Assert.IsType<Forms.Command<int>>(command);
+			Assert.IsAssignableFrom<ICommand>(command);
 		}
 	}
 }
\ No newline at end of file
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.Command.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.Command.shared.cs
new file mode 100644
index 000000000..36f70ac0c
--- /dev/null
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.Command.shared.cs
@@ -0,0 +1,59 @@
+using System;
+using Xamarin.Forms;
+
+namespace Xamarin.CommunityToolkit.ObjectModel
+{
+	/// <summary>
+	/// Factory for IAsyncCommand
+	/// </summary>
+	public partial class CommandFactory
+	{
+		/// <summary>
+		/// Initializes Xamarin.Forms.Command
+		/// </summary>
+		/// <param name="execute">The Function executed when Execute is called. This does not check canExecute before executing and will execute even if canExecute is false</param>
+		/// <returns>Xamarin.Forms.Command</returns>
+		public static Command Create(Action execute) =>
+			new Command(execute);
+
+		/// <summary>
+		/// Initializes Xamarin.Forms.Command
+		/// </summary>
+		/// <param name="execute">The Function executed when Execute is called. This does not check canExecute before executing and will execute even if canExecute is false</param>
+		/// <returns>Xamarin.Forms.Command</returns>
+		public static Command Create(Action execute, Func<bool> canExecute) =>
+			new Command(execute, canExecute);
+
+		/// <summary>
+		/// Initializes Xamarin.Forms.Command
+		/// </summary>
+		/// <param name="execute">The Function executed when Execute is called. This does not check canExecute before executing and will execute even if canExecute is false</param>
+		/// <returns>Xamarin.Forms.Command</returns>
+		public static Command Create(Action<object> execute) =>
+			new Command(execute);
+
+		/// <summary>
+		/// Initializes Xamarin.Forms.Command
+		/// </summary>
+		/// <param name="execute">The Function executed when Execute is called. This does not check canExecute before executing and will execute even if canExecute is false</param>
+		/// <returns>Xamarin.Forms.Command</returns>
+		public static Command Create(Action<object> execute, Func<object, bool> canExecute) =>
+			new Command(execute, canExecute);
+
+		/// <summary>
+		/// Initializes Xamarin.Forms.Command<typeparamref name="T"/>
+		/// </summary>
+		/// <param name="execute">The Function executed when Execute is called. This does not check canExecute before executing and will execute even if canExecute is false</param>
+		/// <returns>Xamarin.Forms.Command<typeparamref name="T"/></returns>
+		public static Command<T> Create<T>(Action<T> execute) =>
+			new Command<T>(execute);
+
+		/// <summary>
+		/// Initializes Xamarin.Forms.Command<typeparamref name="T"/>
+		/// </summary>
+		/// <param name="execute">The Function executed when Execute is called. This does not check canExecute before executing and will execute even if canExecute is false</param>
+		/// <returns>Xamarin.Forms.Command<typeparamref name="T"/></returns>
+		public static Command<T> Create<T>(Action<T> execute, Func<T, bool> canExecute) =>
+			new Command<T>(execute, canExecute);
+	}
+}
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.IAsyncCommand.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.IAsyncCommand.shared.cs
new file mode 100644
index 000000000..40276897c
--- /dev/null
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.IAsyncCommand.shared.cs
@@ -0,0 +1,161 @@
+using System;
+using System.Threading.Tasks;
+
+namespace Xamarin.CommunityToolkit.ObjectModel
+{
+	/// <summary>
+	/// Factory for IAsyncCommand
+	/// </summary>
+	public partial class CommandFactory
+	{
+		/// <summary>
+		/// Initializes a new instance of IAsyncCommand
+		/// </summary>
+		/// <param name="execute">The Function executed when Execute or ExecuteAsync is called. This does not check canExecute before executing and will execute even if canExecute is false</param>
+		/// <param name="canExecute">The Function that verifies whether or not AsyncCommand should execute.</param>
+		/// <param name="onException">If an exception is thrown in the Task, <c>onException</c> will execute. If onException is null, the exception will be re-thrown</param>
+		/// <param name="continueOnCapturedContext">If set to <c>true</c> continue on captured context; this will ensure that the Synchronization Context returns to the calling thread. If set to <c>false</c> continue on a different context; this will allow the Synchronization Context to continue on a different thread</param>
+		/// <returns>IAsyncCommand</returns>
+		public static IAsyncCommand Create(
+			Func<Task> execute,
+			Func<object, bool> canExecute = null,
+			Action<Exception> onException = null,
+			bool continueOnCapturedContext = false,
+			bool allowsMultipleExecutions = true) =>
+			new AsyncCommand(execute, canExecute, onException, continueOnCapturedContext, allowsMultipleExecutions);
+
+		/// <summary>
+		/// Initializes a new instance of IAsyncCommand
+		/// </summary>
+		/// <param name="execute">The Function executed when Execute or ExecuteAsync is called. This does not check canExecute before executing and will execute even if canExecute is false</param>
+		/// <param name="canExecute">The Function that verifies whether or not AsyncCommand should execute.</param>
+		/// <param name="onException">If an exception is thrown in the Task, <c>onException</c> will execute. If onException is null, the exception will be re-thrown</param>
+		/// <param name="continueOnCapturedContext">If set to <c>true</c> continue on captured context; this will ensure that the Synchronization Context returns to the calling thread. If set to <c>false</c> continue on a different context; this will allow the Synchronization Context to continue on a different thread</param>
+		/// <returns>IAsyncCommand</returns>
+		public static IAsyncCommand Create(
+			Func<Task> execute,
+			Func<bool> canExecute,
+			Action<Exception> onException = null,
+			bool continueOnCapturedContext = false,
+			bool allowsMultipleExecutions = true) =>
+			new AsyncCommand(execute, canExecute, onException, continueOnCapturedContext, allowsMultipleExecutions);
+
+		/// <summary>
+		/// Initializes a new instance of IAsyncCommand
+		/// </summary>
+		/// <param name="execute">The Function executed when Execute or ExecuteAsync is called. This does not check canExecute before executing and will execute even if canExecute is false</param>
+		/// <param name="canExecute">The Function that verifies whether or not AsyncCommand should execute.</param>
+		/// <param name="onException">If an exception is thrown in the Task, <c>onException</c> will execute. If onException is null, the exception will be re-thrown</param>
+		/// <param name="continueOnCapturedContext">If set to <c>true</c> continue on captured context; this will ensure that the Synchronization Context returns to the calling thread. If set to <c>false</c> continue on a different context; this will allow the Synchronization Context to continue on a different thread</param>
+		/// <returns>IAsyncCommand<typeparamref name="TExecute"/></returns>
+		public static IAsyncCommand<TExecute> Create<TExecute>(
+			Func<TExecute, Task> execute,
+			Func<object, bool> canExecute = null,
+			Action<Exception> onException = null,
+			bool continueOnCapturedContext = false,
+			bool allowsMultipleExecutions = true) =>
+			new AsyncCommand<TExecute>(execute, canExecute, onException, continueOnCapturedContext, allowsMultipleExecutions);
+
+		/// <summary>
+		/// Initializes a new instance of IAsyncCommand
+		/// </summary>
+		/// <param name="execute">The Function executed when Execute or ExecuteAsync is called. This does not check canExecute before executing and will execute even if canExecute is false</param>
+		/// <param name="canExecute">The Function that verifies whether or not AsyncCommand should execute.</param>
+		/// <param name="onException">If an exception is thrown in the Task, <c>onException</c> will execute. If onException is null, the exception will be re-thrown</param>
+		/// <param name="continueOnCapturedContext">If set to <c>true</c> continue on captured context; this will ensure that the Synchronization Context returns to the calling thread. If set to <c>false</c> continue on a different context; this will allow the Synchronization Context to continue on a different thread</param>
+		/// <returns>IAsyncCommand<typeparamref name="TExecute"/></returns>
+		public static IAsyncCommand<TExecute> Create<TExecute>(
+			Func<TExecute, Task> execute,
+			Func<bool> canExecute,
+			Action<Exception> onException = null,
+			bool continueOnCapturedContext = false,
+			bool allowsMultipleExecutions = true) =>
+			new AsyncCommand<TExecute>(execute, canExecute, onException, continueOnCapturedContext, allowsMultipleExecutions);
+
+		/// <summary>
+		/// Initializes a new instance of IAsyncCommand
+		/// </summary>
+		/// <param name="execute">The Function executed when Execute or ExecuteAsync is called. This does not check canExecute before executing and will execute even if canExecute is false</param>
+		/// <param name="canExecute">The Function that verifies whether or not AsyncCommand should execute.</param>
+		/// <param name="onException">If an exception is thrown in the Task, <c>onException</c> will execute. If onException is null, the exception will be re-thrown</param>
+		/// <param name="continueOnCapturedContext">If set to <c>true</c> continue on captured context; this will ensure that the Synchronization Context returns to the calling thread. If set to <c>false</c> continue on a different context; this will allow the Synchronization Context to continue on a different thread</param>
+		/// <returns>IAsyncCommand</returns>
+		public static IAsyncCommand<TExecute, TCanExecute> Create<TExecute, TCanExecute>(
+			Func<TExecute, Task> execute,
+			Func<TCanExecute, bool> canExecute = null,
+			Action<Exception> onException = null,
+			bool continueOnCapturedContext = false,
+			bool allowsMultipleExecutions = true) =>
+			new AsyncCommand<TExecute, TCanExecute>(execute, canExecute, onException, continueOnCapturedContext, allowsMultipleExecutions);
+
+		#region Helper Methods to Prevent Ambiguous Method Error When Using Anonymous Async Methods
+
+		/// <summary>
+		/// Initializes a new instance of IAsyncCommand
+		/// </summary>
+		/// <param name="execute">The Function executed when Execute or ExecuteAsync is called. This does not check canExecute before executing and will execute even if canExecute is false</param>
+		/// <returns>IAsyncCommand</returns>
+		public static IAsyncCommand Create(Func<Task> execute)
+		{
+			Func<object, bool> canExecute = null;
+			return Create(execute, canExecute, null, false, true);
+		}
+
+		/// <summary>
+		/// Initializes a new instance of IAsyncCommand
+		/// </summary>
+		/// <param name="execute">The Function executed when Execute or ExecuteAsync is called. This does not check canExecute before executing and will execute even if canExecute is false</param>
+		/// <param name="canExecute">The Function that verifies whether or not AsyncCommand should execute.</param>
+		/// <returns>IAsyncCommand</returns>
+		public static IAsyncCommand Create(Func<Task> execute, Func<object, bool> canExecute) =>
+			Create(execute, canExecute, null, false, true);
+
+		/// <summary>
+		/// Initializes a new instance of IAsyncCommand
+		/// </summary>
+		/// <param name="execute">The Function executed when Execute or ExecuteAsync is called. This does not check canExecute before executing and will execute even if canExecute is false</param>
+		/// <param name="canExecute">The Function that verifies whether or not AsyncCommand should execute.</param>
+		/// <returns>IAsyncCommand</returns>
+		public static IAsyncCommand Create(Func<Task> execute, Func<bool> canExecute) =>
+			Create(execute, canExecute, null, false, true);
+
+		/// <summary>
+		/// Initializes a new instance of IAsyncCommand
+		/// </summary>
+		/// <param name="execute">The Function executed when Execute or ExecuteAsync is called. This does not check canExecute before executing and will execute even if canExecute is false</param>
+		/// <returns>IAsyncCommand</returns>
+		public static IAsyncCommand<TExecute> Create<TExecute>(Func<TExecute, Task> execute)
+		{
+			Func<object, bool> canExecute = null;
+			return Create(execute, canExecute, null, false, true);
+		}
+
+		/// <summary>
+		/// Initializes a new instance of IAsyncCommand
+		/// </summary>
+		/// <param name="execute">The Function executed when Execute or ExecuteAsync is called. This does not check canExecute before executing and will execute even if canExecute is false</param>
+		/// <param name="canExecute">The Function that verifies whether or not AsyncCommand should execute.</param>
+		/// <returns>IAsyncCommand</returns>
+		public static IAsyncCommand<TExecute> Create<TExecute>(Func<TExecute, Task> execute, Func<object, bool> canExecute) =>
+			Create(execute, canExecute, null, false, true);
+
+		/// <summary>
+		/// Initializes a new instance of IAsyncCommand
+		/// </summary>
+		/// <param name="execute">The Function executed when Execute or ExecuteAsync is called. This does not check canExecute before executing and will execute even if canExecute is false</param>
+		/// <param name="canExecute">The Function that verifies whether or not AsyncCommand should execute.</param>
+		/// <returns>IAsyncCommand</returns>
+		public static IAsyncCommand<TExecute> Create<TExecute>(Func<TExecute, Task> execute, Func<bool> canExecute) =>
+			Create(execute, canExecute, null, false, true);
+
+		/// <summary>
+		/// Initializes a new instance of IAsyncCommand
+		/// </summary>
+		/// <param name="execute">The Function executed when Execute or ExecuteAsync is called. This does not check canExecute before executing and will execute even if canExecute is false</param>
+		/// <param name="canExecute">The Function that verifies whether or not AsyncCommand should execute.</param>
+		/// <returns>IAsyncCommand</returns>
+		public static IAsyncCommand<TExecute, TCanExecute> Create<TExecute, TCanExecute>(Func<TExecute, Task> execute, Func<TCanExecute, bool> canExecute) =>
+			Create(execute, canExecute, null, false, true);
+		#endregion
+	}
+}
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.IAsyncValueCommand.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.IAsyncValueCommand.shared.cs
new file mode 100644
index 000000000..23d934e8b
--- /dev/null
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.IAsyncValueCommand.shared.cs
@@ -0,0 +1,91 @@
+using System;
+using System.Threading.Tasks;
+
+namespace Xamarin.CommunityToolkit.ObjectModel
+{
+	/// <summary>
+	/// Factory for IAsyncCommand
+	/// </summary>
+	public partial class CommandFactory
+	{
+		/// <summary>
+		/// Initializes a new instance of AsyncValueCommand
+		/// </summary>
+		/// <param name="execute">The Function executed when Execute or ExecuteAsync is called. This does not check canExecute before executing and will execute even if canExecute is false</param>
+		/// <param name="canExecute">The Function that verifies whether or not AsyncCommand should execute.</param>
+		/// <param name="onException">If an exception is thrown in the Task, <c>onException</c> will execute. If onException is null, the exception will be re-thrown</param>
+		/// <param name="continueOnCapturedContext">If set to <c>true</c> continue on captured context; this will ensure that the Synchronization Context returns to the calling thread. If set to <c>false</c> continue on a different context; this will allow the Synchronization Context to continue on a different thread</param>
+		/// <returns>IAsyncValueCommand</returns>
+		public static IAsyncValueCommand Create(
+			Func<ValueTask> execute,
+			Func<object, bool> canExecute = null,
+			Action<Exception> onException = null,
+			bool continueOnCapturedContext = false,
+			bool allowsMultipleExecutions = true) =>
+			new AsyncValueCommand(execute, canExecute, onException, continueOnCapturedContext, allowsMultipleExecutions);
+
+		/// <summary>
+		/// Initializes a new instance of AsyncValueCommand
+		/// </summary>
+		/// <param name="execute">The Function executed when Execute or ExecuteAsync is called. This does not check canExecute before executing and will execute even if canExecute is false</param>
+		/// <param name="canExecute">The Function that verifies whether or not AsyncCommand should execute.</param>
+		/// <param name="onException">If an exception is thrown in the Task, <c>onException</c> will execute. If onException is null, the exception will be re-thrown</param>
+		/// <param name="continueOnCapturedContext">If set to <c>true</c> continue on captured context; this will ensure that the Synchronization Context returns to the calling thread. If set to <c>false</c> continue on a different context; this will allow the Synchronization Context to continue on a different thread</param>
+		/// <returns>IAsyncValueCommand</returns>
+		public static IAsyncValueCommand Create(
+			Func<ValueTask> execute,
+			Func<bool> canExecute,
+			Action<Exception> onException = null,
+			bool continueOnCapturedContext = false,
+			bool allowsMultipleExecutions = true) =>
+			new AsyncValueCommand(execute, canExecute, onException, continueOnCapturedContext, allowsMultipleExecutions);
+
+		/// <summary>
+		/// Initializes a new instance of AsyncValueCommand
+		/// </summary>
+		/// <param name="execute">The Function executed when Execute or ExecuteAsync is called. This does not check canExecute before executing and will execute even if canExecute is false</param>
+		/// <param name="canExecute">The Function that verifies whether or not AsyncCommand should execute.</param>
+		/// <param name="onException">If an exception is thrown in the Task, <c>onException</c> will execute. If onException is null, the exception will be re-thrown</param>
+		/// <param name="continueOnCapturedContext">If set to <c>true</c> continue on captured context; this will ensure that the Synchronization Context returns to the calling thread. If set to <c>false</c> continue on a different context; this will allow the Synchronization Context to continue on a different thread</param>
+		/// <returns>IAsyncValueCommand<typeparamref name="TExecute"/></returns>
+		public static IAsyncValueCommand<TExecute> Create<TExecute>(
+			Func<TExecute, ValueTask> execute,
+			Func<object, bool> canExecute = null,
+			Action<Exception> onException = null,
+			bool continueOnCapturedContext = false,
+			bool allowsMultipleExecutions = true) =>
+			new AsyncValueCommand<TExecute>(execute, canExecute, onException, continueOnCapturedContext, allowsMultipleExecutions);
+
+		/// <summary>
+		/// Initializes a new instance of AsyncValueCommand
+		/// </summary>
+		/// <param name="execute">The Function executed when Execute or ExecuteAsync is called. This does not check canExecute before executing and will execute even if canExecute is false</param>
+		/// <param name="canExecute">The Function that verifies whether or not AsyncCommand should execute.</param>
+		/// <param name="onException">If an exception is thrown in the Task, <c>onException</c> will execute. If onException is null, the exception will be re-thrown</param>
+		/// <param name="continueOnCapturedContext">If set to <c>true</c> continue on captured context; this will ensure that the Synchronization Context returns to the calling thread. If set to <c>false</c> continue on a different context; this will allow the Synchronization Context to continue on a different thread</param>
+		/// <returns>IAsyncValueCommand<typeparamref name="TExecute"/></returns>
+		public static IAsyncValueCommand<TExecute> Create<TExecute>(
+			Func<TExecute, ValueTask> execute,
+			Func<bool> canExecute,
+			Action<Exception> onException = null,
+			bool continueOnCapturedContext = false,
+			bool allowsMultipleExecutions = true) =>
+			new AsyncValueCommand<TExecute>(execute, canExecute, onException, continueOnCapturedContext, allowsMultipleExecutions);
+
+		/// <summary>
+		/// Initializes a new instance of AsyncValueCommand
+		/// </summary>
+		/// <param name="execute">The Function executed when Execute or ExecuteAsync is called. This does not check canExecute before executing and will execute even if canExecute is false</param>
+		/// <param name="canExecute">The Function that verifies whether or not AsyncCommand should execute.</param>
+		/// <param name="onException">If an exception is thrown in the Task, <c>onException</c> will execute. If onException is null, the exception will be re-thrown</param>
+		/// <param name="continueOnCapturedContext">If set to <c>true</c> continue on captured context; this will ensure that the Synchronization Context returns to the calling thread. If set to <c>false</c> continue on a different context; this will allow the Synchronization Context to continue on a different thread</param>
+		/// <returns>IAsyncValueCommand></returns>
+		public static IAsyncValueCommand<TExecute, TCanExecute> Create<TExecute, TCanExecute>(
+			Func<TExecute, ValueTask> execute,
+			Func<TCanExecute, bool> canExecute = null,
+			Action<Exception> onException = null,
+			bool continueOnCapturedContext = false,
+			bool allowsMultipleExecutions = true) =>
+			new AsyncValueCommand<TExecute, TCanExecute>(execute, canExecute, onException, continueOnCapturedContext, allowsMultipleExecutions);
+	}
+}
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.shared.cs
deleted file mode 100644
index 533eda593..000000000
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.shared.cs
+++ /dev/null
@@ -1,136 +0,0 @@
-using System;
-using System.Reflection;
-using System.Threading.Tasks;
-using Xamarin.CommunityToolkit.Exceptions;
-using Xamarin.Forms;
-
-namespace Xamarin.CommunityToolkit.ObjectModel
-{
-	public static class CommandFactory
-	{
-		public static Command Create(Action execute, Func<bool> canExecute = null) =>
-			new Command(execute, canExecute ?? (() => true));
-
-		public static Command Create<TExecute>(Action<TExecute> execute, Func<bool> canExecute = null) =>
-			new Command(ConvertExecute(execute), ConvertCanExecute(canExecute));
-
-		public static Command Create<TExecute, TCanExecute>(Action<TExecute> execute, Func<TCanExecute, bool> canExecute) =>
-			new Command(ConvertExecute(execute), ConvertCanExecute(canExecute));
-
-		public static IAsyncCommand Create(Func<Task> executeTask) =>
-			new AsyncCommand(executeTask);
-
-		public static IAsyncCommand Create(Func<Task> executeTask, Func<bool> canExecute) =>
-			new AsyncCommand(executeTask, canExecute);
-
-		public static IAsyncCommand Create(
-			Func<Task> executeTask,
-			Func<bool> canExecute = null,
-			Action<Exception> onException = null,
-			bool continueOnCapturedContext = false,
-			bool allowsMultipleExecutions = true) =>
-			new AsyncCommand(executeTask, canExecute, onException, continueOnCapturedContext, allowsMultipleExecutions);
-
-		public static IAsyncCommand<TExecute> Create<TExecute>(Func<TExecute, Task> executeTask) =>
-			new AsyncCommand<TExecute>(executeTask);
-
-		public static IAsyncCommand<TExecute> Create<TExecute>(Func<TExecute, Task> executeTask, Func<bool> canExecute) =>
-			new AsyncCommand<TExecute>(executeTask, canExecute);
-
-		public static IAsyncCommand<TExecute> Create<TExecute>(
-			Func<TExecute, Task> executeTask,
-			Func<bool> canExecute = null,
-			Action<Exception> onException = null,
-			bool continueOnCapturedContext = false,
-			bool allowsMultipleExecutions = true) =>
-			new AsyncCommand<TExecute>(executeTask, canExecute, onException, continueOnCapturedContext, allowsMultipleExecutions);
-
-		public static IAsyncCommand<TExecute, TCanExecute> Create<TExecute, TCanExecute>(Func<TExecute, Task> executeTask) =>
-			new AsyncCommand<TExecute, TCanExecute>(executeTask);
-
-		public static IAsyncCommand<TExecute, TCanExecute> Create<TExecute, TCanExecute>(Func<TExecute, Task> executeTask, Func<TCanExecute, bool> canExecute) =>
-			new AsyncCommand<TExecute, TCanExecute>(executeTask, canExecute);
-
-		public static IAsyncCommand<TExecute, TCanExecute> Create<TExecute, TCanExecute>(
-			Func<TExecute, Task> executeTask,
-			Func<TCanExecute, bool> canExecute = null,
-			Action<Exception> onException = null,
-			bool continueOnCapturedContext = false,
-			bool allowsMultipleExecutions = true) =>
-			new AsyncCommand<TExecute, TCanExecute>(executeTask, canExecute, onException, continueOnCapturedContext, allowsMultipleExecutions);
-
-		public static IAsyncValueCommand Create(
-			Func<ValueTask> executeValueTask,
-			Func<bool> canExecute = null,
-			Action<Exception> onException = null,
-			bool continueOnCapturedContext = false,
-			bool allowsMultipleExecutions = true) =>
-			new AsyncValueCommand(executeValueTask, canExecute, onException, continueOnCapturedContext, allowsMultipleExecutions);
-
-		public static IAsyncValueCommand<TExecute> Create<TExecute>(
-			Func<TExecute, ValueTask> executeValueTask,
-			Func<bool> canExecute = null,
-			Action<Exception> onException = null,
-			bool continueOnCapturedContext = false,
-			bool allowsMultipleExecutions = true) =>
-			new AsyncValueCommand<TExecute>(executeValueTask, canExecute, onException, continueOnCapturedContext, allowsMultipleExecutions);
-
-		public static IAsyncValueCommand<TExecute, TCanExecute> Create<TExecute, TCanExecute>(
-			Func<TExecute, ValueTask> executeValueTask,
-			Func<TCanExecute, bool> canExecute = null,
-			Action<Exception> onException = null,
-			bool continueOnCapturedContext = false,
-			bool allowsMultipleExecutions = true) =>
-			new AsyncValueCommand<TExecute, TCanExecute>(executeValueTask, canExecute, onException, continueOnCapturedContext, allowsMultipleExecutions);
-
-		static Action<object> ConvertExecute<T>(Action<T> execute)
-		{
-			if (execute == null)
-				return null;
-
-			return p => Execute(execute, p);
-		}
-
-		static void Execute<T>(Action<T> execute, object parameter)
-		{
-			switch (parameter)
-			{
-				case T validParameter:
-					execute(validParameter);
-					break;
-
-				case null when !typeof(T).GetTypeInfo().IsValueType:
-					execute((T)parameter);
-					break;
-
-				case null:
-					throw new InvalidCommandParameterException(typeof(T));
-
-				default:
-					throw new InvalidCommandParameterException(typeof(T), parameter.GetType());
-			}
-		}
-
-		static Func<object, bool> ConvertCanExecute(Func<bool> canExecute)
-		{
-			if (canExecute == null)
-				return _ => true;
-
-			return _ => canExecute();
-		}
-
-		static Func<object, bool> ConvertCanExecute<T>(Func<T, bool> canExecute)
-		{
-			canExecute ??= _ => true;
-			return p => CanExecute(canExecute, p);
-		}
-
-		static bool CanExecute<T>(Func<T, bool> canExecute, object parameter) => parameter switch
-		{
-			T validParameter => canExecute(validParameter),
-			null when !typeof(T).GetTypeInfo().IsValueType => canExecute((T)parameter),
-			null => throw new InvalidCommandParameterException(typeof(T)),
-			_ => throw new InvalidCommandParameterException(typeof(T), parameter.GetType()),
-		};
-	}
-}

From 2f8e3b39943117b9af6063cc52899d04ace3e5fe Mon Sep 17 00:00:00 2001
From: Brandon Minnick <13558917+brminnick@users.noreply.github.com>
Date: Thu, 28 Jan 2021 17:53:49 -0800
Subject: [PATCH 21/21] Updated XML Documentation

---
 .../ObjectModel/CommandFactory.Command.shared.cs                | 2 +-
 .../ObjectModel/CommandFactory.IAsyncValueCommand.shared.cs     | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.Command.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.Command.shared.cs
index 36f70ac0c..1d3ac9f22 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.Command.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.Command.shared.cs
@@ -4,7 +4,7 @@
 namespace Xamarin.CommunityToolkit.ObjectModel
 {
 	/// <summary>
-	/// Factory for IAsyncCommand
+	/// Factory for Xamarin.Forms.Command
 	/// </summary>
 	public partial class CommandFactory
 	{
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.IAsyncValueCommand.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.IAsyncValueCommand.shared.cs
index 23d934e8b..b237836cf 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.IAsyncValueCommand.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.IAsyncValueCommand.shared.cs
@@ -4,7 +4,7 @@
 namespace Xamarin.CommunityToolkit.ObjectModel
 {
 	/// <summary>
-	/// Factory for IAsyncCommand
+	/// Factory for IAsyncValueCommand
 	/// </summary>
 	public partial class CommandFactory
 	{