ln.bson/ln.bson/BsonTypes.cs

using System;
using System.Text;
using ln.type;

namespace ln.bson
{
    public class BsonString : BsonValue
    {
        public string Value { get; set; }
        public override object ToNative() => Value;

        public BsonString() :base(BsonType.String){}

        public BsonString(string value) : this()
        {
            Value = value;
        }

        public override byte[] GetBytes()
        {
            byte[] sbytes = Encoding.UTF8.GetBytes(Value);
            byte[] buffer = new byte[sbytes.Length + 5];
            Array.Copy(BitConverter.GetBytes(sbytes.Length+1), 0, buffer, 0, 4);
            Array.Copy(sbytes, 0, buffer, 4, sbytes.Length);
            return buffer;
        }

        public static implicit operator string(BsonString bsonString) => bsonString.Value;
    }

    public class BsonDouble : BsonValue
    {
        public double Value { get; set; }
        public override object ToNative() => Value;
        public override byte[] GetBytes() => BitConverter.GetBytes(Value);
        
        public BsonDouble():base(BsonType.Double){}

        public BsonDouble(double value) : this()
        {
            Value = value;
        }
    }

    public class BsonBinary : BsonValue
    {
        public virtual byte[] Value { get; set; }
        public BsonBinarySubType SubType { get; set; }
        public override object ToNative() => Value;

        public BsonBinary() : base(BsonType.Binary) { }

        public BsonBinary(BsonBinarySubType subType) : this()
        {
            SubType = subType;
        }
        public BsonBinary(BsonBinarySubType subType, byte[] value) : this(subType)
        {
            Value = value;
        }
        
        public override byte[] GetBytes()
        {
            byte[] b = new byte[Value.Length + 5];
            Array.Copy(BitConverter.GetBytes(Value.Length), 0, b, 0, 4);
            b[4] = (byte)SubType;
            Array.Copy(Value, 0, b, 5, Value.Length);
            return b;
        }
    }

    public class BsonGuid : BsonBinary
    {
        public override byte[] Value { get => GuidValue.ToByteArray(); set => GuidValue = new Guid(value); }
        public Guid GuidValue { get; set; }
        public override object ToNative() => GuidValue;

        public BsonGuid() : this(Guid.Empty) { }

        public BsonGuid(Guid guid) : base(BsonBinarySubType.Uuid)
        {
            GuidValue = guid;
        }
        public BsonGuid(byte[] guid) : this(new Guid(guid)) { }
    }

    public class BsonBoolean : BsonValue
    {
        public static readonly BsonBoolean True = new BsonBoolean(true);
        public static readonly BsonBoolean False = new BsonBoolean(false);
        
        public bool Value { get; }

        private BsonBoolean(bool b) : base(BsonType.Boolean)
        {
            Value = b;
        }

        public override byte[] GetBytes() => new[] { Value ? (byte)0x01 : (byte)0x00 };
        public override object ToNative() => Value;
    }

    public class BsonDateTime : BsonValue
    {
        public DateTime Value { get; set; }
        public override byte[] GetBytes() => BitConverter.GetBytes((long)Value.ToUnixTimeMilliseconds());
        public override object ToNative() => Value;
        
        public BsonDateTime(): base(BsonType.DateTime){}

        public BsonDateTime(DateTime dateTime) : base(BsonType.DateTime)
        {
            Value = dateTime;
        }
    }

    public class BsonNull : BsonValue
    {
        public static readonly BsonNull Instance = new BsonNull();
        protected BsonNull(): base(BsonType.Null){}
        public override byte[] GetBytes() => new byte[0];
        public override object ToNative() => null;
    }
    
    public class BsonInt32 : BsonValue
    {
        public Int32 Value { get; set; }
        public override object ToNative() => Value;
        public override byte[] GetBytes() => BitConverter.GetBytes(Value);
        
        public BsonInt32():base(BsonType.Int32){}

        public BsonInt32(Int32 value) : this()
        {
            Value = value;
        }
    }

    public class BsonInt64 : BsonValue
    {
        public Int64 Value { get; set; }
        public override object ToNative() => Value;
        public override byte[] GetBytes() => BitConverter.GetBytes(Value);
        
        public BsonInt64():base(BsonType.Int64){}

        public BsonInt64(Int64 value) : this()
        {
            Value = value;
        }
    }
    
    
}