C#

Hello,

I have a dll created with delphi language (Borland Delphi 7) which thus contains functions in delphi which I would like to use in C# under Visual Studio 2017. It is a native dll.
I want to use for example the GENERATE_FILE function contained in test.dll.

Delphi code :
procedure GENERATE _FILE(Path, Input_File : AnsiString); stdcall; 


procedure GENERATE _FILE(Path, Input_File : AnsiString); stdcall;
var

begin
…
GENERATE_CALC(Path_And_File, CRC32, Total, err);
…
end;


In C#, I want to use the function GENERATE_FILE contained in test.dll but what is the type of the parameters Path and Input_File in C# ?

Below is an example of C# code I made to use test.dll in delphi in C#. I set string as a type for parameters of the function GENERATE_FILE.

namespace AppTest
{
    Public class Program
    {
        [DllImport("test.dll", CharSet = CharSet.Ansi)]
        public static extern bool CREATE_FILE(string pathDirectory, string filename);

        static void Main(string[] args)
        {
            GENERATE_FILE(@"C:\Users", "file.txt");
        }
    }
}

I added the test.dll in Visual Studio by right clicking on the project then add an existing element, then, in the properties of the test.dll, I put "Content" in Generation action and I put "Always copy "(output directory). When I run the solution, I have the test.dll in bin\Debug.

But when I test this program, I get the following error at the line that contains:
GENERATE_FILE(@"C:\Users", "file.txt");

System.DllNotFoundException: 'Unable to load DLL' test.dll ': The specified module could not be found. (Exception from HRESULT: 0x8007007E) '


How to solve this problem ?
I think the issue is about the type of parameters in the function GENERATE_FILE. What are the type equivalents between delphi and C# for the function GENERATE_FILE ?

Thank you for your help.

private byte[] ObjectToByteArray(Object obj)
{
    if (obj == null)
        return null;
    BinaryFormatter bf = new BinaryFormatter();
    MemoryStream ms = new MemoryStream();
    bf.Serialize(ms, obj);
    return ms.ToArray();
}

