Open in app

Sign in

Write

Sign in

Interfacing C# with Fortran

Bradrico Rigg
5 min readApr 30, 2021

Introduction

Fortran is not a dead language. Much scientific and financial code is written in Fortran. An example would be the BLAS library (Basic Linear Algebra Subprograms). To be able to call this huge base of code from a modern language such as C# is a very useful tool in the scientific programmer’s tool belt.

The code in this git gives examples of calling Fortran from C# using the C# P/Invoke method.

The assumption is that you have gfortran, make and the .NET 5.0 SDK installed either on Linux or on Windows in the WSL Linux subsystem. If not, directions for Ubuntu are given below.

Install gfortran

sudo apt-get install gfortran

Install make

sudo apt-get install build-essential

Install .NET 5.0 SDK

Install the .NET SDK

Modern Fortran

From Fortran Wiki:

iso_c_binding is a standard intrinsic module which defines named constants, types, and procedures for C interoperability.

iso_c_binding

The code in this git exploits this interoperability to call Fortran routines from C# using P/Invoke (Platform Invocation Services). Below is a Fortran subroutine we wish to call:

Example Fortran routine that can be called from C#.

subroutine myfortsub ( input_string ) bind ( C, name="myfortsub" )
​
   use iso_c_binding, only: C_CHAR, c_null_char
   implicit none
​
   character (kind=c_char, len=1), dimension (10), intent (in) :: input_string
   character (len=10) :: regular_string
   integer :: i
​
   regular_string = " "
   loop_string: do i=1, 10
      if ( input_string (i) == c_null_char ) then
         exit loop_string
      else
         regular_string (i:i) = input_string (i)
      end if
   end do loop_string
​
   write (*, *) ">", trim (regular_string), "<", len_trim (regular_string)
​
   return
​
end subroutine myfortsub
​

Example C# P/Invoke declaration to call subroutine above

[DllImport("myfortsub.so", CallingConvention = CallingConvention.Cdecl)]
 static extern void myfortsub(string str);

Example C# console project

Let’s walk through the steps to create a C# .NET 5.0 project to call the above Fortran subroutine.

Create console app using dotnet cli.

Open a terminal window and enter the following (I am doing it from my HOME directory):

$ dotnet new console -o CallFortranFromCSharp

Change directory to CallFortranFromCSharp

$ cd CallFortranFromCSharp

Edit Program.cs

Edit the Program.cs file to look as below:

using System;
using System.Runtime.InteropServices;
​
namespace CallFortranFromCSharp
{
    class Program
    {
        [DllImport("myfortsub.so", CallingConvention = CallingConvention.Cdecl)]
         static extern void myfortsub(string str);
​
        static void Main(string[] args)
        {
          myfortsub("Howdy");
        }
    }
}

Create file myfortsub.f95 and build shared library.

Cut and paste the Fortran subroutine above in your favorite editor and save it in the CallFortranFromCSharp directory as myfortsub.f95.

In the terminal window run the following command to create a shared library.

$ gfortran -shared -O2 myfortsub.f95 -o myfortsub.so -fPIC

Build C# console project and run it.

Run the following from the terminal window in the CallFortranFromCSharp directory.

$ dotnet build

Once it completes, copy the Fortran shared library to /Debug/net5.0.

$ cp myfortsub.so bin/Debug/net5.0

Run the following from the terminal window to run the app.

$ dotnet run

You should see the following output:

$ dotnet run
 >Howdy<           5

Using code in this git

The code in this git gives examples of passing strings, arrays and structs to Fortran from C#.

Modern Fortran (as of 2003) has the concept of a module to organize your subroutines and structures.

From the Fortran Wiki:

Module

Modules are used for object oriented programming.

General form

The general form is

module <name>
  <use statements>  
  <declarations>
contains
  <subroutines and functions>
end module <name>

Fortran Module

Module csharp_module.f95

In the git source csharp_module directory we have the source file csharp_module.f95. It has three example subroutines:

PassString — Allows C# to pass a C# string and the string length to Fortran.

subroutine PassString ( input_string, n) bind ( C, name="PassString" )
​
        use iso_c_binding, only: C_CHAR, c_null_char
        implicit none
     
        character (kind=c_char, len=1), dimension (n), intent (in) :: input_string
        integer(c_int), intent(in) :: n
​
        character (len=n) :: regular_string
        integer :: i
     
        regular_string = " "
        loop_string: do i=1, n
           if ( input_string (i) == c_null_char ) then
              exit loop_string
           else
              regular_string (i:i) = input_string (i)
           end if
        end do loop_string
     
        write (*, *) ">", trim (regular_string), "<", len_trim (regular_string)
     
        return
     
     end subroutine PassString

Fortran uses character arrays so the c string needs to be converted to a Fortran character array.

DegCtoF — Allows C# to pass arrays of floats. One array contains the Centigrade values to be converted and the subroutine fills the other array with Fahrenheit values.

subroutine DegCtoF(degC, degF, n)&
        bind(c, name = "DegCtoF")
    
        integer(c_int), intent(in) :: n
        real(c_double), intent(in), dimension(n) :: degC
        real(c_double), intent(out), dimension(n) :: degF
        integer :: i
    
        do i = 1, n
            degF(i) = ( degC(i) * 1.8 ) + 32
        end do
    
end subroutine DegCtoF

Notice the use of intent keyword to denote if value is an inbound, outbound or both value.

From the Fortran Wiki:

The intent(in) attribute of argument n means that n cannot be changed inside the subroutine.

The intent(out) attribute of argument degF means that degF can be changed inside the subroutine.

The intent(inout) attribute means it can be changed outside and inside the subroutine.

type, bind(c) :: point3d — Fortran type is similar to C# struct. We denote the point3d type as having c bindings and it’s members are all of c types such as real(c_float):: x .

type, bind(c) :: point3d
        real(c_float):: x
        real(c_float) :: y
        real(c_float) :: z
    end type point3d

fflip — Allows C# to pass struct pointers (using ref) to Fortran.

subroutine fflip(p) bind(c,name='fflip') ! bind with the fflip name 
         
        !declare our struct that will be passed. will pass in and values
        !and pass back values flipped
        type(point3d), intent(inout) :: p 
​
        real :: T
​
  
        T = p%x
        p%x = p%y
        p%y = T
        p%z = -2.*p%z
​
​
    end subroutine fflip
​

Notice the use of intent(inout) on the point3d subroutine parameter p. This allows the parameter to be modified by the subroutine.

Using the code in the git

The code in the git can be cloned and ran if gfortran, make and .Net 5.0 are installed either in Windows WSL or a Linux instance.

Clone code

$ git clone https://github.com/GroupTheorist12/CSharpFortran.git

Chmod runit.sh bash script

cd CSharpFortran
$ chmod 777 runit.sh

Run runit.sh bash script

$ ./runit.sh

produces the following output:

make: Entering directory '/home/brigg/CSharpFortran/csharp_module'
gfortran -shared -O2 csharp_module.f95 -o csharp_module.so -fPIC
make: Leaving directory '/home/brigg/CSharpFortran/csharp_module'
 >Howdy Doody Man<          15
0 : 32.00 [C] = 89.60 [F]
​
1 : 64.00 [C] = 147.20 [F]
​
values before fortran call: x = 3.00, y = 7.00, z = 9.00
values after fortran call: x = 7.00, y = 3.00, z = -18.00
C Sharp Programming
Fortran

--

--

Bradrico Rigg

Written by Bradrico Rigg

31 Followers

Help

Status

About

Careers

Press

Blog

Privacy

Terms

Text to speech

Teams