maersai_heavy_back_vehicle/ConsoleStarter/Program.cs

// See https://aka.ms/new-console-template for more information

using System.Collections;
using HybirdFrameworkCore.Autofac.Attribute;
using HybirdFrameworkCore.Utils;

internal class Program
{
    public static void Main(string[] args)
    {
        List<PropertyAttribute> list = new List<PropertyAttribute>
        {
            new(0, 4),
            new(4, 8),
            new(12, 1),
            new(13, 2),
            new(15, 1),
            new(16, 1),
            new(17, 1),
            new(18, 2),
            new(20, 2),
            new(22, 2),
            new(24, 2),
            new(26, 1),
            new(27, 2),
            new(29, 2),
            new(31, 1),
            new(32, 1),
            new(33, 29)
        };

        int start = 0;
        int length = 0;
        foreach (PropertyAttribute attribute in list)
        {
            if (start < attribute.Start)
            {
                start = attribute.Start;
                length = attribute.Length;
            }
        }

        Console.WriteLine($"{start}, {length}");

        byte[] bytes = new Byte[] { 0xFE, 0xFF };
        ushort uInt16 = BitConverter.ToUInt16(bytes);
        Console.WriteLine($"{uInt16}, {BitUtls.BytesToHexStr(bytes)}");
        BitArray bitArray = new BitArray(16);
        int index = 0;
        foreach (var b in bytes)
        {
            for (int i = 0; i < 8; i++)
            {
                bool flag = (b & (1 << (index % 8))) > 0;
                Console.WriteLine(flag);
                bitArray[index++] = flag;
            }
        }

        byte[] newbytes = new byte[2];
        bitArray.CopyTo(newbytes, 0);
        foreach (var b in newbytes)
        {
            Console.WriteLine(b);
        }

        ushort int16 = BitConverter.ToUInt16(newbytes);
        Console.WriteLine($"{int16}, {BitUtls.BytesToHexStr(newbytes)}");
        
        UInt64 max = UInt64.MaxValue / 8;
        byte[] bytes1 = BitConverter.GetBytes(max);
        Console.WriteLine($"{max}, {BitUtls.BytesToHexStr(bytes1)}");
        foreach (var b in bytes1)
        {
            Console.WriteLine(b);
        }

    }

    private static void Test1()
    {
        Console.WriteLine("Hello, World!");
        List<PropertyAttribute> list = new List<PropertyAttribute>
        {
            new(0, 4),
            new(4, 8),
            new(12, 1),
            new(13, 2),
            new(15, 1),
            new(16, 1),
            new(17, 1),
            new(18, 2),
            new(20, 2),
            new(22, 2),
            new(24, 2),
            new(26, 1),
            new(27, 2),
            new(29, 2),
            new(31, 1),
            new(32, 1),
            new(33, 29)
        };


        Queue<EncodeData> queue = new Queue<EncodeData>();
        int size = 0;
        foreach (PropertyAttribute p in list)
        {
            size += p.Length;
            if (size < 8)
            {
                queue.Enqueue(new EncodeData()
                {
                    Start = 0, Length = p.Length
                });
            }
            else
            {
                Console.WriteLine("---------------------------begin one byte---------------------");
                int length = 0;
                while (queue.Count > 0)
                {
                    EncodeData data = queue.Dequeue();
                    length += data.Length;
                    Console.WriteLine($"use {data.Start}, {data.Length}");
                }

                size -= length;

                int occupy = 8 - length;
                Console.WriteLine($"use 0, {occupy}");
                Console.WriteLine("---------------------------end one byte---------------------");
                size -= occupy;
                while (size >= 8)
                {
                    Console.WriteLine("---------------------------begin one byte---------------------");
                    Console.WriteLine($"use {occupy}, 8");
                    Console.WriteLine("---------------------------end one byte---------------------");
                    size -= 8;
                    occupy += 8;
                }

                if (size > 0)
                {
                    queue.Enqueue(new EncodeData()
                    {
                        Start = occupy, Length = size
                    });
                }
            }
        }

        foreach (EncodeData d in queue)
        {
            Console.WriteLine($"{d.Start}, {d.Length}");
        }

        UInt32 i = UInt32.MaxValue - 1;
        byte[] bytes = BitConverter.GetBytes(i).Reverse().ToArray();
        foreach (byte b in bytes)
        {
            Console.WriteLine(b);
        }

        Console.WriteLine(BitUtls.BytesToHexStr(bytes));
        UInt32 r = BitConverter.ToUInt32(bytes);
        Console.WriteLine(r);
        bytes = BitConverter.GetBytes(r);
        foreach (byte b in bytes)
        {
            Console.WriteLine(b);
        }

        Console.WriteLine(BitUtls.BytesToHexStr(bytes));
    }
}

public struct EncodeData
{
    public int Start { get; set; }
    public int Length { get; set; }
    public byte[] Value { get; set; }
}