{"id":55000452,"date":"2024-12-01T00:00:00","date_gmt":"2025-03-10T20:20:21","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=452"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Ist_die_32_oder_64BitVersion_von_Office_installiert","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/Ist_die_32_oder_64BitVersion_von_Office_installiert\/","title":{"rendered":"Ist die 32- oder 64-Bit-Version von Office installiert?"},"content":{"rendered":"<p><b>Diese Frage, ob Office in der 32-Bit- oder in der 64-Bit-Version vorliegt, ist f&uuml;r viele Aufgaben interessant. Seit Access 2019 wird Office standardm&auml;&szlig;ig in der 64-Bit-Version installiert. Es gibt jedoch auch immer alternativ die 32-Bit-Version. Vor Access 2019 war die 32-Bit-Installation Standard. Wozu aber ben&ouml;tigen wir diese Information &uuml;berhaupt? Wenn wir das VBA-Projekt einer Access-, Excel-, Word- oder PowerPoint-Datei programmieren oder das Outlook-Objektmodell und dabei weder ActiveX-Steuerelemente noch Integrationen wie COM-DLLs oder COM-Add-Ins oder API-Funktionen nutzen, spielt es keine Rolle, ob wir mit 32-Bit- oder 64-Bit-Office arbeiten. Sobald jedoch eines der genannten Elemente auftaucht, m&uuml;ssen wir genau pr&uuml;fen, ob dieses unter beiden Versionen arbeitet. Wir schauen uns kurz an, wo besonderes Augenmerk gefragt ist und wie wir es dem Benutzer mitteilen k&ouml;nnen, wenn seine Office-Version und unsere Erweiterungen nicht kompatibel sind.<\/b><\/p>\n<p>Wie finde ich heraus, ob die 32- oder 64-Bit-Version von Access\/Office installiert ist?Die Information, ob auf einem Rechner die 32-Bit- oder 64-Bit-Version von Microsoft Access oder Office installiert ist, ist in verschiedenen Szenarien wichtig. Beispielsweise spielt dies bei der Entwicklung von Access-Anwendungen oder bei der Verwendung von VBA (Visual Basic for Applications) eine Rolle, da die verwendeten Bibliotheken und API-Deklarationen an die Bit-Version angepasst werden m&uuml;ssen.<\/p>\n<p>Das ist vor allem bei den folgenden Situationen wichtig:<\/p>\n<ul>\n<li>Wenn wir API-Funktionen verwenden. Diese m&uuml;ssen unter 64-Bit anders deklariert werden als unter 32-Bit. In den meisten F&auml;llen erhalten wir bereits beim Kompilieren eines VBA-Projekts in der 64-Bit-Version Fehlermeldungen, wenn die Deklaration der API-Funktionen nicht kompatibel ist. Der Teufel steckt aber im Detail, denn es k&ouml;nnen auch Korrekturen der Datentypen etwa von Parametern erforderlich sein, da es sonst zu Laufzeitfehlern kommt.<\/li>\n<li>Wenn wir ActiveX-Steuerelemente von Drittherstellern nutzen, sind diese oft nur f&uuml;r die 32-Bit-Versionen von Office verf&uuml;gbar. Gerade bei der Verwendung &auml;lterer Steuerelemente, die nicht mehr weiterentwickelt werden, ist oft das Ersetzen des vollst&auml;ndigen Steuerelements durch eine Alternative notwendig.<\/li>\n<li>Wenn wir COM-DLLs oder COM-Add-Ins nutzen, gelten die gleichen Regeln. Diese sind entweder f&uuml;r 32-Bit oder f&uuml;r 64-Bit entwickelt worden und funktionieren nur mit der jeweiligen Office-Version zusammen. Wer selbst solche Elemente entwickelt, beispielsweise mit twinBASIC, VB6 oder Visual Studio .NET, hat immerhin die M&ouml;glichkeit, die COM-DLLs oder COM-Add-Ins f&uuml;r die entsprechende Version zu kompilieren.<\/li>\n<\/ul>\n<h2>M&ouml;glichkeiten zur Pr&uuml;fung auf 32-Bit oder 64-Bit<\/h2>\n<p>In den folgenden Abschnitten schauen wir uns verschiedene M&ouml;glichkeiten an, um herauszufinden, ob Office in der 32-Bit- oder in der 64-Bit-Version installiert ist:<\/p>\n<ul>\n<li>&Uuml;ber die Office-Anwendung selbst herausfinden<\/li>\n<li>Bit-Version mit VBA ermitteln<\/li>\n<\/ul>\n<h2>32-\/64-Bit &uuml;ber die Benutzeroberfl&auml;che identifizieren<\/h2>\n<p>Alle Office-Anwendungen stellen die Information bereit, ob es sich dabei um die 32-Bit- oder 64-Bit-Version handelt. Diese finden wir aber nicht direkt, sondern wir m&uuml;ssen ein wenig graben. Dazu klicken wir zun&auml;chst im Ribbon auf <b>Datei<\/b>. Dies &ouml;ffnet das Datei-Men&uuml;, wo wir beispielsweise unter <b>Microsoft Access <\/b>den Eintrag <b>Konto <\/b>aufklappen (unter Outlook hei&szlig;t der Eintrag <b>Office-Konto<\/b>). Hier finden wir nun eine Schaltfl&auml;che namens <b>Info zu Access<\/b> (siehe Bild 1).<\/p>\n<p class=\"image\"><img decoding=\"async\" src=\"..\/fileadmin\/_temp_\/2024_06\/pic_452_001.png\" alt=\"&Ouml;ffnen der Infos zur jeweiligen Office-Anwendung, hier f&uuml;r Access\" width=\"700\" height=\"409,2688\" \/><\/p>\n<p><b><span style=\"color:darkgrey;\">Bild 1: &Ouml;ffnen der Infos zur jeweiligen Office-Anwendung, hier f&uuml;r Access<\/span><\/b><\/p>\n<p>Klicken wir diese an, erscheint ein weiterer Dialog mit einigen zus&auml;tzlichen Informationen, zum Beispiel der genauen Versionsangabe. Dahinter finden wir schlie&szlig;lich die Angabe, dass wir es hier mit der 32-Bit-Version von Access zu tun haben (siehe Bild 2).<\/p>\n<p class=\"image\"><img decoding=\"async\" src=\"..\/fileadmin\/_temp_\/2024_06\/pic_452_002.png\" alt=\"Diese Access-Installation liegt in der 32-Bit-Variante vor.\" width=\"700\" height=\"230,3108\" \/><\/p>\n<p><b><span style=\"color:darkgrey;\">Bild 2: Diese Access-Installation liegt in der 32-Bit-Variante vor.<\/span><\/b><\/p>\n<h2>32-\/64-Bit per VBA ermitteln<\/h2>\n<p>Die zweite Version erfordert keine Suche in der Benutzeroberfl&auml;che der jeweiligen Office-Anwendung. Stattdessen verwenden wir VBA, um die gew&uuml;nschte Information zu finden.<\/p>\n<p>Allerdings gibt es auch hier keine einfache, direkte M&ouml;glichkeit, um herauszufinden, ob die Office-Anwendung in der 32-Bit- oder 64-Bit-Version vorliegt.<\/p>\n<p>Es gibt also keine Eigenschaft wie die <b>Version<\/b>-Eigenschaft des <b>Application<\/b>-Objekts, die uns f&uuml;r Office 365 beispielsweise den Wert <b>16.0 <\/b>zur&uuml;ckliefert:<\/p>\n<pre>  Application.Version\r\n16.0<\/pre>\n<p>Stattdessen m&uuml;ssen wir den Umweg &uuml;ber die bedingte Kompilierung gehen. Diese stellt verschiedene Konstanten zur Verf&uuml;gung, die wir nutzen k&ouml;nnen, um die gew&uuml;nschten Informationen zu erhalten. Diese Konstanten hei&szlig;en auch Compiler-Konstanten.<\/p>\n<p>In diesem Fall pr&uuml;fen wir zuerst mit der Konstanten <b>VBA7<\/b>, ob wir es mit einer Anwendung zu tun hat, die bereits mit <b>VBA7 <\/b>arbeitet. Es k&ouml;nnte auch sein, dass hier <b>VBA6 <\/b>vorliegt. Dann w&uuml;ssten wir direkt, dass die Anwendung 32-Bit verwendet, denn zu Zeiten von Visual Basic for Applications 6 gab es nur 32-Bit. Visual Basic for Applications 7 wurde &uuml;brigens mit Office 2010 eingef&uuml;hrt.<\/p>\n<p>Im Falle von <b>VBA7 <\/b>k&ouml;nnen sowohl 32-Bit als auch 64-Bit vorliegen. Dies pr&uuml;fen wir mit der Compiler-Konstanten <b>Win64<\/b>. Hat diese den Wert <b>True<\/b>, arbeitet Office in der 64-Bit-Version. Falls nicht, in der 32-Bit-Version:<\/p>\n<pre><span style=\"color:blue;\">Public Function <\/span>GetBitness()<span style=\"color:blue;\"> As Integer<\/span>\r\n     <span style=\"color:blue;\">Dim <\/span>intVersion<span style=\"color:blue;\"> As Integer<\/span>\r\n     \r\n     #If VBA7 = <span style=\"color:blue;\">True<\/span> Then\r\n         #If Win64 = <span style=\"color:blue;\">True<\/span> Then\r\n             intVersion = 64\r\n         #Else\r\n             intVersion = 32\r\n         #End If\r\n     #Else\r\n         intVersion = 32\r\n     #End If\r\n     \r\n     GetBitness = intVersion\r\n<span style=\"color:blue;\">End Function<\/span><\/pre>\n<p>Testen k&ouml;nnen wir diese Funktion mit einem einfachen Aufruf wie in dieser Prozedur:<\/p>\n<pre><span style=\"color:blue;\">Public Sub <\/span>Test_GetBitness()\r\n     <span style=\"color:blue;\">Debug.Print<\/span> GetBitness\r\n<span style=\"color:blue;\">End Sub<\/span><\/pre>\n<h2>Zusammenfassung und Ausblick<\/h2>\n<p>Mit den hier beschriebenen Methoden kannst Du schnell herausfinden, ob Office in der 32-Bit- oder 64-Bit-Version installiert ist.<\/p>\n<p>Das ist insbesondere wichtig, wenn Du selbst L&ouml;sungen an Benutzer verteilst, f&uuml;r die es wichtig ist, welche Office-Version vorliegt.<\/p>\n<p>Man k&ouml;nnte beispielsweise in einem Dokument, das nur f&uuml;r 32-Bit ausgelegt ist, eine Warnmeldung ausgeben, wenn es unter der 64-Bit-Version ausgef&uuml;hrt wird.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>Diese Frage, ob Office in der 32-Bit- oder in der 64-Bit-Version vorliegt, ist f&uuml;r viele Aufgaben interessant. Seit Access 2019 wird Office standardm&auml;&szlig;ig in der 64-Bit-Version installiert. Es gibt jedoch auch immer alternativ die 32-Bit-Version. Vor Access 2019 war die 32-Bit-Installation Standard. Wozu aber ben&ouml;tigen wir diese Information &uuml;berhaupt? Wenn wir das VBA-Projekt einer Access-, Excel-, Word- oder PowerPoint-Datei programmieren oder das Outlook-Objektmodell und dabei weder ActiveX-Steuerelemente noch Integrationen wie COM-DLLs oder COM-Add-Ins oder API-Funktionen nutzen, spielt es keine Rolle, ob wir mit 32-Bit- oder 64-Bit-Office arbeiten. Sobald jedoch eines der genannten Elemente auftaucht, m&uuml;ssen wir genau pr&uuml;fen, ob dieses unter beiden Versionen arbeitet. Wir schauen uns kurz an, wo besonderes Augenmerk gefragt ist und wie wir es dem Benutzer mitteilen k&ouml;nnen, wenn seine Office-Version und unsere Erweiterungen nicht kompatibel sind.<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"om_disable_all_campaigns":false,"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"_uf_show_specific_survey":0,"_uf_disable_surveys":false,"footnotes":""},"categories":[662024,66062024,44000021,44000038,44000023],"tags":[],"yst_prominent_words":[],"class_list":["post-55000452","post","type-post","status-publish","format-standard","hentry","category-662024","category-66062024","category-Entity_Framework","category-Office_programmieren","category-PowerApps"],"aioseo_notices":[],"_links":{"self":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/posts\/55000452","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/comments?post=55000452"}],"version-history":[{"count":0,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/posts\/55000452\/revisions"}],"wp:attachment":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/media?parent=55000452"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/categories?post=55000452"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/tags?post=55000452"},{"taxonomy":"yst_prominent_words","embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/yst_prominent_words?post=55000452"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}