Merge pull request #1 from carl-berg/feature/open-generics-support

Supporting open generics

.github/workflows/build-and-test.yml

@@ -0,0 +1,34 @@
+name: Build and Test
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+env:
+  DOTNET_VERSION: '7.x' # The .NET SDK version to use
+
+jobs:
+  build-and-test:
+    name: Test ${{ matrix.dotnet }} on ${{matrix.os}}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        dotnet: [ '3.1', '6.x', '7.x' ]
+        os: [windows-latest]
+
+    steps:
+    - uses: actions/checkout@v3
+    - uses: actions/setup-dotnet@v3
+      with:
+        dotnet-version: ${{ env.DOTNET_VERSION }}
+
+    - name: Install dependencies
+      run: dotnet restore
+
+    - name: Build
+      run: dotnet build --configuration Debug --no-restore
+
+    - name: Test
+      run: dotnet test --configuration Debug --no-restore --verbosity normal

.github/workflows/release.yml

@@ -0,0 +1,49 @@
+name: Release ATypeScanner
+
+on:
+  push:
+    tags: 
+    - '*'
+
+env:
+  DOTNET_VERSION: '7.x' # The .NET SDK version to use
+
+jobs:
+
+  build-and-test:
+    name: Build and test
+    runs-on: windows-latest
+    steps:
+    - uses: actions/checkout@v3
+    - uses: actions/setup-dotnet@v3
+      with:
+        dotnet-version: ${{ env.DOTNET_VERSION }}
+
+    - name: Install dependencies
+      run: dotnet restore
+
+    - name: Test
+      run: dotnet test --configuration Release --no-restore --verbosity normal
+
+  deploy:
+    name: Deploy
+    runs-on: windows-latest
+    environment: NugetDeploy
+    needs: [build-and-test]
+    steps:
+    - uses: actions/checkout@v2
+    - uses: actions/setup-dotnet@v1
+      with:
+        dotnet-version: ${{ env.DOTNET_VERSION }}
+
+    - name: Package artifact
+      run: dotnet pack ATypeScanner/ATypeScanner.csproj --configuration Release -o ${{ github.workspace }}/artifact
+
+    - name: Upload artifact
+      uses: actions/upload-artifact@v2
+      with:
+        name: ATypeScanner
+        path: ${{ github.workspace }}/artifact/**/*
+
+    - name: Publish the package to nuget.org
+      run: dotnet nuget push ${{ github.workspace }}\artifact\*.nupkg -s https://api.nuget.org/v3/index.json -k ${{ secrets.NUGET_TOKEN }}

ATypeScanner.Tests.Types/OpenTypes.cs

@@ -19,6 +19,16 @@ public class OpenClassImplementation : OpenClass<AType>
 
     }
 
