Generate From Usage

Artikel
08/10/2011

Mit der Funktion Generate From Usage können Sie Klassen und Member verwenden, bevor Sie sie definieren. Für Klassen, Konstruktoren, Methoden, Eigenschaften, Felder oder Enumerationen, die verwendet werden sollen, jedoch noch nicht definiert sind, können Sie einen Stub generieren. Sie können neue Typen und Member generieren, ohne dass dazu Sie die aktuelle Position im Code verlassen müssen. Dies minimiert Unterbrechung im Workflow.

"Generate From Usage" unterstützt Programmierstile wie die Test-First-Entwicklung.

Verwenden von Generate From Usage in C#

Unter jedem nicht definierten Bezeichner wird eine wellenförmige Unterstreichung angezeigt. Wenn Sie den Mauszeiger über den Bezeichner führen, wird in einer QuickInfo eine Fehlermeldung angezeigt.

Sie können mithilfe eines der folgenden Verfahren die entsprechenden Optionen anzeigen:

Klicken Sie auf den nicht definierten Bezeichner. Unter dem äußersten linken Zeichen wird ein kurzer Unterstrich angezeigt. Wenn Sie den Mauszeiger auf dem kurzen Unterstrich ruhen lassen, wird ein Smarttag (ein Symbol) angezeigt. Klicken Sie auf das Smarttag.
Klicken Sie auf den nicht definierten Bezeichner, und drücken Sie dann STRG+. (Punkt).
Klicken Sie mit der rechten Maustaste auf den nicht definierten Bezeichner, und klicken Sie dann auf Generieren.

Zu den Optionen, die angezeigt werden, gehören folgende:

Eigenschaftsstub generieren
Feldstub generieren
Methodenstub generieren
Klasse generieren
Neuen Typ generieren (für eine Klasse, Struktur, Schnittstelle oder Enumeration)

Verwenden von Generate From Usage in Visual Basic

Unter jedem nicht definierten Bezeichner wird eine wellenförmige Unterstreichung und unter dem Zeichen ganz rechts eine kurze Unterstreichung angezeigt. Wenn Sie den Mauszeiger über den Bezeichner führen, wird in einer QuickInfo eine Fehlermeldung angezeigt.

Sie können mithilfe eines der folgenden Verfahren die entsprechenden Optionen anzeigen:

Halten Sie den Mauszeiger über den nicht definierten Bezeichner. Ein Smarttag (ein Symbol) wird angezeigt. Klicken Sie auf das Smarttag.
Klicken Sie auf den nicht definierten Bezeichner, und drücken Sie dann STRG+. (Punkt).
Doppelklicken Sie im Fenster Fehlerliste auf die entsprechende Fehlerzeile.

Zu den Optionen, die angezeigt werden, gehören folgende:

Eigenschaftsstub generieren
Feldstub generieren
Methodenstub generieren
Klasse generieren
Schnittstelle generieren
Neuen Typ generieren (für eine Klasse, Struktur, Schnittstelle, Enumeration, einen Delegaten oder ein Modul)

Generieren eines Eigenschaftenstubs

Wenn Code auf eine nicht definierte Eigenschaft verweist, klicken Sie auf Eigenschaftsstub generieren. Der Eigenschaftenstub wird in der entsprechenden Klasse generiert. Der Rückgabetyp der Eigenschaft wird durch den Kontext bestimmt.

Angenommen, Sie generieren die InstanceProperty-Eigenschaft aus der Anweisung im folgenden Code.

Dim cust As New Customer()
Dim city As String = cust.InstanceProperty

Customer cust = new Customer();
string city = cust.InstanceProperty;

Wenn Sie die Eigenschaft generieren, wird in der Customer-Klasse der folgende Stub erstellt.

Property InstanceProperty() As String

public string InstanceProperty { get; set; }

