Hledat English (United States)  Italiano (Italia) Deutsch (Deutschland)  Español (España) Čeština (Česká Republika)
23. září 2019 ..:: Articles » VB 6.0 » Early-Late Binding con Excel e Outlook ::.. Zaregistrovat se  Přihlásit se
 Download Minimalizovat

  
 Early-Late Binding - esempio con Excel Minimalizovat

Early-Late Binding con Excel

 

Aggiornato il: 26/12/2012

1 - Corretto errore che impediva la chiusura dell'istanza di Excel.
      N.B. Nell'IDE di VB6 l'istanza creata non viene distrutta fino a che non si chiude il form.
      Nell'eseguibile invece funziona tutto correttamente
2 - Ora riconosce anche le versioni di Excel precedenti alla 10.

 

Pubblicato il: 26/05/2012

Quanto già indicato nell'esempio di Outlook vale per qualsiasi applicazione che sfrutta l'Office Automation di Microsoft.

Il nuovo progetto Early-Late Binding con Excel sfrutta quindi la stessa identica tecnica già vista nell'esempio di Outlook, per cui non mi dilungo più di tanto dato che non c'è alcuna utilità nel ripetere le cose già scritte.

L'esempio in Excel (molto più semplice rispetto a quello di Outlook) crea un nuovo file XLS o XLSX, a seconda della versione di Office installata nel vostro computer.

Ricordo di prestare particolare attenzione al fatto che le costanti mnemoniche di Excel, utilizzate normalmente, non sono riconosciute quando si esegue il progetto compilato, quindi vanno espressamente indicate con il loro valore effettivo, esempio:

Const xlCenter As Integer = -4108

Tutti i valori di queste costanti sono disponibile nel Visualizzatore Oggetti di VB6 (premere F2 per aprirlo) applicando un filtro sulla libreria 'Excel'.

Il progetto di esempio esegue quanto descritto di seguito:

- Crea un file (xls o xls)

- aggiunge quattro fogli (MySheet1, MySheet2, MySheet3 e MySheet4)

- rimuovi i tre fogli che Excel crea di default

- in ognuno dei quattro fogli scrive un testo in 4 celle diverse

- formatta le celle in modo casuale impostando il colore di sfondo, il colore del testo ed il bordo.

 Buon divertimento.

 


 Tisk   
 Early-Late Binding - esempio con Outlook Minimalizovat

Early-Late Binding con Outlook

Pubblicato il 23/06/2010

Nello sviluppo di applicazioni che si interfacciano con gli applicativi Office il programmatore si è sempre trovato davanti al classico dubbio: usare l'Early-Binding (associazione preventiva) oppure il Late-binding (associazione tardiva)?

Spesso (troppo spesso) si trovano nei forum le classiche (anche quelle) castronate in cui vengono mescolate entrambe le modalità di binding (che ovviamente non funzionano) e ciò tende ad confondere ancor più le idee del neofita.

Per chi non ha ben presente l'argomento suggerisco la lettura di un breve ma conciso articolo sulle differenze tra le due modalità di associazione ad opera di @Alex: http://forum.masterdrive.it/vba-tutorials-and-how-to-37/latebinding-vs-earlybinding-46733/
Anche se lui si riferisce al solo VBA, il concetto è esattamente uguale. Solo che VB6, come vedremo, mette a disposizione un qualcosa in poù che consente di risolvere il problema in modo elegante.

In questo articolo, invece, spiegherò come sia possibile fare in modo di poter usare l'Early-Binding quando si lavora nell'ambiente integrato di VB6 (IDE), ma nello stesso tempo, senza alcuna modifica al progetto, venga poi eseguito a run-time utilizzando il Late-Binding.

Come esempio, prenderemo l'automazione con Outlook, ma il concetto vale per qualsiasi altra applicazione di Office che esponga il relativo modello ad oggetti.

Prima di tutto, assicuriamoci di aggiungere il riferimento alla libreria di Outlook al nostro progetto. Nel mio caso, avendo Office 2007, sarà la versione 12.0

