How to Eseguire macro di Office utilizzando l'automazione da Visual C++ .NET

Creazione di documenti di Office contenenti macro

1. Creare un documento di Word denominato C:\Doc1.doc. Per fare questo, attenersi alla seguente procedura:
   1. Creare un nuovo documento in Microsoft Word.
   2. Premere ALT+F11 per aprire Visual Basic Editor.
   3. Scegliere Modulo dal menu Inserisci.
   4. Nel nuovo modulo digitare il seguente codice per la macro:

      'Display a message box that displays the application name.
      Public Sub DoKbTest()
         MsgBox "Hello from " & Application.Name
      End Sub
      
      'Display a message box with the string passed from the
      'Automation client.
      Public Sub DoKbTestWithParameter( sMsg As String )
         MsgBox sMsg
      End Sub

   5. Chiudere Visual Basic Editor, salvare il documento e chiudere Word.
2. Creare una cartella di lavoro di Excel denominata C:\Book1.xls utilizzando una procedura simile a quella vista per la creazione del documento di Word.
3. Creare una presentazione di PowerPoint denominata C:\Pres1.ppt utilizzando una procedura simile a quella vista per la creazione del documento di Word.
4. Creare un nuovo database di Access denominato C:\Db1.mdb. Per eseguire questa operazione, attenersi alla seguente procedura:
   1. Scegliere Modulo dal menu Inserisci.
   2. Incollare il codice della macro nel nuovo modulo.
   3. Salvare il modulo e chiudere Access.

Creazione del client di automazione di Visual C++ .NET

1. Avviare Microsoft Visual Studio .NET. Scegliere Nuovo dal menu File, quindi scegliere Progetto. Selezionare Applicazione C++ gestita dai tipi di progetti di Visual C++. Assegnare al progetto il nome OfficeMacros e crearlo in C:\.
2. Creare gli assembly di Office. Per eseguire questa operazione, attenersi alla seguente procedura:
   1. Aprire una finestra di comando. Per fare questo, fare clic sul pulsante Start e scegliere Programmi, Microsoft Visual Studio .NET, Strumenti di Microsoft Visual Studio .NET e infine Prompt dei comandi di Microsoft Visual Studio .NET.
   2. Inviare il comando cd C:\OfficeMacros per passare alla directory del nuovo progetto.
   3. Creare la directory di output per la configurazione di debug utilizzando il comando mkdir Debug.
   4. Utilizzare il comando cd Debug per passare alla directory Debug.
   5. Utilizzare i comandi riportati di seguito per generare assembly dalle librerie di oggetti di Access 2002, Excel 2002, PowerPoint 2002 e Word 2002:

      tlbimp "c:\Program Files\Microsoft Office\Office10\msacc.olb"
      tlbimp "c:\Program Files\Microsoft Office\Office10\excel.exe"
      tlbimp "c:\Program Files\Microsoft Office\Office10\msppt.olb"
      tlbimp "c:\Program Files\Microsoft Office\Office10\msword.olb"

      NOTA: questi comandi utilizzano percorsi di installazione predefiniti per le librerie dei tipi di Office 2002. Se necessario, modificare i percorsi nei comandi riportati sopra in modo da utilizzare il percorso corretto per l'installazione di Office. Il percorso di installazione predefinito per Office 2000 è C:\Programmi\Microsoft Office\Office e le librerie dei tipi sono Msacc9.olb, Excel9.olb, Msppt9.olb e Msword9.olb.
      
      
   6. questi comandi utilizzano percorsi di installazione predefiniti per le librerie dei tipi di Office 2002. Se necessario, modificare i percorsi nei comandi riportati sopra in modo da utilizzare il percorso corretto per l'installazione di Office. Il percorso di installazione predefinito per Office 2000 è C:\Programmi\Microsoft Office\Office e le librerie dei tipi sono Msacc9.olb, Excel9.olb, Msppt9.olb e Msword9.olb. Chiudere la finestra del prompt dei comandi.
