Merge pull request #50 from I-RzR-I/feature/NameSpaceConceptChange

Add ime-ordered id generation

Author: I-RzR-I

README.md

@@ -1,24 +1,26 @@
 > **Note** This repository is developed for net40, net45, .netstandard2.0 and .netstandard2.1.
 
+[![NuGet Version](https://img.shields.io/nuget/v/RzR.Extensions.Domain.svg?style=flat&logo=nuget)](https://www.nuget.org/packages/RzR.Extensions.Domain/)
+[![Nuget Downloads](https://img.shields.io/nuget/dt/RzR.Extensions.Domain.svg?style=flat&logo=nuget)](https://www.nuget.org/packages/RzR.Extensions.Domain)
+
+<details>
+
+  <summary>Old version</summary>
+  
 [![NuGet Version](https://img.shields.io/nuget/v/DomainCommonExtensions.svg?style=flat&logo=nuget)](https://www.nuget.org/packages/DomainCommonExtensions/)
 [![Nuget Downloads](https://img.shields.io/nuget/dt/DomainCommonExtensions.svg?style=flat&logo=nuget)](https://www.nuget.org/packages/DomainCommonExtensions)
 
-> **v5 — Namespace reorganisation (BREAKING)**
->
-> Starting with **v5**, the library was reorganised  with a new namespace (from `DomainCommonExtensions` to `RzR.Extensions.Domain`) and focused into namespace buckets under the new root `RzR.Extensions.Domain.*`
-> (`Async`, `Collections`, `Cryptography`, `Data`, `Diagnostics`, `Internal`, `IO`, `Linq`, `Models`, `Primitives`, `Reflection`, `Text`, `Validation`).
-> Class names and method signatures are unchanged — only the namespaces moved.
->
-> To soften the upgrade, every old (v4) namespace is preserved as `[Obsolete]` forwarder static classes under
-> [`src/DomainCommonExtensions/_Legacy/`](src/DomainCommonExtensions/_Legacy/), so existing v4 code keeps compiling
-> while the IDE highlights every call-site with the new location.
->
-> See the full mapping in [docs/namespace-migration-v5.md](docs/namespace-migration-v5.md).
+</details>
+
+<br />
+
 
 This library/repository was created as a way to simplify the development process. It collects the most used extension methods for primitive data types (`int`, `string`, `DateTime`, `Enum`, `bool`, `byte`, `char`, `Guid`, `TimeSpan`, …) and for the common collection interfaces (`ICollection`, `IEnumerable`, `IList`, `HashSet`, `IQueryable`, `IDictionary`, `ConcurrentDictionary`, `Queue`, `DynamicList`, …).
 
 It also bundles `cryptography` helpers for encrypting/decrypting strings by key with `RSA`, `AES`, `TEA`, plus a `Base32` encoder and a password generator.
 
+A `TimeSeqId` generator in `Primitives` produces time-ordered, lexicographically sortable 48-character unique identifiers with 64-bit CSPRNG entropy and a SHA-256 integrity checksum — a structured, sortable alternative to `Guid`.
+
 If you need to extract documentation/comments from an `Assembly`, those extensions are here too. You will also find async lazy-load primitives `AsyncLazy<T>` and `AsyncExpiringLazy<T>`.
 
 Additionally, there are extensions for `System.Data` (`DbDataReader`, `IDataRecord`, `DataTable`), `FileStream`, `MemoryStream`, `Type`, plus `Linq` / `Expression` extensions and a `PredicateBuilder` to keep call-sites clean.
@@ -31,12 +33,11 @@ I hope I'm on the right way to providing all these things to all who saw or sear
 **You can find a [demo](https://demowebutils.iamrzr.dev/) with some of the extension methods on the [demowebutils](https://demowebutils.iamrzr.dev/) website.**
 
 
-**In case you wish to use it in your project, you can install the package from <a href="https://www.nuget.org/packages/DomainCommonExtensions" target="_blank">nuget.org</a>** or specify what version you want:
+**In case you wish to use it in your project, you can install the package from <a href="https://www.nuget.org/packages/RzR.Extensions.Domain" target="_blank">nuget.org</a>** or specify what version you want:
 
-> `Install-Package DomainCommonExtensions -Version x.x.x.x`
+> `Install-Package RzR.Extensions.Domain -Version x.x.x.x`
 
 ## Content
 1. [USING](docs/usage.md)
 2. [CHANGELOG](docs/CHANGELOG.md)
 3. [BRANCH-GUIDE](docs/branch-guide.md)
-4. [V5 NAMESPACE MIGRATION](docs/namespace-migration-v5.md)

build/generateCustomVersion.bat

@@ -0,0 +1,52 @@
+@echo off
+cls
+
+echo Write the source branch name (you current branch name, where were the changes made): 
+set /p userDefinedSourceBranch=
+echo.
+echo Write the destination branch name (the branch from which you can get the latest changes, like 'develop' or 'main/master'): 
+set /p userDefinedDestinationBranch=
+echo.
+echo Write your custom version number: 
+set /p userDefinedVersion=
+echo.
+
+:: Set init params value
+set applicationName=DomainCommonExtensions
+set runVersionIncrement=y
+set runGenChangeLog=y
+:: If runBuild > y(yes), build in release mode
+set runBuild=y 
+set runSolutionTest=n
+set runTest=n
+set runPack=y
+set assemblyPath=$('..\src\shared\GeneralAssemblyInfo.cs')
+set genType=-2
+set setInChangeLogNewVersion=y
+set autoCommitAndPush=n
+set autoGetLatestDevelop=y
+set changeLogPath=$('..\docs\CHANGELOG.MD')
+set sourceBranch=%userDefinedSourceBranch%
+set destinationBranch=%userDefinedDestinationBranch%
+set customVersion=%userDefinedVersion%
+set solutionPath=$('..\src\RzR.Shared.Attributes.sln')
+set packResultPath=$('..\nuget\')
+set packProjectsPath=$('..\src\DomainCommonExtensions\DomainCommonExtensions.csproj')
+set testProjectsPath=$('..\src\tests\DataTypeTests\DataTypeTests.csproj')
+
+
+echo :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+echo :::         Initialize:                                           :::
+echo :::            - New application version generation               :::
+echo :::            - Change log generation                            :::
+echo :::            - Build                                            :::
+echo :::            - Test                                             :::
+echo :::            - Create package                                   :::
+echo :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+echo:
+echo:
+
+PowerShell -NoProfile -ExecutionPolicy ByPass -Command ".\GenerateBuildInfo.exe -scriptCommands \"runVersionIncrement=%runVersionIncrement%;runGenChangeLog=%runGenChangeLog%;runBuild=%runBuild%;runSolutionTest=%runSolutionTest%;runTest=%runTest%;runPack=%runPack%;setInChangeLogNewVersion=%setInChangeLogNewVersion%;autoCommitAndPush=%autoCommitAndPush%;autoGetLatestDevelop=%autoGetLatestDevelop%;changeLogPath=%changeLogPath%;sourceBranch=%sourceBranch%;destinationBranch=%destinationBranch%;assemblyPath=%assemblyPath%;customVersion=%customVersion%;genType=%genType%;solutionPath=%solutionPath%;packResultPath=%packResultPath%;packProjectsPath=%packProjectsPath%;testProjectsPath=%testProjectsPath%\"";
+
+echo
+pause

docs/CHANGELOG.md

@@ -1,3 +1,8 @@
+### **v6.0.0.8301** [[RzR](mailto:108324929+I-RzR-I@users.noreply.github.com)] 28-05-2026
+* **BREAKING:** `_Legacy/` backward-compatibility shim layer removed. The `[Obsolete]` forwarder namespaces introduced in v5 no longer exist. All consuming code must use `RzR.Extensions.Domain.*` namespaces. See [namespace-migration-v5.md](namespace-migration-v5.md) for the full mapping.
+* [DEV] - (RzR) -> New `TimeSeqId` generator in `Primitives`: time-ordered, lexicographically sortable 48-character unique identifier. Format: `yyyy-MMdd-HHmmssfff-SSSS-RRRRRRRRRRRRRRRR-HHHHHH` (year / date / time-ms / sequence / 16-hex random / 6-char SHA-256 checksum). Fully thread-safe; IDs sort in generation order by plain string comparison.
+
+
 ### **v5.0.0.7637** [[RzR](mailto:108324929+I-RzR-I@users.noreply.github.com)] 24-04-2026
 * **BREAKING:** Repository reorganized into 11 stable namespace buckets (`Async`, `Collections`, `Cryptography`, `Data`, `Diagnostics`, `Internal`, `IO`, `Linq`, `Models`, `Primitives`, `Reflection`, `Text`, `Validation`). Class names and method signatures are unchanged; only the namespaces moved. See [namespace-migration-v5.md](namespace-migration-v5.md) for the full mapping.
 * **Backward-compat shim layer** (`_Legacy/` folder): `[Obsolete]` static methods preserve the v4 namespaces so existing user code still compiles. Each call site lights up with the new v5 location.

docs/usage.md

@@ -4,11 +4,11 @@ Most of these extension methods are self-explanatory. Browse the source for the
 
 The source code is open, so you can check what is available and pick what is useful for your project.
 
-> **Namespaces (v5).** Since v5 the library is with a new namespace (from `DomainCommonExtensions` to `RzR.Extensions.Domain`), and split into focused buckets under `RzR.Extensions.Domain.*`
-> (`Async`, `Collections`, `Cryptography`, `Data`, `Diagnostics`, `Internal`, `IO`, `Linq`, `Models`, `Primitives`,
-> `Reflection`, `Text`, `Validation`). The old (v4) namespaces still resolve via `[Obsolete]` forwarders
-> in [`src/DomainCommonExtensions/_Legacy/`](../src/DomainCommonExtensions/_Legacy/) — see
-> [namespace-migration-v5.md](namespace-migration-v5.md) for the full mapping.
+> **Namespaces (v5+).** Since v5 the library uses the namespace root `RzR.Extensions.Domain.*`, split into focused
+> buckets: `Async`, `Collections`, `Cryptography`, `Data`, `Diagnostics`, `Internal`, `IO`, `Linq`, `Models`,
+> `Primitives`, `Reflection`, `Text`, `Validation`. The old v4 `DomainCommonExtensions.*` namespaces and the
+> `_Legacy/` shim layer were **removed in v6** — see [namespace-migration-v5.md](namespace-migration-v5.md) for
+> the full mapping.
 
 ---
 
@@ -111,3 +111,49 @@ A thread-safe asynchronous lazy initializer with a configurable TTL. After expir
 | **Constructor params** | `factory` | `factory` + `ttl` |
 | **`IsInitializationStarted` after TTL** | N/A | Still `true` until replaced or `Reset()` |
 | **Use when** | Value must be computed once and reused indefinitely | Value needs periodic refresh (tokens, configs, rates, etc) |
+
+---
+
+## Time-ordered unique identifier — `TimeSeqId`
+
+> Namespace: `RzR.Extensions.Domain.Primitives`
+>
+> ```csharp
+> using RzR.Extensions.Domain.Primitives;
+> ```
+
+A sortable, collision-resistant string identifier — a structured alternative to `Guid`. IDs are lexicographically
+sortable by generation time and monotonically ordered within a single process.
+
+### Format
+
+```
+yyyy - MMdd - HHmmssfff - SSSS - RRRRRRRRRRRRRRRR - HHHHHH
+ [0]    [1]      [2]       [3]          [4]            [5]
+```
+
+| Block | Width | Alphabet | Content |
+|---|---|---|---|
+| `[0]` | 4 | `0-9` | Year (`yyyy`) |
+| `[1]` | 4 | `0-9` | Month and day (`MMdd`) |
+| `[2]` | 9 | `0-9` | Time to millisecond (`HHmmssfff`) |
+| `[3]` | 4 | `0-9` | Per-millisecond monotonic sequence `0000`–`9999` |
+| `[4]` | 16 | `0-9 A-F` | 64-bit CSPRNG random salt |
+| `[5]` | 6 | `0-9 A-Z` | SHA-256 integrity checksum over blocks `[0]`–`[4]` |
+
+### Usage
+
+```csharp
+string id = TimeSeqId.Generate();
+// e.g. "2026-0528-143022123-0001-A3F7B2C9D1E50246-X5K3P2"
+```
+
+### Guarantees
+
+| Property | Detail |
+|---|---|
+| **Single-process uniqueness** | The `(timestamp, sequence)` pair is unique within one process; `Generate()` is fully thread-safe. |
+| **Distributed uniqueness** | Two replicas hitting the same millisecond + sequence slot collide with probability **1 in 2⁶⁴ ≈ 5 × 10⁻²⁰** via block `[4]`. |
+| **Lexicographic sort order** | IDs sort in generation order by plain string comparison — no parsing required. |
+| **Monotonicity** | Within one process, IDs are strictly non-decreasing. Burst capacity: 9 999 IDs/ms before the generator waits for the next millisecond (lock is released during the wait). |
+| **Integrity** | Block `[5]` is a SHA-256 checksum over blocks `[0]`–`[4]`. Tampering any preceding block changes the checksum. |

src/DomainCommonExtensions/DomainCommonExtensions.csproj

@@ -25,6 +25,7 @@
 		<PackageIconUrl />
 		<RepositoryType>GIT</RepositoryType>
 		<RootNamespace>RzR.Extensions.Domain</RootNamespace>
+		<AssemblyName>RzR.Extensions.Domain</AssemblyName>
 	</PropertyGroup>
 
 	<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
@@ -51,7 +52,7 @@
 	</ItemGroup>
 
 	<ItemGroup>
-		<PackageReference Include="CodeSource" Version="5.0.0.7373" />
+		<PackageReference Include="	RzR.Core.CodeSource" Version="6.0.0.94" />
 		<!--<PackageReference Include="System.Linq.Dynamic.Core" Version="1.3.3" />-->
 	</ItemGroup>
 

src/DomainCommonExtensions/Primitives/TimeSeqId.cs

@@ -0,0 +1,192 @@
+// ***********************************************************************
+//  Assembly          : RzR.Shared.Extensions.DomainCommonExtensions
+//  Author            : RzR
+//  Created           : 28-05-2026 20:05
+// 
+//  Last Modified By : RzR
+//  Last Modified On : 28-05-2026 20:55
+//  ***********************************************************************
+//  <copyright file="TimeSeqId.cs" company="RzR SOFT & TECH">
+//      Copyright (c) RzR. All rights reserved.
+//  </copyright>
+//  <contact>
+//      https://iamrzr.dev/contact
+//  </contact>
+//  <summary></summary>
+//  ***********************************************************************
+
+#region U S I N G
+
+using System;
+using System.Security.Cryptography;
+using System.Text;
+using System.Threading;
+
+#endregion
+
+namespace RzR.Extensions.Domain.Primitives
+{
+    /// -------------------------------------------------------------------------------------------------
+    /// <summary>
+    ///     A time-ordered, lexicographically sortable 48-character unique identifiers.
+    /// </summary>
+    /// =================================================================================================
+    public static class TimeSeqId
+    {
+        /*
+         * [0] -> 4 digits year yyyy
+         * [1] -> 4 digits month and day MMdd
+         * [2] -> 9 digits HHmmssfff
+         * [3] -> 4 digits sequence for uniqueness
+         * [4] -> 16 characters(random) { 0 - 9A - F}
+         * [5] -> 6 characters, hash of the previous block {0-9A-Z}
+         */
+
+        [ThreadStatic]
+        private static RandomNumberGenerator _threadRng;
+        private static RandomNumberGenerator Rng => _threadRng ??= RandomNumberGenerator.Create();
+
+        private const int MAX_SEQUENCE = 9999;
+        private static long _lastTimestamp;
+        private static int _sequence;
+        private static readonly object Lock = new();
+
+        /// -------------------------------------------------------------------------------------------------
+        /// <summary>
+        ///     Generates a new time-ordered, lexicographically sortable unique identifier.
+        ///     The result is safe for concurrent use and monotonically ordered within a single process.
+        /// </summary>
+        /// <returns>
+        ///     A 48-character string in the format yyyy-MMdd-HHmmssfff-SSSS-RRRRRRRRRRRRRRRR-HHHHHH
+        ///     where SSSS is a per-millisecond sequence, RRRRRRRRRRRRRRRR is 64 bits of CSPRNG entropy,
+        ///     and HHHHHH is a SHA-256-derived integrity checksum.
+        /// </returns>
+        /// =================================================================================================
+        public static string Generate()
+        {
+            DateTime current = default;
+            int sequenceNumber = 0;
+            long waitUntil = 0;
+
+            while (true)
+            {
+                if (waitUntil > 0)
+                {
+                    while (DateTime.UtcNow.Ticks / TimeSpan.TicksPerMillisecond < waitUntil)
+                        Thread.Sleep(1);
+                    waitUntil = 0;
+                }
+
+                var acquired = false;
+
+                lock (Lock)
+                {
+                    current = DateTime.UtcNow;
+                    var currentTimestamp = current.Ticks / TimeSpan.TicksPerMillisecond;
+
+                    if (currentTimestamp <= _lastTimestamp)
+                    {
+                        _sequence++;
+
+                        if (_sequence > MAX_SEQUENCE)
+                        {
+                            // Sequence exhausted for this millisecond: release the lock
+                            // immediately and wait for the clock to advance outside it.
+                            waitUntil = _lastTimestamp + 1;
+                        }
+                        else
+                        {
+                            current = new DateTime(_lastTimestamp * TimeSpan.TicksPerMillisecond, DateTimeKind.Utc);
+                            acquired = true;
+                        }
+                    }
+                    else
+                    {
+                        _lastTimestamp = currentTimestamp;
+                        _sequence = 0;
+                        acquired = true;
+                    }
+
+                    if (acquired)
+                        sequenceNumber = _sequence;
+                }
+
+                if (acquired) break;
+            }
+
+            var block0 = current.ToString("yyyy");
+            var block1 = current.ToString("MMdd");
+            var block2 = current.ToString("HHmmssfff");
+            var block3 = sequenceNumber.ToString("D4");
+            var block4 = GenerateSecureRandomHex(16);
+
+            var combinedBlocks = $"{block0}-{block1}-{block2}-{block3}-{block4}";
+            var block5 = GenerateHash(combinedBlocks, 6);
+
+            return $"{block0}-{block1}-{block2}-{block3}-{block4}-{block5}";
+        }
+
+        /// -------------------------------------------------------------------------------------------------
+        /// <summary>
+        ///     Generates a cryptographically secure random hex string of the specified length.
+        /// </summary>
+        /// <param name="length">The number of hex characters to generate.</param>
+        /// <returns>
+        ///     A random uppercase hex string of the requested length using characters { 0-9, A-F }.
+        /// </returns>
+        /// =================================================================================================
+        private static string GenerateSecureRandomHex(int length)
+        {
+            var bytes = new byte[length];
+            Rng.GetBytes(bytes);
+
+            const string hexChars = "0123456789ABCDEF";
+            var result = new StringBuilder(length);
+
+            foreach (var b in bytes) 
+                result.Append(hexChars[b % 16]);
+
+            return result.ToString();
+        }
+
+        /// -------------------------------------------------------------------------------------------------
+        /// <summary>
+        ///     Computes a SHA-256-based alphanumeric checksum of <paramref name="input"/>,
+        ///     truncated to <paramref name="length"/> characters.
+        ///     Uses rejection sampling to guarantee a uniform distribution over { 0-9, A-Z }.
+        /// </summary>
+        /// <param name="input">The string to hash.</param>
+        /// <param name="length">The desired output length in characters.</param>
+        /// <returns>
+        ///     An alphanumeric string of exactly <paramref name="length"/> characters derived from the SHA-256 digest.
+        /// </returns>
+        /// =================================================================================================
+        private static string GenerateHash(string input, int length)
+        {
+            using (var sha = SHA256.Create())
+            {
+                var hashBytes = sha.ComputeHash(Encoding.UTF8.GetBytes(input));
+                const string alphanumeric = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+                var unbiasedCeiling = 256 - 256 % alphanumeric.Length;
+                var result = new StringBuilder(length);
+                var byteIdx = 0;
+
+                while (result.Length < length)
+                {
+                    if (byteIdx >= hashBytes.Length)
+                    {
+                        hashBytes = sha.ComputeHash(hashBytes);
+                        byteIdx = 0;
+                    }
+
+                    var b = hashBytes[byteIdx++];
+                    if (b < unbiasedCeiling)
+                        result.Append(alphanumeric[b % alphanumeric.Length]);
+                }
+
+                return result.ToString();
+            }
+        }
+
+    }
+}