diff --git a/Src/LiquidProjections/EventMapBuilder.cs b/Src/LiquidProjections/EventMapBuilder.cs
index 7fcaa75..2eb4302 100644
--- a/Src/LiquidProjections/EventMapBuilder.cs
+++ b/Src/LiquidProjections/EventMapBuilder.cs
@@ -179,7 +179,7 @@ public IEventMap<TContext> Build(ProjectorMap<TProjection, TKey, TContext> proje
         private sealed class CrudAction<TEvent> : ICrudAction<TEvent, TProjection, TKey, TContext>
         {
             private readonly IAction<TEvent, TContext> actionBuilder;
-            private readonly Func<ProjectorMap<TProjection, TKey, TContext> > getProjector;
+            private readonly Func<ProjectorMap<TProjection, TKey, TContext>> getProjector;
 
             public CrudAction(EventMapBuilder<TProjection, TKey, TContext> parent)
             {
@@ -187,6 +187,16 @@ public CrudAction(EventMapBuilder<TProjection, TKey, TContext> parent)
                 getProjector = () => parent.projector;
             }
 
+            public ICreateAction<TEvent, TProjection, TContext> AsCreateOf(Func<TEvent, TContext, TKey> getKey)
+            {
+                if (getKey == null)
+                {
+                    throw new ArgumentNullException(nameof(getKey));
+                }
+
+                return new CreateAction(actionBuilder, getProjector, getKey);
+            }
+
             public ICreateAction<TEvent, TProjection, TContext> AsCreateOf(Func<TEvent, TKey> getKey)
             {
                 if (getKey == null)
@@ -218,6 +228,16 @@ public IDeleteAction<TEvent, TKey, TContext> AsDeleteOf(Func<TEvent, TKey> getKe
                 return new DeleteAction(actionBuilder, getProjector, getKey);
             }
 
+            public IDeleteAction<TEvent, TKey, TContext> AsDeleteOf(Func<TEvent, TContext, TKey> getKey)
+            {
+                if (getKey == null)
+                {
+                    throw new ArgumentNullException(nameof(getKey));
+                }
+
+                return new DeleteAction(actionBuilder, getProjector, getKey);
+            }
+
             public IDeleteAction<TEvent, TKey, TContext> AsDeleteIfExistsOf(Func<TEvent, TKey> getKey)
             {
                 return AsDeleteOf(getKey).IgnoringMisses();
@@ -230,6 +250,16 @@ public IUpdateAction<TEvent, TKey, TProjection, TContext> AsUpdateOf(Func<TEvent
                     throw new ArgumentNullException(nameof(getKey));
                 }
 
+                return new UpdateAction(actionBuilder, getProjector, (anEvent, context) => getKey(anEvent));
+            }
+
+            public IUpdateAction<TEvent, TKey, TProjection, TContext> AsUpdateOf(Func<TEvent, TContext, TKey> getKey)
+            {
+                if (getKey == null)
+                {
+                    throw new ArgumentNullException(nameof(getKey));
+                }
+
                 return new UpdateAction(actionBuilder, getProjector, getKey);
             }
 
@@ -267,15 +297,27 @@ private sealed class CreateAction : ICreateAction<TEvent, TProjection, TContext>
 
                 private readonly IAction<TEvent, TContext> actionBuilder;
                 private readonly Func<ProjectorMap<TProjection, TKey, TContext>> projector;
-                private readonly Func<TEvent, TKey> getKey;
+                private readonly Func<TEvent, TContext, TKey> getKey;
 
                 public CreateAction(IAction<TEvent, TContext> actionBuilder,
-                    Func<ProjectorMap<TProjection, TKey, TContext>> projector, Func<TEvent, TKey> getKey)
+                    Func<ProjectorMap<TProjection, TKey, TContext>> projector, Func<TEvent, TContext, TKey> getKey)
                 {
                     this.actionBuilder = actionBuilder;
                     this.projector = projector;
                     this.getKey = getKey;
 
+                    shouldOverwrite = (existingProjection, @event, context) =>
+                        throw new ProjectionException(
+                            $"Projection {typeof(TProjection)} with key {getKey(@event,context)}already exists.");
+                }
+
+                public CreateAction(IAction<TEvent, TContext> actionBuilder,
+                    Func<ProjectorMap<TProjection, TKey, TContext>> projector, Func<TEvent, TKey> getKey)
+                {
+                    this.actionBuilder = actionBuilder;
+                    this.projector = projector;
+                    this.getKey = (@event, context) =>getKey(@event);
+
                     shouldOverwrite = (existingProjection, @event, context) =>
                         throw new ProjectionException(
                             $"Projection {typeof(TProjection)} with key {getKey(@event)}already exists.");
@@ -289,7 +331,7 @@ public ICreateAction<TEvent, TProjection, TContext> Using(Func<TProjection, TEve
                     }
 
                     actionBuilder.As((anEvent, context) => this.projector().Create(
-                            getKey(anEvent),
+                            getKey(anEvent,context),
                             context,
                             projection => projector(projection, anEvent, context),
                             existingProjection => shouldOverwrite(existingProjection, anEvent, context)));
@@ -320,11 +362,11 @@ private sealed class UpdateAction : IUpdateAction<TEvent, TKey, TProjection, TCo
             {
                 private readonly IAction<TEvent, TContext> actionBuilder;
                 private readonly Func<ProjectorMap<TProjection, TKey, TContext>> projector;
-                private readonly Func<TEvent, TKey> getKey;
+                private readonly Func<TEvent, TContext, TKey> getKey;
                 private Func<TKey, TContext, bool> handleMissesUsing;
 
                 public UpdateAction(IAction<TEvent, TContext> actionBuilder,
-                    Func<ProjectorMap<TProjection, TKey, TContext>> projector, Func<TEvent, TKey> getKey)
+                    Func<ProjectorMap<TProjection, TKey, TContext>> projector, Func<TEvent, TContext, TKey> getKey)
                 {
                     this.projector = projector;
                     this.actionBuilder = actionBuilder;
@@ -347,7 +389,7 @@ public IUpdateAction<TEvent, TKey, TProjection, TContext> Using(Func<TProjection
 
                 private async Task OnUpdate(Func<TProjection, TEvent, TContext, Task> projector, TEvent anEvent, TContext context)
                 {
-                    var key = getKey(anEvent);
+                    var key = getKey(anEvent,context);
                     
                     await this.projector().Update(
                         key,
@@ -386,16 +428,24 @@ private class DeleteAction : IDeleteAction<TEvent, TKey, TContext>
                 private Action<TKey, TContext> handleMissing;
 
                 public DeleteAction(IAction<TEvent, TContext> actionBuilder,
-                    Func<ProjectorMap<TProjection, TKey, TContext>> projector, Func<TEvent, TKey> getKey)
+                    Func<ProjectorMap<TProjection, TKey, TContext>> projector, Func<TEvent, TContext, TKey> getKey)
                 {
                     actionBuilder.As((anEvent, context) => OnDelete(projector(), getKey, anEvent, context));
 
                     ThrowingIfMissing();
                 }
 
-                private async Task OnDelete(ProjectorMap<TProjection, TKey, TContext> projector, Func<TEvent, TKey> getKey, TEvent anEvent, TContext context)
+                public DeleteAction(IAction<TEvent, TContext> actionBuilder,
+                    Func<ProjectorMap<TProjection, TKey, TContext>> projector, Func<TEvent, TKey> getKey)
+                {
+                    actionBuilder.As((anEvent, context) => OnDelete(projector(), (anEvent1, context1) => getKey(anEvent1), anEvent, context));
+
+                    ThrowingIfMissing();
+                }
+
+                private async Task OnDelete(ProjectorMap<TProjection, TKey, TContext> projector, Func<TEvent, TContext, TKey> getKey, TEvent anEvent, TContext context)
                 {
-                    TKey key = getKey(anEvent);
+                    TKey key = getKey(anEvent, context);
                     bool deleted = await projector.Delete(key, context);
                     if (!deleted)
                     {
diff --git a/Src/LiquidProjections/MapBuilding/IAction.cs b/Src/LiquidProjections/MapBuilding/IAction.cs
index 49260d3..a1923d9 100644
--- a/Src/LiquidProjections/MapBuilding/IAction.cs
+++ b/Src/LiquidProjections/MapBuilding/IAction.cs
@@ -52,6 +52,17 @@ public interface ICrudAction<TEvent, TProjection, TKey, TContext> : IAction<TEve
         /// </returns>
         ICreateAction<TEvent, TProjection, TContext> AsCreateOf(Func<TEvent, TKey> getKey);
 
+        /// <summary>
+        /// Continues configuring a handler for events of type <typeparamref name="TEvent"/>.
+        /// Specifies that a new projection with the specified key will be created for the event handler.
+        /// An exception will be thrown if a projection with such key already exists.
+        /// </summary>
+        /// <param name="getKey">The delegate that determines the projection key for the event.</param>
+        /// <returns>
+        /// <see cref="ICreateAction{TEvent,TProjection,TContext}"/> that allows to continue configuring the handler.
+        /// </returns>
+        ICreateAction<TEvent, TProjection, TContext> AsCreateOf(Func<TEvent, TContext, TKey> getKey);
+
         /// <summary>
         /// Continues configuring a handler for events of type <typeparamref name="TEvent"/>.
         /// Specifies that a new projection with the specified key will be created for the event handler.
@@ -76,6 +87,17 @@ public interface ICrudAction<TEvent, TProjection, TKey, TContext> : IAction<TEve
         /// </returns>
         IUpdateAction<TEvent, TKey, TProjection, TContext> AsUpdateOf(Func<TEvent, TKey> getKey);
 
+        /// <summary>
+        /// Continues configuring a handler for events of type <typeparamref name="TEvent"/>.
+        /// Specifies that the projection with the specified key will be updated by the event handler.
+        /// An exception will be thrown if a projection with such key does not exist.
+        /// </summary>
+        /// <param name="getKey">The delegate that determines the projection key for the event.</param>
+        /// <returns>
+        /// <see cref="IUpdateAction{TEvent,TKey, TProjection,TContext}"/> that allows to continue configuring the handler.
+        /// </returns>
+        IUpdateAction<TEvent, TKey, TProjection, TContext> AsUpdateOf(Func<TEvent, TContext, TKey> getKey);
+
         /// <summary>
         /// Continues configuring a handler for events of type <typeparamref name="TEvent"/>.
         /// Specifies that the projection with the specified key will be updated by the event handler.
@@ -99,7 +121,7 @@ public interface ICrudAction<TEvent, TProjection, TKey, TContext> : IAction<TEve
         /// that allows to continue configuring the handler.
         /// </returns>
         [Obsolete("Use AsCreateOf().OverwritingDuplicates() instead")]
-        ICreateAction<TEvent, TProjection, TContext>  AsCreateOrUpdateOf(Func<TEvent, TKey> getKey);
+        ICreateAction<TEvent, TProjection, TContext> AsCreateOrUpdateOf(Func<TEvent, TKey> getKey);
 
         /// <summary>
         /// Finishes configuring a handler for events of type <typeparamref name="TEvent"/>.
@@ -109,6 +131,14 @@ public interface ICrudAction<TEvent, TProjection, TKey, TContext> : IAction<TEve
         /// <param name="getKey">The delegate that determines the projection key for the event.</param>
         IDeleteAction<TEvent, TKey, TContext> AsDeleteOf(Func<TEvent, TKey> getKey);
 
+        /// <summary>
+        /// Finishes configuring a handler for events of type <typeparamref name="TEvent"/>.
+        /// Specifies that the projection with the specified key will be deleted when handling the event.
+        /// An exception will be thrown if a projection with such key does not exist.
+        /// </summary>
+        /// <param name="getKey">The delegate that determines the projection key for the event.</param>
+        IDeleteAction<TEvent, TKey, TContext> AsDeleteOf(Func<TEvent, TContext, TKey> getKey);
+
         /// <summary>
         /// Finishes configuring a handler for events of type <typeparamref name="TEvent"/>.
         /// Specifies that the projection with the specified key will be deleted when handling the event.
diff --git a/Tests/LiquidProjections.Specs/EventMapSpecs.cs b/Tests/LiquidProjections.Specs/EventMapSpecs.cs
index 8f636d5..e9b3782 100644
--- a/Tests/LiquidProjections.Specs/EventMapSpecs.cs
+++ b/Tests/LiquidProjections.Specs/EventMapSpecs.cs
@@ -44,10 +44,10 @@ public When_event_should_create_a_new_projection()
                 When(async () =>
                 {
                     await map.Handle(new ProductAddedToCatalogEvent
-                        {
-                            Category = "Hybrids",
-                            ProductKey = "c350E"
-                        },
+                    {
+                        Category = "Hybrids",
+                        ProductKey = "c350E"
+                    },
                         new ProjectionContext());
                 });
             }
@@ -64,6 +64,59 @@ public void It_should_properly_pass_the_mapping_to_the_creating_handler()
             }
         }
 
+        public class When_event_should_create_a_new_projection_from_context : GivenWhenThen
+        {
+            private ProductCatalogEntry projection;
+            private IEventMap<ProjectionContext> map;
+
+            public When_event_should_create_a_new_projection_from_context()
+            {
+                Given(() =>
+                {
+                    var mapBuilder = new EventMapBuilder<ProductCatalogEntry, string, ProjectionContext>();
+                    mapBuilder.Map<ProductAddedToCatalogEvent>().AsCreateOf((e, context) => context.EventHeaders["ProductId"] as string).Using((p, e, ctx) =>
+                     {
+                         p.Category = e.Category;
+
+                         return Task.FromResult(0);
+                     });
+
+                    map = mapBuilder.Build(new ProjectorMap<ProductCatalogEntry, string, ProjectionContext>
+                    {
+                        Create = async (key, context, projector, shouldOverwrite) =>
+                        {
+                            projection = new ProductCatalogEntry
+                            {
+                                Id = key,
+                            };
+
+                            await projector(projection);
+                        }
+                    });
+                });
+
+                When(async () =>
+                {
+                    await map.Handle(new ProductAddedToCatalogEvent
+                    {
+                        Category = "Hybrids"
+                    },
+                        new ProjectionContext() { EventHeaders = new Dictionary<string, object>(1) { { "ProductId", "1234" } } });
+                });
+            }
+
+            [Fact]
+            public void It_should_properly_pass_the_mapping_to_the_creating_handler()
+            {
+                projection.Should().BeEquivalentTo(new
+                {
+                    Id = "1234",
+                    Category = "Hybrids",
+                    Deleted = false
+                });
+            }
+        }
+
         public class When_a_creating_event_must_ignore_an_existing_projection : GivenWhenThen
         {
             private ProductCatalogEntry existingProjection;
@@ -84,7 +137,7 @@ public When_a_creating_event_must_ignore_an_existing_projection()
                             p.Category = e.Category;
                             return Task.FromResult(0);
                         });
-                    
+
                     existingProjection = new ProductCatalogEntry
                     {
                         Id = "c350E",
@@ -235,10 +288,10 @@ public When_a_creating_event_should_allow_manual_handling_of_duplicates()
                 When(async () =>
                 {
                     await map.Handle(new ProductAddedToCatalogEvent
-                        {
-                            Category = "NewCategory",
-                            ProductKey = "c350E"
-                        },
+                    {
+                        Category = "NewCategory",
+                        ProductKey = "c350E"
+                    },
                         new ProjectionContext());
                 });
             }
@@ -314,7 +367,7 @@ public void It_should_throw_without_affecting_the_projection()
 
                 existingProjection.Category.Should().Be("OldCategory");
             }
-    }
+        }
 
         public class When_an_updating_event_should_ignore_missing_projections : GivenWhenThen
         {
@@ -360,6 +413,7 @@ public void It_should_not_throw()
                 WhenAction.Should().NotThrow();
             }
         }
