(#68) implemented explicit and implicit casts

src/StronglyTypedIds.Attributes/StronglyTypedIdImplementations.cs

@@ -33,5 +33,17 @@ public enum StronglyTypedIdImplementations
         /// Implement the <see cref="IComparable{T}"/> interface
         /// </summary>
         IComparable = 4,
+
+        // ReSharper disable once InconsistentNaming
+        /// <summary>
+        /// Implement an explicit cast
+        /// </summary>
+        ExplicitCast = 8,
+
+        // ReSharper disable once InconsistentNaming
+        /// <summary>
+        /// Implement an explicit cast
+        /// </summary>
+        ImplicitCast = 16,
     }
 }

src/StronglyTypedIds/EmbeddedSources.cs

@@ -25,6 +25,8 @@ internal static class EmbeddedSources
             LoadEmbeddedResource("StronglyTypedIds.Templates.Guid.Guid_EfCoreValueConverter.cs"),
             LoadEmbeddedResource("StronglyTypedIds.Templates.Guid.Guid_DapperTypeHandler.cs"),
             LoadEmbeddedResource("StronglyTypedIds.Templates.Guid.Guid_IComparable.cs"),
+            LoadEmbeddedResource("StronglyTypedIds.Templates.Guid.Guid_ImplicitCast.cs"),
+            LoadEmbeddedResource("StronglyTypedIds.Templates.Guid.Guid_ExplicitCast.cs"),
             false
         );
 
@@ -37,6 +39,8 @@ internal static class EmbeddedSources
             LoadEmbeddedResource("StronglyTypedIds.Templates.Int.Int_EfCoreValueConverter.cs"),
             LoadEmbeddedResource("StronglyTypedIds.Templates.Int.Int_DapperTypeHandler.cs"),
             LoadEmbeddedResource("StronglyTypedIds.Templates.Int.Int_IComparable.cs"),
+            LoadEmbeddedResource("StronglyTypedIds.Templates.Int.Int_ImplicitCast.cs"),
+            LoadEmbeddedResource("StronglyTypedIds.Templates.Int.Int_ExplicitCast.cs"),
             false
         );
 
@@ -49,6 +53,8 @@ internal static class EmbeddedSources
             LoadEmbeddedResource("StronglyTypedIds.Templates.Long.Long_EfCoreValueConverter.cs"),
             LoadEmbeddedResource("StronglyTypedIds.Templates.Long.Long_DapperTypeHandler.cs"),
             LoadEmbeddedResource("StronglyTypedIds.Templates.Long.Long_IComparable.cs"),
+            LoadEmbeddedResource("StronglyTypedIds.Templates.Long.Long_ImplicitCast.cs"),
+            LoadEmbeddedResource("StronglyTypedIds.Templates.Long.Long_ExplicitCast.cs"),
             false
         );
 
@@ -61,6 +67,8 @@ internal static class EmbeddedSources
             LoadEmbeddedResource("StronglyTypedIds.Templates.String.String_EfCoreValueConverter.cs"),
             LoadEmbeddedResource("StronglyTypedIds.Templates.String.String_DapperTypeHandler.cs"),
             LoadEmbeddedResource("StronglyTypedIds.Templates.String.String_IComparable.cs"),
+            LoadEmbeddedResource("StronglyTypedIds.Templates.String.String_ImplicitCast.cs"),
+            LoadEmbeddedResource("StronglyTypedIds.Templates.String.String_ExplicitCast.cs"),
             false
         );
 
@@ -73,6 +81,8 @@ internal static class EmbeddedSources
             LoadEmbeddedResource("StronglyTypedIds.Templates.NullableString.NullableString_EfCoreValueConverter.cs"),
             LoadEmbeddedResource("StronglyTypedIds.Templates.NullableString.NullableString_DapperTypeHandler.cs"),
             LoadEmbeddedResource("StronglyTypedIds.Templates.NullableString.NullableString_IComparable.cs"),
+            LoadEmbeddedResource("StronglyTypedIds.Templates.NullableString.NullableString_ImplicitCast.cs"),
+            LoadEmbeddedResource("StronglyTypedIds.Templates.NullableString.NullableString_ExplicitCast.cs"),
             true
         );
 
@@ -85,6 +95,8 @@ internal static class EmbeddedSources
             LoadEmbeddedResource("StronglyTypedIds.Templates.NewId.NewId_EfCoreValueConverter.cs"),
             LoadEmbeddedResource("StronglyTypedIds.Templates.NewId.NewId_DapperTypeHandler.cs"),
             LoadEmbeddedResource("StronglyTypedIds.Templates.NewId.NewId_IComparable.cs"),
