6130084901

Committed 09 Sep 2023 09:14AM UTC coverage: 83.158% (+0.2%) from 82.932%

Build # 6130084901

Build Type

push

github

Committed by

web-flow

Commit Message

Fixes (#27)

Run Details

227 of 266 branches covered (0.0%)

Branch coverage included in aggregate %.

661 of 661 new or added lines in 31 files covered. (100.0%)

642 of 779 relevant lines covered (82.41%)

18.46 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.0

/NetFabric.Reflection/Reflection/TypeExtensions.cs

using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Reflection;

// ReSharper disable LoopCanBeConvertedToQuery

namespace NetFabric.Reflection;

public static partial class TypeExtensions
{

    /// <summary>
    /// Gets a value indicating whether <see cref="System.Type"/> implements the given interface <see cref="System.Type"/>.
    /// </summary>
    /// <param name="type">The <see cref="System.Type"/> to test.</param>
    /// <param name="interfaceType">The interface <see cref="System.Type"/> to test.</param>
    /// <param name="genericArguments">If methods returns <c>true</c> and interface <see cref="System.Type"/> is generic, contains the generic arguments of the implemented interface.</param>
    /// <returns><c>true</c> if <see cref="System.Type"/> implements interface <see cref="System.Type"/>; otherwise, <c>false</c>.</returns>
    public static bool ImplementsInterface(this Type type, Type interfaceType, [NotNullWhen(true)] out Type[]? genericArguments)
    {
        if (!interfaceType.IsGenericType)
        {
            genericArguments = Type.EmptyTypes;
            return interfaceType.IsAssignableFrom(type);
        }

        if (type.IsGenericType && type.GetGenericTypeDefinition() == interfaceType.GetGenericTypeDefinition())
        {
            genericArguments = type.GetGenericArguments();
            return true;
        }

        foreach (var @interface in type.GetAllInterfaces())
        {
            if (@interface.IsGenericType && @interface.GetGenericTypeDefinition() == interfaceType.GetGenericTypeDefinition())
            {
                genericArguments = @interface.GetGenericArguments();
                return true;
            }
        }

        genericArguments = default;
        return false;
    }

    static IEnumerable<Type> GetAllInterfaces(this Type type)
    {
        foreach (var @interface in type.GetInterfaces())
        {
            yield return @interface;

            foreach (var baseInterface in @interface.GetAllInterfaces())
                yield return baseInterface;
        }
    }

    const BindingFlags PublicInstance =
        BindingFlags.Public | BindingFlags.Instance;

    internal static PropertyInfo? GetPublicInstanceReadProperty(this Type type, string name)
    {
        foreach (var property in type.GetProperties(PublicInstance))
        {
            if (property.Name == name && property.GetGetMethod() is not null)
                return property;
        }

        return null;
    }

    internal static MethodInfo? GetPublicInstanceMethod(this Type type, string name, params Type[] types)
        => type.GetMethod(name, PublicInstance, null, types, null);

    const BindingFlags PublicInstanceDeclaredOnly =
        BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly;
    
    internal static PropertyInfo? GetPublicInstanceDeclaredOnlyReadProperty(this Type type, string name)
        => type.GetProperties(PublicInstanceDeclaredOnly)
            .FirstOrDefault(property => property.Name == name && property.GetGetMethod() is not null);
    
    internal static MethodInfo? GetPublicInstanceDeclaredOnlyMethod(this Type type, string name, params Type[] types)
        => type.GetMethod(name, PublicInstanceDeclaredOnly, null, types, null);

    static bool IsByRefLike(this Type type)
        => type.IsByRefLike;

    public static bool IsSpanOrReadOnlySpan(this Type type)
    {
        if (type.IsGenericType)
        {
            var genericTypeDefinition = type.GetGenericTypeDefinition();
            return genericTypeDefinition == typeof(Span<>) || genericTypeDefinition == typeof(ReadOnlySpan<>);
        }

        return false;
    }
}

1	using System;
2	using System.Collections.Generic;
3	using System.Diagnostics.CodeAnalysis;
4	using System.Linq;
5	using System.Reflection;
6
7	// ReSharper disable LoopCanBeConvertedToQuery
8
9	namespace NetFabric.Reflection;
10
11	public static partial class TypeExtensions
12	{
13
14	/// <summary>
15	/// Gets a value indicating whether <see cref="System.Type"/> implements the given interface <see cref="System.Type"/>.
16	/// </summary>
17	/// <param name="type">The <see cref="System.Type"/> to test.</param>
18	/// <param name="interfaceType">The interface <see cref="System.Type"/> to test.</param>
19	/// <param name="genericArguments">If methods returns <c>true</c> and interface <see cref="System.Type"/> is generic, contains the generic arguments of the implemented interface.</param>
20	/// <returns><c>true</c> if <see cref="System.Type"/> implements interface <see cref="System.Type"/>; otherwise, <c>false</c>.</returns>
21	public static bool ImplementsInterface(this Type type, Type interfaceType, [NotNullWhen(true)] out Type[]? genericArguments)
22	{
23	if (!interfaceType.IsGenericType)	133✔
24	{
25	genericArguments = Type.EmptyTypes;	100✔
26	return interfaceType.IsAssignableFrom(type);	100✔
27	}
28
29	if (type.IsGenericType && type.GetGenericTypeDefinition() == interfaceType.GetGenericTypeDefinition())	33✔
30	{
31	genericArguments = type.GetGenericArguments();	4✔
32	return true;	4✔
33	}
34
35	foreach (var @interface in type.GetAllInterfaces())	82✔
36	{
37	if (@interface.IsGenericType && @interface.GetGenericTypeDefinition() == interfaceType.GetGenericTypeDefinition())	17✔
38	{
39	genericArguments = @interface.GetGenericArguments();	10✔
40	return true;	10✔
41	}
42	}
43
44	genericArguments = default;	19✔
45	return false;	19✔
46	}	10✔
47
48	static IEnumerable<Type> GetAllInterfaces(this Type type)
49	{
50	foreach (var @interface in type.GetInterfaces())	96✔
51	{
52	yield return @interface;	17✔
53
54	foreach (var baseInterface in @interface.GetAllInterfaces())	14!
55	yield return baseInterface;	×
56	}	7✔
57	}	26✔
58
59	const BindingFlags PublicInstance =
60	BindingFlags.Public \| BindingFlags.Instance;
61
62	internal static PropertyInfo? GetPublicInstanceReadProperty(this Type type, string name)
63	{
64	foreach (var property in type.GetProperties(PublicInstance))	243✔
65	{
66	if (property.Name == name && property.GetGetMethod() is not null)	76✔
67	return property;	71✔
68	}
69
70	return null;	10✔
71	}
72
73	internal static MethodInfo? GetPublicInstanceMethod(this Type type, string name, params Type[] types)
74	=> type.GetMethod(name, PublicInstance, null, types, null);	218✔
75
76	const BindingFlags PublicInstanceDeclaredOnly =
77	BindingFlags.Public \| BindingFlags.Instance \| BindingFlags.DeclaredOnly;
78
79	internal static PropertyInfo? GetPublicInstanceDeclaredOnlyReadProperty(this Type type, string name)
80	=> type.GetProperties(PublicInstanceDeclaredOnly)	33✔
81	.FirstOrDefault(property => property.Name == name && property.GetGetMethod() is not null);	66!
82
83	internal static MethodInfo? GetPublicInstanceDeclaredOnlyMethod(this Type type, string name, params Type[] types)
84	=> type.GetMethod(name, PublicInstanceDeclaredOnly, null, types, null);	158✔
85
86	static bool IsByRefLike(this Type type)
87	=> type.IsByRefLike;	95✔
88
89	public static bool IsSpanOrReadOnlySpan(this Type type)
90	{
91	if (type.IsGenericType)	76✔
92	{
93	var genericTypeDefinition = type.GetGenericTypeDefinition();	66✔
94	return genericTypeDefinition == typeof(Span<>) \|\| genericTypeDefinition == typeof(ReadOnlySpan<>);	66✔
95	}
96
97	return false;	10✔
98	}
99	}

NetFabric / NetFabric.CodeAnalysis / 6130084901

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous