Updated to new version with improved inheritance and extensibility for non-generic interfaces.

electricessence · electricessence · commit 79a26540649e · 2020-01-08T17:48:48.000-08:00
diff --git a/Open.Serialization.Json/IJsonSerializeObject.cs b/Open.Serialization.Json/IJsonSerializeObject.cs
@@ -0,0 +1,6 @@
+﻿namespace Open.Serialization.Json
+{
+	interface IJsonSerializeObject : ISerializeObject
+	{
+	}
+}
diff --git a/Open.Serialization.Json/Open.Serialization.Json.csproj b/Open.Serialization.Json/Open.Serialization.Json.csproj
@@ -26,7 +26,7 @@
 	    <PrivateAssets>all</PrivateAssets>
 	    <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
 	  </PackageReference>
-	  <PackageReference Include="Open.Serialization" Version="1.4.0" />
+	  <PackageReference Include="Open.Serialization" Version="1.5.0" />
 	</ItemGroup>
 
 </Project>
diff --git a/Open.Serialization/IDeserialize.cs b/Open.Serialization/IDeserialize.cs
@@ -1,12 +1,28 @@
 ﻿namespace Open.Serialization
 {
+	/// <summary>
+	/// Interface for deserializing any given generic type.
+	/// </summary>
 	public interface IDeserialize
 	{
+		/// <summary>
+		/// Deserializes a string value to the specified type.
+		/// </summary>
+		/// <param name="value">The string to deserialize.</param>
+		/// <returns>The deserialized result.</returns>
 		T Deserialize<T>(string? value);
 	}
 
+	/// <summary>
+	/// Interface for deserializing a predefined specific generic type.
+	/// </summary>
 	public interface IDeserialize<out T>
 	{
+		/// <summary>
+		/// Deserializes a string value to the specified type.
+		/// </summary>
+		/// <param name="value">The string to deserialize.</param>
+		/// <returns>The deserialized result.</returns>
 		T Deserialize(string? value);
 	}
 }
diff --git a/Open.Serialization/IDeserializeAsync.cs b/Open.Serialization/IDeserializeAsync.cs
@@ -4,13 +4,31 @@
 
 namespace Open.Serialization
 {
+	/// <summary>
+	/// Interface for asynchronously deserializing any given generic type.
+	/// </summary>
 	public interface IDeserializeAsync
 	{
-		ValueTask<T> DeserializeAsync<T>(Stream stream, CancellationToken cancellationToken = default);
+		/// <summary>
+		/// Deserializes a stream to the specified type.
+		/// </summary>
+		/// <param name="source">The stream to deserialize.</param>
+		/// <param name="cancellationToken">An optional cancellation token.</param>
+		/// <returns>The deserialized result.</returns>
+		ValueTask<T> DeserializeAsync<T>(Stream source, CancellationToken cancellationToken = default);
 	}
 
+	/// <summary>
+	/// Interface for asynchronously deserializing a predefined specific generic type.
+	/// </summary>
 	public interface IDeserializeAsync<T>
 	{
-		ValueTask<T> DeserializeAsync(Stream stream, CancellationToken cancellationToken = default);
+		/// <summary>
+		/// Deserializes a stream to the specified type.
+		/// </summary>
+		/// <param name="source">The stream to deserialize.</param>
+		/// <param name="cancellationToken">An optional cancellation token.</param>
+		/// <returns>The deserialized result.</returns>
+		ValueTask<T> DeserializeAsync(Stream source, CancellationToken cancellationToken = default);
 	}
 }
diff --git a/Open.Serialization/IDeserializeObject.cs b/Open.Serialization/IDeserializeObject.cs
@@ -2,8 +2,23 @@
 
 namespace Open.Serialization
 {
-	public interface IDeserializeObject
+	/// <summary>
+	/// Interface for deserializing any string to an object when given a type.
+	/// </summary>
+	public interface IDeserializeObject : IDeserialize
 	{
+		/// <summary>
+		/// Deserializes a string value to the specified type.
+		/// </summary>
+		/// <param name="value">The string to deserialize.</param>
+		/// <param name="type">The expected type.</param>
+		/// <returns>The deserialized result.</returns>
 		object? Deserialize(string? value, Type type);
+
+#if NETSTANDARD2_1
+		T IDeserialize.Deserialize<T>(string? value)
+			=> (T)Deserialize(value, typeof(T))!;
+#endif
+
 	}
 }
