Author Topic: F# - Use WPF dialog button to draw a line (Read 6260 times)

MickD · « **on:** May 19, 2015, 07:25:23 PM »

Hi All,
this is a discussion on an F# version from this thread http://www.theswamp.org/index.php?topic=49471.0

I'm interested in the best way to do this as WPF and F# are not as advanced as one would like.
It's quite doable but takes a bit more of a lower level way of doing things.

Here's my quick interpretation to get the ball rolling, cheers. (Using Bricscad V15, change assembly ref's as required for AutoCAD)

The Xaml

Code - XML: [Select]

<Window xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:g='clr-namespace:WpfDialogSample;assembly=WpfDialogSample'
        Title="Window1" Height="100" Width="200">
 
    <Grid>
        <Button x:Name="DrawLine" Content="Draw Line" Margin="10" Width="100" Height="30"/>
    </Grid>
</Window>
 

The F# Code

Code - F#: [Select]

namespace WpfDialogSample
 
open System
open System.IO
open System.Windows
open System.Windows.Controls
open System.Windows.Markup
 
open Teigha.Runtime
open Teigha.DatabaseServices
open Teigha.Geometry
open Bricscad.EditorInput
open Bricscad.ApplicationServices
 
type AcAp = Bricscad.ApplicationServices.Application
 
// this should be refactored out to another file
module CadWorker =
    let DrawLine (window:Window) =
        let doc = AcAp.DocumentManager.MdiActiveDocument;
        let db = doc.Database;
 
        let p1 = new PromptPointOptions("Specify base point :");
        let rep1 = doc.Editor.GetPoint(p1);
        let pt1 = rep1.Value;
 
        if (rep1.Status <> PromptStatus.Cancel) then
            let mutable p2 = new PromptPointOptions("Next point :")
            p2.BasePoint <- pt1
            p2.UseBasePoint <- true
            let rep2 = doc.Editor.GetPoint(p2)
            let pt2 = rep2.Value
            if (rep2.Status <> PromptStatus.Cancel) then
                use tr = db.TransactionManager.StartTransaction()
                let mSpace = tr.GetObject(SymbolUtilityServices.GetBlockModelSpaceId(db), OpenMode.ForWrite) :?> BlockTableRecord
                let mutable line = new Line(pt1, pt2);
                line.ColorIndex <- 6;
                mSpace.AppendEntity(line) |> ignore
                tr.AddNewlyCreatedDBObject(line, true)
                tr.Commit()
        // a bit of a hack to close the dialog when done...
        window.Close()
 
type CommandMethods() =
 
    [<CommandMethod("TESTWPF", CommandFlags.Modal)>]
    member this.test() =
        // create the dialog by loading the xaml as a Window
        let win = XamlReader.Load(File.OpenRead("Window1.xaml")) :?> Window
 
        // Hook into xaml button element here
        let btn = win.FindName("DrawLine") :?> Button
 
        // Handle click event on 'DrawLine' button, we pass the window so we can close it when done (i.e. a hack)
        do btn.Click.Add( fun _ -> CadWorker.DrawLine win)
        win.Show()
 

gile · « **Reply #1 on:** May 21, 2015, 02:58:01 AM »

Nice Mick !

Starting from your example, I tried to make it closer to the MVVM pattern.

The Xaml
The button is bound to a Command which parameter is set to the window so that the command can close the window

Code - XML: [Select]

<Window xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:ViewModel="clr-namespace:ViewModel;assembly=AcadFsWpf"
        Name="mainWindow" 
        Title="Draw Line"
        WindowStartupLocation="CenterOwner" Height="100" Width="200">
    <Window.DataContext>
        <ViewModel:ViewModel/>
    </Window.DataContext>
    <Grid>
        <Button x:Name="drawLine" Content="Draw Line" Margin="10" Width="100" Height="30"
                Command="{Binding DrawLineCommand}" CommandParameter="{Binding ElementName=mainWindow}"/>
    </Grid>
</Window>

Model

Code - F#: [Select]

namespace Model
 
