If anyone want's to get this working in .net framework 4.7.2 Below is the modified code for C# 7.3

using System;
using System.IO;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Text;
using System.Text.RegularExpressions;

namespace MultiSimConverter
{
    internal class Program   // Changed from partial class (not needed here)
    {
        private const int BlockInfoSize = 8;
        private const int MaxBlockSize = 900000;

        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private unsafe delegate uint ProcessBufferFunc(byte* buf, uint* size, PKParam* param);

        [DllImport("IMPLODE.DLL", CallingConvention = CallingConvention.Cdecl, EntryPoint = "implode")]
        private static unsafe extern int Implode(
            ProcessBufferFunc read_func,
            ProcessBufferFunc write_func,
            byte* bWorkBuff,
            ref PKParam param,
            ref uint dwType,
            ref uint dwImplSize);

        [DllImport("IMPLODE.DLL", CallingConvention = CallingConvention.Cdecl, EntryPoint = "explode")]
        private static unsafe extern int Explode(
            ProcessBufferFunc read_func,
            ProcessBufferFunc write_func,
            byte* bWorkBuff,
            ref PKParam param);

        static void Main(string[] args)
        {
            if (args == null || args.Length < 1)
            {
                ErrorAndExit("No file provided.");
            }

            if (!File.Exists(args[0]))
            {
                ErrorAndExit("Provided file not found.");
            }

            if (!File.Exists("IMPLODE.DLL"))
            {
                ErrorAndExit("IMPLODE.DLL not found. Place the 32-bit IMPLODE.DLL in the same folder as the executable.");
            }

            var fileName = args[0];
            var fileData = File.ReadAllBytes(fileName);

            // Extract signature from the first 0x80 bytes
            var temp = Encoding.UTF8.GetString(fileData, 0, Math.Min(0x80, fileData.Length));
            var signatureMatch = SignatureRegex.Match(temp);
            var signature = signatureMatch.Value;

            FileStream stream = null;

            try
            {
                switch (signature)
                {
                    case "MSMCompressedElectronicsWorkbenchXML":
                        stream = File.Create(Path.ChangeExtension(fileName, ".xml"));
                        Decompress(fileData.AsSpan(36), stream);
                        break;

                    case "CompressedElectronicsWorkbenchXML":
                        stream = File.Create(Path.ChangeExtension(fileName, ".xml"));
                        Decompress(fileData.AsSpan(33), stream);
                        break;

                    case "MSMElectronicsWorkbench":
                        stream = File.Create(Path.ChangeExtension(fileName, ".ms14"));
                        Compress(fileData.AsSpan(), stream, "MSMCompressedElectronicsWorkbenchXML");
                        break;

                    case "ElectronicsWorkbench":
                        stream = File.Create(Path.ChangeExtension(fileName, ".ewprj"));
                        Compress(fileData.AsSpan(), stream, "CompressedElectronicsWorkbenchXML");
                        break;

                    default:
                        ErrorAndExit("Provided file is invalid or unsupported format.");
                        return;
                }

                if (stream.Length == 0)
                {
                    ErrorAndExit("Unable to convert file.");
                }

                stream.Flush(true);
                Console.WriteLine($"Success! Generated '{Path.GetFileName(stream.Name)}'.");
            }
            finally
            {
                stream?.Close();
                stream?.Dispose();
            }
        }

        private static void ErrorAndExit(string message)
        {
            Console.WriteLine(message);
            Environment.Exit(0);
        }