Nota importante: non importa quale versione usiate voi, e non importa quale versione ha l'utente finale.
Non importa semplicemente perchè tale libreria sarà utilizzata solo all'interno dell'IDE di VB6. Quando il programma sarà eseguito sul computer dell'utente, userà quella presente.

Infatti, come vedremo tra poco, il programma utilizzerà l'Early-Binding quando è eseguito nell'IDE, mentre quando sarà eseguito nella versione compilata userà automaticamente il Late-Binding.

Il bello è che ciò sarà possibile senza che lo sviluppatore debba modificare il proprio progetto!

Ricordo infatti che di solito si usa(va) utilizzare l'Early-Binding in fase di sviluppo con il vantaggio di avere disponibile il modello ad oggetti esposto dall'applicativo Office, intellisense incluso, ma poi al momento della compilazione si dovevano commentare le righe delle dichiarazioni che si riferivano direttamente alla libreria referenziata, rimuovere il riferimento alla libreria stessa, ed utilizzare CreateObject(...); poi si doveva rimettere tutto a posto per eventuali sviluppi futuri del progetto.
Tutt'altro che piacevole...

Ora dobbiamo predisporre il progetto affinchè possa distinguere la modalità di esecuzione sfruttando un argomento di compilazione condizionale.
Apriamo le Proprietà del progetto e nella scheda Crea inseriamo l'assegnazione EarlyBinding = 1 come mostrato in figura:

  

Bene, adesso iniziamo a scrivere il codice in modo da sfruttare l'argomento di compilazione condizionale.
Apriamo la finestra del codice del nostro form, e nella sezione delle Dichiarazioni inseriamo il codice

Rem ------------------------------------------------------------
Rem Dichiarazione condizionale degli oggetti in funzione di come
Rem sarà eseguito il programma (dall'IDE di VB o dall'EXE)
Rem ------------------------------------------------------------
#If EarlyBinding = 1 Then
    Rem VB IDE

    Rem OUTLOOK
    Dim myOlApp         As Outlook.Application
    Dim myNameSpace     As Outlook.NameSpace

    Rem CONTACT
    Dim myContacts      As Outlook.Items
    Dim myItem          As Outlook.ContactItem

    Rem APPOINTMENT
    Dim myAppointments  As Outlook.Items
    Dim myRestrictItems As Outlook.Items
    Dim myAppItem       As Outlook.AppointmentItem

    Rem Used both for CONTACTS and APPOINTMENTS
    Dim objItems        As Outlook.ItemProperties
    Dim objItem         As Outlook.ItemProperty
#Else
    Rem EXE stand alone

    Rem OUTLOOK
    Dim myOlApp         As Object 'Outlook.Application
    Dim myNameSpace     As Object 'Outlook.NameSpace

    Rem CONTACT
    Dim myContacts      As Object 'Outlook.Items
    Dim myItem          As Object 'Outlook.ContactItem

    Rem APPOINTMENT
    Dim myAppointments  As Object 'Outlook.Items
    Dim myRestrictItems As Object 'Outlook.Items
    Dim myAppItem       As Object 'Outlook.AppointmentItem

    Rem Used both for CONTACTS and APPOINTMENTS
    Dim objItems        As Object 'Outlook.ItemProperties
    Dim objItem         As Object 'Outlook.ItemProperty
#End If

Come vedete abbiamo inserito delle doppie dichiarazioni che saranno utilizzate, le une o le altre, a seconda della valore indicato alla riga
#If EarlyBinding = 1 Then

Ora, dato che noi abbiamo impostato questo valore su 1 (figura 1) sarà utilizzata la modalità Early-Binding.
Ciò ci permetterà di sfruttare comodamente l'intellisense di VB6 quindi avere sotto mano tutti gli oggetti e metodi di Outlook e relativa sintassi digitando il punto dopo la nostra variabile oggetto myOlApp:

myOlApp.

