From fa853ff823272af4b307521d4b5774165d1c7e2c Mon Sep 17 00:00:00 2001
From: Peter Moore <13384523+legistek@users.noreply.github.com>
Date: Tue, 9 Jul 2019 05:10:13 -0500
Subject: [PATCH] RelativeSource Binding (#4375)

RelativeSource Binding

- fixes #3847

Implement RelativeSource binding modes for Self, TemplatedParent, and FindAncestor. Add unit tests. Pare down TemplateBinding class to use RelativeSource binding mechanism.

* Include RelativeSource member in Binding.Clone

* Fix issue of unit tests being tricked by async in Binding.Apply; permit "Source={RelativeSource...}" in addition to "RelativeSource={RelativeSource..."; allow FindAncestor relative binding source mode to be based on BindingContext type or control type

* Fix unit test wasn't actually testing "Source={RelativeSource...}" syntax.

* Address @StephaneDelcroix's comments. Make FindAncestor relative source binding work even when the ancestor changes.

* Much better mechanism for detecting when a parent changes for relativesource

* Cleanup

* more cleanup

* more cleanup

* Remove async/await for identifying templated parent and ancestor type binding source

* Remove unused code; fix linting

* Update Xamarin.Forms.Core/Binding.cs

Co-Authored-By: Stephane Delcroix <stephane@delcroix.org>

* Update Xamarin.Forms.Core/Binding.cs

Co-Authored-By: Stephane Delcroix <stephane@delcroix.org>

* Update Xamarin.Forms.Core/Binding.cs

Co-Authored-By: Stephane Delcroix <stephane@delcroix.org>

* Update Xamarin.Forms.Core/BindingExpression.cs

Co-Authored-By: Stephane Delcroix <stephane@delcroix.org>

* Update Xamarin.Forms.Core/BindingExpression.cs

Co-Authored-By: Stephane Delcroix <stephane@delcroix.org>

* Update Xamarin.Forms.Core/Binding.cs

Co-Authored-By: Stephane Delcroix <stephane@delcroix.org>

* Ensure TemplateBinding works correctly when reparenting. Cleanup.

* Finish addressing comments; linting cleanup

* Remove private modifier where unneeded
---
 .../Github3847.xaml                                |  35 ++++
 .../Github3847.xaml.cs                             |  78 ++++++++
 .../PerformanceTrackerTemplate.cs                  |   8 +-
 .../Xamarin.Forms.Controls.Issues.Shared.projitems |  10 +
 .../ControlTemplateTests.cs                        |   4 +-
 .../RelativeSourceBindingTests.cs                  | 211 +++++++++++++++++++++
 .../Xamarin.Forms.Core.UnitTests.csproj            |   1 +
 Xamarin.Forms.Core/Binding.cs                      | 125 +++++++++++-
 Xamarin.Forms.Core/BindingExpression.cs            | 110 +++++++++++
 Xamarin.Forms.Core/ContentPresenter.cs             |   2 +-
 Xamarin.Forms.Core/Element.cs                      |  34 ++++
 Xamarin.Forms.Core/ElementTemplate.cs              |   3 +
 Xamarin.Forms.Core/RelativeBindingSource.cs        |  61 ++++++
 Xamarin.Forms.Core/RelativeBindingSourceMode.cs    |  12 ++
 Xamarin.Forms.Core/TemplateBinding.cs              |   3 +-
 Xamarin.Forms.Pages/ListDataPage.cs                |   6 +-
 Xamarin.Forms.Xaml.UnitTests/Issues/Gh3847.xaml    |  47 +++++
 Xamarin.Forms.Xaml.UnitTests/Issues/Gh3847.xaml.cs |  77 ++++++++
 .../MarkupExtensions/RelativeSourceExtension.cs    |  83 ++++++++
 .../MarkupExtensions/TemplateBindingExtension.cs   |  10 +-
 20 files changed, 903 insertions(+), 17 deletions(-)
 create mode 100644 Xamarin.Forms.Controls.Issues/Xamarin.Forms.Controls.Issues.Shared/Github3847.xaml
 create mode 100644 Xamarin.Forms.Controls.Issues/Xamarin.Forms.Controls.Issues.Shared/Github3847.xaml.cs
 create mode 100644 Xamarin.Forms.Core.UnitTests/RelativeSourceBindingTests.cs
 create mode 100644 Xamarin.Forms.Core/RelativeBindingSource.cs
 create mode 100644 Xamarin.Forms.Core/RelativeBindingSourceMode.cs
 create mode 100644 Xamarin.Forms.Xaml.UnitTests/Issues/Gh3847.xaml
 create mode 100644 Xamarin.Forms.Xaml.UnitTests/Issues/Gh3847.xaml.cs
 create mode 100644 Xamarin.Forms.Xaml/MarkupExtensions/RelativeSourceExtension.cs

diff --git a/Xamarin.Forms.Controls.Issues/Xamarin.Forms.Controls.Issues.Shared/Github3847.xaml b/Xamarin.Forms.Controls.Issues/Xamarin.Forms.Controls.Issues.Shared/Github3847.xaml
new file mode 100644
index 0000000..30be783
--- /dev/null
+++ b/Xamarin.Forms.Controls.Issues/Xamarin.Forms.Controls.Issues.Shared/Github3847.xaml
@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ContentPage xmlns="http://xamarin.com/schemas/2014/forms" 
+             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+             x:Class="Xamarin.Forms.Controls.Issues.Github3847"
+             xmlns:local="clr-namespace:Xamarin.Forms.Controls.Issues"
+             BindingContext="{Binding Source={RelativeSource Self}, Path=Company}">
+    
+    <StackLayout Orientation="Vertical">
+
+        <Label Text="RelativeSource Self Binding (ContentPage's BindingContext is bound to its own Company property."/>
+        <StackLayout Orientation="Horizontal">
+            <Label Text="Company Name: "/>
+            <Label Text="{Binding Name}"/>
+        </StackLayout>
+
+        <Label Text="RelativeSource AncestorType Binding based on BindingContext Type (Delete Button Command bound to parent's view model's DeleteEmployeeCommand, thus PersonViewModel does not need a reference to its parent, nor is the DataTemplate dependent on the parent View type.)"/>
+        <Label Text="Employees:"/>
+        <ListView ItemsSource="{Binding Employees}">
+            <ListView.ItemTemplate>
+                <DataTemplate>
+                    <ViewCell>
+                        <StackLayout Orientation="Horizontal">
+                            <Label Text="{Binding FullName}"/>
+                            <Button Text="Delete"
+                                    CommandParameter="{Binding}"
+                                    Command="{Binding 
+                                        Source={RelativeSource AncestorType={x:Type local:CompanyViewModel}}, 
+                                        Path=DeleteEmployeeCommand}"/>
+                        </StackLayout>
+                    </ViewCell>
+                </DataTemplate>
+            </ListView.ItemTemplate>
+        </ListView>
+    </StackLayout>
+</ContentPage>
diff --git a/Xamarin.Forms.Controls.Issues/Xamarin.Forms.Controls.Issues.Shared/Github3847.xaml.cs b/Xamarin.Forms.Controls.Issues/Xamarin.Forms.Controls.Issues.Shared/Github3847.xaml.cs
new file mode 100644
index 0000000..455809f
--- /dev/null
+++ b/Xamarin.Forms.Controls.Issues/Xamarin.Forms.Controls.Issues.Shared/Github3847.xaml.cs
@@ -0,0 +1,78 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+using Xamarin.Forms;
+using Xamarin.Forms.CustomAttributes;
+using Xamarin.Forms.Internals;
+using Xamarin.Forms.Xaml;
+
+namespace Xamarin.Forms.Controls.Issues
+{
+	[Preserve(AllMembers = true)]
+	[Issue(IssueTracker.Github, 3847, "RelativeSource Binding",
+		PlatformAffected.All)]
+	public partial class Github3847 : ContentPage
+	{
+#if APP
+		public Github3847()
+		{
+			InitializeComponent();
+		}
+#endif
+
+		public CompanyViewModel Company { get; } = new CompanyViewModel
+		{
+			Name = "Evilcorp",
+			Employees = new ObservableCollection<PersonViewModel>
+				{
+					new PersonViewModel
+					{
+						FirstName = "John",
+						LastName = "Doe"
+					},
+					new PersonViewModel
+					{
+						FirstName = "George",
+						LastName = "Washington"
+					},
+					new PersonViewModel
+					{
+						FirstName = "Santa",
+						LastName = "Claus",
+					}
+				}
+		};		
+	}
+
+	public class PersonViewModel
+	{
+		public string FirstName { get; set; }
+
+		public string LastName { get; set; }
+
+		public string FullName => $"{FirstName} {LastName}";
+	}
+
+	public class CompanyViewModel
+	{
+		public string Name { get; set; }
+
+		public ObservableCollection<PersonViewModel> Employees { get; set; }
+
+		Command _deleteEmployeeCommand;
+		public Command DeleteEmployeeCommand
+		{
+			get
+			{
+				return _deleteEmployeeCommand ?? (_deleteEmployeeCommand = new Command((employee) =>
+				{
+					this.Employees?.Remove(employee as PersonViewModel);
+				}));
+			}
+		}
+	}
+}
diff --git a/Xamarin.Forms.Controls.Issues/Xamarin.Forms.Controls.Issues.Shared/PerformanceGallery/PerformanceTrackerTemplate.cs b/Xamarin.Forms.Controls.Issues/Xamarin.Forms.Controls.Issues.Shared/PerformanceGallery/PerformanceTrackerTemplate.cs
index a4ca213..0edfb3c 100644
--- a/Xamarin.Forms.Controls.Issues/Xamarin.Forms.Controls.Issues.Shared/PerformanceGallery/PerformanceTrackerTemplate.cs
+++ b/Xamarin.Forms.Controls.Issues/Xamarin.Forms.Controls.Issues.Shared/PerformanceGallery/PerformanceTrackerTemplate.cs
@@ -20,7 +20,7 @@ namespace Xamarin.Forms.Controls
 				HeightRequest = 25,
 				AutomationId = ScenarioId
 			};