+
         public class When_an_updating_event_should_create_a_missing_projection : GivenWhenThen
         {
             private IEventMap<ProjectionContext> map;
@@ -386,7 +440,7 @@ public When_an_updating_event_should_create_a_missing_projection()
                         Update = (key, context, projector, createIfMissing) =>
                         {
                             shouldCreate = true;
-                            
+
                             return Task.FromResult(0);
                         }
                     });
@@ -411,6 +465,57 @@ public void It_should_not_throw()
             }
         }
 
+        public class When_an_updating_event_should_create_a_missing_projection_from_context : GivenWhenThen
+        {
+            private IEventMap<ProjectionContext> map;
+            private bool shouldCreate;
+
+            public When_an_updating_event_should_create_a_missing_projection_from_context()
+            {
+                Given(() =>
+                {
+                    var mapBuilder = new EventMapBuilder<ProductCatalogEntry, string, ProjectionContext>();
+
+                    mapBuilder
+                        .Map<ProductAddedToCatalogEvent>()
+                        .AsUpdateOf((e, context) => context.EventHeaders["ProductId"] as string)
+                        .CreatingIfMissing()
+                        .Using((p, e, ctx) =>
+                        {
+                            p.Category = e.Category;
+                            return Task.FromResult(0);
+                        });
+
+                    map = mapBuilder.Build(new ProjectorMap<ProductCatalogEntry, string, ProjectionContext>
+                    {
+                        Update = (key, context, projector, createIfMissing) =>
+                        {
+                            shouldCreate = true;
+
+                            return Task.FromResult(0);
+                        }
+                    });
+                });
+
+                When(async () =>
+                {
+                    await map.Handle(
+                        new ProductAddedToCatalogEvent
+                        {
+                            Category = "Hybrids",
+                            ProductKey = "c350E"
+                        },
+                        new ProjectionContext() { EventHeaders = new Dictionary<string, object>(1) { { "ProductId", "1234" } } });
+                });
+            }
+
+            [Fact]
+            public void It_should_not_throw()
+            {
+                shouldCreate.Should().BeTrue("because that's how the map was configured");
+            }
+        }
+
         public class When_an_updating_event_should_handle_misses_manually : GivenWhenThen
         {
             private IEventMap<ProjectionContext> map;
@@ -486,7 +591,7 @@ public When_an_event_is_mapped_as_a_delete()
                         {
                             isDeleted = true;
                             return Task.FromResult(true);
-                        } 
+                        }
                     });
                 });
 
@@ -524,7 +629,7 @@ public When_deleting_a_non_existing_event_should_be_ignored()
 
                     map = mapBuilder.Build(new ProjectorMap<ProductCatalogEntry, string, ProjectionContext>
                     {
-                       Delete = (key, context) => Task.FromResult(false) 
+                        Delete = (key, context) => Task.FromResult(false)
                     });
                 });
 
@@ -566,7 +671,7 @@ public When_deleting_a_non_existing_event_should_be_handled_manually()
 
                     map = mapBuilder.Build(new ProjectorMap<ProductCatalogEntry, string, ProjectionContext>
                     {
-                       Delete = (key, context) => Task.FromResult(false) 
+                        Delete = (key, context) => Task.FromResult(false)
                     });
                 });
 
@@ -588,6 +693,48 @@ public void It_should_not_throw()
             }
         }
 
+        public class When_deleting_a_non_existing_event_should_be_handled_manually_from_context : GivenWhenThen
+        {
+            private IEventMap<ProjectionContext> map;
+            private object missedKey;
+
+            public When_deleting_a_non_existing_event_should_be_handled_manually_from_context()
+            {
+                Given(() =>
+                {
+                    var mapBuilder = new EventMapBuilder<ProductCatalogEntry, string, ProjectionContext>();
+                    mapBuilder
+                        .Map<ProductDiscontinuedEvent>()
+                        .AsDeleteOf((e, context) => context.EventHeaders["ProductId"] as string)
+                        .HandlingMissesUsing((key, context) =>
+                        {
+                            missedKey = key;
+                        });
+
+                    map = mapBuilder.Build(new ProjectorMap<ProductCatalogEntry, string, ProjectionContext>
+                    {
+                        Delete = (key, context) => Task.FromResult(false)
+                    });
+                });
+
+                WhenLater(async () =>
+                {
+                    await map.Handle(
+                        new ProductDiscontinuedEvent
+                        {
+                            ProductKey = "c350E"
+                        },
+                        new ProjectionContext() { EventHeaders = new Dictionary<string, object>(1) { { "ProductId", "1234" } } });
+                });
+            }
+
+            [Fact]
+            public void It_should_not_throw()
+            {
+                WhenAction.Should().NotThrow();
+            }
+        }
+
         public class When_an_event_is_mapped_as_a_custom_action : GivenWhenThen
         {
             private IEventMap<object> map;
@@ -648,7 +795,7 @@ public When_a_global_filter_is_not_met()
 
                             return Task.FromResult(true);
                         });
