%YXSV/EVP,IMR^;EGLPIV -RLEPXPMGLIW0IOXSVEX9PVMOI&ÔXXGLIV F],)6(8:IVPEKJÚV&MPHYRKWQIHMIR+QF, *SVXKIWGLVMXXIRI4VSKVEQQMIVYRK

:'742)8* %YXSV/EVP,IMR^;EGLPIV -RLEPXPMGLIW0IOXSVEX9PVMOI&ÔXXGLIV %YJPEKIZSQ(I^IQFIV F],)6(8:IVPEKJÚV&MPHYRKWQIHMIR+QF, &SHIRLIMQ -RXIVRIX[[[LIVHX]SYHIEXGL [[[LIVHXFYWMRIWWHIEXGL [[[LIVHXZLWHIEX %PPI 6IGLXI ZSVFILEPXIR /IMR 8IMP HIW ;IVOIW HEVJ MR MVKIRHIMRIV*SVQ(VYGO*SXSOSTMI1MGVSJMPQSHIVIMRIQ ERHIVIR :IVJELVIR SLRI WGLVMJXPMGLI +IRILQMKYRK HIW,IVEYWKIFIVW VITVSHY^MIVX SHIV YRXIV :IV[IRHYRK IPIOXVSRMWGLIV 7]WXIQI ZIVEVFIMXIX ZIVZMIPJÂPXMKX SHIV ZIVFVIMXIX[IVHIR (MIWI 9RXIVPEKI [YVHI QMX KVS½IV 7SVKJEPX IVWXIPPX YRH KITVÚJX8VSX^HIQ OÔRRIR *ILPIV RMGLX ZSPPOSQQIR EYW KIWGLPSWWIR [IVHIR :IVPEK,IVEYWKIFIV YRH %YXSVIR OÔRRIRJÚVJILPIVLEJXI%RKEFIRYRHHIVIR*SPKIR[IHIV IMRI NYVMWXMWGLI :IVERX[SVXYRK RSGL MVKIRHIMRI,EJXYRK ÚFIVRILQIR (MI &MPHYRKWQIHMIR HIW,)6(8:IVPEKW IRXLEPXIR 0MROW F^[ :IV[IMWI EYJ -RXIVRIXWIMXIR ERHIVIV %RFMIXIV %YJ -RLEPX YRH +IWXEPXYRK HMIWIV %RKIFSXI LEX HIV,)6(8 :IVPEK OIMRIVPIM )MRJPYWW,MIVJÚV WMRH EPPIMRI HMI NI[IM PMKIR%RFMIXIVZIVERX[SVXPMGL 1MGVSWSJX 6ISUAL #é.%4 JÚV ;MRHS[W 28<4 *SVXKIWGLVMXXIRI4VSKVEQQMIVYRK Ã Ã Ã :'742)8*Ã Ã

I NHALTSVERZEICHNIS Visual C#.NET - Fortgeschr ittene Programmierung 1 Was Sie wissen sollten...6 2 Mit Threads arbeiten...8 2.1 Einführung... 8 2.2 Threads verwenden... 9 2.3 Sperren und Synchronisieren von Threads... 13 2.3.1 Sperren von Threads mit lock... 13 2.3.2 Deadlocks... 15 2.3.3 Synchronisieren von Threads mithilfe der Klasse Mutex... 15 2.3.4 Synchronisieren von Threads mithilfe der Klasse Monitor... 17 2.3.5 Die Klasse Timer... 19 2.3.6 Die Klasse ThreadPool... 21 2.4 Übung... 23 3 Assemblies analysieren, verwalten und schützen...26 3.1 Assemblies analysieren... 26 3.1.1 Assemblies und Module ermitteln... 27 3.1.2 Typen und Typmember ermitteln... 28 3.1.3 Attribute... 31 3.1.4 IL-Code betrachten... 33 3.1.5 Assemblies und Typen dynamisch erstellen... 33 3.2 Assemblies verwalten... 36 3.3 Assemblies schützen... 37 3.3.1 Signieren mit digitalem Zertifikat... 37 3.3.2 Vergeben von starken Namen... 38 3.3.3 Verbergen von Informationen... 40 3.4 Übung... 40 5.4.4 Menüs dynamisch erzeugen...63 5.4.5 Menüs dynamisch verändern...66 5.5 Dialoge... 68 5.6 Statuszeilen... 72 5.7 Symbolleisten... 73 5.8 Hinweise (ToolTips) anzeigen... 75 5.9 Fehlermeldungen anzeigen... 76 5.10 Hilfe anzeigen... 78 5.11 MDI-Fenster... 80 5.12 Übung... 83 6 Mit dem Grafikobjekt zeichnen...86 6.1 Einführung... 86 6.2 Objekte vom Typ Graphics erzeugen... 86 6.3 Zeichenwerkzeuge und -farben... 87 6.3.1 Zeichnen mit Pen-Objekten...88 6.3.2 Zeichnen mit Brush-Objekten...90 6.4 Text grafisch darstellen... 91 6.5 Bilder erzeugen und anzeigen... 92 6.6 Benutzerdefinierte Farben verwenden... 95 6.7 Grafiken skalieren, verschieben und drehen... 96 6.7.1 Globale Transformation...96 6.7.2 Lokale Transformation...97 6.8 Doppelte Pufferung... 98 6.9 Übung... 99 7 Druckausgabe...100 7.1 Ereignisorientiertes Drucken... 100 7.2 Komponenten für die Druckausgabe... 101 7.3 Drucken von mehrseitigen Texten... 103 7.4 Übung... 106 4 Betriebssystem analysieren und steuern...42 4.1 Systeminformationen ermitteln... 42 4.1.1 Auflisten von Prozessen, Modulen und Threads... 42 4.1.2 Arbeiten mit Ereignisprotokollen... 44 4.1.3 Performanceinformationen... 47 4.2 Windows-Prozesse starten und beenden... 51 4.3 Übung... 54 5 Windows-Anwendungen entwickeln...56 5.1 Grundlagen... 56 5.2 Formulare... 56 5.3 Aufteilen der Benutzeroberfläche... 58 5.4 Menüs... 60 5.4.1 Hauptmenü... 60 5.4.2 Kontextmenü... 62 5.4.3 Menüeinträge mit Symbolen versehen... 63 8 Datenbankanwendungen - Grundlagen...108 8.1 Aufbau und Funktion einer Datenbank... 108 8.2 Einführung in SQL... 112 8.2.1 Sprachumfang von SQL...112 8.2.2 Die Datendefinitionssprache DDL...112 8.2.3 Die Abfragesprache DQL...114 8.2.4 Datenaktualisierung mit DML...116 8.2.5 Der Join...117 8.3 XML... 118 8.4 ADO.NET... 118 9 Datenbankanwendungen mit ADO.NET...120 9.1 Vorbereitungen... 120 9.1.1 Installation und Einrichtung der MSDE...120 9.1.2 Erzeugen einer Access- Beispieldatenbank...121

Inhaltsverzeichnis I 9.1.3 Erzeugen einer Beispieldatenbank mit SQL Server...122 9.1.4 Einrichten der Datenverbindung zur Access-Datenbank...123 9.2 Datenzugriff auf eine Access-Datenbank...123 9.3 Datenzugriff auf eine SQL-Server- Datenbank...128 9.4 Datensätze hinz ufügen oder löschen...129 9.5 Daten suchen und sortieren...131 9.6 Daten im XML-Format speichern oder laden...134 9.7 Gebundene Steuerelemente...136 9.8 Datenzugriff über SQL...140 9.9 Transaktionen...141 9.10 Parallelitätssteuerung...144 9.11 Erstellen eines Reports...147 9.12 Übung...148 10 Typbibliotheken und Komponenten entwickeln...152 10.1 Einführung...152 10.2 Klassenbibliotheken erstellen...153 10.3 Komponenten bzw. Steuerelemente anpassen...154 10.4 Eigene Komponenten entwickeln...156 10.5 Steuerelemente erstellen...159 10.6 Übung...160 11 Interaktion mit unverwaltetem Programmcode...162 11.1 Einführung...162 11.2 Zugriff auf Routinen des Windows-API...162 11.3 Einbinden von COM- bzw. ActiveX- Komponenten...165 11.4 Unsichere Codeblöcke...167 11.5 Übung...171 12 Netzwerk und Internet...174 12.1 Grundlagen...174 12.1.1 Netzwerke und Protokolle...174 12.1.2 Adressierung...175 12.2 Klassen für die Speicherung von Internet- Adressen...179 12.2.1 Internetprotokoll-Adressen...179 12.2.2 URIs...179 12.3 Socket-Programmierung...180 12.4 Asynchrone Socket-Programmierung...187 12.5 Anwendungsbeispiele: HTTP- bzw. Web- Request...193 12.6 Übung...197 13 XML-Webdienste...200 13.1 Grundlagen und Voraussetzungen...200 13.2 Webdienste nutzen...201 13.3 Eigene Webdienste erstellen...203 13.4 Einen Webdienst weitergeben...206 13.5 Übung...207 14 Office-Automatisierung...208 14.1 Grundlagen...208 14.2 Objektmodell der Office-Programme...209 14.3 Arten der Automatisierung...211 14.4 Makros aufrufen oder nachbilden...216 14.5 Excel per ADO.NET...218 14.6 Übung...220 15 Reguläre Ausdrücke...222 15.1 Suchen und Ersetzen mit regulären Ausdrücken...222 15.2 Mustererkennung mit regulären Ausdrücken...223 15.3 Optionen für reguläre Ausdrücke...224 15.3.1 Zeichenklassen verwenden... 224 15.3.2 Wiederholungen angeben... 226 15.3.3 Verankerung von Mustern... 227 15.3.4 Alternativen angeben... 228 15.3.5 Splitten von Zeichenfolgen... 229 15.3.6 Gruppieren mit Klammern... 229 15.4 Regeln für das Verwenden regulärer Ausdrücke...232 15.5 Ersetzen von Textteilen mit regulären Ausdrücken...232 15.5.1 Substitution verwenden... 232 15.5.2 Rückverweise verwenden... 234 15.6 Übung...234 Stichwortverzeichnis...236

