COM Callable Wrapper not working when called from delphi program

I've been requested to create a .Net dll for an old delphi program. I'm trying to do this with a COM Callable Wrapper, but I keep getting an error when it tries to load the dll (pretty general, something like "I couldn't load the dll"). Here is what the technical documentation says:

The DLL only needs to export one function under the name 'AUTHORIZE'.

function Authorize(InXml: PChar): PChar; stdcall;
(Delphi syntax. May be different in other languages.)

Here is my code for the CCW:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.InteropServices;

namespace ComCallableWrapper
{
    [Guid("C3FD922A-FB44-47B1-9C0C-8F7FAF57098B")]
    [InterfaceType(ComInterfaceType.InterfaceIsIDispatch)]
    public interface IAuthorizer
    {
        [DispId(1)]
        string Authorize(string lnpInXml);
    }

    [ProgId("ComCallableWrapper.Authorizer")]
    [ClassInterface(ClassInterfaceType.None)]
    public class Authorizer : IAuthorizer
    {
        public Authorizer()
        {
        }

        public string Authorize(string lnpInXml)
        {
            return "Approved!";
        }
    }
}

I also run this command "regasm /tlb:ComCallableWrapper.tlb ComCallableWrapper.dll /codebase" on the computer where the delphi program is running.

I've been doing some research on google about how delphi invokes functions on a dll, and I found at least 2 ways:

function Authorize(lnpInXml: pchar): pchar; stdcall; external 'DLLName.dll';

and

oleObject := CreateOleObject('ComCallableWrapper.Authorizer');
ShowMessage(oleObject.Authorize('Approved?'));

It looks like COM works a little bit different. Is there a way to change my CCW to work like the first way?

Regards.

Solution

You con't need COM. And indeed using COM is a mistake because the Delphi program is not looking for a COM DLL.

What you need to do is to export an unmanaged function from your managed C# DLL. That's a little tricky and is in fact not supported. These are your most attractive options:

Use Robert Giesecke's UnmanagedExports.
Write a mixed mode C++/CLI DLL that consumes your C# code. The mixed mode C++/CLI is capable of export native functions using __declspec(dllexport), .def files etc.

If you chose to use UnmanagedExports, the function would look like this:

[DllExport]
public static IntPtr Authorize(string InXml)
{
    // your code goes here, for now return the input value
    return Marshal.StringToHGlobalAnsi(InXml);
}

Implementing the function is a little tricky because you need to return a Delphi PAnsiChar, that is a C++ char*. You cannot use string for the return type and have to use IntPtr. But how do you allocate the string so that it remains valid for the caller to use it. The code above leaks the string in an HGLOBAL.

I can't advise you definitively how to resolve the lifetime of the string. The interface you are coding to is not at all well designed. Only you with more knowledge of the interface are in a position to resolve that issue.