As far as I can see not possible to mix types in Values{T1,....Tn}

[AndreSteenbergen]

I am trying to make a parser from html microdata to Schema.Net. As far as I can see now, I can only use 1 type in Values with more then 1 generic argument.

e.g. I would like to be able to parse an image using url, but somewhere later in the document I would like to add ImageObject type, because the creator of the html page made a differnce in types of images.

[RehanSaeed]

That's an interesting problem. The only way I think this can be implemented is if we also added List<object> to the Values<T> type. We'd need to do some investigation on what this would mean. I'd be willing to accept a PR for this.

[AndreSteenbergen]

Let me first say: the tool to generate classes is awesome.

I do have a solution ready right now, but it is a breaking change. I removed the values {T1,..Tn} and replaced them with a wrapper. I'll be working on it again this evening. The Values object is still strong typed this way, with reverting back to an object array. I'll try and see if I can create a pull request this evening. I also added ItemList to Thing in the partial, as I found a lot of sites are not really correct about there microdata, trying to put Product entiteis directly under Webpage entities for eaxmple. It is something I added so the parser would still return those child objects.

I basically created the following construct for all multityped stuff:

    public interface IIdentifier : IWrapper { }
    public interface IIdentifier<T> : IIdentifier { new T Data { get; set; } }
    public class IdentifierPropertyValue : IIdentifier<PropertyValue>
    {
        object IWrapper.Data { get { return Data; } set { Data = (PropertyValue) value; } }
        public virtual PropertyValue Data { get; set; }
        public IdentifierPropertyValue () { }
        public IdentifierPropertyValue (PropertyValue data) { Data = data; }
        public static implicit operator IdentifierPropertyValue (PropertyValue data) { return new IdentifierPropertyValue (data); }
    }

    public class Identifierstring : IIdentifier<string>
    {
        object IWrapper.Data { get { return Data; } set { Data = (string) value; } }
        public virtual string Data { get; set; }
        public Identifierstring () { }
        public Identifierstring (string data) { Data = data; }
        public static implicit operator Identifierstring (string data) { return new Identifierstring (data); }
    }

    /// <summary>
    /// The identifier property represents any kind of identifier for any kind of &lt;a class="localLink" href="http://schema.org/Thing"&gt;Thing&lt;/a&gt;, such as ISBNs, GTIN codes, UUIDs etc. Schema.org provides dedicated properties for representing many of these, either as textual strings or as URL (URI) links. See &lt;a href="/docs/datamodel.html#identifierBg"&gt;background notes&lt;/a&gt; for more details.
    /// </summary>
    [DataMember(Name = "identifier", Order = 11)]
    [JsonConverter(typeof(ValuesConverter))]
    public Values<IIdentifier>? Identifier { get; set; } //PropertyValue, string, Uri

I needed to change the jsonconverters quite a lot, and I haven't fully tested it. For the use cases I am working on it does work.

The changes for using the library is the following. Instead of a simple list. You will need to specify the type yourself, for every item. Example

        var webpage = new WebPage
        {
            Name = "TestSite",
            ItemList = new List<Thing> {
                new PriceSpecification
                {
                    MaxPrice = new List<decimal> { 23.45m, 12.35m }
                },
                new Product
                {
                    Offers = new Offer
                    {
                        Price = new List<Offer.IPrice> {
                                        (Offer.Pricedecimal)23.45m,
                                        (Offer.Pricedecimal)12.35m
                                    },
                        PriceCurrency = "EUR"
                    },
                    Name = "test product",
                    Brand = new List<Product.IBrand> {
                        (Product.BrandBrand)new Brand { Name = "Volvo" },
                        (Product.BrandOrganization) new Organization { Name = "Geely" },
                    }
                }
            }
        };

[RehanSaeed]

I have a gut feeling that there is something clever we can do with the Values types. I think we should investigate that before we go down the path of an additional class. Maybe something like this:

Desired Usage

This is still strongly typed and we don't have List<object> anywhere which will mean lots more boxing and unboxing.

public class Foo
{
    public Values<string, int> Bar { get; set; }
}

var foo = new Foo();
foo.Bar = new Values<string, int>(new List<string>() { "1" }, new List<int>() { 2 });

Psuedocode Implementation

As far as I can see, this would just mean adding a new constructor to each Values<T1...TN> type but also changing the Value property on it such that this:

public object Value
{
    get
    {
        if (this.values1.HasValue)
        {
            return this.values1.Value;
        }
        else if (this.values2.HasValue)
        {
            return this.values2.Value;
        }

        return null;
    }
}

Changes into this:

public object Value
{
    get
    {
        if (this.values1.HasValue && this.values2.HasValue)
        {
            // return a List<object> of values1.Value items concatenated with values2.Value items.
        }
        if (this.values1.HasValue)
        {
            return this.values1.Value;
        }
        else if (this.values2.HasValue)
        {
            return this.values2.Value;
        }

        return null;
    }
}

I have not thought through the changes this would require to the serializer for read and write operations.

[RehanSaeed]

This is a great issue by the way, I can't believe I didn't think that somebody might want to do this. I wonder what happens when we try to deserialize JSON-LD with a mix of stuff in it? Have you tested that?

It hurts my brain coming back to this code. I can kind of get where you are going with your code but a sample would make it easier to understand.

[AndreSteenbergen]

As far as I have tested, I can go back and fourth between json+ld and c# classes.

Problem with making multiple arrays of values is you loose original order, which I don't want. That's the whole idea behind the Interface.

I actually added this my test case in the comments. with BrandBrand and BrandOrganization. It results in this json+ld.