diff --git a/Open.Serialization/IDeserializeObjectAsync.cs b/Open.Serialization/IDeserializeObjectAsync.cs
@@ -5,8 +5,23 @@
 
 namespace Open.Serialization
 {
-	public interface IDeserializeObjectAsync
+	/// <summary>
+	/// Interface for asynchronously deserializing any string to an object when given a type.
+	/// </summary>
+	public interface IDeserializeObjectAsync : IDeserializeAsync
 	{
+		/// <summary>
+		/// Deserializes a stream to the specified type.
+		/// </summary>
+		/// <param name="source">The stream to deserialize.</param>
+		/// <param name="type">The expected type.</param>
+		/// <param name="cancellationToken">An optional cancellation token.</param>
+		/// <returns>The deserialized result.</returns>
 		ValueTask<object?> DeserializeAsync(Stream source, Type type, CancellationToken cancellationToken = default);
+
+#if NETSTANDARD2_1
+		async ValueTask<T> IDeserializeAsync.DeserializeAsync<T>(Stream source, CancellationToken cancellationToken)
+			=> (T)(await DeserializeAsync(source, typeof(T), cancellationToken))!;
+#endif
 	}
 }
diff --git a/Open.Serialization/IObjectSerializer.cs b/Open.Serialization/IObjectSerializer.cs
@@ -1,10 +1,16 @@
 ﻿namespace Open.Serialization
 {
-	interface IObjectSerializer : ISerializeObject, IDeserializeObject
+	/// <summary>
+	/// Interface for defining an object serializer.
+	/// </summary>
+	public interface IObjectSerializer : ISerializeObject, IDeserializeObject
 	{
 	}
 
-	interface IAsyncObjectSerializer : ISerializeObjectAsync, IDeserializeObjectAsync
+	/// <summary>
+	/// Interface for defining an asynchronous object serializer.
+	/// </summary>
+	public interface IAsyncObjectSerializer : ISerializeObjectAsync, IDeserializeObjectAsync
 	{
 	}
 }
diff --git a/Open.Serialization/ISerialize.cs b/Open.Serialization/ISerialize.cs
@@ -1,12 +1,29 @@
 ﻿namespace Open.Serialization
 {
+	/// <summary>
+	/// Interface for serializing a given generic type.
+	/// </summary>
 	public interface ISerialize
 	{
+		/// <summary>
+		/// Serializes the provided item to a string.
+		/// </summary>
+		/// <param name="item">The item to deserialze.</param>
+		/// <returns>The serialized string.</returns>
 		string? Serialize<T>(T item);
 	}
 
+
+	/// <summary>
+	/// Interface for serializing a predefined specific generic type.
+	/// </summary>
 	public interface ISerialize<in T>
 	{
+		/// <summary>
+		/// Serializes the provided item to a string.
+		/// </summary>
+		/// <param name="item">The item to deserialze.</param>
+		/// <returns>The serialized string.</returns>
 		string? Serialize(T item);
 	}
 }
diff --git a/Open.Serialization/ISerializeAsync.cs b/Open.Serialization/ISerializeAsync.cs
@@ -4,13 +4,31 @@
 
 namespace Open.Serialization
 {
+	/// <summary>
+	/// Interface for asynchronously serializing a given generic type.
+	/// </summary>
 	public interface ISerializeAsync
 	{
-		ValueTask SerializeAsync<T>(Stream stream, T item, CancellationToken cancellationToken = default);
+		/// <summary>
+		/// Serializes the provided item to a stream.
+		/// </summary>
+		/// <param name="target">The destination stream.</param>
+		/// <param name="item">The item to serialize.</param>
+		/// <param name="cancellationToken">An optional cancellation token.</param>
+		ValueTask SerializeAsync<T>(Stream target, T item, CancellationToken cancellationToken = default);
 	}
 
+	/// <summary>
+	/// Interface for asynchronously serializing a predefined specific generic type.
+	/// </summary>
 	public interface ISerializeAsync<in T>
 	{
-		ValueTask SerializeAsync(Stream stream, T item, CancellationToken cancellationToken = default);
+		/// <summary>
+		/// Serializes the provided item to a stream.
+		/// </summary>
+		/// <param name="target">The destination stream.</param>
+		/// <param name="item">The item to serialize.</param>
+		/// <param name="cancellationToken">An optional cancellation token.</param>
+		ValueTask SerializeAsync(Stream target, T item, CancellationToken cancellationToken = default);
 	}
 }
