What is the F# equivalent of this C# code? - f#

Question

I used VB.Net when I started in C# there was a code translating site. It would be good to have this for F#
I wrote this C# code
public interface IData : INotifyPropertyChanged
{
Guid ID { get; set; }
}
public interface IVertex : INotifyPropertyChanged
{
}
public abstract class Vertex<IData>
{
public IData Properties { get; set; }
public Vertex() { }
public Vertex(IData Properties)
{
this.Properties = Properties ;
}
public string Tipo { get { return typeof(IData).Name; } }
}
public class Data_Person : IData
{
public event PropertyChangedEventHandler PropertyChanged;
public Guid ID { get; set; } = Guid.NewGuid();
public decimal Balance { get; set; }
public string Name { get; set; }
}
public class Person : Vertex<Data_Person>, IVertex
{
public Person()
{
this.Properties = new Data_Person();
}
public Person(Data_Person Properties) : base(Properties)
{ }
public event PropertyChangedEventHandler PropertyChanged;
}
public class EdgeLink<ISourceVertex, IEdgeData, ITargetVertex>
{
public EdgeLink()
{ }
public EdgeLink(ISourceVertex In, IEdgeData Edge, ITargetVertex Out)
{
this.In = In;
this.Properties = Edge;
this.Out = Out;
}
public ISourceVertex In { get; set; }
public IEdgeData Properties { get; set; }
public ITargetVertex Out { get; set; }
//public LoadStatus LoadStatus { get; set; } = LoadStatus.Uknown;
}
I am trying to do the same, but in F#.
How to 'translate' this to F# ?
I tried to translate, but it got messed, so far I have
type IData =
inherit INotifyPropertyChanged
abstract member ID: Guid with get, set
type IEdgeData =
inherit IData
type IVertex =
inherit INotifyPropertyChanged
type ISourceVertex =
inherit IVertex
type ITargetVertex =
interface
inherit IVertex
end

Answer 1

Since the comments indicate that you're having trouble with the event and the generic type, here's how you would convert those, specifically:
open System
open System.ComponentModel
type IData =
inherit INotifyPropertyChanged
abstract member ID: Guid
type IVertex = inherit INotifyPropertyChanged
[<AbstractClass>]
type Vertex<'data when 'data :> IData> (properties: 'data) =
member __.Properties = properties
member __.Tipo = typeof<'data>.Name
type DataPerson (id, balance, name) =
let propertyChanged = Event<_,_>()
member __.ID = id
member __.Balance = balance
member __.Name = name
interface IData with
member __.ID = id
[<CLIEvent>]
member __.PropertyChanged = propertyChanged.Publish
You just need a generic type variable 'data constrained to be an IData for the Vertex class and an F# Event<_,_> with a [] property for the PropertyChanged event.
Note, I left out the setters on the properties here. You can easily add them back if you really need them.
EDIT
Adding the person class:
type Person (person) =
inherit Vertex<DataPerson>(person)
let propertyChanged = Event<_,_>()
interface IVertex with
[<CLIEvent>]
member this.PropertyChanged = propertyChanged.Publish
EDIT 2
Adding optional parameters in constructors (I also made the Vertex.Properties property mutable this time, since it wouldn't make much sense to keep it immutable if you could instantiate the class with it uninitialized). I probably wouldn't do it this way in a pure-F# solution, but this is a more direct representation of the original C# code:
[<AbstractClass>]
type Vertex<'data when 'data :> IData> (?properties: 'data) =
let vertexProperties = defaultArg properties Unchecked.defaultof<'data>
member val Properties = vertexProperties with get,set
member __.Tipo = typeof<'data>.Name
type DataPerson (id, balance, name) =
let propertyChanged = Event<_,_>()
member __.ID = id
member __.Balance = balance
member __.Name = name
interface IData with
member __.ID = id
[<CLIEvent>]
member __.PropertyChanged = propertyChanged.Publish
type Person (?person) =
inherit Vertex<DataPerson>(defaultArg person Unchecked.defaultof<DataPerson>)
let propertyChanged = Event<_,_>()
interface IVertex with
[<CLIEvent>]
member this.PropertyChanged = propertyChanged.Publish