Startseite>Programmierbezogen>Anderer Quellcode
Herunterladen

FSharpApiSearch

Die F#-API-Suchmaschine ist eine Suchmaschine, mit der Sie nach F#-APIs anhand der Signatur oder des Namens suchen können.

Projektliste

Projektname Überblick
FSharpApiSearch Suchmaschinenkörper
FSharpApiSearch.Database Tool zur Erstellung von Suchmaschinendatenbanken
FSharpApiSearch.Console Suchmaschinen-Frontend (Konsolenanwendung)

So installieren Sie es

Laden Sie die ZIP-Datei von der Release-Seite herunter und extrahieren Sie sie.

Wie zu verwenden

Führen Sie zunächst FSharpApiSearch.Database.exe aus, um eine Datenbank zu erstellen. 

 FSharpApiSearch.Database.exe

Die Assemblys, die standardmäßig durchsucht werden können, sind FSharp.Core , mscorlib , System und System.Core . Sie können Suchziele hinzufügen, indem Sie beim Erstellen einer Datenbank eine Assembly angeben. Mit der Option --lib können Sie das Verzeichnis angeben, in dem nach Assemblys gesucht werden soll. Bitte geben Sie auch die Assemblys an, von denen die angegebene Assembly abhängt. 

 FSharpApiSearch.Database.exe --lib:TargetAssemblyDirectory TargetAssembly1 TargetAssembly2 DependentAssembly

Wenn Sie FSharpApiSearch.Console.exe ausführen, ohne eine Abfrage durchzuführen, wird es im interaktiven Modus gestartet. Geben Sie #q ein, um den interaktiven Modus zu verlassen. 

 FSharpApiSearch.Console.exe

Wenn Sie eine Abfrage als Argument übergeben, wird die Suche nur einmal durchgeführt. 

 FSharpApiSearch.Console.exe "int -> int"

Verwenden Sie --target , um die erstellte Datenbank tatsächlich für die Suche zu verwenden. 

 FSharpApiSearch.Console.exe --target:TargetAssembly1 --target:TargetAssembly2

Wenn Sie --target verwenden, werden die Standardeinstellungen FSharp.Core , mscorlib , System und System.Core nicht in das Suchziel aufgenommen. Wenn Sie sie also in das Suchziel einschließen möchten, geben Sie sie explizit an. 

 FSharpApiSearch.Console.exe --target:TargetAssembly1 --target:TargetAssembly2 --target:FSharp.Core --target:mscorlib --target:System --target:System.Core

Suchoptionen

respect-name-difference -Option

Wenn respect-name-difference aktiviert ist, berücksichtigt die Suche Unterschiede in den Namen verschiedener Typvariablen und benannter Platzhalter in der Abfrage. Unterschiedliche Namen stimmen nicht mit demselben Typ überein. Beispielsweise stimmt die Abfrage ?a -> ?a mit der Signatur int -> int überein, aber die Abfrage ?a -> ?b stimmt nicht mit int -> int überein.

Wenn diese Option deaktiviert ist, entspricht die Abfrage ?a -> ?b int -> int .

greedy-matching Option

Wenn greedy-matching aktiviert ist, werden Typvariablen und andere Typen einzeln abgeglichen und die Ergebnisse werden sortiert und in absteigender Übereinstimmungsreihenfolge angezeigt. Außerdem werden jetzt Typbeschränkungen bei der Suche berücksichtigt.

Option ignore-param-style

Es gibt zwei Arten von Argumentformaten für Funktionen und Methoden: Curry-Format ( arg1 -> arg2 -> returnType ) und Tupelformat ( arg1 * arg2 -> returnType ). Wenn ignore-param-style aktiviert ist, ignoriert die Übereinstimmung Curry- und Tupelformate.

Option ignore-case

Wenn die Option ignore-case aktiviert ist, wird die Groß-/Kleinschreibung beim Abgleich von API-Namen und Typnamen ignoriert.

substring Option

Wenn substring aktiviert ist, wird nach Teilzeichenfolge gesucht.

swap-order Option

Wenn swap-order aktiviert ist, vertauscht die Suche die Reihenfolge der Argumente und Tupel. Beispielsweise entspricht die Abfrage a -> b -> c b -> a -> c .

complement

