FluxorLayout (Fixes #8)

Source/Fluxor.Blazor.Web/Components/FluxorComponent.cs

@@ -1,8 +1,5 @@
 using Microsoft.AspNetCore.Components;
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Reflection;
 
 namespace Fluxor.Blazor.Web.Components
 {
@@ -13,7 +10,7 @@ namespace Fluxor.Blazor.Web.Components
 	public class FluxorComponent : ComponentBase, IDisposable
 	{
 		private bool Disposed;
-		private List<IState> SubscribedStates = new List<IState>();
+		private IDisposable StateSubscription;
 
 		/// <summary>
 		/// Disposes of the component and unsubscribes from any state
@@ -29,17 +26,7 @@ public void Dispose()
 		protected override void OnInitialized()
 		{
 			base.OnInitialized();
-			// Find all state properties
-			const BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
-			IEnumerable<PropertyInfo> stateProperties = GetType().GetProperties(bindingFlags)
-				.Where(t => typeof(IState).IsAssignableFrom(t.PropertyType));
-			// Subscribe to each state so that StateHasChanged is executed when the state changes
-			foreach (PropertyInfo propertyInfo in stateProperties)
-			{
-				IState state = (IState)propertyInfo.GetValue(this);
-				SubscribedStates.Add(state);
-				state.StateChanged += InvokeStateHasChanged;
-			}
+			StateSubscription = StateSubscriber.Subscribe(this, _ => StateHasChanged());
 		}
 
 		protected virtual void Dispose(bool disposing)
@@ -48,22 +35,10 @@ protected virtual void Dispose(bool disposing)
 			{
 				if (disposing)
 				{
-					UnsubscribeFromState();
+					StateSubscription.Dispose();
 				}
 				Disposed = true;
 			}
 		}
-
-		private void InvokeStateHasChanged(object sender, EventArgs e)
-		{
-			InvokeAsync(StateHasChanged);
-		}
-
-		private void UnsubscribeFromState()
-		{
-			foreach (IState state in SubscribedStates)
-				state.StateChanged -= InvokeStateHasChanged;
-		}
-
 	}
 }

Source/Fluxor.Blazor.Web/Components/FluxorLayout.cs

@@ -0,0 +1,44 @@
+using Microsoft.AspNetCore.Components;
+using System;
+
+namespace Fluxor.Blazor.Web.Components
+{
+	/// <summary>
+	/// A layout that auto-subscribes to state changes on all <see cref="IState"/> properties
+	/// and ensures <see cref="LayoutComponentBase.StateHasChanged"/> is called
+	/// </summary>
+	public class FluxorLayout : LayoutComponentBase, IDisposable
+	{
+		private bool Disposed;
+		private IDisposable StateSubscription;
+
+		/// <summary>
+		/// Disposes of the component and unsubscribes from any state
+		/// </summary>
+		public void Dispose()
+		{
+			Dispose(true);
+		}
+
+		/// <summary>
+		/// Subscribes to state properties
+		/// </summary>
+		protected override void OnInitialized()
+		{
+			base.OnInitialized();
+			StateSubscription = StateSubscriber.Subscribe(this, _ => StateHasChanged());
+		}
+
+		protected virtual void Dispose(bool disposing)
+		{
+			if (!Disposed)
+			{
+				if (disposing)
+				{
+					StateSubscription.Dispose();
+				}
+				Disposed = true;
+			}
+		}
+	}
+}

Source/Fluxor.Blazor.Web/Components/StateSubscriber.cs

@@ -0,0 +1,68 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using GetStateDelegate = System.Func<object, Fluxor.IState>;
+
+namespace Fluxor.Blazor.Web.Components
+{
+	internal static class StateSubscriber
+	{
+		private static readonly ConcurrentDictionary<Type, IEnumerable<GetStateDelegate>> ValueDelegatesForType;
+
+		static StateSubscriber()
+		{
+			ValueDelegatesForType = new ConcurrentDictionary<Type, IEnumerable<GetStateDelegate>>();
+		}
+
+		public static IDisposable Subscribe(object subject, Action<IState> callback)
+		{
+			if (subject == null)
+				throw new ArgumentNullException(nameof(subject));
+			if (callback == null)
+				throw new ArgumentNullException(nameof(callback));
+
+			IEnumerable<GetStateDelegate> getStateDelegates = GetStateDelegatesForType(subject.GetType());
+			var subscriptions = new List<(IState State, EventHandler Handler)>();
+			foreach(GetStateDelegate getState in getStateDelegates)
+			{
+				var state = (IState)getState(subject);
+				var handler = new EventHandler((s, a) => callback(state));
+
+				subscriptions.Add((state, handler));
+				state.StateChanged += handler;
+			}
+			return new DisposableCallback(() =>
+			{
+				foreach (var subscription in subscriptions)
+					subscription.State.StateChanged -= subscription.Handler;
+			});
+		}
+
+		private static IEnumerable<GetStateDelegate> GetStateDelegatesForType(Type type)
+		{
+			return ValueDelegatesForType.GetOrAdd(type, _ =>
+			{
+				var delegates = new List<GetStateDelegate>();
+
+				const BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
+				IEnumerable<PropertyInfo> stateProperties = type.GetProperties(bindingFlags)
+					.Where(p => p.PropertyType.IsGenericType)
+					.Where(p => p.PropertyType.GetGenericTypeDefinition() == typeof(IState<>));
+
+				foreach(PropertyInfo currentProperty in stateProperties)
+				{
+					Type stateType = currentProperty.PropertyType.GetGenericArguments()[0];
+					Type iStateType = typeof(IState<>).MakeGenericType(stateType);
+					Type getterMethod = typeof(Func<,>).MakeGenericType(type, iStateType);
+					Delegate stronglyTypedDelegate = Delegate.CreateDelegate(getterMethod, currentProperty.GetGetMethod(true));
+					var getValueDelegate = new GetStateDelegate(x => (IState)stronglyTypedDelegate.DynamicInvoke(x));
+					delegates.Add(getValueDelegate);
+				}
+
+				return delegates;
+			});
+		}
+	}
+}