+            LoadEmbeddedResource("StronglyTypedIds.Templates.NewId.NewId_ImplicitCast.cs"),
+            LoadEmbeddedResource("StronglyTypedIds.Templates.NewId.NewId_ExplicitCast.cs"),
             false
         );
 
@@ -117,6 +129,8 @@ public readonly struct ResourceCollection
             public string EfCoreValueConverter { get; }
             public string DapperTypeHandler { get; }
             public string Comparable { get; }
+            public string ImplicitCast { get; }
+            public string ExplicitCast { get; }
 
             public ResourceCollection(
                 string header,
@@ -127,6 +141,8 @@ public ResourceCollection(
                 string efCoreValueConverter,
                 string dapperTypeHandler,
                 string comparable,
+                string implicitCast,
+                string explicitCast,
                 bool nullableEnable)
             {
                 BaseId = baseId;
@@ -136,6 +152,8 @@ public ResourceCollection(
                 EfCoreValueConverter = efCoreValueConverter;
                 DapperTypeHandler = dapperTypeHandler;
                 Comparable = comparable;
+                ImplicitCast = implicitCast;
+                ExplicitCast = explicitCast;
                 NullableEnable = nullableEnable;
                 Header = header;
             }

src/StronglyTypedIds/SourceGenerationHelper.cs

@@ -72,7 +72,14 @@ static string CreateId(
 
             var useIEquatable = implementations.IsSet(StronglyTypedIdImplementations.IEquatable);
             var useIComparable = implementations.IsSet(StronglyTypedIdImplementations.IComparable);
+            var useImplicitCast = implementations.IsSet(StronglyTypedIdImplementations.ImplicitCast);
+            var useExplicitCast = implementations.IsSet(StronglyTypedIdImplementations.ExplicitCast);
 
+            if (useImplicitCast && useExplicitCast)
+            {
+                throw new ArgumentException("Cannot use implicit cast and explicit cast at the same time. Chose only one.", nameof(implementations));
+            }
+
             var parentsCount = 0;
 
             sb ??= new StringBuilder();
@@ -132,6 +139,16 @@ static string CreateId(
                 sb.AppendLine(resources.Comparable);
             }
 
+            if (useImplicitCast)
+            {
+                sb.AppendLine(resources.ImplicitCast);
+            }
+
+            if (useExplicitCast)
+            {
+                sb.AppendLine(resources.ExplicitCast);
+            }
+
             if (useEfCoreValueConverter)
             {
                 sb.AppendLine(resources.EfCoreValueConverter);

src/StronglyTypedIds/Templates/Guid/Guid_ExplicitCast.cs

@@ -0,0 +1,2 @@
+        public static explicit operator System.Guid(TESTID id) => id.Value;
+        public static explicit operator TESTID(System.Guid value) => new(value);

src/StronglyTypedIds/Templates/Guid/Guid_ImplicitCast.cs

@@ -0,0 +1,2 @@
+        public static implicit operator System.Guid(TESTID id) => id.Value;
+        public static implicit operator TESTID(System.Guid value) => new(value);

src/StronglyTypedIds/Templates/Int/Int_ExplicitCast.cs

@@ -0,0 +1,2 @@
+        public static explicit operator int(TESTID id) => id.Value;
+        public static explicit operator TESTID(int value) => new(value);

src/StronglyTypedIds/Templates/Int/Int_ImplicitCast.cs

@@ -0,0 +1,2 @@
+        public static implicit operator int(TESTID id) => id.Value;
+        public static implicit operator TESTID(int value) => new(value);

src/StronglyTypedIds/Templates/Long/Long_ExplicitCast.cs

@@ -0,0 +1,2 @@
+        public static explicit operator long(TESTID id) => id.Value;
+        public static explicit operator TESTID(long value) => new(value);

src/StronglyTypedIds/Templates/Long/Long_ImplicitCast.cs

@@ -0,0 +1,2 @@
+        public static implicit operator long(TESTID id) => id.Value;
+        public static implicit operator TESTID(long value) => new(value);

src/StronglyTypedIds/Templates/NewId/NewId_ExplicitCast.cs

@@ -0,0 +1,2 @@
+        public static explicit operator MassTransit.NewId(TESTID id) => id.Value;
+        public static explicit operator TESTID(MassTransit.NewId value) => new(value);

src/StronglyTypedIds/Templates/NewId/NewId_ImplicitCast.cs

@@ -0,0 +1,2 @@
+        public static implicit operator MassTransit.NewId(TESTID id) => id.Value;
+        public static implicit operator TESTID(MassTransit.NewId value) => new(value);

src/StronglyTypedIds/Templates/NullableString/NullableString_ExplicitCast.cs

@@ -0,0 +1,2 @@
+        public static explicit operator string?(TESTID id) => id.Value;
+        public static explicit operator TESTID(string? value) => new(value);

src/StronglyTypedIds/Templates/NullableString/NullableString_ImplicitCast.cs

@@ -0,0 +1,2 @@
+        public static implicit operator string?(TESTID id) => id.Value;
+        public static implicit operator TESTID(string? value) => new(value);

src/StronglyTypedIds/Templates/String/String_ExplicitCast.cs

@@ -0,0 +1,2 @@
+        public static explicit operator string(TESTID id) => id.Value;
+        public static explicit operator TESTID(string value) => new(value);

src/StronglyTypedIds/Templates/String/String_ImplicitCast.cs

@@ -0,0 +1,2 @@
+        public static implicit operator string(TESTID id) => id.Value;
+        public static implicit operator TESTID(string value) => new(value);

test/StronglyTypedIds.IntegrationTests/GuidIdTests.cs

@@ -272,6 +272,23 @@ public void ImplementsInterfaces()
 #pragma warning restore 184
         }
 
+        [Fact]
+        public void CanExplicitCast()
+        {
+            Assert.IsAssignableFrom<ExplicitCastGuidId>((ExplicitCastGuidId)Guid.NewGuid());
+            Assert.IsAssignableFrom<Guid>((Guid)ExplicitCastGuidId.New());
+        }
+
+        [Fact]
+        public void CanImplicitCast()
+        {
+            ImplicitCastGuidId castedId = Guid.NewGuid();
+            Assert.IsType<ImplicitCastGuidId>(castedId);
+
+            Guid castedGuid = ImplicitCastGuidId.New();
+            Assert.IsType<Guid>(castedGuid);
+        }
+
 #if NET6_0_OR_GREATER
         [Fact]
         public void WhenConventionBasedEfCoreValueConverterUsesValueConverter()

test/StronglyTypedIds.IntegrationTests/Types/GuidId.cs

@@ -37,4 +37,10 @@ public partial struct EquatableGuidId { }
 
     [StronglyTypedId(implementations: StronglyTypedIdImplementations.IComparable)]
     public partial struct ComparableGuidId { }
+
+    [StronglyTypedId(implementations: StronglyTypedIdImplementations.ExplicitCast)]
+    public partial struct ExplicitCastGuidId { }
+
+    [StronglyTypedId(implementations: StronglyTypedIdImplementations.ImplicitCast)]
+    public partial struct ImplicitCastGuidId { }
 }

test/StronglyTypedIds.Tests/EnumHelper.cs

@@ -38,8 +38,15 @@ public static IEnumerable<StronglyTypedIdConverter> AllConverters(bool includeDe
             }
         }
 
-        public static IEnumerable<StronglyTypedIdImplementations> AllImplementations(bool includeDefault = true, bool includeNone = true)
+        public static IEnumerable<StronglyTypedIdImplementations> AllImplementations(
+            bool includeDefault = true,
+            bool includeNone = true,
+            StronglyTypedIdImplementations[] skip = null,
+            StronglyTypedIdImplementations[] only = null)
         {
+            skip ??= Array.Empty<StronglyTypedIdImplementations>();
+            only ??= Array.Empty<StronglyTypedIdImplementations>();
+
             // get highest value
             var highestValue = Enum.GetValues(typeof(StronglyTypedIdImplementations))
                 .Cast<int>()
@@ -50,7 +57,9 @@ public static IEnumerable<StronglyTypedIdImplementations> AllImplementations(boo
             {
                 var implementations = (StronglyTypedIdImplementations)i;
                 if (implementations.IsSet(StronglyTypedIdImplementations.Default) && !includeDefault
-                    || implementations == StronglyTypedIdImplementations.None && !includeNone)
+                    || implementations == StronglyTypedIdImplementations.None && !includeNone
+                    || skip.Any(s => implementations.IsSet(s))
+                    || (only.Length > 0 && !only.Any(s => implementations.IsSet(s))))
                 {
                     continue;
                 }

test/StronglyTypedIds.Tests/Snapshots/EmbeddedResourceTests.EmittedResourceIsSameAsCompiledResource_resource=StronglyTypedIdImplementations.verified.txt

@@ -46,6 +46,18 @@ namespace StronglyTypedIds
         /// Implement the <see cref="IComparable{T}"/> interface
         /// </summary>
         IComparable = 4,
+
+        // ReSharper disable once InconsistentNaming
+        /// <summary>
+        /// Implement an explicit cast
+        /// </summary>
+        ExplicitCast = 8,
+
+        // ReSharper disable once InconsistentNaming
+        /// <summary>
+        /// Implement an explicit cast
+        /// </summary>
+        ImplicitCast = 16,
     }
 }
 #endif

test/StronglyTypedIds.Tests/Snapshots/SourceGenerationHelperSnapshotTests.GeneratesIdCorrectly_ns=Some.Namespace_converter=0_backingType=Guid_implementations=10.verified.txt

@@ -0,0 +1,41 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by the StronglyTypedId source generator
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+#pragma warning disable 1591 // publicly visible type or member must be documented
+
+namespace Some.Namespace
+{
+    readonly partial struct MyTestId : System.IEquatable<MyTestId>
+    {
+        public System.Guid Value { get; }
+
+        public MyTestId(System.Guid value)
+        {
+            Value = value;
+        }
+
+        public static MyTestId New() => new MyTestId(System.Guid.NewGuid());
+        public static readonly MyTestId Empty = new MyTestId(System.Guid.Empty);
+
+        public bool Equals(MyTestId other) => this.Value.Equals(other.Value);
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj)) return false;
+            return obj is MyTestId other && Equals(other);
+        }
+
+        public override int GetHashCode() => Value.GetHashCode();
+
+        public override string ToString() => Value.ToString();
+        public static bool operator ==(MyTestId a, MyTestId b) => a.Equals(b);
+        public static bool operator !=(MyTestId a, MyTestId b) => !(a == b);
+        public static explicit operator System.Guid(MyTestId id) => id.Value;
+        public static explicit operator MyTestId(System.Guid value) => new(value);
+    }
+}