3 Visual C#.NET - Fortgeschr ittene Programmierung 3 Assemblies analysieren, verwalten und schützen,q GLHVHP.DSLWHO HUIDKUHQ 6LH Æ Æ Æ Æ ZLH 6LH GLH ]X HLQHU.ODVVH JHK UHQGH $VVHPEO\ ILQGHQ ZLH 6LH GLH 0RGXOH 7\SHQ XQG 7\SPHPEHU HLQHU $VVHPEO\ HUPLWWHOQ ZLH 6LH HLQH $VVHPEO\ PLW HLQHP GLJLWDOHQ =HUWLILNDW XQG PLW HLQHP VR JHQDQQWHQ VWDUNHQ 1DPHQ YHUVHKHQ ZLH 6LH GHQ,/&RGH HLQHU $VVHPEO\ EHWUDFKWHQ 9RUDXVVHW]XQJHQ 9.HQQWQLVVH YRP $XIEDX YRQ $VVHPEOLHV 9.HQQWQLVVH YRQ.ODVVHQ XQG 2EMHNWHQ 3.1 Assemblies analysieren %HLP (UVWHOOHQ YRQ $QZHQGXQJHQ RGHU.ODVVHQ%LEOLRWKHNHQ PLW 9LVXDO 6WXGLR 1(7 ZHUGHQ $VVHPEOLHV PLW GHQ 'DWHLHUZHLWHUXQJHQ H[H RGHU GOO HUVWHOOW 'LHVH 1(7$VVHPEOLHV HQWKDOWHQ QLFKW QXU GHQ DXV]XI KUHQGHQ 3URJUDPPFRGH LQ )RUP HLQHV RGHU PHKUHUHU 3URJUDPPFRGH0RGXOH VRQGHUQ DXFK 0HWDGDWHQ I U MHGHV 0RGXO XQG HLQ VR JHQDQQWHV 0DQLIHVW,P 0DQLIHVW VLQG YRU DOOHP,QIRUPDWLRQHQ EHU GLH $VVHPEO\ XQG GLH GDULQ HQWKDOWHQHQ 0RGXOH JHVSHLFKHUW,Q GHQ 0HWDGDWHQ HLQHV 0RGXOV EHILQGHQ VLFK,QIRUPDWLRQHQ EHU GLH LP 0RGXO HQWKDOWHQHQ 7\SHQ XQG 7\SPHPEHU 'LH IROJHQGH *UDILN JLEW HLQHQ hehueolfn EHU GLH =XVDPPHQ KlQJH $VVHPEO\ 0DQLIHVW 0RGXOH 0HWDGDWHQ 7\SHQ )HOGHU (LJHQVFKDIWHQ 0HWKRGHQ (UHLJQLVVH 6FKQLWWVWHOOHQ 'DV $XVOHVHQ GHU,QIRUPDWLRQHQ EHU HLQH 1(7$VVHPEO\ XQG LKUHQ,QKDOW ZLUG DOV 5HIOHNWLRQ HQJOLVFK 5HIOHFWLRQ EH]HLFKQHW 'LH I U GLH 5HIOHNWLRQ QRWZHQGLJHQ.ODVVHQ ZHUGHQ YRP 1(7 )UDPHZRUN LP 1DPHQV UDXP System Reflection ]XU 9HUI JXQJ JHVWHOOW 'DPLW GLH LQ GLHVHP.DSLWHO YHUZHQGHWHQ 7RROV GLUHNW YRQ GHU.RPPDQGR]HLOH DXV JHVWDUWHW ZHUGHQ N QQHQ P VVHQ 6LH IDOOV QRFK QLFKW JHVFKHKHQ ]ZHL 9HU]HLFKQLVVH ]XU 9DULDEOHQ Path GHV %HWULHEVV\VWHPV KLQ]X I JHQ giiqhq 6LH GD]X GHQ 0HQ SXQNW 67$57 (,167(//81*(1 6<67(067(8(581* 6<67(0 %HWlWLJHQ 6LH QXQ XQWHU GHP 5HJLVWHU ( 5:(,7(57 GLH 6FKDOWIOlFKH 8 0*(%81*69$5,$%/(1 ) JHQ 6LH DP (QGH GHV (LQWUDJV 3 $7+ HLQ 6HPLNRORQ DQ XQG GDQDFK GLH YROOVWlQGLJH 3IDG DQJDEH I U GDV 9HU]HLFKQLV?)UDPHZRUN6'.?%LQ,KUHV 9LVXDO 6WXGLR 1HW,QVWDOODWLRQV YHU]HLFKQLVVHV ] % &?3URJUDPPH?0LFURVRIW 9LVXDO 6WXGLR 1(7?)UDPHZRUN6'.?%LQ

Assemblies analysieren, verwalten und schützen 3 1DFK HLQHP ZHLWHUHQ 6HPLNRORQ HUZHLWHUQ 6LH GHQ (LQWUDJ XP GHQ 3IDG ]XP 1(7 )UDPHZRUN,QVWDOODWLRQVYHU]HLFKQLV ] % &?:,117?0LFURVRIW1(7?)UDPHZRUN?Y 3.1.1 Assemblies und Module ermitteln =XQlFKVW P VVHQ 6LH ZLVVHQ DXV ZHOFKHU $VVHPEO\ 6LH 'DWHQ DXVOHVHQ ZROOHQ :HQQ 6LH GHQ 1DPHQ XQG GHQ 3IDG HLQHU $VVHPEO\ H[H RGHU GOO'DWHL QLFKW ZLVVHQ N QQHQ 6LH EHVWLPPWH 0HWKRGHQ HLQVHW]HQ GLH GHQ 1DPHQ E]Z GHQ 3IDG ]XU FNJHEHQ 'LH IROJHQGH 7DEHOOH HQWKlOW HLQLJH (LJHQVFKDIWHQ XQG 0HWKRGHQ GHU.ODVVH Assembly PLW GHUHQ +LOIH 6LH $VVHPEOLHV XQG GHUHQ 0RGXOH HUPLWWHOQ N QQHQ 0HWKRGH E]Z (LJHQVFKDIW %HVFKUHLEXQJ %HLVSLHO GetAssembly() 'LHVH 0HWKRGH JLEW GLH $VVHPEO\ ]XU FN LQ GHU GLH DQJHJHEHQH.ODVVH GH NODULHUW LVW GetExecutingAssembly() 0LWKLOIH GLHVHU 0HWKRGH HU PLWWHOQ 6LH GLH $VVHPEO\ GLH GHQ JHUDGH DXVJHI KU WHQ &RGH HQWKlOW GetModules() 'LHVH 0HWKRGH JLEW HLQH $XIOLVWXQJ DOOHU LQ GHU $VVHPEO\ HQWKDOWHQHQ 0R GXOH ]XU FN Assembly a = Assembly.GetAssembly( typeof(klasse)); Assembly a = Assembly.GetExecutingAssembly(); foreach(modul in a.getmodules())... LoadFrom() 'DPLW ZLUG GLH DOV 3DUDPH WHU DQJHJHEHQH $VVHPEO\ JHODGHQ Location 'LH (LJHQVFKDIW JLEW GHQ NRPSOHWWHQ 3IDG HLQHU $VVHPEO\ ]XU FN FullName 0LWKLOIH GLHVHU (LJHQVFKDIW HUPLWWHOQ 6LH GHQ 1DPHQ HLQHU $VVHPEO\ HLQVFKOLH OLFK.XOWXU XQG 9HUVLRQV LQIRUPDWLRQHQ Assembly a = Assembly.LoadFrom(Pfad); string pfad = a.location; Console.WriteLine(a.FullName); Beispiel: Reflektion1.sln,P IROJHQGHQ %HLVSLHO ZHUGHQ GLH EHVFKULHEHQHQ (LJHQVFKDIWHQ XQG 0HWKRGHQ HLQJHVHW]W =XQlFKVW ZLUG GLH $VVHPEO\ HUPLWWHOW GLH GHQ 'DWHQW\S string HQWKlOW 1DPH 3IDG XQG 0RGXOH GHU HQWVSUHFKHQGHQ $VVHPEO\ ZHUGHQ DXI GHP %LOGVFKLUP DQJH]HLJW 'LHVHU 9RUJDQJ ZLUG DQVFKOLH HQG QRFK HLQPDO I U GLH $VVHPEO\ GHV %HLVSLHOSURJUDPPV ZLHGHUKROW Notizen

3 Visual C#.NET - Fortgeschr ittene Programmierung using System; using System.Reflection; class Ablauf static void Main() Assembly a = Assembly.GetAssembly(typeof( string)); Console.WriteLine("Assembly: " + a.fullname); Console.WriteLine("Pfad: " + a.location); foreach(module m in a.getmodules()) Console.WriteLine("Modul: " + m.tostring()); Console.WriteLine(); a = Assembly.GetExecutingAssembly(); Console.WriteLine("Assembly: " + a.fullname); string Filename = a.location; Console.WriteLine("Pfad: " + Filename); a = Assembly.LoadFrom(Filename); foreach(module m in a.getmodules()) Console.WriteLine("Modul: " + m.tostring()); Console.ReadLine(); 'LH $VVHPEO\ GLH GHQ 'DWHQW\S string HQWKlOW ZLUG HUPLWWHOW 'LH,QIRUPDWLRQHQ ]XP 1DPHQ GHU HUPLWWHOWHQ $VVHPEO\ ZHUGHQ DQJH]HLJW $Q GLHVHU 6WHOOH ZLUG GHU YROOVWlQGLJH 3IDG GHU $VVHPEO\ DXVJHJHEHQ $OOH LQ GHU $VVHPEO\ HQWKDOWHQHQ 0RGXOH ZHUGHQ HUPLWWHOW XQG PLWKLOIH HLQHU 6FKOHLIH DQJH]HLJW 9LHOH $VVHPEOLHV HQWKDOWHQ QXU HLQ 0RGXO 'LH $VVHPEO\ GHV JHUDGH DXVJHI KUWHQ &RGHV ZLUG HUPLWWHOW 'LH HQWVSUHFKHQGHQ 1DPHQVLQIRUPDWLR QHQ ZHUGHQ DXI GHP %LOGVFKLUP DXVJHJHEHQ +LHU ZLUG GHU 3IDG GHV %HLVSLHOSURJUDPPV HUPLWWHOW XQG DQJH]HLJW 'LHVHU 6FKULWW LVW HLJHQWOLFK EHUIO VVLJ XQG GLHQW QXU GHU 'HPRQVWUDWLRQ (U ]HLJW ZLH HLQH $VVHPEO\ GXUFK $QJDEH YRQ 3IDG XQG 'DWHLQDPHQ JHODGHQ ZHUGHQ NDQQ $EVFKOLH HQG ZHUGHQ GLH LP %HLVSLHOSURJUDPP HQWKDOWHQHQ 0RGXOH HUPLWWHOW XQG DXI GHP %LOGVFKLUP DXVJHJHEHQ 3.1.2 Typen und Typmember ermitteln 'LH LQ HLQHU $VVHPEO\ HQWKDOWHQHQ 7\SHQ.ODVVHQW\SHQ 6FKQLWWVWHOOHQW\SHQ $UUD\W\SHQ :HUWW\SHQ XQG (QXPHUDWLRQVW\SHQ N QQHQ 6LH PLW GHU 0HWKRGH GetTypes GHU.ODVVH Assembly HUPLWWHOQ 0HWKRGH %HVFKUHLEXQJ %HLVSLHO I U a DOV Assembly XQG Typ DOV Type GetTypes() 'LHVH 0HWKRGH JLEW HLQH $XIOLVWXQJ DOOHU LQ HLQHU $VVHPEO\ HQWKDOWHQHQ 7\SHQ ]XU FN foreach(typ in a.gettypes())...

