Add Serializable Attribute

patrick-dmxc · patrick-dmxc · commit f8d8ff551382 · 2024-05-31T14:25:29.000+02:00
Add JsonSerializer
Bump v0.0.2
diff --git a/WellKnownDataTypes-Tests/Light/ArtNet/Address_Tests.cs b/WellKnownDataTypes-Tests/Light/ArtNet/Address_Tests.cs
@@ -1,4 +1,5 @@
 using org.dmxc.wkdt.Light.ArtNet;
+using org.dmxc.wkdt.Tests;
 
 namespace org.dmxc.wkdt.Tests.Light.ArtNet
 {
@@ -59,5 +60,16 @@ public void TestAddress()
 
             Assert.That(addresses.OrderByDescending(s => s.Universe).ThenBy(s => s).ToArray(), Has.Length.EqualTo(byte.MaxValue));
         }
+
+        [Test]
+        public void TestSerializable()
+        {
+            Address address = new Address(2, 3);
+            var data = Tools.Serialize(address);
+            string json= System.Text.Encoding.Default.GetString(data);
+            Address result = Tools.Deserialize<Address>(data);
+
+            Assert.That(result, Is.EqualTo(address), json);
+        }
     }
 }
diff --git a/WellKnownDataTypes-Tests/Light/ArtNet/Net_Tests.cs b/WellKnownDataTypes-Tests/Light/ArtNet/Net_Tests.cs
@@ -48,5 +48,16 @@ public void TestNet()
                 Assert.That(new Net(1).Equals((Net)2), Is.False);
             });
         }
+
+        [Test]
+        public void TestSerializable()
+        {
+            Net net = new Net(2);
+            var data = Tools.Serialize(net);
+            string json = System.Text.Encoding.Default.GetString(data);
+            Net result = Tools.Deserialize<Net>(data);
+
+            Assert.That(result, Is.EqualTo(net), json);
+        }
     }
 }
diff --git a/WellKnownDataTypes-Tests/Light/ArtNet/PortAddress_Tests.cs b/WellKnownDataTypes-Tests/Light/ArtNet/PortAddress_Tests.cs
@@ -52,5 +52,16 @@ public void TestPortAddress()
                 Assert.That(new PortAddress(1).Equals((PortAddress)2), Is.False);
             });
         }
+
+        [Test]
+        public void TestSerializable()
+        {
+            PortAddress portAddress = new PortAddress(2,3,4);
+            var data = Tools.Serialize(portAddress);
+            string json = System.Text.Encoding.Default.GetString(data);
+            PortAddress result = Tools.Deserialize<PortAddress>(data);
+
+            Assert.That(result, Is.EqualTo(portAddress), json);
+        }
     }
 }
diff --git a/WellKnownDataTypes-Tests/Light/ArtNet/Subnet_Tests.cs b/WellKnownDataTypes-Tests/Light/ArtNet/Subnet_Tests.cs
@@ -50,5 +50,15 @@ public void TestSubnet()
                 Assert.That(new Subnet(0).Equals(Subnet.Default), Is.True);
             });
         }
+        [Test]
+        public void TestSerializable()
+        {
+            Subnet subnet = new Subnet(13);
+            var data = Tools.Serialize(subnet);
+            string json = System.Text.Encoding.Default.GetString(data);
+            Subnet result = Tools.Deserialize<Subnet>(data);
+
+            Assert.That(result, Is.EqualTo(subnet), json);
+        }
     }
 }
diff --git a/WellKnownDataTypes-Tests/Light/ArtNet/Universe_Tests.cs b/WellKnownDataTypes-Tests/Light/ArtNet/Universe_Tests.cs
@@ -49,5 +49,15 @@ public void TestUniverse()
                 Assert.That(new Universe(0).Equals(Universe.Default), Is.True);
             });
         }
