Simplified the WeakEvent example.

Author: gfraiteur

Framework/PostSharp.Samples.WeakEvent/DelegateReferenceKeeper.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+
+namespace PostSharp.Samples.WeakEvent
+{
+    internal static class DelegateReferenceKeeper
+    {
+        private static readonly object staticObj = new object();
+        static readonly ConditionalWeakTable<object,List<Delegate>> table = new ConditionalWeakTable<object, List<Delegate>>();
+
+        public static void AddReference(Delegate handler)
+        {
+            List<Delegate> list = table.GetOrCreateValue(handler.Target ?? staticObj);
+            lock (list)
+            {
+                list.Add(handler);
+            }
+        }
+
+        public static void RemoveReference(Delegate handler)
+        {
+            List<Delegate> list;
+            if ( table.TryGetValue(handler.Target ?? staticObj, out list ) )
+            {
+                lock (list)
+                {
+                    list.Remove(handler);
+                }
+            }
+        }
+
+    }
+}

Framework/PostSharp.Samples.WeakEvent/IWeakEventClient.cs

@@ -57,13 +57,11 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="IWeakEventClient.cs" />
+    <Compile Include="DelegateReferenceKeeper.cs" />
     <Compile Include="Program.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="WeakEventAttribute.cs" />
-    <Compile Include="WeakEventClientAttribute.cs" />
     <Compile Include="WeakEventHandler.cs" />
-    <Compile Include="WeakEventValidation.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="App.config" />

Framework/PostSharp.Samples.WeakEvent/PostSharp.Samples.WeakEvent.csproj

@@ -14,27 +14,27 @@ private static void Main(string[] args)
 
             // Raise the event when the client is alive.
             MyEvent(null, EventArgs.Empty);
-            Console.WriteLine("EventHandlerCount: {0}", EventClient.EventHandlerCount); // Should be 1.
+            Console.WriteLine("EventHandlerCount: {0} (should be 1)", EventClient.EventHandlerCount); 
 
 
             // Cause the client to be collected.
             var weakReference = new WeakReference(eventClient);
             eventClient = null;
             GC.Collect();
 
-            Console.WriteLine("Client is alive: {0}", weakReference.IsAlive); // Should be False.
-
-
+            Console.WriteLine("Client is alive: {0} (should be False)", weakReference.IsAlive);
+
+
             // Raise the event when the client is dead.
+            EventClient.EventHandlerCount = 0;
             MyEvent(null, EventArgs.Empty);
-            Console.WriteLine("EventHandlerCount: {0}", EventClient.EventHandlerCount); // Should be 1.
+            Console.WriteLine("EventHandlerCount: {0} (should be 0)", EventClient.EventHandlerCount); 
         }
 
         [WeakEvent]
         private static event EventHandler MyEvent;
     }
 