-                    
+
                     mapBuilder
                         .Map<ProductAddedToCatalogEvent>()
                         .As((e, ctx) =>
@@ -660,7 +807,7 @@ public When_a_global_filter_is_not_met()
 
                     map = mapBuilder.Build(new ProjectorMap<object>
                     {
-                        Custom = (context, projector) => projector() 
+                        Custom = (context, projector) => projector()
                     });
                 });
 
@@ -705,7 +852,7 @@ public When_a_condition_is_not_met()
 
                     map = mapBuilder.Build(new ProjectorMap<object>
                     {
-                        Custom = (context, projector) => projector() 
+                        Custom = (context, projector) => projector()
                     });
                 });
 
@@ -793,7 +940,7 @@ public When_multiple_conditions_are_registered()
 
                         var map = mapBuilder.Build(new ProjectorMap<object>
                         {
-                            Custom = (context, projector) =>throw new InvalidOperationException("Custom action should not be called.") 
+                            Custom = (context, projector) => throw new InvalidOperationException("Custom action should not be called.")
                         });
                     };
                 });
@@ -1073,7 +1220,7 @@ public class When_an_event_is_mapped_by_a_base_class_and_an_event_of_child_type_
             private IEventMap<ProjectionContext> map;
 
             private ProductCatalogEntry projection;