+        [Test]
+        public void TestSerializable()
+        {
+            Universe universe = new Universe(13);
+            var data = Tools.Serialize(universe);
+            string json = System.Text.Encoding.Default.GetString(data);
+            Universe result = Tools.Deserialize<Universe>(data);
+
+            Assert.That(result, Is.EqualTo(universe), json);
+        }
     }
 }
diff --git a/WellKnownDataTypes-Tests/Light/RDM/UID_Tests.cs b/WellKnownDataTypes-Tests/Light/RDM/UID_Tests.cs
@@ -110,5 +110,15 @@ public void TestUID()
                 Assert.That(new UID(0).Equals(UID.Empty), Is.True);
             });
         }
+        [Test]
+        public void TestSerializable()
+        {
+            UID uid = new UID("1234:12345678");
+            var data = Tools.Serialize(uid);
+            string json = System.Text.Encoding.Default.GetString(data);
+            UID result = Tools.Deserialize<UID>(data);
+
+            Assert.That(result, Is.EqualTo(uid), json);
+        }
     }
 }
diff --git a/WellKnownDataTypes-Tests/Network/IPv4Address_Tests.cs b/WellKnownDataTypes-Tests/Network/IPv4Address_Tests.cs
@@ -61,5 +61,16 @@ public void TestIPv4Address()
                 Assert.Throws(typeof(ArgumentException), () => { var ip = (IPv4Address)System.Net.IPAddress.IPv6Any; });
             });
         }
+
+        [Test]
+        public void TestSerializable()
+        {
+            IPv4Address ipv4Address = new IPv4Address("192.168.178.33");
+            var data = Tools.Serialize(ipv4Address);
+            string json = System.Text.Encoding.Default.GetString(data);
+            IPv4Address result = Tools.Deserialize<IPv4Address>(data);
+
+            Assert.That(result, Is.EqualTo(ipv4Address), json);
+        }
     }
 }
diff --git a/WellKnownDataTypes-Tests/Network/MACAddress_Tests.cs b/WellKnownDataTypes-Tests/Network/MACAddress_Tests.cs
@@ -53,5 +53,16 @@ public void TestMACAddress()
                                     }
             });
         }
+
+        [Test]
+        public void TestSerializable()
+        {
+            MACAddress macAddress = new MACAddress("aa:bb:cc:dD:Ee:fF");
+            var data = Tools.Serialize(macAddress);
+            string json = System.Text.Encoding.Default.GetString(data);
+            MACAddress result = Tools.Deserialize<MACAddress>(data);
+
+            Assert.That(result, Is.EqualTo(macAddress), json);
+        }
     }
 }
diff --git a/WellKnownDataTypes-Tests/Tools.cs b/WellKnownDataTypes-Tests/Tools.cs
@@ -0,0 +1,49 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace org.dmxc.wkdt.Tests
+{
+    public static class Tools
+    {
+        public static byte[] Serialize(object value)
+        {
+#if !NET8_0_OR_GREATER
+            byte[]? data = null;
+            using (MemoryStream ms = new MemoryStream())
+            {
+                //Format the object as Binary
+
+                BinaryFormatter formatter = new BinaryFormatter();
+                //It serialize the employee object
+#pragma warning disable SYSLIB0011 // Typ oder Element ist veraltet
+                formatter.Serialize(ms, value);
+#pragma warning restore SYSLIB0011 // Typ oder Element ist veraltet
+                data = ms.GetBuffer();
+
+                ms.Close();
+            }
+            return data;
+#else
+            return JsonSerializer.SerializeToUtf8Bytes(value);
+#endif
+        }
+        public static T? Deserialize<T>(byte[] data)
+        {
+
+#if !NET8_0_OR_GREATER
+            using (MemoryStream ms = new MemoryStream(data))
+            {
+                BinaryFormatter formatter = new BinaryFormatter();
+#pragma warning disable SYSLIB0011 // Typ oder Element ist veraltet
+                return (T)formatter.Deserialize(ms);
+#pragma warning restore SYSLIB0011 // Typ oder Element ist veraltet
+            }
+#else
+            return JsonSerializer.Deserialize<T>(new ReadOnlySpan<byte>(data));
+#endif
+        }
+    }
+}
diff --git a/WellKnownDataTypes-Tests/Usings.cs b/WellKnownDataTypes-Tests/Usings.cs
@@ -1,15 +1,4 @@
 global using NUnit.Framework;