        private unsafe static void Compress(Span<byte> input, Stream stream, string signatureString)
        {
            var signature = Encoding.ASCII.GetBytes(signatureString);
            var outputBuffer = new byte[input.Length + 0x1000];
            var compressBuffer = new byte[0x8DD8];
            uint bAscii = 1;
            uint dwDictSize = 0x40 << 6;

            int bytesRead = 0;
            int bytesWritten = BlockInfoSize;

            while (bytesRead < input.Length)
            {
                fixed (byte* pCompressBuffer = compressBuffer)
                fixed (byte* pInput = &input[bytesRead])
                fixed (byte* pOutput = &outputBuffer[bytesWritten])
                {
                    var blockInfo = (BlockInfo*)pOutput;
                    var blockSize = Math.Min(input.Length - bytesRead, MaxBlockSize);

                    var param = new PKParam
                    {
                        pCompressedData = pInput,
                        pDecompressedData = pOutput + BlockInfoSize,
                        dwMaxRead = (uint)blockSize,
                        dwMaxWrite = (uint)(input.Length - bytesRead)
                    };

                    if (Implode(ReadBytes, WriteBytes, pCompressBuffer, ref param, ref bAscii, ref dwDictSize) != 0)
                    {
                        Console.WriteLine("Compression failed.");
                        return;
                    }

                    blockInfo->dwUncompressedSize = param.dwReadPos;
                    blockInfo->dwCompressedSize = param.dwWritePos;

                    bytesRead += (int)param.dwReadPos;
                    bytesWritten += (int)param.dwWritePos + BlockInfoSize;
                }
            }

            // Prepend total uncompressed size
            Unsafe.WriteUnaligned(ref outputBuffer[0], (uint)bytesRead);

            // Write signature + data
            stream.Write(signature, 0, signature.Length);
            stream.Write(outputBuffer, 0, bytesWritten);
        }

        private unsafe static void Decompress(Span<byte> input, Stream stream)
        {
            // Read total uncompressed size
            var uncompressedSize = Unsafe.ReadUnaligned<uint>(ref input[0]);
            if (uncompressedSize > 500_000_000) // safety limit
            {
                Console.WriteLine("Uncompressed size too large.");
                return;
            }

            var outputBuffer = new byte[uncompressedSize];
            var compressBuffer = new byte[0x8DD8];

            int bytesRead = BlockInfoSize;
            int bytesWritten = 0;

            while (bytesRead < input.Length)
            {
                fixed (byte* pCompressBuffer = compressBuffer)
                fixed (byte* pInput = &input[bytesRead])
                fixed (byte* pOutput = &outputBuffer[bytesWritten])
                {
                    var blockInfo = *(BlockInfo*)pInput;

                    var param = new PKParam
                    {
                        pCompressedData = pInput + BlockInfoSize,
                        pDecompressedData = pOutput,
                        dwMaxRead = blockInfo.dwCompressedSize,
                        dwMaxWrite = blockInfo.dwUncompressedSize
                    };

                    if (Explode(ReadBytes, WriteBytes, pCompressBuffer, ref param) != 0)
                    {
                        Console.WriteLine("Decompression failed.");
                        return;
                    }

                    bytesRead += (int)param.dwReadPos + BlockInfoSize;
                    bytesWritten += (int)param.dwWritePos;
                }
            }

            stream.Write(outputBuffer, 0, outputBuffer.Length);
        }

        private static unsafe uint ReadBytes(byte* buf, uint* size, PKParam* param)
        {
            var bytesToRead = Math.Min(param->dwMaxRead - param->dwReadPos, *size);
            Unsafe.CopyBlockUnaligned(buf, &param->pCompressedData[param->dwReadPos], bytesToRead);
            param->dwReadPos += bytesToRead;
            return bytesToRead;
        }

        private static unsafe uint WriteBytes(byte* buf, uint* size, PKParam* param)
        {
            if (param->dwWritePos + *size <= param->dwMaxWrite)
            {
                Unsafe.CopyBlockUnaligned(&param->pDecompressedData[param->dwWritePos], buf, *size);
            }
            param->dwWritePos += *size;
            return 0;
        }

        [StructLayout(LayoutKind.Sequential)]
        private struct BlockInfo
        {
            public uint dwUncompressedSize;
            public uint dwCompressedSize;
        }

        [StructLayout(LayoutKind.Sequential)]
        private unsafe struct PKParam
        {
            public byte* pCompressedData;
            public uint dwReadPos;
            public byte* pDecompressedData;
            public uint dwWritePos;
            public uint dwMaxRead;
            public uint dwMaxWrite;
        }

        private static readonly Regex SignatureRegex = new Regex(
            @"(MSM)?(Compressed)?ElectronicsWorkbench(XML)?",
            RegexOptions.Compiled);
    }
}