-            
+
             public When_an_event_is_mapped_by_a_base_class_and_an_event_of_child_type_is_handled()
             {
                 Given(() =>
@@ -1102,7 +1249,7 @@ public When_an_event_is_mapped_by_a_base_class_and_an_event_of_child_type_is_han
                         }
                     });
                 });
-                
+
                 When(async () =>
                 {
                     await map.Handle(
@@ -1121,7 +1268,7 @@ public void It_should_invoke_the_handler_configured_on_the_base_class()
                 projection.Category.Should().Be("All Products");
             }
         }
-        
+
         public class When_mappings_for_the_base_and_concrete_event_types_are_both_configured : GivenWhenThen
         {
             private IEventMap<ProjectionContext> map;
@@ -1129,7 +1276,7 @@ public class When_mappings_for_the_base_and_concrete_event_types_are_both_config
             private ProductCatalogEntry projection;
 
             private Type lastHandlerInvoked;
-            
+
             public When_mappings_for_the_base_and_concrete_event_types_are_both_configured()
             {
                 Given(() =>
@@ -1147,7 +1294,7 @@ public When_mappings_for_the_base_and_concrete_event_types_are_both_configured()
                             lastHandlerInvoked = typeof(ProductEvent);
                             return Task.FromResult(0);
                         });
-                    
+
                     mapBuilder
                         .Map<ProductPriceChangedEvent>()
                         .AsUpdateOf(e => e.ProductKey)
@@ -1177,7 +1324,7 @@ public When_mappings_for_the_base_and_concrete_event_types_are_both_configured()
                         }
                     });
                 });
-                
+
                 When(async () =>
                 {
                     await map.Handle(