-			scenarioLabel.SetBinding(Label.TextProperty, new TemplateBinding(nameof(PerformanceTracker.Scenario)));
+			scenarioLabel.SetBinding(Label.TextProperty, new Binding(nameof(PerformanceTracker.Scenario), source: RelativeBindingSource.TemplatedParent));
 			Children.Add(scenarioLabel);
 
 			var renderTimeLabel = new Label
@@ -32,7 +32,7 @@ namespace Xamarin.Forms.Controls
 				HeightRequest = 25,
 				AutomationId = ActualId
 			};
-			renderTimeLabel.SetBinding(Label.TextProperty, new TemplateBinding(nameof(PerformanceTracker.RenderTime)));
+			renderTimeLabel.SetBinding(Label.TextProperty, new Binding(nameof(PerformanceTracker.RenderTime), source: RelativeBindingSource.TemplatedParent));
 
 			var expectedLabel = new Label
 			{
@@ -43,7 +43,7 @@ namespace Xamarin.Forms.Controls
 				HeightRequest = 25,
 				AutomationId = ExpectedId
 			};
-			expectedLabel.SetBinding(Label.TextProperty, new TemplateBinding(nameof(PerformanceTracker.ExpectedRenderTime)));
+			expectedLabel.SetBinding(Label.TextProperty, new Binding(nameof(PerformanceTracker.ExpectedRenderTime), source: RelativeBindingSource.TemplatedParent));
 
 			var outcomeLabel = new Label
 			{
@@ -54,7 +54,7 @@ namespace Xamarin.Forms.Controls
 				HeightRequest = 25,
 				AutomationId = OutcomeId
 			};
-			outcomeLabel.SetBinding(Label.TextProperty, new TemplateBinding(nameof(PerformanceTracker.Outcome)));
+			outcomeLabel.SetBinding(Label.TextProperty, new Binding(nameof(PerformanceTracker.Outcome), source: RelativeBindingSource.TemplatedParent));
 
 			var horStack = new StackLayout { Orientation = StackOrientation.Horizontal };
 			horStack.Children.Add(renderTimeLabel);
diff --git a/Xamarin.Forms.Controls.Issues/Xamarin.Forms.Controls.Issues.Shared/Xamarin.Forms.Controls.Issues.Shared.projitems b/Xamarin.Forms.Controls.Issues/Xamarin.Forms.Controls.Issues.Shared/Xamarin.Forms.Controls.Issues.Shared.projitems
index c982c22..203b4b5 100644
--- a/Xamarin.Forms.Controls.Issues/Xamarin.Forms.Controls.Issues.Shared/Xamarin.Forms.Controls.Issues.Shared.projitems
+++ b/Xamarin.Forms.Controls.Issues/Xamarin.Forms.Controls.Issues.Shared/Xamarin.Forms.Controls.Issues.Shared.projitems
@@ -46,6 +46,10 @@
       <DependentUpon>CollectionViewBindingErrors.xaml</DependentUpon>
       <SubType>Code</SubType>
     </Compile>