diff --git a/Open.Serialization/ISerializeObject.cs b/Open.Serialization/ISerializeObject.cs
@@ -2,8 +2,22 @@
 
 namespace Open.Serialization
 {
-	interface ISerializeObject
+	/// <summary>
+	/// Interface for serializing an object to a string when given a type.
+	/// </summary>
+	public interface ISerializeObject : ISerialize
 	{
+		/// <summary>
+		/// Serializes the provided item to a string.
+		/// </summary>
+		/// <param name="item">The item to deserialze.</param>
+		/// <param name="type">The expected type.</param>
+		/// <returns>The serialized string.</returns>
 		string? Serialize(object? item, Type type);
+
+#if NETSTANDARD2_1
+		string? ISerialize.Serialize<T>(T item)
+			=> Serialize(item, typeof(T));
+#endif
 	}
 }
diff --git a/Open.Serialization/ISerializeObjectAsync.cs b/Open.Serialization/ISerializeObjectAsync.cs
@@ -5,8 +5,23 @@
 
 namespace Open.Serialization
 {
-	interface ISerializeObjectAsync
+	/// <summary>
+	/// Interface for asynchronously serializing an object to a string when given a type.
+	/// </summary>
+	public interface ISerializeObjectAsync : ISerializeAsync
 	{
+		/// <summary>
+		/// Serializes the provided item to a stream.
+		/// </summary>
+		/// <param name="target">The destination stream.</param>
+		/// <param name="item">The item to serialize.</param>
+		/// <param name="type">The expected type.</param>
+		/// <param name="cancellationToken">An optional cancellation token.</param>
 		ValueTask SerializeAsync(Stream target, object? item, Type type, CancellationToken cancellationToken = default);
+
+#if NETSTANDARD2_1
+		ValueTask ISerializeAsync.SerializeAsync<T>(Stream target, T item, CancellationToken cancellationToken)
+			=> SerializeAsync(target, item, typeof(T), cancellationToken);
+#endif
 	}
 }
diff --git a/Open.Serialization/ObjectSerializer.cs b/Open.Serialization/ObjectSerializer.cs
@@ -0,0 +1,52 @@
+﻿using System;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Open.Serialization
+{
+	/// <summary>
+	/// A class for serializing and deserializing objects.
+	/// </summary>
+	public abstract class ObjectSerializer : ObjectSerializerBase
+	{
+		private readonly Func<string?, Type, object?> _deserializer;
+		private readonly Func<object?, Type, string?>? _serializer;
+		private readonly Func<Stream, Type, CancellationToken, ValueTask<object?>> _deserializerAsync;
+		private readonly Func<Stream, object?, Type, CancellationToken, ValueTask> _serializerAsync;
+
+		/// <summary>
+		/// Constructs a serializer/deserializer using the provided serialization functions.
+		/// </summary>
+		public ObjectSerializer(
+			Func<string?, Type, object?> deserializer,
+			Func<object?, Type, string?>? serializer = null,
+			Func<Stream, Type, CancellationToken, ValueTask<object?>>? deserializerAsync = null,
+			Func<Stream, object?, Type, CancellationToken, ValueTask>? serializerAsync = null)
+		{
+			_deserializer = deserializer ?? throw new ArgumentNullException(nameof(deserializer));
+			_serializer = serializer;
+			_deserializerAsync = deserializerAsync ?? base.DeserializeAsync;
+			_serializerAsync = serializerAsync ?? base.SerializeAsync;
+		}
+
+		/// <inheritdoc />
+		public override object? Deserialize(string? value, Type type)
+			=> _deserializer(value, type);
+
+		/// <inheritdoc />
+		public override ValueTask<object?> DeserializeAsync(Stream stream, Type type, CancellationToken cancellationToken = default)
+			=> _deserializerAsync(stream, type, cancellationToken);
+
+		/// <inheritdoc />
+		public override string? Serialize(object? item, Type type)
+			=> _serializer == null
+			? throw new NullReferenceException("No serializer function was supplied.")
+			: _serializer(item, type);
+
+		/// <inheritdoc />
+		public override ValueTask SerializeAsync(Stream stream, object? item, Type type, CancellationToken cancellationToken = default)
+			=> _serializerAsync(stream, item, type, cancellationToken);
+
+	}
+}
diff --git a/Open.Serialization/ObjectSerializerBase.cs b/Open.Serialization/ObjectSerializerBase.cs
@@ -5,24 +5,48 @@
 
 namespace Open.Serialization
 {
-	public abstract class ObjectSerializerBase : IObjectSerializer, IAsyncObjectSerializer
+	/// <summary>
+	/// Base class for serializing and deserializing non-generic objects.
+	/// </summary>
+	public abstract class ObjectSerializerBase : SerializerBase, IObjectSerializer, IAsyncObjectSerializer
 	{
+		/// <inheritdoc />
 		public abstract string? Serialize(object? item, Type type);
+
+		/// <inheritdoc />
 		public abstract object? Deserialize(string? value, Type type);
 
+		/// <inheritdoc />
 		public virtual async ValueTask SerializeAsync(Stream target, object? item, Type type, CancellationToken cancellationToken = default)
 		{
 			var text = Serialize(item, type);
 			using var writer = new StreamWriter(target);
 			await writer.WriteAsync(text).ConfigureAwait(false);
 		}
 
+		/// <inheritdoc />
 		public async virtual ValueTask<object?> DeserializeAsync(Stream source, Type type, CancellationToken cancellationToken = default)
 		{
 			string text;
 			using (var reader = new StreamReader(source))
 				text = await reader.ReadToEndAsync().ConfigureAwait(false);
 			return Deserialize(text, type);
 		}
+
+		/// <inheritdoc />
+		public override string? Serialize<T>(T item)
+			=> Serialize(item, typeof(T));
+
+		/// <inheritdoc />
+		public override T Deserialize<T>(string? value)
+			=> (T)Deserialize(value, typeof(T))!;
+
+		/// <inheritdoc />
+		public override ValueTask SerializeAsync<T>(Stream target, T item, CancellationToken cancellationToken = default)
+			=> SerializeAsync(target, item, typeof(T), cancellationToken);
+
+		/// <inheritdoc />
+		public override async ValueTask<T> DeserializeAsync<T>(Stream source, CancellationToken cancellationToken = default)
+			=> (T)(await DeserializeAsync(source, typeof(T), cancellationToken))!;
 	}
 }