Wenn complement Komplementoption aktiviert ist, werden fehlende Argumente und Tupelelemente vervollständigt und gesucht. Beispielsweise stimmt die Abfrage a * c mit a * b * c überein.

Option single-letter-as-variable

Wenn single-letter-as-variable aktiviert ist, werden Typnamen mit einem Buchstaben als Typvariablennamen behandelt. Beispielsweise ist die Abfrage t list dasselbe wie 't list .

language

Schaltet Abfragen, Suchen und Ergebnisanzeige auf die durch language angegebene Programmiersprache um. Diese Option akzeptiert F# und C#.

xmldoc Optionen

Wenn xmldoc aktiviert ist, werden XML-Dokumente in den Suchergebnissen angezeigt.

F#-Abfragespezifikation

F#-Abfragen sind grundsätzlich dasselbe wie F#-Signaturen. Lediglich die Erweiterung von FSharpApiSearch wird im Detail erläutert.

> ist die Eingabeaufforderung, wenn Sie FSharpApiSearch.Console.exe im interaktiven Modus starten.

Durchsuchbare API

API Abfragebeispiel
Modulfunktionen und -werte int -> string
Datensatz, Strukturfeld Ref<'a> -> 'a
diskriminierte Gewerkschaft 'a -> Option<'a>
Mitglied 'a list -> int
Konstrukteur Uri : _
Uri.new : _
Uri..ctor : _
Name (Funktionsname, Mitgliedsname usw.) head : 'a list -> 'a
head
aktives Muster (||) : ... -> Expr -> ?
Typen, Typenkürzel, Module List<'T>
Berechnungsausdruck { let! } : Async<'T>
Subtypsuche #seq<'a> -> 'a

Namenssuche

Um nach Namen zu suchen, geben Sie name : signature oder name ein. Wenn Sie keine Signatur angeben, geben Sie _ im Signaturteil an. 

 > id : 'a -> 'a
Microsoft.FSharp.Core.Operators.id: 'T -> 'T, module value, FSharp.Core

> choose
Microsoft.FSharp.Collections.Array.Parallel.choose: ('T -> option<'U>) -> 'T[] -> 'U[], module value, FSharp.Core
Microsoft.FSharp.Collections.Array.choose: ('T -> option<'U>) -> 'T[] -> 'U[], module value, FSharp.Core
Microsoft.FSharp.Collections.List.choose: ('T -> option<'U>) -> list<'T> -> list<'U>, module value, FSharp.Core
Microsoft.FSharp.Collections.Seq.choose: ('T -> option<'U>) -> seq<'T> -> seq<'U>, module value, FSharp.Core
Microsoft.FSharp.Control.Event.choose: ('T -> option<'U>) -> IEvent<'Del, 'T> -> IEvent<'U>, module value, FSharp.Core
  when 'Del : delegate and 'Del :> Delegate
Microsoft.FSharp.Control.Observable.choose: ('T -> option<'U>) -> IObservable<'T> -> IObservable<'U>, module value, FSharp.Core

> choose : _
Microsoft.FSharp.Collections.Array.Parallel.choose: ('T -> option<'U>) -> 'T[] -> 'U[], module value, FSharp.Core
Microsoft.FSharp.Collections.Array.choose: ('T -> option<'U>) -> 'T[] -> 'U[], module value, FSharp.Core
Microsoft.FSharp.Collections.List.choose: ('T -> option<'U>) -> list<'T> -> list<'U>, module value, FSharp.Core
Microsoft.FSharp.Collections.Seq.choose: ('T -> option<'U>) -> seq<'T> -> seq<'U>, module value, FSharp.Core
Microsoft.FSharp.Control.Event.choose: ('T -> option<'U>) -> IEvent<'Del, 'T> -> IEvent<'U>, module value, FSharp.Core
  when 'Del : delegate and 'Del :> Delegate
Microsoft.FSharp.Control.Observable.choose: ('T -> option<'U>) -> IObservable<'T> -> IObservable<'U>, module value, FSharp.Core

Verwenden Sie das Sternchen ( * ), um nach Teilübereinstimmungen zu suchen. Beispielsweise zeigt FSharp.Core.String.* : _ alle APIs des FSharp.Core.String Moduls an. 

 > FSharp.Core.String.* : _