+    <Compile Include="$(MSBuildThisFileDirectory)Github3847.xaml.cs">
+      <DependentUpon>Github3847.xaml</DependentUpon>
+      <SubType>Code</SubType>
+    </Compile>
     <Compile Include="$(MSBuildThisFileDirectory)Issue2102.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Issue1588.xaml.cs">
       <DependentUpon>Issue1588.xaml</DependentUpon>
@@ -1278,6 +1282,12 @@
     </EmbeddedResource>
   </ItemGroup>
   <ItemGroup>
+    <EmbeddedResource Include="$(MSBuildThisFileDirectory)Github3847.xaml">
+      <SubType>Designer</SubType>
+      <Generator>MSBuild:Compile</Generator>
+    </EmbeddedResource>
+  </ItemGroup>
+  <ItemGroup>
     <Compile Update="$(MSBuildThisFileDirectory)Issue6130.xaml.cs">
       <DependentUpon>Issue6130.xaml</DependentUpon>
     </Compile>
diff --git a/Xamarin.Forms.Core.UnitTests/ControlTemplateTests.cs b/Xamarin.Forms.Core.UnitTests/ControlTemplateTests.cs
index cf5442c..9df0587 100644
--- a/Xamarin.Forms.Core.UnitTests/ControlTemplateTests.cs
+++ b/Xamarin.Forms.Core.UnitTests/ControlTemplateTests.cs
@@ -28,7 +28,7 @@ namespace Xamarin.Forms.Core.UnitTests
 			public ContentControl ()
 			{
 				var label = new Label ();
-				label.SetBinding (Label.TextProperty, new TemplateBinding ("Name"));
+				label.SetBinding (Label.TextProperty, new Binding("Name", source: RelativeBindingSource.TemplatedParent));
 
 				Children.Add (label);
 				Children.Add (new ContentPresenter ());
@@ -139,7 +139,7 @@ namespace Xamarin.Forms.Core.UnitTests
 			public TestContent ()
 			{
 				Content = new Entry ();
-				Content.SetBinding (Entry.TextProperty, new TemplateBinding ("Name", BindingMode.TwoWay));
+				Content.SetBinding (Entry.TextProperty, new Binding("Name", BindingMode.TwoWay, source: RelativeBindingSource.TemplatedParent));
 			}
 		}
 
