Using Pascal Libraries with .NET and Mono
English (en) |
italiano (it) |
日本語 (ja)
Introduction
With the .NET framework, Microsoft provided excellent compatibility for "unmanaged" code. While unmanaged code sounds like something wild and dangerous, it just means so-called "legacy" code in the form of native Windows libraries. The Mono project included similar support for native libraries on Linux and macOS. What this means is that you can compile libraries with Free Pascal and use them with .NET apps on Windows and with Mono apps on Linux and macOS.
A simple Pascal library
Copy and save this Pascal code to file SimpleLib.pas:
library SimpleLib;
function MySucc(AVal : Int64) : Int64; stdcall;
begin
Result := System.Succ(AVal);
end;
function MyPred(AVal : Int64) : Int64; stdcall;
begin
Result := System.Pred(AVal);
end;
exports
MySucc,
MyPred;
end.
Now compile the library with Free Pascal:
fpc -Sd SimpleLib.pas
On Windows, this will create file simplelib.dll. On macOS, this will create file libsimplelib.dylib. On Linux, this will create file simplelib.so. On macOS and Linux, rename the compiled library file to simplelib.dll:
mv libsimplelib.dylib simplelib.dll
A simple VB.NET app
Copy and save this VB.NET code to file TestLib.vb:
Imports System
Imports System.Runtime.InteropServices
Public Class TestLib
Const SimpLibName = "simplelib.dll"
'Declare external functions using the DllImport attribute.
<DllImport(SimpLibName, EntryPoint:="MySucc", _
CallingConvention:=CallingConvention.StdCall)> _
Public Shared Function Succ(ByVal AVal As Long) As Long
End Function
<DllImport(SimpLibName, EntryPoint:="MyPred", _
CallingConvention:=CallingConvention.StdCall)> _
Public Shared Function Pred(ByVal AVal As Long) As Long
End Function
Public Shared Sub Main()
Dim TestVal As Long
Try
TestVal = 123
Console.WriteLine("Value is " & TestVal)
Console.WriteLine("Successor is " & Succ(TestVal))
Console.WriteLine("Predecessor is " & Pred(TestVal))
Catch e As Exception
Console.WriteLine(e)
End Try
End Sub 'Main
End Class 'TestLib
If you have the .NET framework installed on Windows, you can compile this code as follows:
[pathto]vbc TestLib.vb
where [pathto] is the path to the .NET framework (example: c:\windows\microsoft.net\framework\v1.1.4322\ with .NET 1.1). This will create file TestLib.exe.
If you have Mono installed, you can also try compiling this code as follows:
vbnc TestLib.vb
You can also try compiling the C# version:
A simple C# app
Here's the equivalent C# code. Copy and save it to file TestLib.cs.
using System;
using System.Runtime.InteropServices;
public class TestLib {
const string SimpLibName = "simplelib.dll";
//Declare external functions using the DllImport attribute.
[DllImport(SimpLibName, EntryPoint="MySucc",
CallingConvention=CallingConvention.StdCall)]
public static extern long Succ(long AVal);
[DllImport(SimpLibName, EntryPoint="MyPred",
CallingConvention=CallingConvention.StdCall)]
public static extern long Pred(long AVal);
public static void Main()
{
long TestVal;
try
{
TestVal = 123;
Console.WriteLine("Value is " + TestVal);
Console.WriteLine("Successor is " + Succ(TestVal));
Console.WriteLine("Predecessor is " + Pred(TestVal));
}
catch(Exception e)
{
Console.WriteLine(e);
}
}
}
With .NET, you can compile it as follows:
[pathto]csc TestLib.cs
With Mono, you can compile it as follows:
mcs TestLib.cs
With both .NET and Mono, compiling will create file TestLib.exe.
A simple Pascal app using Oxygene
Copy and save this Pascal code to file TestLib.pas:
namespace TestLib;
interface
uses
System.Runtime.InteropServices;
const
SimpleLibName = 'simplelib.dll';
type
TestLib = class
private
[DllImportAttribute(SimpleLibName, EntryPoint:='MySucc',
CallingConvention:=CallingConvention.StdCall)]
class method Succ(AVal : Int64) : Int64; external;
[DllImportAttribute(SimpleLibName, EntryPoint:='MyPred',
CallingConvention:=CallingConvention.StdCall)]
class method Pred(AVal : Int64) : Int64; external;
public
class method Main;
end;
implementation
class method TestLib.Main;
var
TestVal : Int64;
begin
try
TestVal := 123;
Console.WriteLine('Value is ' + TestVal);
Console.WriteLine('Successor is ' + Succ(TestVal));
Console.WriteLine('Predecessor is ' + Pred(TestVal));
except
on E: Exception do
Console.WriteLine(E.Message);
end;
end;
end.
The Oxygene Object Pascal compiler is available from RemObjects Software.
With both .NET and Mono, you can compile TestLib.pas as follows:
[pathto]oxygene TestLib.pas
With both .NET and Mono, this will create file testlib.exe.
Running the simple app
With .NET, just run the compiled app as follows:
testlib
If .NET can find simplelib.dll, the app will output this to the console:
Value is 123 Successor is 124 Predecessor is 122
With Mono, run the compiled app as follows:
mono TestLib.exe
Mono will also look for file simplelib.dll -- that's the reason why we renamed the compiled library above on Linux and macOS.
Note that .NET/Mono ".exe" files don't contain actual native compiled code. Instead, they contain bytecode that is executed by the .NET/Mono runtime. As a result, you can take a .NET .exe file created on Windows and run it with Mono on macOS and Linux (and vice versa) without recompiling it. You will have to recompile your Pascal libraries for each platform you want to support.
When to use native libraries with .NET/Mono
Why not just code everything in VB.NET or C#? There are several situations where this might not be a good idea:
- When you have a large or complicated Pascal codebase that you don't want to rewrite (and re-debug) in C#.
- When you have native libraries that need to be used by both native and .NET/Mono apps.
- When there are performance reasons (presumably compiled FPC or Delphi native code is faster than the equivalent compiled bytecode run under .NET/Mono).
- When you need low-level operating system access not available easily with .NET/Mono.
- When you need to quickly develop code in a language you're more proficient in for a multi-developer .NET/Mono project.
Mono tips
1. Since Visual Basic is pretty foreign to Linux and macOS, you'll probably want to develop .NET and Mono apps using C#, which is similar to C++ (and Object Pascal). Or use the Oxygene compiler and develop your .NET and Mono apps with familiar Object Pascal.
2. Mono on macOS includes a script for uninstalling it. You can run this script before installing a newer version of Mono:
- In Finder, navigate to /Library/Receipts.
- Ctrl+click on MonoFramework.pkg and choose Show Package Contents from the popup menu.
- Double-click the Contents folder.
- Double-click the Resources folder.
- Drag a copy of uninstallMono.sh to the desktop.
- Open a Terminal window.
- cd desktop
- sudo ./uninstallMono.sh and enter your password.
3. In general, don't use any Lazarus units in your libraries. Libraries usually don't have a user interface. Confine your use to Free Pascal units like System, SysUtils, StrUtils, DateUtils, Classes, Variants and Math.
4. If you need a user interface to go with your library, program it as a Windows Forms application. Here's a simple form example. Copy and save this code to file MyForm.cs.
using System;
using System.Windows.Forms;
public class MyForm: Form
{
public MyForm ()
{
this.Text = "A .NET/Mono Windows Forms App";
this.Width = 400;
Button b = new Button();
b.Left = 15;
b.Top = 20;
b.Width = this.Width-30;
b.Height = 30;
b.Text = "Click Me";
b.Click += new EventHandler(button_Click);
this.Controls.Add(b);
}
void button_Click(object sender, EventArgs e)
{
MessageBox.Show("Hello");
}
}
public class MyApp
{
public static void Main()
{
MyForm aForm = new MyForm();
Application.Run(aForm);
}
}
Compile this code on Mono as follows:
mcs -r:System.Windows.Forms MyForm.cs
Run the app as follows:
mono MyForm.exe
On macOS, you can also create a normal app bundle using the macpack utility:
macpack -n MyForm -m winforms MyForm.exe
This creates the MyForm.app bundle, which can be double-clicked, dropped onto the Dock, etc.
5. On Linux and macOS, Mono now includes MonoDevelop, a simple IDE for editing and compiling code.
6. If you have any questions or comments about using Pascal libraries with .NET or Mono, please post them to the Lazarus forum.