Assemblies analysieren, verwalten und schützen 3 9RQ GHU.ODVVH Type ZHUGHQ XPIDQJUHLFKH 0HWKRGHQ XQG (LJHQVFKDIWHQ ]XU 9HUI JXQJ JHVWHOOW XP MHGH QXU GHQNEDUH (LQ]HOKHLW EHU GHQ 'DWHQW\S KHUDXV]XILQGHQ (LQLJH GLHVHU (LJHQVFKDIWHQ XQG 0HWKRGHQ VLQG LQ GHU IROJHQGHQ 7DEHOOH ]XVDPPHQJHIDVVW 0HWKRGH RGHU (LJHQVFKDIW GetConstructors() GetEvents() GetFields() GetMethods() GetProperties() GetMembers() GetInterfaces() Assembly Module Namespace BaseType FullName IsClass IsArray IsPublic %HVFKUHLEXQJ $OOH GLHVH 0HWKRGHQ JHEHQ 0HPEHU$XIOLVWXQJHQ HLQHV 7\SV ]XU FN HQWZHGHU HLQH $XIOLVWXQJ DOOHU 0HPEHU GetMembers RGHU HLQH $XIOLVWXQJ GHU.RQV WUXNWRUHQ GetConstructors (UHLJQLVVH GetEvents )HOGHU GetFields 0HWKRGHQ GetMethods (LJHQVFKDIWHQ GetProperties RGHU 6FKQLWWVWHOOHQ GetInterfaces -HGH GHU DXIJHI KUWHQ 0HWKRGHQ H[LVWLHUW DXFK QRFK LQ HLQHU VLQJXOlUHQ )RUP RKQH DEVFKOLH HQGHV V 0LWKLOIH GLHVHU 0HWKRGHQ N QQHQ 6LH EHVWLPPWH 0HPEHU VXFKHQ GHUHQ 1DPHQ 6LH DOV 3DUDPHWHU EHUJHEHQ MethodInfo m = Typ.GetMethod("MeineMethode"); 'LHVH (LJHQVFKDIW HQWKlOW GLH $VVHPEO\ LQ GHU VLFK GHU 7\S EHILQGHW 'LH (LJHQVFKDIW OLHIHUW GDV 0RGXO LQ GHP GHU 7\S GHNODULHUW LVW 'LHVH (LJHQVFKDIW HQWKlOW GHQ 1DPHQVUDXP LQ GHP VLFK GHU 7\S EHILQGHW 'LH (LJHQVFKDIW OLHIHUW GLH %DVLVNODVVH GHV 7\SV 'LHVH (LJHQVFKDIW HQWKlOW GHQ 1DPHQ HLQHV 7\SV HLQVFKOLH OLFK 1DPHQVUDXP 'LH (LJHQVFKDIW OLHIHUW GHQ :HUW true ZHQQ GHU 7\S HLQH.ODVVH LVW 'LHVH (LJHQVFKDIW EHVLW]W GHQ :HUW true ZHQQ GHU 7\S HLQ $UUD\ LVW 'LH (LJHQVFKDIW OLHIHUW GHQ :HUW true ZHQQ GDV HQWVSUHFKHQGH (OHPHQW GHV 7\SV DOV public GHNODULHUW LVW 'HQ GDUJHVWHOOWHQ 0HWKRGHQ ]XP (UPLWWHOQ GHU 0HPEHU HLQHV 7\SV N QQHQ DOV 3DUDPHWHU.RQVWDQWHQ GHU $XI ]lkoxqj BindingFlags EHUJHEHQ ZHUGHQ PLW GHUHQ +LOIH VLFK GDV (UJHEQLV ILOWHUQ OlVVW 'LH )ODJV ODVVHQ VLFK ]X HLQHU %LWPDVNH NRPELQLHUHQ $XI GLHVH :HLVH N QQHQ 6LH VLFK ] % DOOH IIHQWOLFKHQ RGHU DOOH VWDWL VFKHQ 0HWKRGHQ DXVJHEHQ ODVVHQ,Q GHU IROJHQGHQ 7DEHOOH VLQG HLQLJH )ODJV GDUJHVWHOOW %LQGXQJVIODJ DeclaredOnly Instance Public Static NonPublic %HGHXWXQJ 1XU 0HPEHU GLH LQQHUKDOE GHV 7\SV GHNODULHUW VLQG ZHUGHQ ]XU FNJHJHEHQ *HHUEWH 0HPEHU ZHUGHQ QLFKW EHU FNVLFKWLJW,QVWDQ]PHPEHU ZHUGHQ EHU FNVLFKWLJW $OV Public GHNODULHUWH 0HPEHU ZHUGHQ HLQEH]RJHQ 6WDWLVFKH 0HPEHU ZHUGHQ EHU FNVLFKWLJW 1LFKW IIHQWOLFKH 0HPEHU ZHUGHQ HLQEH]RJHQ Notizen

3 Visual C#.NET - Fortgeschr ittene Programmierung,P QlFKVWHQ %HLVSLHO ZHUGHQ QRFK HLQLJH (LJHQVFKDIWHQ XQG 0HWKRGHQ GHU.OD VVHQ MethodInfo XQG ParameterInfo YHUZHQGHW XP ZHLWHUH (LQ]HOKHLWHQ EHU GLH 0HWKRGHQ HLQHV 7\SV XQG GHUHQ 3DUDPHWHU ]X HUPLWWHOQ 0HWKRGH MethodInfo.GetParameters() MethodInfo.Name MethodInfo.ReturnType ParameterInfo.Name ParameterInfo.ParameterType ParameterInfo.Position %HGHXWXQJ 'LHVH 0HWKRGH JLEW HLQH $XIOLVWXQJ GHU 3DUDPHWHU HLQHU 0HWKRGH ]XU FN 'LH (LJHQVFKDIW HQWKlOW GHQ 1DPHQ GHU 0HWKRGH 'LHVH (LJHQVFKDIW OLHIHUW GHQ 5 FNJDEHW\S GHU 0HWKRGH 'LH (LJHQVFKDIW HQWKlOW GHQ 1DPHQ GHV 3DUDPHWHUV 'LHVH (LJHQVFKDIW JLEW GHQ 7\S GHV 3DUDPHWHUV DQ 'LH (LJHQVFKDIW OLHIHUW GLH 3RVLWLRQ GHV 3DUDPHWHUV LQ GHU 3DUDPHWHU OLVWH 'LH =lkoxqj EHJLQQW PLW QXOO Beispiel: Reflektion2.sln 'DV %HLVSLHO HUPLWWHOW DOOH LQ HLQHU $VVHPEO\ HQWKDOWHQHQ 7\SHQ XQG JLEW VLH DXI GHP %LOGVFKLUP DXV =XVlW] OLFK ZHUGHQ DOOH IIHQWOLFKHQ VWDWLVFKHQ 0HWKRGHQ GLHVHU 7\SHQ PLW LKUHQ 3DUDPHWHUQ HUPLWWHOW XQG DQJH]HLJW using System; using System.Reflection; class Ablauf static void Main() Assembly a = Assembly.GetAssembly(typeof(System.Data.DataRow)); foreach(type t in a.gettypes()) if(t.ispublic & t.isclass) Console.WriteLine(t.FullName); foreach(methodinfo m in t.getmethods(bindingflags.static BindingFlags.Public BindingFlags.DeclaredOnly)) Console.WriteLine("\t" + m.name + " " + m.returntype.tostring()); foreach (ParameterInfo p in m.getparameters()) Console.WriteLine("\t\tParameter: " + p.name.tostring()); Console.WriteLine("\t\t Type: " + p.parametertype.tostring()); Console.WriteLine("\t\t Position: " + p.position.tostring()); System.Threading.Thread.Sleep(50); System.Threading.Thread.Sleep(500); Console.ReadLine(); =X %HJLQQ ZLUG GLH $VVHPEO\ HUPLWWHOW LQ GHU GLH.ODVVH SystemDataDataRow GHNODULHUW LVW

Assemblies analysieren, verwalten und schützen 3,P 3URJUDPP JLEW HV GUHL LQHLQDQGHU JHVFKDFKWHOWH foreach6fkohlihq 'LH lx HUVWH 6FKOHLIH GLHQW ]XP (UPLWWHOQ XQG $XVJHEHQ GHU 7\SHQ GLH LQ GHU $VVHPEO\ HQWKDOWHQ VLQG 'DEHL ZHUGHQ QXU GLH DOV public GHNODULHUWHQ.ODVVHQ DXVJHJHEHQ 'LH ]ZHLWH 6FKOHLIH HUPLWWHOW GLH 0HWKRGHQ GHU LQ KHUDXVJHIXQGHQHQ 7\SHQ 'XUFK GLH EHUJHEHQHQ %LQGXQJVIODJV ZLUG GHU 9RUJDQJ VR JHILOWHUW GDVV QXU DOV public GHNODULHUWH VWDWLVFKH 0HWKRGHQ ]XU $Q]HLJH EULJ EOHLEHQ *HHUEWH 0HWKRGHQ ZHUGHQ HEHQIDOOV XQWHUGU FNW %HL GHU $Q]HLJH GHU VWDWLVFKHQ 0HWKRGHQ ZLUG DXFK GHU 5 FNJDEHW\S PLWKLOIH GHU 0HWKRGH ReturnType HUPLWWHOW XQG GDUJHVWHOOW 'LH LQQHUVWH 6FKOHLIH OLHIHUW GLH 3DUDPHWHU GHU DXVJHZlKOWHQ 0HWKRGHQ XQG VWHOOW LKUHQ 1DPHQ LKUHQ 'DWHQW\S XQG LKUH 3RVLWLRQ DXI GHP %LOGVFKLUP GDU 'LH EHLGHQ lx HUHQ 6FKOHLIHQ ZHUGHQ YHU] JHUW XP GLH /HVEDUNHLW DXI GHP %LOGVFKLUP ]X YHUEHVVHUQ 3.1.3 Attribute,Q GHQ 0HWDGDWHQ HLQHU $VVHPEO\ ZHUGHQ DXFK VR JHQDQQWH $WWULEXWH JHVSHLFKHUW GLH 6LH ]XU.HQQ]HLFKQXQJ YRQ 7\SHQ XQG 7\SPHPEHUQ YHUZHQGHQ N QQHQ 0LWKLOIH YRQ $WWULEXWHQ GLH DXFK DOV 'HNODUDWLRQVWDJV EH ]HLFKQHW ZHUGHQ NDQQ GHU HQWVSUHFKHQGH 3URJUDPPFRGH EHVFKULHEHQ XQG GDV 9HUKDOWHQ HLQHV 7\SV RGHU 7\SPHPEHUV ]XU /DXI]HLW ]XU.RPSLOLHU]HLW RGHU ]XU (QWZLFNOXQJV]HLW EHHLQIOXVVW ZHUGHQ,P 1(7 )UDPH ZRUN VWHKHQ YLHOH EHUHLWV YRUGHILQLHUWH $WWULEXWH ]XU 9HUI JXQJ 6LH N QQHQ DEHU DXFK HLJHQH $WWULEXWH HQW ZHUIHQ XQG YHUZHQGHQ ] % XP,QIRUPDWLRQHQ EHU GHQ $XWRU GHV HQWVSUHFKHQGHQ &RGHV EHUHLW]XVWHOOHQ 'HU %HJULII $WWULEXW ZLUG LQ DQGHUHQ 3URJUDPPLHUVSUDFKHQ LQ GHQHQ HV GLHVH )RUP GHU 2EMHNWNHQQ]HLFKQXQJ QLFKW JLEW KlXILJ ]XU %H]HLFKQXQJ GHU 7\SPHPEHU )HOG RGHU (LJHQVFKDIW YHUZHQGHW Syntax [Attribut1(Parameter), Attribut2(Parameter),...] Typ // bzw. Typmember ; $WWULEXWH ZHUGHQ LQ HFNLJH.ODPPHUQ GLUHNW YRU GDV ]X EHVFKUHLEHQGH (OHPHQW JHVHW]W 0HKUHUH $WWUL EXWH VLQG GXUFK.RPPDV ]X WUHQQHQ ; %HL YLHOHQ YRUGHILQLHUWHQ $WWULEXWHQ N QQHQ 3DUDPHWHU DQJHJHEHQ ZHUGHQ ; %HQXW]HUGHILQLHUWH $WWULEXWH VLQG YRQ GHU.ODVVH SystemAttribute DE]XOHLWHQ,Q GHU IROJHQGHQ 7DEHOOH VLQG HLQLJH YRUGHILQLHUWH $WWULEXWH HUNOlUW,QIRUPDWLRQHQ EHU ZHLWHUH $WWULEXWH ILQGHQ 6LH LQ GHU 2QOLQH+LOIH $WWULEXW Obsolete() MTAThread WebMethod() Serializable() DllImport() %HGHXWXQJ 'LHVHV $WWULEXW NHQQ]HLFKQHW GHQ HQWVSUHFKHQGHQ 7\S RGHU 7\SPHPEHU DOV YHUDOWHW 'HU &RPSLOHU JLEW EHL 9HUZHQGXQJ GHV (OHPHQWV VFKRQ EHLP.RPSLOLHUHQ HLQH :DUQXQJ DXV 'HU HQWVSUHFKHQGH &RGH ZLUG I U GLH 9HUZHQGXQJ LQ 0XOWL7KUHDG$QZHQGXQJHQ JHNHQQ]HLFKQHW *HJHQWHLO STAThread I U 6LQJOH7KUHDG$QZHQGXQJHQ 'LH $WWUL EXWH MTAThread XQG STAThread VLQG QXU EHL $QZHQGXQJHQ ZLUNVDP GLH PLW QLFKW YHUZDOWHWHP &RGH EHU GHQ VR JHQDQQWHQ &20,QWHURS ]XVDPPHQDUEHLWHQ (LQH 0HWKRGH ZLUG I U GLH 9HUZHQGXQJ LQ ;0/:HEGLHQVWHQ JHNHQQ]HLFKQHW 6LH NDQQ RKQH GLHVHV $WWULEXW QLFKW LQ HLQHP :HEGLHQVW YHUZHQGHW ZHUGHQ 'LHVHV $WWULEXW NHQQ]HLFKQHW HLQHQ 7\S DOV VHULDOLVLHUEDU 2KQH $QJDEH GLHVHV $WWUL EXWHV NRPPW HV EHL GHP 9HUVXFK GHU 6HULDOLVLHUXQJ ]X HLQHU $XVQDKPH 'LH JHNHQQ]HLFKQHWH 0HWKRGH ZLUG DXV HLQHU QLFKW YHUZDOWHWHQ %LEOLRWKHN LPSRUWLHUW hehu YHUVFKLHGHQH ]XU 9HUI JXQJ VWHKHQGH 3DUDPHWHU N QQHQ (LQ]HOKHLWHQ GHV,P SRUWV IHVWJHOHJW ZHUGHQ Beispiel: Attribute1.sln,P %HLVSLHO ZLUG VRZRKO GLH 9HUZHQGXQJ YRUGHILQLHUWHU DOV DXFK GLH 9HUZHQGXQJ EHQXW]HUGHILQLHUWHU $WWULEXWH GHPRQVWULHUW 'DV EHQXW]HUGHILQLHUWH $WWULEXW Autor ZLUG DX HUGHP PLWWHOV 5HIOHNWLRQ HUPLWWHOW XQG DQJH]HLJW