private void button5_Click(object sender, EventArgs e)
{
    byte[] bookData = null;
    byte[] bookDataSha = null;
    book bog = getBookById("6");
    bog.GetEbookHash(string.Format(@"H:\calibre\{0}\", bog.path), 6);

    using (var db = new MySqlConnection(@"server = xxxxxxx"))
    {
        MySql.Data.MySqlClient.MySqlDataReader myData;

        db.Open();
        MySqlCommand comm = db.CreateCommand();
        comm.CommandText = "select content from bookContent where id='6' and type='epub'";
        myData = comm.ExecuteReader();
        while (myData.Read())
        {
            bookData  = this.ObjectToByteArray(myData["content"]);
            bookDataSha = Sha256.ComputeHash(bookData);
        }
        db.Close();
    }

    if (bog.EpubHash == bookDataSha)
    {
        MessageBox.Show("success");
    }
    MessageBox.Show(bog.getEbookHashStr(bog.EpubHash)+" - "+bog.getEbookHashStr(bookDataSha));
}

public partial class Form2 : Form
{
    private enum ResizableRect
    {
        RightUp,
        RightMiddle,
        RightBottom,

        LeftUp,
        LeftMiddle,
        LeftBottom,

        UpMiddle,
        BottomMiddle,
        None
    };

    private int m_resizableRectSize = 6;

    private ResizableRect m_resizableRectNodeSelected = ResizableRect.None;

    Rectangle rect;
    Point StartXY;
    Point EndXY;

    int x = 0;
    int y = 0;

    bool m_isMouseDown = false;
    bool m_movingRect = false;

    public Form2()
    {
        InitializeComponent();
        this.DoubleBuffered = true;
    }

    private void panel1_Paint(object sender, PaintEventArgs e)
    {
        //if(rect != null)
        {
            Graphics gObj = panel1.CreateGraphics();

            Pen rectPen = new Pen(Color.Red, 2);
            rectPen.DashStyle = DashStyle.Dash;

            x = Math.Min(StartXY.X, EndXY.X);
            y = Math.Min(StartXY.Y, EndXY.Y);

            int height = Math.Abs(StartXY.X - EndXY.X);
            int width = Math.Abs(StartXY.Y - EndXY.Y);

            rect = new Rectangle(x, y, height, width);
            gObj.DrawRectangle(rectPen, rect);
            foreach (ResizableRect pos in Enum.GetValues(typeof(ResizableRect)))
            {
                gObj.DrawRectangle(new Pen(Color.Red), GetResizableRectNode(pos));
            }
        }
    }

    private void panel1_MouseDown(object sender, MouseEventArgs e)
    {
        m_resizableRectNodeSelected = GetNodeSelectable(e.Location);
        StartXY = e.Location;
        m_isMouseDown = true;
    }

    private void panel1_MouseMove(object sender, MouseEventArgs e)
    {
        this.Cursor = GetResizableRectCursorType(GetNodeSelectable(e.Location));

        if (rect.Contains(new Point(e.X, e.Y)))
        {
            //mMove = true;
            this.Cursor = Cursors.SizeAll;
        }
        else
        {
            switch (m_resizableRectNodeSelected)
            {
                case ResizableRect.LeftUp:
                    rect.X += e.X - EndXY.X;
                    rect.Width -= e.X - EndXY.X;
                    rect.Y += e.Y - EndXY.Y;
                    rect.Height -= e.Y - EndXY.Y;
                    break;
                case ResizableRect.LeftMiddle:
                    rect.X += e.X - EndXY.X;
                    rect.Width -= e.X - EndXY.X;
                    break;
                case ResizableRect.LeftBottom:
                    rect.Width -= e.X - EndXY.X;
                    rect.X += e.X - EndXY.X;
                    rect.Height += e.Y - EndXY.Y;
                    break;
                case ResizableRect.BottomMiddle:
                    rect.Height += e.Y - EndXY.Y;
                    break;
                case ResizableRect.RightUp:
                    rect.Width += e.X - EndXY.X;
                    rect.Y += e.Y - EndXY.Y;
                    rect.Height -= e.Y - EndXY.Y;
                    break;
                case ResizableRect.RightBottom:
                    rect.Width += e.X - EndXY.X;
                    rect.Height += e.Y - EndXY.Y;
                    break;
                case ResizableRect.RightMiddle:
                    rect.Width += e.X - EndXY.X;
                    break;

                case ResizableRect.UpMiddle:
                    rect.Y += e.Y - EndXY.Y;
                    rect.Height -= e.Y - EndXY.Y;
                    break;

                default:
                    if (m_isMouseDown)
                    {
                        rect.X = rect.X + e.X - EndXY.X;
                        rect.Y = rect.Y + e.Y - EndXY.Y;
                    }
                    break;
            }
        }

        if (m_isMouseDown)
        {
            EndXY = e.Location;
            panel1.Invalidate();
        }
    }

    private void panel1_MouseUp(object sender, MouseEventArgs e)
    {
        EndXY = e.Location;
        m_isMouseDown = false;
        m_movingRect = false;
        Invalidate();
    }

    private Rectangle DrawResizableRectNode(int x, int y)
    {
        return new Rectangle(x - m_resizableRectSize / 2, y - m_resizableRectSize / 2, m_resizableRectSize, m_resizableRectSize);
    }

    private ResizableRect GetNodeSelectable(Point p)
    {
        foreach (ResizableRect r in Enum.GetValues(typeof(ResizableRect)))
        {
            if (GetResizableRectNode(r).Contains(p))
            {
                //MessageBox.Show(r.ToString());
                Console.WriteLine("GetNodeSelectable: " + r.ToString());
                return r;
            }
        }

        return ResizableRect.None;
    }

    private Rectangle GetResizableRectNode(ResizableRect p)
    {
        switch (p)
        {
            case ResizableRect.LeftUp:
                return DrawResizableRectNode(rect.X, rect.Y);

            case ResizableRect.LeftMiddle:
                return DrawResizableRectNode(rect.X, rect.Y + rect.Height / 2);

            case ResizableRect.LeftBottom:
                return DrawResizableRectNode(rect.X, rect.Y + rect.Height);

            case ResizableRect.BottomMiddle:
                return DrawResizableRectNode(rect.X + rect.Width / 2, rect.Y + rect.Height);

            case ResizableRect.RightUp:
                return DrawResizableRectNode(rect.X + rect.Width, rect.Y);

            case ResizableRect.RightBottom:
                return DrawResizableRectNode(rect.X + rect.Width, rect.Y + rect.Height);

            case ResizableRect.RightMiddle:
                return DrawResizableRectNode(rect.X + rect.Width, rect.Y + rect.Height / 2);

            case ResizableRect.UpMiddle:
                return DrawResizableRectNode(rect.X + rect.Width / 2, rect.Y);
            default:
                return new Rectangle();
        }
    }


    private Cursor GetResizableRectCursorType(ResizableRect resizableRectPoint)
    {
        Cursor rectPositionCursor;
        switch (resizableRectPoint)
        {
            case ResizableRect.LeftUp:
                rectPositionCursor = Cursors.SizeNWSE;
                break;

            case ResizableRect.LeftMiddle:
                rectPositionCursor = Cursors.SizeWE;
                break;

            case ResizableRect.LeftBottom:
                rectPositionCursor = Cursors.SizeNESW;
                break;

            case ResizableRect.BottomMiddle:
                rectPositionCursor = Cursors.SizeNS;
                break;

            case ResizableRect.RightUp:
                rectPositionCursor = Cursors.SizeNESW;
                break;

            case ResizableRect.RightBottom:
                rectPositionCursor = Cursors.SizeNWSE;
                break;

            case ResizableRect.RightMiddle:
                rectPositionCursor = Cursors.SizeWE;
                break;

            case ResizableRect.UpMiddle:
                rectPositionCursor = Cursors.SizeNS;
                break;

            default:
                rectPositionCursor = Cursors.Default;
                break;
        }

        Console.WriteLine("GetResizableRectCursorType: " + rectPositionCursor.ToString());
        return rectPositionCursor;
    }
}