diff --git a/Open.Serialization/Open.Serialization.csproj b/Open.Serialization/Open.Serialization.csproj
@@ -17,9 +17,13 @@ Part of the "Open" set of libraries.
 		<RepositoryUrl>https://github.com/electricessence/Open.Serialization</RepositoryUrl>
 		<RepositoryType>git</RepositoryType>
 		<PackageTags>serialization json</PackageTags>
-		<Version>1.5.0</Version>
+		<Version>2.0.0</Version>
 		<Nullable>enable</Nullable>
-		<PackageReleaseNotes>Improved nullable reference support.  FxCop inspections and fixes.</PackageReleaseNotes>
+		<PackageReleaseNotes></PackageReleaseNotes>
+	</PropertyGroup>
+
+	<PropertyGroup Condition="'$(Configuration)|$(TargetFramework)|$(Platform)'=='Release|netstandard2.0|AnyCPU'">
+	  <DocumentationFile>C:\Users\essence\Development\Open\Open.Serialization\Open.Serialization\Open.Serialization.xml</DocumentationFile>
 	</PropertyGroup>
 
 	<ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.0' ">
diff --git a/Open.Serialization/Open.Serialization.xml b/Open.Serialization/Open.Serialization.xml
diff --git a/Open.Serialization/Serializer.cs b/Open.Serialization/Serializer.cs
diff --git a/Open.Serialization/SerializerBase.cs b/Open.Serialization/SerializerBase.cs

-Original file line number
+Diff line change
@@ @@ -0,0 +1,6 @@ @@
 +namespace Open.Serialization.Json
 +{
 +	interface IJsonSerializeObject : ISerializeObject
 +	{
 +	}
 +}
Original file line number	Diff line number	Diff line change
`@@ -1,12 +1,28 @@`
`1`	`1`	`namespace Open.Serialization`
`2`	`2`	`{`
	`3`	`+ /// <summary>`
	`4`	`+ /// Interface for deserializing any given generic type.`
	`5`	`+ /// </summary>`
`3`	`6`	`public interface IDeserialize`
`4`	`7`	`{`
	`8`	`+ /// <summary>`
	`9`	`+ /// Deserializes a string value to the specified type.`
	`10`	`+ /// </summary>`
	`11`	`+ /// <param name="value">The string to deserialize.</param>`
	`12`	`+ /// <returns>The deserialized result.</returns>`