diff --git a/Xamarin.Forms.Core.UnitTests/RelativeSourceBindingTests.cs b/Xamarin.Forms.Core.UnitTests/RelativeSourceBindingTests.cs
new file mode 100644
index 0000000..976139a
--- /dev/null
+++ b/Xamarin.Forms.Core.UnitTests/RelativeSourceBindingTests.cs
@@ -0,0 +1,211 @@
+using System;
+using System.Threading.Tasks;
+using System.ComponentModel;
+using System.Runtime.CompilerServices;
+using NUnit.Framework;
+using Xamarin.Forms;
+
+namespace Xamarin.Forms.Core.UnitTests
+{
+	[TestFixture]
+	public class RelativeSourceBindingTests : BaseTestFixture
+	{
+		[SetUp]
+		public override void Setup()
+		{
+			base.Setup();
+			Device.PlatformServices = new MockPlatformServices();
+		}
+
+		[TearDown]
+		public override void TearDown()
+		{
+			base.TearDown();
+			Device.PlatformServices = null;
+		}
+
+		[Test]
+		public void RelativeSourceSelfBinding()
+		{
+			Label label = new Label
+			{
+				StyleId = "label1"
+			};
+			label.SetBinding(Label.TextProperty, new Binding(nameof(Label.StyleId))
+			{
+				Source = RelativeBindingSource.Self
+			});
+			Assert.AreEqual(label.Text, label.StyleId);
+		}
+
+		[Test]
+		public void RelativeSourceAncestorTypeBinding()
+		{
+			string bindingContext0 = "bc0";
+			string bindingContext1 = "bc1";
+			string bindingContext2 = "bc2";
+
+			StackLayout stack0 = new StackLayout
+			{
+				StyleId = "stack0",
+				BindingContext = bindingContext0,
+			};
+
+			StackLayout stack1 = new StackLayout
+			{
+				StyleId = "stack1",				
+			};
+
+			StackLayout stack2 = new StackLayout
+			{
+				StyleId = "stack2",
+				BindingContext = bindingContext2
+			};
+
+			Label label0 = new Label
+			{
+				StyleId = "label0",
+			};
+			Label label1 = new Label
+			{
+				StyleId = "label1",
+			};
+			Label label2 = new Label
+			{
+				StyleId = "label2",
+			};
+
+			stack0.Children.Add(stack1);
+			stack0.Children.Add(label2);
+			stack1.Children.Add(label0);
+			stack1.Children.Add(label1);
+
+			label0.SetBinding(Label.TextProperty, new Binding
+			{
+				Path = nameof(StackLayout.StyleId),
+				Source = new RelativeBindingSource(
+					mode: RelativeBindingSourceMode.FindAncestor,
+					ancestorType: typeof(StackLayout))
+			});
+			label1.SetBinding(Label.TextProperty, new Binding
+			{
+				Path = nameof(StackLayout.StyleId),
+				Source = new RelativeBindingSource(
+					mode: RelativeBindingSourceMode.FindAncestor,
+					ancestorType: typeof(StackLayout),
+					ancestorLevel: 2)
+			});
+			label2.SetBinding(Label.TextProperty, new Binding
+			{
+				Path = nameof(StackLayout.StyleId),
+				Source = new RelativeBindingSource(
+					mode: RelativeBindingSourceMode.FindAncestor,
+					ancestorType: typeof(StackLayout),
+					ancestorLevel: 10)
+			});
+
+			Assert.AreEqual(label0.Text, stack1.StyleId);
+			Assert.AreEqual(label1.Text, stack0.StyleId);
+			Assert.IsNull(label2.Text);
+
+			// Ensures RelativeBindingSource.AncestorType
+			// works correctly after immediate ancestor changed.
+			stack1.Children.Remove(label0);
+			Assert.IsNull(label0.Text);
+		
+			stack0.Children.Add(label0);
+
+			Assert.AreEqual(label0.Text, stack0.StyleId);
+			Assert.AreEqual(label0.BindingContext, stack0.BindingContext);
+
+			// And after distant ancestor changed
+			stack0.Children.Remove(stack1);
+			stack2.Children.Add(stack1);
+
+			Assert.AreEqual(label1.Text, stack2.StyleId);
+			Assert.AreEqual(label1.BindingContext, stack2.BindingContext);
+
+			// And after parent binding context changed
+			stack2.BindingContext = "foobar";
+			Assert.AreEqual(label1.Text, stack2.StyleId);
+			Assert.AreEqual(label1.BindingContext, "foobar");
+		}
+
+		[Test]
+		public void RelativeSourceTemplatedParentBinding()
+		{
+			var cc1 = new CustomControl
+			{
+				CustomText = "RelativeSource Binding 1!",
+				ControlTemplate = new ControlTemplate(typeof(MyCustomControlTemplate))				
+			};
+			var cc2 = new CustomControl
+			{
+				CustomText = "RelativeSource Binding 2!",
+				ControlTemplate = new ControlTemplate(typeof(MyCustomControlTemplate))
+			};
+
+			var realLabel = cc1.LogicalChildren[0].LogicalChildren[0] as Label;			
+			Assert.AreEqual(cc1.CustomText, realLabel.Text);
+			Assert.AreEqual(realLabel.TemplatedParent, cc1);
+
+			// Test reparenting
+			int templatedParentChangeCount = 0;
+			realLabel.PropertyChanged += (sender, e) =>
+			{
+				if (e.PropertyName == nameof(Element.TemplatedParent))
+					templatedParentChangeCount++;
+			};
+			((StackLayout)realLabel.Parent).Children.Remove(realLabel);
+			Assert.IsNull(realLabel.TemplatedParent);
+			Assert.IsNull(realLabel.Text);
+			((StackLayout)cc2.LogicalChildren[0]).Children.Add(realLabel);
+			Assert.AreEqual(realLabel.TemplatedParent, cc2);
+			Assert.AreEqual(cc2.CustomText, realLabel.Text);
+			Assert.AreEqual(2, templatedParentChangeCount);
+		}
+	}
+
+	public class CustomControl : ContentView
+	{
+		StackLayout _layout = new StackLayout();
+		public CustomControl()
+		{
+		}
+
+		#region string CustomText bindable property
+		public static BindableProperty CustomTextProperty = BindableProperty.Create(
+			"CustomText",
+			typeof(string),
+			typeof(CustomControl),
+			null);
+		public string CustomText
+		{
+			get
+			{
+				return (string)GetValue(CustomTextProperty);
+			}
+			set
+			{
+				SetValue(CustomTextProperty, value);
+			}
+		}
+		#endregion
+	}
+
+	public class MyCustomControlTemplate : StackLayout
+	{
+		Label _label = new Label();
+
+		public MyCustomControlTemplate()
+		{
+			this.Children.Add(_label);
+
+			_label.SetBinding(
+				Label.TextProperty, 
+				new Binding(
+					nameof(CustomControl.CustomText), 
+					source: RelativeBindingSource.TemplatedParent));
+		}
+	}
+}
diff --git a/Xamarin.Forms.Core.UnitTests/Xamarin.Forms.Core.UnitTests.csproj b/Xamarin.Forms.Core.UnitTests/Xamarin.Forms.Core.UnitTests.csproj
index afeea9e..e8b6f61 100644
--- a/Xamarin.Forms.Core.UnitTests/Xamarin.Forms.Core.UnitTests.csproj
+++ b/Xamarin.Forms.Core.UnitTests/Xamarin.Forms.Core.UnitTests.csproj
@@ -86,6 +86,7 @@
     <Compile Include="MenuUnitTests.cs" />
     <Compile Include="PreviewerReflectionTests.cs" />
     <Compile Include="RegionTests.cs" />
+    <Compile Include="RelativeSourceBindingTests.cs" />
     <Compile Include="ShellTests.cs" />
     <Compile Include="SpanTests.cs" />
     <Compile Include="TabIndexTests.cs" />
diff --git a/Xamarin.Forms.Core/Binding.cs b/Xamarin.Forms.Core/Binding.cs
index f9be40b..86f2e8e 100644
--- a/Xamarin.Forms.Core/Binding.cs
+++ b/Xamarin.Forms.Core/Binding.cs
@@ -6,6 +6,7 @@ using System.Linq;
 using System.Linq.Expressions;
 using System.Reflection;
 using System.Text;
+using System.Diagnostics;
 using Xamarin.Forms.Internals;
 
 namespace Xamarin.Forms
@@ -81,6 +82,8 @@ namespace Xamarin.Forms
 			{
 				ThrowIfApplied();
 				_source = value;
+				if ((value as RelativeBindingSource)?.Mode == RelativeBindingSourceMode.TemplatedParent)
+					this.AllowChaining = true;
 			}
 		}
 
@@ -124,11 +127,123 @@ namespace Xamarin.Forms
 			if (src != null && isApplied && fromBindingContextChanged)
 				return;
 