open System.Windows
open Autodesk.AutoCAD.ApplicationServices
open Autodesk.AutoCAD.DatabaseServices
open Autodesk.AutoCAD.EditorInput
open Autodesk.AutoCAD.Geometry
open Autodesk.AutoCAD.Runtime
 
type AcAp = Autodesk.AutoCAD.ApplicationServices.Application
 
module CadWorker = 
    let drawLine (param : obj) =
        let doc = AcAp.DocumentManager.MdiActiveDocument
        let db = doc.Database
        let ed = doc.Editor
        Autodesk.AutoCAD.Internal.Utils.SetFocusToDwgView();
        let ppr = ed.GetPoint("\nStart point: ")
        if ppr.Status = PromptStatus.OK then
            let p1 = ppr.Value
            let opts = PromptPointOptions("\nEnd point: ", BasePoint = p1, UseBasePoint = true)
            let ppr = ed.GetPoint(opts)
            if ppr.Status = PromptStatus.OK then
                use docLock = doc.LockDocument()
                use tr = db.TransactionManager.StartTransaction()
                let btr = tr.GetObject(db.CurrentSpaceId, OpenMode.ForWrite) :?> BlockTableRecord
                let line = new Line(p1, ppr.Value)
                btr.AppendEntity(line) |> ignore
                tr.AddNewlyCreatedDBObject(line, true)
                tr.Commit();
                (param |> unbox<Window>).Close()

View

Code - F#: [Select]

namespace View
 
open System
open System.IO
open System.Windows
open System.Windows.Markup
open System.Xaml
open Autodesk.AutoCAD.ApplicationServices
open Autodesk.AutoCAD.Runtime
 
type AcAp = Autodesk.AutoCAD.ApplicationServices.Application
 
type CommandMethods() =
    [<CommandMethod("Test")>]
    member x.Test () =
        let win = XamlReader.Load(File.OpenRead("MainWindow.xaml")) :?> Window
        AcAp.ShowModelessWindow(win)

ViewModel

Code - F#: [Select]

namespace ViewModel
 
open System
open System.Windows.Input
open Model
 
type RelayCommand (canExecute:(obj -> bool), action:(obj -> unit)) =
    let event = new DelegateEvent<EventHandler>()
    interface ICommand with
        [<CLIEvent>]
        member x.CanExecuteChanged = event.Publish
        member x.CanExecute arg = canExecute(arg)
        member x.Execute arg = action(arg)
 
type ViewModel() =
     member x.DrawLineCommand =
        new RelayCommand(
            (fun _ -> true),
            (fun p -> CadWorker.drawLine p))  

MickD · « **Reply #2 on:** May 21, 2015, 03:08:36 AM »

Very nice!

I'll have to absorb that for a bit but it looks pretty straight forward.

I tried to use

Code - F#: [Select]

let win = XamlReader.Load(File.OpenRead("MainWindow.xaml")) :?> Window
AcAp.ShowModelessWindow(win)
 

but got a cast error with the win object not being of type 'Form'. I'll re-check my references with yours, maybe it's a Bricscad thing(?).

Thanks for your input Gile.

gile · « **Reply #3 on:** May 21, 2015, 03:34:01 AM »

Attached a screenshot with my references.

The next step should be to add a base type in the ViewModel which implements INotifyPropertyChanged so that the bound properties can notify a changed property.

Code - F#: [Select]

namespace ViewModel
 
open System
open System.Windows.Input
open System.ComponentModel
open Model
 
type ViewModelBase() =
    let propertyChangedEvent = new DelegateEvent<PropertyChangedEventHandler>()
    interface INotifyPropertyChanged with
        [<CLIEvent>]
        member x.PropertyChanged = propertyChangedEvent.Publish
    member x.OnPropertyChanged propertyName = 
        propertyChangedEvent.Trigger([| x; new PropertyChangedEventArgs(propertyName) |])
 
