Использование библиотек на C# в Delphi

namespace NickoTin
{
    public enum ShapeType
    {
        NullShape = 0,
        Point = 1,
        PolyLine = 3,
        Polygon = 5,
        MultiPoint = 8,
        PointZ = 11,
        PolyLineZ = 13,
        PolygonZ = 15,
        MultiPointZ = 18,
        PointM = 21,
        PolyLineM = 23,
        PolygonM = 25,
        MultiPointM = 28,
        MultiPatch = 31
    }
 
    [StructLayout(LayoutKind.Sequential, Pack = 4)]
    unsafe struct ShpHeader
    {
        public int FileCode;
        private fixed int Unused[5];
        public int FileLength;
        public int Version;
        public ShapeType ShapeType;
        public double Xmin;
        public double Ymin;
        public double Xmax;
        public double Ymax;
        public double Zmin;
        public double Zmax;
        public double Mmin;
        public double Mmax;
    }
 
    public abstract class ShpObject
    {
        public abstract ShapeType Type { get; }
 
        protected abstract void ReadData(BinaryReader br);
    }
 
    public class ShpPoint : ShpObject
    {
        internal ShpPoint(BinaryReader br)
        {
            ReadData(br);
        }
 
        public ShpPoint()
        {
 
        }
 
        public override ShapeType Type
        {
            get { return ShapeType.Point; }
        }
 
        protected override void ReadData(BinaryReader br)
        {
            X = br.ReadDouble();
            Y = br.ReadDouble();
        }
 
        public override bool Equals(object obj)
        {
            var point = obj as ShpPoint;
            if (point == null)
                return false;
 
            return X == point.X && Y == point.Y;
        }
 
        public double X { get; set; }
        public double Y { get; set; }
    }
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    class PolyLine : ShpObject
    {
        internal PolyLine(BinaryReader br)
        {
            ReadData(br);
        }
 
        public PolyLine()
        {
 
        }
 
        public override ShapeType Type
        {
            get { return ShapeType.Polygon; }
        }
 
        protected override void ReadData(BinaryReader br)
        {
            Box = new[] { br.ReadDouble(), br.ReadDouble(), br.ReadDouble(), br.ReadDouble() };
 
            var numParts = br.ReadInt32();
            var numPoints = br.ReadInt32();
 
            Parts = new int[numParts];
            for (int i = 0; i < numParts; i++)
                Parts[i] = br.ReadInt32();
 
            Points = new ShpPoint[numPoints];
            for (int i = 0; i < numPoints; i++)
                Points[i] = new ShpPoint(br);
 
            // Судя по всем тут еще нужно строить 'кольца' - замкнутые области из точек
            // Каждое кольцо представляет из себя область точек длиной Parts[i+1] - Parts[i]
 
            Rings = new List<ShpPoint[]>(Parts.Length);
            if (Parts.Length > 1)
            {
                int i = 0;
                for (; i < Parts.Length - 1; i++)
                {
                    Rings.Add(Points.Skip(Parts[i]).Take(Parts[i + 1] - Parts[i]).ToArray());
                }
 
                Rings.Add(Points.Skip(Parts[i]).Take(Points.Length - Parts[i]).ToArray());
            }
            else
                Rings.Add(Points);
        }
 
        public double[] Box { get; set; }
        public int[] Parts { get; set; }
        public ShpPoint[] Points { get; set; }
 
        public List<ShpPoint[]> Rings { get; private set; }
    }
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
    class ShpPolygon : ShpObject
    {
        internal ShpPolygon(BinaryReader br)
        {
            ReadData(br);
        }
 
        public ShpPolygon()
        {
 
        }
 
        public override ShapeType Type
        {
            get { return ShapeType.Polygon; }
        }
 
        protected override void ReadData(BinaryReader br)
        {
            Box = new[] { br.ReadDouble(), br.ReadDouble(), br.ReadDouble(), br.ReadDouble() };
 
            var numParts = br.ReadInt32();
            var numPoints = br.ReadInt32();
 
            Parts = new int[numParts];
            for (int i = 0; i < numParts; i++)
                Parts[i] = br.ReadInt32();
 
            Points = new ShpPoint[numPoints];
            for (int i = 0; i < numPoints; i++)
                Points[i] = new ShpPoint(br);
 
            // Судя по всем тут еще нужно строить 'кольца' - замкнутые области из точек
            // Каждое кольцо представляет из себя область точек длиной Parts[i+1] - Parts[i]
 
            Rings = new List<ShpPoint[]>(Parts.Length);
            if (Parts.Length > 1)
            {
                int i = 0;
                for (; i < Parts.Length - 1; i++)
                {
                    Rings.Add(Points.Skip(Parts[i]).Take(Parts[i + 1] - Parts[i]).ToArray());
                }
 
                Rings.Add(Points.Skip(Parts[i]).Take(Points.Length - Parts[i]).ToArray());
            }
            else
                Rings.Add(Points);
        }
 
