Add IEventListView and improve collection view APIs

Introduced IEventListView for immutable event collections. Renamed DeclaringTypData to DeclaringType for consistency. Added and updated EventListView and ParameterListView classes to provide strongly-typed, immutable views with enhanced equality and hash code support. Improved equality operators for EventList and ParameterList to support comparisons with their view interfaces.

Author: BionicCode

src/BionicCode.Utilities.Reflection/EventDataView.cs

@@ -55,7 +55,7 @@ internal EventDataView(SymbolReflectionInfoCacheKey cacheKey) : base(cacheKey)
     public ITypeDataView EventHandlerTypeData { get; }
     public IMethodDataView EventInvokerMethodData { get; }
     public IMethodDataView RemoveMethodData { get; }
-    public ITypeDataView DeclaringTypData { get; }
+    public ITypeDataView DeclaringType { get; }
     public ITypeDataView ImplementingTypData { get; }
 
     public void AddEventHandler(object eventSource, Delegate handler) => throw new NotImplementedException();

src/BionicCode.Utilities.Reflection/EventList.cs

@@ -126,6 +126,34 @@ public bool Equals(EventList? other)
         return true;
     }
 
+    public bool Equals(IEventListView? other)
+    {
+        if (other is null)
+        {
+            return false;
+        }
+
+        if (Count != other.Count)
+        {
+            return false;
+        }
+
+        if (!ReferenceEquals(DeclaringTypeData.View, other.DeclaringType))
+        {
+            return false;
+        }
+
+        for (int index = 0; index < Count; index++)
+        {
+            if (!Events[index].View.Equals(other.Events[index]))
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
     public override bool Equals(object? obj)
         => obj is EventList other && Equals(other);
 
@@ -147,8 +175,189 @@ private int ComputeHashCode()
         }
     }
 