type RelayCommand (canExecute:(obj -> bool), action:(obj -> unit)) =
    let event = new DelegateEvent<EventHandler>()
    interface ICommand with
        [<CLIEvent>]
        member x.CanExecuteChanged = event.Publish
        member x.CanExecute arg = canExecute(arg)
        member x.Execute arg = action(arg)
 
type ViewModel() =
    inherit ViewModelBase()
    member x.DrawLineCommand =
        new RelayCommand(
            (fun _ -> true),
            (fun p -> CadWorker.drawLine p))  

gile · « **Reply #4 on:** May 22, 2015, 05:36:17 PM »

Hi,

Mick, I really thank you.
You have motivated me to get back a little to F# that I did not have much time to learn these days.
As I also try to learn WPF, mixing the two is fun.

Here's my last attempt. I tried to go a little further with WPF binding features and include some F# helpers (thanks to kaefer for this).
This time the window is run as a modal dialog, closed using DialogResult.

The Xaml

Code - XML: [Select]

<Window xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:ViewModel="clr-namespace:ViewModel;assembly=AcadFsWpf2013"
        Name="mainWindow" 
        Title="Draw Line" 
        WindowStartupLocation="CenterOwner" Height="120" Width="280" ResizeMode="NoResize">
    <Window.DataContext>
        <ViewModel:ViewModel/>
    </Window.DataContext>
    <Grid>
        <StackPanel Orientation="Vertical">
            <StackPanel Orientation="Horizontal" HorizontalAlignment="Center">
                <Label Content="Layer:" VerticalAlignment="Center"/>
                <ComboBox x:Name="layers" Margin="10" Width="200" Height="25"
                          ItemsSource="{Binding Layers}" SelectedItem="{Binding Layer}"/>
            </StackPanel>
            <StackPanel Orientation="Horizontal" HorizontalAlignment="Center">
                <Button x:Name="btnOK" Content="OK" Margin="10" Width="80" Height="25"
                        Command="{Binding OkCommand}" CommandParameter="{Binding ElementName=mainWindow}"/>
                <Button x:Name="btnCancel" Content="Cancel" Margin="10" Width="80" Height="25"
                        Command="{Binding CancelCommand}" CommandParameter="{Binding ElementName=mainWindow}"/>
            </StackPanel>
        </StackPanel>
    </Grid>
</Window>

Model

Code - F#: [Select]

namespace Model
 
open System
open Autodesk.AutoCAD.ApplicationServices
open Autodesk.AutoCAD.DatabaseServices
open Autodesk.AutoCAD.EditorInput
open Autodesk.AutoCAD.Geometry
open Autodesk.AutoCAD.Runtime
 
type AcAp = Autodesk.AutoCAD.ApplicationServices.Application
type AcEx = Autodesk.AutoCAD.Runtime.Exception
 