Probabilmente avete già capito: quando il progetto sarà compilato ed eseguito stand-alone il valore di EarlyBinding sarà sempre 0 (perchè non c'è più l'IDE di VB6 a valorizzarla in automatico) per cui le variabili oggetto dichiarate saranno quelle As Object.

Addesso occorre un secondo passo: dopo averle dichiarate occorre istanziarle in modo corretto. per cui nell'evento Form_Load() faremo più o meno la stessa cosa, ma questa volta useremo una proprietà dell'oggetto Application: App.LogMode

Private Sub Form_Load()

    If App.LogMode = 1 Then ' sta eseguendo l'EXE (compilato)
        ' uso il Late-Binding

        Set myOlApp = CreateObject("Outlook.Application")
    Else ' sta eseguendo il progetto nell'IDE
        ' uso l'Early-Binding

        Set myOlApp = Outlook.Application
    End If

    ' se sul computer non esiste Outlook avvio la chiusura del form
    If myOlApp Is Nothing Then
        GoTo OUTLOOK_NOT_FOUND
    End If

    ' Outlook esiste, per cui posso istanziare anche gli altri oggetti.
    Set myNameSpace = myOlApp.GetNamespace("MAPI")

    Set myAppointments = myNameSpace.GetDefaultFolder(olFolderCalendar).Items
    Set myContacts = myNameSpace.GetDefaultFolder(olFolderContacts).Items


    Exit Sub

OUTLOOK_NOT_FOUND:
    Timer1.Enabled = False ' Esce dall'applicazione
End Sub

Come vedete, non è poi così difficile.

Il vantaggio di non dover modificare niente per 'commutare' tra le due modalità (early e late) non è di poco conto per lo sviluppatore che in pratica non deve curarsi di nulla, se non quella di migliorare la propria applicazione.

A questo punto può essere spontaneo domandarsi se lasciare attivo il riferimento alla libreria di Outlook 2007 (v.12.0) non crei problemi nel caso si esegua il programma su un computer in cui è installata una versione diversa.
No, non crea alcun problema per il semplice fatto che nell'eseguibile l'oggetto Outlook.Application non sarà né dichiarato, né istanziato direttamente ma sempre e solo tramite la CreateObject().

Ultima nota importante: le costanti esposte da Outlook.
Quando il programma sarà compilato (EXE) le costanti di Outlook non sono più visibili perchè esse sono legate direttamente all'oggetto referenziato della libreria nel progetto. 
Ovviamente, non essendoci più un riferimento esplicito a tale libreria il programma eseguibile non è in grado di accedervi, per cui è assolutamente necessario dichiarare nel progetto tutte le costanti utilizzate. Esempio:

Rem Outlook constants:
Public Const olMailItem = 0
Public Const olAppointmentItem = 1
Public Const olContactItem = 2
Public Const olTaskItem = 3
Public Const olJournalItem = 4
Public Const olNoteItem = 5
Public Const olPostItem = 6
Public Const olDistributionListItem = 7
Public Const olFolderDeletedItems = 3
Public Const olFolderOutbox = 4
Public Const olFolderSentMail = 5
Public Const olFolderInbox = 6
Public Const olFolderCalendar = 9
Public Const olFolderContacts = 10
Public Const olFolderJournal = 11
Public Const olFolderNotes = 12
Public Const olFolderTasks = 13
Public Const olFolderDrafts = 16

Sarebbe superfluo farlo, ma ricordo che le costanti devono essere sempre accessibili (scope) quindi consiglio di dichiararle Public in un modulo BAS, oppure impostare un enumerazione, oppure creare una classe, fate voi;
l'importante è che siano sempre accessibili altrimenti quando eseguite il programma compilato i risultati saranno inaspettati.

 

 


 Tisk   
Copyright (c) 2002-2019 Giorgio Brausi   Podmínky používání  Prohlášení o soukromí
DotNetNuke® is copyright 2002-2019 by DotNetNuke Corporation