3 Visual C#.NET - Fortgeschr ittene Programmierung using System; using System.Reflection; namespace Attribute1 [AttributeUsage(AttributeTargets.Method)] public class Autor : Attribute private string fautor; public Autor(string name) fautor = name; [Obsolete("Diese Klasse ist veraltet!")] public class Test [Autor("Frank Müller")] public int Summe(int a, int b) return a + b; class Ablauf static void Main() Test te; Assembly a = Assembly.GetExecutingAssembly(); Type t = a.gettype("attribute1.test"); foreach (MemberInfo m in t.getmembers()) foreach(attribute at in m.getcustomattributes(false)) Console.WriteLine(at); Console.ReadLine(); +LHU ZLUG GDV EHQXW]HUGHILQLHUWH $WWULEXW Autor GHNODULHUW %HL GHU 'HNODUDWLRQ HLQHV $WWULEXWV NDQQ GDV $WWULEXW AttributeUsage YHUZHQGHW ZHUGHQ 0LWKLOIH HLQHU.RQVWDQWHQ DXV GHU $XI]lKOXQJ AttributeTargets OlVVW VLFK IHVWOHJHQ I U ZHOFKH 7\SHQ RGHU 7\SPHPEHU GDV $WWULEXW JHOWHQ VROO,Q GLHVHP )DOO JLOW HV I U 0HWKRGHQ hehu GHQ.RQVWUXNWRU ZLUG YRP $WWULEXW HLQ $XWRUHQQDPH HQW JHJHQJHQRPPHQ =X 'HPRQVWUDWLRQV]ZHFNHQ HUKlOW GLH.ODVVH Test GDV $WWULEXW Obsolete 'LH.ODVVH Test EHVLW]W HLQH 0HWKRGH GLH PLW GHP EHQXW]HUGHILQLHUWHQ $WWULEXW Autor JHNHQQ]HLFKQHW LVW $Q GLHVHU 6WHOOH UHDJLHUW GHU &RPSLOHU DXI GDV $WWULEXW Obsolete XQG ZDUQW YRU YHUDOWHWHP &RGH 0LWKLOIH GHU 0HWKRGH GetCustomAttributes ZHUGHQ DOOH EHQXW]HUGHILQLHUWHQ $WWULEXWH GHU 0HWKRGHQ GHU.ODVVH Test HUPLWWHOW LQ GLHVHP )DOO QXU HLQV XQG DXI GHP %LOGVFKLUP DXVJHJHEHQ 'HU 3DUDPHWHU false JLEW DQ GDVV QLFKW QDFK JHHUEWHQ $WWULEXWHQ JHVXFKW ZHUGHQ VROO

Assemblies analysieren, verwalten und schützen 3 3.1.4 IL-Code betrachten.rpslolhuwh 1(7$VVHPEOLHV HQWKDOWHQ,/,QWHUPHGLDWH /DQJXDJH&RGH =XP /LHIHUXPIDQJ GHV 9LVXDO 6WXGLR1(7 E]Z GHV 1(7 )UDPHZRUN 6'. JHK UW GDV 7RRO,/ '$60 P LW GHVVHQ +LOIH 6LH GHQ,/&RGH VRZLH GLH 0HWDGDWHQ YRQ $VVHPEOLHV VLFKWEDU PDFKHQ N QQHQ 'LHVHU 9RUJDQJ ZLUG DXFK DOV 'LVDVVHPEOLHUHQ EH ]HLFKQHW XQG NDQQ ] % VLQQYROO VHLQ XP VLFK GLH 5HDOLVLHUXQJ HLQHU 4XHOOFRGHSDVVDJH LP,/&RGH DQ]XVHKHQ *HKHQ 6LH ]XP 'LVDVVHPEOLHUHQ HLQHU $VVHPEO\ IROJHQGHUPD HQ YRU %HWlWLJHQ 6LH GLH 7DVWHQNRPELQDWLRQ á R XQG JHEHQ 6LH LQ GLH %HIHKOV]HLOH LOGDVP HLQ %HWlWLJHQ 6LH DQVFKOLH HQG GLH 7DVWH RETURN 'DUDXIKLQ ZLUG GDV 7RRO JHVWDUWHW :lkohq 6LH LP 0HQ YRQ,/ '$60 GHQ 0HQ SXQNW '$7(, g))1(1,p IROJHQ GHQ 'LDORJ ZlKOHQ 6LH QXQ ] % GLH LP %HLVSLHO 5HIOHNWLRQVOQ HU]HXJWH $VVHPEO\ 5HIOHNWLRQH[H LP ELQ9HU]HLFKQLV GHV 3URMHNWV DXV %HVWlWLJHQ 6LH,KUH $XVZDKO GXUFK %HWlWLJHQ GHU 6FKDOWIOlFKH g ))1(1 $OV )ROJH ZLUG,KQHQ HLQH 6WUXNWXUDQVLFKW GHU $VVHPEO\ JH]HLJW 6LH N QQHQ VLFK QXQ GLH 0HWDGDWHQ HLQHU.ODVVH GDV 0DQL IHVW GHU $VVHPEO\ RGHU GLH GLVDVVHPE OLHUWH $QVLFKW GHU.ODVVHQPHPEHU LQ VHSDUDWHQ )HQVWHUQ DQ]HLJHQ ODVVHQ LQGHP 6LH GRSSHOW DXI GDV HQWVSUHFKHQGH (OHPHQW NOLFNHQ 8P GLH 6WUXNWXUDQVLFKW RGHU GHQ GLVDVVHP EOLHUWHQ &RGH ]X VSHLFKHUQ YHUZHQGHQ 6LH GLH 0HQ SXQNWH '$7(, 6758.785 $16,&+7 VLFKHUQ E]Z '$7(, 6,&+(51 %HLP 6SHLFKHUQ GHV &RGHV ZLUG HLQH 'DWHL PLW GHU (UZHLWHUXQJ LO HU]HXJW $XV HLQHU VROFKHQ LO'DWHL N QQHQ 6LH PLW GHP.RPPDQGR]HLOHQWRRO LODVPH[H HLQH $VVHPEO\ H[H RGHU GOO JHQHULHUHQ :HLWHUH (LQ]HOKHLWHQ GD]X ILQGHQ 6LH LQ GHU 2QOLQH+LOIH XQWHU GHP 6WLFKZRUW,ODVPH[H 'DV 'LVDVVHPEOHUWRRO LOGDVPH[H OlVVW VLFK DXFK EHU GLH.RPPDQGR]HLOH VWHXHUQ,QIRUPDWLRQHQ GD]X ILQGHQ 6LH HEHQIDOOV LQ GHU 2QOLQH+LOIH XQWHU GHP 6WLFKZRUW,OGDVPH[H 3.1.5 Assemblies und Typen dynamisch erstellen,p 1DPHQVUDXP System Reflection JLEW HV GHQ 1DPHQVUDXP Emit GHU XQWHU DQGHUHP GLH.ODVVHQ AssemblyBuilder ModuleBuilder TypeBuilder MethodBuilder XQG ILGenerator HQWKlOW PLW GHUHQ +LOIH $VVHPEOLHV G\QDPLVFK ZlKUHQG GHU /DXI]HLW HLQHV 3URJUDPPV HUVWHOOW ZHUGHQ N QQHQ Beispiel: Dynamisch.sln,P IROJHQGHQ %HLVSLHO ZLUG HLQH $VVHPEO\ HU]HXJW GLH HLQ 0RGXO HLQH.ODVVH XQG LQ GLHVHU.ODVVH HLQH 0HWKRGH HQWKlOW 'LH 0HWKRGH JLEW ]ZHL =HLOHQ 7H[W DXI GHP %LOGVFKLUP DXV 1DFKGHP GLH $VVHPEO\ LP $UEHLWVVSHLFKHU HU]HXJW LVW ZLUG VLH DOV DXVI KUEDUH 'DWHL LP $UEHLWVYHU]HLFKQLV GHV 3URMHNWV JHVSHLFKHUW XQG DEVFKOLH HQG JHVWDUWHW