-
-/* Nicht gemergte �nderung aus Projekt "WellKnownDataTypes-Tests (net7.0)"
-Vor:
-global using org.dmxc.wkdt;
-Nach:
-global using System;
-*/
-
-/* Nicht gemergte �nderung aus Projekt "WellKnownDataTypes-Tests (net8.0)"
-Vor:
-global using org.dmxc.wkdt;
-Nach:
-global using System;
-*/
+global using System.Buffers.Text;
+global using System.Runtime.Serialization.Formatters.Binary;
+global using System.Text.Json;
diff --git a/WellKnownDataTypes/Light/ArtNet/Address.cs b/WellKnownDataTypes/Light/ArtNet/Address.cs
@@ -1,11 +1,20 @@
-﻿using System;
-
-namespace org.dmxc.wkdt.Light.ArtNet
+﻿namespace org.dmxc.wkdt.Light.ArtNet
 {
+    [Serializable]
     public readonly struct Address : IEquatable<Address>, IComparable<Address>
     {
+#if NET8_0_OR_GREATER
+        [JsonIgnore(Condition = JsonIgnoreCondition.Always)]
+#endif
         public readonly Subnet Subnet;
+#if NET8_0_OR_GREATER
+        [JsonIgnore(Condition = JsonIgnoreCondition.Always)]
+#endif
         public readonly Universe Universe;
+
+#if NET8_0_OR_GREATER
+        [JsonInclude]
+#endif
         public readonly byte Combined;
 
         public Address(in Subnet subnet, in Universe universe)
@@ -14,7 +23,11 @@ public Address(in Subnet subnet, in Universe universe)
             Universe = universe;
             Combined = (byte)((Subnet & 0xf) << 4 | (Universe & 0xf));
         }
-        public Address(in byte combined)
+
+#if NET8_0_OR_GREATER
+        [JsonConstructor]
+#endif
+        public Address(byte combined)
         {
             Subnet = (Subnet)((combined >> 4) & 0xf);
             Universe = (Universe)(combined & 0xf);
diff --git a/WellKnownDataTypes/Light/ArtNet/Net.cs b/WellKnownDataTypes/Light/ArtNet/Net.cs
@@ -1,12 +1,18 @@
-﻿using System;
-
-namespace org.dmxc.wkdt.Light.ArtNet
+﻿namespace org.dmxc.wkdt.Light.ArtNet
 {
+    [Serializable]
     public readonly struct Net : IEquatable<Net>, IComparable<Net>
     {
+#if NET8_0_OR_GREATER
+        [JsonInclude]
+#endif
         public readonly byte Value;
 
-        public Net(in byte value)
+
+#if NET8_0_OR_GREATER
+        [JsonConstructor]
+#endif
+        public Net(byte value)
         {
             if ((byte)(value & 0x7f) != value)
                 throw new ArgumentException($"Value (0x{value:x}) out of range! A valid value is between 0x00 and 0x7f.");
diff --git a/WellKnownDataTypes/Light/ArtNet/PortAddress.cs b/WellKnownDataTypes/Light/ArtNet/PortAddress.cs
@@ -1,13 +1,28 @@
-﻿using System;
-
-namespace org.dmxc.wkdt.Light.ArtNet
+﻿namespace org.dmxc.wkdt.Light.ArtNet
 {
+    [Serializable]
     public readonly struct PortAddress : IEquatable<PortAddress>, IComparable<PortAddress>
     {
+#if NET8_0_OR_GREATER
+        [JsonIgnore(Condition = JsonIgnoreCondition.Always)]
+#endif
         public readonly Net Net;
+#if NET8_0_OR_GREATER
+        [JsonIgnore(Condition = JsonIgnoreCondition.Always)]
+#endif
         public readonly Subnet Subnet;
+#if NET8_0_OR_GREATER
+        [JsonIgnore(Condition = JsonIgnoreCondition.Always)]
+#endif
         public readonly Universe Universe;
+#if NET8_0_OR_GREATER
+        [JsonIgnore(Condition = JsonIgnoreCondition.Always)]
+#endif
         public readonly Address Address;
+
+#if NET8_0_OR_GREATER
+        [JsonInclude]
+#endif
         public readonly ushort Combined;
 
         public PortAddress(in Net net, in Subnet subnet, in Universe universe)
@@ -18,7 +33,11 @@ public PortAddress(in Net net, in Subnet subnet, in Universe universe)
             Address = new Address(subnet, universe);
             Combined = (ushort)((Net << 8) + Address.Combined);
         }
-        public PortAddress(in ushort combined)
+
+#if NET8_0_OR_GREATER
+        [JsonConstructor]
+#endif
+        public PortAddress(ushort combined)
         {
             if ((ushort)(combined & 0x7fff) != combined)
                 throw new ArgumentException($"Value (0x{combined:x}) out of range! A valid value is between 0x0000 and 0x7fff.");
diff --git a/WellKnownDataTypes/Light/ArtNet/Subnet.cs b/WellKnownDataTypes/Light/ArtNet/Subnet.cs
@@ -1,13 +1,19 @@
-﻿using System;
-
-namespace org.dmxc.wkdt.Light.ArtNet
+﻿namespace org.dmxc.wkdt.Light.ArtNet
 {
+    [Serializable]
     public readonly struct Subnet : IEquatable<Subnet>, IComparable<Subnet>
     {
         public static readonly Subnet Default = new Subnet();
+
+#if NET8_0_OR_GREATER
+        [JsonInclude]
+#endif
         public readonly byte Value;
 
-        public Subnet(in byte value)
+#if NET8_0_OR_GREATER
+        [JsonConstructor]
+#endif
+        public Subnet(byte value)
         {
             if ((byte)(value & 0x0f) != value)
                 throw new ArgumentException($"Value (0x{value:x}) out of range! A valid value is between 0x00 and 0x0f.");
diff --git a/WellKnownDataTypes/Light/ArtNet/Universe.cs b/WellKnownDataTypes/Light/ArtNet/Universe.cs
@@ -1,13 +1,19 @@
-﻿using System;
-
-namespace org.dmxc.wkdt.Light.ArtNet
+﻿namespace org.dmxc.wkdt.Light.ArtNet
 {
+    [Serializable]
     public readonly struct Universe : IEquatable<Universe>, IComparable<Universe>
     {
         public static readonly Universe Default = new Universe();
+
+#if NET8_0_OR_GREATER
+        [JsonInclude]
+#endif
         public readonly byte Value;
 
-        public Universe(in byte value)
+#if NET8_0_OR_GREATER
+        [JsonConstructor]
+#endif
+        public Universe(byte value)
         {
             if ((byte)(value & 0x0f) != value)
                 throw new ArgumentException($"Value (0x{value:x}) out of range! A valid value is between 0x00 and 0x0f.");
diff --git a/WellKnownDataTypes/Light/RDM/UID.cs b/WellKnownDataTypes/Light/RDM/UID.cs
diff --git a/WellKnownDataTypes/Network/IPv4Address.cs b/WellKnownDataTypes/Network/IPv4Address.cs
diff --git a/WellKnownDataTypes/Network/MACAddress.cs b/WellKnownDataTypes/Network/MACAddress.cs
diff --git a/WellKnownDataTypes/Usings.cs b/WellKnownDataTypes/Usings.cs
diff --git a/WellKnownDataTypes/WellKnownDataTypes.csproj b/WellKnownDataTypes/WellKnownDataTypes.csproj

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`	`1`	`using org.dmxc.wkdt.Light.ArtNet;`
	`2`	`+using org.dmxc.wkdt.Tests;`
`2`	`3`
`3`	`4`	`namespace org.dmxc.wkdt.Tests.Light.ArtNet`
`4`	`5`	`{`
`@@ -59,5 +60,16 @@ public void TestAddress()`
`59`	`60`
`60`	`61`	`Assert.That(addresses.OrderByDescending(s => s.Universe).ThenBy(s => s).ToArray(), Has.Length.EqualTo(byte.MaxValue));`
`61`	`62`	`}`
	`63`	`+`
	`64`	`+ [Test]`
	`65`	`+ public void TestSerializable()`
	`66`	`+ {`
	`67`	`+ Address address = new Address(2, 3);`
	`68`	`+ var data = Tools.Serialize(address);`
	`69`	`+ string json= System.Text.Encoding.Default.GetString(data);`
	`70`	`+ Address result = Tools.Deserialize<Address>(data);`
	`71`	`+`
	`72`	`+ Assert.That(result, Is.EqualTo(address), json);`
	`73`	`+ }`
`62`	`74`	`}`
`63`	`75`	`}`
Original file line number	Diff line number	Diff line change
`@@ -48,5 +48,16 @@ public void TestNet()`
`48`	`48`	`Assert.That(new Net(1).Equals((Net)2), Is.False);`
`49`	`49`	`});`
`50`	`50`	`}`
	`51`	`+`
	`52`	`+ [Test]`
	`53`	`+ public void TestSerializable()`
	`54`	`+ {`
	`55`	`+ Net net = new Net(2);`
	`56`	`+ var data = Tools.Serialize(net);`
	`57`	`+ string json = System.Text.Encoding.Default.GetString(data);`
	`58`	`+ Net result = Tools.Deserialize<Net>(data);`
	`59`	`+`
	`60`	`+ Assert.That(result, Is.EqualTo(net), json);`
	`61`	`+ }`
`51`	`62`	`}`
`52`	`63`	`}`
Original file line number	Diff line number	Diff line change
`@@ -52,5 +52,16 @@ public void TestPortAddress()`
`52`	`52`	`Assert.That(new PortAddress(1).Equals((PortAddress)2), Is.False);`
`53`	`53`	`});`
`54`	`54`	`}`
	`55`	`+`
	`56`	`+ [Test]`
	`57`	`+ public void TestSerializable()`
	`58`	`+ {`
	`59`	`+ PortAddress portAddress = new PortAddress(2,3,4);`
	`60`	`+ var data = Tools.Serialize(portAddress);`
	`61`	`+ string json = System.Text.Encoding.Default.GetString(data);`
	`62`	`+ PortAddress result = Tools.Deserialize<PortAddress>(data);`
	`63`	`+`
	`64`	`+ Assert.That(result, Is.EqualTo(portAddress), json);`
	`65`	`+ }`
`55`	`66`	`}`
`56`	`67`	`}`
Original file line number	Diff line number	Diff line change
`@@ -50,5 +50,15 @@ public void TestSubnet()`
`50`	`50`	`Assert.That(new Subnet(0).Equals(Subnet.Default), Is.True);`
`51`	`51`	`});`
`52`	`52`	`}`
	`53`	`+ [Test]`
	`54`	`+ public void TestSerializable()`
	`55`	`+ {`
	`56`	`+ Subnet subnet = new Subnet(13);`
	`57`	`+ var data = Tools.Serialize(subnet);`
	`58`	`+ string json = System.Text.Encoding.Default.GetString(data);`
	`59`	`+ Subnet result = Tools.Deserialize<Subnet>(data);`
	`60`	`+`
	`61`	`+ Assert.That(result, Is.EqualTo(subnet), json);`
	`62`	`+ }`
`53`	`63`	`}`
`54`	`64`	`}`
Original file line number	Diff line number	Diff line change
`@@ -49,5 +49,15 @@ public void TestUniverse()`
`49`	`49`	`Assert.That(new Universe(0).Equals(Universe.Default), Is.True);`
`50`	`50`	`});`
`51`	`51`	`}`
	`52`	`+ [Test]`
	`53`	`+ public void TestSerializable()`
	`54`	`+ {`
	`55`	`+ Universe universe = new Universe(13);`
	`56`	`+ var data = Tools.Serialize(universe);`
	`57`	`+ string json = System.Text.Encoding.Default.GetString(data);`
	`58`	`+ Universe result = Tools.Deserialize<Universe>(data);`
	`59`	`+`
	`60`	`+ Assert.That(result, Is.EqualTo(universe), json);`
	`61`	`+ }`
`52`	`62`	`}`
`53`	`63`	`}`
Original file line number	Diff line number	Diff line change
`@@ -110,5 +110,15 @@ public void TestUID()`
`110`	`110`	`Assert.That(new UID(0).Equals(UID.Empty), Is.True);`
`111`	`111`	`});`
`112`	`112`	`}`
	`113`	`+ [Test]`
	`114`	`+ public void TestSerializable()`
	`115`	`+ {`
	`116`	`+ UID uid = new UID("1234:12345678");`
	`117`	`+ var data = Tools.Serialize(uid);`
	`118`	`+ string json = System.Text.Encoding.Default.GetString(data);`
	`119`	`+ UID result = Tools.Deserialize<UID>(data);`
	`120`	`+`
	`121`	`+ Assert.That(result, Is.EqualTo(uid), json);`
	`122`	`+ }`
`113`	`123`	`}`
`114`	`124`	`}`
Original file line number	Diff line number	Diff line change
`@@ -61,5 +61,16 @@ public void TestIPv4Address()`
`61`	`61`	`Assert.Throws(typeof(ArgumentException), () => { var ip = (IPv4Address)System.Net.IPAddress.IPv6Any; });`
`62`	`62`	`});`
`63`	`63`	`}`
	`64`	`+`
	`65`	`+ [Test]`
	`66`	`+ public void TestSerializable()`
	`67`	`+ {`
	`68`	`+ IPv4Address ipv4Address = new IPv4Address("192.168.178.33");`
	`69`	`+ var data = Tools.Serialize(ipv4Address);`
	`70`	`+ string json = System.Text.Encoding.Default.GetString(data);`
	`71`	`+ IPv4Address result = Tools.Deserialize<IPv4Address>(data);`
	`72`	`+`
	`73`	`+ Assert.That(result, Is.EqualTo(ipv4Address), json);`
	`74`	`+ }`
`64`	`75`	`}`
`65`	`76`	`}`
Original file line number	Diff line number	Diff line change
`@@ -53,5 +53,16 @@ public void TestMACAddress()`
`53`	`53`	`}`
`54`	`54`	`});`
`55`	`55`	`}`
	`56`	`+`
	`57`	`+ [Test]`
	`58`	`+ public void TestSerializable()`
	`59`	`+ {`
	`60`	`+ MACAddress macAddress = new MACAddress("aa:bb:cc:dD:Ee:fF");`
	`61`	`+ var data = Tools.Serialize(macAddress);`
	`62`	`+ string json = System.Text.Encoding.Default.GetString(data);`
	`63`	`+ MACAddress result = Tools.Deserialize<MACAddress>(data);`
	`64`	`+`
	`65`	`+ Assert.That(result, Is.EqualTo(macAddress), json);`
	`66`	`+ }`
`56`	`67`	`}`
`57`	`68`	`}`