test/StronglyTypedIds.Tests/Snapshots/SourceGenerationHelperSnapshotTests.GeneratesIdCorrectly_ns=Some.Namespace_converter=0_backingType=Guid_implementations=12.verified.txt

@@ -0,0 +1,42 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by the StronglyTypedId source generator
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+#pragma warning disable 1591 // publicly visible type or member must be documented
+
+namespace Some.Namespace
+{
+    readonly partial struct MyTestId : System.IComparable<MyTestId>
+    {
+        public System.Guid Value { get; }
+
+        public MyTestId(System.Guid value)
+        {
+            Value = value;
+        }
+
+        public static MyTestId New() => new MyTestId(System.Guid.NewGuid());
+        public static readonly MyTestId Empty = new MyTestId(System.Guid.Empty);
+
+        public bool Equals(MyTestId other) => this.Value.Equals(other.Value);
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj)) return false;
+            return obj is MyTestId other && Equals(other);
+        }
+
+        public override int GetHashCode() => Value.GetHashCode();
+
+        public override string ToString() => Value.ToString();
+        public static bool operator ==(MyTestId a, MyTestId b) => a.Equals(b);
+        public static bool operator !=(MyTestId a, MyTestId b) => !(a == b);
+        public int CompareTo(MyTestId other) => Value.CompareTo(other.Value);
+        public static explicit operator System.Guid(MyTestId id) => id.Value;
+        public static explicit operator MyTestId(System.Guid value) => new(value);
+    }
+}