3. Aggiungere la directory Debug all'elenco delle directory in cui eseguire la ricerca per risolvere i riferimenti ai file passati all'istruzione #using. Per eseguire questa operazione, attenersi alla seguente procedura:
   1. In Esplora soluzioni di Visual Studio .NET fare clic con il pulsante destro del mouse sul progetto e scegliere Proprietà.
   2. Nel riquadro sinistro della finestra di dialogo Pagine proprietà fare clic sulla cartella C/C++ quindi sulla cartella Generale.
   3. Nella casella Risolvi riferimenti #using aggiungere il percorso C:\OfficeMacros\Debug e scegliere OK.
4. Aprire OfficeMacros.cpp nell'editor HTML e sostituire il contenuto con il codice riportato di seguito:

   #include "stdafx.h"
   
   #using <mscorlib.dll>
   //OFFICE9:
   #using "C:\\OfficeMacros\\Debug\\Office.dll"
   //OFFICE10:
   //#using "Office.dll"
   #using "vbide.dll"
   #using "word.dll"
   #using "excel.dll"
   #using "powerpoint.dll"
   #using "access.dll"
   
   using namespace System;
   using namespace System::Reflection;
   //OFFICE9:
   using namespace Office;
   //OFFICE10:
   //using namespace Microsoft::Office::Core;
   
   #include <tchar.h>
   
   void PrintMenu();
   void AutoCallAccess();
   void AutoCallExcel();
   void AutoCallPowerPoint();
   void AutoCallWord();
   void CallMacro(Object* oApp, Object* oArgs[]);
   
   int _tmain(void)
   {
   	PrintMenu();
   	String* s = Console::ReadLine();
   	while( !s->ToLower()->Equals(S"q") )
   	{
   		Int32 i;
   		try
   		{
   			i = Convert::ToInt32(s,10);
   		}
   		catch( Exception* e )
   		{
   			goto print;
   		}
   
   		// Select the Office application to automate based on user input.
   
   		switch( i )
   		{
   		case 1:
   			AutoCallAccess();
   			break;
   		case 2:
   			AutoCallExcel();
   			break;
   		case 3:
   			AutoCallPowerPoint();
   			break;
   		case 4:
   			AutoCallWord();
   			break;
   		default:
   			;
   		}
   print:
   		PrintMenu();
   		s = Console::ReadLine();
   	}
   	return 0;
   }
   
   void PrintMenu()
   {
   	Console::WriteLine(S"\n\nEnter the number of the application you'd like to automate.");
   	Console::WriteLine(S"Enter 'q' to quit the application.\n");
   	Console::WriteLine(S"\t\t1. Microsoft Access");
   	Console::WriteLine(S"\t\t2. Microsoft Excel");
   	Console::WriteLine(S"\t\t3. Microsoft PowerPoint");
   	Console::WriteLine(S"\t\t4. Microsoft Word\n");
   	Console::Write(S"\tSelection:");
   }
   
   void AutoCallAccess()
   {
   	try{
   		//Start Access, make it visible, and open C:\Db1.mdb.
   		Console::WriteLine("\nStarting Microsoft Access...");
   		Access::ApplicationClass* pAccess = new Access::ApplicationClass();
   		pAccess->Visible = true;
   		//ACCESS9:
   		pAccess->OpenCurrentDatabase("c:\\db1.mdb", false);
   		//ACCESS10:
   		//pAccess->OpenCurrentDatabase("c:\\db1.mdb", false, "");
   		//Run the macros.
   		System::Object* oParams[] = {new String("DoKbTest"), 
   			System::Reflection::Missing::Value};
   		CallMacro(pAccess, oParams);
   		oParams[0] = new String("DoKbTestWithParameter");
   		oParams[1] = new String("Hello From Visual C++ .NET (AutoCallAccess)");
   		CallMacro(pAccess, oParams);	
   		//Quit Access and clean up.
   		pAccess->get_DoCmd()->Quit(Access::AcQuitOption::acQuitSaveNone);
   		System::Runtime::InteropServices::Marshal::ReleaseComObject(pAccess);
   		GC::Collect();
   	}
   	catch(Exception* e)
   	{
   		Console::WriteLine(S"Error automating Access...");
   		Console::WriteLine(e->get_Message());
   	}
   }
   
   void AutoCallExcel()
   {
   	try{
   		//Start Excel, make it visible, and open C:\Book1.xls.
   		System::Object* oMissing = System::Reflection::Missing::Value;
   		Console::WriteLine("\nStarting Microsoft Excel...");
   		Excel::ApplicationClass* pExcel = new Excel::ApplicationClass();
   		pExcel->Visible = true;
   		Excel::Workbooks* pBooks = pExcel->get_Workbooks();
   		//EXCEL9:
   		Excel::_Workbook* pBook = pBooks->Open("c:\\book1.xls", oMissing, oMissing,
   			oMissing, oMissing, oMissing, oMissing, oMissing, oMissing, 
   			oMissing, oMissing, oMissing, oMissing);
   		//EXCEL10:
   		//Excel::_Workbook* pBook = pBooks->Open("c:\\book1.xls", oMissing, oMissing,
   		//	oMissing, oMissing, oMissing, oMissing, oMissing, oMissing, 
   		//	oMissing, oMissing, oMissing, oMissing, oMissing, oMissing);
   
   		//Run the macros.
   		System::Object* oParams[] = {new String("DoKbTest"), oMissing};
   		CallMacro(pExcel, oParams);
   		oParams[0] = new String("DoKbTestWithParameter");
   		oParams[1] = new String("Hello From Visual C++ .NET (AutoCallExcel)");
   		CallMacro(pExcel, oParams);
   		//Quit Excel and clean up.
   		pBook->Close(false, oMissing, oMissing);
   		System::Runtime::InteropServices::Marshal::ReleaseComObject(pBook);
   		System::Runtime::InteropServices::Marshal::ReleaseComObject(pBooks);
   		pExcel->Quit();
   		System::Runtime::InteropServices::Marshal::ReleaseComObject(pExcel);
   		GC::Collect();
   	}
   	catch(Exception* e)
   	{
   		Console::WriteLine(S"Error automating Excel...");
   		Console::WriteLine(e->get_Message());
   	}
   }
   
   void AutoCallPowerPoint()
   {
   	try{
   		//Start PowerPoint, make it visible, and open C:\Pres1.ppt.
   		Console::WriteLine("\nStarting Microsoft PowerPoint...");
   		PowerPoint::ApplicationClass* pPPT = new PowerPoint::ApplicationClass();
   		pPPT->Visible = Office::MsoTriState::msoTrue;
   		
   		PowerPoint::Presentations* pPresSet = pPPT->get_Presentations();
   		PowerPoint::_Presentation* pPres = pPresSet->Open("C:\\pres1.ppt", 
   			MsoTriState::msoFalse, 
   			MsoTriState::msoFalse,
   			MsoTriState::msoTrue);
   		
   		//Run the macros.
   		System::Object* oParams[] = {new String("'pres1.ppt'!DoKbTest"), 
   			System::Reflection::Missing::Value};
   		CallMacro(pPPT, oParams);
   		oParams[0] = new String("'pres1.ppt'!DoKbTestWithParameter");
   		oParams[1] = new String("Hello From Visual C++ .NET (AutoCallPowerPoint)");
   		CallMacro(pPPT, oParams);		
   		//Quit PowerPoint and clean up.
   		pPres->Close();
   		System::Runtime::InteropServices::Marshal::ReleaseComObject(pPres);
   		System::Runtime::InteropServices::Marshal::ReleaseComObject(pPresSet);
   		pPPT->Quit();
   		System::Runtime::InteropServices::Marshal::ReleaseComObject(pPPT);
   		GC::Collect();
   	}
   	catch(Exception* e)
   	{
   		Console::WriteLine(S"Error automating PowerPoint...");
   		Console::WriteLine(e->get_Message());
   	}
   }
   
   void AutoCallWord()
   {
   	try{
   		//Start Word, make it visible, and open C:\Doc1.doc.
   		System::Object* oMissing = System::Reflection::Missing::Value;
   		Console::WriteLine("\nStarting Microsoft Word...");
   		Word::ApplicationClass* pWord = new Word::ApplicationClass;
   		pWord->Visible = true;
   		Word::Documents* pDocs = pWord->Documents;
   		System::Object* oFile = new System::Object;
   		oFile = S"c:\\doc1.doc";
   		//WORD9:
   		Word::_Document* pDoc = pDocs->Open(&oFile, &oMissing,
   			&oMissing, &oMissing, &oMissing, &oMissing, &oMissing,
   			&oMissing, &oMissing, &oMissing, &oMissing, &oMissing);
   		//WORD10:
   		//Word::_Document* pDoc = pDocs->Open(&oFile, &oMissing,
   		//	&oMissing, &oMissing, &oMissing, &oMissing, &oMissing,
   		//	&oMissing, &oMissing, &oMissing, &oMissing, &oMissing,
   		//	&oMissing, &oMissing, &oMissing);
   
   		//Run the macros.
   		System::Object* oParams[] = {new String("DoKbTest"), oMissing};
   		CallMacro(pWord, oParams);
   		oParams[0] = new String("DoKbTestWithParameter");
   		oParams[1] = new String("Hello From Visual C++ .NET (AutoCallWord)");
   		CallMacro(pWord, oParams);		
   		//Quit Word and clean up.
   		pDoc->Close(&oMissing, &oMissing, &oMissing);
   		System::Runtime::InteropServices::Marshal::ReleaseComObject(pDoc);
   		System::Runtime::InteropServices::Marshal::ReleaseComObject(pDocs);
   		pWord->Quit(&oMissing, &oMissing, &oMissing);
   		System::Runtime::InteropServices::Marshal::ReleaseComObject(pWord);
   		GC::Collect();
   	}
   	catch(Exception* e)
   	{
   		Console::WriteLine(S"Error automating Word...");
   		Console::WriteLine(e->get_Message());
   	}
   }
   
   void CallMacro(Object* oApp, Object* oArgs[])
   {
   	Console::WriteLine("Calling Macro...");
   	oApp->GetType()->InvokeMember("Run",
   		BindingFlags(BindingFlags::Default | BindingFlags::InvokeMethod),
   		NULL, oApp, oArgs);
   
   } 

   NOTA: come specificato, questo codice utilizza le librerie di oggetti di Office 9.0. Quando si aggiungono riferimenti al progetto, se si selezionano le librerie di oggetti di Office 10.0 anziché quelle di Office 9.0, cercare nel codice le righe di commenti contenenti "//OFFICE10", "//ACCESS10", "//EXCEL10" e "//WORD10" e rimuovere il commento dalla riga o dalle righe di codice a cui il commento si riferisce. Allo stesso modo, cercare nel codice commenti contenenti "//OFFICE9", "//ACCESS9", "//EXCEL9" e "//WORD9" e mettere in commento la riga o le righe a cui il commento si riferisce.

Esecuzione e verifica del client di automazione

1. Premere F5 per compilare ed eseguire il client di automazione.
2. Quando il client viene eseguito, viene offerta la selezione seguente:

   Digitare il numero dell'applicazione che si desidera automatizzare.
   Digitare 'q' per chiudere l'applicazione.
   
                   1. Microsoft Access
                   2. Microsoft Excel
                   3. Microsoft PowerPoint
                   4. Microsoft Word
   
           Selezione:

3. Al prompt dei comandi digitare 1 e premere INVIO. Il client di automazione avvierà Access, eseguirà le macro nel database creato e chiuderà Access.
4. Ripetere il passaggio precedente per automatizzare Excel, PowerPoint e Word.
5. Al termine, digitare q e premere INVIO per chiudere il client di automazione.

Torna all'inizio