3 Visual C#.NET - Fortgeschr ittene Programmierung using System; using System.Threading; using System.Reflection; using System.Reflection.Emit; public class Ablauf static void Main() AppDomain asdomain = Thread.GetDomain(); AssemblyName asname = new AssemblyName(); asname.name = "HalloWelt"; asname.version = new Version(1, 0, 0, 0); AssemblyBuilder asbuilder = asdomain.definedynamicassembly(asname, AssemblyBuilderAccess.Save); ModuleBuilder modbuilder = asbuilder.definedynamicmodule("hallowelt", "HalloWelt.exe"); TypeBuilder tbuilder = modbuilder.definetype("hallowelt", TypeAttributes.Public); MethodBuilder mbuilder = tbuilder.definemethod("main", (MethodAttributes.Public MethodAttributes.Static), null, null); ILGenerator igenerator = mbuilder.getilgenerator(); for( int i = 1; i <= 10000; i++) igenerator.emitwriteline(i.tostring() + " Hallo Welt!"); igenerator.emit(opcodes.ret); tbuilder.createtype(); MethodInfo m = tbuilder.getmethod("main"); asbuilder.setentrypoint(m); asbuilder.save("hallowelt.exe"); Console.ReadLine(); System.Diagnostics.Process.Start("HalloWelt.exe"); Console.ReadLine(); 'LH $QZHQGXQJVGRPlQH GHV DNWXHOOHQ 7KUHDGV ZLUG HUPLWWHOW XQG GHU 9DULDEOHQ asdomain ]XJHZLH VHQ (LQH,QVWDQ] YRP 7\S AssemblyName ZLUG HU]HXJW 6LH ZLUG EHQ WLJW XP GHQ 1DPHQ XQG GLH 9HUVLRQVQXPPHU GHU $VVHPEO\ IHVW]XOHJHQ 'LH $VVHPEO\ ZLUG LQQHUKDOE GHU $QZHQGXQJVGRPlQH PLW GHP DQJHJHEHQHQ 1DPHQ GHNODULHUW 'XUFK GHQ ]ZHLWHQ 3DUDPHWHU ZLUG IHVWJHOHJW GDVV GLH $VVHPEO\ QLFKW QXU LP 6SHLFKHU HU]HXJW VRQGHUQ GDXHUKDIW JHVSHLFKHUW ZHUGHQ VROO $Q GLHVHU 6WHOOH ZLUG LQQHUKDOE GHU $VVHPEO\ HLQ 0RGXO DQJHOHJW 'D]X ZHUGHQ GHU 1DPH GHV 0RGXOV XQG GHU 'DWHLQDPH GHU $VVHPEO\ DOV 3DUDPHWHU EHUJHEHQ,QQHUKDOE GHV 0RGXOV ZLUG HLQH IIHQWOLFKH.ODVVH PLW GHP 1DPHQ HalloWelt GHNODULHUW 'LH.ODVVH HalloWelt HUKlOW HLQH DOV Public XQG Static GHNODULHUWH 0HWKRGH Main 'LH 0HWKRGH ZLUG HLQHU 9DULDEOHQ YRP 7\S MethodBuilder ]XJHZLHVHQ ) U GLH 0HWKRGH Main ZLUG HLQ,QWHUPHGLDWH /DQJXDJH *HQHUDWRU HU]HXJW PLW GHVVHQ 0HWKRGHQ GHU,/ &RGH I U GLH 0HWKRGH Main JHQHULHUW ZHUGHQ NDQQ 'LH G\QDPLVFK HUVWHOOWH 0HWKRGH Main HUKlOW HLQH $QZHLVXQJ GXUFK GLH HLQH 0HOGXQJ ZLHGHUKROW DXI GHP %LOGVFKLUP DXVJHJHEHQ ZLUG 'LH G\QDPLVFK HU]HXJWH 0HWKRGH Main ZLUG DQ GLHVHU 6WHOOH DEJHVFKORVVHQ 6LH JLEW NHLQHQ :HUW ]XU FN

