Add TrySetValue and TryGetValue

Author: Turnerj

Source/Common/JsonLdObject.cs

@@ -1,6 +1,7 @@
 namespace Schema.NET
 {
     using System;
+    using System.Collections.Generic;
     using System.Runtime.Serialization;
     using Newtonsoft.Json;
 
@@ -45,6 +46,27 @@ public class JsonLdObject : IEquatable<JsonLdObject>
         [DataMember(Name = "@id", Order = 2)]
         public virtual Uri? Id { get; set; }
 
+        /// <summary>
+        /// Attempts to set the Schema.org <paramref name="property"/> on the current object with the specified <paramref name="value"/>.
+        /// </summary>
+        /// <param name="property">The property to set the value on.</param>
+        /// <param name="value">The value to set on the property</param>
+        /// <returns><see langword="true"/> when the value has successfully been set; otherwise, <see langword="false"/>.</returns>
+        public virtual bool TrySetValue(string property, IEnumerable<object> value) => false;
+
+        /// <summary>
+        /// Attempts to retrieve the <typeparamref name="TValue"/> from <paramref name="property"/>.
+        /// </summary>
+        /// <typeparam name="TValue">The type of value you want to retrieve.</typeparam>
+        /// <param name="property">The property to get the value from.</param>
+        /// <param name="result">The value on the property.</param>
+        /// <returns><see langword="true"/> when the value has successfully been retrieved; otherwise, <see langword="false"/>.</returns>
+        public virtual bool TryGetValue<TValue>(string property, out OneOrMany<TValue> result)
+        {
+            result = default;
+            return false;
+        }
+
         /// <inheritdoc/>
         public bool Equals(JsonLdObject? other)
         {

Tests/Schema.NET.Test/ThingTest.cs

@@ -199,6 +199,88 @@ public void ToStringWithNullAssignedProperty_ReturnsExpectedJsonLd()
             Assert.Equal(expectedJson, thing.ToString());
         }
 
+        [Fact]
+        public void TrySetValue_ValidProperty()
+        {
+            var thing = new Thing();
+
+            Assert.True(thing.TrySetValue("Name", new[] { "TestName" }));
+            Assert.Equal("TestName", thing.Name);
+        }
+
+        [Fact]
+        public void TrySetValue_InvalidProperty()
+        {
+            var thing = new Thing();
+
+            Assert.False(thing.TrySetValue("InvalidName", new[] { "TestName" }));
+        }
+
+        [Fact]
+        public void TrySetValue_CaseInsensitive()
+        {
+            var thing = new Thing();
+
+            Assert.True(thing.TrySetValue("name", new[] { "TestName" }));
+            Assert.Equal("TestName", thing.Name);
+        }
+
+        [Fact]
+        public void TryGetValue_ValidProperty_OneOrMany()
+        {
+            var thing = new Thing
+            {
+                Name = "TestName",
+            };
+
+            Assert.True(thing.TryGetValue<string>("Name", out var result));
+            Assert.Equal("TestName", result);
+        }
+
+        [Fact]
+        public void TryGetValue_ValidProperty_Values()
+        {
+            var thing = new Thing
+            {
+                Identifier = new Uri("https://example.org/test-identifier"),
+            };
+
+            Assert.True(thing.TryGetValue<Uri>("Identifier", out var result));
+            var identifier = Assert.Single(result);
+            Assert.Equal(new Uri("https://example.org/test-identifier"), identifier);
+        }
+
+        [Fact]
+        public void TryGetValue_InvalidProperty_InvalidName()
+        {
+            var thing = new Thing();
+
+            Assert.False(thing.TryGetValue<string>("InvalidName", out _));
+        }
+
+        [Fact]
+        public void TryGetValue_InvalidProperty_InvalidType()
+        {
+            var thing = new Thing
+            {
+                Name = "TestName",
+            };
+
+            Assert.False(thing.TryGetValue<Uri>("Name", out _));
+        }
+
+        [Fact]
+        public void TryGetValue_CaseInsensitive()
+        {
+            var thing = new Thing
+            {
+                Name = "TestName",
+            };
+
+            Assert.True(thing.TryGetValue<string>("name", out var result));
+            Assert.Equal("TestName", result);
+        }
+
         private static void CompareEqual<T>(T a, T? b)
         {
             Assert.NotNull(a);

Tools/Schema.NET.Tool/GeneratorModels/GeneratorSchemaProperty.cs

@@ -28,11 +28,13 @@ public GeneratorSchemaProperty(GeneratorSchemaClass @class, string jsonName, str
 
         public ICollection<GeneratorSchemaPropertyType> Types { get; } = new List<GeneratorSchemaPropertyType>();
 
+        public IEnumerable<string> CSharpTypes => this.Types.SelectMany(x => x.CSharpTypeStrings);
+
         public string PropertyTypeString
         {
             get
             {
-                var propertyTypes = this.Types.SelectMany(x => x.CSharpTypeStrings).ToArray();
+                var propertyTypes = this.CSharpTypes.ToArray();
                 var propertyTypesString = string.Join(", ", propertyTypes);
                 if (propertyTypes.Length == 1)
                 {

Tools/Schema.NET.Tool/SchemaSourceGenerator.cs

@@ -93,6 +93,7 @@ private static string RenderClass(GeneratorSchemaClass schemaClass)
 $@"namespace Schema.NET
 {{
     using System;
+    using System.Collections.Generic;
     using System.Runtime.Serialization;
     using Newtonsoft.Json;
 
@@ -126,6 +127,58 @@ public partial interface I{schemaClass.Name}{interfaceImplements}
         [JsonConverter(typeof({property.JsonConverterType}))]
         public{GetAccessModifier(property)} {property.PropertyTypeString} {property.Name} {{ get; set; }}")}
 
+        /// <inheritdoc/>
+        public override bool TrySetValue(string property, IEnumerable<object> value)
+        {{
+            if (string.IsNullOrWhiteSpace(property))
+            {{
+                return false;
+            }}
+
+            var success = false;
+            {SourceUtility.RenderItems(allProperties, property => $@"if (""{property.Name}"".Equals(property, StringComparison.OrdinalIgnoreCase))
+            {{
+                this.{property.Name} = new(value);
+                success = true;
+            }}
+            else ")}
+            {{
+                success = base.TrySetValue(property, value);
+            }}
+
+            return success;
+        }}
+
+        /// <inheritdoc/>
+        public override bool TryGetValue<TValue>(string property, out OneOrMany<TValue> result)
+        {{
+            if (string.IsNullOrWhiteSpace(property))
+            {{
+                result = default;
+                return false;
+            }}
+
+            var success = false;
+            {SourceUtility.RenderItems(allProperties, property => $@"if (""{property.Name}"".Equals(property, StringComparison.OrdinalIgnoreCase))
+            {{
+                {SourceUtility.RenderItems(property.CSharpTypes, (propertyType, index) => $@"if (typeof({propertyType}) == typeof(TValue))
+                {{
+                    result = (OneOrMany<TValue>)(IValues)this.{property.Name}{(property.CSharpTypes.Count() > 1 ? $".Value{index + 1}" : string.Empty)};
+                    success = true;
+                }}
+                else ")}
+                {{
+                    result = default;
+                }}
+            }}
+            else ")}
+            {{
+                success = base.TryGetValue(property, out result);
+            }}
+
+            return success;
+        }}
+
         /// <inheritdoc/>
         public bool Equals({schemaClass.Name} other)
         {{

Tools/Schema.NET.Tool/SourceUtility.cs

@@ -42,6 +42,29 @@ public static string RenderItems<T>(IEnumerable<T> items, Func<T, string> action
             return stringBuilder.ToString();
         }
 
+        public static string RenderItems<T>(IEnumerable<T> items, Func<T, int, string> action)
+        {
+            if (items is null)
+            {
+                throw new ArgumentNullException(nameof(items));
+            }
+
+            if (action is null)
+            {
+                throw new ArgumentNullException(nameof(action));
+            }
+
+            var stringBuilder = new StringBuilder();
+            var i = 0;
+            foreach (var item in items)
+            {
+                stringBuilder.Append(action(item, i));
+                i++;
+            }
+
+            return stringBuilder.ToString();
+        }
+
         public static string RenderDoc(int indent, string? text)
         {
             if (text == null)