        public double[] Box { get; set; }
        public int[] Parts { get; set; }
        public ShpPoint[] Points { get; set; }
 
        public List<ShpPoint[]> Rings { get; private set; }
    }
 
    sealed class ShpPointM : ShpPoint
    {
        internal ShpPointM(BinaryReader br)
        {
            ReadData(br);
        }
 
        public ShpPointM()
        {
 
        }
 
        protected override void ReadData(BinaryReader br)
        {
            base.ReadData(br);
            M = br.ReadDouble();
        }
 
        public double M { get; set; }
    }
 
    unsafe static class DataTransformer
    {
        public static ushort EndianSwap(ushort x)
        {
            return (ushort)((x >> 8) | (x << 8));
        }
 
        public static short EndianSwap(short x)
        {
            return (short)EndianSwap((ushort)x);
        }
 
        public static uint EndianSwap(uint x)
        {
            return (x >> 24) |
                ((x << 8) & 0x00FF0000) |
                ((x >> 8) & 0x0000FF00) |
                (x << 24);
        }
 
        public static int EndianSwap(int x)
        {
            return (int)EndianSwap((uint)x);
        }
 
        public static ulong EndianSwap(ulong x)
        {
            return (x >> 56) |
                ((x << 40) & 0x00FF000000000000) |
                ((x << 24) & 0x0000FF0000000000) |
                ((x << 8) & 0x000000FF00000000) |
                ((x >> 8) & 0x00000000FF000000) |
                ((x >> 24) & 0x0000000000FF0000) |
                ((x >> 40) & 0x000000000000FF00) |
                (x << 56);
        }
 
        public static long EndianSwap(long x)
        {
            return (long)EndianSwap((ulong)x);
        }
 
        public static double EndianSwap(double x)
        {
            var v = EndianSwap(*(ulong*)&x);
            return *(double*)&v;
        }
    }
 
    public unsafe class ShpReader
    {
        private const int HeaderSize = 100;
        private ShpHeader mHeader;
        private readonly Stream mStream;
        private readonly List<ShpObject> mObjects;
        public List<ShpObject> objects
        {
            get { return mObjects; }
        }
 
        public ShpReader(Stream stream)
            : this()
        {
            mStream = stream;
            ReadHeader();
            ReadRecords();
        }
 
        private ShpReader()
        {
            mObjects = new List<ShpObject>();
        }
 
        private void ReadHeader()
        {
            var buff = new byte[HeaderSize];
            mStream.Read(buff, 0, buff.Length);
 
            fixed (byte* ptr = buff)
                mHeader = *(ShpHeader*)ptr;
 
            mHeader.FileCode = DataTransformer.EndianSwap(mHeader.FileCode);
            mHeader.FileLength = DataTransformer.EndianSwap(mHeader.FileLength);
        }
 
        private void ReadRecords()
        {
            var br = new BinaryReader(new BufferedStream(mStream));
            var length = mHeader.FileLength * 2;
            ShpObject shpObj = null;
 
            while (br.BaseStream.Position != br.BaseStream.Length && (shpObj = ReadRecord(br)) != null) 
                mObjects.Add(shpObj);
        }
 
        private ShpObject ReadRecord(BinaryReader br)
        {
            // Номер записи.
            var record = DataTransformer.EndianSwap(br.ReadInt32());
            // Длина указана в виде кол-ва слов (2-byte WORD), т.е. длина
            // в байтах будет: 'длина' * 2 - 4, где 4 - размер поля 'тип фигуры'.
            var length = DataTransformer.EndianSwap(br.ReadInt32());
            //var lengthInBytes = length * 2;
            // Тип фигуры
            var type = (ShapeType)br.ReadInt32();
           
            switch (mHeader.ShapeType)
            {
                case ShapeType.Point:
                        return new ShpPoint(br);
                case ShapeType.PointM:
                    return new ShpPointM(br);
                case ShapeType.PolyLine:
                    return new PolyLine(br);
                case ShapeType.Polygon:
                    return new ShpPolygon(br);
                default:
                    throw new NotSupportedException("This type of shape not supported.");
            }
        }
    }
}

public List<ShpObject> objects