Back to Questions
1.3k
views1
comment
Dummy Adapter Pattern
f#classes

I am trying to implement the Dummy Adapter Pattern, wherein a class implements all the methods of an interface with empty methods, then secondary classes can implement just the functionality they wish to provide. However, I can’t find the proper syntax to overload the interface methods declared in the base class.

For example, the following will output “base” twice, rather than “Restarting” followed by “Shutting down”:

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

#light
#r @"Interop.AgentServerObjects.dll"

open System
open AgentServerObjects

type AgentNotifySinkBase() =
    interface AgentServerObjects.IAgentNotifySink with
        member x.BalloonVisibleState(charId, bVisible) = ()
        member x.Size(charId, width, height) = ()
        member x.Move(charId, x, y, cause) = ()
        member x.Idle(charId, start) = ()
        member x.BookMark(bookmarkId) = ()
        member x.RequestComplete(requestId, status) = ()
        member x.RequestStart(requestId) = ()
        member x.DragComplete(charId,fwKeys,x,y) = ()
        member x.DragStart(charId,fwKeys,x,y) = ()
        member x.DblClick(charId,fwKeys,x,y) = ()
        member x.Click(charId,fwKeys,x,y) = ()
        member x.VisibleState(charId, bVisible, cause) = ()
        override x.Shutdown() = printfn "Base"
        member x.Restart() = ()
        member x.ActivateInputState(charId,bActivated) = ()
        member x.Command(command,userInput) = ()

type MySink() =
    inherit AgentNotifySinkBase() as base
    member x.Shutdown() = printfn "Shutting down"
    member x.Restart() = printfn "Restarting"

let callit (o :> #IAgentNotifySink) =
    o.Restart()
    o.Shutdown()

let a = new AgentNotifySinkBase()
let b = new MySink()

callit a
callit b
.

Hi James,

I'm not suprised you haven't found the correct syntax, its a little verbose:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#light
type TestInterface = interface
    abstract DoSomething: unit -> unit
end

type ImplementInterface() = class
    interface TestInterface with
        override x.DoSomething() = printfn "base"
    end
    abstract DoSomething: unit -> unit
    override x.DoSomething() = 
        let inter = x :> TestInterface 
        inter.DoSomething()
end

type OverrideClass() = class 
    inherit ImplementInterface()
    override x.DoSomething() = printfn "something"
end

let base = ImplementInterface()
base.DoSomething()
let child = OverrideClass()
child.DoSomething()

I think all this is necessary because in F# interfaces are implmented implicitly, so you need to hold a refrence to the interface to call there methods not just a refernce, this seems to interfere with overriding a method in a child class. The solution is to add a new virtual method on the interface of the class itself, annoyingly this adds quite a bit of extra code. I'm sure this is one of the things Don will be looking at in productization.

Cheers,
Rob

By on 10/30/2007 10:00 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