F# supports functional programming constructs such as the following:

• Functions as values, which enables flexible manipulation of functions. For more information, see Functions as First-Class Values (F#).

• Function composition and pipelining, which enables you to combine functions together to create new functions and to simplify the coding of successive operations on data. For more information, see Functions (F#).

• Type inference, which reduces the requirement to explicitly call out types without sacrificing type safety.

• Automatic generalization, which promotes code reuse by making it easy to write code that works with a variety of different types without any additional effort.

• Pattern matching support, which simplifies complex conditional code, and discriminated unions, which are optimized to be used with pattern matching.

• Collection types for working with immutable data, including list and sequence types.

• Lambda expressions, which are important to many functional programming constructs.

• Partial application of function arguments, which enables you to create new functions implicitly from existing ones. For more information, see Functions (F#).

• Code Quotations, a feature that enables you to manipulate F# expressions programmatically.

F# supports object-oriented programming and .NET Framework capabilities such as the following:

• The .NET Framework object model, including objects that have properties, methods, and events; polymorphism or virtual functions; inheritance; and interfaces.

• Data encapsulation, or separating the public interface of a type from the implementation.

• Operator overloading that works well with generics and built-in primitive types.

• Type extensions, which enable you to extend an existing type easily without the additional overhead work of creating a new derived type.

• Object expressions, which enable you to define small objects implicitly in expressions as needed, instead of declaring a new type and instantiating an object.

• Access to the .NET Framework and any managed code assembly.

• Access to native code through platform invoke.

F# also supports all the common imperative programming constructs, such as branching and looping constructs.

The Visual F# product also includes an F# library that has many useful functions and types. This includes APIs for collections such as lists, arrays, maps, sets, and sequences. The F# library also supports reflection, events, and formatted I/O.

In addition, the F# library includes support for asynchronous workflows to support parallel computations, and mechanisms for communicating among parallel workflows. For more information, see Asynchronous Workflows (F#), Control.Async Class (F#), and Control.MailboxProcessor<'Msg> Class (F#).

The main F# library is FSharp.Core.dll. Additional libraries are available in the F# PowerPack, which is available on the Microsoft F# Developer Center Web site.

Visual F# provides an interactive window that is integrated into the Visual Studio development environment. This window enables you to enter F# code and have it immediately compiled and executed. This enables you to easily prototype code constructs and test your code while you write it. The interactive window runs the F# interactive tool, fsi.exe, which you can also run from the command line. This feature allows F# to be used as a scripting language. For more information, see F# Interactive (fsi.exe) Reference.

F# is integrated with Visual Studio, and has support for the following:

• Projects, including templates for common project types. For more information, see Using Visual Studio to Write F# Programs and Configuring Projects (F#).

• IntelliSense. For more information, see Using IntelliSense.

• Debugging. For more information, see Debugging in Visual Studio.

• Deployment. To run F# programs on a computer, you must have the F# runtime components installed. These components are installed by the F# Redistributable Package.

• For more information, see F# Development Environment Features.

Other Resources

F# unterstützt beispielsweise folgende Konstrukte der funktionalen Programmierung:

• Funktionen als Werte – ermöglicht die flexible Bearbeitung von Funktionen. Weitere Informationen finden Sie unter Funktionen als erstrangige Werte (F#).

• Funktionszusammensetzung und Pipelinefunktionen – ermöglichen das Kombinieren von Funktionen zum Erstellen neuer Funktionen und die einfachere Codierung aufeinander folgender Datenoperationen. Weitere Informationen finden Sie unter Funktionen (F#).

• Typrückschluss – mithilfe von Typrückschluss müssen Typen seltener explizit aufgerufen werden, und die Typsicherheit bleibt dennoch gewahrt.

• Automatische Verallgemeinerung – erleichtert das Schreiben von Code, der ohne zusätzlichen Aufwand mit einer Vielzahl anderer Typen funktioniert, und fördert so die Codewiederverwendung.

• Unterstützung für Mustervergleich – dies vereinfacht komplexen bedingten Code und Unterscheidungs-Unions, die mit dem Mustervergleich verwendet werden sollen.

• Auflistungstypen zum Arbeiten mit unveränderlichen Daten, einschließlich Listen- und Sequenztypen.

• Lambda-Ausdrücke – diese ermöglichen viele Konstrukte der funktionalen Programmierung.

• Partielle Anwendung von Funktionsargumenten – ermöglicht die implizite Erstellung neuer Funktionen aus vorhandenen Funktionen. Weitere Informationen finden Sie unter Funktionen (F#).

• Codezitate – eine Funktion, die Ihnen ermöglicht, F#-Ausdrücke programmgesteuert zu bearbeiten.

F# unterstützt objektorientierte Programmierungsfunktionen und .NET Framework-Funktionen, wie z. B. Folgende:

• Das .NET Framework-Objektmodell, einschließlich Objekte, die über Eigenschaften, Methoden und Ereignisse verfügen; Polymorphie oder virtuelle Funktionen, Vererbung und Schnittstellen.

• Datenkapselung bzw. das Trennen der öffentlichen Schnittstelle eines Typs von der Implementierung.

• Operatorüberladung – funktioniert gut mit Generika und integrierten primitiven Typen.

• Typerweiterungen – ermöglichen die unkomplizierte Erweiterung eines vorhandenen Typs. Der Mehraufwand für die Erstellung eines neuen abgeleiteten Typs entfällt hierbei.

• Objektausdrücke – ermöglichen nach Bedarf die implizite Definition kleiner Objekte in Ausdrücken. Ein neuer Typ muss so nicht mehr deklariert, ein Objekt nicht mehr instanziiert werden.

• Greifen Sie auf die .NET Framework-Assembly und jede Assembly mit verwaltetem Code zu.

• Greifen Sie auf systemeigenen Code per Plattformaufruf zu.

F# unterstützt außerdem alle üblichen Konstrukte der imperativen Programmierung, z. B. Verzweigungen und Schleifenkonstrukte.

Das Visual F#-Produkt enthält auch eine F#-Bibliothek mit vielen nützlichen Funktionen und Typen. Hierzu gehören auch APIs für Auflistungen, z. B. Listen, Arrays, Zuordnungen, Sätze und Sequenzen. Die F#-Bibliothek unterstützt außerdem Reflektion, Ereignisse und formatierte E/A.

Darüber hinaus bietet die F#-Bibliothek Unterstützung für asynchrone Workflows, um parallele Berechnungen zu ermöglichen, und Mechanismen für die Kommunikation zwischen parallelen Workflows. Weitere Informationen finden Sie unter Asynchrone Workflows (F#), Control.Async-Klasse (F#) und Control.MailboxProcessor<'Msg>-Klasse (F#).

Die F#-Hauptbibliothek ist FSharp.Core.dll. Zusätzliche Bibliotheken sind im F#-PowerPack verfügbar, der auf der Microsoft F# Developer Center-Website verfügbar ist.

Visual F# stellt ein interaktives Fenster bereit, das in der Visual Studio-Entwicklungsumgebung integriert ist. Dieses Fenster ermöglicht Ihnen, F#-Code einzugeben und sofort kompilieren und ausführen zu lassen. Dies ermöglicht die unkomplizierte Entwicklung von Prototypen für Codekonstrukte und das Testen von Code während des Schreibens. Das interaktive Fenster führt das interaktive F#-Tool (fsi.exe) aus, das Sie auch in der Befehlszeile ausführen können. Mit dieser Funktion kann F# als Skriptsprache verwendet werden. Weitere Informationen finden Sie unter F# Interactive-Referenz (fsi.exe).

F# ist in Visual Studio integriert und unterstützt die folgenden Funktionen:

• Projekte, einschließlich Vorlagen für allgemeine Projekttypen. Weitere Informationen finden Sie unter Schreiben von F#-Programmen mit Visual Studio sowie unter Konfigurieren von Projekten (F#).

• IntelliSense Weitere Informationen finden Sie unter Verwenden von IntelliSense.

• Debuggen Weitere Informationen finden Sie unter Debuggen in Visual Studio.

• Bereitstellung: Zum Ausführen von F#-Programmen auf einem Computer müssen die F#-Laufzeitkomponenten installiert sein. Diese Komponenten werden von F# Redistributable Package installiert.

• Weitere Informationen finden Sie unter Funktionen der F#-Entwicklungsumgebung.

Weitere Ressourcen