Comment implémenter une classe abstraite en F #?

Question

Après avoir vu this session PDC je voulais essayer d'apprendre un peu de F #. J'ai donc pensé que le meilleur moyen serait de réécrire en F # quelque chose que j'ai déjà fait en C# mais mon cerveau refuse de penser en mode fonctionnel. J'ai cette classe abstraite qui a quelques méthodes abstraites et quelques méthodes virtuelles. Je voudrais également remplacer certaines méthodes virtuelles. Cette classe est écrite en C# et compilée et je n'ai pas l'intention de la réécrire en F #. Donc, ma question est la suivante:

1. que quelqu'un a un court échantillon de la façon de mettre en œuvre une classe abstraite, méthode abstraite et méthode virtuelle
2. puis-je avoir surchargé les constructeurs?
3. Y at-il des contraintes si je veux le compiler dans une DLL et le rendre disponible pour mes programmes basés sur C#.

Toute aide serait appréciée.

---

Mise à jour: J'ai vraiment apprécié la réponse de Brian, mais il est toujours pas clair pour moi donc je tiens à préciser. Supposons que ce soit ma classe abstraite écrite en C# et compilée en dll. Comment l'implémenter en F #?

public abstract class MyAbstractClass 
{ 
    public abstract Person GetFullName(string firstName, string lastName); 

    public abstract bool TryParse(string fullName, out Person person); 

    public virtual IEnumerable<Person> GetChildren(Person parent) 
    { 
     List<Person> kids = new List<Person>(); 
     foreach(Child person in GroupOfPeople) 
     { 
      if(person.Parent == parent) 
       kids.Add(child as Person); 
     } 
     return kids; 
    } 

    public virtual IEnumerable<Child> GroupOfPeople { get; set; } 
} 

---

documentation pour quiconque est à la recherche de quelques F # ressources: - si tout autre F # est intéressé à obtenir des documents que j'ai trouvé sur le blog de Don Syme (créateur de F #) free chapters of his book F# Expert. Vous pouvez les télécharger en format doc.

• monde réel Programmation fonctionnelle par Tomas Petricek a free chapter here

D'autres ressources qui pourraient intéresser:

• Scott Hanselman's blog poste
• Dustin Campbell's blog
• Tomas Petricek's blog
• La place pour F # - hubFS
• F# WIKI
• Microsoft Research

Answer 1

Voici quelques exemples de code

type IBaz = 
    abstract member Baz : int -> int 

[<AbstractClass>] 
type MyAbsClass() = 
    // abstract 
    abstract member Foo : int -> int 
    // virtual (abstract with default value) 
    abstract member Bar : string -> int 
    default this.Bar s = s.Length 
    // concrete 
    member this.Qux x = x + 1 

    // a way to implement an interface 
    abstract member Baz: int -> int 
    interface IBaz with 
     member this.Baz x = this.Baz x 

type MySubClass(z : int) = 
    inherit MyAbsClass() 
    override this.Foo x = x + 2 
    override this.Bar s = (base.Bar s) - 1 
    override this.Baz x = x + 100 
    member this.Z = z 
    new() = MySubClass(0) 

let c = new MySubClass(42)  
printfn "%d %d %d %d %d" c.Z (c.Foo 40) (c.Bar "two") (c.Qux 41) (c.Baz 42000)