Microsoft.FSharp.Core.String.collect: (char -> string) -> string -> string, module value, FSharp.Core
Microsoft.FSharp.Core.String.concat: string -> seq<string> -> string, module value, FSharp.Core
Microsoft.FSharp.Core.String.exists: (char -> bool) -> string -> bool, module value, FSharp.Core
Microsoft.FSharp.Core.String.filter: (char -> bool) -> string -> string, module value, FSharp.Core
...

Platzhalter

Normalerweise stimmen Typvariablen wie 'a und Typnamen wie int nicht überein. Möglicherweise möchten Sie jedoch nach beiden Fällen gleichzeitig suchen. In solchen Fällen können Sie den Platzhalter ? oder _ verwenden. 

 > ? -> list<?> -> ?
Microsoft.FSharp.Collections.List.append: list<'T> -> list<'T> -> list<'T>, module value, FSharp.Core
Microsoft.FSharp.Collections.List.averageBy: ('T -> 'U) -> list<'T> -> 'U, module value, FSharp.Core
  when 'U : (static member op_Addition : 'U * 'U -> 'U) and 'U : (static member DivideByInt : 'U * int -> 'U) and 'U : (static member get_Zero : unit -> 'U)
Microsoft.FSharp.Collections.List.choose: ('T -> option<'U>) -> list<'T> -> list<'U>, module value, FSharp.Core
Microsoft.FSharp.Collections.List.chunkBySize: int -> list<'T> -> list<list<'T>>, module value, FSharp.Core
...

Durch die Benennung von Platzhaltern können Sie außerdem eine Bedingung hinzufügen, dass derselbe Typname an den Platzhalterpositionen mit demselben Namen angezeigt wird. Beispielsweise entspricht ? -> ? allen folgenden Funktionen:

  • 'a -> 'a
  • int -> int
  • 'a -> int
  • int -> string

Wenn Sie es jedoch wie folgt benennen: ?a -> ?a , stimmt das obige Beispiel nicht mit 'a -> int oder int -> string überein.

Subtypsuche

Eine Subtypsuche ist eine Einschränkung, die Typen angibt, die mit einem angegebenen Basistyp oder einer angegebenen Schnittstelle kompatibel sind.

Um die Subtypsuche in einer Abfrage zu verwenden, schreiben Sie #type . Im type können Sie den Typnamen und den Schnittstellennamen angeben. Typparameter und Platzhalter können im Typnamen nicht angegeben werden.

Beispielsweise kann ? -> #seq<'T> nach Funktionen suchen, die von seq<'T> Typen wie List<'T> , IList<'T> und 'T[] zurückgeben.

Mitgliedersuche

Instanzmitglied

Um nach Instanzmitgliedern zu suchen, schreiben Sie receiver -> signature .

Wenn Sie nach einer Methode suchen, schreiben Sie receiver -> arg -> returnType .

Um nach Methoden mit mehreren Argumenten zu suchen, schreiben Sie receiver -> arg1 -> arg2 -> returnType oder receiver -> arg1 * arg2 -> returnType . Normalerweise werden Methodenargumente durchsucht, ohne zwischen Tupelformat ( arg1 * arg2 ) und Curry-Format ( arg1 -> arg2 ) zu unterscheiden. Wenn Sie nach Argumentformat suchen möchten, deaktivieren Sie ignore-param-style .

Um nach einer Eigenschaft zu suchen, schreiben Sie receiver -> propertyType . Indizierte Eigenschaften werden als receiver -> index -> propertyType geschrieben.

statisches Mitglied

Statische Mitglieder können mit denselben Abfragen durchsucht werden wie Werte und Funktionen in Modulen. Methoden mit mehreren Argumenten werden wie Instanzmethoden geschrieben arg1 -> arg2 -> returnType oder arg1 * arg2 -> returnType .

aktives Muster

Um nach einem aktiven Muster zu suchen, schreiben Sie (||) : (args ->) inputType -> returnType . Um nach einem teilweise aktiven Muster zu suchen, schreiben Sie (|_|) : (args ->) inputType -> returnType .

Geben Sie im Teil inputType den Typ an, der vom aktiven Muster behandelt wird. Wenn Sie beispielsweise nach aktiven Mustern für Expr schreiben Sie (||) : ... -> Expr -> ?

Geben Sie die aktiven Musterargumente in args . Wenn Sie nach aktiven Mustern mit Argumenten suchen möchten, schreiben Sie (||) : arg1 -> arg2 -> inputType -> returnType . Wenn Sie nach aktiven Mustern ohne Argumente suchen möchten, schreiben Sie (||) : inputType -> returnType . Wenn Sie suchen möchten, ohne zwischen dem Vorhandensein oder Fehlen von Argumenten zu unterscheiden, verwenden Sie das Schlüsselwort ... im Argumentteil und schreiben Sie (||) : ... -> inputType -> returnType .

Der retyrnType -Teil gibt den von der Funktion zurückgegebenen Typ an, bei dem es sich um das tatsächlich aktive Muster handelt. Der Rückgabewert der aktiven Musterfunktion ist für einzelne, mehrere und teilweise aktive Muster unterschiedlich. Bitte geben Sie einen entsprechenden Typ an, option<_> , Choice<_,...,_> . Normalerweise wird die Verwendung von Platzhaltern ( ? ) empfohlen.

Berechnungsausdruck

Um nach einem Berechnungsausdruck zu suchen, schreiben Sie { syntax } : type . Sucht einen Builder, der die angegebene Syntax und den angegebenen Typ verarbeiten kann.

Sie können einen beliebigen benutzerdefinierten Operationsnamen in use syntax angeben: let! yield , return yield! return! use! if/then , for while try/with , try/finally . Wenn Sie mehrere syntax angeben möchten, trennen Sie diese mit ; ​​und schreiben Sie { s1; s2 } : type

C#-Abfragespezifikation

C#-Abfragen haben eine andere Syntax als C#-Signaturen.

Durchsuchbare API

API Abfragebeispiel
Mitglied object -> () -> string
string -> int
Konstrukteur Uri : _
Uri..ctor : _
Typparameter List<T> -> int
Dictionary<tkey, tvalue>
<TKey, TValue> : Dictionary<TKey, TValue>
Name (Mitgliedsname usw.) Length : string -> int
Length
Schimmel List
Subtypsuche <T> : #IEnumerable<T> -> T

Namenssuche

Um nach einem Mitglied zu suchen oder es nach Namen einzugeben, schreiben Sie name : signature oder name . Wenn Sie keine Signatur angeben, geben Sie _ im Signaturteil an. 

 > Length : string -> int
System.String.Length : int, instance property with get, mscorlib

> Length
int Array.Length { get; }, instance property, mscorlib
int BitArray.Length { get; set; }, instance property, mscorlib
long BufferedStream.Length { get; }, instance property, mscorlib
long FileInfo.Length { get; }, instance property, mscorlib
...

> Length : _
int Array.Length { get; }, instance property, mscorlib
int BitArray.Length { get; set; }, instance property, mscorlib
long BufferedStream.Length { get; }, instance property, mscorlib
long FileInfo.Length { get; }, instance property, mscorlib
...

Verwenden Sie das Sternchen ( * ), um nach Teilübereinstimmungen zu suchen. Beispielsweise zeigt System.String.* : _ alle APIs vom Typ System.String an. 

 > System.String.* : _
System.Array.Length : int, instance property with get, mscorlib
System.Collections.BitArray.Length : int, instance property with get set, mscorlib
System.ComponentModel.DataObjectFieldAttribute.Length : int, instance property with get, System
System.ComponentModel.MaskedTextProvider.Length : int, instance property with get, System
...

Typparameter

Es gibt drei Arten von Typparameterbeschreibungen:

Format Beispiel Typparameter Bemerkungen
<t> : signature <TKey, TValue> : Dictionary<TKey, TValue> TKey , TValue Großbuchstaben können in ausführlicher Form in Typparametern verwendet werden
alles in Kleinbuchstaben Dictionary<tkey, tvalue> tkey , tvalue Wenn alle Buchstaben Kleinbuchstaben sind, können Sie den <T> -Teil weglassen.
ein Zeichen List<T> -> int T Handelt es sich um ein einzelnes Zeichen, kann der <T> -Teil weggelassen werden.

Selbst wenn sie alle in Kleinbuchstaben geschrieben sind, werden integrierte Typen wie int und string nicht als Typparameter behandelt.

Der Typparametername in der Abfrage muss nicht mit dem gesuchten Typparameternamen übereinstimmen. Beispielsweise entspricht die Abfrage List<A> dem Typ System.Collections.Generics.List<T> .

Platzhalter

Normalerweise stimmen Typparameter wie T und Typnamen wie int nicht überein. Möglicherweise möchten Sie jedoch nach beiden Fällen gleichzeitig suchen. In solchen Fällen können Sie ? verwenden. 

 > <T> : List<T> -> ? -> int
System.Collections.Generic.List<T>.BinarySearch(T item) : int, instance method, mscorlib
System.Collections.Generic.List<T>.FindIndex(Predicate<T> match) : int, instance method, mscorlib
System.Collections.Generic.List<T>.FindLastIndex(Predicate<T> match) : int, instance method, mscorlib
System.Collections.Generic.List<T>.IndexOf(T item) : int, instance method, mscorlib
...

Durch die Benennung von Platzhaltern können Sie außerdem eine Bedingung hinzufügen, dass derselbe Typname an den Platzhalterpositionen mit demselben Namen angezeigt wird. Beispielsweise entspricht ? -> ? allen folgenden Angaben:

  • static T F1<T>(T x)
  • static int F2 (int x)
  • static T F3<T>(int x)
  • static int F4 (string x)

Wenn Sie es jedoch wie folgt benennen ?a -> ?a , stimmt das obige Beispiel nicht mit F2 oder F4 überein.

Subtypsuche

Eine Subtypsuche ist eine Einschränkung, die Typen angibt, die mit einem angegebenen Basistyp oder einer angegebenen Schnittstelle kompatibel sind.

Um die Subtypsuche in einer Abfrage zu verwenden, schreiben Sie #type . Im type können Sie den Typnamen und den Schnittstellennamen angeben. Typparameter und Platzhalter können im Typnamen nicht angegeben werden.

Beispielsweise kann <T> : ? -> #IEnumerable<T> nach Methoden suchen, die von IEnumerable<T> erben und Typen wie List<T> , IList<T> und T[] zurückgeben.

Mitgliedersuche

Instanzmitglied

Um nach einer Methode zu suchen, schreiben Sie receiver -> (arg) -> returnType . Methoden mit mehreren Argumenten werden als receiver -> (arg1, arg2) -> returnType geschrieben. Die Klammern im Argumentteil können weggelassen werden. Wenn Sie nach APIs suchen möchten, die keine Argumente oder Rückgabewerte haben, verwenden Sie () und void . 

 > <T> : List<T> -> T -> int
System.Collections.Generic.List<T>.BinarySearch(T item) : int, instance method, mscorlib
System.Collections.Generic.List<T>.IndexOf(T item) : int, instance method, mscorlib
...

Um nach einer Eigenschaft zu suchen, schreiben Sie receiver -> propertyType . Indizierte Eigenschaften werden als receiver -> index -> propertyType geschrieben. 

 > <T> : List<T> -> int
System.Collections.Generic.List<T>.Capacity : int, instance property with get set, mscorlib
System.Collections.Generic.List<T>.Count : int, instance property with get, mscorlib
...

statisches Mitglied

Um nach einer Methode zu suchen, schreiben Sie (arg) -> returnType . Wenn Sie nach einer Eigenschaft suchen, schreiben Sie propertyType . 

 > string -> int
System.Convert.ToInt32(string value) : int, static method, mscorlib
System.Int32.Parse(string s) : int, static method, mscorlib
...

Auf diese Weise wird der Typ, zu dem das Mitglied gehört, in der Abfrage des statischen Mitglieds nicht angegeben.

APIs, die aufgrund von Einschränkungen von FSharp.Compiler.Service nicht unterstützt werden können

  • Felder von in C# definierten Klassen und Strukturen

Betriebsumgebung

  • .Net Framework 4.5
  • F# 4.1

Bibliothek verwendet

  • FSharp.Compiler.Service
  • FParsec
  • FSharp.Collections.ParallelSeq
  • MessagePack für C#
  • MessagePack.FSharpExtensions
Expandieren
Zusätzliche Informationen
Ähnliche Anwendungen
Empfohlen für Sie
Ähnliche Nachrichten Alle