diff --git a/azure-pipelines.yml b/azure-pipelines.yml
index b31c75dde..965bd9046 100644
--- a/azure-pipelines.yml
+++ b/azure-pipelines.yml
@@ -4,8 +4,8 @@ variables:
   PreviewNumber: $[counter(variables['CurrentSemanticVersionBase'], 1001)]
   CurrentSemanticVersion: '$(CurrentSemanticVersionBase)-preview$(PreviewNumber)'
   NugetPackageVersion: '$(CurrentSemanticVersion)'
-  MONO_VERSION: 6_4_0
-  XCODE_VERSION: 11.4
+  #MONO_VERSION: 6_4_0
+  #XCODE_VERSION: 11.4
   NETCORE_VERSION: '3.1.x'
   NETCORE_TEST_VERSION: '3.1.x'
   RunPoliCheck: 'false'
@@ -153,11 +153,12 @@ jobs:
           Write-Host ("##vso[task.setvariable variable=NugetPackageVersion;]$tagVersion")
         displayName: Set NuGet Version to Tag Number
         condition: startsWith(variables['Build.SourceBranch'], 'refs/tags/')
+      # 16feb21 jfversluis: let's not pin this anymore and use latest
       # make sure to select the correct Xamarin and mono
-      - bash: sudo $AGENT_HOMEDIRECTORY/scripts/select-xamarin-sdk.sh $(MONO_VERSION)
-        displayName: Switch to the latest Xamarin SDK
-      - bash: echo '##vso[task.setvariable variable=MD_APPLE_SDK_ROOT;]'/Applications/Xcode_$(XCODE_VERSION).app;sudo xcode-select --switch /Applications/Xcode_$(XCODE_VERSION).app/Contents/Developer
-        displayName: Switch to the latest Xcode
+      #- bash: sudo $AGENT_HOMEDIRECTORY/scripts/select-xamarin-sdk.sh $(MONO_VERSION)
+      #  displayName: Switch to the latest Xamarin SDK
+      #- bash: echo '##vso[task.setvariable variable=MD_APPLE_SDK_ROOT;]'/Applications/Xcode_$(XCODE_VERSION).app;sudo xcode-select --switch /Applications/Xcode_$(XCODE_VERSION).app/Contents/Developer
+      #  displayName: Switch to the latest Xcode
       # restore, build and pack the packages
       - task: UseDotNet@2
         displayName: 'Use .Net Core sdk'
diff --git a/samples/XCT.Sample/Pages/AboutPage.xaml.cs b/samples/XCT.Sample/Pages/AboutPage.xaml.cs
index b4973351f..2c1826452 100644
--- a/samples/XCT.Sample/Pages/AboutPage.xaml.cs
+++ b/samples/XCT.Sample/Pages/AboutPage.xaml.cs
@@ -1,4 +1,5 @@
 using System;
