Back to Questions
4.9k
views1
comment
Inheriting an F# class in C#
f#c#interface

Hi,

I'm sure this is a simple query, but I have a base class implemented in F# and I want to inherit from it using C#. However, the obvious way to do this gives an error with no suitable method found to override. I've consulted with google et al. but am none the wiser. Can someone point out the flaw in my F# please?

Thanks.

1
2
3
4
5
6
7
8
9
10
11
12

// Module1.fs
namespace M

    module m =
        type IFace2 = abstract DoIt : unit -> unit

        type Base2 () =
            interface IFace2 with
                member x.DoIt () = printfn "In Base2.DoIt"
            member x.Print a = 
                (x :> IFace2).DoIt ()
                printfn "In Base2.Print"
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

// Class1.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using M;

namespace CS_test
{
    public interface IFace1
    {
        void DoIt();
    } 

    public class Base1 : IFace1
    {
        public virtual void DoIt()
        {
            Console.WriteLine("In Base.DoIt");
        }

        public void Print(int a)
        {
            DoIt();
            Console.WriteLine("In Base1.Print");
        }
    }

    public class Class1 : Base1
    {
        public override void DoIt()
        {
            Console.WriteLine("In Class1.DoIt");
        }
    }

    public class Class2 : m.Base2
    {
        // error CS0115: 'CS_test.Class2.DoIt()': no suitable method found to override
        public override void DoIt()
        {
            Console.WriteLine("In Class2.DoIt");
        }
    }
}
.

In F#, all interface implementations are explicit, which means that the C# analog of your code would be

1
2
3
4
5
6

public class Base2 : IFace2 {
    void IFace2.DoIt() { 
        Console.WriteLine("In Base2.DoIt");
    }
    ...
}

So you'll have to add an additional public virtual method to your class so that subclasses can override it - this can use the same name as the interface's method.  Declaring a virtual method in F# is slightly tricky: you declare an abstract method slot and then define the initial implementation:

1
2
3
4
5
6
7
8

type Base2 () =
    interface IFace2 with
        member x.DoIt () = x.DoIt()
    abstract DoIt : unit -> unit
    default x.DoIt() = printfn "In Base2.DoIt"
    member x.Print a = 
        (x :> IFace2).DoIt ()
        printfn "In Base2.Print"

Here I've made the interface call into the virtual method so that overriding it in a derived class will also change the behavior when an instance of the derived class is upcast to the interface.

Hope that helps.

-Keith

By on 10/5/2011 1:29 PM ()

    Topic tags

    IntelliFactory Offices Copyright (c) 2011-2012 IntelliFactory. All rights reserved.
    Home | Products | Consulting | Trainings | Blogs | Jobs | Contact Us | Terms of Use | Privacy Policy | Cookie Policy     		Built with WebSharper