Assemblies analysieren, verwalten und schützen 3 'D NHLQH ZHLWHUHQ 0HPEHU GHNODULHUW ZHUGHQ VROOHQ ZLUG GLH (U]HXJXQJ GHU.ODVVH HalloWelt GXUFK GLH 0HWKRGH CreateType DEJHVFKORVVHQ 'LH 0HWKRGH Main ZLUG DOV 6WDUWSXQNW GHU $QZHQGXQJ IHVWJHOHJW $Q GLHVHU 6WHOOH ZLUG GLH HU]HXJWH $VVHPEO\ LP $UEHLWVYHU]HLFKQLV GHV 3URMHNWV JHVSHLFKHUW $EVFKOLH HQG ZLUG GLH $QZHQGXQJ QDFK GHP %HWlWLJHQ GHU (LQJDEHWDVWH PLWKLOIH GHU 0HWKRGH System.Diagnostics.Process.Start JHVWDUWHW,Q GHQ 1DPHQVUlXPHQ System.CodeDom XQG System.CodeDom.Compiler EHILQGHQ VLFK ZHLWHUH.ODVVHQ PLW GHQHQ 6LH $VVHPEOLHV G\QDPLVFK HU]HXJHQ XQG DXVI KUHQ N QQHQ 'LH $VVHPEOLHV N QQHQ GDEHL ZDKO ZHLVH LP 6SHLFKHU RGHU DXI HLQHP 'DWHQWUlJHU HU]HXJW ZHUGHQ 'HQ DXV]XI KUHQGHQ &RGH N QQHQ 6LH DOV & RGHU DXFK DOV 9LVXDO %DVLF 1(7$QZHLVXQJHQ HQWZHGHU LQ )RUP HLQHU =HLFKHQNHWWH RGHU LQ 'DWHLIRUP EHU JHEHQ 0LW GLHVHU 7HFKQLN N QQHQ 6LH UHODWLY HLQIDFK HLQH 6WHXHUXQJ,KUHU $QZHQGXQJ GXUFK 6FULSWV RGHU 0DNURV UHDOLVLHUHQ Beispiel: CodeGenerator.sln 'DV 3URJUDPP HU]HXJW LP 6SHLFKHU HLQH $VVHPEO\ 'HU &RGH I U GLHVH $VVHPEO\ EHILQGHW VLFK LQ GHU 7H[WGDWHL &RGHFV XQG LVW QHEHQVWHKHQG DEJHELO GHW 'LHVHU &RGH ZLUG ]XU /DXI]HLW GHV 3URJUDPPV NRPSLOLHUW $QVFKOLH HQG ZLUG HLQH,QVWDQ] GHV LQ GHU HU]HXJWHQ $VVHPEO\ YRUKDQGHQHQ 7\SV Test JHELOGHW XQG GHUHQ 0HWKRGH Testmethode DXIJHUX IHQ 'LHVH 0HWKRGH JLEW HLQH EHUJHEHQH =HLFKHQ NHWWH DXI GHP %LOGVFKLUP DXV using System; using System.CodeDom; using System.CodeDom.Compiler; using System.Reflection; using Microsoft.CSharp; namespace CodeGenerator class Ablauf public static Assembly CreateAssemblyFromFile(string Filename) CodeDomProvider cdp = new CSharpCodeProvider(); ICodeCompiler comp = cdp.createcompiler(); CompilerParameters cp = new CompilerParameters(); cp.generateinmemory = true; CompilerResults cr = comp.compileassemblyfromfile(cp, Filename); if(cr.errors.count!= 0) else return null; return cr.compiledassembly; static void Main()

3 Visual C#.NET - Fortgeschr ittene Programmierung Assembly asm = CreateAssemblyFromFile(@"..\..\Code.cs"); object o = asm.createinstance("codegenerator.test"); Type t = o.gettype(); MethodInfo mi = t.getmethod("testmethode"); object[] par = new object[1]; par[0] = "Dies ist ein Test!"; mi.invoke(o, par); Console.ReadLine(); (LQH,QVWDQ] YRP 7\S CSharpCodeProvider ZLUG HU]HXJW XQG HLQHU 2EMHNWYDULDEOHQ GHU %DVLVNODVVH CodeDomProvider ]XJHZLHVHQ $Q GLHVHU 6WHOOH ZLUG GDV &RPSLOHUREMHNW HUVWHOOW XQG HLQHU 6FKQLWWVWHOOHQYDULDEOHQ YRP 7\S ICodeCompiler ]XJHZLHVHQ hehu HLQH,QVWDQ] YRP 7\S CompilerParameters N QQHQ 3DUDPHWHU I U GDV.RPSLOLHUHQ IHVWJHOHJW ZHUGHQ 'LHVHU 3DUDPHWHU EHVWLPPW GDVV GLH $VVHPEO\ LP $UEHLWVVSHLFKHU HU]HXJW ZLUG,Q GLHVHU =HLOH HUIROJW GLH.RPSLOLHUXQJ 'LH 3DUDPHWHU XQG GHU 'DWHLQDPH ZHUGHQ EHUJHEHQ :HQQ HV ]X NHLQHP )HKOHU NRPPW ZLUG GLH NRPSLOLHUWH $VVHPEO\ ]XU FNJHJHEHQ,Q GHU +DXSWPHWKRGH ZLUG ]XQlFKVW GLH $VVHPEO\ DXV GHU LP3URMHNWYHU]HLFKQLV EHILQGOLFKHQ 'DWHL HU ]HXJW $QVFKOLH HQG ZLUG HLQH,QVWDQ] GHU LQ GHU HU]HXJWHQ $VVHPEO\ YRUKDQGHQHQ.ODVVH Test HUVWHOOW 0LWKLOIH GHV 7\SV XQG GHVVHQ 0HWKRGH GetMethod ZLUG GLH (LQVSUXQJDGUHVVH GHU 0HWKRGH Testmethode HUPLWWHOW 'DV ]X EHUJHEHQGH 3DUDPHWHUDUUD\ YRP 7\S object ZLUG HUVWHOOW (V HQWKlOW LQ GLHVHP )DOO QXU HLQHQ 3DUDPHWHU $Q GLHVHU 6WHOOH HUIROJW GHU $XIUXI GHU 0HWKRGH Testmethode :HQQ 6LH PLW GHP JOHLFKHQ &RGH HLQ 6FULSW PLW 9LVXDO %DVLF 1(7&RGH YHUDUEHLWHQ ZROOHQ P VVHQ 6LH VWDWW GHU,QVWDQ] YRP 7\S CSharpCodeProvider HLQH,QVWDQ] GHU.ODVVH VBCodeProvider HU]HXJHQ 3.2 Assemblies verwalten 1RUPDOHUZHLVH EHILQGHQ VLFK $VVHPEOLHV DOV VR JHQDQQWH SULYDWH $VVHPEOLHV LP ORNDOHQ 9HU]HLFKQLV GHU MHZHLOLJHQ $QZHQGXQJ :HQQ 6LH MHGRFK HLQH $VVHPEO\ IUHLJHEHQ XQG I U PHKUHUH $QZHQGXQJHQ JHPHLQVDP QXW]HQ P FKWHQ VKDUHG $VVHPEOLHV N QQHQ 6LH GLH $VVHPEO\ LP JOREDOHQ $VVHPEO\FDFKH *$& HLQHV 5HFKQHUV LQVWDOOLHUHQ 'LHVHU &DFKH ZLUG EHL GHU,QVWDOODWLRQ GHV 1(7 )UDPHZRUN LP :LQGRZV9HU]HLFKQLV HLQJHULFKWHW ) U GLH,QVWDOODWLRQ LP *$& PXVV HLQH $VVHPEO\ HLQHQ VR JHQDQQWHQ VWDUNHQ 1DPHQ XQG HLQH 9HUVLRQVQXPPHU EHVLW]HQ $X HUGHP LVW HVHUIRUGHUOLFK GDVV $VVHPEO\QDPH XQG 'DWHLQDPH EHUHLQVWLPPHQ,P JOREDOHQ $VVHPEO\FDFKH G UIHQ VLFK DXFK PHKUHUH $VVHPEOLHV PLW LGHQWLVFKHP 1DPHQ EHILQGHQ ZHQQ VLFK GLH 9HUVLRQVLQIRUPDWLRQHQ XQWHUVFKHLGHQ 'DV $UEHLWHQ PLW GHP *$& HUIROJW DP HLQIDFKVWHQ PLW GHP :LQGRZV([SORUHU 6LH N QQHQ DEHU DXFK GDV LP 1(7 )UDPHZRUN HQWKDOWHQH 7RRO JDFXWLOH[H YHUZHQGHQ Inhalt des GAC anzeigen giiqhq 6LH GHQ :LQGRZV([SORUHU PLW GHU 7DVWHQNRPELQDWLRQ á E XQG QDYLJLHUHQ 6LH LQ,KU :LQGRZV9HU]HLFKQLV giiqhq 6LH GDV 8QWHUYHU]HLFKQLV?DVVHPEO\

Assemblies analysieren, verwalten und schützen 3 RGHU 6LH VHKHQ QXQ DOOH LP &DFKH EHILQGOLFKHQ $VVHPEOLHV 8P VLFK ZHLWHUH,QIRUPDWLRQHQ EHU HLQH $VVHPEO\ DQ]XVHKHQ ZlKOHQ 6LH DXV GHP.RQWH[WPHQ GHU EHWUHIIHQGHQ 'DWHL GHQ 0HQ SXQNW (,*(16&+$)7(1 giiqhq 6LH GLH (LQJDEHDXIIRUGH UXQJ XQG JHEHQ 6LH gacutil /l HLQ RGHU %HWlWLJHQ 6LH GLH 7DVWHQNRPELQD WLRQ á R XQG JHEHQ 6LH LQ GDV (LQJDEHIHOG mscorcfg.msc HLQ XP GDV 1(7 )UDPHZRUN.RQILJX UDWLRQVWRRO ]X VWDUWHQ.OLFNHQ 6LH DXI GDV 6\PERO $ 66(0%/<&$&+( Assembly im GAC installieren RGHU 9HUVFKLHEHQ 6LH GLH HQWVSUHFKHQGH $VVHPEO\ EHL JHGU FNWHU OLQNHU 0DXVWDVWH LQ GDV )HQVWHU GHV ([SORUHUV LQ GHP GHU *$& DQJH]HLJW ZLUG giiqhq 6LH GLH (LQJDEHDXIIRUGHUXQJ XQG JHEHQ 6LH gacutil /i Assemblyname HLQ :HQQ 6LH I U GLH $QZHQGXQJVZHLWHUJDEH HLQ 6HWXSSURMHNW I U GHQ :LQGRZV,QVWDOOHU YHUZHQGHQ N QQHQ $VVHPEOLHV EHL %HGDUI GLUHNW EHL GHU,QVWDOODWLRQ,KUHU $QZHQGXQJ LQ GHQ *$& LQVWDOOLHUW ZHUGHQ,QVWDOOLHUHQ 6LH MHGRFK QXU GDQQ $VVHPEOLHV LP *$& ZHQQ HV QRWZHQGLJ LVW ZHLO GLH $VVHPEO\ ] % YRQ PHKUHUHQ DQGH UHQ $VVHPEOLHV JHQXW]W ZHUGHQ VROO Assembly im GAC deinstallieren RGHU :lkohq 6LH LP ([SORUHU DXV GHP.RQWH[WPHQ GHU HQWVSUHFKHQGHQ 'DWHL GHQ 0HQ SXQNW /g6&+(1 giiqhq 6LH GLH (LQJDEHDXIIRUGHUXQJ XQG JHEHQ 6LH gacutil /u Assemblyname HLQ 3.3 Assemblies schützen (V JLEW YHUVFKLHGHQH 0 JOLFKNHLWHQ +HUNXQIW XQG,QWHJULWlW YRQ $VVHPEOLHV DE]XVLFKHUQ 'DPLW LVW HV ] % P JOLFK GDVV $VVHPEOLHV YHUVFKLHGHQHU $XWRUHQ GLH ]XIlOOLJ GHQ JOHLFKHQ 1DPHQ EHVLW]HQ LP *$& LQVWDOOLHUW ZHUGHQ N QQHQ $X HUGHP N QQHQ $VVHPEOLHV GDYRU JHVFK W]W ZHUGHQ GDVV VLH YRQ 8QEHIXJWHQ ZHLWHUHQW ZLFNHOW RGHU DXVVSLRQLHUW ZHUGHQ 3.3.1 Signieren mit digitalem Zertifikat 6LH N QQHQ GLH +HUNXQIW,KUHU $QZHQGXQJHQ GXUFK 6LJQLHUHQ PLW HLQHP GLJLWDOHQ =HUWLILNDW EHJODXELJHQ 'DGXUFK LVW HVGHP $QZHQGHU,KUHU 6RIWZDUH P JOLFK ]X EHUSU IHQ RE HLQH EHVWLPPWH $VVHPEO\ ZLUNOLFK YRQ,KQHQ VWDPPW (LQ GLJLWDOHV =HUWLILNDW P VVHQ 6LH VLFK YRQ HLQHU HQWVSUHFKHQGHQ =HUWLIL]LHUXQJVVWHOOH EHVRUJHQ ] % XQWHU KWWSGHJOREDOVLJQQHW =X 7HVW]ZHFNHQ N QQHQ 6LH GLH 7RROV 0DNHFHUWH[H XQG &HUWVSFH[H YHUZHQGHQ PLW GHUHQ +LOIH 6LH HLQ XQEHJODXELJWHV 6RIWZDUH 3XEOLVKHU &HUWLILNDWH 63& HU]HX JHQ *HKHQ 6LH GD]X IROJHQGHUPD HQ YRU %HWlWLJHQ 6LH GLH 7DVWHQNRPELQDWLRQ á R XQG JHEHQ 6LH LQ GDV (LQJDEHIHOG makecert testcert.cer HLQ %HVWlWLJHQ 6LH PLW RETURN

3 Visual C#.NET - Fortgeschr ittene Programmierung,P 6WDPPYHU]HLFKQLV YRQ /DXIZHUN &? EHILQGHW VLFK GDUDXIKLQ GLH ;=HUWLILNDWVGDWHL WHVWFHUWFHU %HWlWLJHQ 6LH GLH 7DVWHQNRPELQDWLRQ á R HUQHXW XQG JHEHQ 6LH cert2spc testcert.cer testcert.spc HLQ %HVWlWLJHQ 6LH PLW RETURN,P 6WDPPYHU]HLFKQLV GHV /DXIZHUNV &? EHILQGHW VLFK QXQ GLH 63&=HUWLILNDWVGDWHL WHVWFHUWVSF GLH SUREHZHLVH ]XP 6LJQLHUHQ YHUZHQGHW ZHUGHQ NDQQ 8P HLQH $VVHPEO\ PLW GHP =HUWLILNDW ]X VLJQLHUHQ YHUIDKUHQ 6LH DQVFKOLH HQG ZLH IROJW %HWlWLJHQ 6LH GLH 7DVWHQNRPELQDWLRQ á R XQG JHEHQ 6LH GHQ %HIHKO signcode HLQ %HVWlWLJHQ 6LH PLW RETURN 'DUDXIKLQ VWDUWHW GHU $VVLVWHQW GHV 3URJUDPPV 6LJQFRGH GHU,KQHQ EHLP 6LJQLHUHQ EHKLOIOLFK LVW %HWlWLJHQ 6LH GLH 6FKDOWIOlFKH : (,7(5 %HWlWLJHQ 6LH QXQ GLH 6FKDOWIOlFKH ' 85&+68&+(1 XQG ZlKOHQ 6LH PLWKLOIHGHV 'LDORJIHQVWHUV GLH $VVHPEO\ DXV GLH 6LHVLJQLHUHQ ZROOHQ %HVWlWLJHQ 6LH,KUH :DKO PLW RETURN %HWlWLJHQ 6LH GLH 6FKDOWIOlFKH : (,7(5 8QWHU GHQ IROJHQGHQ 6LJQDWXURSWLRQHQ ZlKOHQ 6LH % (187=(5'(),1,(57 XQG EHWlWLJHQ GLH 6FKDOWIOlFKH : (,7(5 %HWlWLJHQ 6LH GLH 6FKDOWIOlFKH $86 ' $7(, :b+/(1 hehu GDV IROJHQGH 'LDORJIHQVWHU ZlKOHQ 6LH GLH EHUHLWV HU]HXJWH =HUWLILNDWVGDWHL WHVWFHUWVSF DXV %HVWlWLJHQ 6LH,KUH :DKO PLW RETURN %HWlWLJHQ 6LH GLH 6FKDOWIOlFKH : (,7(5,P IROJHQGHQ 'LDORJ ZlKOHQ 6LH GLH 2SWLRQ 3 5,9 6 &+/h66(/ (,1(6. 5<372*5$3+,(',(167 $1%,(7(56 IDOOV 6LH QRFK NHLQHQ HLJHQHQ SULYDWHQ 56$6FKO VVHO EHVLW]HQ :lkohq 6LH DQ VFKOLH HQG HLQHQ 6FKO VVHOFRQWDLQHU DXV GHU HLQH 6LJQDWXU HQWKlOW %HVWlWLJHQ 6LH LKUH :DKO PLW RETURN (V IROJW HLQ 'LDORJ LQ GHP 6LH HLQHQ +DVKDOJRULWKPXV ] % VKD DXVZlKOHQ N QQHQ %HVWlWLJHQ 6LH PLW RETURN 'LH QlFKVWHQ GUHL 'LDORJH EHUVSULQJHQ 6LH PLWKLOIH GHU 6FKDOWIOlFKH : (,7(5 %HWlWLJHQ 6LH DEVFKOLH HQG GLH 6FKDOWIOlFKH ) (57,*67(//(1,P.RQWH[WPHQ GHU VLJQLHUWHQ 'DWHL LP :LQGRZV ([SORUHU JLEW HV QXQ GDV 5HJLVWHU ',*,7$/(Ã6,*1$785(1 'RUW N QQHQ 6LH (LQ]HOKHLWHQ EHU GLJLWDOH 6LJQDWXUHQ HUIDKUHQ PLW GHQHQ GLH EHWUHIIHQGH $VVHPEO\ VLJQLHUW LVW $XI GLHVH :HLVH OlVVW VLFK GLH +HUNXQIW HLQHU $QZHQGXQJ RGHU HLQHU.ODVVHQELEOLRWKHN NRQWUROOLHUHQ 3.3.2 Vergeben von starken Namen 8P GLH (LQ]LJDUWLJNHLW XQG GLH,QWHJULWlW HLQHU $VVHPEO\ VLFKHU]XVWHOOHQ NDQQ GHU $VVHPEO\ HLQ VR JHQDQQWHU VWDUNHU 1DPH HQJO VWURQJ QDPH JHJHEHQ ZHUGHQ 'LHVHU 1DPH VHW]W VLFK ]XVDPPHQ DXV ; GHP HLQIDFKHQ 1DPHQ GHU $VVHPEO\ ; GHU 9HUVLRQV XQG.XOWXULQIRUPDWLRQ ; HLQHP IIHQWOLFKHQ 6FKO VVHO ; HLQHU DXV GHQ VSH]LILVFKHQ +DVKFRGHV GHU %HVWDQGWHLOH GHU $VVHPEO\ JHZRQQHQHQ GLJLWDOHQ 6LJQDWXU

Assemblies analysieren, verwalten und schützen 3 (V NDQQ GHVKDOE GDYRQ DXVJHJDQJHQ ZHUGHQ GDVV VWDUNH 1DPHQ ZHOWZHLW HLQ]LJDUWLJ VLQG 8PJHNHKUW EHGHXWHW GLHV GDVV $VVHPEOLHV PLW GHPVHOEHQ VWDUNHQ 1DPHQ PLW VHKU KRKHU :DKU VFKHLQOLFKNHLW LGHQWLVFK VLQG =XP 9HUJHEHQ HLQHV VWDUNHQ 1DPHQV PXVV ]XQlFKVW HLQ 6FKO VVHOSDDU JHQHULHUW ZHUGHQ GDV DXV HLQHP IIHQWOLFKHQ XQG HLQHP SULYDWHQ 6FKO VVHO EHVWHKW 'LHV HV 6FKO VVHOSDDU PXVV I U MHGHQ (QWZLFNOHU RGHU I U MHGH HQWVSUHFKHQGH )LUPD QXU HLQPDO HU]HXJW ZHUGHQ 'HU SULYDWH 6FKO VVHO LVW GDQQ YRP $XWRU GHU 6RIWZDUH E]Z YRQ GHVVHQ )LUPD VLFKHU DXI]XEHZDKUHQ 1XU PLW GLHVHP 6FKO VVHO NDQQ HLQH $VVHPEO\ PLW HLQHP LGHQWLVFKHQ VWDUNHQ 1DPHQ HU]HXJW ZHU GHQ 'LH /DXI]HLWXPJHEXQJ &/5 PHUNW DX HU GHP EHL GHU,QWHJULWlWVSU IXQJ ZHQQ GHU,/ &RGH HLQHU PLW HLQHP VWDUNHQ 1DPHQ YHUVHKH QHQ $VVHPEO\ YHUlQGHUW ZXUGH XQG YHUZHLJHUW GLH $XVI KUXQJ GHV 3URJUDPPV 6LH N QQHQ GDV 6FKO VVHOSDDU XQWHU 9HUZHQGXQJ GHV 7RROV VQH[H IROJHQGHUPD HQ KHUVWHOOHQ 1 1 0 0 1... 501 (LQ +DVKFRGH ZLUG PLWKLOIH HLQHV +DVK DOJRULWKPXV DXV HLQHP ELQlUHQ 2EMHNW HU]HXJW -HGH bqghuxqj DP,QKDOW RGHU DQ GHU /lqjh GHV 2EMHNWV EHZLUNW DXFK HLQH 9HUlQGHUXQJ GHV +DVKFRGHV.XOWXULQIRUPDWLRQHQ -HGH 1(7$VVHPEO\ EHLQKDOWHW.XOWXULQIRUPDWLRQHQ 'DV VLQG,QIRUPDWLRQHQ EHU GLH YHUZHQGHWH 6SUDFKH VRZLH EHU GLH )RUPDWH YRQ :lkuxqjv =DKOHQ XQG 'DWXPVDQJDEHQ +DEHQ 6LH GD]X NHLQH VSH]LHOOHQ (LQVWHOOXQJHQ YRUJHQRPPHQ ZHUGHQ GLH LP %HWULHEV V\VWHP HLQJHVWHOOWHQ :HUWH EHUQRPPHQ %HWlWLJHQ 6LH GLH 7DVWHQNRPELQDWLRQ á R XQG JHEHQ 6LH GHQ %HIHKO sn -k keypair.snk HLQ %HVWlWLJHQ 6LH PLW RETURN,P 6WDPPYHU]HLFKQLV GHV /DXIZHUNV &? EHILQGHW VLFK GDUDXIKLQ GLH ELQlUH 'DWHL NH\SDLUVQN PLW HLQHP IIHQWOLFKHQ XQG HLQHP SULYDWHQ 6FKO VVHO $QVFKOLH HQG N QQHQ 6LH GHQ VWDUNHQ 1DPHQ HLQHU $VVHPEO\ HU]HXJHQ giiqhq 6LH GD]X GDV HQWVSUHFKHQGH 3URMHNW PLW 9LVXDO 6WXGLR 1(7 %HWlWLJHQ 6LH GLH 7DVWHQNRPELQDWLRQ STRG ALT L XQG IIQHQ 6LH LP 3URMHNWPDSSHQ([SORUHU GLH 'DWHL $VVHPEO\,QIRFV PLW HLQHP 'RSSHONOLFN $NWXDOLVLHUHQ 6LH JHJHEHQHQIDOOV GLH LQ GLHVHU 'DWHL EHILQGOLFKHQ $QJDEHQ ]XP 1DPHQ GHU $VVHPEO\ ]XU )LUPD XQG ]XP &RS\ULJKW ) JHQ 6LH DQ EHOLHELJHU 6WHOOH PLW IROJHQGHU =HLOH GHQ 9HUZHLV DXI GDV 6FKO VVHOSDDU HLQ [Assembly: AssemblyKeyFile("C:\keypair.snk")].RPSLOLHUHQ 6LH GLH $QZHQGXQJ QHX GDPLW GHU VWDUNH 1DPH HU]HXJW XQG LQ GLH $VVHPEO\ EHUQRPPHQ ZLUG 'LH $VVHPEO\ HQWKlOW PLW GHP VWDUNHQ 1DPHQ DOOH ZHVHQWOLFKHQ %HVWDQGWHLOH ]XU *HZlKUOHLVWXQJ LKUHU,QWHJULWlW (V LVW QLFKW HUIRUGHUOLFK ] % HLQHQ IIHQWOLFKHQ 6FKO VVHO ]XJlQJOLFK ]X PDFKHQ GD HU EHUHLWV LQ GHU $VVHPEO\ HQWKDOWHQ LVW (LQ $QZHQGHU NDQQ QXQ PLW GHP 7RRO VQH[H EHUSU IHQ RE HLQH $VVHPEO\ HLQHQ J OWLJHQ VWDUNHQ 1DPHQ EHVLW]W giiqhq 6LH GD]X EHU GDV 0HQ 67$57 352*5$00( =8%(+g5 (,1*$%( $8))25'(581* HLQ.RQVROHQIHQVWHU 1DYLJLHUHQ 6LH LQ GDV 9HU]HLFKQLV LQ GHP VLFK GLH $VVHPEO\ PLW GHP VWDUNHQ 1DPHQ EHILQ GHW *HEHQ 6LH GLH IROJHQGH $QZHLVXQJ HLQ XQG EHVWlWLJHQ 6LH GLHVH sn -v <Assemblyname>

3 Visual C#.NET - Fortgeschr ittene Programmierung ; 6LH N QQHQ GHQ VWDUNHQ 1DPHQ DXFK EHU GLH %HIHKOV]HLOH HU]HXJHQ LQGHP 6LH GDV 7RRO DOH[H YHU ZHQGHQ (LQ]HOKHLWHQ GD]X ILQGHQ 6LH LQ GHU 2QOLQH+LOIH XQWHU GHP 6WLFKZRUW DOH[H 'DV 6LJQLHUHQ XQG =HUWLIL]LHUHQ YRQ $VVHPEOLHV N QQHQ 6LH DXFK GXUFKI KUHQ ZHQQ 6LH I U,KUH $QZHQGXQJ HLQ 6HWXS 3URMHNW HUVWHOOHQ 8QWHU GHQ (LJHQVFKDIWHQ GHV 6HWXS3URMHNWV JLEW HV GLH 0 JOLFKNHLW HLQ =HUWLILNDW XQG HLQHQ SULYDWHQ 6FKO VVHO DQ]XJHEHQ ; :HQQ LQ HLQHP 8QWHUQHKPHQ QXU HLQH EHVWLPPWH 3HUVRQ =XJULII DXI GHQ SULYDWHQ 6FKO VVHO EHVLW]W N QQHQ GLH (QWZLFNOHU DXFK ]XQlFKVW QXU PLW GHP IIHQWOLFKHQ 6FKO VVHO DUEHLWHQ (UVW YRU GHU $QZHQ GXQJVZHLWHUJDEH HUIROJW GDQQ GDV (U]HXJHQ HLQHV YROOVWlQGLJHQ VWDUNHQ 1DPHQV GXUFK 6LJQLHUHQ PLW GHP SULYDWHQ 6FKO VVHO (LQ]HOKHLWHQ GD]X ILQGHQ 6LH LQ GHU 2QOLQH+LOIH XQWHU GHP 7KHPD 9HU] JHUWHV 6LJQLHUHQ HLQHU $VVHPEO\ ; (LQ )LQJHUSULQW HLQ $XV]XJ GHV IIHQWOLFKHQ 6FKO VVHOV GHV VWDUNHQ 1DPHQV ZLUG LP ([SORUHU YRQ :LQ GRZV DQJH]HLJW XQG NDQQ ]XP VFKQHOOHQ 9HUJOHLFKHQ E]Z,GHQWLIL]LHUHQ VWDUNHU 1DPHQ KHUDQJH]R JHQ ZHUGHQ %HDFKWHQ 6LH GDVV HLQ VWDUNHU 1DPH QLFKWV EHU GLH +HUNXQIW GHU $VVHPEO\ DXVVDJW ) U GLHVH $XIJDEH LVW GDV 6LJQLHUHQ PLW HLQHP GLJLWDOHQ =HUWLILNDW HUIRUGHUOLFK 3.3.3 Verbergen von Informationen :HGHU GLH =HUWLIL]LHUXQJ GHV &RGHV QRFK GDV 9HUJHEHQ HLQHV VWDUNHQ 1DPHQV N QQHQ YHUKLQGHUQ GDVV GHU 3URJUDPPFRGH DXVVSLRQLHUW ZLUG (LQ SRWHQ]LHOOHU $QJUHLIHU EUDXFKW GLH $VVHPEO\ QXU PLW HLQHP JHHLJQHWHQ 'LVDVVHPEOHU ]X IIQHQ XP GDV 0DQLIHVW GLH 0HWDGDWHQ XQG GHQ,/&RGH HLQVHKHQ RGHU VSHLFKHUQ ]X N Q QHQ 8P GLHV ]X YHUKLQGHUQ E]Z ]X HUVFKZHUHQ N QQHQ 6LH,KUH $VVHPEOLHV PLW HLQHP VR JHQDQQWHQ 2EIXVFDWRU 9HUZLUUHU EHKDQGHOQ 'DEHL KDQGHOW HV VLFK XP HLQ 3URJUDPP GDV GLH LQ GHU $VVHPEO\ JHVSHL FKHUWHQ,QIRUPDWLRQHQ MH QDFK (LQVWHOOXQJ PHKU RGHU ZHQLJHU YHUELUJW E]Z GXUFKHLQDQGHU EULQJW VRGDVV HLQH 5 FNZlUWVHQWZLFNOXQJ VWDUN EHKLQGHUW ZLUG (LQ 2EIXVFDWRU ZHQGHW LQ GHU 5HJHO ]ZHL 9HUIDKUHQ DQ ; (U HUVHW]W GLH %H]HLFKQHU GXUFK XQVLQQLJH : UWHU RGHU GXUFK 6FKO VVHOZ UWHU,Q PDQFKHQ )loohq ZHU GHQ %H]HLFKQHU DXFK YHUWDXVFKW 'DGXUFK ZLUG HV VFKZHUHU GHQ 3URJUDPPFRGH PLW HLQHP YHUWUHW EDUHQ =HLWDXIZDQG ]X YHUVWHKHQ ; (U VFKDIIW 9HUZLUUXQJ GXUFK +LQ]XI JHQ YRQ EHUIO VVLJHP 3URJUDPPFRGH VRGDVV HLQ SRWHQ]LHOOHU $QJUHLIHU KHUDXVILQGHQ PXVV DXI ZHOFKHQ &RGH YHU]LFKWHW ZHUGHQ NDQQ XQG DXI ZHOFKHQ QLFKW (LQ JXWHU 2EIXVFDWRU JHVWDWWHW HV GDV $XVPD GHU 6FKXW]PD QDKPHQ IHVW]XOHJHQ GHQQ HV LVW QLFKW VLQQYROO GLH %H]HLFKQHU YRQ.ODVVHQ E]Z 0HWKRGHQ ]X YHUlQGHUQ DXI GLH YRQ DX HQ ]XJHJULIIHQ ZHUGHQ PXVV $X HUGHP VROOWH GLH *U H HLQHU $VVHPEO\ GXUFK +LQ]XI JHQ YRQ EHUIO VVLJHP &RGH QLFKW ]X VHKU ZDFKVHQ hehu GDV,QWHUQHW ZHUGHQ VRZRKO NRVWHQORVH DOV DXFK NRPPHU]LHOOH 2EIXVFDWRUV DQJHERWHQ 3.4 Übung Übung 1 - Reflektion Übungsdatei: Uebung1.sln Ergebnisdatei: Uebung1.exe (UVWHOOHQ 6LH HLQ QHXHV 3URMHNW I U HLQH :LQGRZV$QZHQGXQJ 'DV 3URJUDPP VROO GLH LQ HLQHU $VVHPEO\ YRUKDQGHQHQ 7\SHQ XQG 7\SPHPEHU DXIOLVWHQ

Assemblies analysieren, verwalten und schützen 3 3ODW]LHUHQ 6LH DXI GHP )RUPXODU ]ZHL Button.RPSRQHQWHQ HLQH TexBox.RPSRQHQWH GUHL Label XQG ]ZHL ListBox.RPSRQHQWHQ 9HUZHQGHQ 6LH GLH 7H[WER[ ]XP $Q]HLJHQ GHV $VVHPEO\QDPHQV XQG GLH /LVWER[HQ ]XP $Q]HLJHQ GHU 7\SHQ E]Z 7\SPHPEHU (LQH OpenFileDialog.RPSRQHQWH GLHQW GHU 'DWHLDXVZDKO 'HQ 'DWHLDXVZDKO 'LDORJ N QQHQ 6LH ZLH IROJW UHDOLVLHUHQ if(openfiledialog1.showdialog() == DialogResult.OK) txtassembly.text = OpenFileDialog1.FileName;... 'LH YRQ GHQ 0HWKRGHQ GetTypes XQG GetMembers ]XU FNJHJHEHQHQ $XIOLVWXQJHQ N QQHQ 6LH GHQ /LVWER[HQ GLUHNW PLWWHOV GHU 0HWKRGH Items AddRange EHUJHEHQ ] % Type t = (Type)lstTypen.SelectedItem; lstmember.items.addrange(t.getmembers()); (UVWHOOHQ 6LH HLQH (UHLJQLVEHKDQG OXQJVPHWKRGH I U GDV (UHLJQLV SelectedIndexChanged GHU OLQNHQ /LVWER[,QQHUKDOE GLHVHU 0HWKRGH HUPLWWHOQ 6LH GLH 0HPEHU GHV 7\SV GHU LQ GHU OLQNHQ /LVWER[ DXVJHZlKOW LVW XQG ]HLJHQ 6LH GLHVH LQ GHU UHFKWHQ /LVWER[ DQ =XJULII DXI GHQ 1DPHQ GHV HQWVSUHFKHQGHQ 7\SV KDEHQ 6LH PLW GHU (LJHQVFKDIW SelectedItem GHU /LVWER[ Übung 2 - starker Name Übungsdatei: Uebung2.sln Ergebnisdatei: Uebung2.exe (U]HXJHQ 6LH I U GLH LQ hexqj HQWVWDQGHQH $VVHPEO\ HLQHQ VWDUNHQ 1DPHQ hehusu IHQ 6LH GHQ (UIROJ LQGHP 6LH GLH $VVHPEO\ PLWKLO IH GHV :LQGRZV([SORUHUV SHU 'UDJ 'URS LQ GHQ JOREDOHQ $VVHPEO\FDFKH ]LHKHQ 'LHV ZLUG QXU P JOLFK VHLQ ZHQQ,KUH $VVHPEO\ HLQHQ VWDUNHQ 1DPHQ EHVLW]W (QWIHUQHQ 6LH GLH $VVHPEO\ DQVFKOLH HQG ZLHGHU DXV GHP $VVHPEO\FDFKH 9HUZHQGHQ 6LH GDV 7RRO LOGDVPH[H XP GLH $VVHPEO\ ]X GLVDVVHPEOLHUHQ 6SHLFKHUQ 6LH GHQ GLVDVVHPEOLHUWHQ &RGH XQG YHUlQGHUQ 6LH LKQ PLW HLQHP 7H[WHGLWRU (U]HXJHQ 6LH DQVFKOLH HQG PLW GHP 3URJUDPP LODVPH[H DXV GHP YHUlQGHUWHQ &RGH ZLHGHU HLQH $VVHPEO\ 9HUVXFKHQ 6LH GDV YHUlQGHUWH 3URJUDPP ]X VWDUWHQ 'LH.RQWUROOH GHV VWDUNHQ 1DPHQV VFKHLWHUW VRGDVV HLQH )HKOHUPHOGXQJ DXVJHJHEHQ ZLUG