Wenn eine Eigenschaft für einen Typ und keine Instanz aufgerufen wird, ist der generierte Stub eine statische Eigenschaft (C#) oder eine freigegebene Eigenschaft (Visual Basic).

Stellen Sie sich z. B. vor, dass Sie eine Eigenschaft aus der folgenden Anweisung generieren (unter der Annahme, dass es sich bei Customer um einen Klassennamen handelt).

Dim description As String = Customer.SharedProperty

string description = Customer.StaticProperty;

Wenn Sie die Eigenschaft generieren, wird in der Customer-Klasse der folgende Stub erstellt.

Shared Property SharedProperty As String

public static string StaticProperty { get; set; }

Wenn eine Eigenschaft ohne Qualifizierung (Verweis auf einen Member des aktuellen Typs) aufgerufen wird, ist der generierte Stub statisch, sofern die Eigenschaft von einer statischen Methode aufgerufen wird. Andernfalls handelt es sich um eine Instanzeigenschaft.

Angenommen, Sie generieren eine Eigenschaft aus der folgenden Anweisung.

Dim title As String = UnqualifiedProperty

string title = UnqualifiedProperty;

Wenn Sie die Eigenschaft generieren, wird in der aktuellen Klasse der folgende Stub erstellt.

Private Property UnqualifiedProperty() As String

public string UnqualifiedProperty { get; set; }

Generieren eines Methodenstubs

Wenn Code auf eine nicht definierte Methode verweist, klicken Sie auf Methodenstub generieren. Der Methodenstub wird in der entsprechenden Klasse generiert.

Die Typen der einzelnen Parameter sowie der Rückgabetyp werden durch den Kontext bestimmt. Wenn der Typ nicht abgeleitet werden kann, z. B. bei anonymen Typen oder bei implizit typisierten lokale Variablen (mit dem Schlüsselwort var definierten Variablen), wird der Objekttyp verwendet.

Die Namen der einzelnen Parameter werden von den Namen der an den Methodenaufruf übergebenen Argumente abgeleitet.

Angenommen, Sie generieren die InstanceMethod-Methode aus der Anweisung im folgenden Code.

Dim cust As New Customer()
Dim itemNumber = 3
Dim itemName = "abc"
cust.InstanceMethod(itemNumber, itemName, 4)

Customer cust = new Customer();
int itemNumber = 3;
string itemName = "abc";
cust.InstanceMethod(itemNumber, itemName, 4);

Wenn Sie die Methode generieren, wird in der entsprechenden Klasse der folgende Stub erstellt.

Sub InstanceMethod(ByVal itemNumber As Integer, ByVal itemName As String, ByVal p3 As Integer)
    Throw New NotImplementedException
End Sub

internal void InstanceMethod(int itemNumber, string itemName, int p)
{
    throw new NotImplementedException();
}

Wenn eine Methode für einen Typ und keine Instanz aufgerufen wird, ist der generierte Stub eine statische Methode (C#) oder eine freigegebene Methode (Visual Basic).

Generieren eines Methodenstubs für ein Ereignis

In Visual Basic können Sie eine Ereignishandlermethode für ein Ereignis generieren, auf das in einem AddHandler-Anweisung oder einem RemoveHandler-Anweisung verwiesen wird.

Angenommen, Sie generieren die EventHandler-Methode aus einer der folgenden Anweisungen im Code.

AddHandler obj.Ev_Event, AddressOf EventHandler
RemoveHandler obj.Ev_Event, AddressOf EventHandler

Wenn Sie die Methode generieren, wird in der aktuellen Klasse der folgende Stub erstellt.

Private Sub EventHandler()
    Throw New NotImplementedException
End Sub

Generieren eines Konstruktorstubs

Wenn Code auf einen nicht definierten Konstruktor verweist, klicken Sie auf Konstruktorstub generieren. Der Konstruktorstub wird in der entsprechenden Klasse generiert. Die Typen der einzelnen Parameter werden Kontext bestimmt.

Die Namen der Parameter für den Konstruktor werden untersucht. Wenn die Klasse Eigenschaften aufweist, deren Namen mit diesen Parameternamen übereinstimmen, wird im Konstruktor Code angegeben, der die Argumentwerte für diese Eigenschaften speichert.

Angenommen, Sie generieren einen Konstruktor für die Example-Klasse aus der Anweisung im folgenden Code.

Dim total As Long = 12
Dim exampleTest As New Example(5, total, Date.Now)

long total = 12;
Example exampleTest = new Example(5, total, System.DateTime.Now);

Wenn Sie den Konstruktor generieren, werden in der Example-Klasse die folgenden privaten Variablen erstellt, sofern diese nicht bereits vorhanden sind.

Private _p1 As Integer
Private _total As Long
Private _p3 As Date

private int p;
private long total;
private DateTime dateTime;

Der folgende Konstruktorstub wird erstellt.

Sub New(ByVal p1 As Integer, ByVal total As Long, ByVal p3 As Date)
    ' TODO: Complete member initialization 
    _p1 = p1
    _total = total
    _p3 = p3
End Sub

public Example(int p, long total, DateTime dateTime)
{
    // TODO: Complete member initialization
    this.p = p;
    this.total = total;
    this.dateTime = dateTime;
}

Pro Klasse können Sie mehr als einen Konstruktor generieren. Ein zusätzlicher Konstruktor kann generiert werden, wenn der Konstruktoraufruf eine andere Anzahl von Argumenten oder andere Argumenttypen aufweist.

In Visual Basic kann ein Konstruktor auch generiert werden, wenn Sie eine Klasse generieren. Weitere Informationen finden Sie im nächsten Abschnitt dieses Themas.

Generieren einer Klasse

Wenn Code auf eine nicht definierte Klasse oder einen anderen Typ verweist, werden die Optionen Klasse generieren und Neuen Typ generieren angezeigt.

Wenn Sie auf Klasse generieren klicken, wird ein leerer Klassenstub in einer neuen Datei des Projekts generiert. Die neue Datei wird im Code-Editor geöffnet (erhält jedoch nicht den Fokus). Dies ist die schnellste Möglichkeit, in einer neuen Datei des aktuellen Projekts einen neuen Klassentyp mit Standardzugriffsmodifizierern zu erstellen.

Angenommen, Sie generieren eine Klasse aus der folgenden Anweisung.

Dim cust As Customer

Customer cust;

Wenn Sie die Klasse generieren, wird in einer neuen Datei des Projekts der folgende neue Klassenstub erstellt.

Class Customer

End Class

namespace CSharpWindowsApp
{
    class Customer
    {
    }
}

Sie können den Befehl Klasse generieren auch verwenden, wenn die eine geerbten Basisklasse in einer Klassendefinition nicht definiert ist.

Gleichzeitiges Generieren einer Klasse und eines Konstruktors

In Visual Basic enthält die generierte Klasse bei Bedarf einen Konstruktor.

Angenommen, Sie generieren eine Klasse aus der folgenden Anweisung.

Dim total = 3
Dim exampleTest As New Example(5, total, Date.Now) With {.Description = "book"}

Wenn Sie die Klasse generieren, wird in einer neuen Datei des Projekts der folgende neue Klassenstub erstellt. Der Konstruktor wird in der Klasse generiert. Für den Objektinitialisierer in der With-Klausel im vorherigen Code wird eine Description-Eigenschaft erstellt.

Class Example
    Private _p3 As Date
    Private _total As Integer
    Private _p1 As Integer

    Sub New(ByVal p1 As Integer, ByVal total As Integer, ByVal p3 As Date)
        ' TODO: Complete member initialization 
        _p1 = p1
        _total = total
        _p3 = p3
    End Sub

    Property Description As String
End Class

Generieren neuer Typen mit zusätzlichen Optionen

Wenn Code auf eine nicht definierte Klasse, Schnittstelle, Enumeration, Struktur (C#) oder Struktur (Visual Basic) verweist, werden die Optionen Klasse generieren und Neuen Typ generieren angezeigt. Dies wird in den folgenden Abbildungen dargestellt.

Visual Basic

Kontextmenü "Smarttag" in Visual Basic

Visual C#

Kontextmenü "Smarttag" in C#

Klicken Sie auf Neuen Typ generieren, um das Dialogfeld Neuen Typ generieren zu öffnen, in dem Sie eine Zugriffsebene, eine Art, einen Projektspeicherort und einen Dateinamen auswählen können.

Die Option Neuen Typ generieren bietet zusätzliche Flexibilität beim Generieren einer Klasse. Möglicherweise fügen Sie die Klasse lieber in eine vorhandene Datei ein, geben die Zugriffsmodifizierer an oder fügen die neue Datei einem anderen Projekt der Projektmappe hinzu.

Die folgende Abbildung zeigt das Dialogfeld Neuen Typ generieren.

Dialogfeld "Neuen Typ generieren"

In der folgenden Tabelle finden Sie die im Dialogfeld Neuen Typ generieren verfügbaren Optionen.

Option	Optionen für C#	Optionen für Visual Basic
Zugriff	Standard, öffentlich, intern oder privat.	Standard, Friend oder öffentlich.
Kind	Struktur, Klasse, Schnittstelle oder Enumeration.	Klasse, Struktur, Schnittstelle, Enumeration, Delegat oder Modul.
Projektspeicherort	Aktuelles Projekt oder anderes Projekt der Projektmappe.	Aktuelles Projekt oder anderes Projekt der Projektmappe.
Dateiname	Neue Datei erstellen mit Dateiname oder Zu vorhandener Datei hinzufügen mit Dateiname.	Neue Datei erstellen mit Dateiname oder Zu vorhandener Datei hinzufügen mit Dateiname.

Wenn der Typ in einer neuen Datei generiert wird, enthält die neue Datei den Standardsatz von using-Direktiven für eine Klasse, die im Dialogfeld Neues Element hinzufügen generiert wurde.

Wenn der Typ in einem anderen Projekt der Projektmappe generiert wird, wird der aktuellen Datei eine using-Direktive hinzugefügt, die auf dieses Projekt verweist.

Generieren eines Schnittstellenstubs

Um Code aus einer nicht definierten Schnittstelle zu generieren, klicken Sie auf Neuen Typ generieren. Das Dialogfeld Neuen Typ generieren wird geöffnet. Klicken Sie in der Liste Art auf Schnittstelle. In Visual Basic können Sie auch auf Schnittstelle generieren klicken.

Angenommen, Sie generieren die IAuto-Schnittstelle aus der Anweisung im folgenden Code.

Public Class Sedan : Implements IAuto
End Class

public class Sedan : IAuto
{
}

Wenn Sie die Schnittstelle generieren, wird der folgende Stub erstellt.

Interface IAuto

End Interface

interface IAuto
{
}

Generieren eines Delegatstubs

Zum Generieren von Code aus einem nicht definierten Delegaten in Visual Basic klicken Sie auf Neuen Typ generieren. Das Dialogfeld Neuen Typ generieren wird geöffnet. Klicken Sie in der Liste Art auf Delegat.

Angenommen, Sie generieren den MathOperator-Delegaten aus der Anweisung im folgenden Code.

Dim delInstance As New MathOperator(AddressOf AddNumbers)

Wenn Sie den Delegaten generieren, wird der folgende Stub erstellt.

Delegate Sub MathOperator()

IntelliSense-Vorschlagsmodus

IntelliSense stellt nun zwei Alternativen zur Anweisungsvervollständigung bereit: den Beendigungsmodus und den Vorschlagsmodus. Verwenden Sie den Vorschlagsmodus, wenn Klassen und Member verwendet werden, bevor sie definiert werden.

Wenn Sie im IntelliSense-Vorschlagsmodus im Code-Editor Text eingeben und dann einen Commit für den Eintrag ausführen, wird der von Ihnen eingegebene Text in den Code eingefügt. Wenn Sie im IntelliSense-Beendigungsmodus einen Commit für einen Eintrag ausführen, wird der in der Memberliste ausgewählte Eintrag in den Code eingefügt.

Wenn ein IntelliSense-Fenster geöffnet ist, können Sie STRG+ALT+LEERTASTE drücken, um zwischen dem Beendigungsmodus und dem Vorschlagsmodus zu wechseln.

Weitere Informationen finden Sie unter Member auflisten.

Siehe auch

Aufgaben

Exemplarische Vorgehensweise: Test-First-Unterstützung mit der Funktion "Generate From Usage"

Weitere Ressourcen

Codierungshilfsmittel

Automatische Codegenerierung