-			object bindingContext = src ?? Context ?? context;
-			if (_expression == null && bindingContext != null)
-				_expression = new BindingExpression(this, SelfPath);
+			if (Source is RelativeBindingSource) { 
+				ApplyRelativeSourceBinding(bindObj, targetProperty);
+			} else {
+				object bindingContext = src ?? Context ?? context;
+				if (_expression == null && bindingContext != null)
+					_expression = new BindingExpression(this, SelfPath);
+				_expression.Apply(bindingContext, bindObj, targetProperty);
+			}
+		}
+
+		void ApplyRelativeSourceBinding(
+			BindableObject targetObject, 
+			BindableProperty targetProperty)
+		{
+			if (!(targetObject is Element elem))
+				throw new InvalidOperationException();
+			if (!(Source is RelativeBindingSource relativeSource))
+				return;
+
+			object resolvedSource = null;			
+
+			switch (relativeSource.Mode)
+			{
+				case RelativeBindingSourceMode.Self:
+					resolvedSource = targetObject;
+					break;
+
+				case RelativeBindingSourceMode.TemplatedParent:
+					_expression.SubscribeToTemplatedParentChanges(elem, targetProperty);
+					resolvedSource = elem.TemplatedParent;
+					break;
+
+				case RelativeBindingSourceMode.FindAncestor:
+				case RelativeBindingSourceMode.FindAncestorBindingContext:
+					ApplyAncestorTypeBinding(elem, targetProperty);
+					return;
+
+				default:
+					throw new InvalidOperationException();
+			}
+
+			_expression.Apply(resolvedSource, targetObject, targetProperty);						
+		}		
+
+		void ApplyAncestorTypeBinding(
+			Element target,
+			BindableProperty targetProperty,
+			Element currentElement = null,
+			int currentLevel = 1,
+			List<Element> chain = null)
+		{			
+			currentElement = currentElement ?? target;
+			chain = chain ?? new List<Element> { target };
+
+			if (currentElement.RealParent is Application)
+				return;
+			if (!(Source is RelativeBindingSource relativeSource))
+				return;
+
+			if (currentElement.RealParent != null)
+			{
+				chain.Add(currentElement.RealParent);
+				if (ElementFitsAncestorTypeAndLevel(currentElement.RealParent, currentLevel))
+				{
+					object resolvedSource;
+					if (relativeSource.Mode == RelativeBindingSourceMode.FindAncestor)
+						resolvedSource = currentElement.RealParent;
+					else
+						resolvedSource = currentElement.RealParent?.BindingContext;
+					_expression.Apply(resolvedSource, target, targetProperty);
+					_expression.SubscribeToAncestryChanges(chain);
+				}
+				else
+				{
+					ApplyAncestorTypeBinding(
+						target, 
+						targetProperty, 
+						currentElement.RealParent, 
+						++currentLevel,
+						chain);
+				}
+			}
+			else
+			{
+				EventHandler onElementParentSet = null;
+				onElementParentSet = (sender, e) =>
+				{
+					currentElement.ParentSet -= onElementParentSet;
+					ApplyAncestorTypeBinding(
+						target, 
+						targetProperty, 
+						currentElement, 
+						currentLevel,
+						chain);
+				};
+				currentElement.ParentSet += onElementParentSet;
+			}			
+		}
+
+		bool ElementFitsAncestorTypeAndLevel(Element element, int level)
+		{
+			if (!(Source is RelativeBindingSource relativeSource))
+				return false;
+
+			if (level < relativeSource.AncestorLevel)
+				return false;
+
+			if (relativeSource.Mode == RelativeBindingSourceMode.FindAncestor &&
+				relativeSource.AncestorType.GetTypeInfo().IsAssignableFrom(element.GetType().GetTypeInfo()))
+				return true;
+
+			if (element.BindingContext != null &&
+				relativeSource.Mode == RelativeBindingSourceMode.FindAncestorBindingContext &&
+				relativeSource.AncestorType.GetTypeInfo().IsAssignableFrom(element.BindingContext.GetType().GetTypeInfo()))
+				return true;
 
-			_expression.Apply(bindingContext, bindObj, targetProperty);
+			return false;
 		}
 
 		internal override BindingBase Clone()
@@ -261,4 +376,4 @@ namespace Xamarin.Forms
 			return builder.ToString();
 		}
 	}
-}
\ No newline at end of file
+}
diff --git a/Xamarin.Forms.Core/BindingExpression.cs b/Xamarin.Forms.Core/BindingExpression.cs
index a4ce9bb..a3f10c9 100644
--- a/Xamarin.Forms.Core/BindingExpression.cs
+++ b/Xamarin.Forms.Core/BindingExpression.cs
@@ -16,9 +16,11 @@ namespace Xamarin.Forms
 
 		readonly List<BindingExpressionPart> _parts = new List<BindingExpressionPart>();
 
+		bool _trackingTemplatedParent;
 		BindableProperty _targetProperty;
 		WeakReference<object> _weakSource;
 		WeakReference<BindableObject> _weakTarget;
+		List<WeakReference<Element>> _ancestryChain;
 
 		internal BindingExpression(BindingBase binding, string path)
 		{
@@ -96,8 +98,17 @@ namespace Xamarin.Forms
 				}
 			}
 
+			if (_trackingTemplatedParent)
+			{
+				BindableObject target = null;
+				if (_weakTarget?.TryGetTarget(out target) == true && target is Element elem)
+					elem.TemplatedParentChanged -= OnTargetTemplatedParentChanged;
+			}
+
 			_weakSource = null;
 			_weakTarget = null;
+
+			ClearAncestryChangeSubscriptions();
 		}
 
 		/// <summary>
@@ -458,6 +469,105 @@ namespace Xamarin.Forms
 			}
 		}
 