module Helpers = 
 
    let getObject<'a when 'a :> DBObject> (id : ObjectId) =
        id.GetObject(OpenMode.ForRead) :?> 'a
 
    let getObjects<'a when 'a :> DBObject>  : System.Collections.IEnumerable -> _ =
        let rxc = RXClass.GetClass(typeof<'a>)
        Seq.cast<ObjectId>
        >> Seq.choose (function
            | id when id.ObjectClass.IsDerivedFrom(rxc) -> Some(getObject<'a> id)
            | _ -> None)
 
    let addEntity (ent : #Entity) (btr : BlockTableRecord) =
        if not btr.IsWriteEnabled then btr.UpgradeOpen()
        let id = btr.AppendEntity(ent)
        btr.Database.TransactionManager.AddNewlyCreatedDBObject(ent, true)
        id
 
    type OptionBuilder() = 
        member b.Bind(x, f) = Option.bind f x
        member b.Return(x) = Some x
        member b.Zero() = None
 
    let opt = new OptionBuilder()
 
    let failIfNotOk (pr : #PromptResult) = 
        opt { if pr.Status = PromptStatus.OK then return pr }
 
    type Editor with
        member ed.GetPoint(pt, msg) =
            ed.GetPoint(new PromptPointOptions(msg, BasePoint = pt, UseBasePoint = true))
 
open Helpers
 
module CadWorker = 
 
    let getLayers () =
        let db = HostApplicationServices.WorkingDatabase
        use tr = db.TransactionManager.StartTransaction()
        db.LayerTableId
        |> getObject<LayerTable>
        |> getObjects<LayerTableRecord>
        |> Seq.map (fun l -> l.Name)
        |> Seq.toArray
 
    let drawLine (layer) =
        let doc = AcAp.DocumentManager.MdiActiveDocument
        let db = doc.Database
        let ed = doc.Editor
        let result = opt {
            let! pr1 = failIfNotOk (ed.GetPoint("\nStart point: "))
            let! pr2 = failIfNotOk (ed.GetPoint(pr1.Value, "\nEnd point: "))
            return (pr1, pr2) }
        match result with
        | None -> ()
        | Some (pr1, pr2) ->
            use tr = db.TransactionManager.StartTransaction()
            db.CurrentSpaceId
            |> getObject<BlockTableRecord>
            |> addEntity (new Line(pr1.Value, pr2.Value, Layer = layer)) |> ignore
            tr.Commit();

View

Code - F#: [Select]

namespace View
 
open System
open System.IO
open System.Windows
open System.Windows.Markup
open System.Xaml
open Autodesk.AutoCAD.ApplicationServices
open Autodesk.AutoCAD.Runtime
 
type AcAp = Autodesk.AutoCAD.ApplicationServices.Application
 
type CommandMethods() =
    [<CommandMethod("Test")>]
    member x.Test () =
        let win = XamlReader.Load(File.OpenRead("MainWindow.xaml")) :?> Window
        AcAp.ShowModalWindow(win) |> ignore
 
[<assembly: CommandClass(typeof<CommandMethods>)>]
do ()

ViewModel

Code - F#: [Select]

namespace ViewModel
 
open System
open System.ComponentModel
open System.Windows
open System.Windows.Input
 
type ViewModelBase() =
    let propertyChangedEvent = new DelegateEvent<PropertyChangedEventHandler>()
    interface INotifyPropertyChanged with
        [<CLIEvent>]
        member x.PropertyChanged = propertyChangedEvent.Publish
    member x.OnPropertyChanged propertyName = 
        propertyChangedEvent.Trigger([| x; new PropertyChangedEventArgs(propertyName) |])
 
type RelayCommand (canExecute:(obj -> bool), action:(obj -> unit)) =
    let event = new DelegateEvent<EventHandler>()
    interface ICommand with
        [<CLIEvent>]
        member x.CanExecuteChanged = event.Publish
        member x.CanExecute arg = canExecute(arg)
        member x.Execute arg = action(arg)
 
open Model.CadWorker
 
type ViewModel() =
    inherit ViewModelBase()
 
    let mutable layer = "0"
 
    let resultOk param =
        (unbox<Window> param).DialogResult <- Nullable(true)
        drawLine(layer)
 
    let resultCancel param =
        (unbox<Window> param).DialogResult <- Nullable(false)
 
    member x.Layer
        with get () = layer
        and set v = layer <- v
 
    member x.Layers
        with get () = getLayers()
 
    member x.OkCommand =
        new RelayCommand((fun _ -> true), resultOk)  
 
    member x.CancelCommand =
        new RelayCommand((fun _ -> true), resultCancel) 
 
 

MickD · « **Reply #5 on:** May 22, 2015, 07:32:17 PM »

Thank You Gile,
There is not much out there for F# WPF or with AutoCAD so every bit helps!

I'll try to take a closer look later today, there's a bit to absorb and test with here, thanks.

MexicanCustard · « **Reply #6 on:** May 26, 2015, 08:21:42 AM »

Code - XML: [Select]

<Window xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:ViewModel="clr-namespace:ViewModel;assembly=AcadFsWpf2013"
        Name="mainWindow" 
        Title="Draw Line" 
        WindowStartupLocation="CenterOwner" Height="120" Width="280" ResizeMode="NoResize">
    <Window.DataContext>
        <ViewModel:ViewModel/>
    </Window.DataContext>
    <Grid>
        <StackPanel Orientation="Vertical">
            <StackPanel Orientation="Horizontal" HorizontalAlignment="Center">
                <Label Content="Layer:" VerticalAlignment="Center"/>
                <ComboBox Margin="10" Width="200" Height="25"
                          ItemsSource="{Binding Layers}" SelectedItem="{Binding Layer}"/>
            </StackPanel>
            <StackPanel Orientation="Horizontal" HorizontalAlignment="Center">
                <Button Content="OK" Margin="10" Width="80" Height="25"
                        Command="{Binding OkCommand}" CommandParameter="{Binding ElementName=mainWindow}"/>
                <Button Content="Cancel" Margin="10" Width="80" Height="25" IsCancel="True"/>
            </StackPanel>
        </StackPanel>
    </Grid>
</Window>

Some tweaks as you're learning WPF
1. Don't give names to Controls that you're not referencing somewhere else. You're just causing WPF to declare a bunch of variables in code behind that you're never using.
2. You can set your Cancel Button's IsCancel property to true and achieve the same result without creating a Command Binding. All bindings take overhead and until .NET 2015 are created at runtime taking more processor cycles.

Personally I set my OK button's click event in the code behind then you just set DialogResult to True and your done. In the spirit of MVVM the OK buttons action is part of the window's behavior and even if the model changes the OK button's behavior will always be the same. That's just my personal preference.

gile · « **Reply #7 on:** May 26, 2015, 03:19:22 PM »

Thank you very much for your advices MexicanCustard.

I do agree for the control's names and the IsCancel property.

In this case, about the OK button, I thaught it was a good thing to set the action in the ViewModel because it requires the selected layer which is set in the ViewModel too.

Another thing to keep in mind is that F# doesn't natively provides the same features as C# or VB to build WPF objects (neither WinForms) so we have to use some tricks. The one used here (nicely provided by MickD) is to add a xaml file to the F# project and load it with XamlReader.Load() method. This way doesn't provide any "*.xaml.fs" file for the code behind.

Anyway, thanks again, your knowledge is very helpfull.

Jeff H · « **Reply #8 on:** May 26, 2015, 10:10:59 PM »

Quote from: MexicanCustard on May 26, 2015, 08:21:42 AM

Personally I set my OK button's click event in the code behind

I'm so MVVM this is my typical code behind file

Code - C#: [Select]

using System;
namespace MVVM.Master
{
    public partial class MVVMWpf : Window
    {
 
    }
}
 

kaefer · « **Reply #9 on:** May 30, 2015, 02:51:35 PM »

Quote from: gile on May 22, 2015, 05:36:17 PM

ViewModel
Code - F#: [Select]
type ViewModelBase() =
let propertyChangedEvent = new DelegateEvent<PropertyChangedEventHandler>()
interface INotifyPropertyChanged with
[<CLIEvent>]
member x.PropertyChanged = propertyChangedEvent.Publish
member x.OnPropertyChanged propertyName =
propertyChangedEvent.Trigger([| x; new PropertyChangedEventArgs(propertyName) |])

Nice WPF demo. Let me suggest to use the standard F# event here, Control.Event<'Delegate,'Args>_MSDN.

Code - F#: [Select]

type ViewModelBase() =
    let propertyChangedEvent = Event<_,_>()
    interface INotifyPropertyChanged with
        [<CLIEvent>] member x.PropertyChanged = propertyChangedEvent.Publish
    member x.OnPropertyChanged propertyName =
        propertyChangedEvent.Trigger(x, PropertyChangedEventArgs propertyName)

Quote from: gile on May 22, 2015, 05:36:17 PM

ViewModel
Code - F#: [Select]
type ViewModel() =
inherit ViewModelBase()

let mutable layer = "0"

member x.Layer
with get () = layer
and set v = layer <- v

F# supports automatically implemented properties_MSDN.

Code - F#: [Select]

type ViewModel() =
    inherit ViewModelBase()
 
    member val Layer = "0" with get,set

Quote from: gile on May 26, 2015, 03:19:22 PM

Another thing to keep in mind is that F# doesn't natively provides the same features as C# or VB to build WPF objects (neither WinForms) so we have to use some tricks. The one used here (nicely provided by MickD) is to add a xaml file to the F# project and load it with XamlReader.Load() method.

We're missing partial classes in F# and therefore Code-Behind. I'd like to solicit opinions on the advisability of embedding xaml-files into the assembly, to be loaded as Referenced Assembly Resource File_MSDN.

Code - F#: [Select]

type CommandMethods() =
    [<CommandMethod("Test")>]
    member x.Test () =
        let uri = Uri @"pack://application:,,,/AcadFsWpf2013;component/MainWindow.xaml"
        let info = Application.GetResourceStream uri
        info.Stream
        |> XamlReader.Load
        |> unbox<Window>
        |> AcAp.ShowModalWindow
        |> ignore
 
[<assembly: CommandClass(typeof<CommandMethods>)>]
()

gile · « **Reply #10 on:** May 30, 2015, 04:10:49 PM »

Nice suggestions, thanks kaefer.

MickD · « **Reply #11 on:** August 14, 2015, 03:33:47 AM »

It's been a while since I've had time to play but I've strung most of what you guys have here into something that works ok.

Some things didn't work out but they were only minor.
Things like DialogResult and ShowModalDialog I couldn't get to work.
Also, setting IsCancel="true" in the xaml rather than binding a command didn't seem to work out either. I think this has more to do with the fact that the xaml is a partial class to the view model (under the hood) and we can't have a partial class in F#, I tried everything I could but what I have now works.

I also added some code that loads the xaml as a resource at runtime rather than having to load it from text and compile it.
You will need to set the 'Build Action' property of the .xaml file to 'Resource'
Thanks for the help!

Here's the main changes I made to the ViewModel class:

Code - F#: [Select]

    let resultOk param =
        let win = unbox<Window> param
        win.Hide()
        drawLine(layer)
        win.Show()
 
    let resultCancel param =
        (unbox<Window> param).Close()
 

And here's how I loaded the xaml resource:

Code - F#: [Select]

(*--- Helper Functions for wpf ---*)
module FsWpfHelpers = 
    let (?) (this : Control) (prop : string) : 'T =
            this.FindName(prop) :?> 'T
 
    let LoadXaml<'a>(appName : string, xamlFileName : string) =
        let uri = @"/" + appName + ";component/" + xamlFileName + ""
        Application.LoadComponent(
            new Uri(uri, UriKind.Relative)) :?> 'a
 
open FsWpfHelpers
type CommandMethods() =
    [<CommandMethod("Test")>]
    member x.Test () =
        let win = LoadXaml<Window>("WpfDialogSample", "Window1.xaml")
        win.Show()
 
[<assembly: CommandClass(typeof<CommandMethods>)>]
do ()
 

And the xaml:

Code - XML: [Select]

<Window xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:ViewModel="clr-namespace:WpfDialogSample;assembly=WpfDialogSample"
        Name="mainWindow" 
        Title="Draw Line" 
        WindowStartupLocation="CenterOwner" Height="120" Width="280" ResizeMode="NoResize">
    <Window.DataContext>
        <ViewModel:ViewModel/>
    </Window.DataContext>
    <Grid>
        <StackPanel Orientation="Vertical">
            <StackPanel Orientation="Horizontal" HorizontalAlignment="Center">
                <Label Content="Layer:" VerticalAlignment="Center"/>
                <ComboBox Margin="10" Width="200" Height="25"
                          ItemsSource="{Binding Layers}" SelectedItem="{Binding Layer}"/>
            </StackPanel>
            <StackPanel Orientation="Horizontal" HorizontalAlignment="Center">
                <Button Content="OK" Margin="10" Width="80" Height="25"
                        Command="{Binding OkCommand}" CommandParameter="{Binding ElementName=mainWindow}"/>
                <Button Content="Cancel" Margin="10" Width="80" Height="25"
                        Command="{Binding CancelCommand}" CommandParameter="{Binding ElementName=mainWindow}"/>
            </StackPanel>
        </StackPanel>
    </Grid>
</Window>

MexicanCustard · « **Reply #12 on:** August 14, 2015, 09:48:01 AM »

Quote from: MickD on August 14, 2015, 03:33:47 AM

It's been a while since I've had time to play but I've strung most of what you guys have here into something that works ok.

Some things didn't work out but they were only minor.
Things like DialogResult and ShowModalDialog I couldn't get to work.
Also, setting IsCancel="true" in the xaml rather than binding a command didn't seem to work out either. I think this has more to do with the fact that the xaml is a partial class to the view model (under the hood) and we can't have a partial class in F#, I tried everything I could but what I have now works.

Interesting. Another reason to delay my exploration of F#.

MickD · « **Reply #13 on:** August 14, 2015, 07:38:47 PM »

true, it can be frustrating but it will only be a matter of time until F# tools catch up.

<off topic mumbling>
My interest in F# comes from my frustrations writing boiler plate code all the time in C#, F# is much more concise and easier to read (once you get over what all the 'let's are about).
Every time I write an if statement or for loop it drives me nuts and learning a functional language in my spare time has been very rewarding.
Ideally I'd use a Lisp but the similarities between F# and a Lisp are close enough and I've grown to like the pipe operator in preference to digging into paren's to see what's going on.
I love the way you can build very simple building block functions and string them together to build more interesting ones.

Having said that though, from learning a functional language I now have a much better understanding of Linq and Lambdas, the dangers/problems of immutability and how to code in a more expressive style in C#. Any C# I write/edit from now on will be a lot better (than what I used to write at least).

Even C++ (C++11 on) is getting more functional to cope with the onslaught of multi-core processors.

OO has dug itself into a pretty big hole and only by introducing more functional paradigms (such as immutability and higher order functions) will old code bases be able to be refactored to take advantage of new hardware technology.

It's not just hardware on a single machine either, think passing portions of your calculations to multi pc's in the cloud.

Here's an interesting article worth a read by Joel Spolsky (written nearly 10 years ago!) that explains a lot better my interest in this field
http://www.joelonsoftware.com/items/2006/08/01.html

No wonder people coming from lisp have a hard time learning OO, they took the 'telling' the program what to do into 'describing' what to do (i.e. expressions vs statements).

Jeff H · « **Reply #14 on:** August 15, 2015, 12:25:00 AM »

I thought F# was not used much in actual "designer-tooling code" UI and would use C# if not a as*hole and VB if a di*k, but the libraries used to dynamically build UI, creating, transforming, etc.. data would be F#.

I remember one guy who gave a interview for .NET Rocks worked for some kind casino type app that was very UI oriented but were using C# and would create new game about every week and F# cut it down to about a day. I think C# was still used in designer code of UI but F# libraries used to create UI controls, components, etc....

News:

Author Topic: F# - Use WPF dialog button to draw a line (Read 6260 times)

MickD

F# - Use WPF dialog button to draw a line

gile

Re: F# - Use WPF dialog button to draw a line

MickD

Re: F# - Use WPF dialog button to draw a line

gile

Re: F# - Use WPF dialog button to draw a line

gile

Re: F# - Use WPF dialog button to draw a line

MickD

Re: F# - Use WPF dialog button to draw a line

MexicanCustard

Re: F# - Use WPF dialog button to draw a line

gile

Re: F# - Use WPF dialog button to draw a line

Jeff H

Re: F# - Use WPF dialog button to draw a line

kaefer

Re: F# - Use WPF dialog button to draw a line

gile

Re: F# - Use WPF dialog button to draw a line

MickD

Re: F# - Use WPF dialog button to draw a line

MexicanCustard

Re: F# - Use WPF dialog button to draw a line

MickD

Re: F# - Use WPF dialog button to draw a line

Jeff H

Re: F# - Use WPF dialog button to draw a line