[Discussion] Packet writing methods

[InfamousGeek]

I noticed alot of sources that have been released to public use the accessor method, which was been presented by Hybrid back then. I'm curious which method you personally use, and for what reason. My personal choice is structured packets. Example;

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
        struct LoginResponse
        {
            public PacketHeader Header;
            public UInt32 Key;
            public UInt32 ID;
            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 16)]
            public String IP;
            public UInt16 Port;
            public UInt16 Blank;
        }

        public byte[] ToArray()
        {
            Filler = new PacketFiller(Marshal.SizeOf(Response));
            Filler.FillPacket<LoginResponse>(Response);
            return Filler.ToArray();
        }

Looking forward to your feedback.

[_tao4229_]

or Send(&Response, Response.Header.Size/Marshal.SizeOf(Response));

[InfamousGeek]

Originally Posted by _tao4229_

or Send(&Response, Response.Header.Size/Marshal.SizeOf(Response));

        public PacketFiller(Int32 Size) //When I call the constructor I use Marshal.SizeOf
        {
            Packet = new byte[Size];
        }

        public void FillPacket<TStruct>(TStruct Struct)
        {
            IntPtr Ptr = Marshal.AllocHGlobal(Packet.Length);
            Marshal.StructureToPtr(Struct, Ptr, false);

            fixed (byte* pckt = this.Packet)
            {
                Native.memcpy(pckt, Ptr.ToPointer(), Packet.Length);
            }
        }

If you don't mind if I ask, which method do you use?

[_tao4229_]

Originally Posted by InfamousGeek

        public PacketFiller(Int32 Size) //When I call the constructor I use Marshal.SizeOf
        {
            Packet = new byte[Size];
        }

        public void FillPacket<TStruct>(TStruct Struct)
        {
            IntPtr Ptr = Marshal.AllocHGlobal(Packet.Length);
            Marshal.StructureToPtr(Struct, Ptr, false);

            fixed (byte* pckt = this.Packet)
            {
                Native.memcpy(pckt, Ptr.ToPointer(), Packet.Length);
            }
        }

If you don't mind if I ask, which method do you use?

I import WSASend/send (from ws2_32) and just pass a pointer to the structure.

[© Haydz]

Originally Posted by _tao4229_

I import WSASend/send (from ws2_32) and just pass a pointer to the structure.

Same as above.

[InfamousGeek]

Originally Posted by _tao4229_

I import WSASend/send (from ws2_32) and just pass a pointer to the structure.

I considered writing a winsocket, though my personal opinion is that there is no need to reinvent the wheel.

[Korvacs]

Originally Posted by InfamousGeek

I considered writing a winsocket, though my personal opinion is that there is no need to reinvent the wheel.

If you can improve on the original wheel then why not?

[_tao4229_]

Originally Posted by InfamousGeek

I considered writing a winsocket, though my personal opinion is that there is no need to reinvent the wheel.

If you don't feel like reinventing the wheel, you can just import the function and pass a System.Net.Socket.Handle as the SOCKET s param.

[InfamousGeek]

Originally Posted by Korvacs

If you can improve on the original wheel then why not?

Then it's not reinventing the wheel.. anyhow, we could discuss this forever but there is no point since every programmer has his own methods.

Originally Posted by _tao4229_

If you don't feel like reinventing the wheel, you can just import the function and pass a System.Net.Socket.Handle as the SOCKET s param.

I might give it a shot..

[Nullable]

Same method, but i usually don't program in managed. It is a lot easier in native.