{"id":55000189,"date":"2019-08-01T00:00:00","date_gmt":"2020-03-27T19:38:57","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=189"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Von_Access_zum_EDM_per_Kontextmenue","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/Von_Access_zum_EDM_per_Kontextmenue\/","title":{"rendered":"Von Access zum EDM per Kontextmenü"},"content":{"rendered":"

Nach den vorbereitenden Artikel zum Thema Erweitern von Visual Studio, Anlegen von Elementen im Projektmappen-Explorer und Hinzufügen von Elementen wie Klassen, Prozeduren et cetera per Code können wir uns an ein praktisches Beispiel begeben: Eine Anwendung, die Sie per Menüeintrag aus dem Kontextmenü eines Projekts aus aufrufen können und die nach der Auswahl der Access-Datenbank mit dem zu verwendenden Datenmodell ein Entity Data Model auf Basis dieser Datenbank erstellt. Damit können Sie dann mit wenigen Handgriffen auch direkt eine SQL Server-Datenbank generieren.<\/b><\/p>\n

Grundlagen<\/h2>\n

Die Grundlagen zu den hier verwendeten Techniken finden Sie in den Artikeln Visual Studio erweitern: Menübefehle<\/b>, Visual Studio erweitern: Elemente hinzufügen<\/b>, Visual Studio mit LINQPad: Project und ProjectItems <\/b>und Klassen, Methoden und Co. per Code generieren<\/b>. Außerdem haben wir den größten Teil des Codes, den wir hier in eine Extension stecken wollen, in den Artikeln Von Access zu Entity Framework: Datenmodell<\/b>, Von Access zu Entity Framework: Daten<\/b>, Von Access zu EF: Step by Step<\/b> und Von Access zu Entity Framework: Update 1<\/b> beschrieben.<\/p>\n

Projekt erstellen<\/h2>\n

Die Erweiterung, die unsere Funktionalität in Visual Studio zur Verfügung stellen soll, basiert auf einem Projekt mit der Vorlage Visual Basic|Extensibility|VSIX Projekt<\/b>, die wir Access2EDM <\/b>nennen. Die beiden Elemente index.html <\/b>und stylesheet.css<\/b>, die im nun erstellen Projekt vorliegen, löschen wir direkt.<\/p>\n

Dafür fügen wir über den Kontextmenü-Eintrag Hinzufügen|Neues Element… <\/b>des Projekt-Elements im Projektmappen-Explorer ein neues Element des Typs Extensibility|Custom Command <\/b>hinzu und nennen dieses cmdAccess2EDM<\/b>.<\/p>\n

Damit der standardmäßig im Extras<\/b>-Menü angezeigte Befehl nun im Kontextmenü des Projekt-Elements im Projektmappen-Explorer erscheint, ändern wir eine Zeile in der Datei cmdAccess2EDMPackage.vsct<\/b>, wo wir IDM_VS_MENU_TOOLS <\/b>durch IDM_VS_CTXT_PROJNODE <\/b>ersetzen, was folgende Zeile ergibt:<\/p>\n

<Parent guid=\"guidSHLMainMenu\" id=\"IDM_VS_CTXT_PROJNODE\"\/><\/pre>\n
Außerdem ändern wir in der Zeile zur Definition des Elements ButtonText <\/b>die Beschriftung wie folgt:<\/p>\n
<ButtonText>EDM aus Access-Datenbank<\/ButtonText><\/pre>\n
Icon hinzufügen<\/h2>\n
Als Icon wollen wir ein Access-Logo verwenden. Dieses finden wir in einer Ressourcen-Datei accicons.exe<\/b>. Wir extrahieren die .ico<\/b>-Datei und fügen diese zum Ordner Resources <\/b>des Projekts hinzu. Außerdem ändern wir noch eine weitere Zeile in der bereits bearbeiteten Datei wie folgt ab, um die neu hinzugefügte Bilddatei zu verwenden:<\/p>\n
<Bitmap guid=\"guidImages\" href=\"Resources\\Access.ico\"\/><\/pre>\n
Danach finden wir den Eintrag EDM aus Access-Datenbank <\/b>wie Bild 1 in im Kontextmenü des Projekt-Elements im Projektmappen-Explorer der beim Debuggen gestarteten Instanz von Visual Studio vor.<\/p>\n
\"Erster<\/p>\n
Bild 1: Erster Test des neuen Kontextmenü-Eintrags<\/span><\/b><\/p>\n
Damit sind die Arbeiten an der Datei cmdAccess2EDMPackage.vsct <\/b>beendet und Sie können diese Datei speichern und schließen.<\/p>\n
Wechsel zu LINQPad<\/h2>\n
Ab dieser Stelle sind wir für die Programmierung komplett auf LINQPad umgeschwenkt. Das ständige Warten beim Debuggen der Anwendung zum Testen zerstört jeden Programmierfluss. Nur zwischendurch zum Testen und am Ende fügen wir den produzierten Code in das VSIX-Projekt ein.<\/p>\n
Die Basis: Entity Data Model<\/h2>\n
Basis für das Erstellen eines Entity Data Model auf Basis des Datenmodells einer Access-Datenbank ist das Hinzufügen eines neuen Elements des Typs ADO.NET Entity Date Model<\/b>, was normalerweise über den Dialog Neues Element hinzufügen <\/b>geschieht. Dort wird dann auch der Name des neuen Entity Data Models eingegeben (siehe Bild 2).<\/p>\n
\"Hinzufügen<\/p>\n
Bild 2: Hinzufügen des Entity Data Models auf herkömmlichem Wege<\/span><\/b><\/p>\n
Diesen Schritt wollen wir bereits per Code erledigen und dazu müssen wir den Pfad der Vorlage ermitteln. Diese finden wir mit einer kleinen Prozedur heraus, die wir im Tool LINQPad <\/b>ausführen können und die wie folgt aussieht:<\/p>\n
Public Sub <\/span>Main\r\n     Dim <\/span>objDTE As <\/span>EnvDTE80.DTE2 = Nothing\r\n     Dim <\/span>objSolution As <\/span>EnvDTE80.Solution2\r\n     Dim <\/span>strTemplate As String<\/span>\r\n     If <\/span>GetDTE(objDTE) = True<\/span> Then<\/span>\r\n         objSolution = Trycast(objDTE.Solution, EnvDTE80.Solution2)\r\n         strTemplate = objSolution.GetProjectItemTemplate(\"Daten\\ADO.NET Entity Data Model\", \"VisualBasic\")\r\n         Debug.Print<\/span>(strTemplate)\r\n     End If<\/span>\r\nEnd Sub<\/span><\/pre>\n
Die hier verwendete Hilfsfunktion GetDTE <\/b>finden Sie in der Datei Access2EDM.linq<\/b>. In dieser Datei entwickeln wir innerhalb der Benutzeroberfläche von LINQPad auch den Quellcode dieser Lösung. Der Hintergrund ist, dass das Debuggen von Extensions mit Visual Studio äußerst zeitaufwendig ist, da das Starten zum Debuggen wegen der dazu benötigten zusätzlichen Instanz von Visual Studio sehr lange dauert.<\/p>\n
Mit der oben genannten Prozedur finden wir den Pfad der Vorlage für das ADO.NET Entity Data Model <\/b>schnell heraus:<\/p>\n
C:\\Program Files (x86)\\Microsoft Visual Studio\\2017\\Community\\Common7\\IDE\\ItemTemplates\\VisualBasic\\Data\\1033\\EF_EDM\\ModelObjectItemVB.vstemplate<\/pre>\n
Sie können sich diese Datei auch einmal ansehen.<\/p>\n
ADO.NET Entity Data Model-Vorlage hinzufügen<\/h2>\n
Wenn wir die oben begonnene Prozedur wie folgt erweitern, sollten eigentlich automatisch die entsprechenden Elemente für das Entity Data Model hinzugefügt werden:<\/p>\n
If <\/span>GetCurrentOrNewProject(objProject) = True<\/span> Then<\/span>\r\n     objProject.ProjectItems.AddFromTemplate(strTemplate, \"BestellverwaltungContext\")\r\nEnd If<\/span><\/pre>\n
Allerdings ruft dies noch den Dialog aus Bild 3 auf den Plan. Hier müssen wir noch die Option Leeres Code First-Modell auswählen <\/b>und auf die Schaltfläche Fertigstellen<\/b> klicken, damit die Elemente des leeren Entity Data Models zum Projekt hinzugefügt werden. Leider ist und keine Möglichkeit bekannt, wir diesen Dialog umschiffen können. Daher fügen wir vorher ein Meldungsfenster ein, das den Benutzer darauf hinweist, die Option Leeres Code First-Modell <\/b>auszuwählen.<\/p>\n
\"Entity<\/p>\n
Bild 3: Entity Data Model hinzufügen<\/span><\/b><\/p>\n
In der Datei ModelObjectItemVB.vstemplate <\/b>sehen wir dann auch, dass dort noch ein Assistent namens ModelObjectItemWizard <\/b>geöffnet im Spiel ist, der vermutlich den soeben beschriebenen Dialog erscheinen lässt.<\/p>\n
Wenn wir uns nun allerdings ansehen, welche Elemente und Änderungen der Assistent in unser Projekt gebracht hat, stellt sich die Frage, ob wir nicht selbst eine passende Erweiterung aus dem Ärmel schütteln können. Doch das würde aktuell den Rahmen sprengen, sodass wir uns dieses Thema in einer späteren Ausgabe vornehmen werden.<\/p>\n
Wir haben nun jedenfalls die grundlegenden Elemente des Entity Data Models im Projekt:<\/p>\n