change to lazy loading for the validation visitors

Author: xuzhg

src/Microsoft.OpenApi/Validations/Visitors/OpenApiVisitorSet.cs

@@ -3,9 +3,11 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using Microsoft.OpenApi.Exceptions;
 using Microsoft.OpenApi.Models;
 using Microsoft.OpenApi.Properties;
+using Microsoft.OpenApi.Interfaces;
 
 namespace Microsoft.OpenApi.Validations.Visitors
 {
@@ -14,39 +16,23 @@ namespace Microsoft.OpenApi.Validations.Visitors
     /// </summary>
     internal static class OpenApiVisitorSet
     {
-        private static IDictionary<Type, IVisitor> _visitorCache = new Dictionary<Type, IVisitor>
+        private static IDictionary<Type, IVisitor> _visitors;
+
+        /// <summary>
+        /// Gets the visitors
+        /// </summary>
+        public static IDictionary<Type, IVisitor> Visitors
         {
-            { typeof(OpenApiCallback), new CallbackVisitor() },
-            { typeof(OpenApiComponents), new ComponentsVisitor() },
-            { typeof(OpenApiContact), new ContactVisitor() },
-            { typeof(OpenApiDiscriminator), new DiscriminatorVisitor() },
-            { typeof(OpenApiDocument), new DocumentVisitor() },
-            { typeof(OpenApiEncoding), new EncodingVisitor() },
-            { typeof(OpenApiExample), new ExampleVisitor() },
-            { typeof(OpenApiExternalDocs), new ExternalDocsVisitor() },
-            { typeof(OpenApiHeader), new HeaderVisitor() },
-            { typeof(OpenApiInfo), new InfoVisitor() },
-            { typeof(OpenApiLicense), new LicenseVisitor() },
-            { typeof(OpenApiLink), new LinkVisitor() },
-            { typeof(OpenApiMediaType), new MediaTypeVisitor() },
-            { typeof(OpenApiOAuthFlows), new OAuthFlowsVisitor() },
-            { typeof(OpenApiOAuthFlow), new OAuthFlowVisitor() },
-            { typeof(OpenApiOperation), new OperationVisitor() },
-            { typeof(OpenApiParameter), new ParameterVisitor() },
-            { typeof(OpenApiPathItem), new PathItemVisitor() },
-            { typeof(OpenApiPaths), new PathsVisitor() },
-            { typeof(OpenApiRequestBody), new RequestBodyVisitor() },
-            { typeof(OpenApiResponses), new ResponsesVisitor() },
-            { typeof(OpenApiResponse), new ResponseVisitor() },
-            { typeof(OpenApiSchema), new SchemaVisitor() },
-            { typeof(OpenApiSecurityRequirement), new SecurityRequirementVisitor() },
-            { typeof(OpenApiSecurityScheme), new SecuritySchemeVisitor() },
-            { typeof(OpenApiServerVariable), new ServerVariableVisitor() },
-            { typeof(OpenApiServer), new ServerVisitor() },
-            { typeof(OpenApiTag), new TagVisitor() },
-            { typeof(OpenApiXml), new XmlVisitor() }
-        };
+            get
+            {
+                if (_visitors == null)
+                {
+                    _visitors = new Lazy<IDictionary<Type, IVisitor>>(() => BuildVisitorSet(), isThreadSafe: false).Value;
+                }
 
+                return _visitors;
+            }
+        }
         /// <summary>
         /// Get the element visitor.
         /// </summary>
@@ -55,12 +41,51 @@ internal static class OpenApiVisitorSet
         public static IVisitor GetVisitor(Type elementType)
         {
             IVisitor visitor;
-            if (_visitorCache.TryGetValue(elementType, out visitor))
+            if (Visitors.TryGetValue(elementType, out visitor))
             {
                 return visitor;
             }
 
             throw new OpenApiException(String.Format(SRResource.UnknownVisitorType, elementType.FullName));
         }
+
+        private static IDictionary<Type, IVisitor> BuildVisitorSet()
+        {
+            IDictionary<Type, IVisitor> visitors = new Dictionary<Type, IVisitor>();
+
+            IEnumerable<Type> allTypes = typeof(OpenApiVisitorSet).Assembly.GetTypes().Where(t => t.IsClass && !t.IsAbstract && t != typeof(object));
+
+            Type visitorInterfaceType = typeof(IVisitor);
+            Type elementType = typeof(IOpenApiElement);
+            foreach (Type type in allTypes)
+            {
+                if (!visitorInterfaceType.IsAssignableFrom(type))
+                {
+                    continue;
+                }
+
+                Type baseType = type.BaseType;
+                if (baseType == null || !baseType.IsGenericType ||
+                    baseType.GetGenericTypeDefinition() != typeof(VisitorBase<>))
+                {
+                    continue;
+                }
+
+                Type validationType = baseType.GetGenericArguments()[0];
+                if (!elementType.IsAssignableFrom(validationType))
+                {
+                    continue;
+                }
+
+                object instance = Activator.CreateInstance(type);
+                IVisitor visitor = instance as IVisitor;
+                if (visitor != null)
+                {
+                    visitors[validationType] = visitor;
+                }
+            }
+
+            return visitors;
+        }
     }
 }

test/Microsoft.OpenApi.Tests/Validations/Visitors/OpenApiVisitorSetTests.cs

@@ -0,0 +1,55 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+using System;
+using Microsoft.OpenApi.Exceptions;
+using Microsoft.OpenApi.Models;
+using Xunit;
+
+namespace Microsoft.OpenApi.Validations.Visitors.Tests
+{
+    public class OpenApiVisitorSetTests
+    {
+        [Fact]
+        public void VisitorsPropertyReturnsTheCorrectVisitorList()
+        {
+            for (int i = 0; i < 5; i++) // 5 is just a magic number
+            {
+                // Arrange & Act
+                var visitors = OpenApiVisitorSet.Visitors;
+
+                // Assert
+                Assert.NotNull(visitors);
+                Assert.NotEmpty(visitors);
+                Assert.Equal(29, visitors.Count);
+            }
+        }
+
+        [Fact]
+        public void GetVisitorThrowsUnknowElementType()
+        {
+            // Arrange & Act
+            Action test = () => OpenApiVisitorSet.GetVisitor(typeof(OpenApiVisitorSetTests));
+
+            // Assert
+            var exception = Assert.Throws<OpenApiException>(test);
+            Assert.Equal("Can not find visitor type registered for type 'Microsoft.OpenApi.Validations.Visitors.Tests.OpenApiVisitorSetTests'.",
+                exception.Message);
+        }
+
+        [Theory]
+        [InlineData(typeof(OpenApiDocument), typeof(DocumentVisitor))]
+        [InlineData(typeof(OpenApiInfo), typeof(InfoVisitor))]
+        [InlineData(typeof(OpenApiXml), typeof(XmlVisitor))]
+        [InlineData(typeof(OpenApiComponents), typeof(ComponentsVisitor))]
+        public void GetVisitorReturnsTheCorrectVisitor(Type elementType, Type visitorType)
+        {
+            // Arrange & Act
+            var visitor = OpenApiVisitorSet.GetVisitor(elementType);
+
+            // Assert
+            Assert.NotNull(visitor);
+            Assert.Same(visitorType, visitor.GetType());
+        }
+    }
+}