Modified how DataViewTypes are registered

src/Microsoft.ML.Data/Data/DataViewTypeManager.cs

@@ -53,6 +53,8 @@ public static class DataViewTypeManager
         /// </summary>
         internal static DataViewType GetDataViewType(Type type, IEnumerable<Attribute> typeAttributes = null)
         {
+            //Filter attributes as we only care about DataViewTypeAttributes
+            typeAttributes = typeAttributes == null ? typeAttributes : typeAttributes.Where(attr => attr.GetType().IsSubclassOf(typeof(DataViewTypeAttribute)));
             lock (_lock)
             {
                 // Compute the ID of type with extra attributes.
@@ -73,6 +75,8 @@ internal static DataViewType GetDataViewType(Type type, IEnumerable<Attribute> t
         /// </summary>
         internal static bool Knows(Type type, IEnumerable<Attribute> typeAttributes = null)
         {
+            //Filter attributes as we only care about DataViewTypeAttributes
+            typeAttributes = typeAttributes == null ? typeAttributes : typeAttributes.Where(attr => attr.GetType().IsSubclassOf(typeof(DataViewTypeAttribute)));
             lock (_lock)
             {
                 // Compute the ID of type with extra attributes.
@@ -113,6 +117,16 @@ internal static bool Knows(DataViewType dataViewType)
         /// <param name="typeAttributes">The <see cref="Attribute"/>s attached to <paramref name="type"/>.</param>
         public static void Register(DataViewType dataViewType, Type type, IEnumerable<Attribute> typeAttributes = null)
         {
+            if (typeAttributes != null)
+            {
+                foreach (var attr in typeAttributes)
+                {
+                    if (!attr.GetType().IsSubclassOf(typeof(DataViewTypeAttribute)))
+                    {
+                        throw Contracts.ExceptParam(nameof(type), $"Type {type} has an attribute that is not of DataViewTypeAttribute.");
+                    }
+                }
+            }
             lock (_lock)
             {
                 if (_bannedRawTypes.Contains(type))

test/Microsoft.ML.Core.Tests/UnitTests/TestCustomTypeRegister.cs

@@ -271,11 +271,26 @@ public void TestTypeManager()
             DataViewTypeManager.Register(e, typeof(AlienBody), new[] { f });
             Assert.True(DataViewTypeManager.Knows(e));
             Assert.True(DataViewTypeManager.Knows(typeof(AlienBody), new[] { f }));
-            Assert.True(DataViewTypeManager.Knows(typeof(AlienBody), new[] { f }));
             // "e" is associated with typeof(AlienBody) with "f," so the call below should return true.
             Assert.Equal(e, DataViewTypeManager.GetDataViewType(typeof(AlienBody), new[] { f }));
             // "a" is associated with typeof(AlienBody) without any attribute, so the call below should return false.
             Assert.NotEqual(a, DataViewTypeManager.GetDataViewType(typeof(AlienBody), new[] { f }));
         }
+
+        [Fact]
+        public void RegisterTypeWithAdditionalAttributes()
+        {
+            var a = new DataViewAlienBodyType(7788);
+            var b = new AlienTypeAttributeAttribute(8877);
+            var c = new ColumnNameAttribute("SomeName");
+
+            Assert.Throws<ArgumentOutOfRangeException>(() => DataViewTypeManager.Register(a, typeof(AlienBody), new Attribute[] { b, c }));
+
+            DataViewTypeManager.Register(a, typeof(AlienBody), new Attribute[] { b });
+            Assert.True(DataViewTypeManager.Knows(a));
+            Assert.True(DataViewTypeManager.Knows(typeof(AlienBody), new Attribute[] { b, c }));
+            // "a" is associated with typeof(AlienBody) with "b," so the call below should return true.
+            Assert.Equal(a, DataViewTypeManager.GetDataViewType(typeof(AlienBody), new Attribute[] { b, c }));
+        }
     }
 }

test/Microsoft.ML.Tests/OnnxSequenceTypeWithAttributesTest.cs

@@ -0,0 +1,67 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Generic;
+using System.Drawing;
+using Microsoft.ML.Data;
+using Microsoft.ML.RunTests;
+using Microsoft.ML.Transforms.Image;
+using Microsoft.ML.Transforms.Onnx;
+using Xunit;
+using Xunit.Abstractions;
+using System.Linq;
+using System.IO;
+
+namespace Microsoft.ML.Tests
+{
+    public class OnnxSequenceTypeWithAttributesTest : BaseTestBaseline
+    {
+        public class OutputObj
+        {
+            [ColumnName("output")]
+            [OnnxSequenceType(typeof(IDictionary<string, float>))]
+            public IEnumerable<IDictionary<string, float>> Output;
+        }
+        public class FloatInput
+        {
+            [ColumnName("input")]
+            [VectorType(3)]
+            public float[] Input { get; set; }
+        }
+
+        public OnnxSequenceTypeWithAttributesTest(ITestOutputHelper output) : base(output)
+        {
+        }
+        public static PredictionEngine<FloatInput, OutputObj> LoadModel(string onnxModelFilePath)
+        {
+            var ctx = new MLContext();
+            var dataView = ctx.Data.LoadFromEnumerable(new List<FloatInput>());
+
+            var pipeline = ctx.Transforms.ApplyOnnxModel(
+                                modelFile: onnxModelFilePath,
+                                outputColumnNames: new[] { "output" }, inputColumnNames: new[] { "input" });
+
+            var model = pipeline.Fit(dataView);
+            return ctx.Model.CreatePredictionEngine<FloatInput, OutputObj>(model);
+        }
+
+        [Fact]
+        public void OnnxSequenceTypeWithColumnNameAttributeTest()
+        {
+            var modelFile = @"zipmap/TestZipMapString.onnx";
+            var predictor = LoadModel(modelFile);
+
+            FloatInput input = new FloatInput() { Input = new float[] { 1.0f, 2.0f, 3.0f } };
+            var output = predictor.Predict(input);
+            var onnx_out = output.Output.FirstOrDefault();
+            Assert.True(onnx_out.Count == 3, "Output missing data.");
+            var keys = new List<string>(onnx_out.Keys);
+            for(var i =0; i < onnx_out.Count; ++i)
+            {
+                Assert.Equal(onnx_out[keys[i]], input.Input[i]);
+            }
+
+        }
+    }
+}