From 1a77291dbc86c98ad64baa58c5720abd87003367 Mon Sep 17 00:00:00 2001
From: Ankit Sinha <ankitbko@gmail.com>
Date: Wed, 28 Jun 2017 02:03:44 +0530
Subject: [PATCH 1/6] Added PolicyRegistry Feature (#231)

* Added IPolicyRegistry interface
* Implemented IPolicyRegistry interface as DefaultPolicyRegistry using Dictionary<string,> as backend store
* Changed the implementation to use ConcurrentDictionary

* Polly now targets .NETStandard 1.1
* Pcl.Specs now targets PCL Profile 111.
* Renamed folder and csproj from Polly.NetStandard10 to Polly.NetStandard11
* Updated Cake script to reflect folder and csproj renaming to NetStandard11

* Added unit test cases for DefaultPolicyRegistry
* Added a test to check adding policy with duplicate key through indexer  should overwrite.
* Add and Retrieve through indexer are now separate tests

* Added tests to check
- Exception thrown when retrieving when key does not exist
- Exception thrown when key is null while adding, removing and retriving policy.
* Added test to check if exception is thrown when key is null which using ContainsKey
---
 build.cake                                    |   8 +-
 .../Polly.NetStandard11.csproj}               |   0
 .../Properties/AssemblyInfo.cs                |   0
 .../project.json                              |   2 +-
 src/Polly.Pcl.Specs/Polly.Pcl.Specs.csproj    |  10 +-
 src/Polly.Pcl.Specs/packages.config           |  16 +-
 src/Polly.Shared/Polly.Shared.projitems       |   2 +
 .../Registry/DefaultPolicyRegistry.cs         |  82 +++++++
 src/Polly.Shared/Registry/IPolicyRegistry.cs  |  69 ++++++
 .../Polly.SharedSpecs.projitems               |   1 +
 .../Registry/DefaultPolicyRegistrySpecs.cs    | 223 ++++++++++++++++++
 src/Polly.sln                                 |  16 +-
 12 files changed, 403 insertions(+), 26 deletions(-)
 rename src/{Polly.NetStandard10/Polly.NetStandard10.csproj => Polly.NetStandard11/Polly.NetStandard11.csproj} (100%)
 rename src/{Polly.NetStandard10 => Polly.NetStandard11}/Properties/AssemblyInfo.cs (100%)
 rename src/{Polly.NetStandard10 => Polly.NetStandard11}/project.json (80%)
 create mode 100644 src/Polly.Shared/Registry/DefaultPolicyRegistry.cs
 create mode 100644 src/Polly.Shared/Registry/IPolicyRegistry.cs
 create mode 100644 src/Polly.SharedSpecs/Registry/DefaultPolicyRegistrySpecs.cs

diff --git a/build.cake b/build.cake
index dde3bc5ad13..a7286210bd7 100644
--- a/build.cake
+++ b/build.cake
@@ -49,7 +49,7 @@ var snkFile = srcDir + File(keyName);
 
 var projectToNugetFolderMap = new Dictionary<string, string[]>() {
     { "Net45"        , new [] {"net45"} },
-    { "NetStandard10", new [] {"netstandard1.0"} },
+    { "NetStandard11", new [] {"netstandard1.1"} },
 };
 
 var net40AsyncProjectToNugetFolderMap = new Dictionary<string, string[]>() {
@@ -141,11 +141,11 @@ Task("__UpdateDotNetStandardAssemblyVersionNumber")
     // NOTE: TEMPORARY fix only, while GitVersionTask does not support .Net Standard assemblies.  See https://github.com/App-vNext/Polly/issues/176.  
     // This build Task can be removed when GitVersionTask supports .Net Standard assemblies.
     var assemblySemVer = gitVersionOutput["AssemblySemVer"].ToString();
-    Information("Updating NetStandard10 AssemblyVersion to {0}", assemblySemVer);
-    var replacedFiles = ReplaceRegexInFiles("./src/Polly.NetStandard10/Properties/AssemblyInfo.cs", "AssemblyVersion[(]\".*\"[)]", "AssemblyVersion(\"" + assemblySemVer +"\")");
+    Information("Updating NetStandard11 AssemblyVersion to {0}", assemblySemVer);
+    var replacedFiles = ReplaceRegexInFiles("./src/Polly.NetStandard11/Properties/AssemblyInfo.cs", "AssemblyVersion[(]\".*\"[)]", "AssemblyVersion(\"" + assemblySemVer +"\")");
     if (!replacedFiles.Any())
     {
-        Information("NetStandard1.0 AssemblyVersion could not be updated.");
+        Information("NetStandard1.1 AssemblyVersion could not be updated.");
     }
 });
 
diff --git a/src/Polly.NetStandard10/Polly.NetStandard10.csproj b/src/Polly.NetStandard11/Polly.NetStandard11.csproj
similarity index 100%
rename from src/Polly.NetStandard10/Polly.NetStandard10.csproj
rename to src/Polly.NetStandard11/Polly.NetStandard11.csproj
diff --git a/src/Polly.NetStandard10/Properties/AssemblyInfo.cs b/src/Polly.NetStandard11/Properties/AssemblyInfo.cs
similarity index 100%
rename from src/Polly.NetStandard10/Properties/AssemblyInfo.cs
rename to src/Polly.NetStandard11/Properties/AssemblyInfo.cs
diff --git a/src/Polly.NetStandard10/project.json b/src/Polly.NetStandard11/project.json
similarity index 80%
rename from src/Polly.NetStandard10/project.json
rename to src/Polly.NetStandard11/project.json
index df51d04336a..a5bea354690 100644
--- a/src/Polly.NetStandard10/project.json
+++ b/src/Polly.NetStandard11/project.json
@@ -4,6 +4,6 @@
     "NETStandard.Library": "1.6.1"
   },
   "frameworks": {
-    "netstandard1.0": {}
+    "netstandard1.1": {}
   }
 }
\ No newline at end of file
diff --git a/src/Polly.Pcl.Specs/Polly.Pcl.Specs.csproj b/src/Polly.Pcl.Specs/Polly.Pcl.Specs.csproj
index 96930ecd2f6..54b2ac7170c 100644
--- a/src/Polly.Pcl.Specs/Polly.Pcl.Specs.csproj
+++ b/src/Polly.Pcl.Specs/Polly.Pcl.Specs.csproj
@@ -14,7 +14,7 @@
     <DefaultLanguage>en-US</DefaultLanguage>
     <FileAlignment>512</FileAlignment>
     <ProjectTypeGuids>{786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <TargetFrameworkProfile>Profile259</TargetFrameworkProfile>
+    <TargetFrameworkProfile>Profile111</TargetFrameworkProfile>
     <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
     <NuGetPackageImportStamp>
     </NuGetPackageImportStamp>
@@ -72,21 +72,21 @@
     <None Include="packages.config" />
   </ItemGroup>
   <ItemGroup>
-    <ProjectReference Include="..\Polly.NetStandard10\Polly.NetStandard10.csproj">
+    <ProjectReference Include="..\Polly.NetStandard11\Polly.NetStandard11.csproj">
       <Project>{5017174e-dac5-4408-ab15-1f902f40c612}</Project>
-      <Name>Polly.NetStandard10</Name>
+      <Name>Polly.NetStandard11</Name>
     </ProjectReference>
   </ItemGroup>
   <Import Project="..\Polly.SharedSpecs\Polly.SharedSpecs.projitems" Label="Shared" />
   <Import Project="$(MSBuildExtensionsPath32)\Microsoft\Portable\$(TargetFrameworkVersion)\Microsoft.Portable.CSharp.targets" />
+  <Import Project="..\packages\GitVersionTask.3.1.2\Build\portable-net+sl+win+wpa+wp\GitVersionTask.targets" Condition="Exists('..\packages\GitVersionTask.3.1.2\Build\portable-net+sl+win+wpa+wp\GitVersionTask.targets')" />
   <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
     <PropertyGroup>
       <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
     </PropertyGroup>
+    <Error Condition="!Exists('..\packages\GitVersionTask.3.1.2\Build\portable-net+sl+win+wpa+wp\GitVersionTask.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\GitVersionTask.3.1.2\Build\portable-net+sl+win+wpa+wp\GitVersionTask.targets'))" />
     <Error Condition="!Exists('..\packages\xunit.core.2.1.0\build\portable-net45+win8+wp8+wpa81\xunit.core.props')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\xunit.core.2.1.0\build\portable-net45+win8+wp8+wpa81\xunit.core.props'))" />
-    <Error Condition="!Exists('..\packages\GitVersionTask.3.1.2\build\portable-net+sl+win+wpa+wp\GitVersionTask.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\GitVersionTask.3.1.2\build\portable-net+sl+win+wpa+wp\GitVersionTask.targets'))" />
   </Target>
-  <Import Project="..\packages\GitVersionTask.3.1.2\build\portable-net+sl+win+wpa+wp\GitVersionTask.targets" Condition="Exists('..\packages\GitVersionTask.3.1.2\build\portable-net+sl+win+wpa+wp\GitVersionTask.targets')" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
   <Target Name="BeforeBuild">
diff --git a/src/Polly.Pcl.Specs/packages.config b/src/Polly.Pcl.Specs/packages.config
index 105682e81f5..4b44621345c 100644
--- a/src/Polly.Pcl.Specs/packages.config
+++ b/src/Polly.Pcl.Specs/packages.config
@@ -1,11 +1,11 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
-  <package id="FluentAssertions" version="4.17.0" targetFramework="portable45-net45+win8+wp8+wpa81" />
-  <package id="GitVersionTask" version="3.1.2" targetFramework="portable45-net45+win8+wp8+wpa81" developmentDependency="true" />
-  <package id="xunit" version="2.1.0" targetFramework="portable45-net45+win8+wp8+wpa81" />
-  <package id="xunit.abstractions" version="2.0.0" targetFramework="portable45-net45+win8+wp8+wpa81" />
-  <package id="xunit.assert" version="2.1.0" targetFramework="portable45-net45+win8+wp8+wpa81" />
-  <package id="xunit.core" version="2.1.0" targetFramework="portable45-net45+win8+wp8+wpa81" />
-  <package id="xunit.extensibility.core" version="2.1.0" targetFramework="portable45-net45+win8+wp8+wpa81" />
-  <package id="xunit.extensibility.execution" version="2.1.0" targetFramework="portable45-net45+win8+wp8+wpa81" />
+  <package id="FluentAssertions" version="4.17.0" targetFramework="portable45-net45+win8+wpa81" />
+  <package id="GitVersionTask" version="3.1.2" targetFramework="portable45-net45+win8+wpa81" developmentDependency="true" />
+  <package id="xunit" version="2.1.0" targetFramework="portable45-net45+win8+wpa81" />
+  <package id="xunit.abstractions" version="2.0.0" targetFramework="portable45-net45+win8+wpa81" />
+  <package id="xunit.assert" version="2.1.0" targetFramework="portable45-net45+win8+wpa81" />
+  <package id="xunit.core" version="2.1.0" targetFramework="portable45-net45+win8+wpa81" />
+  <package id="xunit.extensibility.core" version="2.1.0" targetFramework="portable45-net45+win8+wpa81" />
+  <package id="xunit.extensibility.execution" version="2.1.0" targetFramework="portable45-net45+win8+wpa81" />
 </packages>
\ No newline at end of file
diff --git a/src/Polly.Shared/Polly.Shared.projitems b/src/Polly.Shared/Polly.Shared.projitems
index a11e9270b44..07ae8435530 100644
--- a/src/Polly.Shared/Polly.Shared.projitems
+++ b/src/Polly.Shared/Polly.Shared.projitems
@@ -68,6 +68,8 @@
     <Compile Include="$(MSBuildThisFileDirectory)PolicyBuilder.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)PolicyBuilder.OrSyntax.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)PolicyResult.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Registry\DefaultPolicyRegistry.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Registry\IPolicyRegistry.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)ResultPredicate.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Retry\RetrySyntax.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Retry\RetrySyntaxAsync.cs" />
diff --git a/src/Polly.Shared/Registry/DefaultPolicyRegistry.cs b/src/Polly.Shared/Registry/DefaultPolicyRegistry.cs
new file mode 100644
index 00000000000..c36bd0c9ba7
--- /dev/null
+++ b/src/Polly.Shared/Registry/DefaultPolicyRegistry.cs
@@ -0,0 +1,82 @@
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.Concurrent;
+using System;
+
+namespace Polly.Registry
+{
+    /// <summary>
+    /// Stores a registry of <see cref="System.String"/> and <see cref="Policy"/> pair.
+    /// </summary>
+    /// <remarks>Uses ConcurrentDictionary to store the collection.</remarks>
+    public class DefaultPolicyRegistry : IPolicyRegistry<string, Policy>
+    {
+        private IDictionary<string, Policy> _registry = new ConcurrentDictionary<string, Policy>();
+
+        /// <summary>
+        /// Gets or sets the <see cref="Policy"/> associated with the specified key.
+        /// </summary>
+        /// <param name="key">The key of the <see cref="Policy"/> to get or set.</param>
+        /// <returns>The <see cref="Policy"/> with specified <paramref name="key"/>.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="key"/> is null.</exception>
+        /// <exception cref="KeyNotFoundException">Policy with the specified <paramref name="key"/> does not exists in the registry.</exception>
+        public Policy this[string key]
+        {
+            get { return _registry[key]; }
+
+            set { _registry[key] = value; }
+        }
+
+        /// <summary>
+        /// Total number of policies in the registry.
+        /// </summary>
+        public int Count => _registry.Count;
+
+        /// <summary>
+        /// Adds an element with the provided key and <see cref="Policy"/> to the registry.
+        /// </summary>
+        /// <param name="key">The string to use as the key of the element to add.</param>
+        /// <param name="value">The <see cref="Policy"/> to store in the registry.</param>
+        /// <exception cref="ArgumentNullException"><paramref name="key"/> is null.</exception>
+        /// <exception cref="ArgumentException">A Policy with same <paramref name="key"/> already exists.</exception>
+        public void Add(string key, Policy value) =>
+            _registry.Add(key, value);
+
+        /// <summary>
+        /// Removes all keys and policies from registry.
+        /// </summary>
+        public void Clear() =>
+            _registry.Clear();
+
+        /// <summary>
+        /// Determines whether the specified <paramref name="key"/> exists.
+        /// </summary>
+        /// <param name="key">The key to locate in the registry.</param>
+        /// <returns>True if <paramref name="key"/> exists otherwise false.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="key"/> is null.</exception>
+        public bool ContainsKey(string key) =>
+            _registry.ContainsKey(key);
+
+        /// <summary>
+        /// Removes the stored <see cref="Policy"/> under specified <paramref name="key"/> from the registry.
+        /// </summary>
+        /// <param name="key">The <paramref name="key"/> of the policy to remove.</param>
+        /// <returns>True if <see cref="Policy"/> is successfully removed. Otherwise false.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="key"/> is null.</exception>
+        public bool Remove(string key) =>
+            _registry.Remove(key);
+
+        /// <summary>
+        /// Gets the <see cref="Policy"/> associated with the specified key.
+        /// </summary>
+        /// <param name="key">The key whose value to get.</param>
+        /// <param name="value">
+        /// This method returns the <see cref="Policy"/> associated with the specified <paramref name="key"/>, if the
+        /// key is found; otherwise null.
+        /// This parameter is passed uninitialized.
+        /// </param>
+        /// <returns>True if Policy exists for the provided Key. False otherwise.</returns>
+        public bool TryGetValue(string key, out Policy value) =>
+            _registry.TryGetValue(key, out value);
+    }
+}
diff --git a/src/Polly.Shared/Registry/IPolicyRegistry.cs b/src/Polly.Shared/Registry/IPolicyRegistry.cs
new file mode 100644
index 00000000000..f022f78df15
--- /dev/null
+++ b/src/Polly.Shared/Registry/IPolicyRegistry.cs
@@ -0,0 +1,69 @@
+using System;
+using System.Collections.Generic;
+
+namespace Polly.Registry
+{
+    /// <summary>
+    /// Represents a collection of <see cref="Polly.Policy"/> keyed by <typeparamref name="TKey"/>.
+    /// </summary>
+    /// <typeparam name="TKey">The type of keys in the dictionary.</typeparam>
+    /// <typeparam name="TPolicy">The type of Policy to store. Must be derived from <see cref="Polly.Policy"/>.</typeparam>
+    public interface IPolicyRegistry<TKey, TPolicy> where TPolicy: Polly.Policy
+    {
+        /// <summary>
+        /// Gets or sets <typeparamref name="TPolicy"/> with specified Key.
+        /// </summary>
+        /// <param name="key">The key of the policy to get or set.</param>
+        /// <returns>The policy with specified Key.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="key"/> is null.</exception>
+        /// <exception cref="KeyNotFoundException">Policy with the specified <paramref name="key"/> is not found in the registry.</exception>
+        TPolicy this[TKey key] { get; set; }
+
+        /// <summary>
+        /// Total number of policies in the registry.
+        /// </summary>
+        int Count { get; }
+
+        /// <summary>
+        /// Adds a <typeparamref name="TPolicy"/> with the provided key to the registry.
+        /// </summary>
+        /// <param name="key">The key of the <typeparamref name="TPolicy"/> to add.</param>
+        /// <param name="value">The <typeparamref name="TPolicy"/> to store in the registry.</param>
+        /// <exception cref="ArgumentNullException"><paramref name="key"/> is null.</exception>
+        /// <exception cref="ArgumentException">A Policy with same <paramref name="key"/> already exists.</exception>
+        void Add(TKey key, TPolicy value);
+
+        /// <summary>
+        /// Determines whether the specified <paramref name="key"/> exists.
+        /// </summary>
+        /// <param name="key">The Key to locate in the registry</param>
+        /// <returns>True if <paramref name="key"/> exists otherwise false</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="key"/> is null</exception>
+        bool ContainsKey(TKey key);
+
+        /// <summary>
+        /// Removes the specified <typeparamref name="TPolicy"/> from the registry.
+        /// </summary>
+        /// <param name="key">The key of the policy to remove.</param>
+        /// <returns>True if <see cref="Polly.Policy"/> is successfully removed. Otherwise false.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="key"/> is null.</exception>
+        bool Remove(TKey key);
+
+        /// <summary>
+        /// Gets the <typeparamref name="TPolicy"/> associated with the specified key.
+        /// </summary>
+        /// <param name="key">The key whose value to get.</param>
+        /// <param name="value">
+        /// This method returns the <typeparamref name="TPolicy"/> associated with the specified <paramref name="key"/>, if the
+        /// key is found; otherwise null.
+        /// This parameter is passed uninitialized.
+        /// </param>
+        /// <returns>True if Policy exists for the provided Key. False otherwise.</returns>
+        bool TryGetValue(TKey key, out TPolicy value);
+
+        /// <summary>
+        /// Removes all keys and policies from registry.
+        /// </summary>
+        void Clear();
+    }
+}
diff --git a/src/Polly.SharedSpecs/Polly.SharedSpecs.projitems b/src/Polly.SharedSpecs/Polly.SharedSpecs.projitems
index 76286891252..e2b0ba99731 100644
--- a/src/Polly.SharedSpecs/Polly.SharedSpecs.projitems
+++ b/src/Polly.SharedSpecs/Polly.SharedSpecs.projitems
@@ -49,6 +49,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)PolicyContextAndKeyAsyncSpecs.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)PolicyContextAndKeySpecs.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)PolicySpecs.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Registry\DefaultPolicyRegistrySpecs.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Retry\RetryAsyncSpecs.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Retry\RetryForeverAsyncSpecs.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Retry\RetryForeverSpecs.cs" />
diff --git a/src/Polly.SharedSpecs/Registry/DefaultPolicyRegistrySpecs.cs b/src/Polly.SharedSpecs/Registry/DefaultPolicyRegistrySpecs.cs
new file mode 100644
index 00000000000..e81161b8ded
--- /dev/null
+++ b/src/Polly.SharedSpecs/Registry/DefaultPolicyRegistrySpecs.cs
@@ -0,0 +1,223 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Xunit;
+using FluentAssertions;
+using Polly.Registry;
+using Polly.NoOp;
+
+namespace Polly.Specs.Registry
+{
+    public class DefaultPolicyRegistrySpecs
+    {
+        IPolicyRegistry<string, Policy> _registry;
+
+        public DefaultPolicyRegistrySpecs()
+        {
+            _registry = new DefaultPolicyRegistry();
+        }
+
+        #region Tests for adding Policy
+
+        [Fact]
+        public void Should_be_able_to_add_Policy_using_Add()
+        {
+            Policy policy = Policy.NoOp();
+            string key = Guid.NewGuid().ToString();
+
+            _registry.Add(key, policy);
+            _registry.Count.Should().Be(1);
+
+            Policy policy2 = Policy.NoOp();
+            string key2 = Guid.NewGuid().ToString();
+
+            _registry.Add(key2, policy2);
+            _registry.Count.Should().Be(2);
+        }
+
+        [Fact]
+        public void Should_be_able_to_add_Policy_using_Indexer()
+        {
+            Policy policy = Policy.NoOp();
+            string key = Guid.NewGuid().ToString();
+
+            _registry[key] = policy;
+            _registry.Count.Should().Be(1);
+
+            Policy policy2 = Policy.NoOp();
+            string key2 = Guid.NewGuid().ToString();
+
+            _registry[key2] = policy2;
+            _registry.Count.Should().Be(2);
+        }
+
+        [Fact]
+        public void Should_not_be_able_to_add_Policy_with_duplicate_key_using_Add()
+        {
+            Policy policy = Policy.NoOp();
+            string key = Guid.NewGuid().ToString();
+
+            _registry.Invoking(r => r.Add(key, policy))
+                .ShouldNotThrow();
+
+            _registry.Invoking(r => r.Add(key, policy))
+                .ShouldThrow<ArgumentException>();
+
+            _registry.Count.Should().Be(1);
+        }
+
+        [Fact]
+        public void Should_be_able_to_overwrite_existing_Policy_if_key_exists_when_inserting_using_Idexer()
+        {
+            Policy policy = Policy.NoOp();
+            string key = Guid.NewGuid().ToString();
+            _registry.Add(key, policy);
+
+            Policy policy_new = Policy.NoOp();
+            _registry[key] = policy_new;
+            _registry.Count.Should().Be(1);
+
+            _registry[key].Should().BeSameAs(policy_new);
+        }
+
+        [Fact]
+        public void Should_throw_when_adding_Policy_using_Add_when_key_is_null()
+        {
+            string key = null;
+            Policy policy = Policy.NoOp();
+            _registry.Invoking(r => r.Add(key, policy))
+                .ShouldThrow<ArgumentNullException>();
+        }
+
+        [Fact]
+        public void Should_throw_when_adding_Policy_using_Indexer_when_key_is_null()
+        {
+            string key = null;
+            Policy policy = Policy.NoOp();
+            _registry.Invoking(r => r[key] = policy)
+                .ShouldThrow<ArgumentNullException>();
+        }
+
+        #endregion
+
+        #region Tests for retrieving policy
+        [Fact]
+        public void Should_be_able_to_retrieve_stored_Policy_using_TryGetValue()
+        {
+            Policy policy = Policy.NoOp();
+            string key = Guid.NewGuid().ToString();
+            Policy outPolicy = null;
+
+            _registry.Add(key, policy);
+            _registry.TryGetValue(key, out outPolicy).Should().BeTrue();
+            outPolicy.Should().BeSameAs(policy);
+        }
+
+        [Fact]
+        public void Should_be_able_to_retrieve_stored_Policy_using_Indexer()
+        {
+            Policy policy = Policy.NoOp();
+            string key = Guid.NewGuid().ToString();
+
+            _registry.Add(key, policy);
+            _registry[key].Should().BeSameAs(policy);
+        }
+
+        [Fact]
+        public void Should_not_throw_while_retrieving_when_key_does_not_exist_using_TryGetValue()
+        {
+            string key = Guid.NewGuid().ToString();
+            Policy outPolicy = null;
+            bool result = false;
+
+            _registry.Invoking(r => result = r.TryGetValue(key, out outPolicy))
+                .ShouldNotThrow();
+
+            result.Should().BeFalse();
+        }
+
+        [Fact]
+        public void Should_throw_while_retrieving_using_indexer_when_key_does_not_exist()
+        {
+            string key = Guid.NewGuid().ToString();
+            Policy policy = null;
+            _registry.Invoking(r => policy = r[key])
+                .ShouldThrow<KeyNotFoundException>();
+        }
+
+        [Fact]
+        public void Should_throw_when_retrieving_using_indexer_when_key_is_null()
+        {
+            string key = null;
+            Policy policy = null;
+            _registry.Invoking(r => policy = r[key])
+                .ShouldThrow<ArgumentNullException>();
+        }
+        #endregion
+
+        #region Tests for removing policy
+        [Fact]
+        public void Should_be_able_to_clear_registry()
+        {
+            Policy policy = Policy.NoOp();
+            string key = Guid.NewGuid().ToString();
+
+            _registry.Add(key, policy);
+            _registry.Count.Should().Be(1);
+
+            Policy policy2 = Policy.NoOp();
+            string key2 = Guid.NewGuid().ToString();
+
+            _registry.Add(key2, policy2);
+            _registry.Count.Should().Be(2);
+
+            _registry.Clear();
+            _registry.Count.Should().Be(0);
+        }
+
+        [Fact]
+        public void Should_be_able_to_remove_policy()
+        {
+            Policy policy = Policy.NoOp();
+            string key = Guid.NewGuid().ToString();
+
+            _registry.Add(key, policy);
+            _registry.Count.Should().Be(1);
+
+            _registry.Remove(key);
+            _registry.Count.Should().Be(0);
+        }
+
+        [Fact]
+        public void Should_throw_when_removing_Policy_when_key_is_null()
+        {
+            string key = null;
+            _registry.Invoking(r => r.Remove(key))
+                .ShouldThrow<ArgumentNullException>();
+        }
+        #endregion
+
+        #region Tests for checking if key exists
+        [Fact]
+        public void Should_be_able_to_check_if_key_exists()
+        {
+            Policy policy = Policy.NoOp();
+            string key = Guid.NewGuid().ToString();
+
+            _registry.Add(key, policy);
+            _registry.ContainsKey(key).Should().BeTrue();
+
+            string key2 = Guid.NewGuid().ToString();
+            _registry.ContainsKey(key2).Should().BeFalse();
+        }
+
+        [Fact]
+        public void Should_throw_when_checking_if_key_exists_when_key_is_null()
+        {
+            string key = null;
+            _registry.Invoking(r => r.ContainsKey(key))
+                .ShouldThrow<ArgumentNullException>();
+        }
+        #endregion
+    }
+}
diff --git a/src/Polly.sln b/src/Polly.sln
index d26d8ff5abc..14517448621 100644
--- a/src/Polly.sln
+++ b/src/Polly.sln
@@ -1,7 +1,7 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 14
-VisualStudioVersion = 14.0.25420.1
+# Visual Studio 15
+VisualStudioVersion = 15.0.26127.0
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{79FE9DBE-1155-4F78-A41F-FE95DEFA19DD}"
 	ProjectSection(SolutionItems) = preProject
