using System;

using System.Text;

using System.Linq;

using System.Collections.Generic;

using Newtonsoft.Json;

using System.Threading;

​

    // guid version types

    public enum GuidVersion

    {

        TimeBased = 0x01,

        Reserved = 0x02,

        NameBased = 0x03,

        Random = 0x04

    }

        public static partial class GuidGenerator

    {

        // number of bytes in guid

        public const int ByteArraySize = 16;

​

        // multiplex variant info

        public const int VariantByte = 8;

        public const int VariantByteMask = 0x3f;

        public const int VariantByteShift = 0x80;

​

        // multiplex version info

        public const int VersionByte = 7;

        public const int VersionByteMask = 0x0f;

        public const int VersionByteShift = 4;

​

        // indexes within the uuid array for certain boundaries

        private const byte TimestampByte = 0;

        private const byte GuidClockSequenceByte = 8;

        private const byte NodeByte = 10;

​

        // offset to move from 1/1/0001, which is 0-time for .NET, to gregorian 0-time of 10/15/1582

        private static readonly DateTimeOffset GregorianCalendarStart = new DateTimeOffset(1582, 10, 15, 0, 0, 0, TimeSpan.Zero);

​

        // random clock sequence and node

        public static byte[] DefaultClockSequence { get; set; }

        public static byte[] DefaultNode { get; set; }

​

        static GuidGenerator()

        {

            DefaultClockSequence = new byte[2];

            DefaultNode = new byte[6];

​

            var random = new Random();

            random.NextBytes(DefaultClockSequence);

            random.NextBytes(DefaultNode);

        }

​

        public static GuidVersion GetVersion(this Guid guid)

        {

            byte[] bytes = guid.ToByteArray();

            return (GuidVersion)((bytes[VersionByte] & 0xFF) >> VersionByteShift);

        }

​

        public static DateTimeOffset GetDateTimeOffset(Guid guid)

        {

            byte[] bytes = guid.ToByteArray();

​

            // reverse the version

            bytes[VersionByte] &= (byte)VersionByteMask;

            bytes[VersionByte] |= (byte)((byte)GuidVersion.TimeBased >> VersionByteShift);

​

            byte[] timestampBytes = new byte[8];

            Array.Copy(bytes, TimestampByte, timestampBytes, 0, 8);

​

            long timestamp = BitConverter.ToInt64(timestampBytes, 0);

            long ticks = timestamp + GregorianCalendarStart.Ticks;

​

            return new DateTimeOffset(ticks, TimeSpan.Zero);

        }

​

        public static DateTime GetDateTime(Guid guid)

        {

            return GetDateTimeOffset(guid).DateTime;

        }

​

        public static DateTime GetLocalDateTime(Guid guid)

        {

            return GetDateTimeOffset(guid).LocalDateTime;

        }

​

        public static DateTime GetUtcDateTime(Guid guid)

        {

            return GetDateTimeOffset(guid).UtcDateTime;

        }

​

        public static Guid GenerateTimeBasedGuid()

        {

            return GenerateTimeBasedGuid(DateTimeOffset.UtcNow, DefaultClockSequence, DefaultNode);

        }

​

        public static Guid GenerateTimeBasedGuid(DateTime dateTime)

        {

            return GenerateTimeBasedGuid(dateTime, DefaultClockSequence, DefaultNode);

        }

​

        public static Guid GenerateTimeBasedGuid(DateTimeOffset dateTime)

        {

            return GenerateTimeBasedGuid(dateTime, DefaultClockSequence, DefaultNode);

        }

​

        public static Guid GenerateTimeBasedGuid(DateTime dateTime, byte[] clockSequence, byte[] node)

        {

            return GenerateTimeBasedGuid(new DateTimeOffset(dateTime), clockSequence, node);

        }

​

        public static Guid GenerateTimeBasedGuid(DateTimeOffset dateTime, byte[] clockSequence, byte[] node)

        {

            if (clockSequence == null)

                throw new ArgumentNullException("clockSequence");

​

            if (node == null)

                throw new ArgumentNullException("node");

​

            if (clockSequence.Length != 2)

                throw new ArgumentOutOfRangeException("clockSequence", "The clockSequence must be 2 bytes.");

​

            if (node.Length != 6)

                throw new ArgumentOutOfRangeException("node", "The node must be 6 bytes.");

​

            long ticks = (dateTime - GregorianCalendarStart).Ticks;

            byte[] guid = new byte[ByteArraySize];

            byte[] timestamp = BitConverter.GetBytes(ticks);

​

            // copy node

            Array.Copy(node, 0, guid, NodeByte, Math.Min(6, node.Length));

​

            // copy clock sequence

            Array.Copy(clockSequence, 0, guid, GuidClockSequenceByte, Math.Min(2, clockSequence.Length));

​

            // copy timestamp

            Array.Copy(timestamp, 0, guid, TimestampByte, Math.Min(8, timestamp.Length));

​

            // set the variant

            guid[VariantByte] &= (byte)VariantByteMask;

            guid[VariantByte] |= (byte)VariantByteShift;

​

            // set the version

            guid[VersionByte] &= (byte)VersionByteMask;

            guid[VersionByte] |= (byte)((byte)GuidVersion.TimeBased << VersionByteShift);

​

            return new Guid(guid);

        }

    }

public class Program

{   

    public static void Main()

    {

        var msgs = new messages();

        msgs.list = new List<MessageData>();

        for (int i=0; i < 10; i++) 

        {       

            #region GenerateID

            #endregion

​

            var msg = new MessageData() 

            {

                username = "beko",

                timestamp = DateTime.UtcNow.ToString("s"),

                content = "this a message"//,

                //ID = GuidGenerator.GenerateTimeBasedGuid(DateTime.UtcNow, clockseq, node).ToString()

            };

            msgs.list.Add(msg);

            Thread.Sleep(1);

        }

​

        string json = JsonConvert.SerializeObject(msgs, Formatting.Indented);

        //Console.WriteLine(json);

                for (int i=0; i < 10; i++) 

                {       

                            var node = new byte[6];

        Array.Copy(Encoding.UTF8.GetBytes("Berkecan"), node, 6);

        var clockseq = new byte[2];

        var rndint = new Random().Next(0,9) + new Random().Next(0,9);

        Array.Copy(BitConverter.GetBytes(rndint), clockseq, 2);

                    Console.WriteLine(GuidGenerator.GenerateTimeBasedGuid(new DateTime(552877848310000000), clockseq, node).ToString());

                    Thread.Sleep(1);

                }

    }

    public static string RandomString(int length, int? seed = null)

    {

        string text = "abcdefghijklmnoprstuvyzxwq0123456789";

        char[] array = (text).ToCharArray();

        Random random = new Random( (seed == null ? Guid.NewGuid().GetHashCode() : seed.Value) );

        string text2 = string.Empty;

        for (int i = 0; i < length; i++)

        {

            text2 += array[random.Next(array.Length)].ToString();

        }

        return text2;

    }

}

​

public static class Extension

{

    public static string Mask(this string value, string mask, char substituteChar = '#')

    {

    int valueIndex = 0;

    try

    {

        return new string(mask.Select(maskChar => maskChar == substituteChar ? value[valueIndex++] : maskChar).ToArray());

    }

    catch (IndexOutOfRangeException e)

    {

        throw new Exception("Value too short to substitute all substitute characters in the mask", e);

    }

    }

}

​

public class messages 

{

    public List<MessageData> list {get;set;}

}

​

public class MessageData 

{

    public string ID {get;set;}

    public string username {get;set;}

    public string timestamp {get;set;}

    public string content {get;set;}

}