Enables type substitution by API version over an object graph. Fixes #335. Fixes #358.

Author: Chris Martinez

src/Common.OData.ApiExplorer/AspNet.OData/ClassProperty.cs

@@ -1,8 +1,5 @@
 namespace Microsoft.AspNet.OData
 {
-#if !WEBAPI
-    using Microsoft.AspNetCore.Mvc.ApiExplorer;
-#endif
     using Microsoft.OData.Edm;
     using System;
     using System.Collections.Generic;
@@ -11,21 +8,19 @@
     using System.Linq;
     using System.Reflection;
     using System.Reflection.Emit;
-#if WEBAPI
-    using System.Web.Http.Dispatcher;
-#endif
 
     struct ClassProperty
     {
         internal readonly string Name;
         internal readonly Type Type;
 
-        internal ClassProperty( PropertyInfo clrProperty )
+        internal ClassProperty( PropertyInfo clrProperty, Type propertyType )
         {
             Contract.Requires( clrProperty != null );
+            Contract.Requires( propertyType != null );
 
             Name = clrProperty.Name;
-            Type = clrProperty.PropertyType;
+            Type = propertyType;
             Attributes = AttributesFromProperty( clrProperty );
         }
 

src/Common.OData.ApiExplorer/AspNet.OData/ClassSignature.cs

@@ -12,7 +12,7 @@
 
     sealed class ClassSignature : IEquatable<ClassSignature>
     {
-        readonly int hashCode;
+        readonly Lazy<int> hashCode;
 
         internal ClassSignature( string name, IEnumerable<ClassProperty> properties, ApiVersion apiVersion )
         {
@@ -23,18 +23,7 @@ internal ClassSignature( string name, IEnumerable<ClassProperty> properties, Api
             Name = name;
             Properties = properties.ToArray();
             ApiVersion = apiVersion;
-
-            if ( Properties.Count == 0 )
-            {
-                return;
-            }
-
-            hashCode = Properties[0].GetHashCode();
-
-            for ( var i = 1; i < Properties.Count; i++ )
-            {
-                hashCode = ( hashCode * 397 ) ^ Properties[i].GetHashCode();
-            }
+            hashCode = new Lazy<int>( ComputeHashCode );
         }
 
         internal string Name { get; }
@@ -43,10 +32,27 @@ internal ClassSignature( string name, IEnumerable<ClassProperty> properties, Api
 
         internal ApiVersion ApiVersion { get; }
 
-        public override int GetHashCode() => hashCode;
+        public override int GetHashCode() => hashCode.Value;
 
         public override bool Equals( object obj ) => obj is ClassSignature s && Equals( s );
 
-        public bool Equals( ClassSignature other ) => hashCode == other?.hashCode;
+        public bool Equals( ClassSignature other ) => GetHashCode() == other?.GetHashCode();
+
+        int ComputeHashCode()
+        {
+            if ( Properties.Count == 0 )
+            {
+                return 0;
+            }
+
+            var hash = Properties[0].GetHashCode();
+
+            for ( var i = 1; i < Properties.Count; i++ )
+            {
+                hash = ( hash * 397 ) ^ Properties[i].GetHashCode();
+            }
+
+            return hash;
+        }
     }
 }

src/Common.OData.ApiExplorer/AspNet.OData/ModelTypeBuilder.cs renamed to src/Common.OData.ApiExplorer/AspNet.OData/DefaultModelTypeBuilder.cs

@@ -5,7 +5,6 @@
     using Microsoft.Web.Http;
 #else
     using Microsoft.AspNetCore.Mvc;
-    using Microsoft.AspNetCore.Mvc.ApiExplorer;
     using Microsoft.OData.Edm;
 #endif
     using System;
@@ -22,44 +21,93 @@
     using static System.Guid;
     using static System.Reflection.Emit.AssemblyBuilderAccess;
 
-    sealed class ModelTypeBuilder
+    /// <summary>
+    /// Represents the default model type builder.
+    /// </summary>
+    public sealed class DefaultModelTypeBuilder : IModelTypeBuilder
     {
-        readonly IEnumerable<Assembly> assemblies;
+        static readonly Type IEnumerableOfT = typeof( IEnumerable<> );
+        readonly ICollection<Assembly> assemblies;
         readonly ConcurrentDictionary<ApiVersion, ModuleBuilder> modules = new ConcurrentDictionary<ApiVersion, ModuleBuilder>();
         readonly ConcurrentDictionary<ClassSignature, Type> generatedTypes = new ConcurrentDictionary<ClassSignature, Type>();
 
-        internal ModelTypeBuilder( IEnumerable<Assembly> assemblies ) => this.assemblies = assemblies;
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DefaultModelTypeBuilder"/> class.
+        /// </summary>
+        /// <param name="assemblies">The <see cref="IEnumerable{T}">sequence</see> of application <see cref="Assembly">assemblies</see>.</param>
+        public DefaultModelTypeBuilder( IEnumerable<Assembly> assemblies )
+        {
+            Arg.NotNull( assemblies, nameof( assemblies ) );
+            this.assemblies = new HashSet<Assembly>( assemblies );
+        }
 
-        internal Type NewStructuredType( IEdmStructuredType structuredType, Type clrType, ApiVersion apiVersion )
+        /// <inheritdoc />
+        public Type NewStructuredType( IEdmStructuredType structuredType, Type clrType, ApiVersion apiVersion )
         {
-            Contract.Requires( structuredType != null );
-            Contract.Requires( clrType != null );
-            Contract.Requires( apiVersion != null );
+            Arg.NotNull( structuredType, nameof( structuredType ) );
+            Arg.NotNull( clrType, nameof( clrType ) );
+            Arg.NotNull( apiVersion, nameof( apiVersion ) );
             Contract.Ensures( Contract.Result<Type>() != null );
 
             const BindingFlags bindingFlags = BindingFlags.Public | BindingFlags.Instance;
 
             var properties = new List<ClassProperty>();
-            var structuralProperties = new HashSet<string>( structuredType.StructuralProperties().Select( p => p.Name ), StringComparer.OrdinalIgnoreCase );
+            var structuralProperties = structuredType.Properties().ToDictionary( p => p.Name, StringComparer.OrdinalIgnoreCase );
+            var clrTypeMatchesEdmType = true;
 
             foreach ( var property in clrType.GetProperties( bindingFlags ) )
             {
-                if ( structuralProperties.Contains( property.Name ) )
+                if ( !structuralProperties.TryGetValue( property.Name, out var structuralProperty ) )
+                {
+                    clrTypeMatchesEdmType = false;
+                    continue;
+                }
+
+                var propertyType = property.PropertyType;
+                var structuredTypeRef = structuralProperty.Type;
+
+                if ( structuredTypeRef.IsCollection() )
+                {
+                    var collectionType = structuredTypeRef.AsCollection();
+                    var elementType = collectionType.ElementType();
+
+                    if ( elementType.IsStructured() )
+                    {
+                        assemblies.Add( clrType.Assembly );
+
+                        var itemType = elementType.Definition.GetClrType( assemblies );
+                        var newItemType = NewStructuredType( elementType.ToStructuredType(), itemType, apiVersion );
+
+                        if ( !itemType.Equals( newItemType ) )
+                        {
+                            propertyType = IEnumerableOfT.MakeGenericType( newItemType );
+                        }
+                    }
+                }
+                else if ( structuredTypeRef.IsStructured() )
                 {
-                    properties.Add( new ClassProperty( property ) );
+                    propertyType = NewStructuredType( structuredTypeRef.ToStructuredType(), property.PropertyType, apiVersion );
                 }
+
+                clrTypeMatchesEdmType &= property.PropertyType.Equals( propertyType );
+                properties.Add( new ClassProperty( property, propertyType ) );
             }
 
-            var name = clrType.FullName;
-            var signature = new ClassSignature( name, properties, apiVersion );
+            if ( clrTypeMatchesEdmType )
+            {
+                return clrType;
+            }
+
+            var signature = new ClassSignature( clrType.FullName, properties, apiVersion );
 
             return generatedTypes.GetOrAdd( signature, CreateFromSignature );
         }
 
-        internal Type NewActionParameters( IEdmAction action, ApiVersion apiVersion )
+        /// <inheritdoc />
+        public Type NewActionParameters( IEdmAction action, ApiVersion apiVersion )
         {
-            Contract.Requires( action != null );
-            Contract.Requires( apiVersion != null );
+            Arg.NotNull( action, nameof( action ) );
+            Arg.NotNull( apiVersion, nameof( apiVersion ) );
             Contract.Ensures( Contract.Result<Type>() != null );
 
             var name = action.FullName() + "Parameters";

src/Common.OData.ApiExplorer/AspNet.OData/IModelTypeBuilder.cs

@@ -0,0 +1,42 @@
+namespace Microsoft.AspNet.OData
+{
+#if WEBAPI
+    using Microsoft.OData.Edm;
+    using Microsoft.Web.Http;
+#else
+    using Microsoft.AspNetCore.Mvc;
+    using Microsoft.OData.Edm;
+#endif
+    using System;
+    using System.Collections.Generic;
+
+    /// <summary>
+    /// Defines the behavior of a model type builder.
+    /// </summary>
+    public interface IModelTypeBuilder
+    {
+        /// <summary>
+        /// Creates and returns a new structured type given the specified structured type, CLR type, and API version.
+        /// </summary>
+        /// <param name="structuredType">The <see cref="IEdmStructuredType">structured type</see> to evaluate.</param>
+        /// <param name="clrType">The CLR <see cref="Type">type</see> mapped to the <paramref name="structuredType">structured type</paramref>.</param>
+        /// <param name="apiVersion">The <see cref="ApiVersion">API version</see> associated with the type mapping.</param>
+        /// <returns>The original <paramref name="clrType">CLR type</paramref> or a new, dynamically generated substitute <see cref="Type">type</see>
+        /// that is a subset of the original <paramref name="clrType">CLR type</paramref>, but maps one-to-one with the
+        /// <paramref name="structuredType">structured type</paramref>.</returns>
+        /// <remarks>If a substitution is not required, the original <paramref name="clrType">CLR type</paramref> is returned. When a substitution
+        /// <see cref="Type">type</see> is generated, it is performed only once per <paramref name="apiVersion">API version</paramref>.</remarks>
+        Type NewStructuredType( IEdmStructuredType structuredType, Type clrType, ApiVersion apiVersion );
+
+        /// <summary>
+        /// Creates an returns a stronly-typed definition for OData action parameters.
+        /// </summary>
+        /// <param name="action">The defining <see cref="IEdmAction">action</see>.</param>
+        /// <param name="apiVersion">The <see cref="ApiVersion">API version</see> of the <paramref name="action"/> to create the parameter type for.</param>
+        /// <returns>A strong <see cref="Type">type</see> definition for the OData <paramref name="action"/> parameters.</returns>
+        /// <remarks><see cref="ODataActionParameters">OData action parameters</see> are modeled as a <see cref="Dictionary{TKey,TValue}">dictionary</see>,
+        /// which is difficult to use effectively by documentation tools such as the API Explorer. The corresponding type is generated only once per
+        /// <paramref name="apiVersion">API version</paramref>.</remarks>
+        Type NewActionParameters( IEdmAction action, ApiVersion apiVersion );
+    }
+}

src/Common.OData.ApiExplorer/AspNet.OData/StructuredTypeResolver.cs

@@ -0,0 +1,39 @@
+namespace Microsoft.AspNet.OData
+{
+    using Microsoft.OData.Edm;
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics.Contracts;
+    using System.Linq;
+    using System.Reflection;
+
+    sealed class StructuredTypeResolver
+    {
+        readonly IEdmModel model;
+        readonly HashSet<Assembly> assemblies;
+
+        internal StructuredTypeResolver( IEdmModel model, IEnumerable<Assembly> assemblies )
+        {
+            Contract.Requires( model != null );
+            Contract.Requires( assemblies != null );
+
+            this.model = model;
+            this.assemblies = new HashSet<Assembly>( assemblies );
+        }
+
+        internal IEdmStructuredType GetStructuredType( Type type )
+        {
+            Contract.Requires( type != null );
+
+            var structuredTypes = model.SchemaElements.OfType<IEdmStructuredType>();
+            var structuredType = structuredTypes.FirstOrDefault( t => type.Equals( t.GetClrType( assemblies ) ) );
+
+            if ( structuredType == null && assemblies.Add( type.Assembly ) )
+            {
+                structuredType = structuredTypes.FirstOrDefault( t => type.Equals( t.GetClrType( assemblies ) ) );
+            }
+
+            return structuredType;
+        }
+    }
+}