{"@context":"http://schema.org","@type":"WebPage","name":"TestSite","itemlist":[{"@type":"PriceSpecification","maxPrice":[23.45,12.35]},{"@type":"Product","name":"test product","brand":[{"@type":"Brand","name":"Volvo"},{"@type":"Organization","name":"Geely"}],"offers":{"@type":"Offer","price":[23.45,12.35],"priceCurrency":"EUR"}}]}

[AndreSteenbergen]

Changing second price to pricestring end up in json+ld as following:

{"@context":"http://schema.org","@type":"WebPage","name":"TestSite","itemlist":[{"@type":"PriceSpecification","maxPrice":[23.45,12.35]},{"@type":"Product","name":"test product","brand":[{"@type":"Brand","name":"Volvo"},{"@type":"Organization","name":"Geely"}],"offers":{"@type":"Offer","price":[23.45,"EUR 1234,99"],"priceCurrency":"EUR"}}]}

[AndreSteenbergen]

My simple test case

         var jsonLd = webpage.ToString();
        
        //now convert back
        var thing = JsonConvert.DeserializeObject<Thing>(jsonLd);
        Assert.NotNull(thing);
        Assert.IsType<WebPage>(thing);

        WebPage testObject = (WebPage)thing;
        Assert.Equal(testObject.Name.Value.Value, webpage.Name.Value.Value);
        Assert.Equal(testObject.ItemList.Value.List.Count, webpage.ItemList.Value.List.Count);
        Assert.Equal(testObject.ItemList.Value.List[1].Name.Value.Value, webpage.ItemList.Value.List[1].Name.Value.Value);

        var jsonLd2 = testObject.ToString();
        Assert.Equal(jsonLd2, jsonLd);

[RehanSaeed]

I tried your JSON with the current version of Schema.NET and it doesn't handle this scenario very well. The object gets deserialized to a Thing with null properties.

I hadn't thought about the ordering at all. I'm starting to get the code in your initial comment. That will mean a lot of extra classes generated by the tool. Is it possible to use a generic wrapper class so we don't need lots of type specific wrapper classes? Something like:

namespace Schema.NET
{
    public interface IValue
    {
        object Value { get; set; }
    }

    public interface IValues<T1, T2> : IValue
    {
        T1 Value1 { get; set; }

        T2 Value2 { get; set; }
    }

    public class Values<T1, T2> : IValues<T1, T2>
    {
        public T1 Value1 { get; set; }

        public T2 Value2 { get; set; }

        object IValue.Value
        {
            get => default(T1).Equals(this.Value1) ? (object)this.Value2 : this.Value1;
            set
            {
                if (value is T1 value1)
                {
                    this.Value1 = value1;
                }
                else if (value is T2 value2)
                {
                    this.Value2 = value2;
                }
            }
        }

        public Values() { }

        public Values(T1 value) { this.Value1 = value; }

        public Values(T2 value) { this.Value2 = value; }

        public static implicit operator Values<T1, T2>(T1 value) { return new Values<T1, T2>(value); }

        public static implicit operator Values<T1, T2>(T2 value) { return new Values<T1, T2>(value); }
    }
}

So usage becomes:

public Values<Values<string, Address>> Address { get; set; }

This effectively reverses the relationship between Values<T> and the Values<T1,T2...TN> types. Does this work? I'm just thinking out loud here.

[AndreSteenbergen]

I think that might even work, I haven't tried that way. I am worried about the default(T1) part. What if I define a value to be int 0, it would try and return T2, but that's only minor thing. I think I would add a return function property if T1 is set it would be () => value1;

public class Values<T1, T2> : IValues<T1, T2>
{
    public T1 Value1 { get; private set; }
    public T2 Value2 { get; private set; }
    private Func<object> returnFunc = () => null;

    object IValue.Value
    {
        get => this.returnFunc();
        set
        {
            if (value is T1 value1)
            {
                this.returnFunc = () => value1;
                this.Value1 = value1;
            }
            else if (value is T2 value2)
            {
                this.returnFunc = () => value2;
                this.Value2 = value2;
            }
        }
    }

    public Values() { }

    public Values(T1 value) { this.Value = value; }

    public Values(T2 value) { this.Value = value; }

    public static implicit operator Values<T1, T2>(T1 value) { return new Values<T1, T2>(value); }

    public static implicit operator Values<T1, T2>(T2 value) { return new Values<T1, T2>(value); }
}

[AndreSteenbergen]

humm no real need for T1 or T2 as properties, just add an object, no need from strong typed result this way.
just set an extra property value, and return that ...

[AndreSteenbergen]

public class Values<T1, T2> : IValues<T1, T2>
{
    private object value;

    object IValue.Value
    {
        get => value;
        set 
        {
            if (value is T1 value1)
            {
                this.value = value1;
            }
            else if (value is T2 value2)
            {
                this.value = value2;
            }
            throw new ArgumentException();
        }
    }

    public Values() { }

    public Values(T1 value) { this.Value = value; }

    public Values(T2 value) { this.Value = value; }

    public static implicit operator Values<T1, T2>(T1 value) { return new Values<T1, T2>(value); }

    public static implicit operator Values<T1, T2>(T2 value) { return new Values<T1, T2>(value); }
}

[RehanSaeed]

We never define int, we always use nullable types. I think that’s right anyway.

Also, we should keep it open so people can use property initializer syntax and/or use constructors (I know this cleaner in some senses). If we do this we should set Value1 to default(T1) when Value2 is set.

[RehanSaeed]

I think the ArgumentException is unnecessary as the code can never get to that point.