-   [WeakEventClient]
     internal class EventClient
     {
         public static int EventHandlerCount;

Framework/PostSharp.Samples.WeakEvent/Program.cs

@@ -14,31 +14,11 @@ namespace PostSharp.Samples.WeakEvent
     /// </summary>
     [PSerializable]
     [LinesOfCodeAvoided(6)]
-    [WeakEventValidation]
     public sealed class WeakEventAttribute : EventInterceptionAspect, IInstanceScopedAspect
     {
         [PNonSerialized] private WeakEventHandler weakEventHandler;
 
 
-        /// <summary>
-        ///     Initializes a new <see cref="WeakEventAttribute" />
-        /// </summary>
-        /// <param name="allowStrongReferences">
-        ///     Determines whether the current aspect is allowed to create a strong reference if the client does not have
-        ///     the <see cref="WeakEventClientAttribute" /> aspect. The default value is <c>false</c>.
-        /// </param>
-        public WeakEventAttribute(bool allowStrongReferences = false)
-        {
-            AllowStrongReferences = allowStrongReferences;
-        }
-
-        /// <summary>
-        ///     Determines whether the current aspect is allowed to create a strong reference if the client does not have
-        ///     the <see cref="WeakEventClientAttribute" /> aspect.
-        /// </summary>
-        public bool AllowStrongReferences { get; set; }
-
-
         /// <summary>
         ///     Creates an instance of the aspect for a specific instance of the target class (when the target event is not
         ///     static). A call of this method is followed by a call of RuntimeInitializeInstance.
@@ -73,31 +53,19 @@ public override void RuntimeInitialize(EventInfo eventInfo)
         /// <param name="args">Context information.</param>
         public override void OnAddHandler(EventInterceptionArgs args)
         {
-            var weakEventClient = args.Handler.Target as IWeakEventClient;
-            var supportsWeakReference = weakEventClient != null;
-
-            // Throw an exception if the client does not support weak events and we are not allowed to hold strong references.
-            if (!supportsWeakReference && args.Handler.Target != null && !AllowStrongReferences)
-            {
-                throw new InvalidOperationException(
-                    string.Format(
-                        "Attempt to add a reference to the weak event {0} from type {1}, which does not implement the IWeakEventClient interface.",
-                        args.Event, args.Handler.Target.GetType()));
-            }
+           
 
             // Add the handler to our own list.
-            if (weakEventHandler.AddHandler(args.Handler, supportsWeakReference))
+            if (weakEventHandler.AddHandler(args.Handler))
             {
                 // If it is the first handler we are adding, add a fake handler to ourselves to the target event.
                 // Whichever handler will add here will be passed to OnInvokeHandler, so it is safe and convenient to pass null.
                 args.AddHandler(null);
-            }
-
+            }
+
+
             // Register the handler to the client to prevent garbage collection of the handler.
-            if (supportsWeakReference)
-            {
-                weakEventClient.RegisterEventHandler(args.Handler);
-            }
+            DelegateReferenceKeeper.AddReference(args.Handler);
         }
 
         /// <summary>
@@ -106,22 +74,15 @@ public override void OnAddHandler(EventInterceptionArgs args)
         /// <param name="args">Context information.</param>
         public override void OnRemoveHandler(EventInterceptionArgs args)
         {
-            var weakEventClient = args.Handler.Target as IWeakEventClient;
-
-            var supportsWeakReference = weakEventClient != null;
-
-            // Remove the handler from our own list.
+             // Remove the handler from our own list.
             if (weakEventHandler.RemoveHandler(args.Handler))
             {
                 // If this is the last handler, remove the fake handler to ourselves from the target event.
                 args.RemoveHandler(null);
-            }
-
+            }
+
             // Remove the handler from the client.
-            if (supportsWeakReference)
-            {
-                weakEventClient.UnregisterEventHandler(args.Handler);
-            }
+            DelegateReferenceKeeper.RemoveReference(args.Handler);
         }
 
         /// <summary>

Framework/PostSharp.Samples.WeakEvent/WeakEventAttribute.cs

@@ -7,7 +7,6 @@
 
 namespace PostSharp.Samples.WeakEvent
 {
-    [PSerializable]
     internal struct WeakEventHandler
     {
         private bool initialized;
@@ -25,15 +24,15 @@ public void Initialize()
             }
         }
 
-        public bool AddHandler(Delegate handler, bool weak)
+        public bool AddHandler(Delegate handler)
         {
             var lockTaken = false;
 
             try
             {
                 spinLock.Enter(ref lockTaken);
 
-                handlers = handlers.Add(weak ? (object) new WeakReference(handler) : handler);
+                handlers = handlers.Add(new WeakReference(handler));
 
                 return handlers.Length == 1;
             }
@@ -55,9 +54,7 @@ public bool RemoveHandler(Delegate handler)
 
                 handlers =
                     handlers.RemoveAll(
-                        o =>
-                            ReferenceEquals(o, handler) ||
-                            o is WeakReference && ReferenceEquals(((WeakReference) o).Target, handler));
+                        o => ReferenceEquals(((WeakReference) o).Target, handler));
 
                 return handlers.IsEmpty;
             }
@@ -83,24 +80,20 @@ public void InvokeHandler(object[] args)
 
             foreach (var obj in invocationList)
             {
-                var handler = obj as Delegate;
+              
+                var handler = (Delegate) ((WeakReference) obj).Target;
 
                 if (handler == null)
                 {
-                    handler = (Delegate) ((WeakReference) obj).Target;
-
-                    if (handler == null)
+                    if (!needCleanUp)
                     {
-                        if (!needCleanUp)
-                        {
-                            needCleanUp = true;
-                            lastCleanUpCounter = cleanUpCounter;
-                        }
-
-                        continue;
+                        needCleanUp = true;
+                        lastCleanUpCounter = cleanUpCounter;
                     }
-                }
 
+                    continue;
+                }
+               
 
                 handler.DynamicInvoke(args);
             }
@@ -113,7 +106,7 @@ public void InvokeHandler(object[] args)
                     try
                     {
                         spinLock.Enter(ref lockTaken);
-                        handlers = handlers.RemoveAll(w => w is WeakReference && !((WeakReference) w).IsAlive);
+                        handlers = handlers.RemoveAll(w => !((WeakReference) w).IsAlive);
 
                         Interlocked.Increment(ref cleanUpCounter);
                     }