+		internal void SubscribeToTemplatedParentChanges(Element target, BindableProperty targetProperty)
+		{
+			_targetProperty = targetProperty;
+			target.TemplatedParentChanged += OnTargetTemplatedParentChanged;
+			_trackingTemplatedParent = true;
+		}
+
+		void OnTargetTemplatedParentChanged(object sender, EventArgs e)
+		{
+			if (!(sender is Element elem) ||
+				!(this.Binding is Binding binding))
+				return;
+			binding.Unapply();
+			binding.Apply(null, elem, _targetProperty);
+		}
+
+		// SubscribeToAncestryChanges, ClearAncestryChangeSubscriptions, FindAncestryIndex, and
+		// OnElementParentSet are used with RelativeSource ancestor-type bindings, to detect when
+		// there has been an ancestry change requiring re-applying the binding, and to minimize
+		// re-applications especially during visual tree building.
+		internal void SubscribeToAncestryChanges(List<Element> chain)
+		{
+			ClearAncestryChangeSubscriptions();
+			if (chain == null)
+				return;
+			_ancestryChain = new List<WeakReference<Element>>();
+			foreach (var elem in chain)
+			{
+				elem.ParentSet += OnElementParentSet;
+				_ancestryChain.Add(new WeakReference<Element>(elem));
+			}
+		}
+
+		void ClearAncestryChangeSubscriptions(int beginningWith = 0)
+		{
+			if (_ancestryChain == null || _ancestryChain.Count == 0)
+				return;
+			int count = _ancestryChain.Count;
+			for (int i = beginningWith; i < count; i++)
+			{
+				Element elem;
+				var weakElement = _ancestryChain.Last();
+				if (weakElement.TryGetTarget(out elem))
+					elem.ParentSet -= OnElementParentSet;
+				_ancestryChain.RemoveAt(_ancestryChain.Count - 1);
+			}
+		}
+
+		// Returns -1 if the member is not in the chain or the
+		// chain is no longer valid.
+		int FindAncestryIndex(Element elem)
+		{
+			for (int i = 0; i < _ancestryChain.Count; i++)
+			{
+				WeakReference<Element> weak = _ancestryChain[i];
+				Element chainMember = null;
+				if (!weak.TryGetTarget(out chainMember))
+					return -1;
+				else if (object.Equals(elem, chainMember))
+					return i;
+			}
+			return -1;
+		}
+
+		void OnElementParentSet(object sender, EventArgs e)
+		{
+			if (!(sender is Element elem) ||
+				!(this.Binding is Binding binding))
+				return;
+
+			BindableObject target = null;
+			if (_weakTarget?.TryGetTarget(out target) != true)
+				return;
+
+			if (elem.Parent == null)
+			{
+				// Remove anything further up in the chain
+				// than the element with the null parent
+				int index = FindAncestryIndex(elem);
+				if (index == -1)
+				{
+					binding.Unapply();
+					return;
+				}
+				if (index + 1 < _ancestryChain.Count)
+					ClearAncestryChangeSubscriptions(index + 1);
+
+				// Force the binding expression to resolve to null
+				// for now, until someone in the chain gets a new
+				// non-null parent.
+				this.ApplyCore(null, target, _targetProperty);
+			}
+			else
+			{
+				binding.Unapply();
+				binding.Apply(null, target, _targetProperty);
+			}
+		}
+
 		class BindingPair
 		{
 			public BindingPair(BindingExpressionPart part, object source, bool isLast)
diff --git a/Xamarin.Forms.Core/ContentPresenter.cs b/Xamarin.Forms.Core/ContentPresenter.cs
index eae849f..26cb1fd 100644
--- a/Xamarin.Forms.Core/ContentPresenter.cs
+++ b/Xamarin.Forms.Core/ContentPresenter.cs
@@ -9,7 +9,7 @@ namespace Xamarin.Forms
 
 		public ContentPresenter()
 		{
-			SetBinding(ContentProperty, new TemplateBinding("Content"));
+			SetBinding(ContentProperty, new Binding("Content", source: RelativeBindingSource.TemplatedParent));
 		}
 
 		public View Content
diff --git a/Xamarin.Forms.Core/Element.cs b/Xamarin.Forms.Core/Element.cs
index cfbcf46..bc2d9e6 100644
--- a/Xamarin.Forms.Core/Element.cs
+++ b/Xamarin.Forms.Core/Element.cs
@@ -214,9 +214,43 @@ namespace Xamarin.Forms
 				OnParentSet();
 
 				OnPropertyChanged();
+
+				RefreshTemplatedParent();
+			}
+		}
+
+		internal event EventHandler TemplatedParentChanged;
+
+		BindableObject _templatedParent;
+		public BindableObject TemplatedParent
+		{
+			get => _templatedParent;
+			private set
+			{
+				_templatedParent = value;
+				TemplatedParentChanged?.Invoke(this, null);
+				OnPropertyChanged();
 			}
 		}
 
+		void RefreshTemplatedParent()
+		{
+			var templatedParent = this.IsTemplateRoot
+				? this.Parent
+				: this.Parent?.TemplatedParent;
+			if (ReferenceEquals(templatedParent, this.TemplatedParent))
+				return;
+
+			this.TemplatedParent = templatedParent;			
+			foreach (var element in this.LogicalChildren)
+			{
+				if (!element.IsTemplateRoot)
+					element.RefreshTemplatedParent();
+			}
+		}
+
+		internal bool IsTemplateRoot { get; set; }
+
 		void IElement.RemoveResourcesChangedListener(Action<object, ResourcesChangedEventArgs> onchanged)
 		{
 			if (_changeHandlers == null)
diff --git a/Xamarin.Forms.Core/ElementTemplate.cs b/Xamarin.Forms.Core/ElementTemplate.cs
index d7e842b..261a5b0 100644
--- a/Xamarin.Forms.Core/ElementTemplate.cs
+++ b/Xamarin.Forms.Core/ElementTemplate.cs
@@ -82,6 +82,9 @@ namespace Xamarin.Forms
 			object item = LoadTemplate();
 			SetupContent(item);
 
+			if (item is Element elem)
+				elem.IsTemplateRoot = true;
+
 			return item;
 		}
 