@@ -22,10 +22,10 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Polly.Pcl.Specs", "Polly.Pc
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Polly.Net40Async", "Polly.Net40Async\Polly.Net40Async.csproj", "{D6A676C2-982D-42D1-AD21-FA53582A1C31}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Polly.NetStandard10", "Polly.NetStandard10\Polly.NetStandard10.csproj", "{5017174E-DAC5-4408-AB15-1F902F40C612}"
-EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Polly.Net40Async.Specs", "Polly.Net40Async.Specs\Polly.Net40Async.Specs.csproj", "{65062661-9E19-4FC6-859C-8B7811553E13}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Polly.NetStandard11", "Polly.NetStandard11\Polly.NetStandard11.csproj", "{5017174E-DAC5-4408-AB15-1F902F40C612}"
+EndProject
 Global
 	GlobalSection(SharedMSBuildProjectFiles) = preSolution
 		Polly.Shared\Polly.Shared.projitems*{23fa87f9-c77d-4c67-a0b0-2901de51b3ff}*SharedItemsImports = 13
@@ -58,14 +58,14 @@ Global
 		{D6A676C2-982D-42D1-AD21-FA53582A1C31}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{D6A676C2-982D-42D1-AD21-FA53582A1C31}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{D6A676C2-982D-42D1-AD21-FA53582A1C31}.Release|Any CPU.Build.0 = Release|Any CPU
-		{5017174E-DAC5-4408-AB15-1F902F40C612}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{5017174E-DAC5-4408-AB15-1F902F40C612}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{5017174E-DAC5-4408-AB15-1F902F40C612}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{5017174E-DAC5-4408-AB15-1F902F40C612}.Release|Any CPU.Build.0 = Release|Any CPU
 		{65062661-9E19-4FC6-859C-8B7811553E13}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{65062661-9E19-4FC6-859C-8B7811553E13}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{65062661-9E19-4FC6-859C-8B7811553E13}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{65062661-9E19-4FC6-859C-8B7811553E13}.Release|Any CPU.Build.0 = Release|Any CPU
+		{5017174E-DAC5-4408-AB15-1F902F40C612}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{5017174E-DAC5-4408-AB15-1F902F40C612}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{5017174E-DAC5-4408-AB15-1F902F40C612}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{5017174E-DAC5-4408-AB15-1F902F40C612}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

From 453afc8a8ab23da5ba586dc1eb74c95789b205c0 Mon Sep 17 00:00:00 2001
From: reisenberger <software@reisenberger.net>
Date: Tue, 27 Jun 2017 21:53:22 +0100
Subject: [PATCH 2/6] Rename DefaultPolicyRegistry to PolicyRegistry

---
 src/Polly.Shared/Polly.Shared.projitems                     | 2 +-
 .../{DefaultPolicyRegistry.cs => PolicyRegistry.cs}         | 2 +-
 src/Polly.SharedSpecs/Polly.SharedSpecs.projitems           | 2 +-
 ...DefaultPolicyRegistrySpecs.cs => PolicyRegistrySpecs.cs} | 6 +++---
 4 files changed, 6 insertions(+), 6 deletions(-)
 rename src/Polly.Shared/Registry/{DefaultPolicyRegistry.cs => PolicyRegistry.cs} (98%)
 rename src/Polly.SharedSpecs/Registry/{DefaultPolicyRegistrySpecs.cs => PolicyRegistrySpecs.cs} (97%)

diff --git a/src/Polly.Shared/Polly.Shared.projitems b/src/Polly.Shared/Polly.Shared.projitems
index 07ae8435530..fea4da5f250 100644
--- a/src/Polly.Shared/Polly.Shared.projitems
+++ b/src/Polly.Shared/Polly.Shared.projitems
@@ -68,7 +68,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)PolicyBuilder.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)PolicyBuilder.OrSyntax.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)PolicyResult.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)Registry\DefaultPolicyRegistry.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Registry\PolicyRegistry.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Registry\IPolicyRegistry.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)ResultPredicate.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Retry\RetrySyntax.cs" />
diff --git a/src/Polly.Shared/Registry/DefaultPolicyRegistry.cs b/src/Polly.Shared/Registry/PolicyRegistry.cs
similarity index 98%
rename from src/Polly.Shared/Registry/DefaultPolicyRegistry.cs
rename to src/Polly.Shared/Registry/PolicyRegistry.cs
index c36bd0c9ba7..c6211d26458 100644
--- a/src/Polly.Shared/Registry/DefaultPolicyRegistry.cs
+++ b/src/Polly.Shared/Registry/PolicyRegistry.cs
@@ -9,7 +9,7 @@ namespace Polly.Registry
     /// Stores a registry of <see cref="System.String"/> and <see cref="Policy"/> pair.
     /// </summary>
     /// <remarks>Uses ConcurrentDictionary to store the collection.</remarks>
