InvalidOperationException in Fsharp.Core.dll

Question

So I am doing a simple personal project in winforms with F#. My code used to work, but now throws this exception for seemingly no reason.

An unhandled exception of type 'System.InvalidOperationException' occurred in FSharp.Core.dll

 Additional information: The initialization of an object or value resulted in an object or value being accessed recursively before it was fully initialized.

The code is a member method that is being invoked from the constructor of the form itself

    do
 //lots of other constructor code before this point
 // render the form
        form.ResumeLayout(false)
        form.PerformLayout()
        form.ReloadGoals



//several other members before here
    member form.ReloadGoals  =
        let x = 10  //crashes on this line

The website where I grabbed the template for the project I am using is this one. Unfortunately I have made some substantial additions to this.

I would be glad to post more code, but I need to know what code would be relevant exactly, as I am not exactly sure and don't want to bog down the post in extraneous code.

Also I can't really find a lot of documentation on System.InvalidOperationException. Every time I find it, it is being used as an example of an exception you can throw on your own, not what causes it.

Answer 1

See The F# 3.0 Language Specification (final version, PDF), §8.6.1 Primary Constructors in Classes:

During construction, no member on the type may be called before the last value or function definition in the type has completed; such a call results in an InvalidOperationException.

Almost certainly, your code in the question doesn't tell the full story. If you hit the above mentioned restriction, then there's somewhere an attempt to access a field or member not fully initialized.

Some example:

type X() as this =
    let x = this.X
    member __.X = 42
X()

One workaround might be to encapsulate the offending code in a member of its own and call that in the constructor instead. Another would be the wrapping in a function definition.

Answer 2

This will be an incomplete answer, since I cannot reproduce the problem (using F# interactive, the given example, the ReloadGoals modification, and Form.Show, the code runs fine). However, there are strange things happening:

• Taken from the template, there should be a handler method for the Form.Load event, which fires when the type is fully constructed. Why is additional loading code in the constructor instead of this event handler? Load exists precisely to counter this kind of problem with unorderly initialization.

• The template you are using isn't exactly sane F#. For example, initControls is a value of type unit that is evaluated where it is defined; its binding to a name is absolutely useless and should be replaced with a simple do. Writing initControls in the do block later has no effect at all. form.ResumeLayout(false); form.PerformLayout() should be equivalent to form.ResumeLayout(true), but I don't understand what these are doing in the constructor in the first place. The event handlers have two possibly unnecessary indirections: one to a delegate constructor, another to a method that has no real reason to exist -- the handlers should be lambdas or simple, private functions. Why are they public members?!

The error appearing in the question is probably caused by the usage of form in its own constructor. Move your new usage to the Load event handler, and it should work.

Personally, I would go further and ditch implementation inheritance by instantiating a plain Form and subscribing to its events. For example, in FSI, something similar to the template could be done like this:

open System.Drawing
open System.Windows.Forms

let form = new Form()
form.ClientSize <- new Size(600, 600)
form.Text <- "F# Form"

let formLabel = new Label()
formLabel.Text <- "Doubleclick test!"
formLabel.DoubleClick.Add <| fun _ -> form.Close() 
form.Controls.Add(formLabel)

form.Show()

which uses no inheritance at all. (In an application, you'd use Application.Run etc instead of form.Show().) This does not run into initialization problems as easily and, additionally, is very useful if you want to encapsulate the form inside a simpler type or even just a function.