-    public static bool operator ==(EventList? left, EventList? right)
-        => left?.Equals(right) ?? (right is null);
-    public static bool operator !=(EventList? left, EventList? right)
-        => !(left == right);
+    public static bool operator ==(EventList? left, EventList? right) => left?.Equals(right) ?? (right is null);
+    public static bool operator !=(EventList? left, EventList? right) => !(left == right);
+
+    public static bool operator ==(EventList? left, IEventListView? right) => left?.Equals(right) ?? (right is null);
+    public static bool operator !=(EventList? left, IEventListView? right) => !(left == right);
+
+    public static bool operator ==(IEventListView? left, EventList? right) => right == left;
+    public static bool operator !=(IEventListView? left, EventList? right) => !(left == right);
+}
+
+public sealed class EventListView : IReadOnlyList<IEventDataView>, IEquatable<IEventListView>, IEventListView
+{
+    public static EventListView Empty { get; } = new EventListView();
+    private readonly int _hashCode; // precomputed
+    private readonly ITypeDataView _declaringType;
+    private readonly Dictionary<string, IEventDataView> _eventNameIndex;
+
+    public EventListView(IEventDataView[] items, ITypeDataView? declaringType) : this((IEnumerable<IEventDataView>)items, declaringType)
+    {
+    }
+
+    public EventListView(IEnumerable<IEventDataView> items, ITypeDataView? declaringType)
+    {
+        ArgumentNullException.ThrowIfNull(declaringType);
+
+        _declaringType = declaringType;
+        Events = items?.ToImmutableList() ?? ImmutableList<IEventDataView>.Empty;
+        _eventNameIndex = Events.ToDictionary(eventData => eventData.Name, StringComparer.Ordinal);
+
+        if (HasItems)
+        {
+            ArgumentExceptionAdvanced.ThrowIfAny(
+                Events,
+                eventData => !ReferenceEquals(eventData.DeclaringType, _declaringType),
+                nameof(items),
+                $"At least one item in the argument sequence '{nameof(items)}' has a different value for the '{nameof(IEventDataView)}.{nameof(IEventDataView.DeclaringType)}' declaring type handle. All events must belong to the same declaring type.");
+
+        }
+
+        _hashCode = ComputeHashCode();
+    }
+
+    internal EventListView(IEnumerable<IEventDataView> items, ITypeDataView? declaringType, bool isIntegrityValidationEnabled)
+    {
+        ArgumentNullException.ThrowIfNull(declaringType);
+
+        _declaringType = declaringType;
+
+        Events = items?.ToImmutableList() ?? ImmutableList<IEventDataView>.Empty;
+        _eventNameIndex = Events.ToDictionary(eventData => eventData.Name, StringComparer.Ordinal);
+
+        if (isIntegrityValidationEnabled && HasItems)
+        {
+            ArgumentExceptionAdvanced.ThrowIfAny(
+                Events,
+                eventData => !ReferenceEquals(eventData.DeclaringType, _declaringType),
+                nameof(items),
+                $"At least one item in the argument sequence '{nameof(items)}' has a different value for the '{nameof(IEventDataView)}.{nameof(IEventDataView.DeclaringType)}' declaring type handle. All events must belong to the same declaring type.");
+
+        }
+
+        _hashCode = ComputeHashCode();
+    }
+
+    private EventListView()
+    {
+        _declaringType = default!;
+        Events = ImmutableList<IEventDataView>.Empty;
+        _eventNameIndex = new Dictionary<string, IEventDataView>(0, StringComparer.Ordinal);
+        _hashCode = ComputeHashCode();
+    }
+
+    public bool TryGetEventByName(string eventName, out IEventDataView? eventData)
+    {
+        ArgumentNullException.ThrowIfNullOrWhiteSpace(eventName);
+        return _eventNameIndex.TryGetValue(eventName, out eventData);
+    }
+
+    public int Count => Events.Count;
+    public bool IsEmpty => Events.IsEmpty;
+    public bool HasItems => !IsEmpty;
+    public ImmutableList<IEventDataView> Events { get; }
+    public ITypeDataView DeclaringType => _declaringType ?? throw new InvalidOperationException(ExceptionMessages.GetInvalidAccessCollectionEmptyExceptionMessage(nameof(EventListView), nameof(DeclaringType)));
+
+    public IEventDataView this[int index]
+    {
+        get
+        {
+            ArgumentOutOfRangeException.ThrowIfLessThan(index, 0, nameof(index));
+            ArgumentOutOfRangeException.ThrowIfGreaterThanOrEqual(index, Events.Count, nameof(index));
+
+            return HasItems
+                ? Events[index]
+                : throw new InvalidOperationException(ExceptionMessages.GetInvalidAccessCollectionEmptyExceptionMessage(nameof(EventList), ReflectionConstants.IndexerGetMethodName));
+        }
+    }
+
+    public IEnumerator<IEventDataView> GetEnumerator()
+        => ((IEnumerable<IEventDataView>)Events).GetEnumerator();
+
+    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
+        => Events.GetEnumerator();
+
+    public bool Equals(IEventListView? other)
+    {
+        if (other is null)
+        {
+            return false;
+        }
+
+        if (Count != other.Count)
+        {
+            return false;
+        }
+
+        if (!ReferenceEquals(DeclaringType, other.DeclaringType))
+        {
+            return false;
+        }
+
+        for (int index = 0; index < Count; index++)
+        {
+            if (!Events[index].Equals(other.Events[index]))
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    internal bool Equals(EventList? other)
+    {
+        if (other is null)
+        {
+            return false;
+        }
+
+        if (Count != other.Count)
+        {
+            return false;
+        }
+
+        if (!ReferenceEquals(DeclaringType, other.DeclaringTypeData.View))
+        {
+            return false;
+        }
+
+        for (int index = 0; index < Count; index++)
+        {
+            if (!Events[index].Equals(other.Events[index].View))
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    public override bool Equals(object? obj)
+        => obj is IEventListView other && Equals(other);
+
+    public override int GetHashCode() => _hashCode;
+
+    private int ComputeHashCode()
+    {
+        unchecked
+        {
+            var hashCode = new HashCode();
+            hashCode.Add(Count);
+            hashCode.Add(DeclaringType);
+            for (int index = 0; index < Events.Count; index++)
+            {
+                hashCode.Add(Events[index]);
+            }
+
+            return hashCode.ToHashCode();
+        }
+    }
+
+    public static bool operator ==(EventListView? left, IEventListView? right) => left?.Equals(right) ?? (right is null);
+    public static bool operator !=(EventListView? left, IEventListView? right) => !(left == right);
+
+    public static bool operator ==(IEventListView? left, EventListView? right) => left?.Equals(right) ?? (right is null);
+    public static bool operator !=(IEventListView? left, EventListView? right) => !(left == right);
 }

src/BionicCode.Utilities.Reflection/IEventListView.cs

@@ -0,0 +1,15 @@
+namespace BionicCode.Utilities.Net.Reflection;
+
+using System.Collections.Immutable;
+
+public interface IEventListView : IEquatable<IEventListView>
+{
+    IEventDataView this[int index] { get; }
+    int Count { get; }
+    ITypeDataView DeclaringType { get; }
+    ImmutableList<IEventDataView> Events { get; }
+    bool HasItems { get; }
+    bool IsEmpty { get; }
+    IEnumerator<IEventDataView> GetEnumerator();
+    bool TryGetEventByName(string eventName, out IEventDataView? eventData);
+}

src/BionicCode.Utilities.Reflection/IMemberDataView.cs

@@ -8,7 +8,7 @@ public interface IMemberDataView : ISymbolInfoDataView
 {
     AccessModifier AccessModifier { get; }
     BindingFlags BindingFlagsVisibilityMask { get; }
-    ITypeDataView DeclaringTypData { get; }
+    ITypeDataView DeclaringType { get; }
     RuntimeTypeHandle DeclaringTypeHandle { get; }
     RuntimeTypeHandle ImplementingTypeHandle { get; }
     ITypeDataView ImplementingTypData { get; }

src/BionicCode.Utilities.Reflection/IParameterListView.cs

@@ -2,17 +2,14 @@
 
 using System.Collections.Immutable;
 
-public interface IParameterListView
+public interface IParameterListView : IEquatable<IParameterListView>
 {
     IParameterDataView this[int index] { get; }
     int Count { get; }
     IParameterizedMemberDataView DeclaringMemberDataView { get; }
     bool HasItems { get; }
     bool IsEmpty { get; }
     ImmutableList<IParameterDataView> Parameters { get; }
-    bool Equals(object? obj);
-    bool Equals(IParameterListView? other);
     IEnumerator<IParameterDataView> GetEnumerator();
-    int GetHashCode();
     bool TryGetParameterByName(string parameterName, out IParameterDataView? parameterData);
 }

src/BionicCode.Utilities.Reflection/ParameterList.cs

@@ -206,12 +206,15 @@ private int ComputeHashCode()
         => left?.Equals(right) ?? (right is null);
     public static bool operator !=(ParameterList? left, ParameterList? right)
         => !(left == right);
-    public static bool operator ==(ParameterList left, IParameterListView? right) => left?.Equals(right) ?? (right is null);
-    public static bool operator !=(ParameterList left, IParameterListView? right) => !(left == right);
+    public static bool operator ==(ParameterList? left, IParameterListView? right) => left?.Equals(right) ?? (right is null);
+    public static bool operator !=(ParameterList? left, IParameterListView? right) => !(left == right);
+
+    public static bool operator ==(IParameterListView? left, ParameterList? right) => right == left;
+    public static bool operator !=(IParameterListView? left, ParameterList? right) => !(left == right);
 }
 #endregion ParameterList
 
-internal sealed class ParameterListView : IReadOnlyList<IParameterDataView>, IEquatable<IParameterListView>, IParameterListView
+public sealed class ParameterListView : IReadOnlyList<IParameterDataView>, IEquatable<IParameterListView>, IParameterListView
 {
     public static IParameterListView Empty { get; } = new ParameterListView();
     private readonly int _hashCode; // precomputed
@@ -347,7 +350,7 @@ public bool Equals(IParameterListView? other)
         return true;
     }
 
-    public bool Equals(ParameterList? other)
+    internal bool Equals(ParameterList? other)
     {
         if (other is null)
         {
@@ -397,8 +400,6 @@ private int ComputeHashCode()
         }
     }
 
-    public static bool operator ==(ParameterListView? left, ParameterList? right) => left?.Equals(right) ?? (right is null);
-    public static bool operator !=(ParameterListView? left, ParameterList? right) => !(left == right);
     public static bool operator ==(IParameterListView? left, ParameterListView? right) => left?.Equals(right) ?? (right is null);
     public static bool operator !=(IParameterListView? left, ParameterListView? right) => !(left == right);
     public static bool operator ==(ParameterListView? left, IParameterListView? right) => left?.Equals(right) ?? (right is null);

src/BionicCode.Utilities.Reflection/PropertyDataView.cs

@@ -396,7 +396,7 @@ public bool TryGetPropertySetMethodData(out IMethodDataView? setMethodData)
     public ITypeDataView? PropertyTypeData { get; }
     public AccessModifier AccessModifier { get; }
     public BindingFlags BindingFlagsVisibilityMask { get; }
-    public ITypeDataView? DeclaringTypData { get; }
+    public ITypeDataView? DeclaringType { get; }
     public RuntimeTypeHandle DeclaringTypeHandle { get; }
     public RuntimeTypeHandle ImplementingTypeHandle { get; }
     public ITypeDataView? ImplementingTypData { get; }