test/StronglyTypedIds.Tests/Snapshots/SourceGenerationHelperSnapshotTests.GeneratesIdCorrectly_ns=Some.Namespace_converter=0_backingType=Guid_implementations=14.verified.txt

@@ -0,0 +1,42 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by the StronglyTypedId source generator
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+#pragma warning disable 1591 // publicly visible type or member must be documented
+
+namespace Some.Namespace
+{
+    readonly partial struct MyTestId : System.IComparable<MyTestId>, System.IEquatable<MyTestId>
+    {
+        public System.Guid Value { get; }
+
+        public MyTestId(System.Guid value)
+        {
+            Value = value;
+        }
+
+        public static MyTestId New() => new MyTestId(System.Guid.NewGuid());
+        public static readonly MyTestId Empty = new MyTestId(System.Guid.Empty);
+
+        public bool Equals(MyTestId other) => this.Value.Equals(other.Value);
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj)) return false;
+            return obj is MyTestId other && Equals(other);
+        }
+
+        public override int GetHashCode() => Value.GetHashCode();
+
+        public override string ToString() => Value.ToString();
+        public static bool operator ==(MyTestId a, MyTestId b) => a.Equals(b);
+        public static bool operator !=(MyTestId a, MyTestId b) => !(a == b);
+        public int CompareTo(MyTestId other) => Value.CompareTo(other.Value);
+        public static explicit operator System.Guid(MyTestId id) => id.Value;
+        public static explicit operator MyTestId(System.Guid value) => new(value);
+    }
+}