+using Xamarin.CommunityToolkit.Sample.ViewModels;
 
 namespace Xamarin.CommunityToolkit.Sample.Pages
 {
diff --git a/samples/XCT.Sample/Pages/Behaviors/EmailValidationBehaviorPage.xaml b/samples/XCT.Sample/Pages/Behaviors/EmailValidationBehaviorPage.xaml
index e9d055e70..f9fef55cd 100644
--- a/samples/XCT.Sample/Pages/Behaviors/EmailValidationBehaviorPage.xaml
+++ b/samples/XCT.Sample/Pages/Behaviors/EmailValidationBehaviorPage.xaml
@@ -15,11 +15,21 @@
                  Spacing="50"
                  VerticalOptions="CenterAndExpand">
         <Label Text="Text color will change accordingly to the style that is configured when a invalid value (email address) is entered." />
-        <Entry Placeholder="Email">
-            <Entry.Behaviors>
-                <xct:EmailValidationBehavior DecorationFlags="Trim" InvalidStyle="{StaticResource InvalidEntryStyle}"/>
-            </Entry.Behaviors>
-        </Entry>
+        <StackLayout Spacing="3">
+            <Entry Placeholder="Email">
+                <Entry.Behaviors>
+                    <xct:EmailValidationBehavior
+                        x:Name="EmailValidator"
+                        DecorationFlags="Trim"
+                        InvalidStyle="{StaticResource InvalidEntryStyle}"/>
+                </Entry.Behaviors>
+            </Entry>
+            <Label Text="Invalid email"
+                   TextColor="Red"
+                   FontSize="10"
+                   IsVisible="{Binding IsNotValid, Source={x:Reference EmailValidator}}"
+                   />
+        </StackLayout>
     </StackLayout>
 
 </pages:BasePage>
diff --git a/samples/XCT.Sample/Pages/Behaviors/ImpliedOrderGridBehaviorPage.xaml.cs b/samples/XCT.Sample/Pages/Behaviors/ImpliedOrderGridBehaviorPage.xaml.cs
index 6c1af281b..e671d3a1d 100644
--- a/samples/XCT.Sample/Pages/Behaviors/ImpliedOrderGridBehaviorPage.xaml.cs
+++ b/samples/XCT.Sample/Pages/Behaviors/ImpliedOrderGridBehaviorPage.xaml.cs
@@ -1,11 +1,9 @@
 using System;
 using System.Linq;
 using Xamarin.Forms;
-using Xamarin.Forms.Xaml;
 
 namespace Xamarin.CommunityToolkit.Sample.Pages.Behaviors
 {
-	[XamlCompilation(XamlCompilationOptions.Compile)]
 	public partial class ImpliedOrderGridBehaviorPage
 	{
 		public ImpliedOrderGridBehaviorPage() => InitializeComponent();
diff --git a/samples/XCT.Sample/Pages/Behaviors/MaxLengthReachedBehaviorPage.xaml.cs b/samples/XCT.Sample/Pages/Behaviors/MaxLengthReachedBehaviorPage.xaml.cs
index 51767df6e..857afffc0 100644
--- a/samples/XCT.Sample/Pages/Behaviors/MaxLengthReachedBehaviorPage.xaml.cs
+++ b/samples/XCT.Sample/Pages/Behaviors/MaxLengthReachedBehaviorPage.xaml.cs
@@ -1,9 +1,7 @@
 using Xamarin.CommunityToolkit.Behaviors;
-using Xamarin.Forms.Xaml;
 
 namespace Xamarin.CommunityToolkit.Sample.Pages.Behaviors
 {
-	[XamlCompilation(XamlCompilationOptions.Compile)]
 	public partial class MaxLengthReachedBehaviorPage : BasePage
 	{
 		public MaxLengthReachedBehaviorPage()
diff --git a/samples/XCT.Sample/Pages/Behaviors/RequiredStringValidationBehaviorPage.xaml.cs b/samples/XCT.Sample/Pages/Behaviors/RequiredStringValidationBehaviorPage.xaml.cs
index 4bc8c0016..ad6f186f0 100644
--- a/samples/XCT.Sample/Pages/Behaviors/RequiredStringValidationBehaviorPage.xaml.cs
+++ b/samples/XCT.Sample/Pages/Behaviors/RequiredStringValidationBehaviorPage.xaml.cs
@@ -1,8 +1,5 @@
-using Xamarin.Forms.Xaml;
-
-namespace Xamarin.CommunityToolkit.Sample.Pages.Behaviors
+namespace Xamarin.CommunityToolkit.Sample.Pages.Behaviors
 {
-	[XamlCompilation(XamlCompilationOptions.Compile)]
 	public partial class RequiredStringValidationBehaviorPage : BasePage
 	{
 		public RequiredStringValidationBehaviorPage()
diff --git a/samples/XCT.Sample/Pages/Behaviors/UserStoppedTypingBehaviorPage.xaml.cs b/samples/XCT.Sample/Pages/Behaviors/UserStoppedTypingBehaviorPage.xaml.cs
index bc3b31262..066560f7d 100644
--- a/samples/XCT.Sample/Pages/Behaviors/UserStoppedTypingBehaviorPage.xaml.cs
+++ b/samples/XCT.Sample/Pages/Behaviors/UserStoppedTypingBehaviorPage.xaml.cs
@@ -1,8 +1,5 @@
-using Xamarin.Forms.Xaml;
-
-namespace Xamarin.CommunityToolkit.Sample.Pages.Behaviors
+namespace Xamarin.CommunityToolkit.Sample.Pages.Behaviors
 {
-	[XamlCompilation(XamlCompilationOptions.Compile)]
 	public partial class UserStoppedTypingBehaviorPage : BasePage
 	{
 		public UserStoppedTypingBehaviorPage() => InitializeComponent();
diff --git a/samples/XCT.Sample/Pages/Converters/DateTimeOffsetConverterPage.xaml.cs b/samples/XCT.Sample/Pages/Converters/DateTimeOffsetConverterPage.xaml.cs
index 3e2984d5f..22654798d 100644
--- a/samples/XCT.Sample/Pages/Converters/DateTimeOffsetConverterPage.xaml.cs
+++ b/samples/XCT.Sample/Pages/Converters/DateTimeOffsetConverterPage.xaml.cs
@@ -1,8 +1,5 @@
-using Xamarin.Forms.Xaml;
-
-namespace Xamarin.CommunityToolkit.Sample.Pages.Converters
+namespace Xamarin.CommunityToolkit.Sample.Pages.Converters
 {
-	[XamlCompilation(XamlCompilationOptions.Compile)]
 	public partial class DateTimeOffsetConverterPage : BasePage
 	{
 		public DateTimeOffsetConverterPage()
diff --git a/samples/XCT.Sample/Pages/Effects/EffectsGalleryPage.xaml.cs b/samples/XCT.Sample/Pages/Effects/EffectsGalleryPage.xaml.cs
index e63a98bc9..001353ba9 100644
--- a/samples/XCT.Sample/Pages/Effects/EffectsGalleryPage.xaml.cs
+++ b/samples/XCT.Sample/Pages/Effects/EffectsGalleryPage.xaml.cs
@@ -1,8 +1,5 @@
-using Xamarin.Forms.Xaml;
-
-namespace Xamarin.CommunityToolkit.Sample.Pages.Effects
+namespace Xamarin.CommunityToolkit.Sample.Pages.Effects
 {
-	[XamlCompilation(XamlCompilationOptions.Compile)]
 	public partial class EffectsGalleryPage
 	{
 		public EffectsGalleryPage() => InitializeComponent();
diff --git a/samples/XCT.Sample/Pages/Effects/IconTintColorEffectPage.xaml.cs b/samples/XCT.Sample/Pages/Effects/IconTintColorEffectPage.xaml.cs
index e344a9c0b..d3fab6c14 100644
--- a/samples/XCT.Sample/Pages/Effects/IconTintColorEffectPage.xaml.cs
+++ b/samples/XCT.Sample/Pages/Effects/IconTintColorEffectPage.xaml.cs
@@ -1,8 +1,5 @@
-using Xamarin.Forms.Xaml;
-
-namespace Xamarin.CommunityToolkit.Sample.Pages.Effects
+namespace Xamarin.CommunityToolkit.Sample.Pages.Effects
 {
-	[XamlCompilation(XamlCompilationOptions.Compile)]
 	public partial class IconTintColorEffectPage : BasePage
 	{
 		public IconTintColorEffectPage()
diff --git a/samples/XCT.Sample/Pages/Effects/RemoveBorderEffectPage.xaml.cs b/samples/XCT.Sample/Pages/Effects/RemoveBorderEffectPage.xaml.cs
index 5d109b590..54873b20e 100644
--- a/samples/XCT.Sample/Pages/Effects/RemoveBorderEffectPage.xaml.cs
+++ b/samples/XCT.Sample/Pages/Effects/RemoveBorderEffectPage.xaml.cs
@@ -1,12 +1,5 @@
-using System;
-using System.Collections.Generic;
-
-using Xamarin.Forms;
-using Xamarin.Forms.Xaml;
-
-namespace Xamarin.CommunityToolkit.Sample.Pages.Effects
+namespace Xamarin.CommunityToolkit.Sample.Pages.Effects
 {
-	[XamlCompilation(XamlCompilationOptions.Compile)]
 	public partial class RemoveBorderEffectPage
 	{
 		public RemoveBorderEffectPage() => InitializeComponent();
diff --git a/samples/XCT.Sample/Pages/Effects/SafeAreaEffectPage.xaml.cs b/samples/XCT.Sample/Pages/Effects/SafeAreaEffectPage.xaml.cs
index 8fa159feb..8227d5564 100644
--- a/samples/XCT.Sample/Pages/Effects/SafeAreaEffectPage.xaml.cs
+++ b/samples/XCT.Sample/Pages/Effects/SafeAreaEffectPage.xaml.cs
@@ -1,9 +1,7 @@
 using Xamarin.CommunityToolkit.Effects;
-using Xamarin.Forms.Xaml;
 
 namespace Xamarin.CommunityToolkit.Sample.Pages.Effects
 {
-	[XamlCompilation(XamlCompilationOptions.Compile)]
 	public partial class SafeAreaEffectPage
 	{
 		public SafeAreaEffectPage() => InitializeComponent();
diff --git a/samples/XCT.Sample/Pages/Effects/SelectAllTextEffectPage.xaml.cs b/samples/XCT.Sample/Pages/Effects/SelectAllTextEffectPage.xaml.cs
index f37276384..76a7e2628 100644
--- a/samples/XCT.Sample/Pages/Effects/SelectAllTextEffectPage.xaml.cs
+++ b/samples/XCT.Sample/Pages/Effects/SelectAllTextEffectPage.xaml.cs
@@ -1,12 +1,5 @@
-using System;
-using System.Collections.Generic;
-
-using Xamarin.Forms;
-using Xamarin.Forms.Xaml;
-
-namespace Xamarin.CommunityToolkit.Sample.Pages.Effects
+namespace Xamarin.CommunityToolkit.Sample.Pages.Effects
 {
-	[XamlCompilation(XamlCompilationOptions.Compile)]
 	public partial class SelectAllTextEffectPage
 	{
 		public SelectAllTextEffectPage() => InitializeComponent();
diff --git a/samples/XCT.Sample/Pages/Effects/TouchEffectPage.xaml.cs b/samples/XCT.Sample/Pages/Effects/TouchEffectPage.xaml.cs
index 466cfedcb..67253a5a1 100644
--- a/samples/XCT.Sample/Pages/Effects/TouchEffectPage.xaml.cs
+++ b/samples/XCT.Sample/Pages/Effects/TouchEffectPage.xaml.cs
@@ -1,10 +1,10 @@
 using System.Windows.Input;
 using Xamarin.CommunityToolkit.ObjectModel;
 using Xamarin.Forms.Xaml;
+using Xamarin.Forms;
 
 namespace Xamarin.CommunityToolkit.Sample.Pages.Effects
 {
-	[XamlCompilation(XamlCompilationOptions.Compile)]
 	public partial class TouchEffectPage
 	{
 		public TouchEffectPage()
diff --git a/samples/XCT.Sample/Pages/TestCases/TouchEffectCollectionViewPage.xaml b/samples/XCT.Sample/Pages/TestCases/TouchEffectCollectionViewPage.xaml
new file mode 100644
index 000000000..08c5fcc4b
--- /dev/null
+++ b/samples/XCT.Sample/Pages/TestCases/TouchEffectCollectionViewPage.xaml
@@ -0,0 +1,67 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<pages:BasePage xmlns="http://xamarin.com/schemas/2014/forms"
+                xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+                xmlns:xct="http://xamarin.com/schemas/2020/toolkit"
+                xmlns:pages="clr-namespace:Xamarin.CommunityToolkit.Sample.Pages"
+                xmlns:ios="clr-namespace:Xamarin.Forms.PlatformConfiguration.iOSSpecific;assembly=Xamarin.Forms.Core"
+                ios:Page.UseSafeArea="true"
+                x:Class="Xamarin.CommunityToolkit.Sample.Pages.TestCases.TouchEffectCollectionViewPage"
+                x:Name="Page">
+
+    <CollectionView x:Name="Collection"
+                    SelectionMode="Multiple">
+    <CollectionView.ItemsSource>
+        <x:Array Type="{x:Type x:String}">
+            <x:String>One</x:String>
+            <x:String>Two</x:String>
+            <x:String>Three</x:String>
+            <x:String>Four</x:String>
+            <x:String>Five</x:String>
+            <x:String>Six</x:String>
+        </x:Array>
+    </CollectionView.ItemsSource>
+    <CollectionView.ItemsLayout>
+        <GridItemsLayout
+            Orientation="Vertical"
+            Span="2"
+            HorizontalItemSpacing="8"
+            VerticalItemSpacing="8"/>
+    </CollectionView.ItemsLayout>
+    <CollectionView.ItemTemplate>
+        <DataTemplate>
+            <Frame HeightRequest="120"
+                   CornerRadius="0"
+                   Padding="0"
+                   HasShadow="True"
+                   xct:TouchEffect.LongPressCommand="{Binding LongPressCommand, Source={x:Reference Page}}"
+                   xct:TouchEffect.NativeAnimation="True">
+                <VisualStateManager.VisualStateGroups>
+                    <VisualStateGroup x:Name="CommonStates">
+                        <VisualState x:Name="Normal">
+                            <VisualState.Setters>
+                                <Setter
+                                    TargetName="Label"
+                                    Property="Label.TextColor"
+                                    Value="Black"/>
+                            </VisualState.Setters>
+                        </VisualState>
+                        <VisualState x:Name="Selected">
+                            <VisualState.Setters>
+                                <Setter
+                                    TargetName="Label"
+                                    Property="Label.TextColor"
+                                    Value="Red"/>
+                            </VisualState.Setters>
+                        </VisualState>
+                    </VisualStateGroup>
+                </VisualStateManager.VisualStateGroups>
+                <Label x:Name="Label"
+                       Text="{Binding .}"
+                       VerticalOptions="CenterAndExpand"
+                       HorizontalOptions="CenterAndExpand"/>
+            </Frame>
+        </DataTemplate>
+    </CollectionView.ItemTemplate>
+</CollectionView>
+
+</pages:BasePage>
diff --git a/samples/XCT.Sample/Pages/TestCases/TouchEffectCollectionViewPage.xaml.cs b/samples/XCT.Sample/Pages/TestCases/TouchEffectCollectionViewPage.xaml.cs
new file mode 100644
index 000000000..ada32eb11
--- /dev/null
+++ b/samples/XCT.Sample/Pages/TestCases/TouchEffectCollectionViewPage.xaml.cs
@@ -0,0 +1,19 @@
+
+using System.Windows.Input;
+using Xamarin.Forms;
+
+namespace Xamarin.CommunityToolkit.Sample.Pages.TestCases
+{
+	public partial class TouchEffectCollectionViewPage
+	{
+		ICommand longPressCommand;
+
+		public TouchEffectCollectionViewPage()
+			=> InitializeComponent();
+
+		public ICommand LongPressCommand => longPressCommand ??= new Command(() =>
+		{
+			this.DisplayAlert("Long Press", null, "OK");
+		});
+	}
+}
diff --git a/samples/XCT.Sample/Pages/Views/SideMenuViewPage.xaml b/samples/XCT.Sample/Pages/Views/SideMenuViewPage.xaml
index 8e46bf770..ae62efc38 100644
--- a/samples/XCT.Sample/Pages/Views/SideMenuViewPage.xaml
+++ b/samples/XCT.Sample/Pages/Views/SideMenuViewPage.xaml
@@ -16,29 +16,32 @@
 
     <xct:SideMenuView x:Name="SideMenuView">
         <!-- MainView -->
-        <StackLayout
-            Orientation="Horizontal"
-            BackgroundColor="Gold">
+        <StackLayout BackgroundColor="Gold">
+            <StackLayout
+                Orientation="Horizontal">
 
-            <Button Style="{StaticResource BaseMenuButtonStyle}"
-                    Clicked="OnLeftButtonClicked" />
+                <Button Style="{StaticResource BaseMenuButtonStyle}"
+                        Clicked="OnLeftButtonClicked" />
 
-            <Button Style="{StaticResource BaseMenuButtonStyle}"
-                    HorizontalOptions="EndAndExpand"
-                    Clicked="OnRightButtonClicked" />
+                <Button Style="{StaticResource BaseMenuButtonStyle}"
+                        HorizontalOptions="EndAndExpand"
+                        Clicked="OnRightButtonClicked" />
+
+            </StackLayout>
+            <Slider />
         </StackLayout>
 
         <!-- LeftMenu -->
         <BoxView
-            BackgroundColor="Orange"
             xct:SideMenuView.Position="LeftMenu"
-            xct:SideMenuView.MenuWidthPercentage=".5" />
+            xct:SideMenuView.MenuWidthPercentage=".5"
+            BackgroundColor="Orange"/>
 
         <!-- RightMenu -->
         <BoxView
-            BackgroundColor="LightGreen"
             xct:SideMenuView.Position="RightMenu"
-            xct:SideMenuView.MenuWidthPercentage=".3" />
+            xct:SideMenuView.MenuWidthPercentage=".3"
+            BackgroundColor="LightGreen" />
 
     </xct:SideMenuView>
 
diff --git a/samples/XCT.Sample/ViewModels/TestCases/TestCasesGalleryViewModel.cs b/samples/XCT.Sample/ViewModels/TestCases/TestCasesGalleryViewModel.cs
index 9e894109c..8ff86fc02 100644
--- a/samples/XCT.Sample/ViewModels/TestCases/TestCasesGalleryViewModel.cs
+++ b/samples/XCT.Sample/ViewModels/TestCases/TestCasesGalleryViewModel.cs
@@ -13,6 +13,11 @@ public class TestCasesGalleryViewModel : BaseGalleryViewModel
 				"TouchEffect + Button",
 				"TouchEffect must automatically invoke button'c command execution."),
 
+			new SectionModel(
+				typeof(TouchEffectCollectionViewPage),
+				"TouchEffect + CollectionView",
+				"Using TouchEffect's LongPress should allow still use items selection."),
+
 			new SectionModel(
 				typeof(MediaElementSourcePage),
 				"MediaElement with Source as string",
diff --git a/samples/XCT.Sample/ViewModels/Views/ViewsGalleryViewModel.cs b/samples/XCT.Sample/ViewModels/Views/ViewsGalleryViewModel.cs
index 9a95a3bc8..72caebe65 100644
--- a/samples/XCT.Sample/ViewModels/Views/ViewsGalleryViewModel.cs
+++ b/samples/XCT.Sample/ViewModels/Views/ViewsGalleryViewModel.cs
@@ -12,7 +12,7 @@ public class ViewsGalleryViewModel : BaseGalleryViewModel
 				"The AvatarView represents a user's name by using the initials and a generated background color"),
 
 			new SectionModel(typeof(BadgeViewPage), "BadgeView",
-				"View used to used to notify users notifications, or status of something"),
+				"View used to notify users notifications, or status of something"),
 
 			new SectionModel(typeof(CameraViewPage), "CameraView",
 				"The CameraView allows you to show a live preview from the camera. You can take pictures, record videos and much more!"),
@@ -54,4 +54,4 @@ public class ViewsGalleryViewModel : BaseGalleryViewModel
 				"The popup control renders native popups from the shared code. This page demonstrates a variety of different techniques for displaying native popups.")
 		};
 	}
-}
\ No newline at end of file
+}
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/AsyncCommandTests/AsyncCommand_Tests.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/AsyncCommandTests/AsyncCommand_Tests.cs
index f2bb18211..63cbe4e0c 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/AsyncCommandTests/AsyncCommand_Tests.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/AsyncCommandTests/AsyncCommand_Tests.cs
@@ -162,7 +162,7 @@ public void AsyncCommand_NoParameter_NoCanExecute_Test()
 		}
 
 		[Fact]
-		public void AsyncCommand_RaiseCanExecuteChanged_Test()
+		public void AsyncCommand_RaiseCanExecuteChanged_MainThreadCreation_MainThreadExecution_Test()
 		{
 			// Arrange
 			var canCommandExecute = false;
@@ -193,9 +193,117 @@ public void AsyncCommand_RaiseCanExecuteChanged_Test()
 		}
 
 		[Fact]
-		public void AsyncCommand_ChangeCanExecute_Test()
+		public Task AsyncCommand_RaiseCanExecuteChanged_BackgroundThreadCreation_BackgroundThreadExecution_Test() => Task.Run(async () =>
 		{
 			// Arrange
+			await Task.Delay(100).ConfigureAwait(false);
+
+			var canCommandExecute = false;
+			var didCanExecuteChangeFire = false;
+
+			var command = new AsyncCommand(NoParameterTask, commandCanExecute);
+			command.CanExecuteChanged += handleCanExecuteChanged;
+
+			bool commandCanExecute(object parameter) => canCommandExecute;
+
+			Assert.False(command.CanExecute(null));
+
+			// Act
+			canCommandExecute = true;
+
+			// Assert
+			Assert.True(command.CanExecute(null));
+			Assert.False(didCanExecuteChangeFire);
+
+			// Act
+			command.RaiseCanExecuteChanged();
+
+			// Assert
+			Assert.True(didCanExecuteChangeFire);
+			Assert.True(command.CanExecute(null));
+
+			void handleCanExecuteChanged(object sender, EventArgs e) => didCanExecuteChangeFire = true;
+		});
+
+		[Fact]
+		public async Task AsyncCommand_RaiseCanExecuteChanged_MainThreadCreation_BackgroundThreadExecution_Test()
+		{
+			// Arrange
+
+			var canCommandExecute = false;
+			var didCanExecuteChangeFire = false;
+
+			var command = new AsyncCommand(NoParameterTask, commandCanExecute);
+			command.CanExecuteChanged += handleCanExecuteChanged;
+
+			bool commandCanExecute(object parameter) => canCommandExecute;
+
+			Assert.False(command.CanExecute(null));
+
+			// Act
+			canCommandExecute = true;
+
+			// Assert
+			Assert.True(command.CanExecute(null));
+			Assert.False(didCanExecuteChangeFire);
+
+			// Act
+			await Task.Run(async () =>
+			{
+				await Task.Delay(100).ConfigureAwait(false);
+				command.RaiseCanExecuteChanged();
+
+				// Assert
+				Assert.True(didCanExecuteChangeFire);
+				Assert.True(command.CanExecute(null));
+			});
+
+			void handleCanExecuteChanged(object sender, EventArgs e) => didCanExecuteChangeFire = true;
+		}
+
+		[Fact]
+		public async Task AsyncCommand_RaiseCanExecuteChanged_BackgroundThreadCreation_MainThreadExecution_Test()
+		{
+			// Arrange
+			AsyncCommand command = null;
+			var didCanExecuteChangeFire = false;
+			var canCommandExecute = false;
+
+			await Task.Run(async () =>
+			{
+				await Task.Delay(100).ConfigureAwait(false);
+
+				command = new AsyncCommand(NoParameterTask, commandCanExecute);
+				command.CanExecuteChanged += handleCanExecuteChanged;
+
+				bool commandCanExecute(object parameter) => canCommandExecute;
+
+				Assert.False(command.CanExecute(null));
+
+				// Act
+				canCommandExecute = true;
+
+				// Assert
+				Assert.True(command.CanExecute(null));
+				Assert.False(didCanExecuteChangeFire);
+			}).ConfigureAwait(true);
+
+			// Act
+			command.RaiseCanExecuteChanged();
+
+			// Assert
+			Assert.True(didCanExecuteChangeFire);
+			Assert.True(command.CanExecute(null));
+
+			void handleCanExecuteChanged(object sender, EventArgs e) => didCanExecuteChangeFire = true;
+		}
+
+		[Fact]
+		public async Task AsyncCommand_ChangeCanExecute_Test()
+		{
+			// Arrange
+			var canExecuteChangedTCS = new TaskCompletionSource<object>();
+
 			var canCommandExecute = false;
 			var didCanExecuteChangeFire = false;
 
@@ -216,13 +324,18 @@ public void AsyncCommand_ChangeCanExecute_Test()
 			// Act
 #pragma warning disable CS0618 // Type or member is obsolete
 			command.ChangeCanExecute();
+			await canExecuteChangedTCS.Task;
 #pragma warning restore CS0618 // Type or member is obsolete
 
 			// Assert
 			Assert.True(didCanExecuteChangeFire);
 			Assert.True(command.CanExecute(null));
 
-			void handleCanExecuteChanged(object sender, EventArgs e) => didCanExecuteChangeFire = true;
+			void handleCanExecuteChanged(object sender, EventArgs e)
+			{
+				didCanExecuteChangeFire = true;
+				canExecuteChangedTCS.SetResult(null);
+			}
 		}
 
 		[Fact]
@@ -257,6 +370,8 @@ public async Task AsyncCommand_CanExecuteChanged_AllowsMultipleExecutions_Test()
 		public async Task AsyncCommand_CanExecuteChanged_DoesNotAllowMultipleExecutions_Test()
 		{
 			// Arrange
+			var canExecuteChangedGreaterThan1TCS = new TaskCompletionSource<object>();
+
 			var canExecuteChangedCount = 0;
 
 			var command = new AsyncCommand<int>(IntParameterTask, allowsMultipleExecutions: false);
@@ -273,12 +388,17 @@ public async Task AsyncCommand_CanExecuteChanged_DoesNotAllowMultipleExecutions_
 
 			// Act
 			await asyncCommandTask;
+			await canExecuteChangedGreaterThan1TCS.Task;
 
 			// Assert
 			Assert.True(command.CanExecute(null));
 			Assert.Equal(2, canExecuteChangedCount);
 
-			void handleCanExecuteChanged(object sender, EventArgs e) => canExecuteChangedCount++;
+			void handleCanExecuteChanged(object sender, EventArgs e)
+			{
+				if (++canExecuteChangedCount > 1)
+					canExecuteChangedGreaterThan1TCS.SetResult(null);
+			}
 		}
 	}
 }
\ No newline at end of file
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/AsyncValueCommandTests/AsyncValueCommand_Tests.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/AsyncValueCommandTests/AsyncValueCommand_Tests.cs
index 2650c7116..152aed39e 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/AsyncValueCommandTests/AsyncValueCommand_Tests.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit.UnitTests/ObjectModel/ICommandTests/AsyncValueCommandTests/AsyncValueCommand_Tests.cs
@@ -185,9 +185,11 @@ public void AsyncValueCommandNoParameter_NoCanExecute_Test()
 		}
 
 		[Fact]
-		public void AsyncValueCommand_RaiseCanExecuteChanged_Test()
+		public async Task AsyncValueCommand_RaiseCanExecuteChanged_Test()
 		{
 			// Arrange
+			var handleCanExecuteChangedTCS = new TaskCompletionSource<object>();
+
 			var canCommandExecute = false;
 			var didCanExecuteChangeFire = false;
 
@@ -207,18 +209,25 @@ public void AsyncValueCommand_RaiseCanExecuteChanged_Test()
 
 			// Act
 			command.RaiseCanExecuteChanged();
+			await handleCanExecuteChangedTCS.Task;
 
 			// Assert
 			Assert.True(didCanExecuteChangeFire);
 			Assert.True(command.CanExecute(null));
 
-			void handleCanExecuteChanged(object sender, EventArgs e) => didCanExecuteChangeFire = true;
+			void handleCanExecuteChanged(object sender, EventArgs e)
+			{
+				didCanExecuteChangeFire = true;
+				handleCanExecuteChangedTCS.SetResult(null);
+			}
 		}
 
 		[Fact]
-		public void AsyncValueCommand_ChangeCanExecute_Test()
+		public async Task AsyncValueCommand_ChangeCanExecute_Test()
 		{
 			// Arrange
+			var handleCanExecuteChangedTCS = new TaskCompletionSource<object>();
+
 			var canCommandExecute = false;
 			var didCanExecuteChangeFire = false;
 
@@ -239,13 +248,18 @@ public void AsyncValueCommand_ChangeCanExecute_Test()
 			// Act
 #pragma warning disable CS0618 // Type or member is obsolete
 			command.ChangeCanExecute();
+			await handleCanExecuteChangedTCS.Task;
 #pragma warning restore CS0618 // Type or member is obsolete
 
 			// Assert
 			Assert.True(didCanExecuteChangeFire);
 			Assert.True(command.CanExecute(null));
 
-			void handleCanExecuteChanged(object sender, EventArgs e) => didCanExecuteChangeFire = true;
+			void handleCanExecuteChanged(object sender, EventArgs e)
+			{
+				didCanExecuteChangeFire = true;
+				handleCanExecuteChangedTCS.SetResult(null);
+			}
 		}
 
 		[Fact]
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/BaseBehavior.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/BaseBehavior.shared.cs
index adbbfd100..c331fb17a 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/BaseBehavior.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/BaseBehavior.shared.cs
@@ -5,6 +5,10 @@
 
 namespace Xamarin.CommunityToolkit.Behaviors.Internals
 {
+	/// <summary>
+	/// Abstract class for our behaviors to inherit.
+	/// </summary>
+	/// <typeparam name="TView">The <see cref="VisualElement"/> that the behavior can be applied to</typeparam>
 	public abstract class BaseBehavior<TView> : Behavior<TView> where TView : VisualElement
 	{
 		static readonly MethodInfo getContextMethod
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/EventToCommandBehavior.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/EventToCommandBehavior.shared.cs
index 687c362a3..0505d0c38 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/EventToCommandBehavior.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/EventToCommandBehavior.shared.cs
@@ -7,17 +7,32 @@
 
 namespace Xamarin.CommunityToolkit.Behaviors
 {
+	/// <summary>
+	/// The <see cref="EventToCommandBehavior"/> is a behavior that allows the user to invoke a <see cref="ICommand"/> through an event. It is designed to associate Commands to events exposed by controls that were not designed to support Commands. It allows you to map any arbitrary event on a control to a Command.
+	/// </summary>
 	public class EventToCommandBehavior : BaseBehavior<VisualElement>
 	{
+		/// <summary>
+		/// Backing BindableProperty for the <see cref="EventName"/> property.
+		/// </summary>
 		public static readonly BindableProperty EventNameProperty =
 			BindableProperty.Create(nameof(EventName), typeof(string), typeof(EventToCommandBehavior), propertyChanged: OnEventNamePropertyChanged);
 
+		/// <summary>
+		/// Backing BindableProperty for the <see cref="Command"/> property.
+		/// </summary>
 		public static readonly BindableProperty CommandProperty =
 			BindableProperty.Create(nameof(Command), typeof(ICommand), typeof(EventToCommandBehavior));
 
+		/// <summary>
+		/// Backing BindableProperty for the <see cref="CommandParameter"/> property.
+		/// </summary>
 		public static readonly BindableProperty CommandParameterProperty =
 			BindableProperty.Create(nameof(CommandParameter), typeof(object), typeof(EventToCommandBehavior));
 
+		/// <summary>
+		/// Backing BindableProperty for the <see cref="EventArgs"/> property.
+		/// </summary>
 		public static readonly BindableProperty EventArgsConverterProperty =
 			BindableProperty.Create(nameof(EventArgsConverter), typeof(IValueConverter), typeof(EventToCommandBehavior));
 
@@ -27,24 +42,36 @@ public class EventToCommandBehavior : BaseBehavior<VisualElement>
 
 		EventInfo eventInfo;
 
+		/// <summary>
+		/// The name of the event that should be associated with <see cref="Command"/>. This is bindable property.
+		/// </summary>
 		public string EventName
 		{
 			get => (string)GetValue(EventNameProperty);
 			set => SetValue(EventNameProperty, value);
 		}
 
+		/// <summary>
+		/// The Command that should be executed when the event configured with <see cref="EventName"/> is triggered. This is a bindable property.
+		/// </summary>
 		public ICommand Command
 		{
 			get => (ICommand)GetValue(CommandProperty);
 			set => SetValue(CommandProperty, value);
 		}
 
+		/// <summary>
+		/// An optional parameter to forward to the <see cref="Command"/>. This is a bindable property.
+		/// </summary>
 		public object CommandParameter
 		{
 			get => GetValue(CommandParameterProperty);
 			set => SetValue(CommandParameterProperty, value);
 		}
 
+		/// <summary>
+		/// An optional <see cref="IValueConverter"/> that can be used to convert <see cref="EventArgs"/> values, associated with the event configured with <see cref="EventName"/>, to values passed into the <see cref="Command"/>. This is a bindable property.
+		/// </summary>
 		public IValueConverter EventArgsConverter
 		{
 			get => (IValueConverter)GetValue(EventArgsConverterProperty);
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/ImpliedOrderGridBehavior.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/ImpliedOrderGridBehavior.shared.cs
index 288117b0e..ec40e4082 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/ImpliedOrderGridBehavior.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/ImpliedOrderGridBehavior.shared.cs
@@ -6,12 +6,18 @@
 
 namespace Xamarin.CommunityToolkit.Behaviors
 {
+	/// <summary>
+	/// The <see cref="ImpliedOrderGridBehavior"/> enables you to automatically assign a <see cref="Grid"/> row and column to a view based on the order the view is added to the <see cref="Grid"/>. You only need to setup the row and column definitions and then add children to the <see cref="Grid"/>. You may still assign RowSpan and ColumnSpan to views and their values will be taken into account when assigning a row and column to a view. If a view has a user defined row or column value it will be honored.
+	/// </summary>
 	public class ImpliedOrderGridBehavior : BaseBehavior<Grid>
 	{
 		bool[][] usedMatrix;
 		int rowCount;
 		int columnCount;
 
+		/// <summary>
+		/// When set to true, warnings will throw an exception instead of being logged. Defaults to false.
+		/// </summary>
 		public bool ThrowOnLayoutWarning { get; set; }
 
 		protected override void OnAttachedTo(Grid bindable)
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/MaskedBehavior.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/MaskedBehavior.shared.cs
index a9640f840..9addd051c 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/MaskedBehavior.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/MaskedBehavior.shared.cs
@@ -6,11 +6,20 @@
 
 namespace Xamarin.CommunityToolkit.Behaviors
 {
+	/// <summary>
+	/// The MaskedBehavior is a behavior that allows the user to define an input mask for data entry. Adding this behavior to an <see cref="InputView"/> (i.e. <see cref="Entry"/>) control will force the user to only input values matching a given mask. Examples of its usage include input of a credit card number or a phone number.
+	/// </summary>
 	public class MaskedBehavior : BaseBehavior<InputView>
 	{
+		/// <summary>
+		/// Backing BindableProperty for the <see cref="Mask"/> property.
+		/// </summary>
 		public static readonly BindableProperty MaskProperty =
 			BindableProperty.Create(nameof(Mask), typeof(string), typeof(MaskedBehavior), propertyChanged: OnMaskPropertyChanged);
 
+		/// <summary>
+		/// Backing BindableProperty for the <see cref="UnMaskedCharacter"/> property.
+		/// </summary>
 		public static readonly BindableProperty UnMaskedCharacterProperty =
 			BindableProperty.Create(nameof(UnMaskedCharacter), typeof(char), typeof(MaskedBehavior), 'X', propertyChanged: OnUnMaskedCharacterPropertyChanged);
 
@@ -18,12 +27,18 @@ public class MaskedBehavior : BaseBehavior<InputView>
 
 		bool applyingMask;
 
+		/// <summary>
+		/// The mask that the input value needs to match. This is a bindable property.
+		/// </summary>
 		public string Mask
 		{
 			get => (string)GetValue(MaskProperty);
 			set => SetValue(MaskProperty, value);
 		}
 
+		/// <summary>
+		/// The placeholder character for when no input has been given yet. This is a bindable property.
+		/// </summary>
 		public char UnMaskedCharacter
 		{
 			get => (char)GetValue(UnMaskedCharacterProperty);
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/MaxLengthReachedBehavior.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/MaxLengthReachedBehavior.shared.cs
index 0133c6d67..11a993787 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/MaxLengthReachedBehavior.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/MaxLengthReachedBehavior.shared.cs
@@ -7,20 +7,35 @@
 
 namespace Xamarin.CommunityToolkit.Behaviors
 {
+	/// <summary>
+	/// The <see cref="MaxLengthReachedBehavior"/> is a behavior that allows the user to trigger an action when a user has reached the maximum length allowed on an <see cref="InputView"/>. It can either trigger a <see cref="ICommand"/> or an event depending on the user's preferred scenario.
+	/// </summary>
 	public class MaxLengthReachedBehavior : BaseBehavior<InputView>
 	{
+		/// <summary>
+		/// Backing BindableProperty for the <see cref="Command"/> property.
+		/// </summary>
 		public static readonly BindableProperty CommandProperty
 			= BindableProperty.Create(nameof(Command), typeof(ICommand), typeof(MaxLengthReachedBehavior));
 
+		/// <summary>
+		/// Command that is triggered when the value configured in <see cref="InputView.MaxLength" /> is reached. Both the <see cref="MaxLengthReached"/> event and this command are triggered. This is a bindable property.
+		/// </summary>
 		public ICommand Command
 		{
 			get => (ICommand)GetValue(CommandProperty);
 			set => SetValue(CommandProperty, value);
 		}
 
+		/// <summary>
+		/// Backing BindableProperty for the <see cref="ShouldDismissKeyboardAutomatically"/> property.
+		/// </summary>
 		public static readonly BindableProperty ShouldDismissKeyboardAutomaticallyProperty
 			= BindableProperty.Create(nameof(ShouldDismissKeyboardAutomatically), typeof(bool), typeof(MaxLengthReachedBehavior), false);
 
+		/// <summary>
+		/// Indicates whether or not the keyboard should be dismissed automatically after the maximum length is reached. This is a bindable property.
+		/// </summary>
 		public bool ShouldDismissKeyboardAutomatically
 		{
 			get => (bool)GetValue(ShouldDismissKeyboardAutomaticallyProperty);
@@ -29,6 +44,9 @@ public bool ShouldDismissKeyboardAutomatically
 
 		readonly WeakEventManager<MaxLengthReachedEventArgs> maxLengthReachedEventManager = new WeakEventManager<MaxLengthReachedEventArgs>();
 
+		/// <summary>
+		/// Event that is triggered when the value configured in <see cref="InputView.MaxLength" /> is reached. Both the <see cref="Command"/> and this event are triggered. This is a bindable property.
+		/// </summary>
 		public event EventHandler<MaxLengthReachedEventArgs> MaxLengthReached
 		{
 			add => maxLengthReachedEventManager.AddEventHandler(value);
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/MaxLengthReachedEventArgs.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/MaxLengthReachedEventArgs.shared.cs
index 3734d6e7a..7cdd68bb2 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/MaxLengthReachedEventArgs.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/MaxLengthReachedEventArgs.shared.cs
@@ -2,10 +2,20 @@
 
 namespace Xamarin.CommunityToolkit.Behaviors
 {
+	/// <summary>
+	/// Container object for the event arguments that are provided when the <see cref="MaxLengthReachedBehavior.MaxLengthReached"/> event is triggered.
+	/// </summary>
 	public class MaxLengthReachedEventArgs : EventArgs
 	{
+		/// <summary>
+		/// The new text value as determined by the <see cref="MaxLengthReachedBehavior"/>
+		/// </summary>
 		public string Text { get; }
 
+		/// <summary>
+		/// Constructor to create a new instance of <see cref="MaxLengthReachedEventArgs"/>.
+		/// </summary>
+		/// <param name="text">The new text value as determined by the <see cref="MaxLengthReachedBehavior"/></param>
 		public MaxLengthReachedEventArgs(string text)
 			=> Text = text;
 	}
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/Validators/CharacterType.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/Validators/CharacterType.shared.cs
index 25dbbdf9a..e60806a8d 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/Validators/CharacterType.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/Validators/CharacterType.shared.cs
@@ -2,19 +2,43 @@
 
 namespace Xamarin.CommunityToolkit.Behaviors
 {
+	/// <summary>
+	/// The allowed character types used to determine if a value is valid in the <see cref="CharactersValidationBehavior"/>. Since this is a flag, multiple flags cane be combined.
+	/// </summary>
 	[Flags]
 	public enum CharacterType
 	{
+		/// <summary>Lowercase characters are allowed.</summary>
 		LowercaseLetter = 1,
+
+		/// <summary>Uppercase characters are allowed.</summary>
 		UppercaseLetter = 2,
+
+		/// <summary>Either lowercase characters or uppercase characters are allowed.</summary>
 		Letter = LowercaseLetter | UppercaseLetter,
+
+		/// <summary>Digits are allowed.</summary>
 		Digit = 4,
+
+		/// <summary>Characters and digits are allowed.</summary>
 		Alphanumeric = Letter | Digit,
+
+		/// <summary>Whitespace is allowed.</summary>
 		Whitespace = 8,
+
+		/// <summary>Non-alphanumeric symbols are allowed.</summary>
 		NonAlphanumericSymbol = 16,
+
+		/// <summary>Lowercase latin characters are allowed.</summary>
 		LowercaseLatinLetter = 32,
+
+		/// <summary>Uppercase latin characters are allowed.</summary>
 		UppercaseLatinLetter = 64,
+
+		/// <summary>Either latin lowercase characters or latin uppercase characters are allowed.</summary>
 		LatinLetter = LowercaseLatinLetter | UppercaseLatinLetter,
+
+		/// <summary>Any type of character or digit either lowercase or uppercase, latin or non-latin is allowed.</summary>
 		Any = Alphanumeric | NonAlphanumericSymbol | Whitespace
 	}
 }
\ No newline at end of file
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/Validators/CharactersValidationBehavior.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/Validators/CharactersValidationBehavior.shared.cs
index 2b98a02c5..b4a78fcb1 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/Validators/CharactersValidationBehavior.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/Validators/CharactersValidationBehavior.shared.cs
@@ -5,34 +5,58 @@
 
 namespace Xamarin.CommunityToolkit.Behaviors
 {
+	/// <summary>
+	/// The <see cref="CharactersValidationBehavior"/> is a behavior that allows the user to validate text input depending on specified parameters.For example, an <see cref="Entry"/> control can be styled differently depending on whether a valid or an invalid text value is provided. This behavior includes built-in checks such as checking for a certain number of digits or alphanumeric characters. Additional properties handling validation are inherited from <see cref="Internals.ValidationBehavior"/>.
+	/// </summary>
 	public class CharactersValidationBehavior : TextValidationBehavior
 	{
 		List<Predicate<char>> characterPredicates;
 
+		/// <summary>
+		/// Backing BindableProperty for the <see cref="CharacterType"/> property.
+		/// </summary>
 		public static readonly BindableProperty CharacterTypeProperty =
 			BindableProperty.Create(nameof(CharacterType), typeof(CharacterType), typeof(CharactersValidationBehavior), CharacterType.Any, propertyChanged: OnCharacterTypePropertyChanged);
 
+		/// <summary>
+		/// Backing BindableProperty for the <see cref="MinimumCharacterCount"/> property.
+		/// </summary>
 		public static readonly BindableProperty MinimumCharacterCountProperty =
 			BindableProperty.Create(nameof(MinimumCharacterCount), typeof(int), typeof(CharactersValidationBehavior), 0, propertyChanged: OnValidationPropertyChanged);
 
+		/// <summary>
+		/// Backing BindableProperty for the <see cref="MaximumCharacterCount"/> property.
+		/// </summary>
 		public static readonly BindableProperty MaximumCharacterCountProperty =
 			BindableProperty.Create(nameof(MaximumCharacterCount), typeof(int), typeof(CharactersValidationBehavior), int.MaxValue, propertyChanged: OnValidationPropertyChanged);
 
+		/// <summary>
+		/// Constructor for this behavior
+		/// </summary>
 		public CharactersValidationBehavior()
 			=> OnCharacterTypePropertyChanged();
 
+		/// <summary>
+		/// Provides an enumerated value to use to set how to handle comparisons. This is a bindable property.
+		/// </summary>
 		public CharacterType CharacterType
 		{
 			get => (CharacterType)GetValue(CharacterTypeProperty);
 			set => SetValue(CharacterTypeProperty, value);
 		}
 
+		/// <summary>
+		/// The minimum length of the text input that's allowed. This is a bindable property.
+		/// </summary>
 		public int MinimumCharacterCount
 		{
 			get => (int)GetValue(MinimumCharacterCountProperty);
 			set => SetValue(MinimumCharacterCountProperty, value);
 		}
 
+		/// <summary>
+		/// The maximum length of the text input that's allowed. This is a bindable property.
+		/// </summary>
 		public int MaximumCharacterCount
 		{
 			get => (int)GetValue(MaximumCharacterCountProperty);
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/Validators/EmailValidationBehavior.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/Validators/EmailValidationBehavior.shared.cs
index eb71a5849..fbf89afb3 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/Validators/EmailValidationBehavior.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/Validators/EmailValidationBehavior.shared.cs
@@ -6,6 +6,9 @@
 
 namespace Xamarin.CommunityToolkit.Behaviors
 {
+	/// <summary>
+	/// The <see cref="EmailValidationBehavior"/> is a behavior that allows users to determine whether or not text input is a valid e-mail address. For example, an <see cref="Forms.Entry"/> control can be styled differently depending on whether a valid or an invalid e-mail address is provided. The validation is achieved through a regular expression that is used to verify whether or not the text input is a valid e-mail address. It can be overridden to customize the validation through the properties it inherits from <see cref="Internals.ValidationBehavior"/>.
+	/// </summary>
 	public class EmailValidationBehavior : TextValidationBehavior
 	{
 #if !NETSTANDARD1_0
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/Validators/MultiValidationBehavior.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/Validators/MultiValidationBehavior.shared.cs
index d304407a8..86bd43892 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/Validators/MultiValidationBehavior.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/Validators/MultiValidationBehavior.shared.cs
@@ -7,9 +7,15 @@
 
 namespace Xamarin.CommunityToolkit.Behaviors
 {
+	/// <summary>
+	/// The <see cref="MultiValidationBehavior"/> is a behavior that allows the user to combine multiple validators to validate text input depending on specified parameters. For example, an <see cref="Entry"/> control can be styled differently depending on whether a valid or an invalid text input is provided. By allowing the user to chain multiple existing validators together, it offers a high degree of customizability when it comes to validation. Additional properties handling validation are inherited from <see cref="ValidationBehavior"/>.
+	/// </summary>
 	[ContentProperty(nameof(Children))]
 	public class MultiValidationBehavior : ValidationBehavior
 	{
+		/// <summary>
+		/// Backing BindableProperty for the <see cref="Errors"/> property.
+		/// </summary>
 		public static readonly BindableProperty ErrorsProperty =
 			BindableProperty.Create(nameof(Errors), typeof(List<object>), typeof(MultiValidationBehavior), null, BindingMode.OneWayToSource);
 
@@ -19,21 +25,40 @@ public class MultiValidationBehavior : ValidationBehavior
 		readonly ObservableCollection<ValidationBehavior> children
 			= new ObservableCollection<ValidationBehavior>();
 
+		/// <summary>
+		/// Constructor for this behavior.
+		/// </summary>
 		public MultiValidationBehavior()
 			=> children.CollectionChanged += OnChildrenCollectionChanged;
 
+		/// <summary>
+		/// Holds the errors from all of the nested invalid validators in <see cref="Children"/>. This is a bindable property.
+		/// </summary>
 		public List<object> Errors
 		{
 			get => (List<object>)GetValue(ErrorsProperty);
 			set => SetValue(ErrorsProperty, value);
 		}
 
+		/// <summary>
+		/// All child behaviors that are part of this <see cref="MultiValidationBehavior"/>. This is a bindable property.
+		/// </summary>
 		public IList<ValidationBehavior> Children
 			=> children;
 
+		/// <summary>
+		/// Method to extract the error from the attached property for a child behavior in <see cref="Children"/>.
+		/// </summary>
+		/// <param name="bindable">The <see cref="ValidationBehavior"/> that we extract the attached Error property</param>
+		/// <returns>Object containing error information</returns>
 		public static object GetError(BindableObject bindable)
 			=> bindable.GetValue(ErrorProperty);
 
+		/// <summary>
+		/// Method to set the error on the attached property for a child behavior in <see cref="Children"/>.
+		/// </summary>
+		/// <param name="bindable">The <see cref="ValidationBehavior"/> on which we set the attached Error property value</param>
+		/// <param name="value">The value to set</param>
 		public static void SetError(BindableObject bindable, object value)
 			=> bindable.SetValue(ErrorProperty, value);
 
@@ -43,7 +68,7 @@ protected override bool Validate(object value)
 			{
 				c.Value = value;
 				c.ForceValidate();
-				return !c.IsValid;
+				return c.IsNotValid;
 			}).Select(c => GetError(c));
 
 			if (!errors.Any())
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/Validators/NumericValidationBehavior.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/Validators/NumericValidationBehavior.shared.cs
index af0d6124d..c182c6b29 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/Validators/NumericValidationBehavior.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/Validators/NumericValidationBehavior.shared.cs
@@ -4,38 +4,65 @@
 
 namespace Xamarin.CommunityToolkit.Behaviors
 {
+	/// <summary>
+	/// The <see cref="NumericValidationBehavior"/> is a behavior that allows the user to determine if text input is a valid numeric value. For example, an <see cref="Entry"/> control can be styled differently depending on whether a valid or an invalid numeric input is provided. Additional properties handling validation are inherited from <see cref="ValidationBehavior"/>.
+	/// </summary>
 	public class NumericValidationBehavior : ValidationBehavior
 	{
+		/// <summary>
+		/// Backing BindableProperty for the <see cref="MinimumValue"/> property.
+		/// </summary>
 		public static readonly BindableProperty MinimumValueProperty =
 			BindableProperty.Create(nameof(MinimumValue), typeof(double), typeof(NumericValidationBehavior), double.NegativeInfinity, propertyChanged: OnValidationPropertyChanged);
 
+		/// <summary>
+		/// Backing BindableProperty for the <see cref="MaximumValue"/> property.
+		/// </summary>
 		public static readonly BindableProperty MaximumValueProperty =
 			BindableProperty.Create(nameof(MaximumValue), typeof(double), typeof(NumericValidationBehavior), double.PositiveInfinity, propertyChanged: OnValidationPropertyChanged);
 
+		/// <summary>
+		/// Backing BindableProperty for the <see cref="MinimumDecimalPlaces"/> property.
+		/// </summary>
 		public static readonly BindableProperty MinimumDecimalPlacesProperty =
 			BindableProperty.Create(nameof(MinimumDecimalPlaces), typeof(int), typeof(NumericValidationBehavior), 0, propertyChanged: OnValidationPropertyChanged);
 
+		/// <summary>
+		/// Backing BindableProperty for the <see cref="MaximumDecimalPlaces"/> property.
+		/// </summary>
 		public static readonly BindableProperty MaximumDecimalPlacesProperty =
 			BindableProperty.Create(nameof(MaximumDecimalPlaces), typeof(int), typeof(NumericValidationBehavior), int.MaxValue, propertyChanged: OnValidationPropertyChanged);
 
+		/// <summary>
+		/// The minimum numeric value that will be allowed. This is a bindable property.
+		/// </summary>
 		public double MinimumValue
 		{
 			get => (double)GetValue(MinimumValueProperty);
 			set => SetValue(MinimumValueProperty, value);
 		}
 
+		/// <summary>
+		/// The maximum numeric value that will be allowed. This is a bindable property.
+		/// </summary>
 		public double MaximumValue
 		{
 			get => (double)GetValue(MaximumValueProperty);
 			set => SetValue(MaximumValueProperty, value);
 		}
 
+		/// <summary>
+		/// The minimum number of decimal places that will be allowed. This is a bindable property.
+		/// </summary>
 		public int MinimumDecimalPlaces
 		{
 			get => (int)GetValue(MinimumDecimalPlacesProperty);
 			set => SetValue(MinimumDecimalPlacesProperty, value);
 		}
 
+		/// <summary>
+		/// The maximum number of decimal places that will be allowed. This is a bindable property.
+		/// </summary>
 		public int MaximumDecimalPlaces
 		{
 			get => (int)GetValue(MaximumDecimalPlacesProperty);
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/Validators/RequiredStringValidationBehavior.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/Validators/RequiredStringValidationBehavior.shared.cs
index d45339a34..c27db20dc 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/Validators/RequiredStringValidationBehavior.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/Validators/RequiredStringValidationBehavior.shared.cs
@@ -3,11 +3,20 @@
 
 namespace Xamarin.CommunityToolkit.Behaviors
 {
+	/// <summary>
+	/// The <see cref="RequiredStringValidationBehavior"/> is a behavior that allows the user to determine if text input is equal to specific text. For example, an <see cref="Entry"/> control can be styled differently depending on whether a valid or an invalid text input is provided. Additional properties handling validation are inherited from <see cref="ValidationBehavior"/>.
+	/// </summary>
 	public class RequiredStringValidationBehavior : ValidationBehavior
 	{
+		/// <summary>
+		/// Backing BindableProperty for the <see cref="RequiredString"/> property.
+		/// </summary>
 		public static readonly BindableProperty RequiredStringProperty
 			= BindableProperty.Create(nameof(RequiredString), typeof(string), typeof(RequiredStringValidationBehavior));
 
+		/// <summary>
+		/// The string that will be compared to the value provided by the user. This is a bindable property.
+		/// </summary>
 		public string RequiredString
 		{
 			get => (string)GetValue(RequiredStringProperty);
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/Validators/TextDecorationFlags.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/Validators/TextDecorationFlags.shared.cs
index e16ddae00..082b75902 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/Validators/TextDecorationFlags.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/Validators/TextDecorationFlags.shared.cs
@@ -2,14 +2,28 @@
 
 namespace Xamarin.CommunityToolkit.Behaviors
 {
+	/// <summary>
+	/// Flags to indicate what treatment <see cref="Internals.ValidationBehavior.Value"/> should receive prior to validation with <see cref="Internals.ValidationBehavior"/> or subclasses. This can be used to trim or ignore whitespace for instance. This value might be ignored by a behavior if <see cref="Internals.ValidationBehavior.Value"/> isn't of type <see cref="string"/>.
+	/// </summary>
 	[Flags]
 	public enum TextDecorationFlags
 	{
+		/// <summary>No text decoration will be applied.</summary>
 		None = 0,
+
+		/// <summary><see cref="string.TrimStart"/> is applied on the value prior to validation.</summary>
 		TrimStart = 1,
+
+		/// <summary><see cref="string.TrimEnd"/> is applied on the value prior to validation.</summary>
 		TrimEnd = 2,
+
+		/// <summary><see cref="string.Trim"/> is applied on the value prior to validation.</summary>
 		Trim = 3,
+
+		/// <summary>If <see cref="Internals.ValidationBehavior.Value"/> is null, replace the value with <see cref="string.Empty"/></summary>
 		NullToEmpty = 4,
+
+		/// <summary>Excessive white space is removed from <see cref="Internals.ValidationBehavior.Value"/> prior to validation. I.e. I.e. "Hello    World" will become "Hello World". This applies to whitespace found anywhere.</summary>
 		NormalizeWhiteSpace = 8
 	}
 }
\ No newline at end of file
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/Validators/TextValidationBehavior.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/Validators/TextValidationBehavior.shared.cs
index ab6bb94c1..552694210 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/Validators/TextValidationBehavior.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/Validators/TextValidationBehavior.shared.cs
@@ -5,59 +5,92 @@
 
 namespace Xamarin.CommunityToolkit.Behaviors
 {
+	/// <summary>
+	/// The <see cref="TextValidationBehavior"/> is a behavior that allows the user to validate a given text depending on specified parameters. By adding this behavior to an <see cref="InputView"/> inherited control (i.e. <see cref="Entry"/>) it can be styled differently depending on whether a valid or an invalid text value is provided. It offers various built-in checks such as checking for a certain length or whether or not the input value matches a specific regular expression. Additional properties handling validation are inherited from <see cref="ValidationBehavior"/>.
+	/// </summary>
 	public class TextValidationBehavior : ValidationBehavior
 	{
+		/// <summary>
+		/// Backing BindableProperty for the <see cref="MinimumLength"/> property.
+		/// </summary>
 		public static readonly BindableProperty MinimumLengthProperty =
 			BindableProperty.Create(nameof(MinimumLength), typeof(int), typeof(TextValidationBehavior), 0, propertyChanged: OnValidationPropertyChanged);
 
+		/// <summary>
+		/// Backing BindableProperty for the <see cref="MaximumLength"/> property.
+		/// </summary>
 		public static readonly BindableProperty MaximumLengthProperty =
 			BindableProperty.Create(nameof(MaximumLength), typeof(int), typeof(TextValidationBehavior), int.MaxValue, propertyChanged: OnValidationPropertyChanged);
 
+		/// <summary>
+		/// Backing BindableProperty for the <see cref="DecorationFlags"/> property.
+		/// </summary>
 		public static readonly BindableProperty DecorationFlagsProperty =
 			BindableProperty.Create(nameof(DecorationFlags), typeof(TextDecorationFlags), typeof(TextValidationBehavior), TextDecorationFlags.None, propertyChanged: OnValidationPropertyChanged);
 
+		/// <summary>
+		/// Backing BindableProperty for the <see cref="RegexPattern"/> property.
+		/// </summary>
 		public static readonly BindableProperty RegexPatternProperty =
 			BindableProperty.Create(nameof(RegexPattern), typeof(string), typeof(TextValidationBehavior), defaultValueCreator: GetDefaultRegexPattern, propertyChanged: OnRegexPropertyChanged);
 
+		/// <summary>
+		/// Backing BindableProperty for the <see cref="RegexOptions"/> property.
+		/// </summary>
 		public static readonly BindableProperty RegexOptionsProperty =
 			BindableProperty.Create(nameof(RegexOptions), typeof(RegexOptions), typeof(TextValidationBehavior), defaultValueCreator: GetDefaultRegexOptions, propertyChanged: OnRegexPropertyChanged);
 
 		Regex regex;
 
+		/// <summary>
+		/// The minimum length of the value that will be allowed. This is a bindable property.
+		/// </summary>
 		public int MinimumLength
 		{
 			get => (int)GetValue(MinimumLengthProperty);
 			set => SetValue(MinimumLengthProperty, value);
 		}
 
+		/// <summary>
+		/// The maximum length of the value that will be allowed. This is a bindable property.
+		/// </summary>
 		public int MaximumLength
 		{
 			get => (int)GetValue(MaximumLengthProperty);
 			set => SetValue(MaximumLengthProperty, value);
 		}
 
+		/// <summary>
+		/// Provides enumerated value to use to set how to handle white spaces. This is a bindable property.
+		/// </summary>
 		public TextDecorationFlags DecorationFlags
 		{
 			get => (TextDecorationFlags)GetValue(DecorationFlagsProperty);
 			set => SetValue(DecorationFlagsProperty, value);
 		}
 
+		/// <summary>
+		/// The regular expression pattern which the value will have to match before it will be allowed. This is a bindable property.
+		/// </summary>
 		public string RegexPattern
 		{
 			get => (string)GetValue(RegexPatternProperty);
 			set => SetValue(RegexPatternProperty, value);
 		}
 
+		/// <summary>
+		/// Provides enumerated values to use to set regular expression options. This is a bindable property.
+		/// </summary>
 		public RegexOptions RegexOptions
 		{
 			get => (RegexOptions)GetValue(RegexOptionsProperty);
 			set => SetValue(RegexOptionsProperty, value);
 		}
 
-		public TextValidationBehavior()
-		{
-			OnRegexPropertyChanged();
-		}
+		/// <summary>
+		/// Constructor of this behavior.
+		/// </summary>
+		public TextValidationBehavior() => OnRegexPropertyChanged();
 
 		protected virtual string DefaultRegexPattern => string.Empty;
 
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/Validators/UriValidationBehavior.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/Validators/UriValidationBehavior.shared.cs
index eb1ed4831..baacfe922 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/Validators/UriValidationBehavior.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/Validators/UriValidationBehavior.shared.cs
@@ -3,11 +3,20 @@
 
 namespace Xamarin.CommunityToolkit.Behaviors
 {
+	/// <summary>
+	/// The <see cref="UriValidationBehavior"/> is a behavior that allows users to determine whether or not text input is a valid URI. For example, an <see cref="Entry"/> control can be styled differently depending on whether a valid or an invalid URI is provided. Additional properties handling validation are inherited from <see cref="Internals.ValidationBehavior"/>.
+	/// </summary>
 	public class UriValidationBehavior : TextValidationBehavior
 	{
+		/// <summary>
+		/// Backing BindableProperty for the <see cref="UriKind"/> property.
+		/// </summary>
 		public static readonly BindableProperty UriKindProperty =
 			BindableProperty.Create(nameof(UriKind), typeof(UriKind), typeof(UriValidationBehavior), UriKind.RelativeOrAbsolute, propertyChanged: OnValidationPropertyChanged);
 
+		/// <summary>
+		/// Provides an enumerated value that specifies how to handle different URI types. This is a bindable property.
+		/// </summary>
 		public UriKind UriKind
 		{
 			get => (UriKind)GetValue(UriKindProperty);
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/Validators/ValidationBehavior.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/Validators/ValidationBehavior.shared.cs
index 43d96c294..4603f95ac 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/Validators/ValidationBehavior.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Behaviors/Validators/ValidationBehavior.shared.cs
@@ -4,26 +4,56 @@
 
 namespace Xamarin.CommunityToolkit.Behaviors.Internals
 {
+	/// <summary>
+	/// The <see cref="ValidationBehavior"/> allows users to create custom validation behaviors. All of the validation behaviors in the Xamarin Community Toolkit inherit from this behavior, to expose a number of shared properties. Users can inherit from this class to create a custom validation behavior currently not supported through the Xamarin Community Toolkit. This behavios cannot be used directly as it's abstract.
+	/// </summary>
 	public abstract class ValidationBehavior : BaseBehavior<VisualElement>
 	{
+		/// <summary>
+		/// Backing BindableProperty for the <see cref="IsNotValid"/> property.
+		/// </summary>
+		public static readonly BindableProperty IsNotValidProperty =
+			BindableProperty.Create(nameof(IsNotValid), typeof(bool), typeof(ValidationBehavior), false, BindingMode.OneWayToSource);
+
+		/// <summary>
+		/// Backing BindableProperty for the <see cref="IsValid"/> property.
+		/// </summary>
 		public static readonly BindableProperty IsValidProperty =
-			BindableProperty.Create(nameof(IsValid), typeof(bool), typeof(ValidationBehavior), true, BindingMode.OneWayToSource);
+			BindableProperty.Create(nameof(IsValid), typeof(bool), typeof(ValidationBehavior), true, BindingMode.OneWayToSource, propertyChanged: OnIsValidPropertyChanged);
 
+		/// <summary>
+		/// Backing BindableProperty for the <see cref="ValidStyle"/> property.
+		/// </summary>
 		public static readonly BindableProperty ValidStyleProperty =
 			BindableProperty.Create(nameof(ValidStyle), typeof(Style), typeof(ValidationBehavior), propertyChanged: OnValidationPropertyChanged);
 
+		/// <summary>
+		/// Backing BindableProperty for the <see cref="InvalidStyle"/> property.
+		/// </summary>
 		public static readonly BindableProperty InvalidStyleProperty =
 			BindableProperty.Create(nameof(InvalidStyle), typeof(Style), typeof(ValidationBehavior), propertyChanged: OnValidationPropertyChanged);
 
+		/// <summary>
+		/// Backing BindableProperty for the <see cref="Flags"/> property.
+		/// </summary>
 		public static readonly BindableProperty FlagsProperty =
 			BindableProperty.Create(nameof(Flags), typeof(ValidationFlags), typeof(ValidationBehavior), ValidationFlags.ValidateOnUnfocusing | ValidationFlags.ForceMakeValidWhenFocused, propertyChanged: OnValidationPropertyChanged);
 
+		/// <summary>
+		/// Backing BindableProperty for the <see cref="Value"/> property.
+		/// </summary>
 		public static readonly BindableProperty ValueProperty =
 			BindableProperty.Create(nameof(Value), typeof(object), typeof(ValidationBehavior), propertyChanged: OnValuePropertyChanged);
 
+		/// <summary>
+		/// Backing BindableProperty for the <see cref="ValuePropertyName"/> property.
+		/// </summary>
 		public static readonly BindableProperty ValuePropertyNameProperty =
 			BindableProperty.Create(nameof(ValuePropertyName), typeof(string), typeof(ValidationBehavior), defaultValueCreator: GetDefaultValuePropertyName, propertyChanged: OnValuePropertyNamePropertyChanged);
 
+		/// <summary>
+		/// Backing BindableProperty for the <see cref="ForceValidateCommand"/> property.
+		/// </summary>
 		public static readonly BindableProperty ForceValidateCommandProperty =
 			BindableProperty.Create(nameof(ForceValidateCommand), typeof(ICommand), typeof(ValidationBehavior), defaultValueCreator: GetDefaultForceValidateCommand, defaultBindingMode: BindingMode.OneWayToSource);
 
@@ -33,42 +63,72 @@ public abstract class ValidationBehavior : BaseBehavior<VisualElement>
 
 		BindingBase defaultValueBinding;
 
+		/// <summary>
+		/// Indicates whether or not the current value is considered valid. This is a bindable property.
+		/// </summary>
 		public bool IsValid
 		{
 			get => (bool)GetValue(IsValidProperty);
 			set => SetValue(IsValidProperty, value);
 		}
 
+		/// <summary>
+		/// Indicates whether or not the current value is considered not valid. This is a bindable property.
+		/// </summary>
+		public bool IsNotValid
+		{
+			get => (bool)GetValue(IsNotValidProperty);
+			set => SetValue(IsNotValidProperty, value);
+		}
+
+		/// <summary>
+		/// The <see cref="Style"/> to apply to the element when validation is successful. This is a bindable property.
+		/// </summary>
 		public Style ValidStyle
 		{
 			get => (Style)GetValue(ValidStyleProperty);
 			set => SetValue(ValidStyleProperty, value);
 		}
 
+		/// <summary>
+		/// The <see cref="Style"/> to apply to the element when validation fails. This is a bindable property.
+		/// </summary>
 		public Style InvalidStyle
 		{
 			get => (Style)GetValue(InvalidStyleProperty);
 			set => SetValue(InvalidStyleProperty, value);
 		}
 
+		/// <summary>
+		/// Provides an enumerated value that specifies how to handle validation. This is a bindable property.
+		/// </summary>
 		public ValidationFlags Flags
 		{
 			get => (ValidationFlags)GetValue(FlagsProperty);
 			set => SetValue(FlagsProperty, value);
 		}
 
+		/// <summary>
+		/// The value to validate. This is a bindable property.
+		/// </summary>
 		public object Value
 		{
 			get => GetValue(ValueProperty);
 			set => SetValue(ValueProperty, value);
 		}
 
+		/// <summary>
+		/// Allows the user to override the property that will be used as the value to validate. This is a bindable property.
+		/// </summary>
 		public string ValuePropertyName
 		{
 			get => (string)GetValue(ValuePropertyNameProperty);
 			set => SetValue(ValuePropertyNameProperty, value);
 		}
 
+		/// <summary>
+		/// Allows the user to provide a custom <see cref="ICommand"/> that handles forcing validation. This is a bindable property.
+		/// </summary>
 		public ICommand ForceValidateCommand
 		{
 			get => (ICommand)GetValue(ForceValidateCommandProperty);
@@ -79,6 +139,9 @@ public ICommand ForceValidateCommand
 
 		protected virtual ICommand DefaultForceValidateCommand => new Command(ForceValidate);
 
+		/// <summary>
+		/// Forces the behavior to make a validation pass.
+		/// </summary>
 		public void ForceValidate() => UpdateState(true);
 
 		protected virtual object DecorateValue() => Value;
@@ -124,6 +187,9 @@ protected override void OnViewPropertyChanged(object sender, PropertyChangedEven
 		protected static void OnValidationPropertyChanged(BindableObject bindable, object oldValue, object newValue)
 			=> ((ValidationBehavior)bindable).UpdateState(false);
 
+		static void OnIsValidPropertyChanged(BindableObject bindable, object oldValue, object newValue)
+			=> ((ValidationBehavior)bindable).OnIsValidPropertyChanged();
+
 		static void OnValuePropertyChanged(BindableObject bindable, object oldValue, object newValue)
 		{
 			((ValidationBehavior)bindable).OnValuePropertyChanged();
@@ -139,6 +205,9 @@ static object GetDefaultForceValidateCommand(BindableObject bindable)
 		static object GetDefaultValuePropertyName(BindableObject bindable)
 			=> ((ValidationBehavior)bindable).DefaultValuePropertyName;
 
+		void OnIsValidPropertyChanged()
+			=> IsNotValid = !IsValid;
+
 		void OnValuePropertyChanged()
 		{
 			if (isAttaching)
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/BoolToObjectConverter.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/BoolToObjectConverter.shared.cs
index 85725537d..3cde18df6 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/BoolToObjectConverter.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/BoolToObjectConverter.shared.cs
@@ -1,6 +1,5 @@
 using System;
 using System.Globalization;
-using Xamarin.CommunityToolkit.Extensions;
 using Xamarin.CommunityToolkit.Extensions.Internals;
 using Xamarin.Forms;
 
@@ -14,7 +13,7 @@ public class BoolToObjectConverter : BoolToObjectConverter<object>
 	}
 
 	/// <summary>
-	/// Converts boolean to object and vice versa.
+	/// Converts <see cref="bool"/> to object and vice versa.
 	/// </summary>
 	public class BoolToObjectConverter<TObject> : ValueConverterExtension, IValueConverter
 	{
@@ -29,13 +28,13 @@ public class BoolToObjectConverter<TObject> : ValueConverterExtension, IValueCon
 		public TObject FalseObject { get; set; }
 
 		/// <summary>
-		/// Converts boolean to object.
+		/// Converts <see cref="bool"/> to object.
 		/// </summary>
 		/// <param name="value">The value to convert.</param>
-		/// <param name="targetType">The type of the binding target property.</param>
-		/// <param name="parameter">Additional parameter for the converter to handle. Not implemented.</param>
-		/// <param name="culture">The culture to use in the converter.</param>
-		/// <returns>TrueObject if value equals True, otherwise FalseObject.</returns>
+		/// <param name="targetType">The type of the binding target property. This is not implemented.</param>
+		/// <param name="parameter">Additional parameter for the converter to handle. This is not implemented.</param>
+		/// <param name="culture">The culture to use in the converter.  This is not implemented.</param>
+		/// <returns>The object assigned to <see cref="TrueObject"/> if value equals True, otherwise the value assigned to <see cref="FalseObject"/>.</returns>
 		public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
 		{
 			if (value is bool result)
@@ -45,13 +44,13 @@ public object Convert(object value, Type targetType, object parameter, CultureIn
 		}
 
 		/// <summary>
-		/// Converts back object to boolean.
+		/// Converts back object to <see cref="bool"/>.
 		/// </summary>
 		/// <param name="value">The value to convert.</param>
-		/// <param name="targetType">The type of the binding target property.</param>
-		/// <param name="parameter">Additional parameter for the converter to handle. Not implemented.</param>
-		/// <param name="culture">The culture to use in the converter.</param>
-		/// <returns>True if value equals TrueObject, otherwise False.</returns>
+		/// <param name="targetType">The type of the binding target property. This is not implemented.</param>
+		/// <param name="parameter">Additional parameter for the converter to handle. This is not implemented.</param>
+		/// <param name="culture">The culture to use in the converter.  This is not implemented.</param>
+		/// <returns>True if value equals <see cref="TrueObject"/>, otherwise False.</returns>
 		public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
 		{
 			if (value is TObject result)
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/ByteArrayToImageSourceConverter.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/ByteArrayToImageSourceConverter.shared.cs
index 9782e2185..e07b6d7cf 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/ByteArrayToImageSourceConverter.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/ByteArrayToImageSourceConverter.shared.cs
@@ -2,25 +2,24 @@
 using System.Globalization;
 using System.IO;
 using System.Threading;
-using Xamarin.CommunityToolkit.Extensions;
 using Xamarin.CommunityToolkit.Extensions.Internals;
 using Xamarin.Forms;
 
 namespace Xamarin.CommunityToolkit.Converters
 {
 	/// <summary>
-	/// Converts the incoming value from byte array and returns the object of a type ImageSource.
+	/// Converts the incoming value from <see cref="byte[]"/> and returns the object of a type <see cref="ImageSource"/> or vice versa.
 	/// </summary>
 	public class ByteArrayToImageSourceConverter : ValueConverterExtension, IValueConverter
 	{
 		/// <summary>
-		/// Converts the incoming value from byte array and returns the object of a type ImageSource.
+		/// Converts the incoming value from <see cref="byte[]"/> and returns the object of a type <see cref="ImageSource"/>.
 		/// </summary>
 		/// <param name="value">The value to convert.</param>
-		/// <param name="targetType">The type of the binding target property.</param>
-		/// <param name="parameter">Additional parameter for the converter to handle. Not implemented.</param>
-		/// <param name="culture">The culture to use in the converter.</param>
-		/// <returns>An object of type ImageSource.</returns>
+		/// <param name="targetType">The type of the binding target property. This is not implemented.</param>
+		/// <param name="parameter">Additional parameter for the converter to handle. This is not implemented.</param>
+		/// <param name="culture">The culture to use in the converter. This is not implemented.</param>
+		/// <returns>An object of type <see cref="ImageSource"/>.</returns>
 		public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
 		{
 			if (value == null)
@@ -32,6 +31,14 @@ public object Convert(object value, Type targetType, object parameter, CultureIn
 			throw new ArgumentException("Expected value to be of type byte[].", nameof(value));
 		}
 
+		/// <summary>
+		/// Converts the incoming value from <see cref="StreamImageSource"/> and returns a <see cref="byte[]"/>.
+		/// </summary>
+		/// <param name="value">The value to convert.</param>
+		/// <param name="targetType">The type of the binding target property. This is not implemented.</param>
+		/// <param name="parameter">Additional parameter for the converter to handle. This is not implemented.</param>
+		/// <param name="culture">The culture to use in the converter. This is not implemented.</param>
+		/// <returns>An object of type <see cref="ImageSource"/>.</returns>
 		public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
 		{
 			if (value == null)
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/DateTimeOffsetConverter.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/DateTimeOffsetConverter.shared.cs
index c8b4cf5ac..c16ec6331 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/DateTimeOffsetConverter.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/DateTimeOffsetConverter.shared.cs
@@ -5,31 +5,31 @@
 namespace Xamarin.CommunityToolkit.Converters
 {
 	/// <summary>
-	/// Converts DateTimeFormat to DateTime and back
+	/// Converts <see cref="DateTimeOffset"/> to <see cref="DateTime"/> and back.
 	/// </summary>
 	public class DateTimeOffsetConverter : ValueConverterExtension, IValueConverter
 	{
 		/// <summary>
-		/// Converts DatetimeOffset to DateTime
+		/// Converts <see cref="DateTimeOffset"/> to <see cref="DateTime"/>
 		/// </summary>
 		/// <param name="value">The value to convert.</param>
-		/// <param name="targetType">The type of the binding target property.</param>
-		/// <param name="parameter">Additional parameter for the converter to handle. Not implemented.</param>
-		/// <param name="culture">The culture to use in the converter. Not used.</param>
-		/// <returns>The DateTime value.</returns>
+		/// <param name="targetType">The type of the binding target property. This is not implemented.</param>
+		/// <param name="parameter">Additional parameter for the converter to handle. This is not implemented.</param>
+		/// <param name="culture">The culture to use in the converter. This is not implemented.</param>
+		/// <returns>The <see cref="DateTime"/> value.</returns>
 		public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
 			=> value is DateTimeOffset dateTimeOffset
 				? dateTimeOffset.DateTime
 				: throw new ArgumentException("Value is not a valid DateTimeOffset", nameof(value));
 
 		/// <summary>
-		/// Converts Datetime back to DateTimeOffset
+		/// Converts <see cref="DateTime"/> back to <see cref="DateTimeOffset"/>.
 		/// </summary>
 		/// <param name="value">The value to convert.</param>
-		/// <param name="targetType">The type of the binding target property.</param>
-		/// <param name="parameter">Additional parameter for the converter to handle. Not implemented.</param>
-		/// <param name="culture">The culture to use in the converter. Not used.</param>
-		/// <returns>The DateTimeOffset value.</returns>
+		/// <param name="targetType">The type of the binding target property. This is not implemented.</param>
+		/// <param name="parameter">Additional parameter for the converter to handle. This is not implemented.</param>
+		/// <param name="culture">The culture to use in the converter. This is not implemented..</param>
+		/// <returns>The <see cref="DateTimeOffset"/> value.</returns>
 		public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
 			=> value is DateTime dateTime
 				? dateTime.Kind switch
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/DoubleToIntConverter.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/DoubleToIntConverter.shared.cs
index d4b263ae0..9697ddea0 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/DoubleToIntConverter.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/DoubleToIntConverter.shared.cs
@@ -6,7 +6,7 @@
 namespace Xamarin.CommunityToolkit.Converters
 {
 	/// <summary>
-	/// Converts double to integer and vice versa.
+	/// Converts <see cref="double"/> to <see cref="int"/> and vice versa.
 	/// </summary>
 	[ContentProperty(nameof(Ratio))]
 	public class DoubleToIntConverter : ValueConverterExtension, IValueConverter
@@ -17,26 +17,26 @@ public class DoubleToIntConverter : ValueConverterExtension, IValueConverter
 		public double Ratio { get; set; } = 1;
 
 		/// <summary>
-		/// Converts double to integer.
+		/// Converts <see cref="double"/> to <see cref="int"/>.
 		/// </summary>
-		/// <param name="value">Double value.</param>
-		/// <param name="targetType">The type of the binding target property.</param>
+		/// <param name="value"><see cref="double"/> value.</param>
+		/// <param name="targetType">The type of the binding target property. This is not implemented.</param>
 		/// <param name="parameter">Multiplier (Equals 1 by default).</param>
-		/// <param name="culture">The culture to use in the converter.</param>
-		/// <returns>Integer value.</returns>
+		/// <param name="culture">The culture to use in the converter. This is not implemented.</param>
+		/// <returns><see cref="int"/> value.</returns>
 		public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
 			=> value is double result
 				? (int)Math.Round(result * GetParameter(parameter))
 				: throw new ArgumentException("Value is not a valid double", nameof(value));
 
 		/// <summary>
-		/// Converts back integer to double.
+		/// Converts back <see cref="int"/> to <see cref="double"/>.
 		/// </summary>
 		/// <param name="value">Integer value.</param>
-		/// <param name="targetType">The type of the binding target property.</param>
+		/// <param name="targetType">The type of the binding target property. This is not implemented.</param>
 		/// <param name="parameter">Denominator (Equals 1 by default).</param>
-		/// <param name="culture">The culture to use in the converter.</param>
-		/// <returns>Double value.</returns>
+		/// <param name="culture">The culture to use in the converter. This is not implemented.</param>
+		/// <returns><see cref="double"/> value.</returns>
 		public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
 			=> value is int result
 				? result / GetParameter(parameter)
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/EqualConverter.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/EqualConverter.shared.cs
index 048d9ad1d..e8af98d33 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/EqualConverter.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/EqualConverter.shared.cs
@@ -11,16 +11,24 @@ namespace Xamarin.CommunityToolkit.Converters
 	public class EqualConverter : ValueConverterExtension, IValueConverter
 	{
 		/// <summary>
-		/// Checks whether the incoming value equals the provided parameter.
+		/// Checks whether the incoming value doesn't equal the provided parameter.
 		/// </summary>
-		/// <param name="value">The value to convert.</param>
-		/// <param name="targetType">The type of the binding target property.</param>
-		/// <param name="parameter">Additional parameter for the converter to handle. Not implemented.</param>
-		/// <param name="culture">The culture to use in the converter.</param>
-		/// <returns>An inverted boolean from the one coming in.</returns>
+		/// <param name="value">The first object to compare.</param>
+		/// <param name="targetType">The type of the binding target property. This is not implemented.</param>
+		/// <param name="parameter">The second object to compare.</param>
+		/// <param name="culture">The culture to use in the converter. This is not implemented.</param>
+		/// <returns>True if <paramref name="value"/> and <paramref name="parameter"/> are equal, False if they are not equal.</returns>
 		public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
 			=> (value != null && value.Equals(parameter)) || (value == null && parameter == null);
 
+		/// <summary>
+		/// This method is not implemented and will throw a <see cref="NotImplementedException"/>.
+		/// </summary>
+		/// <param name="value">N/A</param>
+		/// <param name="targetType">N/A</param>
+		/// <param name="parameter">N/A</param>
+		/// <param name="culture">N/A</param>
+		/// <returns>N/A</returns>
 		public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
 			=> throw new NotImplementedException();
 	}
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/IndexToArrayItemConverter.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/IndexToArrayItemConverter.shared.cs
index 9a312cfa1..3fd9a0e24 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/IndexToArrayItemConverter.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/IndexToArrayItemConverter.shared.cs
@@ -6,17 +6,17 @@
 namespace Xamarin.CommunityToolkit.Converters
 {
 	/// <summary>
-	/// Converts an integer index to corresponding array item and vice versa.
+	/// Converts an <see cref="int"/> index to corresponding array item and vice versa.
 	/// </summary>
 	public class IndexToArrayItemConverter : ValueConverterExtension, IValueConverter
 	{
 		/// <summary>
-		/// Converts an integer index to corresponding array item.
+		/// Converts an <see cref="int"/> index to corresponding array item.
 		/// </summary>
 		/// <param name="value">The index of items array.</param>
-		/// <param name="targetType">The type of the binding target property.</param>
+		/// <param name="targetType">The type of the binding target property. This is not implemented.</param>
 		/// <param name="parameter">The items array.</param>
-		/// <param name="culture">The culture to use in the converter.</param>
+		/// <param name="culture">The culture to use in the converter. This is not implemented.</param>
 		/// <returns>The item from the array that corresponds to passed index.</returns>
 		public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
 		{
@@ -36,9 +36,9 @@ public object Convert(object value, Type targetType, object parameter, CultureIn
 		/// Converts back an array item to corresponding index of the item in the array.
 		/// </summary>
 		/// <param name="value">The item from the array.</param>
-		/// <param name="targetType">The type of the binding target property.</param>
+		/// <param name="targetType">The type of the binding target property. This is not implemented.</param>
 		/// <param name="parameter">The items array.</param>
-		/// <param name="culture">The culture to use in the converter.</param>
+		/// <param name="culture">The culture to use in the converter. This is not implemented.</param>
 		/// <returns>The index of the item from the array.</returns>
 		public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
 		{
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/IntToBoolConverter.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/IntToBoolConverter.shared.cs
index 40e26dadc..453df7906 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/IntToBoolConverter.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/IntToBoolConverter.shared.cs
@@ -6,31 +6,31 @@
 namespace Xamarin.CommunityToolkit.Converters
 {
 	/// <summary>
-	/// Converts an integer to corresponding boolean and vice versa.
+	/// Converts an <see cref="int"/> to corresponding <see cref="bool"/> and vice versa.
 	/// </summary>
 	public class IntToBoolConverter : ValueConverterExtension, IValueConverter
 	{
 		/// <summary>
-		/// Converts an integer to corresponding boolean.
+		/// Converts an <see cref="int"/> to corresponding <see cref="bool"/>.
 		/// </summary>
-		/// <param name="value">Integer value.</param>
-		/// <param name="targetType">The type of the binding target property.</param>
-		/// <param name="parameter">Additional parameter for the converter to handle. Not implemented.</param>
-		/// <param name="culture">The culture to use in the converter.</param>
-		/// <returns>False if the value is zero, otherwice True.</returns>
+		/// <param name="value"><see cref="int"/> value.</param>
+		/// <param name="targetType">The type of the binding target property. This is not implemented.</param>
+		/// <param name="parameter">Additional parameter for the converter to handle. This is not implemented.</param>
+		/// <param name="culture">The culture to use in the converter. This is not implemented.</param>
+		/// <returns>False if the value is 0, otherwise if the value is anything but 0 it returns True.</returns>
 		public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
 			=> value is int result
 				? result != 0
 				: throw new ArgumentException("Value is not a valid integer", nameof(value));
 
 		/// <summary>
-		/// Converts back boolean to corresponding integer.
+		/// Converts back <see cref="bool"/> to corresponding <see cref="int"/>.
 		/// </summary>
-		/// <param name="value">Boolean value.</param>
-		/// <param name="targetType">The type of the binding target property.</param>
-		/// <param name="parameter">Additional parameter for the converter to handle. Not implemented.</param>
-		/// <param name="culture">The culture to use in the converter.</param>
-		/// <returns>0 if the value is False, otherwice 1.</returns>
+		/// <param name="value"><see cref="bool"/> value.</param>
+		/// <param name="targetType">The type of the binding target property. This is not implemented.</param>
+		/// <param name="parameter">Additional parameter for the converter to handle. This is not implemented.</param>
+		/// <param name="culture">The culture to use in the converter. This is not implemented.</param>
+		/// <returns>0 if the value is False, otherwise 1 if the value is True.</returns>
 		public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
 		{
 			if (value is bool result)
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/InvertedBoolConverter.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/InvertedBoolConverter.shared.cs
index 39446c6f7..66ff4e97e 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/InvertedBoolConverter.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/InvertedBoolConverter.shared.cs
@@ -6,37 +6,37 @@
 namespace Xamarin.CommunityToolkit.Converters
 {
 	/// <summary>
-	/// Converts true to false and false to true.
+	/// Converts true to false and false to true. Simple as that!
 	/// </summary>
 	public class InvertedBoolConverter : ValueConverterExtension, IValueConverter
 	{
 		/// <summary>
-		/// Converts a boolean to its inverse value.
+		/// Converts a <see cref="bool"/> to its inverse value.
 		/// </summary>
 		/// <param name="value">The value to convert.</param>
-		/// <param name="targetType">The type of the binding target property.</param>
-		/// <param name="parameter">Additional parameter for the converter to handle. Not implemented.</param>
-		/// <param name="culture">The culture to use in the converter.</param>
-		/// <returns>An inverted boolean from the one coming in.</returns>
+		/// <param name="targetType">The type of the binding target property. This is not implemented.</param>
+		/// <param name="parameter">Additional parameter for the converter to handle. This is not implemented.</param>
+		/// <param name="culture">The culture to use in the converter. This is not implemented.</param>
+		/// <returns>An inverted <see cref="bool"/> from the one coming in.</returns>
 		public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
 			=> InverseBool(value);
 
 		/// <summary>
-		/// Converts a boolean to its inverse value.
+		/// Converts a <see cref="bool"/> to its inverse value.
 		/// </summary>
 		/// <param name="value">The value to convert.</param>
-		/// <param name="targetType">The type of the binding target property.</param>
-		/// <param name="parameter">Additional parameter for the converter to handle. Not implemented.</param>
-		/// <param name="culture">The culture to use in the converter.</param>
-		/// <returns>An inverted boolean from the one coming in.</returns>
+		/// <param name="targetType">The type of the binding target property. This is not implemented.</param>
+		/// <param name="parameter">Additional parameter for the converter to handle. This is not implemented.</param>
+		/// <param name="culture">The culture to use in the converter. This is not implemented.</param>
+		/// <returns>An inverted <see cref="bool"/> from the one coming in.</returns>
 		public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
 			=> InverseBool(value);
 
 		/// <summary>
-		/// Inverses an incoming boolean.
+		/// Inverses an incoming <see cref="bool"/>.
 		/// </summary>
 		/// <param name="value">The value to inverse.</param>
-		/// <returns>The inverted value of the incoming boolean.</returns>
+		/// <returns>The inverted value of the incoming <see cref="bool"/>.</returns>
 		bool InverseBool(object value)
 		{
 			if (value is bool result)
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/IsNotNullOrEmptyConverter.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/IsNotNullOrEmptyConverter.shared.cs
index 24793c748..42634a917 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/IsNotNullOrEmptyConverter.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/IsNotNullOrEmptyConverter.shared.cs
@@ -6,21 +6,29 @@
 namespace Xamarin.CommunityToolkit.Converters
 {
 	/// <summary>
-	/// Converts the incoming value to a boolean indicating whether or not the value is not null and not empty.
+	/// Converts the incoming value to a <see cref="bool"/> indicating whether or not the value is not null and not empty.
 	/// </summary>
 	public class IsNotNullOrEmptyConverter : ValueConverterExtension, IValueConverter
 	{
 		/// <summary>
-		/// Converts the incoming value to a boolean indicating whether or not the value is not null and not empty.
+		/// Converts the incoming value to a <see cref="bool"/> indicating whether or not the value is not null and not empty.
 		/// </summary>
 		/// <param name="value">The value to convert.</param>
-		/// <param name="targetType">The type of the binding target property.</param>
-		/// <param name="parameter">Additional parameter for the converter to handle. Not implemented.</param>
-		/// <param name="culture">The culture to use in the converter.</param>
-		/// <returns>A boolean indicating if the incoming value is not null and not empty.</returns>
+		/// <param name="targetType">The type of the binding target property. This is not implemented.</param>
+		/// <param name="parameter">Additional parameter for the converter to handle. This is not implemented.</param>
+		/// <param name="culture">The culture to use in the converter. This is not implemented.</param>
+		/// <returns>A <see cref="bool"/> indicating if the incoming value is not null and not empty.</returns>
 		public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
 			=> value is string str ? !string.IsNullOrWhiteSpace(str) : value != null;
 
+		/// <summary>
+		/// This method is not implemented and will throw a <see cref="NotImplementedException"/>.
+		/// </summary>
+		/// <param name="value">N/A</param>
+		/// <param name="targetType">N/A</param>
+		/// <param name="parameter">N/A</param>
+		/// <param name="culture">N/A</param>
+		/// <returns>N/A</returns>
 		public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
 			=> throw new NotImplementedException();
 	}
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/IsNullOrEmptyConverter.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/IsNullOrEmptyConverter.shared.cs
index 74df34d34..a4fed1064 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/IsNullOrEmptyConverter.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/IsNullOrEmptyConverter.shared.cs
@@ -6,21 +6,29 @@
 namespace Xamarin.CommunityToolkit.Converters
 {
 	/// <summary>
-	/// Converts the incoming value to a boolean indicating whether or not the value is null or empty.
+	/// Converts the incoming value to a <see cref="bool"/> indicating whether or not the value is null or empty.
 	/// </summary>
 	public class IsNullOrEmptyConverter : ValueConverterExtension, IValueConverter
 	{
 		/// <summary>
-		/// Converts the incoming value to a boolean indicating whether or not the value is null or empty.
+		/// Converts the incoming value to a <see cref="bool"/> indicating whether or not the value is null or empty.
 		/// </summary>
 		/// <param name="value">The value to convert.</param>
-		/// <param name="targetType">The type of the binding target property.</param>
-		/// <param name="parameter">Additional parameter for the converter to handle. Not implemented.</param>
-		/// <param name="culture">The culture to use in the converter.</param>
-		/// <returns>A boolean indicating if the incoming value is null or empty.</returns>
+		/// <param name="targetType">The type of the binding target property. This is not implemented.</param>
+		/// <param name="parameter">Additional parameter for the converter to handle. This is not implemented.</param>
+		/// <param name="culture">The culture to use in the converter. This is not implemented.</param>
+		/// <returns>A <see cref="bool"/> indicating if the incoming value is null or empty.</returns>
 		public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
 			=> value == null || (value is string str && string.IsNullOrWhiteSpace(str));
 
+		/// <summary>
+		/// This method is not implemented and will throw a <see cref="NotImplementedException"/>.
+		/// </summary>
+		/// <param name="value">N/A</param>
+		/// <param name="targetType">N/A</param>
+		/// <param name="parameter">N/A</param>
+		/// <param name="culture">N/A</param>
+		/// <returns>N/A</returns>
 		public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
 			=> throw new NotImplementedException();
 	}
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/ItemSelectedEventArgsConverter.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/ItemSelectedEventArgsConverter.shared.cs
index 9bf4f2d39..8559d8c86 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/ItemSelectedEventArgsConverter.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/ItemSelectedEventArgsConverter.shared.cs
@@ -6,23 +6,31 @@
 namespace Xamarin.CommunityToolkit.Converters
 {
 	/// <summary>
-	/// Converts/Extracts the incoming value from SelectedItemChangedEventArgs object and returns the value of SelectedItem property from it.
+	/// Converts/Extracts the incoming value from <see cref="SelectedItemChangedEventArgs"/> object and returns the value of <see cref="SelectedItemChangedEventArgs.SelectedItem"/> property from it.
 	/// </summary>
 	public class ItemSelectedEventArgsConverter : ValueConverterExtension, IValueConverter
 	{
 		/// <summary>
-		/// Converts/Extracts the incoming value from SelectedItemChangedEventArgs object and returns the value of SelectedItem property from it.
+		/// Converts/Extracts the incoming value from <see cref="SelectedItemChangedEventArgs"/> object and returns the value of <see cref="SelectedItemChangedEventArgs.SelectedItem"/> property from it.
 		/// </summary>
 		/// <param name="value">The value to convert.</param>
-		/// <param name="targetType">The type of the binding target property.</param>
-		/// <param name="parameter">Additional parameter for the converter to handle. Not implemented.</param>
-		/// <param name="culture">The culture to use in the converter.</param>
-		/// <returns>A SelectedItem object from object of type SelectedItemChangedEventArgs.</returns>
+		/// <param name="targetType">The type of the binding target property. This is not implemented.</param>
+		/// <param name="parameter">Additional parameter for the converter to handle. This is not implemented.</param>
+		/// <param name="culture">The culture to use in the converter. This is not implemented.</param>
+		/// <returns>A <see cref="SelectedItemChangedEventArgs.SelectedItem"/> object from object of type <see cref="SelectedItemChangedEventArgs"/>.</returns>
 		public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
 		   => value is SelectedItemChangedEventArgs selectedItemChangedEventArgs
 			   ? selectedItemChangedEventArgs.SelectedItem
 			   : throw new ArgumentException("Expected value to be of type SelectedItemChangedEventArgs", nameof(value));
 
+		/// <summary>
+		/// This method is not implemented and will throw a <see cref="NotImplementedException"/>.
+		/// </summary>
+		/// <param name="value">N/A</param>
+		/// <param name="targetType">N/A</param>
+		/// <param name="parameter">N/A</param>
+		/// <param name="culture">N/A</param>
+		/// <returns>N/A</returns>
 		public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
 			=> throw new NotImplementedException();
 	}
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/ItemTappedEventArgsConverter.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/ItemTappedEventArgsConverter.shared.cs
index 86723ba82..0f8d240db 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/ItemTappedEventArgsConverter.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/ItemTappedEventArgsConverter.shared.cs
@@ -6,23 +6,31 @@
 namespace Xamarin.CommunityToolkit.Converters
 {
 	/// <summary>
-	/// Converts/Extracts the incoming value from ItemTappedEventArgs object and returns the value of Item property from it.
+	/// Converts/Extracts the incoming value from <see cref="ItemTappedEventArgs"/> object and returns the value of <see cref="ItemTappedEventArgs.Item"/> property from it.
 	/// </summary>
 	public class ItemTappedEventArgsConverter : ValueConverterExtension, IValueConverter
 	{
 		/// <summary>
-		/// Converts/Extracts the incoming value from ItemTappedEventArgs object and returns the value of Item property from it.
+		/// Converts/Extracts the incoming value from <see cref="ItemTappedEventArgs"/> object and returns the value of <see cref="ItemTappedEventArgs.Item"/> property from it.
 		/// </summary>
 		/// <param name="value">The value to convert.</param>
-		/// <param name="targetType">The type of the binding target property.</param>
-		/// <param name="parameter">Additional parameter for the converter to handle. Not implemented.</param>
-		/// <param name="culture">The culture to use in the converter.</param>
-		/// <returns>A Item object from object of type ItemTappedEventArgs.</returns>
+		/// <param name="targetType">The type of the binding target property. This is not implemented.</param>
+		/// <param name="parameter">Additional parameter for the converter to handle. This is not implemented.</param>
+		/// <param name="culture">The culture to use in the converter. This is not implemented.</param>
+		/// <returns>A <see cref="ItemTappedEventArgs.Item"/> object from object of type <see cref="ItemTappedEventArgs"/>.</returns>
 		public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
 			=> value is ItemTappedEventArgs itemTappedEventArgs
 				? itemTappedEventArgs.Item
 				: throw new ArgumentException("Expected value to be of type ItemTappedEventArgs", nameof(value));
 
+		/// <summary>
+		/// This method is not implemented and will throw a <see cref="NotImplementedException"/>.
+		/// </summary>
+		/// <param name="value">N/A</param>
+		/// <param name="targetType">N/A</param>
+		/// <param name="parameter">N/A</param>
+		/// <param name="culture">N/A</param>
+		/// <returns>N/A</returns>
 		public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
 			=> throw new NotImplementedException();
 	}
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/ListIsNotNullOrEmptyConverter.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/ListIsNotNullOrEmptyConverter.shared.cs
index 838e8998e..b3b28aa3f 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/ListIsNotNullOrEmptyConverter.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/ListIsNotNullOrEmptyConverter.shared.cs
@@ -7,18 +7,18 @@
 namespace Xamarin.CommunityToolkit.Converters
 {
 	/// <summary>
-	/// Converts the incoming value to a boolean indicating whether or not the value is not null and not empty.
+	/// Converts the incoming value to a <see cref="bool"/> indicating whether or not the value is not null and not empty.
 	/// </summary>
 	public class ListIsNotNullOrEmptyConverter : ValueConverterExtension, IValueConverter
 	{
 		/// <summary>
-		/// Converts the incoming value to a boolean indicating whether or not the value is not null and not empty.
+		/// Converts the incoming value to a <see cref="bool"/> indicating whether or not the value is not null and not empty.
 		/// </summary>
 		/// <param name="value">The value to convert.</param>
-		/// <param name="targetType">The type of the binding target property.</param>
-		/// <param name="parameter">Additional parameter for the converter to handle. Not implemented.</param>
-		/// <param name="culture">The culture to use in the converter.</param>
-		/// <returns>A boolean indicating if the incoming value is not null and not empty.</returns>
+		/// <param name="targetType">The type of the binding target property. This is not implemented.</param>
+		/// <param name="parameter">Additional parameter for the converter to handle. This is not implemented.</param>
+		/// <param name="culture">The culture to use in the converter. This is not implemented.</param>
+		/// <returns>A <see cref="bool"/> 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 == null)
@@ -30,6 +30,14 @@ public object Convert(object value, Type targetType, object parameter, CultureIn
 			throw new ArgumentException("Value is not a valid IEnumerable or null", nameof(value));
 		}
 
+		/// <summary>
+		/// This method is not implemented and will throw a <see cref="NotImplementedException"/>.
+		/// </summary>
+		/// <param name="value">N/A</param>
+		/// <param name="targetType">N/A</param>
+		/// <param name="parameter">N/A</param>
+		/// <param name="culture">N/A</param>
+		/// <returns>N/A</returns>
 		public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
 			=> throw new NotImplementedException();
 	}
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/ListIsNullOrEmptyConverter.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/ListIsNullOrEmptyConverter.shared.cs
index 2b75ef8d2..27da69ad3 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/ListIsNullOrEmptyConverter.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/ListIsNullOrEmptyConverter.shared.cs
@@ -7,18 +7,18 @@
 namespace Xamarin.CommunityToolkit.Converters
 {
 	/// <summary>
-	/// Converts the incoming value to a boolean indicating whether or not the value is null or empty.
+	/// Converts the incoming value to a <see cref="bool"/> indicating whether or not the value is null or empty.
 	/// </summary>
 	public class ListIsNullOrEmptyConverter : ValueConverterExtension, IValueConverter
 	{
 		/// <summary>
-		/// Converts the incoming value to a boolean indicating whether or not the value is null or empty.
+		/// Converts the incoming value to a <see cref="bool"/> indicating whether or not the value is null or empty.
 		/// </summary>
 		/// <param name="value">The value to convert.</param>
-		/// <param name="targetType">The type of the binding target property.</param>
-		/// <param name="parameter">Additional parameter for the converter to handle. Not implemented.</param>
-		/// <param name="culture">The culture to use in the converter.</param>
-		/// <returns>A boolean indicating if the incoming value is null or empty.</returns>
+		/// <param name="targetType">The type of the binding target property. This is not implemented.</param>
+		/// <param name="parameter">Additional parameter for the converter to handle. This is not implemented.</param>
+		/// <param name="culture">The culture to use in the converter. This is not implemented.</param>
+		/// <returns>A <see cref="bool"/> indicating if the incoming value is null or empty.</returns>
 		public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
 		{
 			if (value == null)
@@ -30,6 +30,14 @@ public object Convert(object value, Type targetType, object parameter, CultureIn
 			throw new ArgumentException("Value is not a valid IEnumerable or null", nameof(value));
 		}
 
+		/// <summary>
+		/// This method is not implemented and will throw a <see cref="NotImplementedException"/>.
+		/// </summary>
+		/// <param name="value">N/A</param>
+		/// <param name="targetType">N/A</param>
+		/// <param name="parameter">N/A</param>
+		/// <param name="culture">N/A</param>
+		/// <returns>N/A</returns>
 		public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
 			=> throw new NotImplementedException();
 	}
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/ListToStringConverter.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/ListToStringConverter.shared.cs
index 24ed33079..85c7d3bad 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/ListToStringConverter.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/ListToStringConverter.shared.cs
@@ -18,13 +18,13 @@ public class ListToStringConverter : ValueConverterExtension, IValueConverter
 		public string Separator { get; set; }
 
 		/// <summary>
-		/// Concatenates the items of a collection, using the specified separator between each item.
+		/// Concatenates the items of a collection, using the specified <see cref="Separator"/> between each item. On each item ToString() will be called.
 		/// </summary>
 		/// <param name="value">The collection to convert.</param>
-		/// <param name="targetType">The type of the binding target property.</param>
-		/// <param name="parameter">The separator that should be between each collection item.</param>
-		/// <param name="culture">The culture to use in the converter.</param>
-		/// <returns>Concatenated members string.</returns>
+		/// <param name="targetType">The type of the binding target property. This is not implemented.</param>
+		/// <param name="parameter">The separator that should be between each collection item. This overrides the value in <see cref="Separator"/>.</param>
+		/// <param name="culture">The culture to use in the converter. This is not implemented.</param>
+		/// <returns>Concatenated members string separated by <see cref="Separator"/> or, if set, <paramref name="parameter"/>.</returns>
 		public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
 		{
 			if (value == null)
@@ -44,6 +44,14 @@ public object Convert(object value, Type targetType, object parameter, CultureIn
 			return string.Join(separator, collection);
 		}
 
+		/// <summary>
+		/// This method is not implemented and will throw a <see cref="NotImplementedException"/>.
+		/// </summary>
+		/// <param name="value">N/A</param>
+		/// <param name="targetType">N/A</param>
+		/// <param name="parameter">N/A</param>
+		/// <param name="culture">N/A</param>
+		/// <returns>N/A</returns>
 		public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
 			=> throw new NotImplementedException();
 	}
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/MultiConverter.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/MultiConverter.shared.cs
index 04ce9a5b3..f4d406ffe 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/MultiConverter.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/MultiConverter.shared.cs
@@ -24,6 +24,14 @@ public object Convert(object value, Type targetType, object parameter, System.Gl
 					 parameters.FirstOrDefault(x => x.ConverterType == converter.GetType())?.Value, culture))
 			: this.Aggregate(value, (current, converter) => converter.Convert(current, targetType, parameter, culture));
 
+		/// <summary>
+		/// This method is not implemented and will throw a <see cref="NotImplementedException"/>.
+		/// </summary>
+		/// <param name="value">N/A</param>
+		/// <param name="targetType">N/A</param>
+		/// <param name="parameter">N/A</param>
+		/// <param name="culture">N/A</param>
+		/// <returns>N/A</returns>
 		public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
 			=> throw new NotImplementedException();
 	}
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/MultiConverterParameter.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/MultiConverterParameter.shared.cs
index ffcacb6b5..85950c23d 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/MultiConverterParameter.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/MultiConverterParameter.shared.cs
@@ -4,12 +4,18 @@
 namespace Xamarin.CommunityToolkit.Converters
 {
 	/// <summary>
-	/// Represents a parameter to be used in the MultiConverter.
+	/// Represents a parameter to be used in the <see cref="MultiConverter"/>.
 	/// </summary>
 	public class MultiConverterParameter : BindableObject
 	{
+		/// <summary>
+		/// The type of object of this parameter.
+		/// </summary>
 		public Type ConverterType { get; set; }
 
+		/// <summary>
+		/// The value of this parameter.
+		/// </summary>
 		public object Value { get; set; }
 	}
 }
\ No newline at end of file
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/NotEqualConverter.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/NotEqualConverter.shared.cs
index 015ef9e5c..c09446242 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/NotEqualConverter.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/NotEqualConverter.shared.cs
@@ -13,14 +13,22 @@ public class NotEqualConverter : ValueConverterExtension, IValueConverter
 		/// <summary>
 		/// Checks whether the incoming value doesn't equal the provided parameter.
 		/// </summary>
-		/// <param name="value">The value to convert.</param>
-		/// <param name="targetType">The type of the binding target property.</param>
-		/// <param name="parameter">Additional parameter for the converter to handle. Not implemented.</param>
-		/// <param name="culture">The culture to use in the converter.</param>
-		/// <returns>An inverted boolean from the one coming in.</returns>
+		/// <param name="value">The first object to compare.</param>
+		/// <param name="targetType">The type of the binding target property. This is not implemented.</param>
+		/// <param name="parameter">The second object to compare.</param>
+		/// <param name="culture">The culture to use in the converter. This is not implemented.</param>
+		/// <returns>True if <paramref name="value"/> and <paramref name="parameter"/> are not equal, False if they are equal.</returns>
 		public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
 			=> !((value != null && value.Equals(parameter)) || (value == null && parameter == null));
 
+		/// <summary>
+		/// This method is not implemented and will throw a <see cref="NotImplementedException"/>.
+		/// </summary>
+		/// <param name="value">N/A</param>
+		/// <param name="targetType">N/A</param>
+		/// <param name="parameter">N/A</param>
+		/// <param name="culture">N/A</param>
+		/// <returns>N/A</returns>
 		public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
 			=> throw new NotImplementedException();
 	}
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/StateToBooleanConverter.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/StateToBooleanConverter.shared.cs
index d032c059d..21fe1fea0 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/StateToBooleanConverter.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/StateToBooleanConverter.shared.cs
@@ -5,10 +5,24 @@
 
 namespace Xamarin.CommunityToolkit.Converters
 {
+	/// <summary>
+	/// This converter can be used with <see cref="StateLayout"/> to determine if a certain state is visible. This can be useful, for instance, in scenarios where you want to show/hide certain elements based on the current <see cref="StateLayout.LayoutState"/>. Additionally a <see cref="StateLayout"/> can be supplied in the parameter of the Convert method to compare against that.
+	/// </summary>
 	public class StateToBooleanConverter : IValueConverter
 	{
+		/// <summary>
+		/// The <see cref="LayoutState"/> to compare to.
+		/// </summary>
 		public LayoutState StateToCompare { get; set; }
 
+		/// <summary>
+		/// Takes the incoming <see cref="StateLayout"/> in <paramref name="value"/> and compares it to <see cref="StateToCompare"/>. If they are equal it returns True, if they are not equal it returns False. Additionally a state to compare against can be provided in <paramref name="parameter"/>.
+		/// </summary>
+		/// <param name="value">The <see cref="StateLayout"/> to compare.</param>
+		/// <param name="targetType">The type of the binding target property. This is not implemented.</param>
+		/// <param name="parameter">Optionally, a <see cref="StateLayout"/> can be supplied here to compare against.</param>
+		/// <param name="culture">The culture to use in the converter. This is not implemented.</param>
+		/// <returns>True if the provided <see cref="StateLayout"/>s match, otherwise False if they don't match.</returns>
 		public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
 		{
 			if (!(value is LayoutState state))
@@ -20,6 +34,14 @@ public object Convert(object value, Type targetType, object parameter, CultureIn
 			return state == StateToCompare;
 		}
 
+		/// <summary>
+		/// This method is not implemented and will throw a <see cref="NotImplementedException"/>.
+		/// </summary>
+		/// <param name="value">N/A</param>
+		/// <param name="targetType">N/A</param>
+		/// <param name="parameter">N/A</param>
+		/// <param name="culture">N/A</param>
+		/// <returns>N/A</returns>
 		public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
 			=> throw new NotImplementedException();
 	}
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/TextCaseConverter.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/TextCaseConverter.shared.cs
index 43ef5d57b..8d8f9ce39 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/TextCaseConverter.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/TextCaseConverter.shared.cs
@@ -6,7 +6,7 @@
 namespace Xamarin.CommunityToolkit.Converters
 {
 	/// <summary>
-	/// Converts text (string, char) to certain case.
+	/// Converts text (string, char) to certain case as specified with <see cref="Type"/> or the parameter of the Convert method.
 	/// </summary>
 	[ContentProperty(nameof(Type))]
 	public class TextCaseConverter : ValueConverterExtension, IValueConverter
@@ -20,15 +20,23 @@ public class TextCaseConverter : ValueConverterExtension, IValueConverter
 		/// Converts text (string, char) to certain case.
 		/// </summary>
 		/// <param name="value">The text to convert.</param>
-		/// <param name="targetType">The type of the binding target property.</param>
-		/// <param name="parameter">The desired text case that the text should be converted to (TextCaseType enum value).</param>
-		/// <param name="culture">The culture to use in the converter.</param>
-		/// <returns>The lowercase text representation.</returns>
+		/// <param name="targetType">The type of the binding target property. This is not implemented.</param>
+		/// <param name="parameter">The desired text case that the text should be converted to. Must match <see cref="TextCaseType"/> enum value.</param>
+		/// <param name="culture">The culture to use in the converter. This is not implemented.</param>
+		/// <returns>The converted text representation with the desired casing.</returns>
 		public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
 			=> value == null || value is string || value is char
 				? Convert(value?.ToString(), parameter)
 				: throw new ArgumentException("Value is neither a string nor a char", nameof(value));
 
+		/// <summary>
+		/// This method is not implemented and will throw a <see cref="NotImplementedException"/>.
+		/// </summary>
+		/// <param name="value">N/A</param>
+		/// <param name="targetType">N/A</param>
+		/// <param name="parameter">N/A</param>
+		/// <param name="culture">N/A</param>
+		/// <returns>N/A</returns>
 		public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
 			=> throw new NotImplementedException();
 
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/TextCaseType.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/TextCaseType.shared.cs
index 65c0322fb..c85ead61f 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/TextCaseType.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/TextCaseType.shared.cs
@@ -1,12 +1,17 @@
 namespace Xamarin.CommunityToolkit.Converters
 {
 	/// <summary>
-	/// The text case that the TextCaseConverter should convert a value.
+	/// The text cases that can be used with <see cref="TextCaseConverter"/> to convert text to a specific case.
 	/// </summary>
 	public enum TextCaseType
 	{
+		/// <summary>Should not be converted</summary>
 		None,
+
+		/// <summary>Convert to uppercase</summary>
 		Upper,
+
+		/// <summary>Convert to lowercase</summary>
 		Lower,
 		FirstUpperRestLower,
 	}
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/TimeSpanToDoubleConverter.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/TimeSpanToDoubleConverter.shared.cs
index 42feb9fe4..14d026cf9 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/TimeSpanToDoubleConverter.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/TimeSpanToDoubleConverter.shared.cs
@@ -4,16 +4,19 @@
 
 namespace Xamarin.CommunityToolkit.Converters
 {
+	/// <summary>
+	/// Converts a <see cref="TimeSpan"/> to a <see cref="double"/> value expressed in seconds.
+	/// </summary>
 	public class TimeSpanToDoubleConverter : IValueConverter
 	{
 		/// <summary>
-		/// Converts a timespan to a double value in seconds.
+		/// Converts a <see cref="TimeSpan"/> to a <see cref="double"/> value expressed in seconds.
 		/// </summary>
-		/// <param name="value">The TimeSpan to convert.</param>
-		/// <param name="targetType">The type of the binding target property.</param>
-		/// <param name="parameter"></param>
-		/// <param name="culture">The culture to use in the converter.</param>
-		/// <returns>A double value in seconds.</returns>
+		/// <param name="value">The <see cref="TimeSpan"/> value to convert.</param>
+		/// <param name="targetType">The type of the binding target property. This is not implemented.</param>
+		/// <param name="parameter">Additional parameter for the converter to handle. This is not implemented.</param>
+		/// <param name="culture">The culture to use in the converter. This is not implemented.</param>
+		/// <returns>A <see cref="double"/> value expressed in seconds.</returns>
 		public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
 		{
 			if (value is TimeSpan timespan)
@@ -24,6 +27,14 @@ public object Convert(object value, Type targetType, object parameter, CultureIn
 			return 1.0;
 		}
 
+		/// <summary>
+		/// Converts a <see cref="double"/> (value should be in seconds) to a <see cref="TimeSpan"/> value.
+		/// </summary>
+		/// <param name="value">The <see cref="double"/> value (in seconds) to convert.</param>
+		/// <param name="targetType">The type of the binding target property. This is not implemented.</param>
+		/// <param name="parameter">Additional parameter for the converter to handle. This is not implemented.</param>
+		/// <param name="culture">The culture to use in the converter. This is not implemented.</param>
+		/// <returns>The <see cref="TimeSpan"/> value representing the converted <see cref="double"/> value.</returns>
 		public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
 		{
 			if (value is double doubleValue)
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/VariableMultiValueConverter.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/VariableMultiValueConverter.shared.cs
index 7618ea34a..ffc7afb09 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/VariableMultiValueConverter.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Converters/VariableMultiValueConverter.shared.cs
@@ -8,12 +8,29 @@
 
 namespace Xamarin.CommunityToolkit.Converters
 {
+	/// <summary>
+	/// The <see cref="VariableMultiValueConverter"/> is a converter that allows users to convert multiple <see cref="bool"/> value bindings to a single <see cref="bool"/>. It does this by enabling them to specify whether All, Any, None or a specific number of values are true as specified in <see cref="ConditionType"/>. This is useful when combined with the <see cref="MultiBinding"/>.
+	/// </summary>
 	public class VariableMultiValueConverter : MultiValueConverterExtension, IMultiValueConverter
 	{
+		/// <summary>
+		/// Indicates how many values should be true out of the provided boolean values in the <see cref="MultiBinding"/>. Supports the following values: All, None, Any, GreaterThan, LessThan.
+		/// </summary>
 		public MultiBindingCondition ConditionType { get; set; }
 
+		/// <summary>
+		/// The number of values that should be true when using <see cref="ConditionType"/> GreaterThan, LessThan or Exact.
+		/// </summary>
 		public int Count { get; set; }
 
+		/// <summary>
+		/// Converts multiple <see cref="bool"/> value bindings to a single <see cref="bool"/>. It does this by enabling them to specify whether All, Any, None or a specific number of values are true as specified in <see cref="ConditionType"/>. This is useful when combined with the <see cref="MultiBinding"/>.
+		/// </summary>
+		/// <param name="values">The values (of type <see cref="bool"/>) that should be converted.</param>
+		/// <param name="targetType">The type of the binding target property. This is not implemented.</param>
+		/// <param name="parameter">Additional parameter for the converter to handle. This is not implemented.</param>
+		/// <param name="culture">The culture to use in the converter. This is not implemented.</param>
+		/// <returns>A single <see cref="bool"/> value dependant on the configuration for this converter.</returns>
 		public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
 		{
 			if (values == null || values.Length == 0)
@@ -37,6 +54,14 @@ public object Convert(object[] values, Type targetType, object parameter, Cultur
 			};
 		}
 
+		/// <summary>
+		/// Converts one <see cref="bool"/> value. Returns null if <paramref name="value"/> is not a <see cref="bool"/> value or when not all <paramref name="targetTypes"/> can be assigned from <see cref="bool"/>.
+		/// </summary>
+		/// <param name="value">The <see cref="bool"/> value that should be converted.</param>
+		/// <param name="targetTypes">The types of the binding target properties.</param>
+		/// <param name="parameter">Additional parameter for the converter to handle. This is not implemented.</param>
+		/// <param name="culture">The culture to use in the converter. This is not implemented.</param>
+		/// <returns>All bindings that evaluate to true if <paramref name="value"/> is true. Or null if <paramref name="value"/> is not a <see cref="bool"/> value or <paramref name="value"/> is false.</returns>
 		public object[] ConvertBack(object value, Type[] targetTypes, object parameter, CultureInfo culture)
 		{
 			if (!(value is bool boolValue) || targetTypes.Any(t => !t.IsAssignableFrom(typeof(bool))))
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Effects/Touch/GestureManager.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Effects/Touch/GestureManager.shared.cs
index 564ce4595..c384fe70d 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Effects/Touch/GestureManager.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Effects/Touch/GestureManager.shared.cs
@@ -1,4 +1,6 @@
 using System;
+using System.Collections.Generic;
+using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Xamarin.CommunityToolkit.Extensions;
@@ -211,6 +213,9 @@ internal void OnTapped(TouchEffect sender)
 			if (!sender.CanExecute || (sender.LongPressCommand != null && sender.InteractionStatus == TouchInteractionStatus.Completed))
 				return;
 
+			if (Device.RuntimePlatform == Device.Android)
+				HandleCollectionViewSelection(sender);
+
 			if (sender.Element is IButtonController button)
 				button.SendClicked();
 
@@ -218,6 +223,31 @@ internal void OnTapped(TouchEffect sender)
 			sender.RaiseCompleted();
 		}
 
+		void HandleCollectionViewSelection(TouchEffect sender)
+		{
+			if (!sender.Element.TryFindParentElementWithParentOfType(out var element, out CollectionView collectionView))
+				return;
+
+			var item = element.BindingContext ?? element;
+
+			switch (collectionView.SelectionMode)
+			{
+				case SelectionMode.Single:
+					collectionView.SelectedItem = !item.Equals(collectionView.SelectedItem) ? item : null;
+					break;
+				case SelectionMode.Multiple:
+					var selectedItems = collectionView.SelectedItems?.ToList() ?? new List<object>();
+
+					if (selectedItems.Contains(item))
+						selectedItems.Remove(item);
+					else
+						selectedItems.Add(item);
+
+					collectionView.UpdateSelectedItems(selectedItems);
+					break;
+			}
+		}
+
 		internal void AbortAnimations(TouchEffect sender)
 		{
 			animationTokenSource?.Cancel();
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Extensions/VisualElement/VisualElementExtension.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Extensions/VisualElement/VisualElementExtension.shared.cs
index 8906ec030..cebcc1fc5 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Extensions/VisualElement/VisualElementExtension.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Extensions/VisualElement/VisualElementExtension.shared.cs
@@ -1,4 +1,5 @@
-using System.Threading.Tasks;
+using System;
+using System.Threading.Tasks;
 using Xamarin.Forms;
 
 namespace Xamarin.CommunityToolkit.Extensions
@@ -32,5 +33,26 @@ public static void AbortAnimations(this VisualElement element, params string[] o
 			foreach (var name in otherAnimationNames)
 				element.AbortAnimation(name);
 		}
+
+		internal static bool TryFindParentElementWithParentOfType<T>(this VisualElement element, out VisualElement result, out T parent) where T : VisualElement
+		{
+			result = null;
+			parent = null;
+			while (element.Parent != null)
+			{
+				if (!(element.Parent is T parentElement))
+				{
+					element = element.Parent as VisualElement;
+					continue;
+				}
+				result = element;
+				parent = parentElement;
+				return true;
+			}
+			return false;
+		}
+
+		internal static bool TryFindParentOfType<T>(this VisualElement element, out T parent) where T : VisualElement
+			=> TryFindParentElementWithParentOfType<T>(element, out _, out parent);
 	}
 }
\ No newline at end of file
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Helpers/MultiBindingCondition.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Helpers/MultiBindingCondition.shared.cs
index e5aa960ff..4d4c0f18c 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Helpers/MultiBindingCondition.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Helpers/MultiBindingCondition.shared.cs
@@ -1,12 +1,26 @@
 namespace Xamarin.CommunityToolkit.Helpers
 {
+	/// <summary>
+	/// Different types of conditions that can be used in <see cref="Converters.VariableMultiValueConverter"/>.
+	/// </summary>
 	public enum MultiBindingCondition
 	{
+		/// <summary>None of the values should be true.</summary>
 		None,
+
+		/// <summary>All of the values should be true.</summary>
 		All,
+
+		/// <summary>Any of the values should be true.</summary>
 		Any,
+
+		/// <summary>The exact number as configured in <see cref="Converters.VariableMultiValueConverter.Count"/> should be true.</summary>
 		Exact,
+
+		/// <summary>At least the number as configured in <see cref="Converters.VariableMultiValueConverter.Count"/> should be true.</summary>
 		GreaterThan,
+
+		/// <summary>At most the number as configured in <see cref="Converters.VariableMultiValueConverter.Count"/> should be true.</summary>
 		LessThan
 	}
 }
\ No newline at end of file
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/BaseAsyncCommand.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/Internals/BaseAsyncCommand.shared.cs
similarity index 98%
rename from src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/BaseAsyncCommand.shared.cs
rename to src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/Internals/BaseAsyncCommand.shared.cs
index ad5174831..eb6f8dbf8 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/BaseAsyncCommand.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/Internals/BaseAsyncCommand.shared.cs
@@ -1,4 +1,5 @@
 using System;
+using System.ComponentModel;
 using System.Reflection;
 using System.Threading.Tasks;
 using System.Windows.Input;
@@ -9,6 +10,7 @@ namespace Xamarin.CommunityToolkit.ObjectModel.Internals
 	/// <summary>
 	/// Abstract Base Class used by AsyncValueCommand
 	/// </summary>
+	[EditorBrowsable(EditorBrowsableState.Never)]
 	public class BaseAsyncCommand<TExecute, TCanExecute> : BaseCommand<TCanExecute>, ICommand
 	{
 		readonly Func<TExecute, Task> execute;
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/BaseAsyncValueCommand.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/Internals/BaseAsyncValueCommand.shared.cs
similarity index 95%
rename from src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/BaseAsyncValueCommand.shared.cs
rename to src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/Internals/BaseAsyncValueCommand.shared.cs
index 7fba6146d..c32ae7000 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/BaseAsyncValueCommand.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/Internals/BaseAsyncValueCommand.shared.cs
@@ -1,4 +1,5 @@
 using System;
+using System.ComponentModel;
 using System.Reflection;
 using System.Threading.Tasks;
 using System.Windows.Input;
@@ -9,7 +10,8 @@ namespace Xamarin.CommunityToolkit.ObjectModel.Internals
 	/// <summary>
 	/// Abstract Base Class used by AsyncValueCommand
 	/// </summary>
-	public class BaseAsyncValueCommand<TExecute, TCanExecute> : BaseCommand<TCanExecute>, ICommand
+	[EditorBrowsable(EditorBrowsableState.Never)]
+	public abstract class BaseAsyncValueCommand<TExecute, TCanExecute> : BaseCommand<TCanExecute>, ICommand
 	{
 		readonly Func<TExecute, ValueTask> execute;
 		readonly Action<Exception> onException;
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/Internals/BaseCommand.android.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/Internals/BaseCommand.android.cs
new file mode 100644
index 000000000..77fde7ebc
--- /dev/null
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/Internals/BaseCommand.android.cs
@@ -0,0 +1,30 @@
+using System;
+using Android.OS;
+
+// Inspired by Xamarin.Essentials.MainThread  https://github.com/xamarin/Essentials/tree/main/Xamarin.Essentials/MainThread
+namespace Xamarin.CommunityToolkit.ObjectModel.Internals
+{
+	public abstract partial class BaseCommand<TCanExecute>
+	{
+		static volatile Handler handler;
+
+		static bool IsMainThread
+		{
+			get
+			{
+				if (Build.VERSION.SdkInt >= BuildVersionCodes.M)
+					return Looper.MainLooper.IsCurrentThread;
+
+				return Looper.MyLooper() == Looper.MainLooper;
+			}
+		}
+
+		static void BeginInvokeOnMainThread(Action action)
+		{
+			if (handler?.Looper != Looper.MainLooper)
+				handler = new Handler(Looper.MainLooper);
+
+			handler.Post(action);
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/Internals/BaseCommand.gtk.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/Internals/BaseCommand.gtk.cs
new file mode 100644
index 000000000..37ef803e1
--- /dev/null
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/Internals/BaseCommand.gtk.cs
@@ -0,0 +1,21 @@
+using System;
+using System.Threading;
+
+namespace Xamarin.CommunityToolkit.ObjectModel.Internals
+{
+	public abstract partial class BaseCommand<TCanExecute>
+	{
+		static readonly Thread mainThread = Thread.CurrentThread;
+
+		static bool IsMainThread => Thread.CurrentThread == mainThread;
+
+		static void BeginInvokeOnMainThread(Action action)
+		{
+			GLib.Idle.Add(() =>
+			{
+				action();
+				return false;
+			});
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/Internals/BaseCommand.ios.watchos.tvos.macos.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/Internals/BaseCommand.ios.watchos.tvos.macos.cs
new file mode 100644
index 000000000..dfa891920
--- /dev/null
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/Internals/BaseCommand.ios.watchos.tvos.macos.cs
@@ -0,0 +1,13 @@
+using System;
+using Foundation;
+
+// Inspired by Xamarin.Essentials.MainThread  https://github.com/xamarin/Essentials/tree/main/Xamarin.Essentials/MainThread
+namespace Xamarin.CommunityToolkit.ObjectModel.Internals
+{
+	public abstract partial class BaseCommand<TCanExecute>
+	{
+		static bool IsMainThread => NSThread.Current.IsMainThread;
+
+		static void BeginInvokeOnMainThread(Action action) => NSRunLoop.Main.BeginInvokeOnMainThread(action.Invoke);
+	}
+}
\ No newline at end of file
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/Internals/BaseCommand.netstandard.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/Internals/BaseCommand.netstandard.cs
new file mode 100644
index 000000000..b30723162
--- /dev/null
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/Internals/BaseCommand.netstandard.cs
@@ -0,0 +1,21 @@
+using System;
+using System.Threading;
+
+// Inspired by Prism.Commands https://github.com/PrismLibrary/Prism/blob/0fc56abbea733a319c9734c65d1110db07f7ebd4/src/Prism.Core/Commands/DelegateCommandBase.cs#L37-L47
+namespace Xamarin.CommunityToolkit.ObjectModel.Internals
+{
+	public abstract partial class BaseCommand<TCanExecute>
+	{
+		static readonly SynchronizationContext synchronizationContext = SynchronizationContext.Current;
+
+		static bool IsMainThread => SynchronizationContext.Current == synchronizationContext;
+
+		static void BeginInvokeOnMainThread(Action action)
+		{
+			if (synchronizationContext != null && SynchronizationContext.Current != synchronizationContext)
+				synchronizationContext.Post((o) => action(), null);
+			else
+				action();
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/BaseCommand.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/Internals/BaseCommand.shared.cs
similarity index 89%
rename from src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/BaseCommand.shared.cs
rename to src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/Internals/BaseCommand.shared.cs
index 95fc5ea20..1f094d662 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/BaseCommand.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/Internals/BaseCommand.shared.cs
@@ -8,7 +8,8 @@ namespace Xamarin.CommunityToolkit.ObjectModel.Internals
 	/// <summary>
 	/// Abstract Base Class used by AsyncCommand and AsyncValueCommand
 	/// </summary>
-	public abstract class BaseCommand<TCanExecute>
+	[EditorBrowsable(EditorBrowsableState.Never)]
+	public abstract partial class BaseCommand<TCanExecute>
 	{
 		readonly Func<TCanExecute, bool> canExecute;
 		readonly WeakEventManager weakEventManager = new WeakEventManager();
@@ -83,7 +84,10 @@ protected int ExecutionCount
 		public void RaiseCanExecuteChanged()
 		{
 			// Automatically marshall to the Main Thread to adhere to the way that Xamarin.Forms automatically marshalls binding events to Main Thread
-			Device.BeginInvokeOnMainThread(() => weakEventManager.RaiseEvent(this, EventArgs.Empty, nameof(CanExecuteChanged)));
+			if (IsMainThread)
+				weakEventManager.RaiseEvent(this, EventArgs.Empty, nameof(CanExecuteChanged));
+			else
+				BeginInvokeOnMainThread(() => weakEventManager.RaiseEvent(this, EventArgs.Empty, nameof(CanExecuteChanged)));
 		}
 
 		/// <summary>
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/Internals/BaseCommand.tizen.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/Internals/BaseCommand.tizen.cs
new file mode 100644
index 000000000..20e636dcc
--- /dev/null
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/Internals/BaseCommand.tizen.cs
@@ -0,0 +1,19 @@
+using System;
+using ElmSharp;
+
+// Inspired by Xamarin.Essentials.MainThread  https://github.com/xamarin/Essentials/tree/main/Xamarin.Essentials/MainThread
+namespace Xamarin.CommunityToolkit.ObjectModel.Internals
+{
+	public abstract partial class BaseCommand<TCanExecute>
+	{
+		static bool IsMainThread => EcoreMainloop.IsMainThread;
+
+		static void BeginInvokeOnMainThread(Action action)
+		{
+			if (IsMainThread)
+				action();
+			else
+				EcoreMainloop.PostAndWakeUp(action);
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/Internals/BaseCommand.uwp.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/Internals/BaseCommand.uwp.cs
new file mode 100644
index 000000000..a14c6e85e
--- /dev/null
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/Internals/BaseCommand.uwp.cs
@@ -0,0 +1,45 @@
+using System;
+using System.Diagnostics;
+using System.Threading;
+using System.Threading.Tasks;
+using Windows.ApplicationModel.Core;
+using Windows.UI.Core;
+
+// Inspired by Xamarin.Essentials.MainThread  https://github.com/xamarin/Essentials/tree/main/Xamarin.Essentials/MainThread
+namespace Xamarin.CommunityToolkit.ObjectModel.Internals
+{
+	public abstract partial class BaseCommand<TCanExecute>
+	{
+		static bool IsMainThread
+		{
+			get
+			{
+				// if there is no main window, then this is either a service
+				// or the UI is not yet constructed, so the main thread is the
+				// current thread
+				try
+				{
+					if (CoreApplication.MainView?.CoreWindow == null)
+						return true;
+				}
+				catch (Exception ex)
+				{
+					Debug.WriteLine($"Unable to validate MainView creation. {ex.Message}");
+					return true;
+				}
+
+				return CoreApplication.MainView.CoreWindow.Dispatcher?.HasThreadAccess ?? false;
+			}
+		}
+
+		static async void BeginInvokeOnMainThread(Action action)
+		{
+			var dispatcher = CoreApplication.MainView?.CoreWindow?.Dispatcher;
+
+			if (dispatcher == null)
+				throw new InvalidOperationException("Unable to find main thread.");
+
+			await dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => action());
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/Internals/BaseCommand.wpf.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/Internals/BaseCommand.wpf.cs
new file mode 100644
index 000000000..ebfc34415
--- /dev/null
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/ObjectModel/Internals/BaseCommand.wpf.cs
@@ -0,0 +1,12 @@
+using System;
+using System.Threading;
+
+namespace Xamarin.CommunityToolkit.ObjectModel.Internals
+{
+	public abstract partial class BaseCommand<TCanExecute>
+	{
+		static bool IsMainThread => Thread.CurrentThread == System.Windows.Threading.Dispatcher.CurrentDispatcher.Thread;
+
+		static void BeginInvokeOnMainThread(Action action) => System.Windows.Application.Current?.Dispatcher.BeginInvoke(action);
+	}
+}
\ No newline at end of file
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/AvatarView/AvatarView.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/AvatarView/AvatarView.shared.cs
index eaa0f6767..8ff96b516 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/AvatarView/AvatarView.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/AvatarView/AvatarView.shared.cs
@@ -1,4 +1,7 @@
 using System;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using Xamarin.CommunityToolkit.UI.Views.Internals;
 using Xamarin.Forms;
 using static System.Math;
@@ -11,8 +14,18 @@ namespace Xamarin.CommunityToolkit.UI.Views
 	public class AvatarView : BaseTemplatedView<Frame>
 	{
 		const string emptyText = "X";
+
 		static readonly IImageSourceValidator imageSourceValidator = new ImageSourceValidator();
 
+		readonly SemaphoreSlim imageSourceSemaphore = new SemaphoreSlim(1);
+
+		CancellationTokenSource imageLoadingTokenSource;
+
+		object sourceBindingContext;
+
+		// Indicates if any thread already waits for the semaphore is released (0 == False | 1 == True).
+		int isWaitingForSourceUpdateValue;
+
 		/// <summary>
 		/// Backing BindableProperty for the <see cref="Aspect"/> property.
 		/// </summary>
@@ -208,8 +221,12 @@ protected override void OnControlInitialized(Frame control)
 			control.HasShadow = false;
 			control.Padding = 0;
 			control.Content = MainLayout;
+		}
 
-			Image.BindingContextChanged += (s, e) => OnValuePropertyChanged(true);
+		protected override void OnBindingContextChanged()
+		{
+			base.OnBindingContextChanged();
+			OnSourcePropertyChanged(true);
 		}
 
 		protected override void OnSizeAllocated(double width, double height)
@@ -225,10 +242,10 @@ static void OnSizePropertyChanged(BindableObject bindable, object oldValue, obje
 		}
 
 		static void OnValuePropertyChanged(BindableObject bindable, object oldValue, object newValue)
-			=> ((AvatarView)bindable).OnValuePropertyChanged(false);
+			=> ((AvatarView)bindable).OnValuePropertyChanged();
 
 		static void OnSourcePropertyChanged(BindableObject bindable, object oldValue, object newValue)
-			=> ((AvatarView)bindable).OnValuePropertyChanged(true);
+			=> ((AvatarView)bindable).OnSourcePropertyChanged(false);
 
 		void OnSizePropertyChanged()
 		{
@@ -251,32 +268,12 @@ void OnSizePropertyChanged()
 			BatchCommit();
 		}
 
-		async void OnValuePropertyChanged(bool shouldUpdateSource)
+		void OnValuePropertyChanged()
 		{
 			if (Control == null)
 				return;
 
 			Image.BatchBegin();
-			if (shouldUpdateSource)
-			{
-				if (Image.Source == Source)
-					Image.Source = null;
-
-				try
-				{
-					Image.IsVisible = await imageSourceValidator.IsImageSourceValidAsync(Source);
-				}
-				catch (OperationCanceledException)
-				{
-					Forms.Internals.Log.Warning("CancellationException", "IsImageSourceValidAsync was cancelled.");
-				}
-				catch (Exception ex)
-				{
-					Forms.Internals.Log.Warning("Error", ex.Message);
-					throw;
-				}
-				Image.Source = Source;
-			}
 
 			Image.Aspect = Aspect;
 			if (Aspect == Aspect.AspectFit)
@@ -321,6 +318,79 @@ async void OnValuePropertyChanged(bool shouldUpdateSource)
 			Control.BorderColor = BorderColor;
 		}
 
+		async void OnSourcePropertyChanged(bool isBindingContextChanged)
+		{
+			if (Control == null)
+				return;
+
+			// If any thread is already waiting for its turn for updating the source
+			// then the current thread needn't have to stay in the queue in this case.
+			if (Interlocked.CompareExchange(ref isWaitingForSourceUpdateValue, 1, 0) == 1)
+				return;
+
+			try
+			{
+				if (!isBindingContextChanged)
+					imageLoadingTokenSource?.Cancel();
+
+				// Only one thread can update the source at the same time.
+				await imageSourceSemaphore.WaitAsync();
+
+				Interlocked.Exchange(ref isWaitingForSourceUpdateValue, 0);
+
+				if (isBindingContextChanged && (sourceBindingContext?.Equals(BindingContext) ?? false))
+					return;
+
+				// Wait for possible BindingContext change to prevent double image loading.
+				await Task.Delay(1);
+
+				var source = Source;
+				if (source != null)
+					SetInheritedBindingContext(source, BindingContext);
+
+				sourceBindingContext = source?.BindingContext;
+
+				imageLoadingTokenSource = new CancellationTokenSource();
+
+				try
+				{
+					var imageStreamLoadingTask = GetImageStreamLoadingTask(source, imageLoadingTokenSource.Token);
+					if (imageStreamLoadingTask != null)
+					{
+						using var stream = await imageStreamLoadingTask;
+						if (stream != null)
+						{
+							var newStream = new MemoryStream();
+							stream.CopyTo(newStream);
+							newStream.Position = 0;
+							Image.IsVisible = true;
+							source = ImageSource.FromStream(() => newStream);
+						}
+						else
+						{
+							Image.IsVisible = false;
+							source = null;
+						}
+					}
+					else
+						Image.IsVisible = await imageSourceValidator.IsImageSourceValidAsync(source);
+
+					Image.Source = source;
+					OnValuePropertyChanged();
+				}
+				catch (OperationCanceledException)
+				{
+					// Loading was canceled due to a new loading is started.
+				}
+			}
+			finally
+			{
+				imageLoadingTokenSource?.Dispose();
+				imageLoadingTokenSource = null;
+				imageSourceSemaphore.Release();
+			}
+		}
+
 		double CalculateFontSize()
 		{
 			var size = Size;
@@ -332,5 +402,20 @@ async void OnValuePropertyChanged(bool shouldUpdateSource)
 
 			return size * .4;
 		}
+
+		Task<Stream> GetImageStreamLoadingTask(ImageSource source, CancellationToken token)
+			=> source switch
+			{
+				IStreamImageSource streamImageSource => streamImageSource.GetStreamAsync(token),
+				UriImageSource uriImageSource => uriImageSource.Uri != null
+					? new UriImageSource
+					{
+						Uri = uriImageSource.Uri,
+						CachingEnabled = uriImageSource.CachingEnabled,
+						CacheValidity = uriImageSource.CacheValidity
+					}.GetStreamAsync(token)
+					: Task.FromResult<Stream>(null),
+				_ => null
+			};
 	}
-}
\ No newline at end of file
+}
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/SideMenuView/SideMenuView.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/SideMenuView/SideMenuView.shared.cs
index 4dee51967..3b3e0d2a4 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/SideMenuView/SideMenuView.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/SideMenuView/SideMenuView.shared.cs
@@ -67,14 +67,11 @@ public class SideMenuView : BaseTemplatedView<AbsoluteLayout>
 			= BindableProperty.Create(nameof(CurrentGestureShift), typeof(double), typeof(SideMenuView), 0.0, BindingMode.OneWayToSource);
 
 		public static readonly BindableProperty GestureThresholdProperty
-			= BindableProperty.Create(nameof(GestureThreshold), typeof(double), typeof(SideMenuView), 7.0);
+			= BindableProperty.Create(nameof(GestureThreshold), typeof(double), typeof(SideMenuView), -1.0);
 
 		public static readonly BindableProperty CancelVerticalGestureThresholdProperty
 			= BindableProperty.Create(nameof(CancelVerticalGestureThreshold), typeof(double), typeof(SideMenuView), 1.0);
 
-		public static readonly BindableProperty AllowInterceptGestureProperty
-			= BindableProperty.Create(nameof(AllowInterceptGesture), typeof(bool), typeof(SideMenuView), false);
-
 		public static readonly BindableProperty StateProperty
 			= BindableProperty.Create(nameof(State), typeof(SideMenuState), typeof(SideMenuView), SideMenuState.MainViewShown, BindingMode.TwoWay, propertyChanged: OnStatePropertyChanged);
 
@@ -90,36 +87,15 @@ public class SideMenuView : BaseTemplatedView<AbsoluteLayout>
 		public static readonly BindableProperty MenuGestureEnabledProperty
 			= BindableProperty.CreateAttached(nameof(GetMenuGestureEnabled), typeof(bool), typeof(SideMenuView), true);
 
-		internal void OnPanUpdated(object sender, PanUpdatedEventArgs e)
+		public SideMenuView()
 		{
-			var shift = e.TotalX;
-			var verticalShift = e.TotalY;
-			switch (e.StatusType)
-			{
-				case GestureStatus.Started:
-					OnTouchStarted();
-					return;
-				case GestureStatus.Running:
-					OnTouchChanged(shift, verticalShift);
-					return;
-				case GestureStatus.Canceled:
-				case GestureStatus.Completed:
-					if (Device.RuntimePlatform == Device.Android)
-						OnTouchChanged(shift, verticalShift);
-
-					OnTouchEnded();
-					return;
-			}
-		}
-
-		internal async void OnSwiped(SwipeDirection swipeDirection)
-		{
-			await Task.Delay(1);
-			if (isGestureStarted)
-				return;
-
-			var state = ResolveSwipeState(swipeDirection == SwipeDirection.Right);
-			UpdateState(state, true);
+#if __ANDROID__
+			if (System.DateTime.Now.Ticks < 0)
+				_ = new Xamarin.CommunityToolkit.Android.UI.Views.SideMenuViewRenderer(null);
+#elif __IOS__
+			if (System.DateTime.Now.Ticks < 0)
+				_ = new Xamarin.CommunityToolkit.iOS.UI.Views.SideMenuViewRenderer();
+#endif
 		}
 
 		public new ISideMenuList<View> Children
@@ -149,12 +125,6 @@ public double CancelVerticalGestureThreshold
 			set => SetValue(CancelVerticalGestureThresholdProperty, value);
 		}
 
-		public bool AllowInterceptGesture
-		{
-			get => (bool)GetValue(AllowInterceptGestureProperty);
-			set => SetValue(AllowInterceptGestureProperty, value);
-		}
-
 		public SideMenuState State
 		{
 			get => (SideMenuState)GetValue(StateProperty);
@@ -185,6 +155,46 @@ public static bool GetMenuGestureEnabled(BindableObject bindable)
 		public static void SetMenuGestureEnabled(BindableObject bindable, bool value)
 			=> bindable.SetValue(MenuGestureEnabledProperty, value);
 
+		internal void OnPanUpdated(object sender, PanUpdatedEventArgs e)
+		{
+			var shift = e.TotalX;
+			var verticalShift = e.TotalY;
+			switch (e.StatusType)
+			{
+				case GestureStatus.Started:
+					OnTouchStarted();
+					return;
+				case GestureStatus.Running:
+					OnTouchChanged(shift, verticalShift);
+					return;
+				case GestureStatus.Canceled:
+				case GestureStatus.Completed:
+					if (Device.RuntimePlatform == Device.Android)
+						OnTouchChanged(shift, verticalShift);
+
+					OnTouchEnded();
+					return;
+			}
+		}
+
+		internal async void OnSwiped(SwipeDirection swipeDirection)
+		{
+			await Task.Delay(1);
+			if (isGestureStarted)
+				return;
+
+			var state = ResolveSwipeState(swipeDirection == SwipeDirection.Right);
+			UpdateState(state, true);
+		}
+
+		internal bool CheckGestureEnabled(SideMenuPosition menuPosition)
+			=> menuPosition switch
+			{
+				SideMenuPosition.LeftMenu => CheckMenuGestureEnabled(leftMenu),
+				SideMenuPosition.RightMenu => CheckMenuGestureEnabled(rightMenu),
+				_ => true
+			};
+
 		protected override void OnControlInitialized(AbsoluteLayout control)
 		{
 			children.CollectionChanged += OnChildrenCollectionChanged;
@@ -213,6 +223,12 @@ protected override void OnControlInitialized(AbsoluteLayout control)
 			control.LayoutChanged += OnLayoutChanged;
 		}
 
+		protected override void OnSizeAllocated(double width, double height)
+		{
+			base.OnSizeAllocated(width, height);
+			PerformUpdate(false);
+		}
+
 		static View SetupMainViewLayout(View view)
 		{
 			SetLayoutFlags(view, AbsoluteLayoutFlags.All);
@@ -235,7 +251,7 @@ static void OnStatePropertyChanged(BindableObject bindable, object oldValue, obj
 			=> ((SideMenuView)bindable).OnStatePropertyChanged();
 
 		void OnStatePropertyChanged()
-			=> PerformAnimation();
+			=> PerformUpdate();
 
 		void OnTouchStarted()
 		{
@@ -290,13 +306,20 @@ void OnTouchEnded()
 			UpdateState(state, isSwipe);
 		}
 
-		void PerformAnimation()
+		void PerformUpdate(bool isAnimated = true)
 		{
 			var state = State;
 			var start = Shift;
 			var menuWidth = (state == SideMenuState.LeftMenuShown ? leftMenu : rightMenu)?.Width ?? 0;
 			var end = -Sign((int)state) * menuWidth;
 
+			if (!isAnimated)
+			{
+				TryUpdateShift(end, true, false);
+				SetOverlayViewInputTransparent(state);
+				return;
+			}
+
 			var animationLength = (uint)(SideMenuView.animationLength * Abs(start - end) / Width);
 			if (isSwipe)
 			{
@@ -393,7 +416,7 @@ void UpdateState(SideMenuState state, bool isSwipe)
 			this.isSwipe = isSwipe;
 			if (State == state)
 			{
-				PerformAnimation();
+				PerformUpdate();
 				return;
 			}
 			State = state;
@@ -418,7 +441,7 @@ void SetActiveView(bool isLeft)
 				Control.Children.IndexOf(inactiveMenu) < Control.Children.IndexOf(activeMenu))
 				return;
 
-			LowerChild(inactiveMenu);
+			Control.LowerChild(inactiveMenu);
 		}
 
 		bool CheckMenuGestureEnabled(SideMenuState state)
@@ -548,5 +571,8 @@ void OnLayoutChanged(object sender, EventArgs e)
 			Control.RaiseChild(mainView);
 			Control.RaiseChild(overlayView);
 		}
+
+		bool CheckMenuGestureEnabled(View menuView)
+			=> menuView != null && GetMenuGestureEnabled(menuView);
 	}
 }
\ No newline at end of file
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/SideMenuView/SideMenuViewRenderer.android.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/SideMenuView/SideMenuViewRenderer.android.cs
index a5559394b..1b4649fbe 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/SideMenuView/SideMenuViewRenderer.android.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/SideMenuView/SideMenuViewRenderer.android.cs
@@ -12,9 +12,11 @@
 
 namespace Xamarin.CommunityToolkit.Android.UI.Views
 {
-	[Preserve(AllMembers = true)]
+	[Preserve(Conditional = true)]
 	public class SideMenuViewRenderer : VisualElementRenderer<SideMenuView>
 	{
+		const double defaultGestureThreshold = 30.0;
+
 		static Guid? lastTouchHandlerId;
 
 		readonly float density;
@@ -31,14 +33,12 @@ public SideMenuViewRenderer(Context context)
 			: base(context)
 			=> density = context.Resources.DisplayMetrics.Density;
 
+		double GestureThreshold => Element.GestureThreshold >= 0
+			? Element.GestureThreshold
+			: defaultGestureThreshold;
+
 		public override bool OnInterceptTouchEvent(MotionEvent ev)
 		{
-			if (Element.AllowInterceptGesture)
-			{
-				base.OnInterceptTouchEvent(ev);
-				return false;
-			}
-
 			if (ev.ActionMasked == MotionEventActions.Move)
 			{
 				if (lastTouchHandlerId.HasValue && lastTouchHandlerId != elementId)
@@ -81,7 +81,10 @@ bool CheckIsTouchHandled(float xDelta, float yDelta)
 		{
 			var xDeltaAbs = Abs(xDelta);
 			var yDeltaAbs = Abs(yDelta);
-			var isHandled = xDeltaAbs > yDeltaAbs && xDeltaAbs > Element.GestureThreshold;
+			var isHandled = xDeltaAbs > yDeltaAbs
+				&& xDeltaAbs > GestureThreshold
+				&& ((xDelta > 0 && Element.CheckGestureEnabled(SideMenuPosition.LeftMenu))
+				|| (xDelta < 0 && Element.CheckGestureEnabled(SideMenuPosition.RightMenu)));
 
 			Parent?.RequestDisallowInterceptTouchEvent(isHandled);
 			return isHandled;
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/SideMenuView/SideMenuViewRenderer.ios.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/SideMenuView/SideMenuViewRenderer.ios.cs
index 35446655c..9da312c3f 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/SideMenuView/SideMenuViewRenderer.ios.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/SideMenuView/SideMenuViewRenderer.ios.cs
@@ -10,9 +10,11 @@
 
 namespace Xamarin.CommunityToolkit.iOS.UI.Views
 {
-	[Preserve(AllMembers = true)]
+	[Preserve(Conditional = true)]
 	public class SideMenuViewRenderer : VisualElementRenderer<SideMenuView>
 	{
+		const double defaultGestureThreshold = 7.0;
+
 		UISwipeGestureRecognizer leftSwipeGestureRecognizer;
 
 		UISwipeGestureRecognizer rightSwipeGestureRecognizer;
@@ -32,7 +34,11 @@ public SideMenuViewRenderer()
 		}
 
 		bool IsPanGestureHandled
-			=> Abs(Element?.CurrentGestureShift ?? 0) >= Element?.GestureThreshold;
+			=> Element != null && Abs(Element.CurrentGestureShift) >= GestureThreshold;
+
+		double GestureThreshold => Element.GestureThreshold >= 0
+			? Element.GestureThreshold
+			: defaultGestureThreshold;
 
 		public override void AddGestureRecognizer(UIGestureRecognizer gestureRecognizer)
 		{
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/TabView/TabView.shared.cs b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/TabView/TabView.shared.cs
index f1310d1c9..1ace34527 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/TabView/TabView.shared.cs
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Views/TabView/TabView.shared.cs
@@ -210,7 +210,7 @@ public DataTemplate TabContentDataTemplate
 		}
 
 		public static readonly BindableProperty SelectedIndexProperty =
-			BindableProperty.Create(nameof(SelectedIndex), typeof(int), typeof(TabView), -1,
+			BindableProperty.Create(nameof(SelectedIndex), typeof(int), typeof(TabView), -1, BindingMode.TwoWay,
 				propertyChanged: OnSelectedIndexChanged);
 
 		public int SelectedIndex
diff --git a/src/CommunityToolkit/Xamarin.CommunityToolkit/Xamarin.CommunityToolkit.csproj b/src/CommunityToolkit/Xamarin.CommunityToolkit/Xamarin.CommunityToolkit.csproj
index 019c5ca6c..8c05cd600 100644
--- a/src/CommunityToolkit/Xamarin.CommunityToolkit/Xamarin.CommunityToolkit.csproj
+++ b/src/CommunityToolkit/Xamarin.CommunityToolkit/Xamarin.CommunityToolkit.csproj
@@ -79,12 +79,18 @@
     <PackageReference Include="System.ComponentModel" Version="4.3.0" />
     <PackageReference Include="System.ValueTuple" Version="4.5.0" />
     <PackageReference Update="NETStandard.Library" PrivateAssets="all" />
+    <Compile Include="**\*.netstandard.cs" />
+    <Compile Include="**\*.netstandard.*.cs" />
   </ItemGroup>
   <ItemGroup Condition=" $(TargetFramework.StartsWith('netstandard2.0')) ">
     <PackageReference Include="System.Threading.Tasks.Extensions" Version="4.5.4" />
     <PackageReference Include="System.Reflection.Emit.Lightweight" Version="4.7.0" />
+    <Compile Include="**\*.netstandard.cs" />
+    <Compile Include="**\*.netstandard.*.cs" />
   </ItemGroup>
   <ItemGroup Condition=" $(TargetFramework.StartsWith('netstandard2.1')) ">
+    <Compile Include="**\*.netstandard.cs" />
+    <Compile Include="**\*.netstandard.*.cs" />
   </ItemGroup>
   <ItemGroup Condition=" $(TargetFramework.StartsWith('uap10.0')) ">
     <PackageReference Include="System.Threading.Tasks.Extensions" Version="4.5.4" />