`5`	`13`	`T Deserialize<T>(string? value);`
`6`	`14`	`}`
`7`	`15`
	`16`	`+ /// <summary>`
	`17`	`+ /// Interface for deserializing a predefined specific generic type.`
	`18`	`+ /// </summary>`
`8`	`19`	`public interface IDeserialize<out T>`
`9`	`20`	`{`
	`21`	`+ /// <summary>`
	`22`	`+ /// Deserializes a string value to the specified type.`
	`23`	`+ /// </summary>`
	`24`	`+ /// <param name="value">The string to deserialize.</param>`
	`25`	`+ /// <returns>The deserialized result.</returns>`
`10`	`26`	`T Deserialize(string? value);`
`11`	`27`	`}`
`12`	`28`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,13 +4,31 @@`
`4`	`4`
`5`	`5`	`namespace Open.Serialization`
`6`	`6`	`{`
	`7`	`+ /// <summary>`
	`8`	`+ /// Interface for asynchronously deserializing any given generic type.`
	`9`	`+ /// </summary>`
`7`	`10`	`public interface IDeserializeAsync`
`8`	`11`	`{`
`9`		`- ValueTask<T> DeserializeAsync<T>(Stream stream, CancellationToken cancellationToken = default);`
	`12`	`+ /// <summary>`
	`13`	`+ /// Deserializes a stream to the specified type.`
	`14`	`+ /// </summary>`
	`15`	`+ /// <param name="source">The stream to deserialize.</param>`
	`16`	`+ /// <param name="cancellationToken">An optional cancellation token.</param>`
	`17`	`+ /// <returns>The deserialized result.</returns>`
	`18`	`+ ValueTask<T> DeserializeAsync<T>(Stream source, CancellationToken cancellationToken = default);`
`10`	`19`	`}`
`11`	`20`
	`21`	`+ /// <summary>`
	`22`	`+ /// Interface for asynchronously deserializing a predefined specific generic type.`
	`23`	`+ /// </summary>`
`12`	`24`	`public interface IDeserializeAsync<T>`
`13`	`25`	`{`
`14`		`- ValueTask<T> DeserializeAsync(Stream stream, CancellationToken cancellationToken = default);`
	`26`	`+ /// <summary>`
	`27`	`+ /// Deserializes a stream to the specified type.`
	`28`	`+ /// </summary>`
	`29`	`+ /// <param name="source">The stream to deserialize.</param>`
	`30`	`+ /// <param name="cancellationToken">An optional cancellation token.</param>`
	`31`	`+ /// <returns>The deserialized result.</returns>`
	`32`	`+ ValueTask<T> DeserializeAsync(Stream source, CancellationToken cancellationToken = default);`
`15`	`33`	`}`
`16`	`34`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,8 +2,23 @@`
`2`	`2`
`3`	`3`	`namespace Open.Serialization`
`4`	`4`	`{`
`5`		`- public interface IDeserializeObject`
	`5`	`+ /// <summary>`
	`6`	`+ /// Interface for deserializing any string to an object when given a type.`
	`7`	`+ /// </summary>`
	`8`	`+ public interface IDeserializeObject : IDeserialize`
`6`	`9`	`{`
	`10`	`+ /// <summary>`
	`11`	`+ /// Deserializes a string value to the specified type.`
	`12`	`+ /// </summary>`
	`13`	`+ /// <param name="value">The string to deserialize.</param>`
	`14`	`+ /// <param name="type">The expected type.</param>`
	`15`	`+ /// <returns>The deserialized result.</returns>`
`7`	`16`	`object? Deserialize(string? value, Type type);`
	`17`	`+`
	`18`	`+#if NETSTANDARD2_1`
	`19`	`+ T IDeserialize.Deserialize<T>(string? value)`
	`20`	`+ => (T)Deserialize(value, typeof(T))!;`
	`21`	`+#endif`
	`22`	`+`
`8`	`23`	`}`
`9`	`24`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,8 +5,23 @@`
`5`	`5`
`6`	`6`	`namespace Open.Serialization`
`7`	`7`	`{`
`8`		`- public interface IDeserializeObjectAsync`
	`8`	`+ /// <summary>`
	`9`	`+ /// Interface for asynchronously deserializing any string to an object when given a type.`
	`10`	`+ /// </summary>`
	`11`	`+ public interface IDeserializeObjectAsync : IDeserializeAsync`
`9`	`12`	`{`
	`13`	`+ /// <summary>`
	`14`	`+ /// Deserializes a stream to the specified type.`
	`15`	`+ /// </summary>`
	`16`	`+ /// <param name="source">The stream to deserialize.</param>`
	`17`	`+ /// <param name="type">The expected type.</param>`
	`18`	`+ /// <param name="cancellationToken">An optional cancellation token.</param>`
	`19`	`+ /// <returns>The deserialized result.</returns>`
`10`	`20`	`ValueTask<object?> DeserializeAsync(Stream source, Type type, CancellationToken cancellationToken = default);`
	`21`	`+`
	`22`	`+#if NETSTANDARD2_1`
	`23`	`+ async ValueTask<T> IDeserializeAsync.DeserializeAsync<T>(Stream source, CancellationToken cancellationToken)`
	`24`	`+ => (T)(await DeserializeAsync(source, typeof(T), cancellationToken))!;`
	`25`	`+#endif`
`11`	`26`	`}`
`12`	`27`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,10 +1,16 @@`
`1`	`1`	`namespace Open.Serialization`
`2`	`2`	`{`
`3`		`- interface IObjectSerializer : ISerializeObject, IDeserializeObject`
	`3`	`+ /// <summary>`
	`4`	`+ /// Interface for defining an object serializer.`
	`5`	`+ /// </summary>`
	`6`	`+ public interface IObjectSerializer : ISerializeObject, IDeserializeObject`
`4`	`7`	`{`
`5`	`8`	`}`
`6`	`9`
`7`		`- interface IAsyncObjectSerializer : ISerializeObjectAsync, IDeserializeObjectAsync`
	`10`	`+ /// <summary>`
	`11`	`+ /// Interface for defining an asynchronous object serializer.`
	`12`	`+ /// </summary>`
	`13`	`+ public interface IAsyncObjectSerializer : ISerializeObjectAsync, IDeserializeObjectAsync`
`8`	`14`	`{`
`9`	`15`	`}`
`10`	`16`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,12 +1,29 @@`
`1`	`1`	`namespace Open.Serialization`
`2`	`2`	`{`
	`3`	`+ /// <summary>`
	`4`	`+ /// Interface for serializing a given generic type.`
	`5`	`+ /// </summary>`
`3`	`6`	`public interface ISerialize`
`4`	`7`	`{`
	`8`	`+ /// <summary>`
	`9`	`+ /// Serializes the provided item to a string.`
	`10`	`+ /// </summary>`
	`11`	`+ /// <param name="item">The item to deserialze.</param>`
	`12`	`+ /// <returns>The serialized string.</returns>`
`5`	`13`	`string? Serialize<T>(T item);`
`6`	`14`	`}`
`7`	`15`
	`16`	`+`
	`17`	`+ /// <summary>`
	`18`	`+ /// Interface for serializing a predefined specific generic type.`
	`19`	`+ /// </summary>`
`8`	`20`	`public interface ISerialize<in T>`
`9`	`21`	`{`
	`22`	`+ /// <summary>`
	`23`	`+ /// Serializes the provided item to a string.`
	`24`	`+ /// </summary>`
	`25`	`+ /// <param name="item">The item to deserialze.</param>`
	`26`	`+ /// <returns>The serialized string.</returns>`
`10`	`27`	`string? Serialize(T item);`
`11`	`28`	`}`
`12`	`29`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,8 +2,22 @@`
`2`	`2`
`3`	`3`	`namespace Open.Serialization`
`4`	`4`	`{`
`5`		`- interface ISerializeObject`
	`5`	`+ /// <summary>`
	`6`	`+ /// Interface for serializing an object to a string when given a type.`
	`7`	`+ /// </summary>`
	`8`	`+ public interface ISerializeObject : ISerialize`
`6`	`9`	`{`
	`10`	`+ /// <summary>`
	`11`	`+ /// Serializes the provided item to a string.`
	`12`	`+ /// </summary>`
	`13`	`+ /// <param name="item">The item to deserialze.</param>`
	`14`	`+ /// <param name="type">The expected type.</param>`
	`15`	`+ /// <returns>The serialized string.</returns>`
`7`	`16`	`string? Serialize(object? item, Type type);`
	`17`	`+`
	`18`	`+#if NETSTANDARD2_1`
	`19`	`+ string? ISerialize.Serialize<T>(T item)`
	`20`	`+ => Serialize(item, typeof(T));`
	`21`	`+#endif`
`8`	`22`	`}`
`9`	`23`	`}`