+    public class GenericOpenInterfaceImplementation<T> : IOpenInterface<T> where T : AType
+    {
+
+    }
+
+    public class GenericOpenClassImplementation<T> : OpenClass<T> where T : AType
+    {
+
+    }
+
     public class AType
     {
 

ATypeScanner.Tests/ATypeScanner.Tests.csproj

@@ -1,13 +1,14 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>netcoreapp2.2</TargetFramework>
+    <TargetFramework>net7.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Shouldly" Version="3.0.2" />
-    <PackageReference Include="xunit" Version="2.4.1" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.1">
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.5.0" />
+    <PackageReference Include="Shouldly" Version="4.1.0" />
+    <PackageReference Include="xunit" Version="2.4.2" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>

ATypeScanner.Tests/TypeScannerTests.cs

@@ -12,12 +12,21 @@ public class TypeScannerTests
         public void CanResolveOpenInterfaceTypes()
         {
             var scanner = new TypeScanner(typeof(AType).Assembly);
-            var matches = scanner.FindClosingImplementationsOf(typeof(IOpenInterface<>));
+            var matches = scanner.FindClosingImplementationsOf(typeof(IOpenInterface<>)).ToList();
             matches.ShouldNotBeEmpty();
             matches.ShouldContain(p => p.ConcreteType == typeof(OpenInterfaceImplementation));
             matches.ShouldContain(p => p.ConcreteType == typeof(OpenClassImplementation));
             matches.ShouldAllBe(p => p.GenericType == typeof(IOpenInterface<AType>));
-
+        }
+
+        [Fact]
+        public void CanResolveGenericOpenTypes()
+        {
+            var scanner = new TypeScanner(typeof(AType).Assembly);
+            var matches = scanner.FindOpenImplementationsOf(typeof(IOpenInterface<>)).ToList();
+            matches.ShouldNotBeEmpty();
+            matches.ShouldContain(p => p.ConcreteType == typeof(GenericOpenInterfaceImplementation<>));
+            matches.ShouldContain(p => p.ConcreteType == typeof(GenericOpenClassImplementation<>));
         }
 
         [Fact]

ATypeScanner.sln

@@ -1,7 +1,7 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio Version 16
-VisualStudioVersion = 16.0.29123.88
+# Visual Studio Version 17
+VisualStudioVersion = 17.6.33417.168
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ATypeScanner", "ATypeScanner\ATypeScanner.csproj", "{74535BC4-A06A-48D4-BAB3-5EF10848A8B5}"
 EndProject
@@ -11,8 +11,9 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ATypeScanner.Tests.Types",
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{F7675175-60B9-46E4-90E8-82EA34DEC7DB}"
 	ProjectSection(SolutionItems) = preProject
-		azure-pipeline.yml = azure-pipeline.yml
+		.github\workflows\build-and-test.yml = .github\workflows\build-and-test.yml
 		README.md = README.md
+		.github\workflows\release.yml = .github\workflows\release.yml
 	EndProjectSection
 EndProject
 Global

ATypeScanner/ATypeScanner.csproj

@@ -2,8 +2,8 @@
 
   <PropertyGroup>
     <TargetFramework>netstandard2.0</TargetFramework>
-    <Copyright>Copyright (c) 2019 Carl Berg</Copyright>
-    <VersionPrefix>0.1.1</VersionPrefix>
+    <Copyright>Copyright (c) 2023 Carl Berg</Copyright>
+    <Version>0.2.0</Version>
     <Authors>Carl Berg</Authors>
     <Description>An appeasing light weight type scanner</Description>
     <PackageLicenseExpression>MIT</PackageLicenseExpression>

ATypeScanner/ITypeScanner.cs

@@ -6,6 +6,7 @@ namespace ATypeScanner
     public interface ITypeScanner
     {
         IEnumerable<ClosingTypeResult> FindClosingImplementationsOf(Type openType);
+        IEnumerable<ClosingTypeResult> FindOpenImplementationsOf(Type openType);
         IEnumerable<Type> FindImplementationsOf<TType>();
         IEnumerable<Type> FindImplementationsOf(Type typeToFind);
     }

ATypeScanner/TypeScanner.cs

@@ -48,6 +48,40 @@ public IEnumerable<ClosingTypeResult> FindClosingImplementationsOf(Type openType
             }
         }
 
+        /// <summary>
+        /// Returns all generic classes that implement <paramref name="openType"/>
+        /// </summary>
+        public IEnumerable<ClosingTypeResult> FindOpenImplementationsOf(Type openType)
+        {
+            foreach (var assembly in _assemblies)
+            {
+                foreach (var type in assembly.DefinedTypes)
+                {
+                    if (type.IsInterface)
+                    {
+                        continue;
+                    }
+                    else if (type.IsGenericType) 
+                    { 
+                        if (openType.IsInterface)
+                        {
+                            foreach (var @interface in type.GetInterfaces())
+                            {
+                                if (@interface.IsGenericType && openType.IsAssignableFrom(@interface.GetGenericTypeDefinition()))
+                                {
+                                    yield return new ClosingTypeResult(@interface, type.AsType());
+                                }
+                            }
+                        }
+                        else if (openType != type && MatchClassType(openType, type) is Type matchingType)
+                        {
+                            yield return new ClosingTypeResult(matchingType, type);
+                        }
+                    }
+                }
+            }
+        }
+
         /// <summary>
         /// Returns all classes that implement <typeparamref name="TType"/>
         /// </summary>