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..8e7a5071f 100644
--- a/samples/XCT.Sample/Pages/Base/BasePage.cs
+++ b/samples/XCT.Sample/Pages/Base/BasePage.cs
@@ -8,12 +8,12 @@ namespace Xamarin.CommunityToolkit.Sample.Pages
 {
 	public class BasePage : ContentPage
 	{
-		ICommand navigateCommand;
+		public BasePage() =>
+			NavigateCommand = CommandFactory.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..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.Forms;
+using Xamarin.CommunityToolkit.ObjectModel;
 using Xamarin.Forms.Xaml;
 
 namespace Xamarin.CommunityToolkit.Sample.Pages.Effects
@@ -9,18 +9,18 @@ public partial class TouchEffectPage
 	{
 		public TouchEffectPage()
 		{
-			Command = new Command(() =>
+			Command = CommandFactory.Create(() =>
 			{
 				TouchCount++;
 				OnPropertyChanged(nameof(TouchCount));
 			});
-			LongPressCommand = new Command(() =>
+			LongPressCommand = CommandFactory.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..61de4d00e 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.ObjectModel;
 
 namespace Xamarin.CommunityToolkit.Sample.Pages.TestCases
 {
 	public partial class TouchEffectButtonPage
 	{
-		ICommand command;
-
 		public TouchEffectButtonPage()
-			=> InitializeComponent();
+		{
+			Command = CommandFactory.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..e7d242b4c 100644
--- a/samples/XCT.Sample/ViewModels/AboutViewModel.cs
+++ b/samples/XCT.Sample/ViewModels/AboutViewModel.cs
@@ -18,7 +18,18 @@ public class AboutViewModel : BaseViewModel
 
 		string emptyViewText = "Loading data...";
 
-		ICommand selectedContributorCommand;
+		public AboutViewModel()
+		{
+			PageAppearingCommand = CommandFactory.Create(OnAppearing);
+			SelectedContributorCommand = CommandFactory.Create(async () =>
+			{
+				if (SelectedContributor == 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..1ca508b72 100644
--- a/samples/XCT.Sample/ViewModels/Base/BaseGalleryViewModel.cs
+++ b/samples/XCT.Sample/ViewModels/Base/BaseGalleryViewModel.cs
@@ -4,21 +4,22 @@
 using System.Windows.Input;
 using Xamarin.CommunityToolkit.ObjectModel;
 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 = CommandFactory.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..a8973056f 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.ObjectModel;
 
 namespace Xamarin.CommunityToolkit.Sample.ViewModels.Behaviors
 {
 	public class EventToCommandBehaviorViewModel : BaseViewModel
 	{
-		ICommand incrementCommand;
-
 		int clickCount;
 
-		public ICommand IncrementCommand => incrementCommand ??= new Command(() => ClickCount++);
+		public EventToCommandBehaviorViewModel() =>
+			IncrementCommand = CommandFactory.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..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.Forms;
+using Xamarin.CommunityToolkit.ObjectModel;
 
 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 = 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 a80440737..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.Forms;
+using Xamarin.CommunityToolkit.ObjectModel;
 
 namespace Xamarin.CommunityToolkit.Sample.ViewModels.Behaviors
 {
@@ -21,7 +21,7 @@ public string PerformedSearches
 		#endregion Properties
 
 		public UserStoppedTypingBehaviorViewModel()
-			=> SearchCommand = new Command<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 195c042fd..a7e7ef2bb 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.ObjectModel;
 
 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 = CommandFactory.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..6569e2053 100644
--- a/samples/XCT.Sample/ViewModels/Converters/ItemSelectedEventArgsViewModel.cs
+++ b/samples/XCT.Sample/ViewModels/Converters/ItemSelectedEventArgsViewModel.cs
@@ -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; } =
+			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 7f53249d1..8aa56632b 100644
--- a/samples/XCT.Sample/ViewModels/Converters/ItemTappedEventArgsViewModel.cs
+++ b/samples/XCT.Sample/ViewModels/Converters/ItemTappedEventArgsViewModel.cs
@@ -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; } =
+			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 392a6415a..051593e0a 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 = CommandFactory.Create(() =>
 			{
 				Items.Add(new Person
 				{
@@ -17,7 +18,7 @@ public ListIsNullOrEmptyViewModel()
 					Name = $"Person {Items.Count}"
 				});
 			});
-			RemoveItemCommand = new Command(() => 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/Markup/SearchViewModel.cs b/samples/XCT.Sample/ViewModels/Markup/SearchViewModel.cs
index e9c21cfed..132006d9a 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,15 +52,20 @@ 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() { }
 
diff --git a/samples/XCT.Sample/ViewModels/SettingViewModel.cs b/samples/XCT.Sample/ViewModels/SettingViewModel.cs
index dd834e376..34623cf3f 100644
--- a/samples/XCT.Sample/ViewModels/SettingViewModel.cs
+++ b/samples/XCT.Sample/ViewModels/SettingViewModel.cs
@@ -3,17 +3,15 @@
 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;
-using Xamarin.Forms;
 
 namespace Xamarin.CommunityToolkit.Sample.ViewModels
 {
 	public class SettingViewModel : BaseViewModel
 	{
-		public SettingViewModel() => LoadLanguages();
-
 		IList<Language> supportedLanguages;
 
 		public IList<Language> SupportedLanguages
@@ -32,13 +30,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 = CommandFactory.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..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.Forms;
+using Xamarin.CommunityToolkit.ObjectModel;
 
 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 = CommandFactory.Create(Increase);
+			DecreaseCommand = CommandFactory.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..108859756 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.ObjectModel;
 
 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 = CommandFactory.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/StateLayoutViewModel.cs b/samples/XCT.Sample/ViewModels/Views/StateLayoutViewModel.cs
index 68b673a2c..d1d63e27c 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.ObjectModel;
 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 = CommandFactory.Create(async () =>
 			{
 				MainState = LayoutState.Loading;
 				await Task.Delay(2000);
 				MainState = LayoutState.None;
 			});
-
-			CycleStatesCommand = new Command(async (x) => await 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 8e08baa8c..451391518 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.ObjectModel;
 using Xamarin.Forms;
 
 namespace Xamarin.CommunityToolkit.Sample.ViewModels.Views
@@ -19,13 +20,16 @@ public class TabItemsSourceViewModel : BaseViewModel
 		public TabItemsSourceViewModel()
 		{
 			LoadMonkeys();
+
+			ClearDataCommand = CommandFactory.Create(ClearData);
+			UpdateDataCommand = CommandFactory.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()
 		{
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
new file mode 100644
index 000000000..6b5618c3c
--- /dev/null
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_AsyncCommand_Tests.cs
@@ -0,0 +1,264 @@
+using System;
+using System.Threading.Tasks;
+using System.Windows.Input;
+using Xamarin.CommunityToolkit.Exceptions;
+using Xamarin.CommunityToolkit.ObjectModel;
+using Xunit;
+
+namespace Xamarin.CommunityToolkit.UnitTests.ObjectModel.ICommandTests.CommandFactoryTests
+{
+	public class CommandFactoryAsyncCommandTests : BaseCommandTests
+	{
+		[Fact]
+		public void AsyncCommand_NullExecuteParameter()
+		{
+			// Arrange
+			Func<Task> execute = null;
+
+			// Act
+
+			// Assert
+			Assert.Throws<ArgumentNullException>(() => CommandFactory.Create(execute));
+		}
+
+		[Fact]
+		public async Task AsyncCommand_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<AsyncCommand>(command);
+			Assert.IsAssignableFrom<IAsyncCommand>(command);
+		}
+
+		[Fact]
+		public async Task AsyncCommand_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<AsyncCommand>(command);
+			Assert.IsAssignableFrom<IAsyncCommand>(command);
+		}
+
+		[Fact]
+		public void AsyncCommand_FuncBool_NullExecuteParameter()
+		{
+			// Arrange
+			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 async Task AsyncCommand_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<AsyncCommand>(command);
+			Assert.IsAssignableFrom<ICommand>(command);
+			Assert.IsAssignableFrom<IAsyncCommand>(command);
+		}
+
+		[Fact]
+		public void AsyncCommandT_NullExecuteParameter()
+		{
+			// Arrange
+			Func<int, Task> execute = null;
+
+			// Act
+
+			// Assert
+			Assert.Throws<ArgumentNullException>(() => CommandFactory.Create(execute));
+		}
+
+		[Fact]
+		public async Task AsyncCommandT_NullCanExecuteParameter()
+		{
+			// Arrange
+			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(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 async Task AsyncCommandTExecuteTCanExecute_ObjectCanExecuteParameter()
+		{
+			// Arrange
+			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
new file mode 100644
index 000000000..2655be1e4
--- /dev/null
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_AsyncValueCommand_Tests.cs
@@ -0,0 +1,265 @@
+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;
+using Xunit;
+
+namespace Xamarin.CommunityToolkit.UnitTests.ObjectModel.ICommandTests.CommandFactoryTests
+{
+	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 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 async Task AsyncValueCommandT_NullCanExecuteParameter()
+		{
+			// Arrange
+			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 async Task AsyncValueCommandT_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<AsyncValueCommand<int>>(command);
+			Assert.IsAssignableFrom<ICommand>(command);
+			Assert.IsAssignableFrom<IAsyncValueCommand<int>>(command);
+		}
+
+		[Fact]
+		public void AsyncValueCommandT_FuncBool_NullExecuteParameter()
+		{
+			// Arrange
+			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 async Task AsyncValueCommandT_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<AsyncValueCommand<int>>(command);
+			Assert.IsAssignableFrom<ICommand>(command);
+			Assert.IsAssignableFrom<IAsyncValueCommand<int>>(command);
+		}
+
+		[Fact]
+		public void AsyncValueCommandTExecuteTCanExecute_NullExecuteParameter()
+		{
+			// Arrange
+			Func<int, ValueTask> execute = null;
+
+			// Act
+
+			// Assert
+			Assert.Throws<ArgumentNullException>(() => CommandFactory.Create(execute));
+		}
+
+		[Fact]
+		public async Task AsyncValueCommandTExecuteTCanExecute_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(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 async Task AsyncValueCommandTExecuteTCanExecute_ObjectCanExecuteParameter()
+		{
+			// Arrange
+			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
new file mode 100644
index 000000000..b6e4f48d4
--- /dev/null
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/CommandFactoryTests/CommandFactory_Command_Tests.cs
@@ -0,0 +1,171 @@
+using System;
+using System.Windows.Input;
+using Xamarin.CommunityToolkit.Exceptions;
+using Xamarin.CommunityToolkit.ObjectModel;
+using Xunit;
+
+namespace Xamarin.CommunityToolkit.UnitTests.ObjectModel.ICommandTests.CommandFactoryTests
+{
+	public class CommandFactoryCommandTests : BaseCommandTests
+	{
+		[Fact]
+		public void Action_NullExecuteParameter()
+		{
+			// Arrange
+			Action execute = null;
+
+			// Act
+
+			// Assert
+			Assert.Throws<ArgumentNullException>(() => CommandFactory.Create(execute));
+		}
+
+		[Fact]
+		public void Action_ValidExecuteParameter()
+		{
+			// Arrange
+			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 Action_ValidCanExecuteParameter()
+		{
+			// Arrange
+			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));
+
+			Assert.IsType<Forms.Command>(command);
+			Assert.IsAssignableFrom<ICommand>(command);
+		}
+
+		[Fact]
+		public void ActionObject_NullExecuteParameter()
+		{
+			// Arrange
+			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 ActionObject_NullCanExecuteParameter()
+		{
+			// Arrange
+
+			// Act
+
+			// Assert
+			Assert.Throws<ArgumentNullException>(() => CommandFactory.Create(ObjectParameterAction, null));
+		}
+
+		[Fact]
+		public void ActionObject_ValidCanExecuteParameter()
+		{
+			// Arrange
+			var command = CommandFactory.Create(ObjectParameterAction, _ => true);
+
+			// Act
+			command.Execute(1);
+			command.Execute(null);
+			command.Execute(string.Empty);
+
+			// 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 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 ActionInt_ValidCanExecuteParameter()
+		{
+			// Arrange
+			var command = CommandFactory.Create<int>(IntParameterAction, CanExecuteTrue);
+
+			// Act
+
+			// Assert
+			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/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/ObjectModel/CommandFactory.Command.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/CommandFactory.Command.shared.cs
new file mode 100644
index 000000000..1d3ac9f22
--- /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 Xamarin.Forms.Command
+	/// </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..b237836cf
--- /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 IAsyncValueCommand
+	/// </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/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)