Erstellen einer LightSwitch-Bildschirmvorlage
LightSwitch enthält Vorlagen, mit denen Sie Bildschirme mit gängigen Mustern erstellen können. Sie können auch Vorlagen entwickeln, die Sie mit einer bestimmten Datenquelle oder einem beliebigen Datentyp verwenden können.
Eine Bildschirmvorlage erstellt Daten und Steuerelemente für einen Bildschirm auf der Grundlage von Informationen, die ein Entwickler im Dialogfeld Bildschirm hinzufügen angibt. Bildschirmvorlagen können auch programmiert werden, um Code für den Bildschirm hinzuzufügen.
Die Methoden zum Erstellen von HTML-Clientbildschirmvorlagen entsprechen den hier dargestellten Methoden für Desktopclient-Bildschirmvorlagen. Den Hauptunterschied machen ViewIDs aus, die für jeden Clienttyp unterschiedlich sind. Siehe LightSwitch-Steuerelement ViewIDs.
Hinweis
In diesem Dokument werden zahlreiche Szenarien veranschaulicht, die sich über Bildschirmvorlagen umsetzen lassen. Es wird jedoch nicht gezeigt, wie Sie eine tatsächliche Vorlage erstellen, die mehrfach verwendbar ist.Bei der Vorlagenerstellung können Sie diese Szenarien als empfohlene Vorgehensweise verwenden.Sie können ein Beispiel, das sowohl Desktopclient- als auch HTML-Clientvorlagen enthält, aus der MSDN Code Gallery herunterladen.
Definieren einer Bildschirmvorlage
Um eine Bildschirmvorlage zu erstellen, erstellen Sie zunächst ein Projekt mithilfe der Projektvorlage LightSwitch-Erweiterungsbibliothek, die vom LightSwitch Extensibility Toolkit für Visual Studio 2013 bereitgestellt wird. Wenn Sie das Projekt erstellen, wählen Sie entweder Visual Basic oder C# als Entwicklungssprache aus.
So definieren Sie eine Bildschirmvorlage
Wählen Sie im Projektmappen-Explorer das LibraryName.Lspkg-Projekt aus, wobei LibraryName der Name des Erweiterungsprojekts ist.
Wählen Sie in der Menüleiste Projekt, Neues Element hinzufügen aus.
Wählen Sie im Dialogfeld Neues Element hinzufügen die Option LightSwitch-Bildschirmvorlage aus.
Geben Sie im Feld Name einen Namen für die Bildschirmvorlage ein. Das ist der Name, den Entwickler im Dialogfeld Bildschirm hinzufügen sehen.
Klicken Sie auf die Schaltfläche OK.
Eine Klasse, die die Bildschirmvorlage repräsentiert, wird dem Ordner Bildschirmvorlagen im Design-Projekt hinzugefügt. Die TemplateName.vb-Datei bzw. die TemplateName.cs-Datei enthält den gesamten Code für die Vorlage. Alle Beispiele in diesem Dokument befinden sich in dieser Datei.
Auch zwei Bilddateien werden dem Projekt im Ressource\ScreenTemplateImages-Ordner hinzugefügt. Diese repräsentieren die Bilder, die für die Vorlage im Dialogfeld Bildschirm hinzufügen angezeigt werden.
.gif "Hh304432.collapse_all(de-de,VS.140).gif")
Angeben des Anzeigenamens und der Beschreibung
Die Eigenschaften DisplayName und Description stellen den Namen und die Beschreibung bereit, die für die Bildschirmvorlage im Dialogfeld Bildschirm hinzufügen angezeigt werden.
Im folgenden Beispiel werden die Eigenschaften Description und DisplayName angezeigt, die für eine Bildschirmvorlage mit dem Namen "Test Template" generiert werden. Sie sollten dafür einen Namen und eine Beschreibung wählen, die aussagekräftiger sind.
Public ReadOnly Property Description As String Implements IScreenTemplateMetadata.Description
Get
Return "Test Template Description"
End Get
End Property
Public ReadOnly Property DisplayName As String Implements IScreenTemplateMetadata.DisplayName
Get
Return "Test Template"
End Get
End Property
public string Description
{
get { return "TestTemplate Description"; }
}
public string DisplayName
{
get { return "Test Template"; }
}
Angeben der Stammdatenquelle
Die RootDataSource-Eigenschaft bestimmt, welche Datentypen von der Bildschirmvorlage angezeigt werden können. Die Datentypen sind in der Option Bildschirmdaten im Dialogfeld Bildschirm hinzufügen verfügbar. Die RootDataSource-Eigenschaft besitzt vier gültige Werte:
Collection |
Aktiviert die Auswahl von Auflistungen oder von mehreren Ergebnisabfragen. |
ScalarEntity |
Aktiviert die Auswahl von einem Entitätstyp oder von Abfragen, die ein Element zurückgeben. |
NewEntity |
Wird für Bildschirme verwendet, die dazu bestimmt sind, das Erstellen von neuen Entitäten zu ermöglichen. |
None |
Wird für Bildschirme verwendet, auf denen keine Daten ausgewählt werden sollen. |
Im folgenden Beispiel wird Collection als RootDataSource angegeben.
Public ReadOnly Property RootDataSource As RootDataSourceType Implements IScreenTemplateMetadata.RootDataSource
Get
Return RootDataSourceType.Collection
End Get
End Property
public RootDataSourceType RootDataSource
{
get { return RootDataSourceType.Collection; }
}
Festlegen der Unterstützung für untergeordnete Auflistungen
In manchen Fällen muss eine Bildschirmvorlage auch Daten anzeigen, die sich auf die Stammdaten des Bildschirms beziehen. Beispielsweise soll eine Bildschirmvorlage zur Anzeige eines Auftrags auch die zugehörigen Auftragspositionen anzeigen. Um diese Funktion zu aktivieren, legen Sie die SupportsChildCollections-Eigenschaft fest. Wenn Sie diese auf True setzen, werden alle verwandten Auflistungen für den Stammdatentyp im Dialogfeld Bildschirm hinzufügen angezeigt, sodass ein Entwickler entscheiden kann, diese in den Bildschirm einzubeziehen.
Im folgenden Beispiel ist die SupportsChildCollections-Eigenschaft auf True festgelegt. Damit untergeordnete Auflistungen deaktiviert werden, sollten Sie dies in False ändern:
Public ReadOnly Property SupportsChildCollections As Boolean Implements IScreenTemplateMetadata.SupportsChildCollections
Get
Return True
End Get
End Property
public bool SupportsChildCollections
{
get { return true; }
}
Generieren einer Struktur der Bildschirminhalte
In der Regel befindet sich der Großteil des Codes für eine Bildschirmvorlage in der Generate-Methode. Diese Methode kann verwendet werden, um Daten, Code oder Steuerelemente für Bildschirme hinzuzufügen, die auf der Vorlage basieren. LightSwitch enthält Basiselemente für den Bildschirm, wie z. B. Bildschirmbefehle. Sie können die Hierarchie der Inhaltselemente ändern und Elemente mithilfe der verfügbaren Speichermodellklassen – wie ContentItem und verwandte Klassen – erstellen.
LightSwitch enthält einen Verweis auf den Generierungshost von Bildschirmvorlagen, dessen Funktionalität vom Generierungscode beim Erstellen eines Bildschirms verwendet werden kann. Ein Teil dieser Funktionalität ist nur bei Verwendung mit dem Host verfügbar. Falls Sie unsicher sind, welche Strukturen Sie erstellen möchten, wird empfohlen, in LightSwitch einen Beispielbildschirm zu erstellen. Anschließend können Sie die LSML-Datei im Projektordner Common untersuchen und sehen, auf welche Weise der Bildschirm von LightSwitch generiert wurde.
Hinzufügen eines Inhaltselements zu den Stammdaten eines Bildschirms
Ein Inhaltselement stellt ein LightSwitch-Steuerelement auf dem Bildschirm dar. Der folgende Code in der Generate-Methode zeigt, wie für den primären Datenmember eines Bildschirms ein Inhaltselement im Stamm des Bildschirms hinzugefügt wird. Dabei kann es sich um eine Auflistung oder eine einzelne Entität handeln, je nach Typ der Bildschirmvorlage.
Dim primaryDataControl As ContentItem = host.AddContentItem(host.ScreenLayoutContentItem, host.MakeUniqueLegalNameForContentItem("My Root Data"), host.PrimaryDataSourceProperty)
ContentItem primaryDataControl = host.AddContentItem(host.ScreenLayoutContentItem, host.MakeUniqueLegalNameForContentItem("My Root Data"), host.PrimaryDataSourceProperty);
Angeben eines bestimmten Steuerelements für ein Inhaltselement
Steuerelemente werden über ViewID identifiziert. Dabei handelt es sich um eine Kombination aus dem Namen des Steuerelements und der Modulbezeichnung, in dem dieses definiert ist. Eine Liste mit ViewIDs finden Sie unter LightSwitch-Steuerelement ViewIDs.
Der folgende Code veranschaulicht, wie der Steuerelementtyp von ContentItem als DataGrid festgelegt wird.
host.SetContentItemView(primaryDataControl, "Microsoft.LightSwitch.RichClient:DataGrid")
host.SetContentItemView(primaryDataControl, "Microsoft.LightSwitch.RichClient:DataGrid");
LightSwitch verwendet zum Beispiel für das Steuerelement, das für ein bestimmtes Inhaltselement verwendet werden soll, und dessen Standardeigenschaftswerte intelligente Standardwerte. Intelligente Standardwerte berücksichtigen auch den Datentyp eines Steuerelements, ob es sich in der Inhaltsstruktur befindet, welche übergeordneten Steuerelemente dafür vorhanden sind usw. Wird ein Inhaltselement auf ein bestimmtes Steuerelement festgelegt, verwendet LightSwitch anstelle der Standardwerte diese Auswahl (außer sie ist ungültig). Der Datentyp eines bestimmten Felds kann ein benutzerdefinierter Typ sein, über den Sie nichts wissen, und eine Standardzuordnung zu einem Steuerelement aufweisen, über das Sie nichts wissen. Außerdem kann ein Entwickler ggf. die standardmäßig ausgewählten Steuerelemente in bestimmten Situationen überschreiben. Daher wird empfohlen, ein bestimmtes Steuerelement nur für ein Inhaltselement festzulegen, wenn dieses Steuerelement in allen Fällen verwendet werden soll.
Erweitern der untergeordneten Elemente eines Inhaltselements
Häufig ist es erforderlich, ein Inhaltselement zu erweitern und untergeordnete Elemente für alle Felder in der gebundenen Entität hinzuzufügen. Es wird empfohlen, dass Sie dazu host.ExpandContentItem aufrufen, anstatt dies manuell auszuführen. Mit diesem Aufruf werden die standardmäßig untergeordneten Elemente für dieses Steuerelement automatisch konsistent und korrekt generiert. Im folgenden Beispiel wird von ExpandContentItem das standardmäßig untergeordnete Element (DataGridRow) zu DataGrid hinzugefügt. Außerdem werden die standardmäßig untergeordneten Elemente für DataGridRow hinzugefügt. Dies entspricht der Verwendung von Zurücksetzen im Bildschirm-Designer von LightSwitch.
host.ExpandContentItem(primaryDataControl)
host.ExpandContentItem(primaryDataControl);
Festlegen von Steuerelementeigenschaften auf nicht standardmäßige Werte
LightSwitch unterstützt ein Vererbungsmuster für Steuerelemente. Eigenschaften können auf unterschiedlichen Ebenen der Vererbungshierarchie definiert werden. Beispielsweise erben alle LightSwitch-Steuerelemente von Microsoft.LightSwitch.RichClient:RootControl, das allgemeine Eigenschaften für Größenänderungen bei Steuerelementen aufweist (horizontale und vertikale Ausrichtung, Höhe, Breite usw.). Um eine Eigenschaft für ein Steuerelement festzulegen, müssen Sie wissen, auf welchem Steuerelementtyp die Eigenschaft definiert wurde. Eine Liste mit integrierten LightSwitch-Steuerelementeigenschaften finden Sie unter Definieren, Überschreiben und Verwenden von LightSwitch-Steuerelementeigenschaften.
Im folgenden Beispiel werden die Eigenschaften VerticalAlignment und HeightSizingMode für ein Bildschirmsteuerelement festgelegt.
host.SetControlPropertyValue(primaryDataControl, "Microsoft.LightSwitch.RichClient:RootControl", "VerticalAlignment", "Top")
host.SetControlPropertyValue(primaryDataControl, "Microsoft.LightSwitch.RichClient:RootControl", "HeightSizingMode", "Auto")
host.SetControlPropertyValue(primaryDataControl, "Microsoft.LightSwitch.RichClient:RootControl", "VerticalAlignment", "Top");
host.SetControlPropertyValue(primaryDataControl, "Microsoft.LightSwitch.RichClient:RootControl", "HeightSizingMode", "Auto");
Es wird empfohlen, nur Werte für Eigenschaften festzulegen, wenn diese bestimmten Werte obligatorisch verwendet werden müssen. In diesem Fall ermittelt LightSwitch keine Standardwerte für die Eigenschaften auf Basis des Kontexts in der Struktur der Bildschirminhalte.
Festlegen des Anzeigenamens für ein Inhaltselement oder einen Bildschirmmember
Im folgenden Beispiel wird der Anzeigename für ein Inhaltselement festgelegt. Das Beispiel kann auch verwendet werden, um den Anzeigenamen für einen Bildschirmmember festzulegen.
host.SetDisplayName(primaryDataControl, "Main Screen Data")
host.SetDisplayName(primaryDataControl, "Main Screen Data");
Falls kein Name festgelegt wird, stellt LightSwitch einen standardmäßigen Anzeigenamen auf Basis der Daten bereit, an die das Inhaltselement gebunden ist.
Festlegen von Eigenschaften auf Bildschirm-Datenmembern
Im folgenden Beispiel wird die DisablePaging-Eigenschaft für einen Bildschirm-Datenmember festgelegt. ScreenCollectionProperty stellt einen Bildschirmmember des Typs Auflistung dar, und ScreenProperty steht für einen Skalartyp (Entität oder einfacher Datentyp).
DirectCast(host.PrimaryDataSourceProperty, ScreenCollectionProperty).DisablePaging = True
((ScreenCollectionProperty)host.PrimaryDataSourceProperty).DisablePaging = true;
Hinzufügen von Bildschirmmembern
Im folgenden Beispiel wird dem Bildschirm eine Zeichenfolgeneigenschaft hinzugefügt.
' Add a screen member.
Dim screenProperty As ScreenProperty = host.AddScreenProperty("Microsoft.LightSwitch:String", "NewScreenProperty")
// Add a screen member.
ScreenProperty screenProperty = host.AddScreenProperty("Microsoft.LightSwitch:String", "NewScreenProperty") as ScreenProperty;
Anzeigen des ausgewählten Elements einer Auflistung
Im folgenden Beispiel wird dem Bildschirm das ausgewählten Element einer Bildschirmauflistung hinzugefügt.
' Get the data type of your property.
Dim collectionProperty As ScreenCollectionProperty = DirectCast(host.PrimaryDataSourceProperty, ScreenCollectionProperty)
Dim collectionDataType As IEntityType = host.FindGlobalModelItem(Of ISequenceType)(collectionProperty.PropertyType).ElementType
' Create an expression that represents accessing the selected item on your collection property.
Dim chain As ChainExpression = host.CreateChainExpression(host.CreateMemberExpression(collectionProperty.Id))
host.AppendMemberExpression(chain, "SelectedItem")
' Add a content item representing the selected item and set its view to a RowsLayout.
Dim detailControl As ContentItem = host.AddContentItem(host.ScreenLayoutContentItem, "ItemDetail", ContentItemKind.Details, chain, collectionDataType)
host.SetContentItemView(detailControl, "Microsoft.LightSwitch.RichClient:RowsLayout")
host.SetControlPropertyValue(detailControl, "Microsoft.LightSwitch.RichClient:RootControl", "VerticalAlignment", "Top")
host.ExpandContentItem(detailControl)
// Get the data type of your property.
ScreenCollectionProperty collectionProperty = (ScreenCollectionProperty)(host.PrimaryDataSourceProperty);
IEntityType collectionDataType = host.FindGlobalModelItem<ISequenceType>(collectionProperty.PropertyType).ElementType as IEntityType;
// Create an expression that represents accessing the selected item on your collection property.
ChainExpression chain = host.CreateChainExpression(host.CreateMemberExpression(collectionProperty.Id));
host.AppendMemberExpression(chain, "SelectedItem");
// Add a content item representing the selected item and set its view to a RowsLayout.
ContentItem detailControl = host.AddContentItem(host.ScreenLayoutContentItem, "ItemDetail", ContentItemKind.Details, chain, collectionDataType);
host.SetContentItemView(detailControl, "Microsoft.LightSwitch.RichClient:RowsLayout");
host.SetControlPropertyValue(detailControl, "Microsoft.LightSwitch.RichClient:RootControl", "VerticalAlignment", "Top");
host.ExpandContentItem(detailControl);
Hinzufügen eines Gruppensteuerelements
Im folgenden Beispiel wird dem Bildschirm ein Gruppensteuerelement hinzugefügt.
'Add a tabs group to the screen.
Dim tabsGroup As ContentItem = host.AddContentItem(host.ScreenLayoutContentItem, "TabsGroup", ContentItemKind.Group)
host.SetContentItemView(tabsGroup, "Microsoft.LightSwitch.RichClient:TabsLayout")
// Add a tabs group to the screen.
ContentItem tabsGroup = host.AddContentItem(host.ScreenLayoutContentItem, "TabsGroup", ContentItemKind.Group);
host.SetContentItemView(tabsGroup, "Microsoft.LightSwitch.RichClient:TabsLayout");
Zugreifen auf verwandte Auflistungen
Wenn dies vom Entwickler so angegeben ist, können weitere verwandte Auflistungen zum Bildschirm hinzugefügt werden. Beispielsweise möchte der Entwickler, dass bei der Anzeige von Aufträgen auch die Auftragspositionen berücksichtigt werden. Das folgende Beispiel zeigt, wie verwandte Auflistungen zum Bildschirm hinzugefügt werden. Bei diesem Code wird vorausgesetzt, dass Sie bereits den Code aus dem vorherigen Beispiel "Hinzufügen eines Gruppensteuerelements" ergänzt haben.
For Each p As ScreenCollectionProperty In host.ChildCollectionProperties
'Display each child collection as a grid.
Dim currentTab As ContentItem = host.AddContentItem(tabsGroup, host.MakeUniqueLegalNameForContentItem("Tab"), p)
host.SetContentItemView(currentTab, "Microsoft.LightSwitch.RichClient:DataGrid")
host.ExpandContentItem(currentTab)
Next
foreach (ScreenCollectionProperty p in host.ChildCollectionProperties)
{
// Display each child collection as a grid.
ContentItem currentTab = host.AddContentItem(tabsGroup, host.MakeUniqueLegalNameForContentItem("Tab"), p);
host.SetContentItemView(currentTab, "Microsoft.LightSwitch.RichClient:DataGrid");
host.ExpandContentItem(currentTab);
}
Hinzufügen von Abfrageparametern
Wenn die für den Bildschirm ausgewählten Hauptdaten eine Abfrage sind, sind möglicherweise Parameter enthalten. Im folgenden Beispiel wird veranschaulicht, wie einem Bildschirm Parameter hinzugefügt werden.
'Add parameters to the screen.
Dim parameterGroup As ContentItem = host.AddContentItem(host.ScreenLayoutContentItem, "ParameterGroup", ContentItemKind.Group)
host.SetContentItemView(parameterGroup, "Microsoft.LightSwitch.RichClient:ColumnsLayout")
host.SetControlPropertyValue(parameterGroup, "Microsoft.LightSwitch.RichClient:RootControl", "VerticalAlignment", "Top")
For Each param As ScreenPropertyBase In host.PrimaryDataSourceParameterProperties
host.AddContentItem(parameterGroup, param.Name, param)
Next
// Add parameters to the screen.
ContentItem parameterGroup = host.AddContentItem(host.ScreenLayoutContentItem, "ParameterGroup", ContentItemKind.Group);
host.SetContentItemView(parameterGroup, "Microsoft.LightSwitch.RichClient:ColumnsLayout");
host.SetControlPropertyValue(parameterGroup, "Microsoft.LightSwitch.RichClient:RootControl", "VerticalAlignment", "Top");
foreach (ScreenPropertyBase param in host.PrimaryDataSourceParameterProperties)
{
host.AddContentItem(parameterGroup, param.Name, param);
}
Hinzufügen eines Felds aus einer Entität
Möglicherweise müssen Sie ein bestimmtes Feld aus einer Entität ermitteln und einem Bildschirm hinzufügen. Das folgende Beispiel veranschaulicht, wie Sie die Definition einer Entität finden und ein bestimmtes Feld aus dem ausgewählten Element hinzufügen. Beachten Sie, dass der erste Codeblock Code aus dem früheren Beispiel "Anzeigen des ausgewählten Elements einer Auflistung" dupliziert.
'Find field called "Name"
Dim nameProperty As IEntityPropertyDefinition = collectionDataType.Properties.Where(Function(p) p.Name.ToLower = "name").FirstOrDefault()
If nameProperty IsNot Nothing Then
'expression used to access collectionproperty.SelectedItem.Name
Dim nameExpression As ChainExpression = host.CreateChainExpression(host.CreateMemberExpression(collectionProperty.Id))
host.AppendMemberExpression(nameExpression, "SelectedItem")
host.AppendMemberExpression(nameExpression, nameProperty.Name)
Dim namePropertyControl As ContentItem = host.AddContentItem(host.ScreenLayoutContentItem,
host.MakeUniqueLegalNameForContentItem("Name"),
ContentItemKind.Value,
nameExpression,
nameProperty.PropertyType)
host.SetControlPropertyValue(namePropertyControl, "Microsoft.LightSwitch.RichClient:RootControl", "VerticalAlignment", "Top")
End If
// Find field called "Name".
IEntityPropertyDefinition nameProperty = collectionDataType.Properties.Where(p => p.Name.ToLower() == "name").FirstOrDefault();
if (nameProperty != null)
{
// Expression used to access collectionproperty.SelectedItem.Name
ChainExpression nameExpression = host.CreateChainExpression(host.CreateMemberExpression(collectionProperty.Id));
host.AppendMemberExpression(nameExpression, "SelectedItem");
host.AppendMemberExpression(nameExpression, nameProperty.Name);
ContentItem namePropertyControl = host.AddContentItem(host.ScreenLayoutContentItem,
host.MakeUniqueLegalNameForContentItem("Name"),
ContentItemKind.Value,
nameExpression,
nameProperty.PropertyType);
host.SetControlPropertyValue(namePropertyControl, "Microsoft.LightSwitch.RichClient:RootControl", "VerticalAlignment", "Top");
}
Wenn Ihr Ziel darin besteht, alle oder die meisten Felder einer Entität anzuzeigen, ist es am besten, einen Detail-Knoten zu erstellen und host.ExpandContentItem zu verwenden. Die Ergebnisse können Sie bei Bedarf modifizieren.
Hinzufügen von Code zum Bildschirm
Mit der host.AddScreenCodeBehind-Methode veranlassen Sie das Vorlagenmodul, Code-Behind-Bausteine während der Bildschirmerstellung hinzuzufügen. Der Entwickler kann diesen Code ändern. Code muss als sprachspezifische Zeichenfolge bereitgestellt werden. Daher ist für jede Sprache, die Sie aktivieren möchten (derzeit werden C# und Visual Basic unterstützt), eine Codezeichenfolge bereitzustellen. Im folgenden Beispiel wird die Möglichkeit veranschaulicht, dies mithilfe eines Wörterbuchs zu erreichen. Das Wörterbuch setzt die Codierungssprache in eine formatierte Zeichenfolge um, die den Code für diese Sprache enthält. Zuerst wird dem Bildschirm eine lokale Eigenschaft des Typs String hinzugefügt. Anschließend wird der Code-Behind hinzugefügt, um den Wert in der InitializeDataWorkspace-Methode festzulegen. Das folgende Beispiel zeigt das Wörterbuch an, das den Code-Behind für Visual Basic und C# enthält.
Private Shared _codeTemplates As Dictionary(Of CodeLanguage, String) = New Dictionary(Of CodeLanguage, String)() From
{
{CodeLanguage.CSharp, _
"" _
+ "{0}namespace {1}" _
+ "{0}{{" _
+ "{0} public partial class {2}" _
+ "{0} {{" _
+ "{0}" _
+ "{0} partial void {2}_InitializeDataWorkspace(global::System.Collections.Generic.List<global::Microsoft.LightSwitch.IDataService> saveChangesTo)" _
+ "{0} {{" _
+ "{0} this.{3} = ""Hello World"";" _
+ "{0} }}" _
+ "{0}" _
+ "{0} }}" _
+ "{0}}}"
}, _
{CodeLanguage.VB, _
"" _
+ "{0}Namespace {1}" _
+ "{0}" _
+ "{0} Public Class {2}" _
+ "{0}" _
+ "{0} Private Sub {2}_InitializeDataWorkspace(ByVal saveChangesTo As Global.System.Collections.Generic.List(Of Global.Microsoft.LightSwitch.IDataService))" _
+ "{0} Me.{3} = ""Hello World""" _
+ "{0} End Sub" _
+ "{0}" _
+ "{0} End Class" _
+ "{0}" _
+ "{0}End Namespace" _
}
}
private static Dictionary<CodeLanguage, String> _codeTemplates = new Dictionary<CodeLanguage, String>()
{
{CodeLanguage.CSharp,
""
+ "{0}namespace {1}"
+ "{0}{{"
+ "{0} public partial class {2}"
+ "{0} {{"
+ "{0}"
+ "{0} partial void {2}_InitializeDataWorkspace(global::System.Collections.Generic.List<global::Microsoft.LightSwitch.IDataService> saveChangesTo)"
+ "{0} {{"
+ "{0} this.{3} = \"Hello World\";"
+ "{0} }}"
+ "{0}"
+ "{0} }}"
+ "{0}}}"
},
{CodeLanguage.VB,
""
+ "{0}Namespace {1}"
+ "{0}"
+ "{0} Public Class {2}"
+ "{0}"
+ "{0} Private Sub {2}_InitializeDataWorkspace(ByVal saveChangesTo As Global.System.Collections.Generic.List(Of Global.Microsoft.LightSwitch.IDataService))"
+ "{0} Me.{3} = \"Hello World\""
+ "{0} End Sub"
+ "{0}"
+ "{0} End Class"
+ "{0}"
+ "{0}End Namespace"
}
};
Der folgende Code muss der Generate-Methode ebenfalls hinzugefügt werden:
' Code Generation
Dim codeTemplate As String = ""
If _codeTemplates.TryGetValue(host.ScreenCodeBehindLanguage, codeTemplate) Then
host.AddScreenCodeBehind(String.Format(codeTemplate,
Environment.NewLine,
host.ScreenNamespace,
host.ScreenName,
screenProperty.Name))
End If
// Code Generation
string codeTemplate = "";
if (_codeTemplates.TryGetValue(host.ScreenCodeBehindLanguage, out codeTemplate))
{
host.AddScreenCodeBehind(String.Format(codeTemplate,
Environment.NewLine,
host.ScreenNamespace,
host.ScreenName,
screenProperty.Name));
}
Codelisting
Nachfolgend finden Sie eine vollständige Codeauflistung für eine Bildschirmvorlage mit dem Namen "TestTemplate" mit dem gesamten Code dieses Themas.
Imports System
Imports System.Collections.Generic
Imports System.ComponentModel.Composition
Imports System.Text
Imports Microsoft.LightSwitch.Designers.ScreenTemplates.Model
Imports Microsoft.LightSwitch.Model.Storage
Imports Microsoft.LightSwitch.Model
Imports System.Management
Namespace ScreenTemplates
Public Class TestTemplate
Implements IScreenTemplate
#Region "IScreenTemplate Members"
Public Sub Generate(host As IScreenTemplateHost) Implements IScreenTemplate.Generate
Dim primaryDataControl As ContentItem = host.AddContentItem(host.ScreenLayoutContentItem, host.MakeUniqueLegalNameForContentItem("My Root Data"), host.PrimaryDataSourceProperty)
host.SetContentItemView(primaryDataControl, "Microsoft.LightSwitch.RichClient:DataGrid")
host.ExpandContentItem(primaryDataControl)
host.SetControlPropertyValue(primaryDataControl, "Microsoft.LightSwitch.RichClient:RootControl", "VerticalAlignment", "Top")
host.SetControlPropertyValue(primaryDataControl, "Microsoft.LightSwitch.RichClient:RootControl", "HeightSizingMode", "Auto")
host.SetDisplayName(primaryDataControl, "Main Screen Data")
DirectCast(host.PrimaryDataSourceProperty, ScreenCollectionProperty).DisablePaging = True
'Get the data type of your property
Dim collectionProperty As ScreenCollectionProperty = DirectCast(host.PrimaryDataSourceProperty, ScreenCollectionProperty)
Dim collectionDataType As IEntityType = host.FindGlobalModelItem(Of ISequenceType)(collectionProperty.PropertyType).ElementType
'Create an expression that represents accessing the selected item on your collection property
Dim chain As ChainExpression = host.CreateChainExpression(host.CreateMemberExpression(collectionProperty.Id))
host.AppendMemberExpression(chain, "SelectedItem")
'Add a content item representing the selected item and set its view to a RowsLayout
Dim detailControl As ContentItem = host.AddContentItem(host.ScreenLayoutContentItem, "ItemDetail", ContentItemKind.Details, chain, collectionDataType)
host.SetContentItemView(detailControl, "Microsoft.LightSwitch.RichClient:RowsLayout")
host.SetControlPropertyValue(detailControl, "Microsoft.LightSwitch.RichClient:RootControl", "VerticalAlignment", "Top")
host.ExpandContentItem(detailControl)
'Add parameters to the screen.
Dim parameterGroup As ContentItem = host.AddContentItem(host.ScreenLayoutContentItem, "ParameterGroup", ContentItemKind.Group)
host.SetContentItemView(parameterGroup, "Microsoft.LightSwitch.RichClient:ColumnsLayout")
host.SetControlPropertyValue(parameterGroup, "Microsoft.LightSwitch.RichClient:RootControl", "VerticalAlignment", "Top")
For Each param As ScreenPropertyBase In host.PrimaryDataSourceParameterProperties
host.AddContentItem(parameterGroup, param.Name, param)
Next
'Find field called "Name".
Dim nameProperty As IEntityPropertyDefinition = collectionDataType.Properties.Where(Function(p) p.Name.ToLower = "name").FirstOrDefault()
If nameProperty IsNot Nothing Then
'expression used to access collectionproperty.SelectedItem.Name
Dim nameExpression As ChainExpression = host.CreateChainExpression(host.CreateMemberExpression(collectionProperty.Id))
host.AppendMemberExpression(nameExpression, "SelectedItem")
host.AppendMemberExpression(nameExpression, nameProperty.Name)
Dim namePropertyControl As ContentItem = host.AddContentItem(host.ScreenLayoutContentItem,
host.MakeUniqueLegalNameForContentItem("Name"),
ContentItemKind.Value,
nameExpression,
nameProperty.PropertyType)
host.SetControlPropertyValue(namePropertyControl, "Microsoft.LightSwitch.RichClient:RootControl", "VerticalAlignment", "Top")
End If
'Add a tabs group to the screen.
Dim tabsGroup As ContentItem = host.AddContentItem(host.ScreenLayoutContentItem, "TabsGroup", ContentItemKind.Group)
host.SetContentItemView(tabsGroup, "Microsoft.LightSwitch.RichClient:TabsLayout")
For Each p As ScreenCollectionProperty In host.ChildCollectionProperties
'Display each child collection as a grid
Dim currentTab As ContentItem = host.AddContentItem(tabsGroup, host.MakeUniqueLegalNameForContentItem("Tab"), p)
host.SetContentItemView(currentTab, "Microsoft.LightSwitch.RichClient:DataGrid")
host.ExpandContentItem(currentTab)
Next
'Add a screen member.
Dim screenProperty As ScreenProperty = host.AddScreenProperty("Microsoft.LightSwitch:String", "NewScreenProperty")
'Code Generation
Dim codeTemplate As String = ""
If _codeTemplates.TryGetValue(host.ScreenCodeBehindLanguage, codeTemplate) Then
host.AddScreenCodeBehind(String.Format(codeTemplate,
Environment.NewLine,
host.ScreenNamespace,
host.ScreenName,
screenProperty.Name))
End If
End Sub
Private Shared _codeTemplates As Dictionary(Of CodeLanguage, String) = New Dictionary(Of CodeLanguage, String)() From
{
{CodeLanguage.CSharp, _
"" _
+ "{0}namespace {1}" _
+ "{0}{{" _
+ "{0} public partial class {2}" _
+ "{0} {{" _
+ "{0}" _
+ "{0} partial void {2}_InitializeDataWorkspace(global::System.Collections.Generic.List<global::Microsoft.LightSwitch.IDataService> saveChangesTo)" _
+ "{0} {{" _
+ "{0} this.{3} = ""Hello World"";" _
+ "{0} }}" _
+ "{0}" _
+ "{0} }}" _
+ "{0}}}"
}, _
{CodeLanguage.VB, _
"" _
+ "{0}Namespace {1}" _
+ "{0}" _
+ "{0} Public Class {2}" _
+ "{0}" _
+ "{0} Private Sub {2}_InitializeDataWorkspace(ByVal saveChangesTo As Global.System.Collections.Generic.List(Of Global.Microsoft.LightSwitch.IDataService))" _
+ "{0} Me.{3} = ""Hello World""" _
+ "{0} End Sub" _
+ "{0}" _
+ "{0} End Class" _
+ "{0}" _
+ "{0}End Namespace" _
}
}
Public ReadOnly Property Description As String Implements IScreenTemplateMetadata.Description
Get
Return "Test Template Description"
End Get
End Property
Public ReadOnly Property DisplayName As String Implements IScreenTemplateMetadata.DisplayName
Get
Return "Test Template"
End Get
End Property
Public ReadOnly Property PreviewImage As Uri Implements IScreenTemplateMetadata.PreviewImage
Get
Return New Uri("/ScreenTemplateExtension.Design;component/Resources/ScreenTemplateImages/TestTemplateLarge.png", UriKind.Relative)
End Get
End Property
Public ReadOnly Property RootDataSource As RootDataSourceType Implements IScreenTemplateMetadata.RootDataSource
Get
Return RootDataSourceType.Collection
End Get
End Property
Public ReadOnly Property ScreenNameFormat As String Implements IScreenTemplateMetadata.ScreenNameFormat
Get
Return "{0}TestTemplate"
End Get
End Property
Public ReadOnly Property SmallIcon As Uri Implements IScreenTemplateMetadata.SmallIcon
Get
Return New Uri("/ScreenTemplateExtension.Design;component/Resources/ScreenTemplateImages/TestTemplateSmall.png", UriKind.Relative)
End Get
End Property
Public ReadOnly Property SupportsChildCollections As Boolean Implements IScreenTemplateMetadata.SupportsChildCollections
Get
Return True
End Get
End Property
Public ReadOnly Property TemplateName As String Implements IScreenTemplateMetadata.TemplateName
Get
Return TestTemplate.TemplateId
End Get
End Property
#End Region
#Region "Constants"
Friend Const TemplateId As String = "ScreenTemplateExtension:TestTemplate"
#End Region
End Class
<Export(GetType(IScreenTemplateFactory))>
<Template(TestTemplate.TemplateId)>
Friend Class TestTemplateFactory
Implements IScreenTemplateFactory
#Region "IScreenTemplateFactory Members"
Public Function CreateScreenTemplate() As IScreenTemplate Implements IScreenTemplateFactory.CreateScreenTemplate
Return New TestTemplate()
End Function
#End Region
End Class
End Namespace
using System;
using System.Collections.Generic;
using System.ComponentModel.Composition;
using System.Linq;
using System.Management;
using System.Text;
using Microsoft.LightSwitch.Designers.ScreenTemplates.Model;
using Microsoft.LightSwitch.Model;
using Microsoft.LightSwitch.Model.Storage;
namespace ScreenTemplateExtension.ScreenTemplates
{
public class TestTemplate : IScreenTemplate
{
#region IScreenTemplate Members
public void Generate(IScreenTemplateHost host)
{
ContentItem primaryDataControl = host.AddContentItem(host.ScreenLayoutContentItem, host.MakeUniqueLegalNameForContentItem("My Root Data"), host.PrimaryDataSourceProperty);
host.SetContentItemView(primaryDataControl, "Microsoft.LightSwitch: .RichClient DataGrid");
host.ExpandContentItem(primaryDataControl);
host.SetControlPropertyValue(primaryDataControl, "Microsoft.LightSwitch.RichClient:RootControl", "VerticalAlignment", "Top");
host.SetControlPropertyValue(primaryDataControl, "Microsoft.LightSwitch.RichClient:RootControl", "HeightSizingMode", "Auto");
host.SetDisplayName(primaryDataControl, "Main Screen Data");
((ScreenCollectionProperty)host.PrimaryDataSourceProperty).DisablePaging = true;
// Get the data type of your property.
ScreenCollectionProperty collectionProperty = (ScreenCollectionProperty)(host.PrimaryDataSourceProperty);
IEntityType collectionDataType = host.FindGlobalModelItem<ISequenceType>(collectionProperty.PropertyType).ElementType as IEntityType;
// Create an expression that represents accessing the selected item on your collection property.
ChainExpression chain = host.CreateChainExpression(host.CreateMemberExpression(collectionProperty.Id));
host.AppendMemberExpression(chain, "SelectedItem");
// Add a content item representing the selected item and set its view to a RowsLayout.
ContentItem detailControl = host.AddContentItem(host.ScreenLayoutContentItem, "ItemDetail", ContentItemKind.Details, chain, collectionDataType);
host.SetContentItemView(detailControl, "Microsoft.LightSwitch.RichClient:RowsLayout");
host.SetControlPropertyValue(detailControl, "Microsoft.LightSwitch.RichClient:RootControl", "VerticalAlignment", "Top");
host.ExpandContentItem(detailControl);
// Add parameters to the screen.
ContentItem parameterGroup = host.AddContentItem(host.ScreenLayoutContentItem, "ParameterGroup", ContentItemKind.Group);
host.SetContentItemView(parameterGroup, "Microsoft.LightSwitch.RichClient:ColumnsLayout");
host.SetControlPropertyValue(parameterGroup, "Microsoft.LightSwitch.RichClient:RootControl", "VerticalAlignment", "Top");
foreach (ScreenPropertyBase param in host.PrimaryDataSourceParameterProperties)
{
host.AddContentItem(parameterGroup, param.Name, param);
}
// Find field called "Name".
IEntityPropertyDefinition nameProperty = collectionDataType.Properties.Where(p => p.Name.ToLower() == "name").FirstOrDefault();
if (nameProperty != null)
{
// Expression used to access collectionproperty.SelectedItem.Name
ChainExpression nameExpression = host.CreateChainExpression(host.CreateMemberExpression(collectionProperty.Id));
host.AppendMemberExpression(nameExpression, "SelectedItem");
host.AppendMemberExpression(nameExpression, nameProperty.Name);
ContentItem namePropertyControl = host.AddContentItem(host.ScreenLayoutContentItem,
host.MakeUniqueLegalNameForContentItem("Name"),
ContentItemKind.Value,
nameExpression,
nameProperty.PropertyType);
host.SetControlPropertyValue(namePropertyControl, "Microsoft.LightSwitch.RichClient:RootControl", "VerticalAlignment", "Top");
}
// Add a tabs group to the screen.
ContentItem tabsGroup = host.AddContentItem(host.ScreenLayoutContentItem, "TabsGroup", ContentItemKind.Group);
host.SetContentItemView(tabsGroup, "Microsoft.LightSwitch.RichClient:TabsLayout");
foreach (ScreenCollectionProperty p in host.ChildCollectionProperties)
{
// Display each child collection as a grid.
ContentItem currentTab = host.AddContentItem(tabsGroup, host.MakeUniqueLegalNameForContentItem("Tab"), p);
host.SetContentItemView(currentTab, "Microsoft.LightSwitch.RichClient:DataGrid");
host.ExpandContentItem(currentTab);
}
// Add a screen member.
ScreenProperty screenProperty = host.AddScreenProperty("Microsoft.LightSwitch:String", "NewScreenProperty") as ScreenProperty;
// Code Generation
string codeTemplate = "";
if (_codeTemplates.TryGetValue(host.ScreenCodeBehindLanguage, out codeTemplate))
{
host.AddScreenCodeBehind(String.Format(codeTemplate,
Environment.NewLine,
host.ScreenNamespace,
host.ScreenName,
screenProperty.Name));
}
}
private static Dictionary<CodeLanguage, String> _codeTemplates = new Dictionary<CodeLanguage, String>()
{
{CodeLanguage.CSharp,
""
+ "{0}namespace {1}"
+ "{0}{{"
+ "{0} public partial class {2}"
+ "{0} {{"
+ "{0}"
+ "{0} partial void {2}_InitializeDataWorkspace(global::System.Collections.Generic.List<global::Microsoft.LightSwitch.IDataService> saveChangesTo)"
+ "{0} {{"
+ "{0} this.{3} = \"Hello World\";"
+ "{0} }}"
+ "{0}"
+ "{0} }}"
+ "{0}}}"
},
{CodeLanguage.VB,
""
+ "{0}Namespace {1}"
+ "{0}"
+ "{0} Public Class {2}"
+ "{0}"
+ "{0} Private Sub {2}_InitializeDataWorkspace(ByVal saveChangesTo As Global.System.Collections.Generic.List(Of Global.Microsoft.LightSwitch.IDataService))"
+ "{0} Me.{3} = \"Hello World\""
+ "{0} End Sub"
+ "{0}"
+ "{0} End Class"
+ "{0}"
+ "{0}End Namespace"
}
};
public string Description
{
get { return "TestTemplate Description"; }
}
public string DisplayName
{
get { return "Test Template"; }
}
public Uri PreviewImage
{
get { return new Uri("/ScreenTemplateExtension.Design;component/Resources/ScreenTemplateImages/TestTemplateLarge.png", UriKind.Relative); }
}
public RootDataSourceType RootDataSource
{
get { return RootDataSourceType.Collection; }
}
public string ScreenNameFormat
{
get { return "{0}TestTemplate"; }
}
public Uri SmallIcon
{
get { return new Uri("/ScreenTemplateExtension.Design;component/Resources/ScreenTemplateImages/TestTemplateSmall.png", UriKind.Relative); }
}
public bool SupportsChildCollections
{
get { return true; }
}
public string TemplateName
{
get { return TestTemplate.TemplateId; }
}
#endregion
#region Constants
internal const string TemplateId = "ScreenTemplateExtension:TestTemplate";
#endregion
}
[Export(typeof(IScreenTemplateFactory))]
[Template(TestTemplate.TemplateId)]
internal class TestTemplateFactory : IScreenTemplateFactory
{
#region IScreenTemplateFactory Members
IScreenTemplate IScreenTemplateFactory.CreateScreenTemplate()
{
return new TestTemplate();
}
#endregion
}
}
Siehe auch
Aufgaben
Gewusst wie: Debuggen oder Testen einer LightSwitch-Erweiterung
Gewusst wie: Erstellen eines LightSwitch-Erweiterungsprojekts
Konzepte
LightSwitch-Steuerelement ViewIDs
Definieren, Überschreiben und Verwenden von LightSwitch-Steuerelementeigenschaften