-    public class DefaultPolicyRegistry : IPolicyRegistry<string, Policy>
+    public class PolicyRegistry : IPolicyRegistry<string, Policy>
     {
         private IDictionary<string, Policy> _registry = new ConcurrentDictionary<string, Policy>();
 
diff --git a/src/Polly.SharedSpecs/Polly.SharedSpecs.projitems b/src/Polly.SharedSpecs/Polly.SharedSpecs.projitems
index e2b0ba99731..e1304a143ad 100644
--- a/src/Polly.SharedSpecs/Polly.SharedSpecs.projitems
+++ b/src/Polly.SharedSpecs/Polly.SharedSpecs.projitems
@@ -49,7 +49,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)PolicyContextAndKeyAsyncSpecs.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)PolicyContextAndKeySpecs.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)PolicySpecs.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)Registry\DefaultPolicyRegistrySpecs.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Registry\PolicyRegistrySpecs.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Retry\RetryAsyncSpecs.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Retry\RetryForeverAsyncSpecs.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Retry\RetryForeverSpecs.cs" />
diff --git a/src/Polly.SharedSpecs/Registry/DefaultPolicyRegistrySpecs.cs b/src/Polly.SharedSpecs/Registry/PolicyRegistrySpecs.cs
similarity index 97%
rename from src/Polly.SharedSpecs/Registry/DefaultPolicyRegistrySpecs.cs
rename to src/Polly.SharedSpecs/Registry/PolicyRegistrySpecs.cs
index e81161b8ded..bc72be48d9b 100644
--- a/src/Polly.SharedSpecs/Registry/DefaultPolicyRegistrySpecs.cs
+++ b/src/Polly.SharedSpecs/Registry/PolicyRegistrySpecs.cs
@@ -8,13 +8,13 @@
 
 namespace Polly.Specs.Registry
 {
-    public class DefaultPolicyRegistrySpecs
+    public class PolicyRegistrySpecs
     {
         IPolicyRegistry<string, Policy> _registry;
 
-        public DefaultPolicyRegistrySpecs()
+        public PolicyRegistrySpecs()
         {
-            _registry = new DefaultPolicyRegistry();
+            _registry = new PolicyRegistry();
         }
 
         #region Tests for adding Policy

From 41a7677c12a9d4c055e8a047faa6acbfe73fe5de Mon Sep 17 00:00:00 2001
From: reisenberger <software@reisenberger.net>
Date: Tue, 27 Jun 2017 22:15:33 +0100
Subject: [PATCH 3/6] Add interfaces to Polly

Adds interfaces to Polly.  Delivers #257
---
 src/Polly.Shared/Bulkhead/BulkheadPolicy.cs   |   4 +-
 .../Bulkhead/BulkheadPolicyAsync.cs           |   4 +-
 src/Polly.Shared/Bulkhead/IBulkheadPolicy.cs  |  29 ++
 .../CircuitBreaker/CircuitBreakerPolicy.cs    |   4 +-
 .../CircuitBreakerPolicyAsync.cs              |   4 +-
 .../CircuitBreaker/ICircuitBreakerPolicy.cs   |  43 +++
 src/Polly.Shared/Fallback/FallbackPolicy.cs   |   4 +-
 .../Fallback/FallbackPolicyAsync.cs           |   4 +-
 src/Polly.Shared/Fallback/IFallbackPolicy.cs  |  18 +
 src/Polly.Shared/IAsyncPolicy.cs              | 349 ++++++++++++++++++
 src/Polly.Shared/IAsyncPolicyTResult.cs       | 185 ++++++++++
 src/Polly.Shared/ISyncPolicy.cs               | 232 ++++++++++++
 src/Polly.Shared/ISyncPolicyTResult.cs        | 132 +++++++
 src/Polly.Shared/IsPolicy.cs                  |  15 +
 src/Polly.Shared/NoOp/INoOpPolicy.cs          |  18 +
 src/Polly.Shared/NoOp/NoOpPolicy.cs           |   4 +-
 src/Polly.Shared/NoOp/NoOpPolicyAsync.cs      |   4 +-
 src/Polly.Shared/NoOp/NoOpSyntax.cs           |   3 -
 src/Polly.Shared/NoOp/NoOpSyntaxAsync.cs      |   3 -
 src/Polly.Shared/NoOp/NoOpTResultSyntax.cs    |   3 -
 .../NoOp/NoOpTResultSyntaxAsync.cs            |   3 -
 src/Polly.Shared/Policy.ContextAndKeys.cs     |  57 ++-
 src/Polly.Shared/Policy.TResult.cs            |   2 +-
 src/Polly.Shared/Policy.cs                    |   2 +-
 src/Polly.Shared/PolicyAsync.TResult.cs       |   2 +-
 src/Polly.Shared/PolicyAsync.cs               |   2 +-
 src/Polly.Shared/Polly.Shared.projitems       |  14 +-
 src/Polly.Shared/Retry/IRetryPolicy.cs        |  22 ++
 src/Polly.Shared/Retry/RetryPolicy.cs         |   4 +-
 src/Polly.Shared/Retry/RetryPolicyAsync.cs    |   4 +-
 src/Polly.Shared/Timeout/ITimeoutPolicy.cs    |  18 +
 src/Polly.Shared/Timeout/TimeoutPolicy.cs     |   4 +-
 .../Timeout/TimeoutPolicyAsync.cs             |   4 +-
 src/Polly.Shared/Wrap/IPolicyWrap.cs          |  18 +
 src/Polly.Shared/Wrap/PolicyWrap.cs           |   4 +-
 src/Polly.Shared/Wrap/PolicyWrapAsync.cs      |   4 +-
 .../Bulkhead/IBulkheadPolicySpecs.cs          |  28 ++
 .../ICircuitBreakerPolicySpecs.cs             |  58 +++
 .../ICircuitBreakerPolicyTResultSpecs.cs      |  23 ++
 .../PolicyContextAndKeyAsyncSpecs.cs          |  18 +
 .../PolicyContextAndKeySpecs.cs               |  18 +
 .../Polly.SharedSpecs.projitems               |   5 +-
 42 files changed, 1328 insertions(+), 48 deletions(-)
 create mode 100644 src/Polly.Shared/Bulkhead/IBulkheadPolicy.cs
 create mode 100644 src/Polly.Shared/CircuitBreaker/ICircuitBreakerPolicy.cs
 create mode 100644 src/Polly.Shared/Fallback/IFallbackPolicy.cs
 create mode 100644 src/Polly.Shared/IAsyncPolicy.cs
 create mode 100644 src/Polly.Shared/IAsyncPolicyTResult.cs
 create mode 100644 src/Polly.Shared/ISyncPolicy.cs
 create mode 100644 src/Polly.Shared/ISyncPolicyTResult.cs
 create mode 100644 src/Polly.Shared/IsPolicy.cs
 create mode 100644 src/Polly.Shared/NoOp/INoOpPolicy.cs
 create mode 100644 src/Polly.Shared/Retry/IRetryPolicy.cs
 create mode 100644 src/Polly.Shared/Timeout/ITimeoutPolicy.cs
 create mode 100644 src/Polly.Shared/Wrap/IPolicyWrap.cs
 create mode 100644 src/Polly.SharedSpecs/Bulkhead/IBulkheadPolicySpecs.cs
 create mode 100644 src/Polly.SharedSpecs/CircuitBreaker/ICircuitBreakerPolicySpecs.cs
 create mode 100644 src/Polly.SharedSpecs/CircuitBreaker/ICircuitBreakerPolicyTResultSpecs.cs

diff --git a/src/Polly.Shared/Bulkhead/BulkheadPolicy.cs b/src/Polly.Shared/Bulkhead/BulkheadPolicy.cs
index ee4bb633e69..8a7d07b9eb3 100644
--- a/src/Polly.Shared/Bulkhead/BulkheadPolicy.cs
+++ b/src/Polly.Shared/Bulkhead/BulkheadPolicy.cs
@@ -13,7 +13,7 @@ namespace Polly.Bulkhead
     /// <summary>
     /// A bulkhead-isolation policy which can be applied to delegates.
     /// </summary>
-    public partial class BulkheadPolicy : Policy, IDisposable
+    public partial class BulkheadPolicy : Policy, IBulkheadPolicy
     {
         private readonly SemaphoreSlim _maxParallelizationSemaphore;
         private readonly SemaphoreSlim _maxQueuedActionsSemaphore;
@@ -58,7 +58,7 @@ public void Dispose()
     /// <summary>
     /// A bulkhead-isolation policy which can be applied to delegates returning a value of type <typeparamref name="TResult"/>.
     /// </summary>
-    public partial class BulkheadPolicy<TResult> : Policy<TResult>, IDisposable
+    public partial class BulkheadPolicy<TResult> : Policy<TResult>, IBulkheadPolicy<TResult>
     {
         private readonly SemaphoreSlim _maxParallelizationSemaphore;
         private readonly SemaphoreSlim _maxQueuedActionsSemaphore;
diff --git a/src/Polly.Shared/Bulkhead/BulkheadPolicyAsync.cs b/src/Polly.Shared/Bulkhead/BulkheadPolicyAsync.cs
index b7d4d58c697..e80fffc5d25 100644
--- a/src/Polly.Shared/Bulkhead/BulkheadPolicyAsync.cs
+++ b/src/Polly.Shared/Bulkhead/BulkheadPolicyAsync.cs
@@ -11,7 +11,7 @@
 
 namespace Polly.Bulkhead
 {
-    public partial class BulkheadPolicy
+    public partial class BulkheadPolicy : IBulkheadPolicy
     {
         internal BulkheadPolicy(Func<Func<Context, CancellationToken, Task>, Context, CancellationToken, bool, Task> asyncExceptionPolicy,
             int maxParallelization,
@@ -27,7 +27,7 @@ internal BulkheadPolicy(Func<Func<Context, CancellationToken, Task>, Context, Ca
         }
     }
 
-    public partial class BulkheadPolicy<TResult>
+    public partial class BulkheadPolicy<TResult> : IBulkheadPolicy<TResult>
     {
         internal BulkheadPolicy(
             Func<Func<Context, CancellationToken, Task<TResult>>, Context, CancellationToken, bool, Task<TResult>> asyncExecutionPolicy,
diff --git a/src/Polly.Shared/Bulkhead/IBulkheadPolicy.cs b/src/Polly.Shared/Bulkhead/IBulkheadPolicy.cs
new file mode 100644
index 00000000000..64273314a2e
--- /dev/null
+++ b/src/Polly.Shared/Bulkhead/IBulkheadPolicy.cs
@@ -0,0 +1,29 @@
+using System;
+
+namespace Polly.Bulkhead
+{
+    /// <summary>
+    /// Defines properties and methods common to all bulkhead policies.
+    /// </summary>
+
+    public interface IBulkheadPolicy : IsPolicy, IDisposable
+    {
+        /// <summary>
+        /// Gets the number of slots currently available for executing actions through the bulkhead.
+        /// </summary>
+        int BulkheadAvailableCount { get; }
+
+        /// <summary>
+        /// Gets the number of slots currently available for queuing actions for execution through the bulkhead.
+        /// </summary>
+        int QueueAvailableCount { get; }
+    }
+
+    /// <summary>
+    /// Defines properties and methods common to all bulkhead policies generic-typed for executions returning results of type <typeparamref name="TResult"/>.
+    /// </summary>
+    public interface IBulkheadPolicy<TResult> : IBulkheadPolicy
+    {
+        
+    }
+}
diff --git a/src/Polly.Shared/CircuitBreaker/CircuitBreakerPolicy.cs b/src/Polly.Shared/CircuitBreaker/CircuitBreakerPolicy.cs
index f54e7d95ee1..5c9953a8767 100644
--- a/src/Polly.Shared/CircuitBreaker/CircuitBreakerPolicy.cs
+++ b/src/Polly.Shared/CircuitBreaker/CircuitBreakerPolicy.cs
@@ -8,7 +8,7 @@ namespace Polly.CircuitBreaker
     /// <summary>
     /// A circuit-breaker policy that can be applied to delegates.
     /// </summary>
-    public partial class CircuitBreakerPolicy : Policy
+    public partial class CircuitBreakerPolicy : Policy, ICircuitBreakerPolicy
     {
         internal readonly ICircuitController<EmptyStruct> _breakerController;
 
@@ -58,7 +58,7 @@ public void Reset()
     /// <summary>
     /// A circuit-breaker policy that can be applied to delegates returning a value of type <typeparamref name="TResult"/>.
     /// </summary>
-    public partial class CircuitBreakerPolicy<TResult> : Policy<TResult>
+    public partial class CircuitBreakerPolicy<TResult> : Policy<TResult>, ICircuitBreakerPolicy<TResult>
     {
         internal readonly ICircuitController<TResult> _breakerController;
 
diff --git a/src/Polly.Shared/CircuitBreaker/CircuitBreakerPolicyAsync.cs b/src/Polly.Shared/CircuitBreaker/CircuitBreakerPolicyAsync.cs
index aaac0daf36b..5fa8d8368ed 100644
--- a/src/Polly.Shared/CircuitBreaker/CircuitBreakerPolicyAsync.cs
+++ b/src/Polly.Shared/CircuitBreaker/CircuitBreakerPolicyAsync.cs
@@ -7,7 +7,7 @@
 
 namespace Polly.CircuitBreaker
 {
-    public partial class CircuitBreakerPolicy
+    public partial class CircuitBreakerPolicy : ICircuitBreakerPolicy
     {
         internal CircuitBreakerPolicy(
             Func<Func<Context, CancellationToken, Task>, Context, CancellationToken, bool, Task> asyncExceptionPolicy, 
@@ -19,7 +19,7 @@ ICircuitController<EmptyStruct> breakerController
         }
     }
 
-    public partial class CircuitBreakerPolicy<TResult>
+    public partial class CircuitBreakerPolicy<TResult> : ICircuitBreakerPolicy<TResult>
     {
         internal CircuitBreakerPolicy(
             Func<Func<Context, CancellationToken, Task<TResult>>, Context, CancellationToken, bool, Task<TResult>> asyncExecutionPolicy, 
diff --git a/src/Polly.Shared/CircuitBreaker/ICircuitBreakerPolicy.cs b/src/Polly.Shared/CircuitBreaker/ICircuitBreakerPolicy.cs
new file mode 100644
index 00000000000..b19922e6779
--- /dev/null
+++ b/src/Polly.Shared/CircuitBreaker/ICircuitBreakerPolicy.cs
@@ -0,0 +1,43 @@
+using System;
+
+namespace Polly.CircuitBreaker
+{
+    /// <summary>
+    /// Defines properties and methods common to all circuit-breaker policies.
+    /// </summary>
+    public interface ICircuitBreakerPolicy : IsPolicy
+    {
+        /// <summary>
+        /// Gets the state of the underlying circuit.
+        /// </summary>
+        CircuitState CircuitState { get; }
+
+        /// <summary>
+        /// Gets the last exception handled by the circuit-breaker.
+        /// <remarks>This will be null if no exceptions have been handled by the circuit-breaker since the circuit last closed.</remarks>
+        /// </summary>
+        Exception LastException { get; }
+
+        /// <summary>
+        /// Isolates (opens) the circuit manually, and holds it in this state until a call to <see cref="CircuitBreakerPolicy.Reset"/> is made.
+        /// </summary>
+        void Isolate();
+
+        /// <summary>
+        /// Closes the circuit, and resets any statistics controlling automated circuit-breaking.
+        /// </summary>
+        void Reset();
+    }
+
+    /// <summary>
+    /// Defines properties and methods common to all circuit-breaker policies generic-typed for executions returning results of type <typeparamref name="TResult"/>.
+    /// </summary>
+    public interface ICircuitBreakerPolicy<TResult> : ICircuitBreakerPolicy
+    {
+        /// <summary>
+        /// Gets the last result returned from a user delegate which the circuit-breaker handled.
+        /// <remarks>This will be default(<typeparamref name="TResult"/>) if no results have been handled by the circuit-breaker since the circuit last closed, or if the last event handled by the circuit was an exception.</remarks>
+        /// </summary>
+        TResult LastHandledResult { get; }
+    }
+}
diff --git a/src/Polly.Shared/Fallback/FallbackPolicy.cs b/src/Polly.Shared/Fallback/FallbackPolicy.cs
index 349547b9a83..1ffb80d3ddd 100644
--- a/src/Polly.Shared/Fallback/FallbackPolicy.cs
+++ b/src/Polly.Shared/Fallback/FallbackPolicy.cs
@@ -7,7 +7,7 @@ namespace Polly.Fallback
     /// <summary>
     /// A fallback policy that can be applied to delegates.
     /// </summary>
-    public partial class FallbackPolicy : Policy
+    public partial class FallbackPolicy : Policy, IFallbackPolicy
     {
         internal FallbackPolicy(Action<Action<Context, CancellationToken>, Context, CancellationToken> exceptionPolicy, IEnumerable<ExceptionPredicate> exceptionPredicates)
             : base(exceptionPolicy, exceptionPredicates)
@@ -18,7 +18,7 @@ internal FallbackPolicy(Action<Action<Context, CancellationToken>, Context, Canc
     /// <summary>
     /// A fallback policy that can be applied to delegates returning a value of type <typeparamref name="TResult"/>.
     /// </summary>
-    public partial class FallbackPolicy<TResult> : Policy<TResult>
+    public partial class FallbackPolicy<TResult> : Policy<TResult>, IFallbackPolicy<TResult>
     {
         internal FallbackPolicy(
             Func<Func<Context, CancellationToken, TResult>, Context, CancellationToken, TResult> executionPolicy,
diff --git a/src/Polly.Shared/Fallback/FallbackPolicyAsync.cs b/src/Polly.Shared/Fallback/FallbackPolicyAsync.cs
index 7d9226da01d..5c49e0ec61e 100644
--- a/src/Polly.Shared/Fallback/FallbackPolicyAsync.cs
+++ b/src/Polly.Shared/Fallback/FallbackPolicyAsync.cs
@@ -5,7 +5,7 @@
 
 namespace Polly.Fallback
 {
-    public partial class FallbackPolicy
+    public partial class FallbackPolicy : IFallbackPolicy
     {
         internal FallbackPolicy(Func<Func<Context, CancellationToken, Task>, Context, CancellationToken, bool, Task> asyncExceptionPolicy, IEnumerable<ExceptionPredicate> exceptionPredicates)
            : base(asyncExceptionPolicy, exceptionPredicates)
@@ -13,7 +13,7 @@ internal FallbackPolicy(Func<Func<Context, CancellationToken, Task>, Context, Ca
         }
     }
 
-    public partial class FallbackPolicy<TResult>
+    public partial class FallbackPolicy<TResult> : IFallbackPolicy<TResult>
     {
         internal FallbackPolicy(
             Func<Func<Context, CancellationToken, Task<TResult>>, Context, CancellationToken, bool, Task<TResult>> asyncExecutionPolicy,
diff --git a/src/Polly.Shared/Fallback/IFallbackPolicy.cs b/src/Polly.Shared/Fallback/IFallbackPolicy.cs
new file mode 100644
index 00000000000..a05bb7956cf
--- /dev/null
+++ b/src/Polly.Shared/Fallback/IFallbackPolicy.cs
@@ -0,0 +1,18 @@
+namespace Polly.Fallback
+{
+    /// <summary>
+    /// Defines properties and methods common to all Fallback policies.
+    /// </summary>
+
+    public interface IFallbackPolicy : IsPolicy
+    {
+    }
+
+    /// <summary>
+    /// Defines properties and methods common to all Fallback policies generic-typed for executions returning results of type <typeparamref name="TResult"/>.
+    /// </summary>
+    public interface IFallbackPolicy<TResult> : IFallbackPolicy
+    {
+
+    }
+}
diff --git a/src/Polly.Shared/IAsyncPolicy.cs b/src/Polly.Shared/IAsyncPolicy.cs
new file mode 100644
index 00000000000..d8be1ad86da
--- /dev/null
+++ b/src/Polly.Shared/IAsyncPolicy.cs
@@ -0,0 +1,349 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Polly
+{
+    /// <summary>
+    /// An interface defining all executions available on a non-generic, asynchronous policy
+    /// </summary>
+    public interface IAsyncPolicy : IsPolicy
+    {
+        /// <summary>
+        /// Sets the PolicyKey for this <see cref="Policy"/> instance.
+        /// <remarks>Must be called before the policy is first used.  Can only be set once.</remarks>
+        /// </summary>
+        /// <param name="policyKey">The unique, used-definable key to assign to this <see cref="Policy"/> instance.</param>
+        IAsyncPolicy WithPolicyKey(String policyKey);
+
+        /// <summary>
+        ///     Executes the specified asynchronous action within the policy.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        Task ExecuteAsync(Func<Task> action);
+
+        /// <summary>
+        ///     Executes the specified asynchronous action within the policy.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="contextData">Arbitrary data that is passed to the exception policy.</param>
+        Task ExecuteAsync(Func<Context, Task> action, IDictionary<string, object> contextData);
+
+        /// <summary>
+        ///     Executes the specified asynchronous action within the policy.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="context">Context data that is passed to the exception policy.</param>
+        Task ExecuteAsync(Func<Context, Task> action, Context context);
+
+        /// <summary>
+        ///     Executes the specified asynchronous action within the policy.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="cancellationToken">A cancellation token which can be used to cancel the action.  When a retry policy in use, also cancels any further retries.</param>
+        Task ExecuteAsync(Func<CancellationToken, Task> action, CancellationToken cancellationToken);
+
+        /// <summary>
+        ///     Executes the specified asynchronous action within the policy.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="contextData">Arbitrary data that is passed to the exception policy.</param>
+        /// <param name="cancellationToken">A cancellation token which can be used to cancel the action.  When a retry policy in use, also cancels any further retries.</param>
+        Task ExecuteAsync(Func<Context, CancellationToken, Task> action, IDictionary<string, object> contextData, CancellationToken cancellationToken);
+
+        /// <summary>
+        ///     Executes the specified asynchronous action within the policy.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="context">Context data that is passed to the exception policy.</param>
+        /// <param name="cancellationToken">A cancellation token which can be used to cancel the action.  When a retry policy in use, also cancels any further retries.</param>
+        Task ExecuteAsync(Func<Context, CancellationToken, Task> action, Context context, CancellationToken cancellationToken);
+
+        /// <summary>
+        ///     Executes the specified asynchronous action within the policy.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="continueOnCapturedContext">Whether to continue on a captured synchronization context.</param>
+        /// <param name="cancellationToken">A cancellation token which can be used to cancel the action.  When a retry policy in use, also cancels any further retries.</param>
+        /// <exception cref="System.InvalidOperationException">Please use asynchronous-defined policies when calling asynchronous ExecuteAsync (and similar) methods.</exception>
+        Task ExecuteAsync(Func<CancellationToken, Task> action, CancellationToken cancellationToken, bool continueOnCapturedContext);
+
+        /// <summary>
+        ///     Executes the specified asynchronous action within the policy.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>        /// <param name="contextData">Arbitrary data that is passed to the exception policy.</param>
+        /// <param name="cancellationToken">A cancellation token which can be used to cancel the action.  When a retry policy in use, also cancels any further retries.</param>
+        /// <param name="continueOnCapturedContext">Whether to continue on a captured synchronization context.</param>
+        /// <exception cref="System.ArgumentNullException">contextData</exception>
+        Task ExecuteAsync(Func<Context, CancellationToken, Task> action, IDictionary<string, object> contextData, CancellationToken cancellationToken, bool continueOnCapturedContext);
+
+        /// <summary>
+        ///     Executes the specified asynchronous action within the policy.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="context">Context data that is passed to the exception policy.</param>
+        /// <param name="continueOnCapturedContext">Whether to continue on a captured synchronization context.</param>
+        /// <param name="cancellationToken">A cancellation token which can be used to cancel the action.  When a retry policy in use, also cancels any further retries.</param>
+        /// <exception cref="System.InvalidOperationException">Please use asynchronous-defined policies when calling asynchronous ExecuteAsync (and similar) methods.</exception>
+        Task ExecuteAsync(Func<Context, CancellationToken, Task> action, Context context, CancellationToken cancellationToken, bool continueOnCapturedContext);
+
+        /// <summary>
+        ///     Executes the specified asynchronous action within the policy and returns the result.
+        /// </summary>
+        /// <typeparam name="TResult">The type of the result.</typeparam>
+        /// <param name="action">The action to perform.</param>
+        /// <returns>The value returned by the action</returns>
+        Task<TResult> ExecuteAsync<TResult>(Func<Task<TResult>> action);
+
+        /// <summary>
+        ///     Executes the specified asynchronous action within the policy and returns the result.
+        /// </summary>
+        /// <typeparam name="TResult">The type of the result.</typeparam>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="context">Context data that is passed to the exception policy.</param>
+        /// <returns>The value returned by the action</returns>
+        Task<TResult> ExecuteAsync<TResult>(Func<Context, Task<TResult>> action, Context context);
+
+        /// <summary>
+        ///     Executes the specified asynchronous action within the policy and returns the result.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="contextData">Arbitrary data that is passed to the exception policy.</param>
+        /// <returns>The value returned by the action</returns>
+        Task<TResult> ExecuteAsync<TResult>(Func<Context, Task<TResult>> action, IDictionary<string, object> contextData);
+
+        /// <summary>
+        ///     Executes the specified asynchronous action within the policy and returns the result.
+        /// </summary>
+        /// <typeparam name="TResult">The type of the result.</typeparam>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="cancellationToken">A cancellation token which can be used to cancel the action.  When a retry policy is in use, also cancels any further retries.</param>
+        /// <returns>The value returned by the action</returns>
+        Task<TResult> ExecuteAsync<TResult>(Func<CancellationToken, Task<TResult>> action, CancellationToken cancellationToken);
+
+        /// <summary>
+        ///     Executes the specified asynchronous action within the policy and returns the result.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="contextData">Arbitrary data that is passed to the exception policy.</param>
+        /// <param name="cancellationToken">A cancellation token which can be used to cancel the action.  When a retry policy in use, also cancels any further retries.</param>
+        /// <returns>The value returned by the action</returns>
+        Task<TResult> ExecuteAsync<TResult>(Func<Context, CancellationToken, Task<TResult>> action, IDictionary<string, object> contextData, CancellationToken cancellationToken);
+
+        /// <summary>
+        ///     Executes the specified asynchronous action within the policy and returns the result.
+        /// </summary>
+        /// <typeparam name="TResult">The type of the result.</typeparam>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="context">Context data that is passed to the exception policy.</param>
+        /// <param name="cancellationToken">A cancellation token which can be used to cancel the action.  When a retry policy is in use, also cancels any further retries.</param>
+        /// <returns>The value returned by the action</returns>
+        Task<TResult> ExecuteAsync<TResult>(Func<Context, CancellationToken, Task<TResult>> action, Context context, CancellationToken cancellationToken);
+
+        /// <summary>
+        ///     Executes the specified asynchronous action within the policy and returns the result.
+        /// </summary>
+        /// <typeparam name="TResult">The type of the result.</typeparam>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="continueOnCapturedContext">Whether to continue on a captured synchronization context.</param>
+        /// <param name="cancellationToken">A cancellation token which can be used to cancel the action.  When a retry policy is in use, also cancels any further retries.</param>
+        /// <returns>The value returned by the action</returns>
+        /// <exception cref="System.InvalidOperationException">Please use asynchronous-defined policies when calling asynchronous ExecuteAsync (and similar) methods.</exception>
+        Task<TResult> ExecuteAsync<TResult>(Func<CancellationToken, Task<TResult>> action, CancellationToken cancellationToken, bool continueOnCapturedContext);
+
+        /// <summary>
+        ///     Executes the specified asynchronous action within the policy and returns the result.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="contextData">Arbitrary data that is passed to the exception policy.</param>
+        /// <param name="cancellationToken">A cancellation token which can be used to cancel the action.  When a retry policy in use, also cancels any further retries.</param>
+        /// <param name="continueOnCapturedContext">Whether to continue on a captured synchronization context.</param>
+        /// <returns>The value returned by the action</returns>
+        /// <exception cref="System.ArgumentNullException">contextData</exception>
+        Task<TResult> ExecuteAsync<TResult>(Func<Context, CancellationToken, Task<TResult>> action, IDictionary<string, object> contextData, CancellationToken cancellationToken, bool continueOnCapturedContext);
+
+        /// <summary>
+        ///     Executes the specified asynchronous action within the policy and returns the result.
+        /// </summary>
+        /// <typeparam name="TResult">The type of the result.</typeparam>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="context">Context data that is passed to the exception policy.</param>
+        /// <param name="continueOnCapturedContext">Whether to continue on a captured synchronization context.</param>
+        /// <param name="cancellationToken">A cancellation token which can be used to cancel the action.  When a retry policy is in use, also cancels any further retries.</param>
+        /// <returns>The value returned by the action</returns>
+        /// <exception cref="System.InvalidOperationException">Please use asynchronous-defined policies when calling asynchronous ExecuteAsync (and similar) methods.</exception>
+        Task<TResult> ExecuteAsync<TResult>(Func<Context, CancellationToken, Task<TResult>> action, Context context, CancellationToken cancellationToken, bool continueOnCapturedContext);
+
+        /// <summary>
+        ///     Executes the specified asynchronous action within the policy and returns the captured result.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <returns>The captured result</returns>
+        Task<PolicyResult> ExecuteAndCaptureAsync(Func<Task> action);
+
+        /// <summary>
+        ///     Executes the specified asynchronous action within the policy and returns the captured result.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="contextData">Arbitrary data that is passed to the exception policy.</param>
+        /// <exception cref="System.ArgumentNullException">contextData</exception>
+        /// <returns>The captured result</returns>
+        Task<PolicyResult> ExecuteAndCaptureAsync(Func<Context, Task> action, IDictionary<string, object> contextData);
+
+        /// <summary>
+        ///     Executes the specified asynchronous action within the policy and returns the captured result.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="context">Context data that is passed to the exception policy.</param>
+        /// <returns>The captured result</returns>
+        Task<PolicyResult> ExecuteAndCaptureAsync(Func<Context, Task> action, Context context);
+
+        /// <summary>
+        ///     Executes the specified asynchronous action within the policy and returns the captured result.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="cancellationToken">A cancellation token which can be used to cancel the action.  When a retry policy in use, also cancels any further retries.</param>
+        Task<PolicyResult> ExecuteAndCaptureAsync(Func<CancellationToken, Task> action, CancellationToken cancellationToken);
+
+        /// <summary>
+        ///     Executes the specified asynchronous action within the policy and returns the captured result.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="contextData">Arbitrary data that is passed to the exception policy.</param>
+        /// <param name="cancellationToken">A cancellation token which can be used to cancel the action.  When a retry policy in use, also cancels any further retries.</param>
+        /// <exception cref="System.ArgumentNullException">contextData</exception>
+        /// <returns>The captured result</returns>
+        Task<PolicyResult> ExecuteAndCaptureAsync(Func<Context, CancellationToken, Task> action, IDictionary<string, object> contextData, CancellationToken cancellationToken);
+
+        /// <summary>
+        ///     Executes the specified asynchronous action within the policy and returns the captured result.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="context">Context data that is passed to the exception policy.</param>
+        /// <param name="cancellationToken">A cancellation token which can be used to cancel the action.  When a retry policy in use, also cancels any further retries.</param>
+        Task<PolicyResult> ExecuteAndCaptureAsync(Func<Context, CancellationToken, Task> action, Context context, CancellationToken cancellationToken);
+
+        /// <summary>
+        ///     Executes the specified asynchronous action within the policy and returns the captured result.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="cancellationToken">A cancellation token which can be used to cancel the action.  When a retry policy in use, also cancels any further retries.</param>
+        /// <param name="continueOnCapturedContext">Whether to continue on a captured synchronization context.</param>
+        /// <exception cref="System.InvalidOperationException">Please use asynchronous-defined policies when calling asynchronous ExecuteAsync (and similar) methods.</exception>
+        Task<PolicyResult> ExecuteAndCaptureAsync(Func<CancellationToken, Task> action, CancellationToken cancellationToken, bool continueOnCapturedContext);
+
+        /// <summary>
+        ///     Executes the specified asynchronous action within the policy and returns the captured result.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="contextData">Arbitrary data that is passed to the exception policy.</param>
+        /// <param name="cancellationToken">A cancellation token which can be used to cancel the action.  When a retry policy in use, also cancels any further retries.</param>
+        /// <param name="continueOnCapturedContext">Whether to continue on a captured synchronization context.</param>
+        /// <exception cref="System.ArgumentNullException">contextData</exception>
+        /// <returns>The captured result</returns>
+        Task<PolicyResult> ExecuteAndCaptureAsync(Func<Context, CancellationToken, Task> action, IDictionary<string, object> contextData, CancellationToken cancellationToken, bool continueOnCapturedContext);
+
+        /// <summary>
+        ///     Executes the specified asynchronous action within the policy and returns the captured result.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="context">Context data that is passed to the exception policy.</param>
+        /// <param name="continueOnCapturedContext">Whether to continue on a captured synchronization context.</param>
+        /// <param name="cancellationToken">A cancellation token which can be used to cancel the action.  When a retry policy in use, also cancels any further retries.</param>
+        /// <exception cref="System.InvalidOperationException">Please use asynchronous-defined policies when calling asynchronous ExecuteAsync (and similar) methods.</exception>
+        Task<PolicyResult> ExecuteAndCaptureAsync(Func<Context, CancellationToken, Task> action, Context context, CancellationToken cancellationToken, bool continueOnCapturedContext);
+
+        /// <summary>
+        /// Executes the specified asynchronous action within the policy and returns the result.
+        /// </summary>
+        /// <typeparam name="TResult">The type of the result.</typeparam>
+        /// <param name="action">The action to perform.</param>
+        /// <returns>The captured result</returns>
+        Task<PolicyResult<TResult>> ExecuteAndCaptureAsync<TResult>(Func<Task<TResult>> action);
+
+        /// <summary>
+        /// Executes the specified asynchronous action within the policy and returns the result.
+        /// </summary>
+        /// <typeparam name="TResult">The type of the result.</typeparam>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="contextData">Arbitrary data that is passed to the exception policy.</param>
+        /// <exception cref="System.ArgumentNullException">contextData</exception>
+        /// <returns>The captured result</returns>
+        Task<PolicyResult<TResult>> ExecuteAndCaptureAsync<TResult>(Func<Context, Task<TResult>> action, IDictionary<string, object> contextData);
+
+        /// <summary>
+        /// Executes the specified asynchronous action within the policy and returns the result.
+        /// </summary>
+        /// <typeparam name="TResult">The type of the result.</typeparam>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="context">Context data that is passed to the exception policy.</param>
+        /// <returns>The captured result</returns>
+        Task<PolicyResult<TResult>> ExecuteAndCaptureAsync<TResult>(Func<Context, Task<TResult>> action, Context context);
+
+        /// <summary>
+        ///     Executes the specified asynchronous action within the policy and returns the result.
+        /// </summary>
+        /// <typeparam name="TResult">The type of the result.</typeparam>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="cancellationToken">A cancellation token which can be used to cancel the action.  When a retry policy in use, also cancels any further retries.</param>
+        /// <returns>The captured result</returns>
+        Task<PolicyResult<TResult>> ExecuteAndCaptureAsync<TResult>(Func<CancellationToken, Task<TResult>> action, CancellationToken cancellationToken);
+
+        /// <summary>
+        ///     Executes the specified asynchronous action within the policy and returns the result.
+        /// </summary>
+        /// <typeparam name="TResult">The type of the result.</typeparam>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="contextData">Arbitrary data that is passed to the exception policy.</param>
+        /// <param name="cancellationToken">A cancellation token which can be used to cancel the action.  When a retry policy in use, also cancels any further retries.</param>
+        /// <exception cref="System.ArgumentNullException">contextData</exception>
+        /// <returns>The captured result</returns>
+        Task<PolicyResult<TResult>> ExecuteAndCaptureAsync<TResult>(Func<Context, CancellationToken, Task<TResult>> action, IDictionary<string, object> contextData, CancellationToken cancellationToken);
+
+        /// <summary>
+        ///     Executes the specified asynchronous action within the policy and returns the result.
+        /// </summary>
+        /// <typeparam name="TResult">The type of the result.</typeparam>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="context">A cancellation token which can be used to cancel the action.  When a retry policy in use, also cancels any further retries.</param>
+        /// <param name="cancellationToken">A cancellation token which can be used to cancel the action.  When a retry policy in use, also cancels any further retries.</param>
+        /// <returns>The captured result</returns>
+        Task<PolicyResult<TResult>> ExecuteAndCaptureAsync<TResult>(Func<Context, CancellationToken, Task<TResult>> action, Context context, CancellationToken cancellationToken);
+
+        /// <summary>
+        ///     Executes the specified asynchronous action within the policy and returns the result.
+        /// </summary>
+        /// <typeparam name="TResult">The type of the result.</typeparam>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="cancellationToken">A cancellation token which can be used to cancel the action.  When a retry policy in use, also cancels any further retries.</param>
+        /// <param name="continueOnCapturedContext">Whether to continue on a captured synchronization context.</param>
+        /// <returns>The captured result</returns>
+        /// <exception cref="System.InvalidOperationException">Please use asynchronous-defined policies when calling asynchronous ExecuteAsync (and similar) methods.</exception>
+        Task<PolicyResult<TResult>> ExecuteAndCaptureAsync<TResult>(Func<CancellationToken, Task<TResult>> action, CancellationToken cancellationToken, bool continueOnCapturedContext);
+
+        /// <summary>
+        ///     Executes the specified asynchronous action within the policy and returns the result.
+        /// </summary>
+        /// <typeparam name="TResult">The type of the result.</typeparam>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="contextData">Arbitrary data that is passed to the exception policy.</param>
+        /// <param name="continueOnCapturedContext">Whether to continue on a captured synchronization context.</param>
+        /// <param name="cancellationToken">A cancellation token which can be used to cancel the action.  When a retry policy in use, also cancels any further retries.</param>
+        /// <returns>The captured result</returns>
+        /// <exception cref="System.ArgumentNullException">contextData</exception>
+        Task<PolicyResult<TResult>> ExecuteAndCaptureAsync<TResult>(Func<Context, CancellationToken, Task<TResult>> action, IDictionary<string, object> contextData, CancellationToken cancellationToken, bool continueOnCapturedContext);
+
+        /// <summary>
+        ///     Executes the specified asynchronous action within the policy and returns the result.
+        /// </summary>
+        /// <typeparam name="TResult">The type of the result.</typeparam>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="context">Context data that is passed to the exception policy.</param>
+        /// <param name="cancellationToken">A cancellation token which can be used to cancel the action.  When a retry policy in use, also cancels any further retries.</param>
+        /// <param name="continueOnCapturedContext">Whether to continue on a captured synchronization context.</param>
+        /// <returns>The captured result</returns>
+        /// <exception cref="System.InvalidOperationException">Please use asynchronous-defined policies when calling asynchronous ExecuteAsync (and similar) methods.</exception>
+        Task<PolicyResult<TResult>> ExecuteAndCaptureAsync<TResult>(Func<Context, CancellationToken, Task<TResult>> action, Context context, CancellationToken cancellationToken, bool continueOnCapturedContext);
+    }
+}
diff --git a/src/Polly.Shared/IAsyncPolicyTResult.cs b/src/Polly.Shared/IAsyncPolicyTResult.cs
new file mode 100644
index 00000000000..34393131594
--- /dev/null
+++ b/src/Polly.Shared/IAsyncPolicyTResult.cs
@@ -0,0 +1,185 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Polly
+{
+    /// <summary>
+    /// An interface defining all executions available on an asynchronous policy generic-typed for executions returning results of type <typeparamref name="TResult"/>.
+    /// </summary>
+    /// <typeparam name="TResult">The type of the result of funcs executed through the Policy.</typeparam>
+    public interface IAsyncPolicy<TResult> : IsPolicy
+    {
+        /// <summary>
+        /// Sets the PolicyKey for this <see cref="Policy"/> instance.
+        /// <remarks>Must be called before the policy is first used.  Can only be set once.</remarks>
+        /// </summary>
+        /// <param name="policyKey">The unique, used-definable key to assign to this <see cref="Policy"/> instance.</param>
+        IAsyncPolicy<TResult> WithPolicyKey(String policyKey);
+
+        /// <summary>
+        ///     Executes the specified asynchronous action within the policy and returns the result.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <returns>The value returned by the action</returns>
+        Task<TResult> ExecuteAsync(Func<Task<TResult>> action);
+
+        /// <summary>
+        ///     Executes the specified asynchronous action within the policy and returns the result.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="context">Context data that is passed to the exception policy.</param>
+        /// <returns>The value returned by the action</returns>
+        Task<TResult> ExecuteAsync(Func<Context, Task<TResult>> action, Context context);
+
+        /// <summary>
+        ///     Executes the specified asynchronous action within the policy and returns the result.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="contextData">Arbitrary data that is passed to the exception policy.</param>
+        /// <returns>The value returned by the action</returns>
+        Task<TResult> ExecuteAsync(Func<Context, Task<TResult>> action, IDictionary<string, object> contextData);
+
+        /// <summary>
+        ///     Executes the specified asynchronous action within the policy and returns the result.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="cancellationToken">A cancellation token which can be used to cancel the action.  When a retry policy is in use, also cancels any further retries.</param>
+        /// <returns>The value returned by the action</returns>
+        Task<TResult> ExecuteAsync(Func<CancellationToken, Task<TResult>> action, CancellationToken cancellationToken);
+
+        /// <summary>
+        ///     Executes the specified asynchronous action within the policy and returns the result.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="contextData">Arbitrary data that is passed to the exception policy.</param>
+        /// <param name="cancellationToken">A cancellation token which can be used to cancel the action.  When a retry policy in use, also cancels any further retries.</param>
+        /// <returns>The value returned by the action</returns>
+        Task<TResult> ExecuteAsync(Func<Context, CancellationToken, Task<TResult>> action, IDictionary<string, object> contextData, CancellationToken cancellationToken);
+
+        /// <summary>
+        ///     Executes the specified asynchronous action within the policy and returns the result.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="context">Context data that is passed to the exception policy.</param>
+        /// <param name="cancellationToken">A cancellation token which can be used to cancel the action.  When a retry policy is in use, also cancels any further retries.</param>
+        /// <returns>The value returned by the action</returns>
+        Task<TResult> ExecuteAsync(Func<Context, CancellationToken, Task<TResult>> action, Context context, CancellationToken cancellationToken);
+
+        /// <summary>
+        ///     Executes the specified asynchronous action within the policy and returns the result.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="continueOnCapturedContext">Whether to continue on a captured synchronization context.</param>
+        /// <param name="cancellationToken">A cancellation token which can be used to cancel the action.  When a retry policy is in use, also cancels any further retries.</param>
+        /// <returns>The value returned by the action</returns>
+        /// <exception cref="System.InvalidOperationException">Please use asynchronous-defined policies when calling asynchronous ExecuteAsync (and similar) methods.</exception>
+        Task<TResult> ExecuteAsync(Func<CancellationToken, Task<TResult>> action, CancellationToken cancellationToken, bool continueOnCapturedContext);
+
+        /// <summary>
+        ///     Executes the specified asynchronous action within the policy and returns the result.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="contextData">Arbitrary data that is passed to the exception policy.</param>
+        /// <param name="cancellationToken">A cancellation token which can be used to cancel the action.  When a retry policy in use, also cancels any further retries.</param>
+        /// <param name="continueOnCapturedContext">Whether to continue on a captured synchronization context.</param>
+        /// <returns>The value returned by the action</returns>
+        /// <exception cref="System.ArgumentNullException">contextData</exception>
+        Task<TResult> ExecuteAsync(Func<Context, CancellationToken, Task<TResult>> action, IDictionary<string, object> contextData, CancellationToken cancellationToken, bool continueOnCapturedContext);
+
+        /// <summary>
+        ///     Executes the specified asynchronous action within the policy and returns the result.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="context">Context data that is passed to the exception policy.</param>
+        /// <param name="continueOnCapturedContext">Whether to continue on a captured synchronization context.</param>
+        /// <param name="cancellationToken">A cancellation token which can be used to cancel the action.  When a retry policy is in use, also cancels any further retries.</param>
+        /// <returns>The value returned by the action</returns>
+        /// <exception cref="System.InvalidOperationException">Please use asynchronous-defined policies when calling asynchronous ExecuteAsync (and similar) methods.</exception>
+        Task<TResult> ExecuteAsync(Func<Context, CancellationToken, Task<TResult>> action, Context context, CancellationToken cancellationToken, bool continueOnCapturedContext);
+
+        /// <summary>
+        /// Executes the specified asynchronous action within the policy and returns the result.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <returns>The captured result</returns>
+        Task<PolicyResult<TResult>> ExecuteAndCaptureAsync(Func<Task<TResult>> action);
+
+        /// <summary>
+        /// Executes the specified asynchronous action within the policy and returns the result.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="contextData">Arbitrary data that is passed to the exception policy.</param>
+        /// <exception cref="System.ArgumentNullException">contextData</exception>
+        /// <returns>The captured result</returns>
+        Task<PolicyResult<TResult>> ExecuteAndCaptureAsync(Func<Context, Task<TResult>> action, IDictionary<string, object> contextData);
+
+        /// <summary>
+        /// Executes the specified asynchronous action within the policy and returns the result.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="context">Context data that is passed to the exception policy.</param>
+        /// <returns>The captured result</returns>
+        Task<PolicyResult<TResult>> ExecuteAndCaptureAsync(Func<Context, Task<TResult>> action, Context context);
+
+        /// <summary>
+        ///     Executes the specified asynchronous action within the policy and returns the result.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="cancellationToken">A cancellation token which can be used to cancel the action.  When a retry policy in use, also cancels any further retries.</param>
+        /// <returns>The captured result</returns>
+        Task<PolicyResult<TResult>> ExecuteAndCaptureAsync(Func<CancellationToken, Task<TResult>> action, CancellationToken cancellationToken);
+
+        /// <summary>
+        ///     Executes the specified asynchronous action within the policy and returns the result.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="contextData">Arbitrary data that is passed to the exception policy.</param>
+        /// <param name="cancellationToken">A cancellation token which can be used to cancel the action.  When a retry policy in use, also cancels any further retries.</param>
+        /// <exception cref="System.ArgumentNullException">contextData</exception>
+        /// <returns>The captured result</returns>
+        Task<PolicyResult<TResult>> ExecuteAndCaptureAsync(Func<Context, CancellationToken, Task<TResult>> action, IDictionary<string, object> contextData, CancellationToken cancellationToken);
+
+        /// <summary>
+        ///     Executes the specified asynchronous action within the policy and returns the result.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="context">A cancellation token which can be used to cancel the action.  When a retry policy in use, also cancels any further retries.</param>
+        /// <param name="cancellationToken">A cancellation token which can be used to cancel the action.  When a retry policy in use, also cancels any further retries.</param>
+        /// <returns>The captured result</returns>
+        Task<PolicyResult<TResult>> ExecuteAndCaptureAsync(Func<Context, CancellationToken, Task<TResult>> action, Context context, CancellationToken cancellationToken);
+
+        /// <summary>
+        ///     Executes the specified asynchronous action within the policy and returns the result.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="cancellationToken">A cancellation token which can be used to cancel the action.  When a retry policy in use, also cancels any further retries.</param>
+        /// <param name="continueOnCapturedContext">Whether to continue on a captured synchronization context.</param>
+        /// <returns>The captured result</returns>
+        /// <exception cref="System.InvalidOperationException">Please use asynchronous-defined policies when calling asynchronous ExecuteAsync (and similar) methods.</exception>
+        Task<PolicyResult<TResult>> ExecuteAndCaptureAsync(Func<CancellationToken, Task<TResult>> action, CancellationToken cancellationToken, bool continueOnCapturedContext);
+
+        /// <summary>
+        ///     Executes the specified asynchronous action within the policy and returns the result.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="contextData">Arbitrary data that is passed to the exception policy.</param>
+        /// <param name="continueOnCapturedContext">Whether to continue on a captured synchronization context.</param>
+        /// <param name="cancellationToken">A cancellation token which can be used to cancel the action.  When a retry policy in use, also cancels any further retries.</param>
+        /// <returns>The captured result</returns>
+        /// <exception cref="System.ArgumentNullException">contextData</exception>
+        Task<PolicyResult<TResult>> ExecuteAndCaptureAsync(Func<Context, CancellationToken, Task<TResult>> action, IDictionary<string, object> contextData, CancellationToken cancellationToken, bool continueOnCapturedContext);
+
+        /// <summary>
+        ///     Executes the specified asynchronous action within the policy and returns the result.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="context">Context data that is passed to the exception policy.</param>
+        /// <param name="cancellationToken">A cancellation token which can be used to cancel the action.  When a retry policy in use, also cancels any further retries.</param>
+        /// <param name="continueOnCapturedContext">Whether to continue on a captured synchronization context.</param>
+        /// <returns>The captured result</returns>
+        /// <exception cref="System.InvalidOperationException">Please use asynchronous-defined policies when calling asynchronous ExecuteAsync (and similar) methods.</exception>
+        Task<PolicyResult<TResult>> ExecuteAndCaptureAsync(Func<Context, CancellationToken, Task<TResult>> action, Context context, CancellationToken cancellationToken, bool continueOnCapturedContext);
+    }
+}
diff --git a/src/Polly.Shared/ISyncPolicy.cs b/src/Polly.Shared/ISyncPolicy.cs
new file mode 100644
index 00000000000..317538b4c53
--- /dev/null
+++ b/src/Polly.Shared/ISyncPolicy.cs
@@ -0,0 +1,232 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+
+namespace Polly
+{
+    /// <summary>
+    /// An interface defining all executions available on a non-generic, synchronous policy
+    /// </summary>
+    public interface ISyncPolicy : IsPolicy
+    {
+        /// <summary>
+        /// Sets the PolicyKey for this <see cref="Policy"/> instance.
+        /// <remarks>Must be called before the policy is first used.  Can only be set once.</remarks>
+        /// </summary>
+        /// <param name="policyKey">The unique, used-definable key to assign to this <see cref="Policy"/> instance.</param>
+        ISyncPolicy WithPolicyKey(String policyKey);
+
+        /// <summary>
+        /// Executes the specified action within the policy.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        void Execute(Action action);
+
+        /// <summary>
+        /// Executes the specified action within the policy.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="contextData">Arbitrary data that is passed to the exception policy.</param>
+        void Execute(Action<Context> action, IDictionary<string, object> contextData);
+
+        /// <summary>
+        /// Executes the specified action within the policy.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="context">Context data that is passed to the exception policy.</param>
+        void Execute(Action<Context> action, Context context);
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="action"></param>
+        /// <param name="cancellationToken"></param>
+        void Execute(Action<CancellationToken> action, CancellationToken cancellationToken);
+
+        /// <summary>
+        /// Executes the specified action within the policy.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="contextData">Arbitrary data that is passed to the exception policy.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <exception cref="System.ArgumentNullException">contextData</exception>
+        void Execute(Action<Context, CancellationToken> action, IDictionary<string, object> contextData, CancellationToken cancellationToken);
+
+        /// <summary>
+        /// Executes the specified action within the policy.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="context">Context data that is passed to the exception policy.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        void Execute(Action<Context, CancellationToken> action, Context context, CancellationToken cancellationToken);
+
+        /// <summary>
+        /// Executes the specified action within the policy and returns the Result.
+        /// </summary>
+        /// <typeparam name="TResult">The type of the Result.</typeparam>
+        /// <param name="action">The action to perform.</param>
+        /// <returns>The value returned by the action</returns>
+        TResult Execute<TResult>(Func<TResult> action);
+
+        /// <summary>
+        /// Executes the specified action within the policy and returns the result.
+        /// </summary>
+        /// <typeparam name="TResult">The type of the result.</typeparam>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="contextData">Arbitrary data that is passed to the exception policy.</param>
+        /// <exception cref="System.ArgumentNullException">contextData</exception>
+        /// <returns>
+        /// The value returned by the action
+        /// </returns>
+        /// <exception cref="System.ArgumentNullException">contextData</exception>
+        TResult Execute<TResult>(Func<Context, TResult> action, IDictionary<string, object> contextData);
+
+        /// <summary>
+        /// Executes the specified action within the policy and returns the result.
+        /// </summary>
+        /// <typeparam name="TResult">The type of the result.</typeparam>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="context">Context data that is passed to the exception policy.</param>
+        /// <exception cref="System.ArgumentNullException">contextData</exception>
+        /// <returns>
+        /// The value returned by the action
+        /// </returns>
+        /// <exception cref="System.ArgumentNullException">contextData</exception>
+        TResult Execute<TResult>(Func<Context, TResult> action, Context context);
+
+        /// <summary>
+        /// Executes the specified action within the policy and returns the result.
+        /// </summary>
+        /// <typeparam name="TResult">The type of the result.</typeparam>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>The value returned by the action</returns>
+        TResult Execute<TResult>(Func<CancellationToken, TResult> action, CancellationToken cancellationToken);
+
+        /// <summary>
+        /// Executes the specified action within the policy and returns the result.
+        /// </summary>
+        /// <typeparam name="TResult">The type of the result.</typeparam>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="contextData">Arbitrary data that is passed to the exception policy.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>The value returned by the action</returns>
+        /// <exception cref="System.ArgumentNullException">contextData</exception>
+        TResult Execute<TResult>(Func<Context, CancellationToken, TResult> action, IDictionary<string, object> contextData, CancellationToken cancellationToken);
+
+        /// <summary>
+        /// Executes the specified action within the policy and returns the result.
+        /// </summary>
+        /// <typeparam name="TResult">The type of the result.</typeparam>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="context">Context data that is passed to the exception policy.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>The value returned by the action</returns>
+        TResult Execute<TResult>(Func<Context, CancellationToken, TResult> action, Context context, CancellationToken cancellationToken);
+
+        /// <summary>
+        /// Executes the specified action within the policy and returns the captured result
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <returns>The captured result</returns>
+        PolicyResult ExecuteAndCapture(Action action);
+
+        /// <summary>
+        /// Executes the specified action within the policy and returns the captured result.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="contextData">Arbitrary data that is passed to the exception policy.</param>
+        /// <exception cref="System.ArgumentNullException">contextData</exception>
+        /// <returns>The captured result</returns>
+        PolicyResult ExecuteAndCapture(Action<Context> action, IDictionary<string, object> contextData);
+
+        /// <summary>
+        /// Executes the specified action within the policy and returns the captured result.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="context">Context data that is passed to the exception policy.</param>
+        /// <returns>The captured result</returns>
+        PolicyResult ExecuteAndCapture(Action<Context> action, Context context);
+
+        /// <summary>
+        /// Executes the specified action within the policy and returns the captured result
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>The captured result</returns>
+        PolicyResult ExecuteAndCapture(Action<CancellationToken> action, CancellationToken cancellationToken);
+
+        /// <summary>
+        /// Executes the specified action within the policy and returns the captured result.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="contextData">Arbitrary data that is passed to the exception policy.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>The captured result</returns>
+        /// <exception cref="System.ArgumentNullException">contextData</exception>
+        PolicyResult ExecuteAndCapture(Action<Context, CancellationToken> action, IDictionary<string, object> contextData, CancellationToken cancellationToken);
+
+        /// <summary>
+        /// Executes the specified action within the policy and returns the captured result
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="context">Context data that is passed to the exception policy.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>The captured result</returns>
+        PolicyResult ExecuteAndCapture(Action<Context, CancellationToken> action, Context context, CancellationToken cancellationToken);
+
+        /// <summary>
+        /// Executes the specified action within the policy and returns the captured result
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <returns>The captured result</returns>
+        PolicyResult<TResult> ExecuteAndCapture<TResult>(Func<TResult> action);
+
+        /// <summary>
+        /// Executes the specified action within the policy and returns the captured result.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="contextData">Arbitrary data that is passed to the exception policy.</param>
+        /// <exception cref="System.ArgumentNullException">contextData</exception>
+        /// <returns>The captured result</returns>
+        PolicyResult<TResult> ExecuteAndCapture<TResult>(Func<Context, TResult> action, IDictionary<string, object> contextData);
+
+        /// <summary>
+        /// Executes the specified action within the policy and returns the captured result.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="context">Context data that is passed to the exception policy.</param>
+        /// <exception cref="System.ArgumentNullException">contextData</exception>
+        /// <returns>The captured result</returns>
+        PolicyResult<TResult> ExecuteAndCapture<TResult>(Func<Context, TResult> action, Context context);
+
+        /// <summary>
+        /// Executes the specified action within the policy and returns the captured result
+        /// </summary>
+        /// <typeparam name="TResult">The type of the t result.</typeparam>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>The captured result</returns>
+        PolicyResult<TResult> ExecuteAndCapture<TResult>(Func<CancellationToken, TResult> action, CancellationToken cancellationToken);
+
+        /// <summary>
+        /// Executes the specified action within the policy and returns the captured result.
+        /// </summary>
+        /// <typeparam name="TResult">The type of the result.</typeparam>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="contextData">Arbitrary data that is passed to the exception policy.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>The captured result</returns>
+        /// <exception cref="System.ArgumentNullException">contextData</exception>
+        PolicyResult<TResult> ExecuteAndCapture<TResult>(Func<Context, CancellationToken, TResult> action, IDictionary<string, object> contextData, CancellationToken cancellationToken);
+
+        /// <summary>
+        /// Executes the specified action within the policy and returns the captured result.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="context">Context data that is passed to the exception policy.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>The captured result</returns>
+        PolicyResult<TResult> ExecuteAndCapture<TResult>(Func<Context, CancellationToken, TResult> action, Context context, CancellationToken cancellationToken);
+    }
+}
diff --git a/src/Polly.Shared/ISyncPolicyTResult.cs b/src/Polly.Shared/ISyncPolicyTResult.cs
new file mode 100644
index 00000000000..46829366b12
--- /dev/null
+++ b/src/Polly.Shared/ISyncPolicyTResult.cs
@@ -0,0 +1,132 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+
+namespace Polly
+{
+    /// <summary>
+    /// An interface defining all executions available on a synchronous policy generic-typed for executions returning results of type <typeparamref name="TResult"/>.
+    /// </summary>
+    /// <typeparam name="TResult">The type of the result of funcs executed through the Policy.</typeparam>
+
+    interface ISyncPolicy<TResult> : IsPolicy
+    {
+        /// <summary>
+        /// Sets the PolicyKey for this <see cref="Policy"/> instance.
+        /// <remarks>Must be called before the policy is first used.  Can only be set once.</remarks>
+        /// </summary>
+        /// <param name="policyKey">The unique, used-definable key to assign to this <see cref="Policy"/> instance.</param>
+        ISyncPolicy<TResult> WithPolicyKey(String policyKey);
+
+        /// <summary>
+        /// Executes the specified action within the policy and returns the Result.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <returns>The value returned by the action</returns>
+        TResult Execute(Func<TResult> action);
+
+        /// <summary>
+        /// Executes the specified action within the policy and returns the result.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="contextData">Arbitrary data that is passed to the exception policy.</param>
+        /// <exception cref="System.ArgumentNullException">contextData</exception>
+        /// <returns>
+        /// The value returned by the action
+        /// </returns>
+        /// <exception cref="System.ArgumentNullException">contextData</exception>
+        TResult Execute(Func<Context, TResult> action, IDictionary<string, object> contextData);
+
+        /// <summary>
+        /// Executes the specified action within the policy and returns the result.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="context">Context data that is passed to the exception policy.</param>
+        /// <exception cref="System.ArgumentNullException">context</exception>
+        /// <returns>
+        /// The value returned by the action
+        /// </returns>
+        /// <exception cref="System.ArgumentNullException">contextData</exception>
+        TResult Execute(Func<Context, TResult> action, Context context);
+
+        /// <summary>
+        /// Executes the specified action within the policy and returns the result.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>The value returned by the action</returns>
+        TResult Execute(Func<CancellationToken, TResult> action, CancellationToken cancellationToken);
+
+        /// <summary>
+        /// Executes the specified action within the policy and returns the result.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="contextData">Arbitrary data that is passed to the exception policy.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>The value returned by the action</returns>
+        /// <exception cref="System.ArgumentNullException">contextData</exception>
+        TResult Execute(Func<Context, CancellationToken, TResult> action, IDictionary<string, object> contextData, CancellationToken cancellationToken);
+
+        /// <summary>
+        /// Executes the specified action within the policy and returns the result.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="context">Context data that is passed to the exception policy.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>The value returned by the action</returns>
+        TResult Execute(Func<Context, CancellationToken, TResult> action, Context context, CancellationToken cancellationToken);
+
+        /// <summary>
+        /// Executes the specified action within the policy and returns the captured result
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <returns>The captured result</returns>
+        PolicyResult<TResult> ExecuteAndCapture(Func<TResult> action);
+
+        /// <summary>
+        /// Executes the specified action within the policy and returns the captured result.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="contextData">Arbitrary data that is passed to the exception policy.</param>
+        /// <exception cref="System.ArgumentNullException">contextData</exception>
+        /// <returns>The captured result</returns>
+        PolicyResult<TResult> ExecuteAndCapture(Func<Context, TResult> action, IDictionary<string, object> contextData);
+
+        /// <summary>
+        /// Executes the specified action within the policy and returns the captured result.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="context">Context data that is passed to the exception policy.</param>
+        /// <exception cref="System.ArgumentNullException">contextData</exception>
+        /// <returns>The captured result</returns>
+        PolicyResult<TResult> ExecuteAndCapture(Func<Context, TResult> action, Context context);
+
+        /// <summary>
+        /// Executes the specified action within the policy and returns the captured result
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>The captured result</returns>
+        PolicyResult<TResult> ExecuteAndCapture(Func<CancellationToken, TResult> action, CancellationToken cancellationToken);
+
+        /// <summary>
+        /// Executes the specified action within the policy and returns the captured result.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="contextData">Arbitrary data that is passed to the exception policy.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>The captured result</returns>
+        /// <exception cref="System.ArgumentNullException">contextData</exception>
+        PolicyResult<TResult> ExecuteAndCapture(Func<Context, CancellationToken, TResult> action, IDictionary<string, object> contextData, CancellationToken cancellationToken);
+
+        /// <summary>
+        /// Executes the specified action within the policy and returns the captured result.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <param name="context">Context data that is passed to the exception policy.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>The captured result</returns>
+        PolicyResult<TResult> ExecuteAndCapture(Func<Context, CancellationToken, TResult> action, Context context, CancellationToken cancellationToken);
+    }
+}
diff --git a/src/Polly.Shared/IsPolicy.cs b/src/Polly.Shared/IsPolicy.cs
new file mode 100644
index 00000000000..b1eef658da8
--- /dev/null
+++ b/src/Polly.Shared/IsPolicy.cs
@@ -0,0 +1,15 @@
+using System;
+
+namespace Polly
+{
+    /// <summary>
+    /// A marker interface identifying Polly policies of all types, and containing properties common to all policies
+    /// </summary>
+    public interface IsPolicy
+    {    
+        /// <summary>
+        /// A key intended to be unique to each <see cref="Policy"/> instance, which is passed with executions as the <see cref="M:Context.PolicyKey"/> property.
+        /// </summary>
+        String PolicyKey { get; }
+    }
+}
diff --git a/src/Polly.Shared/NoOp/INoOpPolicy.cs b/src/Polly.Shared/NoOp/INoOpPolicy.cs
new file mode 100644
index 00000000000..85be076c686
--- /dev/null
+++ b/src/Polly.Shared/NoOp/INoOpPolicy.cs
@@ -0,0 +1,18 @@
+namespace Polly.NoOp
+{
+    /// <summary>
+    /// Defines properties and methods common to all NoOp policies.
+    /// </summary>
+
+    public interface INoOpPolicy : IsPolicy
+    {
+    }
+
+    /// <summary>
+    /// Defines properties and methods common to all NoOp policies generic-typed for executions returning results of type <typeparamref name="TResult"/>.
+    /// </summary>
+    public interface INoOpPolicy<TResult> : INoOpPolicy
+    {
+
+    }
+}
diff --git a/src/Polly.Shared/NoOp/NoOpPolicy.cs b/src/Polly.Shared/NoOp/NoOpPolicy.cs
index 773efb91802..df7bfcfab42 100644
--- a/src/Polly.Shared/NoOp/NoOpPolicy.cs
+++ b/src/Polly.Shared/NoOp/NoOpPolicy.cs
@@ -10,7 +10,7 @@ namespace Polly.NoOp
     /// <summary>
     /// A no op policy that can be applied to delegates.
     /// </summary>
-    public partial class NoOpPolicy : Policy
+    public partial class NoOpPolicy : Policy, INoOpPolicy
     {
         internal NoOpPolicy(Action<Action<Context, CancellationToken>, Context, CancellationToken> exceptionPolicy)
             : base(exceptionPolicy, PredicateHelper.EmptyExceptionPredicates)
@@ -22,7 +22,7 @@ internal NoOpPolicy(Action<Action<Context, CancellationToken>, Context, Cancella
     /// A no op policy that can be applied to delegates returning a value of type <typeparamref name="TResult" />
     /// </summary>
     /// <typeparam name="TResult">The type of return values this policy will handle.</typeparam>
-    public partial class NoOpPolicy<TResult> : Policy<TResult>
+    public partial class NoOpPolicy<TResult> : Policy<TResult>, INoOpPolicy<TResult>
     {
         internal NoOpPolicy(
              Func<Func<Context, CancellationToken, TResult>, Context, CancellationToken, TResult> executionPolicy
diff --git a/src/Polly.Shared/NoOp/NoOpPolicyAsync.cs b/src/Polly.Shared/NoOp/NoOpPolicyAsync.cs
index 4cdc3268883..cd348c92746 100644
--- a/src/Polly.Shared/NoOp/NoOpPolicyAsync.cs
+++ b/src/Polly.Shared/NoOp/NoOpPolicyAsync.cs
@@ -8,7 +8,7 @@
 
 namespace Polly.NoOp
 {
-    public partial class NoOpPolicy
+    public partial class NoOpPolicy : INoOpPolicy
     {
         internal NoOpPolicy(Func<Func<Context, CancellationToken, Task>, Context, CancellationToken, bool, Task> asyncExceptionPolicy)
            : base(asyncExceptionPolicy, Enumerable.Empty<ExceptionPredicate>())
@@ -16,7 +16,7 @@ internal NoOpPolicy(Func<Func<Context, CancellationToken, Task>, Context, Cancel
         }
     }
 
-    public partial class NoOpPolicy<TResult>
+    public partial class NoOpPolicy<TResult> : INoOpPolicy<TResult>
     {
         internal NoOpPolicy(
             Func<Func<Context, CancellationToken, Task<TResult>>, Context, CancellationToken, bool, Task<TResult>> asyncExecutionPolicy
diff --git a/src/Polly.Shared/NoOp/NoOpSyntax.cs b/src/Polly.Shared/NoOp/NoOpSyntax.cs
index ccefa747743..6dc9fa4734b 100644
--- a/src/Polly.Shared/NoOp/NoOpSyntax.cs
+++ b/src/Polly.Shared/NoOp/NoOpSyntax.cs
@@ -6,9 +6,6 @@
 
 namespace Polly
 {
-    /// <summary>
-    /// Fluent API for defining a NoOp <see cref="Policy"/>.
-    /// </summary>
     public partial class Policy
     {
         /// <summary>
diff --git a/src/Polly.Shared/NoOp/NoOpSyntaxAsync.cs b/src/Polly.Shared/NoOp/NoOpSyntaxAsync.cs
index 6f63d02729d..126dee6bbf5 100644
--- a/src/Polly.Shared/NoOp/NoOpSyntaxAsync.cs
+++ b/src/Polly.Shared/NoOp/NoOpSyntaxAsync.cs
@@ -6,9 +6,6 @@
 
 namespace Polly
 {
-    /// <summary>
-    /// Fluent API for defining a NoOp <see cref="Policy"/>.
-    /// </summary>
     public partial class Policy
     {
         /// <summary>
diff --git a/src/Polly.Shared/NoOp/NoOpTResultSyntax.cs b/src/Polly.Shared/NoOp/NoOpTResultSyntax.cs
index da3011de5fb..bb99885136b 100644
--- a/src/Polly.Shared/NoOp/NoOpTResultSyntax.cs
+++ b/src/Polly.Shared/NoOp/NoOpTResultSyntax.cs
@@ -5,9 +5,6 @@
 
 namespace Polly
 {
-    /// <summary>
-    /// Fluent API for defining a NoOp <see cref="Policy"/>.
-    /// </summary>
     public partial class Policy
     {
         /// <summary>
diff --git a/src/Polly.Shared/NoOp/NoOpTResultSyntaxAsync.cs b/src/Polly.Shared/NoOp/NoOpTResultSyntaxAsync.cs
index 2df76ad853d..748ec4904ea 100644
--- a/src/Polly.Shared/NoOp/NoOpTResultSyntaxAsync.cs
+++ b/src/Polly.Shared/NoOp/NoOpTResultSyntaxAsync.cs
@@ -5,9 +5,6 @@
 
 namespace Polly
 {
-    /// <summary>
-    /// Fluent API for defining a NoOp <see cref="Policy"/>.
-    /// </summary>
     public partial class Policy
     {
         /// <summary>
diff --git a/src/Polly.Shared/Policy.ContextAndKeys.cs b/src/Polly.Shared/Policy.ContextAndKeys.cs
index 9afc5390ae3..c6cd24785ab 100644
--- a/src/Polly.Shared/Policy.ContextAndKeys.cs
+++ b/src/Polly.Shared/Policy.ContextAndKeys.cs
@@ -12,6 +12,8 @@ public partial class Policy
         /// </summary>
         public String PolicyKey => _policyKey ?? (_policyKey = GetType().Name + "-" + KeyHelper.GuidPart());
 
+        internal static ArgumentException PolicyKeyMustBeImmutableException => new ArgumentException("PolicyKey cannot be changed once set; or (when using the default value after the PolicyKey property has been accessed.", "policyKey");
+
         /// <summary>
         /// Sets the PolicyKey for this <see cref="Policy"/> instance.
         /// <remarks>Must be called before the policy is first used.  Can only be set once.</remarks>
@@ -19,7 +21,33 @@ public partial class Policy
         /// <param name="policyKey">The unique, used-definable key to assign to this <see cref="Policy"/> instance.</param>
         public Policy WithPolicyKey(String policyKey)
         {
-            if (_policyKey != null) throw new ArgumentException("For thread-safety reasons, PolicyKey cannot be set more than once on a Policy instance; or if the default value is being used, cannot be set after the PolicyKey property has been accessed.", nameof(policyKey));
+            if (_policyKey != null) throw PolicyKeyMustBeImmutableException;
+
+            _policyKey = policyKey;
+            return this;
+        }
+
+        /// <summary>
+        /// Sets the PolicyKey for this <see cref="Policy"/> instance.
+        /// <remarks>Must be called before the policy is first used.  Can only be set once.</remarks>
+        /// </summary>
+        /// <param name="policyKey">The unique, used-definable key to assign to this <see cref="Policy"/> instance.</param>
+        ISyncPolicy ISyncPolicy.WithPolicyKey(String policyKey)
+        {
+            if (_policyKey != null) throw PolicyKeyMustBeImmutableException;
+
+            _policyKey = policyKey;
+            return this;
+        }
+
+        /// <summary>
+        /// Sets the PolicyKey for this <see cref="Policy"/> instance.
+        /// <remarks>Must be called before the policy is first used.  Can only be set once.</remarks>
+        /// </summary>
+        /// <param name="policyKey">The unique, used-definable key to assign to this <see cref="Policy"/> instance.</param>
+        IAsyncPolicy IAsyncPolicy.WithPolicyKey(String policyKey)
+        {
+            if (_policyKey != null) throw PolicyKeyMustBeImmutableException;
 
             _policyKey = policyKey;
             return this;
@@ -51,12 +79,37 @@ public partial class Policy<TResult>
         /// <param name="policyKey">The unique, used-definable key to assign to this <see cref="Policy"/> instance.</param>
         public Policy<TResult> WithPolicyKey(String policyKey)
         {
-            if (_policyKey != null) throw new ArgumentException("For thread-safety reasons, PolicyKey cannot be set more than once on a Policy instance; or if the default value is being used, cannot be set after the PolicyKey property has been accessed.", nameof(policyKey));
+            if (_policyKey != null) throw Policy.PolicyKeyMustBeImmutableException;
+
+            _policyKey = policyKey;
+            return this;
+        }
+
+        /// <summary>
+        /// Sets the PolicyKey for this <see cref="Policy"/> instance.
+        /// <remarks>Must be called before the policy is first used.  Can only be set once.</remarks>
+        /// </summary>
+        /// <param name="policyKey">The unique, used-definable key to assign to this <see cref="Policy"/> instance.</param>
+        ISyncPolicy<TResult> ISyncPolicy<TResult>.WithPolicyKey(String policyKey)
+        {
+            if (_policyKey != null) throw Policy.PolicyKeyMustBeImmutableException;
 
             _policyKey = policyKey;
             return this;
         }
 
+        /// <summary>
+        /// Sets the PolicyKey for this <see cref="Policy"/> instance.
+        /// <remarks>Must be called before the policy is first used.  Can only be set once.</remarks>
+        /// </summary>
+        /// <param name="policyKey">The unique, used-definable key to assign to this <see cref="Policy"/> instance.</param>
+        IAsyncPolicy<TResult> IAsyncPolicy<TResult>.WithPolicyKey(String policyKey)
+        {
+            if (_policyKey != null) throw Policy.PolicyKeyMustBeImmutableException;
+
+            _policyKey = policyKey;
+            return this;
+        }
         /// <summary>
         /// Updates the execution <see cref="Context"/> with context from the executing <see cref="Policy{TResult}"/>.
         /// </summary>
diff --git a/src/Polly.Shared/Policy.TResult.cs b/src/Polly.Shared/Policy.TResult.cs
index 20f569d606f..070d3917b60 100644
--- a/src/Polly.Shared/Policy.TResult.cs
+++ b/src/Polly.Shared/Policy.TResult.cs
@@ -11,7 +11,7 @@ namespace Polly
     /// <summary>
     /// Transient fault handling policies that can be applied to delegates returning results of type <typeparamref name="TResult"/>
     /// </summary>
-    public abstract partial class Policy<TResult>
+    public abstract partial class Policy<TResult> : ISyncPolicy<TResult>
     {
         private readonly Func<Func<Context, CancellationToken, TResult>, Context, CancellationToken, TResult> _executionPolicy;
         private readonly IEnumerable<ExceptionPredicate> _exceptionPredicates;
diff --git a/src/Polly.Shared/Policy.cs b/src/Polly.Shared/Policy.cs
index 7a5e58c4535..4522726a6e8 100644
--- a/src/Polly.Shared/Policy.cs
+++ b/src/Polly.Shared/Policy.cs
@@ -11,7 +11,7 @@ namespace Polly
     /// Transient exception handling policies that can
     /// be applied to delegates
     /// </summary>
-    public abstract partial class Policy
+    public abstract partial class Policy : ISyncPolicy
     {
         private readonly Action<Action<Context, CancellationToken>, Context, CancellationToken> _exceptionPolicy;
         private readonly IEnumerable<ExceptionPredicate> _exceptionPredicates;
diff --git a/src/Polly.Shared/PolicyAsync.TResult.cs b/src/Polly.Shared/PolicyAsync.TResult.cs
index 7706c5c2e07..23893e2c34d 100644
--- a/src/Polly.Shared/PolicyAsync.TResult.cs
+++ b/src/Polly.Shared/PolicyAsync.TResult.cs
@@ -8,7 +8,7 @@
 
 namespace Polly
 {
-    public partial class Policy<TResult>
+    public abstract partial class Policy<TResult> : IAsyncPolicy<TResult>
     {
         private readonly Func<Func<Context, CancellationToken, Task<TResult>>, Context, CancellationToken, bool, Task<TResult>> _asyncExecutionPolicy;
 
diff --git a/src/Polly.Shared/PolicyAsync.cs b/src/Polly.Shared/PolicyAsync.cs
index cb222ffbf0a..87c46fe49ff 100644
--- a/src/Polly.Shared/PolicyAsync.cs
+++ b/src/Polly.Shared/PolicyAsync.cs
@@ -7,7 +7,7 @@
 
 namespace Polly
 {
-    public partial class Policy
+    public abstract partial class Policy : IAsyncPolicy
     {
         private readonly Func<Func<Context, CancellationToken, Task>, Context, CancellationToken, bool, Task> _asyncExceptionPolicy;
 
diff --git a/src/Polly.Shared/Polly.Shared.projitems b/src/Polly.Shared/Polly.Shared.projitems
index 94ace6bbf7a..62a9b94ddd8 100644
--- a/src/Polly.Shared/Polly.Shared.projitems
+++ b/src/Polly.Shared/Polly.Shared.projitems
@@ -18,6 +18,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)Bulkhead\BulkheadPolicy.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Bulkhead\BulkheadPolicyAsync.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Bulkhead\BulkheadRejectedException.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Bulkhead\IBulkheadPolicy.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)CircuitBreaker\AdvancedCircuitBreakerSyntax.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)CircuitBreaker\AdvancedCircuitBreakerSyntaxAsync.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)CircuitBreaker\AdvancedCircuitBreakerTResultSyntax.cs" />
@@ -35,6 +36,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)CircuitBreaker\CircuitState.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)CircuitBreaker\CircuitStateController.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)CircuitBreaker\HealthCount.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)CircuitBreaker\ICircuitBreakerPolicy.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)CircuitBreaker\ICircuitController.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)CircuitBreaker\IHealthMetrics.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)CircuitBreaker\IsolatedCircuitException.cs" />
@@ -51,6 +53,13 @@
     <Compile Include="$(MSBuildThisFileDirectory)Fallback\FallbackEngineAsync.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Fallback\FallbackPolicy.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Fallback\FallbackPolicyAsync.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Fallback\IFallbackPolicy.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)IAsyncPolicy.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)IAsyncPolicyTResult.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)ISyncPolicy.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)IsPolicy.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)ISyncPolicyTResult.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)NoOp\INoOpPolicy.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)NoOp\NoOpEngineAsync.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)NoOp\NoOpEngine.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)NoOp\NoOpPolicyAsync.cs" />
@@ -67,10 +76,11 @@
     <Compile Include="$(MSBuildThisFileDirectory)PolicyBuilder.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)PolicyBuilder.OrSyntax.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)PolicyResult.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Policy.TResult.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Registry\PolicyRegistry.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Registry\IPolicyRegistry.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)Policy.TResult.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)ResultPredicate.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Retry\IRetryPolicy.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Retry\RetryStateWaitAndRetryWithProvider.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Retry\RetryStateWaitAndRetryWithProviderAsync.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Retry\RetrySyntax.cs" />
@@ -91,6 +101,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)Retry\RetryStateWaitAndRetry.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Retry\RetryStateWaitAndRetryForever.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Retry\RetryStateWaitAndRetryForeverAsync.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Timeout\ITimeoutPolicy.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Timeout\TimeoutSyntax.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Timeout\TimeoutSyntaxAsync.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Timeout\TimeoutTResultSyntax.cs" />
@@ -109,6 +120,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)Utilities\SystemClock.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Utilities\TaskHelper.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Utilities\TimedLock.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Wrap\IPolicyWrap.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Wrap\PolicyWrapSyntax.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Wrap\PolicyWrapSyntaxAsync.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Wrap\PolicyWrap.ContextAndKeys.cs" />
diff --git a/src/Polly.Shared/Retry/IRetryPolicy.cs b/src/Polly.Shared/Retry/IRetryPolicy.cs
new file mode 100644
index 00000000000..aabf289f3bf
--- /dev/null
+++ b/src/Polly.Shared/Retry/IRetryPolicy.cs
@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Polly.Retry
+{
+    /// <summary>
+    /// Defines properties and methods common to all Retry policies.
+    /// </summary>
+
+    public interface IRetryPolicy : IsPolicy
+    {
+    }
+
+    /// <summary>
+    /// Defines properties and methods common to all Retry policies generic-typed for executions returning results of type <typeparamref name="TResult"/>.
+    /// </summary>
+    public interface IRetryPolicy<TResult> : IRetryPolicy
+    {
+
+    }
+}
diff --git a/src/Polly.Shared/Retry/RetryPolicy.cs b/src/Polly.Shared/Retry/RetryPolicy.cs
index 363692bc8c1..efeb22baddd 100644
--- a/src/Polly.Shared/Retry/RetryPolicy.cs
+++ b/src/Polly.Shared/Retry/RetryPolicy.cs
@@ -7,7 +7,7 @@ namespace Polly.Retry
     /// <summary>
     /// A retry policy that can be applied to delegates.
     /// </summary>
-    public partial class RetryPolicy : Policy
+    public partial class RetryPolicy : Policy, IRetryPolicy
     {
         internal RetryPolicy(Action<Action<Context, CancellationToken>, Context, CancellationToken> exceptionPolicy, IEnumerable<ExceptionPredicate> exceptionPredicates) 
             : base(exceptionPolicy, exceptionPredicates)
@@ -18,7 +18,7 @@ internal RetryPolicy(Action<Action<Context, CancellationToken>, Context, Cancell
     /// <summary>
     /// A retry policy that can be applied to delegates returning a value of type <typeparamref name="TResult"/>.
     /// </summary>
-    public partial class RetryPolicy<TResult> : Policy<TResult>
+    public partial class RetryPolicy<TResult> : Policy<TResult>, IRetryPolicy<TResult>
     {
         internal RetryPolicy(
             Func<Func<Context, CancellationToken, TResult>, Context, CancellationToken, TResult> executionPolicy,
diff --git a/src/Polly.Shared/Retry/RetryPolicyAsync.cs b/src/Polly.Shared/Retry/RetryPolicyAsync.cs
index 0b99a77291f..c859856f7fa 100644
--- a/src/Polly.Shared/Retry/RetryPolicyAsync.cs
+++ b/src/Polly.Shared/Retry/RetryPolicyAsync.cs
@@ -5,7 +5,7 @@
 
 namespace Polly.Retry
 {
-    public partial class RetryPolicy
+    public partial class RetryPolicy : IRetryPolicy
     {
         internal RetryPolicy(Func<Func<Context, CancellationToken, Task>, Context, CancellationToken, bool, Task> asyncExceptionPolicy, IEnumerable<ExceptionPredicate> exceptionPredicates)
            : base(asyncExceptionPolicy, exceptionPredicates)
@@ -13,7 +13,7 @@ internal RetryPolicy(Func<Func<Context, CancellationToken, Task>, Context, Cance
         }
     }
 
-    public partial class RetryPolicy<TResult>
+    public partial class RetryPolicy<TResult> : IRetryPolicy<TResult>
     {
         internal RetryPolicy(
             Func<Func<Context, CancellationToken, Task<TResult>>, Context, CancellationToken, bool, Task<TResult>> asyncExecutionPolicy, 
diff --git a/src/Polly.Shared/Timeout/ITimeoutPolicy.cs b/src/Polly.Shared/Timeout/ITimeoutPolicy.cs
new file mode 100644
index 00000000000..bdf26a02be4
--- /dev/null
+++ b/src/Polly.Shared/Timeout/ITimeoutPolicy.cs
@@ -0,0 +1,18 @@
+namespace Polly.Timeout
+{
+    /// <summary>
+    /// Defines properties and methods common to all Timeout policies.
+    /// </summary>
+
+    public interface ITimeoutPolicy : IsPolicy
+    {
+    }
+
+    /// <summary>
+    /// Defines properties and methods common to all Timeout policies generic-typed for executions returning results of type <typeparamref name="TResult"/>.
+    /// </summary>
+    public interface ITimeoutPolicy<TResult> : ITimeoutPolicy
+    {
+
+    }
+}
diff --git a/src/Polly.Shared/Timeout/TimeoutPolicy.cs b/src/Polly.Shared/Timeout/TimeoutPolicy.cs
index 29bdab097af..3d4ef2f520b 100644
--- a/src/Polly.Shared/Timeout/TimeoutPolicy.cs
+++ b/src/Polly.Shared/Timeout/TimeoutPolicy.cs
@@ -7,7 +7,7 @@ namespace Polly.Timeout
     /// <summary>
     /// A timeout policy which can be applied to delegates.
     /// </summary>
-    public partial class TimeoutPolicy : Policy
+    public partial class TimeoutPolicy : Policy, ITimeoutPolicy
     {
         internal TimeoutPolicy(
             Action<Action<Context, CancellationToken>, Context, CancellationToken> exceptionPolicy
@@ -21,7 +21,7 @@ Action<Action<Context, CancellationToken>, Context, CancellationToken> exception
     /// <summary>
     /// A timeout policy which can be applied to delegates returning a value of type <typeparamref name="TResult"/>.
     /// </summary>
-    public partial class TimeoutPolicy<TResult> : Policy<TResult>
+    public partial class TimeoutPolicy<TResult> : Policy<TResult>, ITimeoutPolicy<TResult>
     {
         internal TimeoutPolicy(
             Func<Func<Context, CancellationToken, TResult>, Context, CancellationToken, TResult> executionPolicy
diff --git a/src/Polly.Shared/Timeout/TimeoutPolicyAsync.cs b/src/Polly.Shared/Timeout/TimeoutPolicyAsync.cs
index 4b9836f1f06..7b50ae0894f 100644
--- a/src/Polly.Shared/Timeout/TimeoutPolicyAsync.cs
+++ b/src/Polly.Shared/Timeout/TimeoutPolicyAsync.cs
@@ -6,7 +6,7 @@
 
 namespace Polly.Timeout
 {
-    public partial class TimeoutPolicy
+    public partial class TimeoutPolicy : ITimeoutPolicy
     {
         internal TimeoutPolicy(Func<Func<Context, CancellationToken, Task>, Context, CancellationToken, bool, Task> asyncExceptionPolicy)
            : base(asyncExceptionPolicy, Enumerable.Empty<ExceptionPredicate>())
@@ -15,7 +15,7 @@ internal TimeoutPolicy(Func<Func<Context, CancellationToken, Task>, Context, Can
 
     }
 
-    public partial class TimeoutPolicy<TResult>
+    public partial class TimeoutPolicy<TResult> : ITimeoutPolicy<TResult>
     {
         internal TimeoutPolicy(
             Func<Func<Context, CancellationToken, Task<TResult>>, Context, CancellationToken, bool, Task<TResult>> asyncExecutionPolicy
diff --git a/src/Polly.Shared/Wrap/IPolicyWrap.cs b/src/Polly.Shared/Wrap/IPolicyWrap.cs
new file mode 100644
index 00000000000..716930af84a
--- /dev/null
+++ b/src/Polly.Shared/Wrap/IPolicyWrap.cs
@@ -0,0 +1,18 @@
+namespace Polly.Wrap
+{
+    /// <summary>
+    /// Defines properties and methods common to all PolicyWrap policies.
+    /// </summary>
+
+    public interface IPolicyWrap : IsPolicy
+    {
+    }
+
+    /// <summary>
+    /// Defines properties and methods common to all PolicyWrap policies generic-typed for executions returning results of type <typeparamref name="TResult"/>.
+    /// </summary>
+    public interface IPolicyWrap<TResult> : IPolicyWrap
+    {
+
+    }
+}
diff --git a/src/Polly.Shared/Wrap/PolicyWrap.cs b/src/Polly.Shared/Wrap/PolicyWrap.cs
index 80bb6f9a9fe..9dd4b391989 100644
--- a/src/Polly.Shared/Wrap/PolicyWrap.cs
+++ b/src/Polly.Shared/Wrap/PolicyWrap.cs
@@ -10,7 +10,7 @@ namespace Polly.Wrap
     /// <summary>
     /// A policy that allows two (and by recursion more) Polly policies to wrap executions of delegates.
     /// </summary>
-    public partial class PolicyWrap : Policy
+    public partial class PolicyWrap : Policy, IPolicyWrap
     {
         internal PolicyWrap(Action<Action<Context, CancellationToken>, Context, CancellationToken> policyAction) 
             : base(policyAction, PredicateHelper.EmptyExceptionPredicates)
@@ -22,7 +22,7 @@ internal PolicyWrap(Action<Action<Context, CancellationToken>, Context, Cancella
     /// A policy that allows two (and by recursion more) Polly policies to wrap executions of delegates.
     /// </summary>
     /// <typeparam name="TResult">The return type of delegates which may be executed through the policy.</typeparam>
-    public partial class PolicyWrap<TResult> : Policy<TResult>
+    public partial class PolicyWrap<TResult> : Policy<TResult>, IPolicyWrap<TResult>
     {
         internal PolicyWrap(Func<Func<Context, CancellationToken, TResult>, Context, CancellationToken, TResult> policyAction)
             : base(policyAction, PredicateHelper.EmptyExceptionPredicates, PredicateHelper<TResult>.EmptyResultPredicates)
diff --git a/src/Polly.Shared/Wrap/PolicyWrapAsync.cs b/src/Polly.Shared/Wrap/PolicyWrapAsync.cs
index 8d5c38e808c..3ff181de9a3 100644
--- a/src/Polly.Shared/Wrap/PolicyWrapAsync.cs
+++ b/src/Polly.Shared/Wrap/PolicyWrapAsync.cs
@@ -5,7 +5,7 @@
 
 namespace Polly.Wrap
 {
-    public partial class PolicyWrap
+    public partial class PolicyWrap : IPolicyWrap
     {
         internal PolicyWrap(Func<Func<Context, CancellationToken, Task>, Context, CancellationToken, bool, Task> policyAction)
             : base(policyAction, PredicateHelper.EmptyExceptionPredicates)
@@ -13,7 +13,7 @@ internal PolicyWrap(Func<Func<Context, CancellationToken, Task>, Context, Cancel
         }
     }
 
-    public partial class PolicyWrap<TResult>
+    public partial class PolicyWrap<TResult> : IPolicyWrap<TResult>
     {
         internal PolicyWrap(Func<Func<Context, CancellationToken, Task<TResult>>, Context, CancellationToken, bool, Task<TResult>> policyAction)
             : base(policyAction, PredicateHelper.EmptyExceptionPredicates, PredicateHelper<TResult>.EmptyResultPredicates)
diff --git a/src/Polly.SharedSpecs/Bulkhead/IBulkheadPolicySpecs.cs b/src/Polly.SharedSpecs/Bulkhead/IBulkheadPolicySpecs.cs
new file mode 100644
index 00000000000..dd16e9ee31a
--- /dev/null
+++ b/src/Polly.SharedSpecs/Bulkhead/IBulkheadPolicySpecs.cs
@@ -0,0 +1,28 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using FluentAssertions;
+using Polly.Bulkhead;
+using Xunit;
+
+namespace Polly.Specs.Bulkhead
+{
+    public class IBulkheadPolicySpecs
+    {
+        [Fact]
+        public void Should_be_able_to_use_BulkheadAvailableCount_via_interface()
+        {
+            IBulkheadPolicy bulkhead = Policy.Bulkhead(20, 10);
+
+            bulkhead.BulkheadAvailableCount.Should().Be(20);
+        }
+
+        [Fact]
+        public void Should_be_able_to_use_QueueAvailableCount_via_interface()
+        {
+            IBulkheadPolicy bulkhead = Policy.Bulkhead(20, 10);
+
+            bulkhead.QueueAvailableCount.Should().Be(10);
+        }
+    }
+}
diff --git a/src/Polly.SharedSpecs/CircuitBreaker/ICircuitBreakerPolicySpecs.cs b/src/Polly.SharedSpecs/CircuitBreaker/ICircuitBreakerPolicySpecs.cs
new file mode 100644
index 00000000000..4854f25ba0d
--- /dev/null
+++ b/src/Polly.SharedSpecs/CircuitBreaker/ICircuitBreakerPolicySpecs.cs
@@ -0,0 +1,58 @@
+using System;
+using FluentAssertions;
+using Polly.CircuitBreaker;
+using Xunit;
+
+namespace Polly.Specs.CircuitBreaker
+{
+    public class ICircuitBreakerPolicySpecs
+    {
+        [Fact]
+        public void Should_be_able_to_use_CircuitState_via_interface()
+        {
+            ICircuitBreakerPolicy breaker = Policy
+                .Handle<DivideByZeroException>()
+                .CircuitBreaker(2, TimeSpan.FromMinutes(1));
+
+            breaker.CircuitState.Should().Be(CircuitState.Closed);
+
+        }
+
+        [Fact]
+        public void Should_be_able_to_use_Isolate_via_interface()
+        {
+            ICircuitBreakerPolicy breaker = Policy
+                .Handle<DivideByZeroException>()
+                .CircuitBreaker(2, TimeSpan.FromMinutes(1));
+
+            breaker.Isolate();
+            breaker.CircuitState.Should().Be(CircuitState.Isolated);
+        }
+
+        [Fact]
+        public void Should_be_able_to_use_Reset_via_interface()
+        {
+            ICircuitBreakerPolicy breaker = Policy
+                .Handle<DivideByZeroException>()
+                .CircuitBreaker(2, TimeSpan.FromMinutes(1));
+
+            breaker.Isolate();
+            breaker.CircuitState.Should().Be(CircuitState.Isolated);
+
+            breaker.Reset();
+            breaker.CircuitState.Should().Be(CircuitState.Closed);
+        }
+
+        [Fact]
+        public void Should_be_able_to_use_LastException_via_interface()
+        {
+            ICircuitBreakerPolicy breaker = Policy
+                .Handle<DivideByZeroException>()
+                .CircuitBreaker(2, TimeSpan.FromMinutes(1));
+
+            breaker.LastException.Should().BeNull();
+
+        }
+
+    }
+}
diff --git a/src/Polly.SharedSpecs/CircuitBreaker/ICircuitBreakerPolicyTResultSpecs.cs b/src/Polly.SharedSpecs/CircuitBreaker/ICircuitBreakerPolicyTResultSpecs.cs
new file mode 100644
index 00000000000..f4ab982fccb
--- /dev/null
+++ b/src/Polly.SharedSpecs/CircuitBreaker/ICircuitBreakerPolicyTResultSpecs.cs
@@ -0,0 +1,23 @@
+using System;
+using FluentAssertions;
+using Polly.CircuitBreaker;
+using Polly.Specs.Helpers;
+using Xunit;
+
+namespace Polly.Specs.CircuitBreaker
+{
+    public class ICircuitBreakerTResultPolicySpecs
+    {
+        [Fact]
+        public void Should_be_able_to_use_LastHandledResult_via_interface()
+        {
+            ICircuitBreakerPolicy<ResultPrimitive> breaker = Policy
+                .HandleResult(ResultPrimitive.Fault)
+                .CircuitBreaker(2, TimeSpan.FromMinutes(1));
+
+            breaker.LastHandledResult.Should().Be(default(ResultPrimitive));
+
+        }
+
+    }
+}
diff --git a/src/Polly.SharedSpecs/PolicyContextAndKeyAsyncSpecs.cs b/src/Polly.SharedSpecs/PolicyContextAndKeyAsyncSpecs.cs
index 4a0daf95810..c1a091d3157 100644
--- a/src/Polly.SharedSpecs/PolicyContextAndKeyAsyncSpecs.cs
+++ b/src/Polly.SharedSpecs/PolicyContextAndKeyAsyncSpecs.cs
@@ -19,6 +19,15 @@ public void Should_be_able_fluently_to_configure_the_policy_key()
             policy.Should().BeAssignableTo<Policy>();
         }
 
+        [Fact]
+        public void Should_be_able_fluently_to_configure_the_policy_key_via_interface()
+        {
+            IAsyncPolicy policyAsInterface = Policy.Handle<Exception>().RetryAsync();
+            var policyAsInterfaceAfterWithPolicyKey = policyAsInterface.WithPolicyKey(Guid.NewGuid().ToString());
+
+            policyAsInterfaceAfterWithPolicyKey.Should().BeAssignableTo<IAsyncPolicy>();
+        }
+
         [Fact]
         public void PolicyKey_property_should_be_the_fluently_configured_policy_key()
         {
@@ -193,6 +202,15 @@ public void Should_be_able_fluently_to_configure_the_policy_key()
             policy.Should().BeAssignableTo<Policy<int>>();
         }
 
+        [Fact]
+        public void Should_be_able_fluently_to_configure_the_policy_key_via_interface()
+        {
+            IAsyncPolicy<int> policyAsInterface = Policy.HandleResult<int>(0).RetryAsync();
+            var policyAsInterfaceAfterWithPolicyKey = policyAsInterface.WithPolicyKey(Guid.NewGuid().ToString());
+
+            policyAsInterfaceAfterWithPolicyKey.Should().BeAssignableTo<IAsyncPolicy<int>>();
+        }
+
         [Fact]
         public void PolicyKey_property_should_be_the_fluently_configured_policy_key()
         {
diff --git a/src/Polly.SharedSpecs/PolicyContextAndKeySpecs.cs b/src/Polly.SharedSpecs/PolicyContextAndKeySpecs.cs
index 6f658275abb..19c1cee1148 100644
--- a/src/Polly.SharedSpecs/PolicyContextAndKeySpecs.cs
+++ b/src/Polly.SharedSpecs/PolicyContextAndKeySpecs.cs
@@ -17,6 +17,15 @@ public void Should_be_able_fluently_to_configure_the_policy_key()
             policy.Should().BeAssignableTo<Policy>();
         }
 
+        [Fact]
+        public void Should_be_able_fluently_to_configure_the_policy_key_via_interface()
+        {
+            ISyncPolicy policyAsInterface = Policy.Handle<Exception>().Retry();
+            var policyAsInterfaceAfterWithPolicyKey = policyAsInterface.WithPolicyKey(Guid.NewGuid().ToString());
+
+            policyAsInterfaceAfterWithPolicyKey.Should().BeAssignableTo<ISyncPolicy>();
+        }
+
         [Fact]
         public void PolicyKey_property_should_be_the_fluently_configured_policy_key()
         {
@@ -190,6 +199,15 @@ public void Should_be_able_fluently_to_configure_the_policy_key()
             policy.Should().BeAssignableTo<Policy<int>>();
         }
 
+        [Fact]
+        public void Should_be_able_fluently_to_configure_the_policy_key_via_interface()
+        {
+            ISyncPolicy<int> policyAsInterface = Policy.HandleResult<int>(0).Retry();
+            var policyAsInterfaceAfterWithPolicyKey = policyAsInterface.WithPolicyKey(Guid.NewGuid().ToString());
+
+            policyAsInterfaceAfterWithPolicyKey.Should().BeAssignableTo<ISyncPolicy<int>>();
+        }
+
         [Fact]
         public void PolicyKey_property_should_be_the_fluently_configured_policy_key()
         {
diff --git a/src/Polly.SharedSpecs/Polly.SharedSpecs.projitems b/src/Polly.SharedSpecs/Polly.SharedSpecs.projitems
index 2ab0bb38957..fd80c97db71 100644
--- a/src/Polly.SharedSpecs/Polly.SharedSpecs.projitems
+++ b/src/Polly.SharedSpecs/Polly.SharedSpecs.projitems
@@ -15,6 +15,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)Bulkhead\BulkheadSpecsHelper.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Bulkhead\BulkheadTResultAsyncSpecs.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Bulkhead\BulkheadTResultSpecs.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Bulkhead\IBulkheadPolicySpecs.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)CircuitBreaker\AdvancedCircuitBreakerSpecs.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)CircuitBreaker\AdvancedCircuitBreakerAsyncSpecs.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)CircuitBreaker\CircuitBreakerSpecs.cs" />
@@ -22,6 +23,8 @@
     <Compile Include="$(MSBuildThisFileDirectory)CircuitBreaker\CircuitBreakerTResultAsyncSpecs.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)CircuitBreaker\CircuitBreakerTResultMixedResultExceptionSpecs.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)CircuitBreaker\CircuitBreakerTResultSpecs.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)CircuitBreaker\ICircuitBreakerPolicySpecs.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)CircuitBreaker\ICircuitBreakerPolicyTResultSpecs.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)ContextSpecs.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Fallback\FallbackAsyncSpecs.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Fallback\FallbackSpecs.cs" />
@@ -47,9 +50,9 @@
     <Compile Include="$(MSBuildThisFileDirectory)PolicyContextAndKeyAsyncSpecs.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)PolicyContextAndKeySpecs.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)PolicySpecs.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)Registry\PolicyRegistrySpecs.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)PolicyTResultAsyncSpecs.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)PolicyTResultSpecs.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Registry\PolicyRegistrySpecs.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Retry\RetryAsyncSpecs.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Retry\RetryForeverAsyncSpecs.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Retry\RetryForeverSpecs.cs" />

From d20102e1078df8a58c5a6954407a4762e7302418 Mon Sep 17 00:00:00 2001
From: reisenberger <software@reisenberger.net>
Date: Tue, 27 Jun 2017 22:16:28 +0100
Subject: [PATCH 4/6] Remove incorrect intellisense doco

Remove intellisense doco incorrectly on syntax classes which are
extension methods on the base Policy class.  This intellisense was
overriding the correct intellisense for the base Policy class.
---
 src/Polly.Shared/Bulkhead/BulkheadSyntaxAsync.cs        | 3 ---
 src/Polly.Shared/Bulkhead/BulkheadTResultSyntax.cs      | 3 ---
 src/Polly.Shared/Bulkhead/BulkheadTResultSyntaxAsync.cs | 3 ---
 3 files changed, 9 deletions(-)

diff --git a/src/Polly.Shared/Bulkhead/BulkheadSyntaxAsync.cs b/src/Polly.Shared/Bulkhead/BulkheadSyntaxAsync.cs
index 5be2f8a5a85..c7a9473ab54 100644
--- a/src/Polly.Shared/Bulkhead/BulkheadSyntaxAsync.cs
+++ b/src/Polly.Shared/Bulkhead/BulkheadSyntaxAsync.cs
@@ -12,9 +12,6 @@
 
 namespace Polly
 {
-    /// <summary>
-    /// Fluent API for defining a <see cref="BulkheadPolicy"/>. 
-    /// </summary>    
     public partial class Policy
     {
         /// <summary>
diff --git a/src/Polly.Shared/Bulkhead/BulkheadTResultSyntax.cs b/src/Polly.Shared/Bulkhead/BulkheadTResultSyntax.cs
index 76405e3ab79..368c31c82a5 100644
--- a/src/Polly.Shared/Bulkhead/BulkheadTResultSyntax.cs
+++ b/src/Polly.Shared/Bulkhead/BulkheadTResultSyntax.cs
@@ -12,9 +12,6 @@
 
 namespace Polly
 {
-    /// <summary>
-    /// Fluent API for defining a <see cref="BulkheadPolicy"/>. 
-    /// </summary>
     public partial class Policy
     {
         /// <summary>
diff --git a/src/Polly.Shared/Bulkhead/BulkheadTResultSyntaxAsync.cs b/src/Polly.Shared/Bulkhead/BulkheadTResultSyntaxAsync.cs
index 03bcaefa5ae..e0e00f7869f 100644
--- a/src/Polly.Shared/Bulkhead/BulkheadTResultSyntaxAsync.cs
+++ b/src/Polly.Shared/Bulkhead/BulkheadTResultSyntaxAsync.cs
@@ -12,9 +12,6 @@
 
 namespace Polly
 {
-    /// <summary>
-    /// Fluent API for defining a <see cref="BulkheadPolicy"/>. 
-    /// </summary>    
     public partial class Policy
     {
         /// <summary>

From 9a9da0437f368013b6a58eb673e42e5efea2bfea Mon Sep 17 00:00:00 2001
From: reisenberger <software@reisenberger.net>
Date: Tue, 27 Jun 2017 22:18:38 +0100
Subject: [PATCH 5/6] Amend PolicyRegistry to use interfaces

---
 src/Polly.Shared/Registry/IPolicyRegistry.cs  |  69 ++---
 src/Polly.Shared/Registry/PolicyRegistry.cs   |  98 ++++---
 .../Registry/PolicyRegistrySpecs.cs           | 241 +++++++++++++++++-
 3 files changed, 333 insertions(+), 75 deletions(-)

diff --git a/src/Polly.Shared/Registry/IPolicyRegistry.cs b/src/Polly.Shared/Registry/IPolicyRegistry.cs
index f022f78df15..1d00ea2e159 100644
--- a/src/Polly.Shared/Registry/IPolicyRegistry.cs
+++ b/src/Polly.Shared/Registry/IPolicyRegistry.cs
@@ -1,37 +1,60 @@
 using System;
 using System.Collections.Generic;
+using Polly;
 
 namespace Polly.Registry
 {
     /// <summary>
-    /// Represents a collection of <see cref="Polly.Policy"/> keyed by <typeparamref name="TKey"/>.
+    /// Represents a collection of policies keyed by <typeparamref name="TKey"/>.
     /// </summary>
-    /// <typeparam name="TKey">The type of keys in the dictionary.</typeparam>
-    /// <typeparam name="TPolicy">The type of Policy to store. Must be derived from <see cref="Polly.Policy"/>.</typeparam>
-    public interface IPolicyRegistry<TKey, TPolicy> where TPolicy: Polly.Policy
+    /// <typeparam name="TKey">The type of keys in the policy registry.</typeparam>
+    public interface IPolicyRegistry<in TKey> 
     {
         /// <summary>
-        /// Gets or sets <typeparamref name="TPolicy"/> with specified Key.
+        /// Adds an element with the provided key and policy to the registry.
         /// </summary>
-        /// <param name="key">The key of the policy to get or set.</param>
-        /// <returns>The policy with specified Key.</returns>
+        /// <param name="key">The key for the policy.</param>
+        /// <param name="policy">The policy to store in the registry.</param>
+        /// <typeparam name="TPolicy">The type of Policy.</typeparam>
         /// <exception cref="ArgumentNullException"><paramref name="key"/> is null.</exception>
-        /// <exception cref="KeyNotFoundException">Policy with the specified <paramref name="key"/> is not found in the registry.</exception>
-        TPolicy this[TKey key] { get; set; }
+        /// <exception cref="ArgumentException">A Policy with same <paramref name="key"/> already exists.</exception>
+        void Add<TPolicy>(TKey key, TPolicy policy) where TPolicy : IsPolicy;
 
         /// <summary>
-        /// Total number of policies in the registry.
+        /// Gets of sets the <see cref="IsPolicy"/> with the specified key.
+        /// <remarks>To retrieve a policy directly as a particular Policy type or Policy interface (avoiding a cast), use the <see cref="Get{TPolicy}"/> method.</remarks>
         /// </summary>
-        int Count { get; }
+        /// <param name="key">The key of the value to get or set.</param>
+        /// <exception cref="T:System.ArgumentNullException"><paramref name="key" /> is null.</exception>
+        /// <exception cref="KeyNotFoundException">The given key was not present in the dictionary.</exception>
+        /// <returns>The value associated with the specified key.</returns>
+        IsPolicy this[TKey key] { get; set; }
 
         /// <summary>
-        /// Adds a <typeparamref name="TPolicy"/> with the provided key to the registry.
+        /// Gets the policy stored under the provided key, casting to <typeparamref name="TPolicy"/>.
         /// </summary>
-        /// <param name="key">The key of the <typeparamref name="TPolicy"/> to add.</param>
-        /// <param name="value">The <typeparamref name="TPolicy"/> to store in the registry.</param>
+        /// <typeparam name="TPolicy">The type of Policy.</typeparam>
+        /// <returns>The policy stored in the registry under the given key.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="key"/> is null.</exception>
-        /// <exception cref="ArgumentException">A Policy with same <paramref name="key"/> already exists.</exception>
-        void Add(TKey key, TPolicy value);
+        TPolicy Get<TPolicy>(TKey key) where TPolicy : IsPolicy;
+
+        /// <summary>
+        /// Gets the policy stored under the provided key, casting to <typeparamref name="TPolicy"/>.
+        /// </summary>
+        /// <param name="key">The key of the policy to get.</param>
+        /// <param name="policy">
+        /// This method returns the policy associated with the specified <paramref name="key"/>, if the
+        /// key is found; otherwise null.
+        /// This parameter is passed uninitialized.
+        /// </param>
+        /// <typeparam name="TPolicy">The type of Policy.</typeparam>
+        /// <returns>True if Policy exists for the provided Key. False otherwise.</returns>
+        bool TryGet<TPolicy>(TKey key, out TPolicy policy) where TPolicy : IsPolicy;
+
+        /// <summary>
+        /// Total number of policies in the registry.
+        /// </summary>
+        int Count { get; }
 
         /// <summary>
         /// Determines whether the specified <paramref name="key"/> exists.
@@ -42,25 +65,13 @@ public interface IPolicyRegistry<TKey, TPolicy> where TPolicy: Polly.Policy
         bool ContainsKey(TKey key);
 
         /// <summary>
-        /// Removes the specified <typeparamref name="TPolicy"/> from the registry.
+        /// Removes the specified <see cref="Polly.Policy"/> from the registry.
         /// </summary>
         /// <param name="key">The key of the policy to remove.</param>
         /// <returns>True if <see cref="Polly.Policy"/> is successfully removed. Otherwise false.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="key"/> is null.</exception>
         bool Remove(TKey key);
 
-        /// <summary>
-        /// Gets the <typeparamref name="TPolicy"/> associated with the specified key.
-        /// </summary>
-        /// <param name="key">The key whose value to get.</param>
-        /// <param name="value">
-        /// This method returns the <typeparamref name="TPolicy"/> associated with the specified <paramref name="key"/>, if the
-        /// key is found; otherwise null.
-        /// This parameter is passed uninitialized.
-        /// </param>
-        /// <returns>True if Policy exists for the provided Key. False otherwise.</returns>
-        bool TryGetValue(TKey key, out TPolicy value);
-
         /// <summary>
         /// Removes all keys and policies from registry.
         /// </summary>
diff --git a/src/Polly.Shared/Registry/PolicyRegistry.cs b/src/Polly.Shared/Registry/PolicyRegistry.cs
index c6211d26458..1c23adf26de 100644
--- a/src/Polly.Shared/Registry/PolicyRegistry.cs
+++ b/src/Polly.Shared/Registry/PolicyRegistry.cs
@@ -1,46 +1,85 @@
-using System.Collections;
+using System;
 using System.Collections.Generic;
 using System.Collections.Concurrent;
-using System;
 
 namespace Polly.Registry
 {
     /// <summary>
-    /// Stores a registry of <see cref="System.String"/> and <see cref="Policy"/> pair.
+    /// Stores a registry of <see cref="System.String"/> and <see cref="Polly.Policy"/> pair.
     /// </summary>
     /// <remarks>Uses ConcurrentDictionary to store the collection.</remarks>
-    public class PolicyRegistry : IPolicyRegistry<string, Policy>
+    public class PolicyRegistry : IPolicyRegistry<string>
     {
-        private IDictionary<string, Policy> _registry = new ConcurrentDictionary<string, Policy>();
+        private readonly IDictionary<string, IsPolicy> _registry = new ConcurrentDictionary<string, IsPolicy>();
 
         /// <summary>
-        /// Gets or sets the <see cref="Policy"/> associated with the specified key.
+        /// Total number of policies in the registry.
+        /// </summary>
+        public int Count => _registry.Count;
+
+        /// <summary>
+        /// Adds an element with the provided key and policy to the registry.
         /// </summary>
-        /// <param name="key">The key of the <see cref="Policy"/> to get or set.</param>
-        /// <returns>The <see cref="Policy"/> with specified <paramref name="key"/>.</returns>
+        /// <param name="key">The key for the policy.</param>
+        /// <param name="policy">The policy to store in the registry.</param>
+        /// <typeparam name="TPolicy">The type of Policy.</typeparam>
         /// <exception cref="ArgumentNullException"><paramref name="key"/> is null.</exception>
-        /// <exception cref="KeyNotFoundException">Policy with the specified <paramref name="key"/> does not exists in the registry.</exception>
-        public Policy this[string key]
+        /// <exception cref="ArgumentException">A Policy with same <paramref name="key"/> already exists.</exception>
+        public void Add<TPolicy>(string key, TPolicy policy) where TPolicy : IsPolicy
         {
-            get { return _registry[key]; }
-
-            set { _registry[key] = value; }
+            _registry.Add(key, policy);
         }
 
         /// <summary>
-        /// Total number of policies in the registry.
+        /// Gets of sets the <see cref="IsPolicy"/> with the specified key.
+        /// <remarks>To retrieve a policy directly as a particular Policy type or Policy interface (avoiding a cast), use the <see cref="Get{TPolicy}"/> method.</remarks>
         /// </summary>
-        public int Count => _registry.Count;
+        /// <param name="key">The key of the value to get or set.</param>
+        /// <exception cref="T:System.ArgumentNullException"><paramref name="key" /> is null.</exception>
+        /// <exception cref="KeyNotFoundException">The given key was not present in the dictionary.</exception>
+        /// <returns>The value associated with the specified key.</returns>
+        public IsPolicy this[string key]
+        {
+            get
+            {
+                return _registry[key];
+            }
+            set
+            {
+                _registry[key] = value;
+            }
+        }
 
         /// <summary>
-        /// Adds an element with the provided key and <see cref="Policy"/> to the registry.
+        /// Gets the policy stored under the provided key, casting to <typeparamref name="TPolicy"/>.
         /// </summary>
-        /// <param name="key">The string to use as the key of the element to add.</param>
-        /// <param name="value">The <see cref="Policy"/> to store in the registry.</param>
+        /// <typeparam name="TPolicy">The type of Policy.</typeparam>
+        /// <returns>The policy stored in the registry under the given key.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="key"/> is null.</exception>
-        /// <exception cref="ArgumentException">A Policy with same <paramref name="key"/> already exists.</exception>
-        public void Add(string key, Policy value) =>
-            _registry.Add(key, value);
+        /// <exception cref="KeyNotFoundException">The given key was not present in the dictionary.</exception>
+        public TPolicy Get<TPolicy>(string key) where TPolicy : IsPolicy
+        {
+            return (TPolicy) _registry[key];
+        }
+
+        /// <summary>
+        /// Gets the policy stored under the provided key, casting to <typeparamref name="TPolicy"/>.
+        /// </summary>
+        /// <param name="key">The key of the policy to get.</param>
+        /// <param name="policy">
+        /// This method returns the policy associated with the specified <paramref name="key"/>, if the
+        /// key is found; otherwise null.
+        /// This parameter is passed uninitialized.
+        /// </param>
+        /// <typeparam name="TPolicy">The type of Policy.</typeparam>
+        /// <returns>True if Policy exists for the provided Key. False otherwise.</returns>
+        public bool TryGet<TPolicy>(string key, out TPolicy policy) where TPolicy : IsPolicy
+        {
+            IsPolicy value;
+            bool got = _registry.TryGetValue(key, out value);
+            policy = got ? (TPolicy)value : default(TPolicy);
+            return got;
+        }
 
         /// <summary>
         /// Removes all keys and policies from registry.
@@ -58,25 +97,12 @@ public bool ContainsKey(string key) =>
             _registry.ContainsKey(key);
 
         /// <summary>
-        /// Removes the stored <see cref="Policy"/> under specified <paramref name="key"/> from the registry.
+        /// Removes the stored <see cref="Polly.Policy"/> under specified <paramref name="key"/> from the registry.
         /// </summary>
         /// <param name="key">The <paramref name="key"/> of the policy to remove.</param>
-        /// <returns>True if <see cref="Policy"/> is successfully removed. Otherwise false.</returns>
+        /// <returns>True if <see cref="Polly.Policy"/> is successfully removed. Otherwise false.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="key"/> is null.</exception>
         public bool Remove(string key) =>
             _registry.Remove(key);
-
-        /// <summary>
-        /// Gets the <see cref="Policy"/> associated with the specified key.
-        /// </summary>
-        /// <param name="key">The key whose value to get.</param>
-        /// <param name="value">
-        /// This method returns the <see cref="Policy"/> associated with the specified <paramref name="key"/>, if the
-        /// key is found; otherwise null.
-        /// This parameter is passed uninitialized.
-        /// </param>
-        /// <returns>True if Policy exists for the provided Key. False otherwise.</returns>
-        public bool TryGetValue(string key, out Policy value) =>
-            _registry.TryGetValue(key, out value);
     }
 }
diff --git a/src/Polly.SharedSpecs/Registry/PolicyRegistrySpecs.cs b/src/Polly.SharedSpecs/Registry/PolicyRegistrySpecs.cs
index bc72be48d9b..856e6d306b6 100644
--- a/src/Polly.SharedSpecs/Registry/PolicyRegistrySpecs.cs
+++ b/src/Polly.SharedSpecs/Registry/PolicyRegistrySpecs.cs
@@ -5,12 +5,13 @@
 using FluentAssertions;
 using Polly.Registry;
 using Polly.NoOp;
+using Polly.Specs.Helpers;
 
 namespace Polly.Specs.Registry
 {
     public class PolicyRegistrySpecs
     {
-        IPolicyRegistry<string, Policy> _registry;
+        IPolicyRegistry<string> _registry;
 
         public PolicyRegistrySpecs()
         {
@@ -35,6 +36,38 @@ public void Should_be_able_to_add_Policy_using_Add()
             _registry.Count.Should().Be(2);
         }
 
+        [Fact]
+        public void Should_be_able_to_add_PolicyTResult_using_Add()
+        {
+            Policy policy = Policy.NoOp();
+            string key = Guid.NewGuid().ToString();
+
+            _registry.Add(key, policy);
+            _registry.Count.Should().Be(1);
+
+            Policy<ResultPrimitive> policy2 = Policy<ResultPrimitive>.HandleResult(ResultPrimitive.Fault).Retry();
+            string key2 = Guid.NewGuid().ToString();
+
+            _registry.Add(key2, policy2);
+            _registry.Count.Should().Be(2);
+        }
+
+        [Fact]
+        public void Should_be_able_to_add_Policy_by_interface_using_Add()
+        {
+            Policy policy = Policy.NoOp();
+            string key = Guid.NewGuid().ToString();
+
+            _registry.Add(key, policy);
+            _registry.Count.Should().Be(1);
+
+            ISyncPolicy<ResultPrimitive> policy2 = Policy<ResultPrimitive>.HandleResult(ResultPrimitive.Fault).Retry();
+            string key2 = Guid.NewGuid().ToString();
+
+            _registry.Add<ISyncPolicy<ResultPrimitive>>(key2, policy2);
+            _registry.Count.Should().Be(2);
+        }
+
         [Fact]
         public void Should_be_able_to_add_Policy_using_Indexer()
         {
@@ -51,6 +84,22 @@ public void Should_be_able_to_add_Policy_using_Indexer()
             _registry.Count.Should().Be(2);
         }
 
+        [Fact]
+        public void Should_be_able_to_add_PolicyTResult_using_Indexer()
+        {
+            Policy policy = Policy.NoOp();
+            string key = Guid.NewGuid().ToString();
+
+            _registry[key] = policy;
+            _registry.Count.Should().Be(1);
+
+            Policy<ResultPrimitive> policy2 = Policy<ResultPrimitive>.HandleResult(ResultPrimitive.Fault).Retry();
+            string key2 = Guid.NewGuid().ToString();
+
+            _registry[key2] = policy2;
+            _registry.Count.Should().Be(2);
+        }
+        
         [Fact]
         public void Should_not_be_able_to_add_Policy_with_duplicate_key_using_Add()
         {
@@ -67,7 +116,7 @@ public void Should_not_be_able_to_add_Policy_with_duplicate_key_using_Add()
         }
 
         [Fact]
-        public void Should_be_able_to_overwrite_existing_Policy_if_key_exists_when_inserting_using_Idexer()
+        public void Should_be_able_to_overwrite_existing_Policy_if_key_exists_when_inserting_using_Indexer()
         {
             Policy policy = Policy.NoOp();
             string key = Guid.NewGuid().ToString();
@@ -75,11 +124,27 @@ public void Should_be_able_to_overwrite_existing_Policy_if_key_exists_when_inser
 
             Policy policy_new = Policy.NoOp();
             _registry[key] = policy_new;
+
             _registry.Count.Should().Be(1);
 
-            _registry[key].Should().BeSameAs(policy_new);
+            _registry.Get<Policy>(key).Should().BeSameAs(policy_new);
         }
 
+        [Fact]
+        public void Should_be_able_to_overwrite_existing_PolicyTResult_if_key_exists_when_inserting_using_Indexer()
+        {
+            Policy<ResultPrimitive> policy = Policy<ResultPrimitive>.HandleResult(ResultPrimitive.Fault).Retry();
+            string key = Guid.NewGuid().ToString();
+            _registry.Add<ISyncPolicy<ResultPrimitive>>(key, policy);
+
+            Policy<ResultPrimitive> policy_new = Policy<ResultPrimitive>.HandleResult(ResultPrimitive.Fault).Retry();
+            _registry[key] = policy_new;
+
+            _registry.Count.Should().Be(1);
+
+            _registry.Get<Policy<ResultPrimitive>>(key).Should().BeSameAs(policy_new);
+        }
+        
         [Fact]
         public void Should_throw_when_adding_Policy_using_Add_when_key_is_null()
         {
@@ -101,18 +166,73 @@ public void Should_throw_when_adding_Policy_using_Indexer_when_key_is_null()
         #endregion
 
         #region Tests for retrieving policy
+
         [Fact]
-        public void Should_be_able_to_retrieve_stored_Policy_using_TryGetValue()
+        public void Should_be_able_to_retrieve_stored_Policy_using_TryGet()
         {
             Policy policy = Policy.NoOp();
             string key = Guid.NewGuid().ToString();
             Policy outPolicy = null;
 
             _registry.Add(key, policy);
-            _registry.TryGetValue(key, out outPolicy).Should().BeTrue();
+            _registry.TryGet(key, out outPolicy).Should().BeTrue();
             outPolicy.Should().BeSameAs(policy);
         }
 
+        [Fact]
+        public void Should_be_able_to_retrieve_stored_PolicyTResult_using_TryGet()
+        {
+            Policy<ResultPrimitive> policy = Policy<ResultPrimitive>.HandleResult(ResultPrimitive.Fault).Retry();
+            string key = Guid.NewGuid().ToString();
+            Policy<ResultPrimitive> outPolicy = null;
+
+            _registry.Add(key, policy);
+            _registry.TryGet(key, out outPolicy).Should().BeTrue();
+            outPolicy.Should().BeSameAs(policy);
+        }
+
+        [Fact]
+        public void Should_be_able_to_retrieve_stored_Policy_by_interface_using_TryGet()
+        {
+            ISyncPolicy<ResultPrimitive> policy = Policy<ResultPrimitive>.HandleResult(ResultPrimitive.Fault).Retry();
+            string key = Guid.NewGuid().ToString();
+            ISyncPolicy<ResultPrimitive> outPolicy = null;
+
+            _registry.Add(key, policy);
+            _registry.TryGet(key, out outPolicy).Should().BeTrue();
+            outPolicy.Should().BeSameAs(policy);
+        }
+
+        [Fact]
+        public void Should_be_able_to_retrieve_stored_Policy_using_Get()
+        {
+            Policy policy = Policy.NoOp();
+            string key = Guid.NewGuid().ToString();
+
+            _registry.Add(key, policy);
+            _registry.Get<Policy>(key).Should().BeSameAs(policy);
+        }
+
+        [Fact]
+        public void Should_be_able_to_retrieve_stored_PolicyTResult_using_Get()
+        {
+            Policy<ResultPrimitive> policy = Policy<ResultPrimitive>.HandleResult(ResultPrimitive.Fault).Retry();
+            string key = Guid.NewGuid().ToString();
+
+            _registry.Add(key, policy);
+            _registry.Get<Policy<ResultPrimitive>>(key).Should().BeSameAs(policy);
+        }
+
+        [Fact]
+        public void Should_be_able_to_retrieve_stored_Policy_by_interface_using_Get()
+        {
+            ISyncPolicy<ResultPrimitive> policy = Policy<ResultPrimitive>.HandleResult(ResultPrimitive.Fault).Retry();
+            string key = Guid.NewGuid().ToString();
+
+            _registry.Add(key, policy);
+            _registry.Get<ISyncPolicy<ResultPrimitive>>(key).Should().BeSameAs(policy);
+        }
+
         [Fact]
         public void Should_be_able_to_retrieve_stored_Policy_using_Indexer()
         {
@@ -124,32 +244,133 @@ public void Should_be_able_to_retrieve_stored_Policy_using_Indexer()
         }
 
         [Fact]
-        public void Should_not_throw_while_retrieving_when_key_does_not_exist_using_TryGetValue()
+        public void Should_be_able_to_retrieve_stored_PolicyTResult_using_Indexer()
+        {
+            Policy<ResultPrimitive> policy = Policy<ResultPrimitive>.HandleResult(ResultPrimitive.Fault).Retry();
+            string key = Guid.NewGuid().ToString();
+
+            _registry.Add(key, policy);
+            _registry[key].Should().BeSameAs(policy);
+        }
+
+        [Fact]
+        public void Should_be_able_to_retrieve_stored_Policy_by_interface_using_Indexer()
+        {
+            ISyncPolicy<ResultPrimitive> policy = Policy<ResultPrimitive>.HandleResult(ResultPrimitive.Fault).Retry();
+            string key = Guid.NewGuid().ToString();
+
+            _registry.Add(key, policy);
+            _registry[key].Should().BeSameAs(policy);
+        }
+
+        [Fact]
+        public void Should_not_throw_while_retrieving_when_key_does_not_exist_using_TryGet()
         {
             string key = Guid.NewGuid().ToString();
             Policy outPolicy = null;
             bool result = false;
 
-            _registry.Invoking(r => result = r.TryGetValue(key, out outPolicy))
+            _registry.Invoking(r => result = r.TryGet(key, out outPolicy))
+                .ShouldNotThrow();
+
+            result.Should().BeFalse();
+        }
+
+        [Fact]
+        public void Should_not_throw_while_retrieving_when_key_does_not_exist_using_TryGetPolicyTResult()
+        {
+            string key = Guid.NewGuid().ToString();
+            Policy<ResultPrimitive> outPolicy = null;
+            bool result = false;
+
+            _registry.Invoking(r => result = r.TryGet(key, out outPolicy))
                 .ShouldNotThrow();
 
             result.Should().BeFalse();
         }
 
         [Fact]
-        public void Should_throw_while_retrieving_using_indexer_when_key_does_not_exist()
+        public void Should_not_throw_while_retrieving_when_key_does_not_exist_using_TryGetPolicy_by_interface()
+        {
+            string key = Guid.NewGuid().ToString();
+            ISyncPolicy<ResultPrimitive> outPolicy = null;
+            bool result = false;
+
+            _registry.Invoking(r => result = r.TryGet<ISyncPolicy<ResultPrimitive>>(key, out outPolicy))
+                .ShouldNotThrow();
+
+            result.Should().BeFalse();
+        }
+
+        [Fact]
+        public void Should_throw_while_retrieving_using_Get_when_key_does_not_exist()
         {
             string key = Guid.NewGuid().ToString();
             Policy policy = null;
-            _registry.Invoking(r => policy = r[key])
+            _registry.Invoking(r => policy = r.Get<Policy>(key))
+                .ShouldThrow<KeyNotFoundException>();
+        }
+
+        [Fact]
+        public void Should_throw_while_retrieving_using_GetTResult_when_key_does_not_exist()
+        {
+            string key = Guid.NewGuid().ToString();
+            Policy<ResultPrimitive> policy = null;
+            _registry.Invoking(r => policy = r.Get<Policy<ResultPrimitive>>(key))
+                .ShouldThrow<KeyNotFoundException>();
+        }
+
+        [Fact]
+        public void Should_throw_while_retrieving_using_Get_by_interface_when_key_does_not_exist()
+        {
+            string key = Guid.NewGuid().ToString();
+            ISyncPolicy<ResultPrimitive> policy = null;
+            _registry.Invoking(r => policy = r.Get<ISyncPolicy<ResultPrimitive>>(key))
+                .ShouldThrow<KeyNotFoundException>();
+        }
+
+        [Fact]
+        public void Should_throw_while_retrieving_when_key_does_not_exist_using_Indexer()
+        {
+            string key = Guid.NewGuid().ToString();
+            IsPolicy outPolicy = null;
+            _registry.Invoking(r => outPolicy = r[key])
                 .ShouldThrow<KeyNotFoundException>();
         }
 
+
         [Fact]
-        public void Should_throw_when_retrieving_using_indexer_when_key_is_null()
+        public void Should_throw_when_retrieving_using_Get_when_key_is_null()
         {
             string key = null;
             Policy policy = null;
+            _registry.Invoking(r => policy = r.Get<Policy>(key))
+                .ShouldThrow<ArgumentNullException>();
+        }
+
+        [Fact]
+        public void Should_throw_when_retrieving_using_GetTResult_when_key_is_null()
+        {
+            string key = null;
+            Policy<ResultPrimitive> policy = null;
+            _registry.Invoking(r => policy = r.Get<Policy<ResultPrimitive>>(key))
+                .ShouldThrow<ArgumentNullException>();
+        }
+
+        [Fact]
+        public void Should_throw_when_retrieving_using_Get_by_interface_when_key_is_null()
+        {
+            string key = null;
+            ISyncPolicy<ResultPrimitive> policy = null;
+            _registry.Invoking(r => policy = r.Get<ISyncPolicy<ResultPrimitive>>(key))
+                .ShouldThrow<ArgumentNullException>();
+        }
+
+        [Fact]
+        public void Should_throw_when_retrieving_using_Indexer_when_key_is_null()
+        {
+            string key = null;
+            IsPolicy policy = null;
             _registry.Invoking(r => policy = r[key])
                 .ShouldThrow<ArgumentNullException>();
         }

From e52ef9645f83817d420b28b6050639b71225a323 Mon Sep 17 00:00:00 2001
From: reisenberger <software@reisenberger.net>
Date: Tue, 27 Jun 2017 22:19:10 +0100
Subject: [PATCH 6/6] Add v5.2.0 doco

---
 CHANGELOG.md                                  |   5 +
 GitVersionConfig.yaml                         |   2 +-
 README.md                                     | 207 ++++++++++++------
 build.cake                                    |   2 +-
 src/GlobalAssemblyInfo.cs                     |   2 +-
 src/Polly.Net40Async.nuspec                   |  10 +-
 .../Properties/AssemblyInfo.cs                |   2 +-
 src/Polly.nuspec                              |  14 +-
 8 files changed, 163 insertions(+), 81 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2d73a50c0e2..8c3cdb6fa00 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,8 @@
+## 5.2.0
+- Add PolicyRegistry for storing and retrieving policies.
+- Add interfaces by policy type and execution type.
+- Change .NetStandard minimum support to NetStandard1.1.
+     
 ## 5.1.0
 - Allow different parts of a policy execution to exchange data via a mutable Context travelling with each execution.
 
diff --git a/GitVersionConfig.yaml b/GitVersionConfig.yaml
index a812e4112ca..d4468eacb11 100644
--- a/GitVersionConfig.yaml
+++ b/GitVersionConfig.yaml
@@ -1 +1 @@
-next-version: 5.1.0
+next-version: 5.2.0
diff --git a/README.md b/README.md
index 79d5cff421e..95104248320 100644
--- a/README.md
+++ b/README.md
@@ -2,7 +2,7 @@
 
 Polly is a .NET resilience and transient-fault-handling library that allows developers to express policies such as Retry, Circuit Breaker, Timeout, Bulkhead Isolation, and Fallback in a fluent and thread-safe manner.  
 
-Polly targets .NET 4.0, .NET 4.5 and .NET Standard 1.0 ([coverage](https://github.com/dotnet/standard/blob/master/docs/versions.md): .NET Core, Mono, Xamarin.iOS, Xamarin.Android, UWP, WP8.0+).
+Polly targets .NET 4.0, .NET 4.5 and .NET Standard 1.1 ([coverage](https://github.com/dotnet/standard/blob/master/docs/versions.md): .NET Core, Mono, Xamarin.iOS, Xamarin.Android, UWP, WP8.1+).
 
 [<img align="right" src="https://dotnetfoundation.org/Themes/DotNetFoundation.Theme/Images/logo-small.png" width="100" />](https://www.dotnetfoundation.org/)
 We are now a member of the [.NET Foundation](https://www.dotnetfoundation.org/about)!
@@ -461,6 +461,8 @@ Policy
   .Execute(() => DoSomething());
 ```
 
+The above examples show policy definition immediately followed by policy execution, for simplicity.  Policy definition and execution may equally be separated - for example, define policies on start-up, then provide them to point-of-use by dependency injection (perhaps using [`PolicyRegistry`](#PolicyRegistry)).
+
 # Usage &ndash; general resilience policies
 
 The general resilience policies add resilience strategies that are not explicitly centred around handling faults which delegates may throw or return.
@@ -609,6 +611,74 @@ policyResult.Result - if executing a func, the result if the call succeeded or t
 */
 ```
 
+# Handing return values, and Policy&lt;TResult&gt;
+
+As described at step 1b, from Polly v4.3.0 onwards, policies can handle return values and exceptions in combination: 
+
+```csharp
+// Handle both exceptions and return values in one policy
+HttpStatusCode[] httpStatusCodesWorthRetrying = {
+   HttpStatusCode.RequestTimeout, // 408
+   HttpStatusCode.InternalServerError, // 500
+   HttpStatusCode.BadGateway, // 502
+   HttpStatusCode.ServiceUnavailable, // 503
+   HttpStatusCode.GatewayTimeout // 504
+}; 
+HttpResponseMessage result = Policy
+  .Handle<HttpResponseException>()
+  .OrResult<HttpResponseMessage>(r => httpStatusCodesWorthRetrying.Contains(r.StatusCode))
+  .Retry(...)
+  .Execute( /* some Func<HttpResponseMessage> */ )
+```
+
+The exceptions and return results to handle can be expressed fluently in any order.
+
+### Strongly-typed Policy&lt;TResult&gt;
+
+Configuring a policy with `.HandleResult<TResult>(...)` or `.OrResult<TResult>(...)` generates a strongly-typed `Policy<TResult>` of the specific policy type, eg `Retry<TResult>`, `AdvancedCircuitBreaker<TResult>`.
+
+These policies must be used to execute delegates returning `TResult`, ie:
+
+* `Execute(Func<TResult>)` (and related overloads)
+* `ExecuteAsync(Func<CancellationToken, Task<TResult>>)` (and related overloads)  
+
+### ExecuteAndCapture&lt;TResult&gt;()
+
+`.ExecuteAndCapture(...)` on non-generic policies returns a `PolicyResult` with properties:
+
+```          
+policyResult.Outcome - whether the call succeeded or failed         
+policyResult.FinalException - the final exception captured; will be null if the call succeeded
+policyResult.ExceptionType - was the final exception an exception the policy was defined to handle (like DivideByZeroException above) or an unhandled one (say Exception)? Will be null if the call succeeded.
+policyResult.Result - if executing a func, the result if the call succeeded; otherwise, the type's default value
+```
+
+`.ExecuteAndCapture<TResult>(Func<TResult>)` on strongly-typed policies adds two properties:
+
+```
+policyResult.FaultType - was the final fault handled an exception or a result handled by the policy? Will be null if the delegate execution succeeded. 
+policyResult.FinalHandledResult - the final fault result handled; will be null or the type's default value, if the call succeeded
+```
+
+### State-change delegates on Policy&lt;TResult&gt; policies
+
+In non-generic policies handling only exceptions, state-change delegates such as `onRetry` and `onBreak` take an `Exception` parameter.  
+
+In generic-policies handling `TResult` return values, state-change delegates are identical except they take a `DelegateResult<TResult>` parameter in place of `Exception.` `DelegateResult<TResult>` has two properties:
+
+* `Exception // The exception just thrown if policy is in process of handling an exception (otherwise null)`
+* `Result // The TResult just raised, if policy is in process of handling a result (otherwise default(TResult))`
+   
+
+### BrokenCircuitException&lt;TResult&gt;
+
+Non-generic CircuitBreaker policies throw a `BrokenCircuitException` when the circuit is broken.  This `BrokenCircuitException` contains the last exception (the one which caused the circuit to break) as the `InnerException`.
+
+For `CircuitBreakerPolicy<TResult>` policies: 
+
+* A circuit broken due to an exception throws a `BrokenCircuitException` with `InnerException` set to the exception which triggered the break (as previously).
+* A circuit broken due to handling a result throws a `BrokenCircuitException<TResult>` with the `Result` property set to the result which caused the circuit to break.
+
 # Policy Keys and Context data
 
 
@@ -648,6 +718,67 @@ var customerDetails = policy.Execute(() => GetCustomer(id),
 
 For more detail see: [Keys and Context Data](https://github.com/App-vNext/Polly/wiki/Keys-And-Context-Data) on wiki.
 
+# PolicyRegistry (v5.2+)
+
+```csharp
+// Create a policy registry (for example on application start-up) 
+PolicyRegistry registry = new PolicyRegistry();
+
+// Populate the registry with policies
+registry.Add("StandardHttpResilience", myStandardHttpResiliencePolicy);
+// Or:
+registry["StandardHttpResilience"] = myStandardHttpResiliencePolicy;
+
+// Pass the registry instance to usage sites by DI, perhaps
+public class MyServiceGateway 
+{
+    public void MyServiceGateway(..., IPolicyRegistry<string> registry, ...)
+    {
+       ...
+    } 
+}
+// (Or if you prefer ambient-context pattern, use a thread-safe singleton)
+
+// Use a policy from the registry
+registry.Get<IAsyncPolicy<HttpResponseMessage>>("StandardHttpResilience")
+    .ExecuteAsync<HttpResponseMessage>(...)
+```
+
+`PolicyRegistry` has a range of further dictionary-like semantics such as `.ContainsKey(...)`, `.TryGet<TPolicy>(...)`, `.Count`, `.Clear()`, and `Remove(...)`.
+
+For more detail see: [PolicyRegistry](https://github.com/App-vNext/Polly/wiki/PolicyRegistry) on wiki.
+
+# Interfaces (v5.2+)
+
+Polly v5.2.0 adds interfaces intended to support [`PolicyRegistry`](https://github.com/App-vNext/Polly/wiki/PolicyRegistry) and to group Policy functionality by the [interface segregation principle](https://en.wikipedia.org/wiki/Interface_segregation_principle).  Polly's interfaces are not intended for coding your own policy implementations against.
+
+## Execution interfaces: `ISyncPolicy` etc
+
+Execution interfaces [`ISyncPolicy`](https://github.com/reisenberger/Polly/blob/feature/interfacesplusregistry/src/Polly.Shared/ISyncPolicy.cs), [`IAsyncPolicy`](https://github.com/reisenberger/Polly/blob/feature/interfacesplusregistry/src/Polly.Shared/IAsyncPolicy.cs), [`ISyncPolicy<TResult>`](https://github.com/reisenberger/Polly/blob/feature/interfacesplusregistry/src/Polly.Shared/ISyncPolicyTResult.cs) and [`IAsyncPolicy<TResult>`](https://github.com/reisenberger/Polly/blob/feature/interfacesplusregistry/src/Polly.Shared/IAsyncPolicyTResult.cs)  define the execution overloads available to policies targeting sync/async, and non-generic / generic calls respectively.
+
+Blog posts outline why Polly has [both non-generic and generic policies](http://www.thepollyproject.org/2017/06/07/why-does-polly-offer-both-non-generic-and-generic-policies/) and [separate sync and async policies](http://www.thepollyproject.org/2017/06/09/polly-and-synchronous-versus-asynchronous-policies/).
+
+## Policy-kind interfaces: `ICircuitBreakerPolicy` etc
+
+Orthogonal to the execution interfaces, interfaces specific to the kind of Policy define properties and methods common to that type of policy.  
+
+For example, [`ICircuitBreakerPolicy`](https://github.com/reisenberger/Polly/blob/feature/interfacesplusregistry/src/Polly.Shared/CircuitBreaker/ICircuitBreakerPolicy.cs) defines 
+
+
++ `CircuitState CircuitState`
++ `Exception LastException`
++ `void Isolate()`
++ `void Reset()`
+
+with `ICircuitBreakerPolicy<TResult> : ICircuitBreakerPolicy` adding:
+
++ `TResult LastHandledResult`.
+
+This allows collections of similar kinds of policy to be treated as one - for example, for monitoring all your circuit-breakers as [described here](https://github.com/App-vNext/Polly/pull/205). 
+
+For more detail see: [Polly and interfaces](https://github.com/App-vNext/Polly/wiki/Polly-and-interfaces) on wiki.
+
+
 # Thread safety
 
 All Polly policies are fully thread-safe.  You can safely re-use policies at multiple call sites, and execute through policies concurrently on different threads. 
@@ -718,78 +849,10 @@ var response = await policy.ExecuteAsync(ct => httpClient.GetAsync(uri, ct), can
 
 From Polly v5.0, synchronous executions also support cancellation via `CancellationToken`.
 
-# .NET4.0 support ###
+# .NET4.0 support 
 
 The .NET4.0 package uses `Microsoft.Bcl.Async` to add async support.  To minimise  dependencies on the main Polly nuget package, the .NET4.0 version is available as separate Nuget packages `Polly.Net40Async` and `Polly.Net40Async-signed`.
 
-# Handing return values, and Policy&lt;TResult&gt;
-
-As described at step 1b, from Polly v4.3.0 onwards, policies can handle return values and exceptions in combination: 
-
-```csharp
-// Handle both exceptions and return values in one policy
-HttpStatusCode[] httpStatusCodesWorthRetrying = {
-   HttpStatusCode.RequestTimeout, // 408
-   HttpStatusCode.InternalServerError, // 500
-   HttpStatusCode.BadGateway, // 502
-   HttpStatusCode.ServiceUnavailable, // 503
-   HttpStatusCode.GatewayTimeout // 504
-}; 
-HttpResponseMessage result = Policy
-  .Handle<HttpResponseException>()
-  .OrResult<HttpResponseMessage>(r => httpStatusCodesWorthRetrying.Contains(r.StatusCode))
-  .Retry(...)
-  .Execute( /* some Func<HttpResponseMessage> */ )
-```
-
-The exceptions and return results to handle can be expressed fluently in any order.
-
-### Strongly-typed Policy&lt;TResult&gt;
-
-Configuring a policy with `.HandleResult<TResult>(...)` or `.OrResult<TResult>(...)` generates a strongly-typed `Policy<TResult>` of the specific policy type, eg `Retry<TResult>`, `AdvancedCircuitBreaker<TResult>`.
-
-These policies must be used to execute delegates returning `TResult`, ie:
-
-* `Execute(Func<TResult>)` (and related overloads)
-* `ExecuteAsync(Func<CancellationToken, Task<TResult>>)` (and related overloads)  
-
-### ExecuteAndCapture&lt;TResult&gt;()
-
-`.ExecuteAndCapture(...)` on non-generic policies returns a `PolicyResult` with properties:
-
-```          
-policyResult.Outcome - whether the call succeeded or failed         
-policyResult.FinalException - the final exception captured; will be null if the call succeeded
-policyResult.ExceptionType - was the final exception an exception the policy was defined to handle (like DivideByZeroException above) or an unhandled one (say Exception)? Will be null if the call succeeded.
-policyResult.Result - if executing a func, the result if the call succeeded; otherwise, the type's default value
-```
-
-`.ExecuteAndCapture<TResult>(Func<TResult>)` on strongly-typed policies adds two properties:
-
-```
-policyResult.FaultType - was the final fault handled an exception or a result handled by the policy? Will be null if the delegate execution succeeded. 
-policyResult.FinalHandledResult - the final fault result handled; will be null or the type's default value, if the call succeeded
-```
-
-### State-change delegates on Policy&lt;TResult&gt; policies
-
-In non-generic policies handling only exceptions, state-change delegates such as `onRetry` and `onBreak` take an `Exception` parameter.  
-
-In generic-policies handling `TResult` return values, state-change delegates are identical except they take a `DelegateResult<TResult>` parameter in place of `Exception.` `DelegateResult<TResult>` has two properties:
-
-* `Exception // The exception just thrown if policy is in process of handling an exception (otherwise null)`
-* `Result // The TResult just raised, if policy is in process of handling a result (otherwise default(TResult))`
-   
-
-### BrokenCircuitException&lt;TResult&gt;
-
-Non-generic CircuitBreaker policies throw a `BrokenCircuitException` when the circuit is broken.  This `BrokenCircuitException` contains the last exception (the one which caused the circuit to break) as the `InnerException`.
-
-For `CircuitBreakerPolicy<TResult>` policies: 
-
-* A circuit broken due to an exception throws a `BrokenCircuitException` with `InnerException` set to the exception which triggered the break (as previously).
-* A circuit broken due to handling a result throws a `BrokenCircuitException<TResult>` with the `Result` property set to the result which caused the circuit to break.
-
 # Release notes
 
 For details of changes by release see the [change log](https://github.com/App-vNext/Polly/blob/master/CHANGELOG.md).  We also tag relevant Pull Requests and Issues with [milestones](https://github.com/App-vNext/Polly/milestones), which match to nuget package release numbers.
@@ -799,7 +862,7 @@ For details of changes by release see the [change log](https://github.com/App-vN
 * [Fluent Assertions](https://github.com/fluentassertions/fluentassertions) - A set of .NET extension methods that allow you to more naturally specify the expected outcome of a TDD or BDD-style test | [Apache License 2.0 (Apache)](https://github.com/dennisdoomen/fluentassertions/blob/develop/LICENSE)
 * [xUnit.net](https://github.com/xunit/xunit) - Free, open source, community-focused unit testing tool for the .NET Framework | [Apache License 2.0 (Apache)](https://github.com/xunit/xunit/blob/master/license.txt)
 * [Ian Griffith's TimedLock](http://www.interact-sw.co.uk/iangblog/2004/04/26/yetmoretimedlocking)
-* [Steven van Deursen's ReadOnlyDictionary](http://www.cuttingedge.it/blogs/steven/pivot/entry.php?id=29)
+* [Steven van Deursen's ReadOnlyDictionary](http://www.cuttingedge.it/blogs/steven/pivot/entry.php?id=29) (until v5.0.6)
 * [Stephen Cleary's AsyncEx library](https://github.com/StephenCleary/AsyncEx) for AsyncSemaphore (supports BulkheadAsync policy for .NET4.0 only) | [MIT license](https://github.com/StephenCleary/AsyncEx/blob/master/LICENSE)
 * Build powered by [Cake](http://cakebuild.net/) and [GitVersionTask](https://github.com/GitTools/GitVersion).
 
@@ -838,6 +901,8 @@ For details of changes by release see the [change log](https://github.com/App-vN
 * [@lakario](https://github.com/lakario) - Add NoOpPolicy.
 * [@Julien-Mialon](https://github.com/Julien-Mialon) - Fixes, support and examples for .NETStandard compatibility with Xamarin PCL projects
 * [@reisenberger](https://github.com/reisenberger) - Add mutable Context and extra overloads taking Context.  Allows different parts of a policy execution to exchange data via the mutable Context travelling with each execution.
+* [@ankitbko](https://github.com/ankitbko) - Add PolicyRegistry for storing and retrieving policies.
+* [@reisenberger](https://github.com/reisenberger) - Add interfaces by policy type and execution type.
 
 # Sample Projects
 
diff --git a/build.cake b/build.cake
index a7286210bd7..e550164e003 100644
--- a/build.cake
+++ b/build.cake
@@ -141,7 +141,7 @@ Task("__UpdateDotNetStandardAssemblyVersionNumber")
     // NOTE: TEMPORARY fix only, while GitVersionTask does not support .Net Standard assemblies.  See https://github.com/App-vNext/Polly/issues/176.  
     // This build Task can be removed when GitVersionTask supports .Net Standard assemblies.
     var assemblySemVer = gitVersionOutput["AssemblySemVer"].ToString();
-    Information("Updating NetStandard11 AssemblyVersion to {0}", assemblySemVer);
+    Information("Updating NetStandard1.1 AssemblyVersion to {0}", assemblySemVer);
     var replacedFiles = ReplaceRegexInFiles("./src/Polly.NetStandard11/Properties/AssemblyInfo.cs", "AssemblyVersion[(]\".*\"[)]", "AssemblyVersion(\"" + assemblySemVer +"\")");
     if (!replacedFiles.Any())
     {
diff --git a/src/GlobalAssemblyInfo.cs b/src/GlobalAssemblyInfo.cs
index c528a5d6af1..ffbd5997d32 100644
--- a/src/GlobalAssemblyInfo.cs
+++ b/src/GlobalAssemblyInfo.cs
@@ -3,7 +3,7 @@
 [assembly: AssemblyProduct("Polly")]
 [assembly: AssemblyCompany("App vNext")]
 [assembly: AssemblyDescription("Polly is a library that allows developers to express resilience and transient fault handling policies such as Retry, Circuit Breaker, Timeout, Bulkhead Isolation, and Fallback in a fluent and thread-safe manner.")]
-[assembly: AssemblyCopyright("Copyright (c) 2016, App vNext")]
+[assembly: AssemblyCopyright("Copyright (c) 2017, App vNext")]
 
 #if DEBUG
 [assembly: AssemblyConfiguration("Debug")]
diff --git a/src/Polly.Net40Async.nuspec b/src/Polly.Net40Async.nuspec
index ed34821fe14..17fa7c3dd16 100644
--- a/src/Polly.Net40Async.nuspec
+++ b/src/Polly.Net40Async.nuspec
@@ -11,9 +11,15 @@
     <iconUrl>https://raw.github.com/App-vNext/Polly/master/Polly.png</iconUrl>
     <projectUrl>https://github.com/App-vNext/Polly</projectUrl>
     <tags>Exception Handling Resilience Transient Fault Policy Circuit Breaker CircuitBreaker Retry Wait Bulkhead Fallback Timeout Throttle Parallelization</tags>
-    <copyright>Copyright © 2016, App vNext</copyright>
+    <copyright>Copyright © 2017, App vNext</copyright>
     <releaseNotes>
-     v5.0 is a major release with significant new resilience policies: Timeout; Bulkhead Isolation; Fallback; and PolicyWrap.  See release notes back to v5.0.0 for full details.
+     v5.0 is a major release with significant new resilience policies: Timeout; Bulkhead Isolation; Fallback; and PolicyWrap.  See release notes back to v5.0.0 for full details.  v5.0.5 includes important circuit-breaker fixes.
+
+     5.2.0
+     ---------------------
+     - Add PolicyRegistry for storing and retrieving policies.
+     - Add interfaces by policy type and execution type.
+     - Change .NetStandard minimum support to NetStandard1.1.
 
      5.1.0
      ---------------------
diff --git a/src/Polly.NetStandard11/Properties/AssemblyInfo.cs b/src/Polly.NetStandard11/Properties/AssemblyInfo.cs
index 56094347a87..99ae7ecc0bc 100644
--- a/src/Polly.NetStandard11/Properties/AssemblyInfo.cs
+++ b/src/Polly.NetStandard11/Properties/AssemblyInfo.cs
@@ -3,7 +3,7 @@
 using System.Runtime.CompilerServices;
 
 [assembly: AssemblyTitle("Polly")]
-[assembly: AssemblyVersion("5.1.0.0")]
+[assembly: AssemblyVersion("5.2.0.0")]
 [assembly: CLSCompliant(true)]
 
 [assembly: InternalsVisibleTo("Polly.Pcl.Specs")]
\ No newline at end of file
diff --git a/src/Polly.nuspec b/src/Polly.nuspec
index 9056c22dfca..bca6a2390c5 100644
--- a/src/Polly.nuspec
+++ b/src/Polly.nuspec
@@ -4,16 +4,22 @@
     <owners>App vNext</owners>
     <authors>Michael Wolfenden, App vNext</authors>
     <description>
-      Polly is a .NET 4.5 / .NET Standard 1.0 library that allows developers to express resilience and transient fault handling policies such as Retry, Circuit Breaker, Timeout, Bulkhead Isolation and Fallback in a fluent and thread-safe manner.
+      Polly is a .NET 4.5 / .NET Standard 1.1 library that allows developers to express resilience and transient fault handling policies such as Retry, Circuit Breaker, Timeout, Bulkhead Isolation and Fallback in a fluent and thread-safe manner.
     </description>
     <language>en-US</language>
     <licenseUrl>https://raw.github.com/App-vNext/Polly/master/LICENSE.txt</licenseUrl>
     <iconUrl>https://raw.github.com/App-vNext/Polly/master/Polly.png</iconUrl>
     <projectUrl>https://github.com/App-vNext/Polly</projectUrl>
     <tags>Exception Handling Resilience Transient Fault Policy Circuit Breaker CircuitBreaker Retry Wait Bulkhead Fallback Timeout Throttle Parallelization</tags>
-    <copyright>Copyright © 2016, App vNext</copyright>
+    <copyright>Copyright © 2017, App vNext</copyright>
     <releaseNotes>
-     v5.0 is a major release with significant new resilience policies: Timeout; Bulkhead Isolation; Fallback; and PolicyWrap.  See release notes back to v5.0.0 for full details. 
+     v5.0 is a major release with significant new resilience policies: Timeout; Bulkhead Isolation; Fallback; and PolicyWrap.  See release notes back to v5.0.0 for full details.  v5.0.5 includes important circuit-breaker fixes.
+
+     5.2.0
+     ---------------------
+     - Add PolicyRegistry for storing and retrieving policies.
+     - Add interfaces by policy type and execution type.
+     - Change .NetStandard minimum support to NetStandard1.1.
 
      5.1.0
      ---------------------
@@ -167,7 +173,7 @@
    </releaseNotes>
     <dependencies>
       <group targetFramework="net45"/>
-      <group targetFramework="netstandard1.0">
+      <group targetFramework="netstandard1.1">
         <dependency id="NETStandard.Library" version="1.6.1" />
       </group>
     </dependencies>