make base class not abstract

Pilz.Cryptography/UniquieID.cs

@@ -11,24 +11,36 @@ namespace Pilz.Cryptography
 {
     public class UniquieID<TargetType> : UniquieID
     {
-        public UniquieID() : this(false)
+        public UniquieID() : base()
         {
         }
 
-        public UniquieID(bool autoGenerate)
+        public UniquieID(bool autoGenerate) : base(autoGenerate)
         {
-            if (autoGenerate)
-                GenerateIfNull();
         }
 
-        public override void Generate()
+        protected override string GenerateSimple()
         {
-            if (SimpleMode)
+            return typeof(TargetType).ToString() + base.GenerateSimple();
-                ID = typeof(TargetType).ToString() + currentSimpleID++.ToString();
-            else
-                ID = GenerateUniquieID<TargetType>(string.Empty);
         }
 
+        protected override string GenerateDefault()
+        {
+            return GenerateUniquieID<TargetType>(string.Empty);
+        }
+
+        public override int GetHashCode()
+        {
+            return base.GetHashCode();
+        }
+
+        public override bool Equals(object obj)
+        {
+            return base.Equals(obj);
+        }
+
+        #region Statics for Generation
+
         private static string GenerateUniquieID<T>(string var)
         {
             var sn = TryGetSerialNumberOfFirstHardDrive();
@@ -59,47 +71,11 @@ namespace Pilz.Cryptography
 
                 Win32_PhysicalMedia_SerialNumber = sn;
             }
-            
+
             return Win32_PhysicalMedia_SerialNumber;
         }
 
-        public override bool Equals(object obj)
+        #endregion
-        {
-            var res = false;
-
-            if (obj is UniquieID<TargetType> iD)
-            {
-                if (ReferenceEquals(res, iD))
-                    res = true;
-                else
-                {
-                    var leftHasID = iD.HasID;
-                    var rightHasID = HasID;
-
-                    if (!leftHasID && iD.GenerateOnGet)
-                    {
-                        iD.Generate();
-                        leftHasID = iD.HasID;
-                    }
-
-                    if (!rightHasID && GenerateOnGet)
-                    {
-                        Generate();
-                        rightHasID = HasID;
-                    }
-
-                    if (leftHasID && rightHasID)
-                        res = _iD.Equals(iD._iD);
-                }
-            }
-
-            return res;
-        }
-
-        public override int GetHashCode()
-        {
-            return base.GetHashCode();
-        }
 
         public static implicit operator string(UniquieID<TargetType> id)    => id.ID;
         public static implicit operator UniquieID<TargetType>(string id)    => new UniquieID<TargetType>() { ID = id };

Pilz.Cryptography/UniquieIDBase.cs

@@ -5,7 +5,7 @@ using System.Text;
 
 namespace Pilz.Cryptography
 {
-    public abstract class UniquieID : IUniquieID
+    public class UniquieID : IUniquieID
     {
         protected static int currentSimpleID = 0;
 
@@ -34,22 +34,83 @@ namespace Pilz.Cryptography
                 => _iD = value;
         }
 
-        public abstract void Generate();
+        public UniquieID() : this(false)
-        public abstract override bool Equals(object obj);
+        {
+        }
+
+        public UniquieID(bool autoGenerate)
+        {
+            if (autoGenerate)
+                GenerateIfNull();
+        }
+
+        public virtual void Generate()
+        {
+            if (SimpleMode)
+                ID = GenerateSimple();
+            else
+                ID = GenerateDefault();
+        }
+
+        protected virtual string GenerateSimple()
+        {
+            return DateTime.Now.ToString("yyyyMMddHHmmssfffffff") + currentSimpleID++.ToString();
+        }
+
+        protected virtual string GenerateDefault()
+        {
+            return new Random().Next().ToString() + currentSimpleID++.ToString();
+        }
 
         public virtual void GenerateIfNull()
         {
             if (!HasID) Generate();
         }
 
-        public override string ToString() => ID;
+        public override string ToString()
+        {
+            return ID;
+        }
 
         public override int GetHashCode()
         {
             return -1430039477 + EqualityComparer<string>.Default.GetHashCode(_iD);
         }
 
+        public override bool Equals(object obj)
+        {
+            if (obj is UniquieID iD)
+            {
+                if (ReferenceEquals(obj, iD))
+                    return true;
+                else
+                {
+                    var leftHasID = iD.HasID;
+                    var rightHasID = HasID;
+
+                    if (!leftHasID && iD.GenerateOnGet)
+                    {
+                        iD.Generate();
+                        leftHasID = iD.HasID;
+                    }
+
+                    if (!rightHasID && GenerateOnGet)
+                    {
+                        Generate();
+                        rightHasID = HasID;
+                    }
+
+                    if (leftHasID && rightHasID)
+                        return _iD.Equals(iD._iD);
+                }
+            }
+            
+            return base.Equals(obj);
+        }
+
         public static implicit operator string(UniquieID id) => id.ID;
+        public static implicit operator UniquieID(string id) => new UniquieID() { ID = id };
+        public static implicit operator UniquieID(int id) => new UniquieID() { ID = Convert.ToString(id) };
 
         public static bool operator ==(UniquieID left, UniquieID right) => left.ID.Equals(right.ID);
         public static bool operator !=(UniquieID left, UniquieID right) => !left.ID.Equals(right.ID);