Index: 1/Chernobyl.Audio.Console/Program.cs
===================================================================
--- 1/Chernobyl.Audio.Console/Program.cs	(revision 300)
+++ 1/Chernobyl.Audio.Console/Program.cs	(working copy)
@@ -34,13 +34,13 @@
 
             var instances = Config.Dependency.Module.GetServices();
 
-            Action<MethodInfo, Callback<KeyValuePair<Object, Observable<Object>>>> createReturnValueObservable = (methodInfo, callback)=>
+            Action<MethodInfo, Callback<KeyValuePair<Object, Subscribe<Object>>>> createReturnValueObservable = (methodInfo, callback)=>
             {
                 // The subscription for the parameters of the method.
                 Callback<IEnumerable<Object>> parametersSubscription = parameters =>
                 {
                     // The stream for the return value.
-                    Observable<Object> returnValueStream = returnValueSubscription =>
+                    Subscribe<Object> returnValueStream = returnValueSubscription =>
                     {
                         var returnValue = methodInfo.Invoke(null, parameters.ToArray());
                         returnValueSubscription(returnValue);
@@ -47,7 +47,7 @@
                     };
 
                     var keyAttribute = (GuidAttribute)methodInfo.ReturnParameter.GetCustomAttribute(typeof(GuidAttribute));
-                    var pair = new KeyValuePair<Object, Observable<Object>>(keyAttribute.Key, returnValueStream);
+                    var pair = new KeyValuePair<Object, Subscribe<Object>>(keyAttribute.Key, returnValueStream);
                     callback(pair);
                 };
 
@@ -93,7 +93,7 @@
 
         class Player
         {
-            public Player(IDictionary<Object, Observable<Object>> instances)
+            public Player(IDictionary<Object, Subscribe<Object>> instances)
             {
                 var cannonSoundPlayerFactory = instances[new Guid(Services.CannonSoundPlayerFactoryId)];
                 cannonSoundPlayerFactory(soundPlayerFactory =>
Index: 1/Chernobyl.Config/Dependency/ServicesModule.cs
===================================================================
--- 1/Chernobyl.Config/Dependency/ServicesModule.cs	(revision 300)
+++ 1/Chernobyl.Config/Dependency/ServicesModule.cs	(working copy)
@@ -18,9 +18,9 @@
         /// Creates the instance that maps services to their key.
         /// </summary>
         /// <returns>The instance containing services.</returns>
-        public static IDictionary<Object, Observable<Object>> CreateServiceDictionary()
+        public static IDictionary<Object, Subscribe<Object>> CreateServiceDictionary()
         {
-            return new Dictionary<Object, Observable<Object>>();
+            return new Dictionary<Object, Subscribe<Object>>();
         }
 
         /// <summary>
@@ -45,7 +45,7 @@
         /// Create a list of services from this module tied to the keys.
         /// </summary>
         /// <returns>The list of services tied to the key.</returns>
-        public static IDictionary<Object, Observable<Object>> GetServices()
+        public static IDictionary<Object, Subscribe<Object>> GetServices()
         {
             var serviceDictionary = CreateServiceDictionary();
 
Index: 1/Chernobyl.Extensions/CallbackExtensions.cs
===================================================================
--- 1/Chernobyl.Extensions/CallbackExtensions.cs	(revision 298)
+++ 1/Chernobyl.Extensions/CallbackExtensions.cs	(working copy)
@@ -1,4 +1,8 @@
 using System;
+using System.Collections.Generic;
+using System.Reflection;
+using Chernobyl.Attribution;
+using Chernobyl.Reflection;
 
 namespace Chernobyl.Extensions
 {
@@ -30,5 +34,25 @@
         {
             return new Callback<T>(action);
         }
+
+        /// <summary>
+        /// Projects each element of a callback into a new form using the 
+        /// specified selector.
+        /// </summary>
+        /// <typeparam name="TSource">The type of the callback origin.</typeparam>
+        /// <typeparam name="TResult">The type of the callback destination.</typeparam>
+        /// <param name="callback">The method to receive the result.</param>
+        /// <param name="selector">The method that will convert the source to 
+        /// the result.</param>
+        /// <returns>The method to receive the source.</returns>
+        public static Callback<TSource> Select<TSource, TResult>(
+            this Callback<TResult> callback, Func<TSource, TResult> selector)
+        {
+            return source =>
+            {
+                var result = selector(source);
+                callback(result);
+            };
+        }
     }
 }
Index: 1/Chernobyl.Extensions/Chernobyl.Extensions.csproj
===================================================================
--- 1/Chernobyl.Extensions/Chernobyl.Extensions.csproj	(revision 300)
+++ 1/Chernobyl.Extensions/Chernobyl.Extensions.csproj	(working copy)
@@ -41,9 +41,11 @@
     <Compile Include="Func.cs" />
     <Compile Include="Guid.cs" />
     <Compile Include="KeyAttribute.cs" />
+    <Compile Include="MethodInfoExtensions.cs" />
     <Compile Include="ObservableExtensions.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="String.cs" />
+    <Compile Include="System\Collections\Generic\KeyValuePairExtensions.cs" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
Index: 1/Chernobyl.Extensions/MethodInfoExtensions.cs
===================================================================
--- 1/Chernobyl.Extensions/MethodInfoExtensions.cs	(revision 0)
+++ 1/Chernobyl.Extensions/MethodInfoExtensions.cs	(working copy)
@@ -0,0 +1,72 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Threading.Tasks;
+using Chernobyl.Attribution;
+using Chernobyl.Extensions.System.Collections.Generic;
+using Chernobyl.Reflection;
+
+namespace Chernobyl.Extensions
+{
+    /// <summary>
+    /// Extensions to the <see cref="MethodInfo"/> types.
+    /// </summary>
+    public static class MethodInfoExtensions
+    {
+        /// <summary>
+        /// Returns a method that, when invoked, invokes the method identified
+        /// by <paramref name="methodInfo"/> and send the result to 
+        /// <paramref name="returnCallback"/>.
+        /// </summary>
+        /// <param name="methodInfo">The method to invoke.</param>
+        /// <param name="returnCallback">The instance that is to receive the
+        /// result of the invocation.</param>
+        /// <returns>The method to provide the parameters to.</returns>
+        public static Callback<IEnumerable<object>> Invoke(
+            this MethodInfo methodInfo, Callback<object> returnCallback)
+        {
+            return returnCallback
+                    .Select<object[], object>(parameters => methodInfo.Invoke(null, parameters))
+                    .Select<IEnumerable<object>, object[]>(parameters => parameters.ToArray());
+        }
+
+        /// <summary>
+        /// Creates the return value observable.
+        /// </summary>
+        /// <param name="methodInfo">The method information.</param>
+        /// <param name="callback">The callback.</param>
+        public static void CreateReturnValueObservable(this MethodInfo methodInfo, Callback<KeyValuePair<Object, Subscribe<Object>>> callback)
+        {
+            // The subscription for the parameters of the method.
+            var parametersSubscription =
+                callback
+                    .AttributeKey(methodInfo.ReturnParameter, true, key => key)
+                    .Select<IEnumerable<Object>, Subscribe<Object>>(
+                        parameters => subscriber => methodInfo.Invoke(subscriber).Invoke(parameters));
+
+            var parameterInfos = methodInfo.GetParameters();
+            if (parameterInfos.Length > 0)
+            {
+                // Convert the single subscription to multiple subscriptions:
+                // one for each parameter taken by the method.
+                var parametersSubscriptions =
+                    parametersSubscription.AsAction()
+                                          .AsMany(methodInfo.GetParameters().Count())
+                                          .Select(action => action.AsCallback());
+
+                // Obtains the parameters for the method to be invoked.
+                parameterInfos
+                    .Where(param => param.HasAttribute<GuidAttribute>(true))
+                    .Select(param => param.GetCustomAttribute<GuidAttribute>().Key)
+                    .Select(key => instances[key])
+                    .Select(stream => stream.AsAction())
+                    .AsOne()
+                    .Invoke(parametersSubscriptions);
+            }
+            else
+                parametersSubscription(Array.Empty<object>());
+        }
+    }
+}
Index: 1/Chernobyl.Extensions/ObservableExtensions.cs
===================================================================
--- 1/Chernobyl.Extensions/ObservableExtensions.cs	(revision 298)
+++ 1/Chernobyl.Extensions/ObservableExtensions.cs	(working copy)
@@ -1,22 +1,43 @@
 using System;
+using System.ComponentModel;
 
 namespace Chernobyl.Extensions
 {
     /// <summary>
-    /// Extension methods for the <see cref="Observable{T}"/> type.
+    /// Extension methods for the <see cref="Subscribe{T}"/> type.
     /// </summary>
     public static class ObservableExtensions
     {
         /// <summary>
-        /// Returns the <see cref="Observable{T}"/> as its <see cref="Action{T}"/>
+        /// Returns the <see cref="Subscribe{T}"/> as its <see cref="Action{T}"/>
         /// equivalent.
         /// </summary>
         /// <typeparam name="T">The type returned to the response channel.</typeparam>
-        /// <param name="observable">The method to return as an <see cref="Action{T}"/>.</param>
-        /// <returns><paramref name="observable"/> as <see cref="Action{T}"/>.</returns>
-        public static Action<Callback<T>> AsAction<T>(this Observable<T> observable)
+        /// <param name="subscribe">The method to return as an <see cref="Action{T}"/>.</param>
+        /// <returns><paramref name="subscribe"/> as <see cref="Action{T}"/>.</returns>
+        public static Action<Callback<T>> AsAction<T>(this Subscribe<T> subscribe)
         {
-            return new Action<Callback<T>>(observable);
+            return new Action<Callback<T>>(subscribe);
         }
+
+        /// <summary>
+        /// Projects each element of an observable into a new form using the 
+        /// specified selector.
+        /// </summary>
+        /// <typeparam name="TSource">The type of the subscription origin.</typeparam>
+        /// <typeparam name="TResult">The type of the subscription destination.</typeparam>
+        /// <param name="subscribe">The method to receive from.</param>
+        /// <param name="selector">The method that will convert the source to 
+        /// the result.</param>
+        /// <returns>The method to receive the result from.</returns>
+        public static Subscribe<TResult> Select<TSource, TResult>(
+            this Subscribe<TSource> subscribe, Func<TSource, TResult> selector)
+        {
+            return resultCallback =>
+            {
+                var sourceCallback = resultCallback.Select(selector);
+                subscribe(sourceCallback);
+            };
+        }
     }
 }
Index: 1/Chernobyl.Extensions/System/Collections/Generic/KeyValuePairExtensions.cs
===================================================================
--- 1/Chernobyl.Extensions/System/Collections/Generic/KeyValuePairExtensions.cs	(revision 0)
+++ 1/Chernobyl.Extensions/System/Collections/Generic/KeyValuePairExtensions.cs	(working copy)
@@ -0,0 +1,86 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using Chernobyl.Attribution;
+using Chernobyl.Reflection;
+
+namespace Chernobyl.Extensions.System.Collections.Generic
+{
+    /// <summary>
+    /// Extensions for <see cref="KeyValuePair{TKey, TValue}"/> and related types.
+    /// </summary>
+    public static class KeyValuePairExtensions
+    {
+        /// <summary>
+        /// Returns a method that, when invoked, invokes the specified callback
+        /// with the value tied to a key.
+        /// </summary>
+        /// <typeparam name="TKey">The type of the key.</typeparam>
+        /// <typeparam name="TValue">The type of the value.</typeparam>
+        /// <param name="callback">The method to invoke with the key-value 
+        /// pair.</param>
+        /// <param name="createKey">The method that creates the key.</param>
+        /// <returns>The method that converts the instance to a key-value pair.</returns>
+        public static Callback<TValue> Key<TKey, TValue>(
+            this Callback<KeyValuePair<TKey, TValue>> callback,
+            Func<TValue, TKey> createKey)
+        {
+            return callback.Select<TValue, KeyValuePair<TKey, TValue>>(
+                value =>
+                {
+                    var key = createKey(value);
+                    return new KeyValuePair<TKey, TValue>(key, value);
+                });
+        }
+
+        /// <summary>
+        /// Returns a method that, when invoked, invokes the specified callback
+        /// with the value tied to a key retrieved from the <see cref="GuidAttribute" />
+        /// assigned to <paramref name="attributeProvider" />.
+        /// </summary>
+        /// <typeparam name="TValue">The type of the value.</typeparam>
+        /// <param name="callback">The method to invoke with the key-value
+        /// pair.</param>
+        /// <param name="attributeProvider">The instance to pull the key from.</param>
+        /// <param name="inherit">True to look up the hiearchy chain for the 
+        /// attribute.</param>
+        /// <returns>
+        /// The method that converts the instance to a key-value pair.
+        /// </returns>
+        public static Callback<TValue> AttributeKey<TValue>(
+            this Callback<KeyValuePair<Guid, TValue>> callback,
+            ICustomAttributeProvider attributeProvider, bool inherit)
+        {
+            return callback.AttributeKey(attributeProvider, true, key => key);
+        }
+
+        /// <summary>
+        /// Returns a method that, when invoked, invokes the specified callback
+        /// with the value tied to a key retrieved from the <see cref="GuidAttribute" />
+        /// assigned to <paramref name="attributeProvider" />.
+        /// </summary>
+        /// <typeparam name="TKey">The type of the key.</typeparam>
+        /// <typeparam name="TValue">The type of the value.</typeparam>
+        /// <param name="callback">The method to invoke with the key-value
+        /// pair.</param>
+        /// <param name="attributeProvider">The instance to pull the key from.</param>
+        /// <param name="inherit">True to look up the hiearchy chain for the
+        /// attribute.</param>
+        /// <param name="keySelect">The method that converts the key.</param>
+        /// <returns>
+        /// The method that converts the instance to a key-value pair.
+        /// </returns>
+        public static Callback<TValue> AttributeKey<TKey, TValue>(
+            this Callback<KeyValuePair<TKey, TValue>> callback,
+            ICustomAttributeProvider attributeProvider, bool inherit,
+            Func<Guid, TKey> keySelect)
+        {
+            return callback.Key(
+                subscribe =>
+                {
+                    var key = attributeProvider.GetCustomAttribute<GuidAttribute>(inherit).Key;
+                    return keySelect(key);
+                });
+        }
+    }
+}
Index: 1/Chernobyl.Extensions/System/Collections/Generic/KeyValuePairExtensions.cs
===================================================================
--- 1/Chernobyl.Extensions/System/Collections/Generic/KeyValuePairExtensions.cs	(revision 0)
+++ 1/Chernobyl.Extensions/System/Collections/Generic/KeyValuePairExtensions.cs	(working copy)
@@ -0,0 +1,86 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using Chernobyl.Attribution;
+using Chernobyl.Reflection;
+
+namespace Chernobyl.Extensions.System.Collections.Generic
+{
+    /// <summary>
+    /// Extensions for <see cref="KeyValuePair{TKey, TValue}"/> and related types.
+    /// </summary>
+    public static class KeyValuePairExtensions
+    {
+        /// <summary>
+        /// Returns a method that, when invoked, invokes the specified callback
+        /// with the value tied to a key.
+        /// </summary>
+        /// <typeparam name="TKey">The type of the key.</typeparam>
+        /// <typeparam name="TValue">The type of the value.</typeparam>
+        /// <param name="callback">The method to invoke with the key-value 
+        /// pair.</param>
+        /// <param name="createKey">The method that creates the key.</param>
+        /// <returns>The method that converts the instance to a key-value pair.</returns>
+        public static Callback<TValue> Key<TKey, TValue>(
+            this Callback<KeyValuePair<TKey, TValue>> callback,
+            Func<TValue, TKey> createKey)
+        {
+            return callback.Select<TValue, KeyValuePair<TKey, TValue>>(
+                value =>
+                {
+                    var key = createKey(value);
+                    return new KeyValuePair<TKey, TValue>(key, value);
+                });
+        }
+
+        /// <summary>
+        /// Returns a method that, when invoked, invokes the specified callback
+        /// with the value tied to a key retrieved from the <see cref="GuidAttribute" />
+        /// assigned to <paramref name="attributeProvider" />.
+        /// </summary>
+        /// <typeparam name="TValue">The type of the value.</typeparam>
+        /// <param name="callback">The method to invoke with the key-value
+        /// pair.</param>
+        /// <param name="attributeProvider">The instance to pull the key from.</param>
+        /// <param name="inherit">True to look up the hiearchy chain for the 
+        /// attribute.</param>
+        /// <returns>
+        /// The method that converts the instance to a key-value pair.
+        /// </returns>
+        public static Callback<TValue> AttributeKey<TValue>(
+            this Callback<KeyValuePair<Guid, TValue>> callback,
+            ICustomAttributeProvider attributeProvider, bool inherit)
+        {
+            return callback.AttributeKey(attributeProvider, true, key => key);
+        }
+
+        /// <summary>
+        /// Returns a method that, when invoked, invokes the specified callback
+        /// with the value tied to a key retrieved from the <see cref="GuidAttribute" />
+        /// assigned to <paramref name="attributeProvider" />.
+        /// </summary>
+        /// <typeparam name="TKey">The type of the key.</typeparam>
+        /// <typeparam name="TValue">The type of the value.</typeparam>
+        /// <param name="callback">The method to invoke with the key-value
+        /// pair.</param>
+        /// <param name="attributeProvider">The instance to pull the key from.</param>
+        /// <param name="inherit">True to look up the hiearchy chain for the
+        /// attribute.</param>
+        /// <param name="keySelect">The method that converts the key.</param>
+        /// <returns>
+        /// The method that converts the instance to a key-value pair.
+        /// </returns>
+        public static Callback<TValue> AttributeKey<TKey, TValue>(
+            this Callback<KeyValuePair<TKey, TValue>> callback,
+            ICustomAttributeProvider attributeProvider, bool inherit,
+            Func<Guid, TKey> keySelect)
+        {
+            return callback.Key(
+                subscribe =>
+                {
+                    var key = attributeProvider.GetCustomAttribute<GuidAttribute>(inherit).Key;
+                    return keySelect(key);
+                });
+        }
+    }
+}
Index: 1/Chernobyl.Extensions/System/Collections/Generic/KeyValuePairExtensions.cs
===================================================================
--- 1/Chernobyl.Extensions/System/Collections/Generic/KeyValuePairExtensions.cs	(revision 0)
+++ 1/Chernobyl.Extensions/System/Collections/Generic/KeyValuePairExtensions.cs	(working copy)
@@ -0,0 +1,86 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using Chernobyl.Attribution;
+using Chernobyl.Reflection;
+
+namespace Chernobyl.Extensions.System.Collections.Generic
+{
+    /// <summary>
+    /// Extensions for <see cref="KeyValuePair{TKey, TValue}"/> and related types.
+    /// </summary>
+    public static class KeyValuePairExtensions
+    {
+        /// <summary>
+        /// Returns a method that, when invoked, invokes the specified callback
+        /// with the value tied to a key.
+        /// </summary>
+        /// <typeparam name="TKey">The type of the key.</typeparam>
+        /// <typeparam name="TValue">The type of the value.</typeparam>
+        /// <param name="callback">The method to invoke with the key-value 
+        /// pair.</param>
+        /// <param name="createKey">The method that creates the key.</param>
+        /// <returns>The method that converts the instance to a key-value pair.</returns>
+        public static Callback<TValue> Key<TKey, TValue>(
+            this Callback<KeyValuePair<TKey, TValue>> callback,
+            Func<TValue, TKey> createKey)
+        {
+            return callback.Select<TValue, KeyValuePair<TKey, TValue>>(
+                value =>
+                {
+                    var key = createKey(value);
+                    return new KeyValuePair<TKey, TValue>(key, value);
+                });
+        }
+
+        /// <summary>
+        /// Returns a method that, when invoked, invokes the specified callback
+        /// with the value tied to a key retrieved from the <see cref="GuidAttribute" />
+        /// assigned to <paramref name="attributeProvider" />.
+        /// </summary>
+        /// <typeparam name="TValue">The type of the value.</typeparam>
+        /// <param name="callback">The method to invoke with the key-value
+        /// pair.</param>
+        /// <param name="attributeProvider">The instance to pull the key from.</param>
+        /// <param name="inherit">True to look up the hiearchy chain for the 
+        /// attribute.</param>
+        /// <returns>
+        /// The method that converts the instance to a key-value pair.
+        /// </returns>
+        public static Callback<TValue> AttributeKey<TValue>(
+            this Callback<KeyValuePair<Guid, TValue>> callback,
+            ICustomAttributeProvider attributeProvider, bool inherit)
+        {
+            return callback.AttributeKey(attributeProvider, true, key => key);
+        }
+
+        /// <summary>
+        /// Returns a method that, when invoked, invokes the specified callback
+        /// with the value tied to a key retrieved from the <see cref="GuidAttribute" />
+        /// assigned to <paramref name="attributeProvider" />.
+        /// </summary>
+        /// <typeparam name="TKey">The type of the key.</typeparam>
+        /// <typeparam name="TValue">The type of the value.</typeparam>
+        /// <param name="callback">The method to invoke with the key-value
+        /// pair.</param>
+        /// <param name="attributeProvider">The instance to pull the key from.</param>
+        /// <param name="inherit">True to look up the hiearchy chain for the
+        /// attribute.</param>
+        /// <param name="keySelect">The method that converts the key.</param>
+        /// <returns>
+        /// The method that converts the instance to a key-value pair.
+        /// </returns>
+        public static Callback<TValue> AttributeKey<TKey, TValue>(
+            this Callback<KeyValuePair<TKey, TValue>> callback,
+            ICustomAttributeProvider attributeProvider, bool inherit,
+            Func<Guid, TKey> keySelect)
+        {
+            return callback.Key(
+                subscribe =>
+                {
+                    var key = attributeProvider.GetCustomAttribute<GuidAttribute>(inherit).Key;
+                    return keySelect(key);
+                });
+        }
+    }
+}
Index: 1/Chernobyl.Extensions/System/Collections/Generic/KeyValuePairExtensions.cs
===================================================================
--- 1/Chernobyl.Extensions/System/Collections/Generic/KeyValuePairExtensions.cs	(revision 0)
+++ 1/Chernobyl.Extensions/System/Collections/Generic/KeyValuePairExtensions.cs	(working copy)
@@ -0,0 +1,86 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using Chernobyl.Attribution;
+using Chernobyl.Reflection;
+
+namespace Chernobyl.Extensions.System.Collections.Generic
+{
+    /// <summary>
+    /// Extensions for <see cref="KeyValuePair{TKey, TValue}"/> and related types.
+    /// </summary>
+    public static class KeyValuePairExtensions
+    {
+        /// <summary>
+        /// Returns a method that, when invoked, invokes the specified callback
+        /// with the value tied to a key.
+        /// </summary>
+        /// <typeparam name="TKey">The type of the key.</typeparam>
+        /// <typeparam name="TValue">The type of the value.</typeparam>
+        /// <param name="callback">The method to invoke with the key-value 
+        /// pair.</param>
+        /// <param name="createKey">The method that creates the key.</param>
+        /// <returns>The method that converts the instance to a key-value pair.</returns>
+        public static Callback<TValue> Key<TKey, TValue>(
+            this Callback<KeyValuePair<TKey, TValue>> callback,
+            Func<TValue, TKey> createKey)
+        {
+            return callback.Select<TValue, KeyValuePair<TKey, TValue>>(
+                value =>
+                {
+                    var key = createKey(value);
+                    return new KeyValuePair<TKey, TValue>(key, value);
+                });
+        }
+
+        /// <summary>
+        /// Returns a method that, when invoked, invokes the specified callback
+        /// with the value tied to a key retrieved from the <see cref="GuidAttribute" />
+        /// assigned to <paramref name="attributeProvider" />.
+        /// </summary>
+        /// <typeparam name="TValue">The type of the value.</typeparam>
+        /// <param name="callback">The method to invoke with the key-value
+        /// pair.</param>
+        /// <param name="attributeProvider">The instance to pull the key from.</param>
+        /// <param name="inherit">True to look up the hiearchy chain for the 
+        /// attribute.</param>
+        /// <returns>
+        /// The method that converts the instance to a key-value pair.
+        /// </returns>
+        public static Callback<TValue> AttributeKey<TValue>(
+            this Callback<KeyValuePair<Guid, TValue>> callback,
+            ICustomAttributeProvider attributeProvider, bool inherit)
+        {
+            return callback.AttributeKey(attributeProvider, true, key => key);
+        }
+
+        /// <summary>
+        /// Returns a method that, when invoked, invokes the specified callback
+        /// with the value tied to a key retrieved from the <see cref="GuidAttribute" />
+        /// assigned to <paramref name="attributeProvider" />.
+        /// </summary>
+        /// <typeparam name="TKey">The type of the key.</typeparam>
+        /// <typeparam name="TValue">The type of the value.</typeparam>
+        /// <param name="callback">The method to invoke with the key-value
+        /// pair.</param>
+        /// <param name="attributeProvider">The instance to pull the key from.</param>
+        /// <param name="inherit">True to look up the hiearchy chain for the
+        /// attribute.</param>
+        /// <param name="keySelect">The method that converts the key.</param>
+        /// <returns>
+        /// The method that converts the instance to a key-value pair.
+        /// </returns>
+        public static Callback<TValue> AttributeKey<TKey, TValue>(
+            this Callback<KeyValuePair<TKey, TValue>> callback,
+            ICustomAttributeProvider attributeProvider, bool inherit,
+            Func<Guid, TKey> keySelect)
+        {
+            return callback.Key(
+                subscribe =>
+                {
+                    var key = attributeProvider.GetCustomAttribute<GuidAttribute>(inherit).Key;
+                    return keySelect(key);
+                });
+        }
+    }
+}
Index: 1/Chernobyl/Callback.cs
===================================================================
--- 1/Chernobyl/Callback.cs	(revision 298)
+++ 1/Chernobyl/Callback.cs	(working copy)
@@ -8,9 +8,11 @@
     public delegate void Callback<in T>(T value);
 
     /// <summary>
-    /// Signature for methods which act as a stream of data.
+    /// Signature for methods which act as a stream of data. The invoked method
+    /// will take in the <paramref name="subscriber"/> and invoke whenever
+    /// necessary.
     /// </summary>
     /// <typeparam name="T">The type returned to the response channel.</typeparam>
     /// <param name="subscriber">The method that is to receive the stream of data.</param>
-    public delegate void Observable<out T>(Callback<T> subscriber);
+    public delegate void Subscribe<out T>(Callback<T> subscriber);
 }