diff --git a/Xamarin.Forms.Core/RelativeBindingSource.cs b/Xamarin.Forms.Core/RelativeBindingSource.cs
new file mode 100644
index 0000000..2d7bc62
--- /dev/null
+++ b/Xamarin.Forms.Core/RelativeBindingSource.cs
@@ -0,0 +1,61 @@
+using System;
+
+namespace Xamarin.Forms
+{
+	public sealed class RelativeBindingSource
+	{
+		static RelativeBindingSource _self;
+		static RelativeBindingSource _templatedParent;
+
+		public RelativeBindingSource(
+			RelativeBindingSourceMode mode,
+			Type ancestorType = null,
+			int ancestorLevel = 1)
+		{
+			if ((mode == RelativeBindingSourceMode.FindAncestor ||
+				 mode == RelativeBindingSourceMode.FindAncestorBindingContext) &&
+				ancestorType == null)
+			{
+				throw new InvalidOperationException(
+					$"{nameof(RelativeBindingSourceMode.FindAncestor)} and " +
+					$"{nameof(RelativeBindingSourceMode.FindAncestorBindingContext)} " +
+					$"require non-null {nameof(AncestorType)}");
+			}
+
+			Mode = mode;
+			AncestorType = ancestorType;
+			AncestorLevel = ancestorLevel;
+		}
+
+		public RelativeBindingSourceMode Mode
+		{
+			get;
+		}
+
+		public Type AncestorType
+		{
+			get;
+		}
+
+		public int AncestorLevel
+		{
+			get;
+		}
+
+		public static RelativeBindingSource Self
+		{
+			get
+			{
+				return _self ?? (_self = new RelativeBindingSource(RelativeBindingSourceMode.Self));
+			}
+		}
+
+		public static RelativeBindingSource TemplatedParent
+		{
+			get
+			{
+				return _templatedParent ?? (_templatedParent = new RelativeBindingSource(RelativeBindingSourceMode.TemplatedParent));
+			}
+		}		
+	}
+}
diff --git a/Xamarin.Forms.Core/RelativeBindingSourceMode.cs b/Xamarin.Forms.Core/RelativeBindingSourceMode.cs
new file mode 100644
index 0000000..a64a9a7
--- /dev/null
+++ b/Xamarin.Forms.Core/RelativeBindingSourceMode.cs
@@ -0,0 +1,12 @@
+namespace Xamarin.Forms
+{
+	public enum RelativeBindingSourceMode
+	{
+		// 0 reserved for possible future implementation of PreviousData 
+
+		TemplatedParent = 1,
+		Self = 2,
+		FindAncestor = 3,
+		FindAncestorBindingContext = 4,
+	}
+}
diff --git a/Xamarin.Forms.Core/TemplateBinding.cs b/Xamarin.Forms.Core/TemplateBinding.cs
index 9b18f85..dd1ea12 100644
--- a/Xamarin.Forms.Core/TemplateBinding.cs
+++ b/Xamarin.Forms.Core/TemplateBinding.cs
@@ -3,7 +3,8 @@ using System.Globalization;
 
 namespace Xamarin.Forms
 {
-	public class TemplateBinding : BindingBase
+	[Obsolete("Use Binding.Source=RelativeBindingSource.TemplatedParent")]
+	public sealed class TemplateBinding : BindingBase
 	{
 		internal const string SelfPath = ".";
 		IValueConverter _converter;
diff --git a/Xamarin.Forms.Pages/ListDataPage.cs b/Xamarin.Forms.Pages/ListDataPage.cs
index 9b2c788..11f4afe 100644
--- a/Xamarin.Forms.Pages/ListDataPage.cs
+++ b/Xamarin.Forms.Pages/ListDataPage.cs
@@ -6,9 +6,9 @@ namespace Xamarin.Forms.Pages
 	{
 		public ListDataPageControl()
 		{
-			SetBinding(ItemTemplateProperty, new TemplateBinding(DataPage.DefaultItemTemplateProperty.PropertyName));
-			SetBinding(SelectedItemProperty, new TemplateBinding(ListDataPage.SelectedItemProperty.PropertyName, BindingMode.TwoWay));
-			SetBinding(ItemsSourceProperty, new TemplateBinding(DataPage.DataProperty.PropertyName));
+			SetBinding(ItemTemplateProperty, new Binding(DataPage.DefaultItemTemplateProperty.PropertyName, source: RelativeBindingSource.TemplatedParent));
+			SetBinding(SelectedItemProperty, new Binding(ListDataPage.SelectedItemProperty.PropertyName, BindingMode.TwoWay, source: RelativeBindingSource.TemplatedParent));
+			SetBinding(ItemsSourceProperty, new Binding(DataPage.DataProperty.PropertyName, source: RelativeBindingSource.TemplatedParent));
 		}
 	}
 
diff --git a/Xamarin.Forms.Xaml.UnitTests/Issues/Gh3847.xaml b/Xamarin.Forms.Xaml.UnitTests/Issues/Gh3847.xaml
new file mode 100644
index 0000000..23152aa
--- /dev/null
+++ b/Xamarin.Forms.Xaml.UnitTests/Issues/Gh3847.xaml
@@ -0,0 +1,47 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<ContentPage xmlns="http://xamarin.com/schemas/2014/forms"
+             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+             x:Class="Xamarin.Forms.Xaml.UnitTests.Gh3847"
+			 xmlns:local="clr-namespace:Xamarin.Forms.Xaml.UnitTests">
+	<ContentPage.Resources>
+		<ControlTemplate x:Key="CustomControlTemplate">
+			<Label Text="{Binding Source={RelativeSource TemplatedParent}, Path=StyleId}"/>
+		</ControlTemplate>
+	</ContentPage.Resources>
+	<ContentPage.Content>
+		<StackLayout x:Name="Stack0">
+			<StackLayout.BindingContext>
+				<local:Gh3847ViewModel />
+			</StackLayout.BindingContext>
+			<StackLayout x:Name="Stack1"
+						 BindingContext="{x:Null}">
+				
+				<!-- Text = "" -->
+				<Label x:Name="AncestorLevel3Label"
+					   Text="{Binding Source={RelativeSource AncestorType={x:Type StackLayout}, AncestorLevel=3}, Path=StyleId}"/>
+
+				<!-- Text = "Stack0" -->
+				<Label x:Name="AncestorLevel2Label"
+					   Text="{Binding Source={RelativeSource AncestorType={x:Type StackLayout}, AncestorLevel=2}, Path=StyleId}"/>
+
+				<!-- Text = "Foo" -->
+				<!-- (Finding Ancestor by BindingContext (view model) type rather than control (view) type) -->
+				<Label x:Name="AncestorBindingContextLabel"
+					   Text="{Binding Source={RelativeSource AncestorType={x:Type local:Gh3847ViewModel}}, Path=Foo}"/>
+
+				<!-- Text = "Stack1" -->
+				<Label x:Name="AncestorLevel1Label"
+					   Text="{Binding Source={RelativeSource AncestorType={x:Type StackLayout}}, Path=StyleId}"/>
+
+				<!-- Text = "SelfBindingLabel" -->
+				<!-- Note that "Source=" and "RelativeSource=" are both allowed, different from UWP/WPF -->
+				<Label x:Name="SelfBindingLabel"
+					   Text="{Binding Source={RelativeSource Self}, Path=StyleId}"/>
+
+				<!-- Text = "contentView" -->
+				<ContentView x:Name="contentView"
+							 ControlTemplate="{StaticResource CustomControlTemplate}"/>
+			</StackLayout>
+		</StackLayout>
+	</ContentPage.Content>
+</ContentPage>
diff --git a/Xamarin.Forms.Xaml.UnitTests/Issues/Gh3847.xaml.cs b/Xamarin.Forms.Xaml.UnitTests/Issues/Gh3847.xaml.cs
new file mode 100644
index 0000000..b6d71cc
--- /dev/null
+++ b/Xamarin.Forms.Xaml.UnitTests/Issues/Gh3847.xaml.cs
@@ -0,0 +1,77 @@
+using System;
+using System.Collections.Generic;
+using NUnit.Framework;
+
+using Xamarin.Forms;
+using Xamarin.Forms.Core.UnitTests;
+
+namespace Xamarin.Forms.Xaml.UnitTests
+{	
+	public partial class Gh3847 : ContentPage
+	{
+		public Gh3847()
+		{
+			InitializeComponent();
+		}
+
+		public Gh3847(bool useCompiledXaml)
+		{
+			//this stub will be replaced at compile time
+		}
+
+		[TestFixture]
+		class Tests
+		{
+			[SetUp]
+			public void Setup()
+			{
+				Device.PlatformServices = new MockPlatformServices();
+			}
+
+			[TearDown]
+			public void TearDown()
+			{
+				Device.PlatformServices = null;
+			}
+
+			[TestCase(false), TestCase(true)]
+			public void RelativeSourceSelfBinding(bool useCompiledXaml)
+			{
+				var view = new Gh3847(useCompiledXaml);
+				var label = view.FindByName<Label>("SelfBindingLabel");
+				Assert.AreEqual(label.Text, label.StyleId);
+			}
+
+			[TestCase(false), TestCase(true)]
+			public void RelativeSourceAncestorLevelBinding(bool useCompiledXaml)
+			{
+				var view = new Gh3847(useCompiledXaml);
+				var stack0 = view.FindByName<StackLayout>("Stack0");
+				var stack1 = view.FindByName<StackLayout>("Stack1");
+				var level1Label = view.FindByName<Label>("AncestorLevel1Label");
+				var level2Label = view.FindByName<Label>("AncestorLevel2Label");
+				var level3Label = view.FindByName<Label>("AncestorLevel3Label");
+				var ancestorBindingContextLabel = view.FindByName<Label>("AncestorBindingContextLabel");
+
+				Assert.AreEqual(level1Label.Text, stack1.StyleId);
+				Assert.AreEqual(level2Label.Text, stack0.StyleId);
+				Assert.AreEqual(ancestorBindingContextLabel.Text, "Foo");
+				Assert.IsNull(level3Label.Text);
+			}
+
+			[TestCase(false), TestCase(true)]
+			public void RelativeSourceTemplatedParentBinding(bool useCompiledXaml)
+			{
+				var view = new Gh3847(useCompiledXaml);
+				var cv = view.FindByName<ContentView>("contentView");
+				var label = cv.Children[0] as Label;
+				Assert.AreEqual(label.Text, cv.StyleId);
+			}
+		}
+	}
+
+	public class Gh3847ViewModel
+	{
+		public string Foo => "Foo";
+	}
+}
diff --git a/Xamarin.Forms.Xaml/MarkupExtensions/RelativeSourceExtension.cs b/Xamarin.Forms.Xaml/MarkupExtensions/RelativeSourceExtension.cs
new file mode 100644
index 0000000..9f485f9
--- /dev/null
+++ b/Xamarin.Forms.Xaml/MarkupExtensions/RelativeSourceExtension.cs
@@ -0,0 +1,83 @@
+using System;
+using System.Reflection;
+
+namespace Xamarin.Forms.Xaml
+{
+	[ContentProperty("Mode")]
+	[AcceptEmptyServiceProvider]
+	public sealed class RelativeSourceExtension : IMarkupExtension<RelativeBindingSource>
+	{
+		public RelativeBindingSourceMode Mode
+		{
+			get;
+			set;
+		}
+
+		public int AncestorLevel
+		{
+			get;
+			set;
+		}
+
+		public Type AncestorType
+		{
+			get;
+			set;
+		}
+
+		RelativeBindingSource IMarkupExtension<RelativeBindingSource>.ProvideValue(IServiceProvider serviceProvider)
+		{
+			if (AncestorType != null)
+			{
+				RelativeBindingSourceMode actualMode;
+
+				if (Mode != RelativeBindingSourceMode.FindAncestor && 
+					Mode != RelativeBindingSourceMode.FindAncestorBindingContext)
+				{
+					// Note to documenters:
+
+					// This permits "{Binding Source={RelativeSource AncestorType={x:Type MyType}}}" syntax
+					// where Mode hasn't been explicitly set, consistent with WPF.
+
+					// Also, we assume FindAncestor is meant if the ancestor type is a visual 
+					// Element, otherwise assume FindAncestorBindingContext is intended. (The
+					// mode can also be explicitly set in XAML)
+					actualMode = typeof(Element).GetTypeInfo().IsAssignableFrom(AncestorType.GetTypeInfo())
+						? RelativeBindingSourceMode.FindAncestor
+						: RelativeBindingSourceMode.FindAncestorBindingContext;
+				}
+				else
+				{
+					actualMode = Mode;
+				}
+
+				return new RelativeBindingSource(actualMode, AncestorType, AncestorLevel);
+			}
+			else if (Mode == RelativeBindingSourceMode.FindAncestor || 
+					Mode == RelativeBindingSourceMode.FindAncestorBindingContext)
+			{
+				throw new XamlParseException(
+					$"{nameof(RelativeBindingSourceMode.FindAncestor)} and " +
+					$"{nameof(RelativeBindingSourceMode.FindAncestorBindingContext)} " +
+					$"require {nameof(AncestorType)}.");
+			}
+			else if (Mode == RelativeBindingSourceMode.Self)
+			{
+				return RelativeBindingSource.Self;
+			}
+			else if (Mode == RelativeBindingSourceMode.TemplatedParent)
+			{
+				return RelativeBindingSource.TemplatedParent;
+			}
+			else
+			{
+				throw new XamlParseException($"Invalid {nameof(Mode)}");
+			}
+		}
+
+		public object ProvideValue(IServiceProvider serviceProvider)
+		{
+			return (this as IMarkupExtension<RelativeBindingSource>).ProvideValue(serviceProvider);
+		}
+	}
+}
diff --git a/Xamarin.Forms.Xaml/MarkupExtensions/TemplateBindingExtension.cs b/Xamarin.Forms.Xaml/MarkupExtensions/TemplateBindingExtension.cs
index 7b3d81b..0c10c51 100644
--- a/Xamarin.Forms.Xaml/MarkupExtensions/TemplateBindingExtension.cs
+++ b/Xamarin.Forms.Xaml/MarkupExtensions/TemplateBindingExtension.cs
@@ -24,7 +24,15 @@ namespace Xamarin.Forms.Xaml
 
 		BindingBase IMarkupExtension<BindingBase>.ProvideValue(IServiceProvider serviceProvider)
 		{
-			return new TemplateBinding(Path, Mode, Converter, ConverterParameter, StringFormat);
+			return new Binding
+			{
+				Source = RelativeBindingSource.TemplatedParent,
+				Path = Path,
+				Mode = Mode,
+				Converter = Converter,
+				ConverterParameter = ConverterParameter,
+				StringFormat = StringFormat
+			};		
 		}
 
 		object IMarkupExtension.ProvideValue(IServiceProvider serviceProvider)
-- 
2.7.4