LEGGETE ANCHE GLI ARTICOLI!!! L’ultimo al link:

http://blog.shareoffice.it/giannigiaccaglini/articles/10324.aspx

I bachi inattesi? Colpa della Semantica, signori miei...

Questo post, frivolo nell’esemplificazione che darò, pretende in modo alquanto serioso di discutere su un problema che affligge l’Informatica e non solo. Parlo della Semantica, disciplina linguistica che si occupa del significato di un testo, meaning in inglese. Di sfuggita cito solo un interrogativo provocatorio (che riprendo – se non ricordo male - dal ponderoso trattato di Semiotica generale di Umberto Eco): The meaning of the meaning che diavolo è?

In due parole, alla buona, la faccenda ha a che fare - nella vita o peggio ancora nella giurisprudenza - coi molti fraintendimenti derivanti dalla più o meno evitabile divaricazione fra i significati letterali e quelli intenzionali (cosiddetti). In gergo semiotico si tenta una distinzione fra denotazione e connotazione di un messaggio.

Venendo allo specifico dell’Informatica sono noti i fallimenti di certi settori avanzati. Tipicamente l’Intelligenza Artificiale (IA) o un suo figliolo, la traduzione automatica. L’IA ogni tanto viene ri-chiamata in ballo ma oggi dei tanto celebrati Sistemi Esperti quasi nessuno parla più. La seconda da qualche tempo partorisce qualche topolino non del tutto privo di utilità, però ognuno di noi ha quotidianamente modo di ridacchiare di fronte a certi risultati del pur potente traduttore di Google...

Il frivolo esempio: ruotine eliminare cifre da una stringa

Appartiene all’autobiografia recente. Volevo una routinetta volta a eliminare i caratteri numerici da una stringa. Ed ecco una serie di tentativi infruttuosi di specifiche Sub, prima in VBA poi in Visual Basic 2008, che ho corredato con istruzioni messaggistiche opportune per facilitarne l’esecuzione passo dopo passo a chi legge.

Prima versione

Sub EliminaCifre()

    Dim MiaStr As String, Car As String, i As Integer

    MiaStr = "Amba12raba2345cicci178"

    For i = 1 To Len(MiaStr)

        Car = Mid(MiaStr, i, 1)

        If IsNumeric(Car) Then

            MiaStr = Replace(MiaStr, Car, "")

        End If

        MsgBox("i = " & i & vbLf & "Car = " _

        & Car & vbLf & "MiaStr = " & MiaStr)

    Next

    MsgBox(("Stringa finale: " & MiaStr)

End Sub

Lanciando la procedurina si notano due stranezze inattese (per gente ingenua come molti di noi siamo):

• non tutte le cifre vengono eliminate e l’MsgBox conclusivo proclama “Stringa finale:  ambaraba34cicci8”;
• il ciclo va avanti fino a i = 22 (la Len iniziale della stringa), indicando caratteri vuoti (blank) negli ultimi passaggi.

Dopo riflessione mi sono reso conto che il guaio deriva dal fatto che lunghezza della MiaStr diminuisce di un’unità ad ogni rimpiazzo di una cifra con “” (Replace(MiaStr, Car, “”). La pezza (patch) è presto trovata.

Seconda versione

Sub EliminaCifreBIS()

    Dim MiaStr As String, Car As String, i As Integer

    MiaStr = "Amba12raba2345cicci178"

    For i = 1 To Len(MiaStr)

        Car = Mid(MiaStr, i, 1)

        If IsNumeric(Car) Then

            MiaStr = Replace(MiaStr, Car, "")

            i = i - 1

        End If

        MsgBox ("i = " & i & vbLf & "Car = " _

        & Car & vbLf & "MiaStr = " & MiaStr)

    Next

    MsgBox ("Stringa finale: " & MiaStr)

End Sub

L’aggiunta, evidenziata in giallo, è semplicemente la correzione i = i - 1 ogni volta che una cifra è rimpiazzata. Ci potremmo accontentare, visto che il risultato ora è corretto, anche se resta la seconda anomalia.

Da queste come da altre esperienza si evince facilmente il principio enunciato in apertura, che nel caso del software, tradurrei nella legge seguente:

In Informatica è la Semantica lo scoglio in cui s’infrangono molti prodotti, a causa della discrasia non sempre evitabile fra l’intenzionalità dell’uomo e la fredda, inesorabile logica letterale della macchina.

Visual Studio 2008: mondo nuovo, altra sorpresa

In tale ambiente ho poi testato il precedente programmetto. Funzionava, ma poi pur non essendo un benpensante ho... ben pensato di sostituire Car As String con Car As Char (non supportato in VBA o VB6) più moderno e logico, visto che si tratta di un singolo carattere. Già che c’ero, ho approfittato della possibilità di accedere con un indice a ciascun carattere di una stringa, con Car = MiaStr(i).

Terza versione (VB 2008)

Sub EliminaCifre()

    Dim MiaStr As String, Car As Char, i As Integer

    MiaStr = "Amba12raba2345cicci178"

    For i = 0 To Len(MiaStr) - 1

        Car = MiaStr(i)

        If IsNumeric(Car) Then

            Mid(MiaStr, i, 1) = Replace(MiaStr, Car, "")

            i -= 1

        End If

        MessageBox.Show("i = " & i & vbLf & "Car = " _

        & Car & vbLf & "MiaStr = " & MiaStr)

    Next

    MessageBox.Show("Stringa finale: " & MiaStr)

End Sub

Tutto bene? Macché. L’illusione semantica stavolta naufraga in modo, come sempre, inatteso. Infatti non si procede con tutti i 22 giri del loop For i = 0 To Len(MiaStr) ... Next in quanto ahimè il programma si arresta per errore a run-time sulla tanto ammirata istruzione moderna Car = MiaStr(i), con indicazione di indice fuori dai limiti.

Riflettendo adeguatamente comprendiamo che:

• il ciclo For... To Next del Visual Basic (a differenza di altri linguaggi, credo) valuta una tantum l’espressione all’inizio e ne mantiene il valore in tutto il suo corso (in altri casi questa è una virtù, ma qui ci crea un guaio);
• Mid(MiaStr, i, 1) è permissivo al punto di non dare errore se l’indice va fuori della stringa (semplicemente restituisce un blank); al contrario di Car(i), che invece considera la stringa come un vettore di caratteri.

Soluzione finale

Ne riporto il nocciolo, astenendomi dal commentare altre varianti “moderne”, dicendo solo che alla fine ho adottato un ciclo While ... End While (While... Wend in VBA/VB6) che è immune dalla persistenza della lunghezza imputabile a For... Next e, pertanto, fa sì che MiaStr.Length muti dinamicamente ad ogni giro dell’anello.

   Dim i = 0

   While i < MiaStr.Length

       Car = MiaStr(i)

       CodCar = Char.ConvertToUtf32(Car, 0)

       If Not (CodCar < 48 Or CodCar > 57) Then

           MiaStr = MiaStr.Replace(Car, "")

           i -= 1

       End If

       i += 1

   End While

Il Ribbon personalizzabile di Office 2010

Questa interessante novità si offre come alternativa per utenti “normali” rispetto al sistema di personalizzazione avanzata della barra multifunzione, che, ricordiamo, richiede la creazione a parte di appositi file customUI.xml.

Per consentirne lo studio ho preparato un file PDF, che si può scaricare da:

http://www.giannigiaccaglini.it/download/Nuovo%20Ribbon2010Personalizzabile.pdf

Buona lettura.

Considerazioni fuori programma (rispetto alle macro e all'IT)

Sperando di non disturbare la suscettibilità o la commiserazione di chicchessia, mi permetto alcune osservazioni spicciole su tre celebri antinomie (senza pretesa di essere esaustivo né di aver fatto scoperte originali o peggio di non commettere errori).

Premetto che i vari casi mi paiono afflitti da un limite della logica, almeno “normale” (ossia degli Enunciati) quando pretende di considerare il tempo...

ACHILLE E LA TARTARUGA

Considerare unità di tempo piccole a piacere è legittimo, ma non lo è aggiungerne di sempre più piccole concludendo con MAI. Infatti nel primo caso, per quanto piccoli siano gl’intervalli temporali Achille supererà di certo la tartaruga in un numero finito di essi.

IL CRETESE

Non è possibile, per coerenza, che un perfetto mentitore dica “tutto quel che dico è falso”, potrà semmai affermare “tutto quel che dico è vero”. Dopo di che, sospettato ingiustamente di un  delitto capitale risponderà sì alla domanda “Sei tu il colpevole?”, senza la soddisfazione di poter affermare, sul patibolo, “Muoio per amore della Menzogna!”. [O forse “Muoio per amore della verità” è un’antinomia? Boh].

IL BARBIERE

L’editto “Il barbiere deve radere tutti quelli che non si fanno la barba da soli” presenta almeno un’ambiguità: è lecito farsi radere da un altro? Immaginiamo che alla specifica richiesta di chiarimento – come sempre accade nelle norme giuridiche o assimilabili che richiedono interpretazioni “autentiche” sullo spirito di una legge – il Sovrano cambi la dizione in “Tutti gli abitanti si debbono radere da soli o farsi radere dal barbiere”, che, senza chiarire esplicitamente che cosa deve fare il barbiere,  esclude la possibilità di ricorrere ad altri che non sia il barbiere. A parte il fatto che resta oscura e comunque ardua la possibilità di sanzione, esclusa la fragranza (ma se uno è sbarbato che si fa?), e tralasciando l’ipotesi di un barbiere eunuco o femmina, il punto a mio avviso è che il barbiere ha un duplice ruolo: cittadino e funzionario-barbitonsore (senza essere schizofrenico: tutti hanno ruoli molteplici in un consesso sociale). E scegliendo di radersi da solo, come cittadino, subito DOPO toglie a se stesso, cioè al barbiere, il compito di farlo.

CIRCUITI LOGICI SEQUENZIALI

Mi permetto di insistere coi Logici puri (che finora non mi hanno dato retta...). I circuiti logici sequenziali (elettronici o, persino, implementati con relè e contatti) hanno un comportamento che varia nel tempo, presentando cioè una isteresi appunto temporale. Ne sono esempi noti anche a chi ne ignora le connessioni (di tipo feedback) i circuiti memoria (come i flip-flop) o gli oscillatori. I tecnici per descriverli e progettarli adottano una particolare – ma semplice nei casi elementari - Algebra booleana, in cui sono in gioco NEGAZIONI delle uscite riportate in input. Ad esempio con un X  = not Y ove X e Y sono, rispettivamente l’input e l’output si ottiene sulla carta ma anche di fatto un oscillatore di periodo pari al tempo che separa Y e X.

Dunque “in natura” le antinomie sono di fatto risolte. O no?

Buon 2010 !

P.S. – Aggiungo che l’astrattezza della logica rispetto alla lebenswelt (mondo della vita) si fa sentire anche in altri contesti ove siano in gioco verbi riflessivi. Provare per ridere, con “sputarsi” o, peggio, con “masturbarsi”. O, in genere, con verbi che ammettono solo forma riflessiva...

Nasce Wpfitalia.it, dedicato all’affascinante tecnologia WPF

Dedicare un intero sito a una particolare tecnologia del vasto mondo Visual Studio .NET è senz’altro una scommessa. La compie con una certa dose di temerarietà un gruppo di amici Renato Marzaro, Antonio Catucci e Alessandro Del Sole, noto MVP Microsoft autore di molti libri su vari ambienti .NET (in particolare su LINQ, altra tecnologia emergente di Microsoft per accesso “dichiarativo” in stile SQL-like alle più varie fonti dati, relazionali o XML) nonché animatore e leader del popolare sito Visual Basic Tips & Tricks (www.visual-basic.it ).

Anche il neonato www.wpfitalia.it ne è figlio, tant’è vero che il suo nome esteso è guarda caso WPF Italia Tips & Tricks, e nasce per così dire con la camicia, ricco come si presenta da subito di chiari articoli e video dedicati.

WPF in due parole

WPF ovvero Windows Presentation Foundation è una speciale tecnologia creata da Microsoft, che in soldoni consente di implementare l’equivalente multimediale delle classiche finestre di dialogo (Windows Form) che a regime rischiano l’obsolescenza a vantaggio del nuovo WPF, dato il suo aspetto decisamente più accattivante esteticamente e, a un tempo, più agevole da personalizzare.

Prima di illustrarne i caratteri salienti va detto che non si tratta di una novità assoluta, visto che WPF è già supportato in Visual Studio 2008. Il fatto è che il mercato come spesso capita con le novità rivoluzionarie non ha fin qui aderito come merita al nuovo verbo. Ma – assicura lo scommettitore Alessandro – vi sono segnali incoraggianti di un interesse crescente, inoltre l’imminente versione 2010 ha potenziato in modo significativo WPF (con riferimento anche all’ultimo sistema operativo Windows 7).

Tornando a bomba, con WPF si possono creare applicazioni dall'interfaccia grafica avanzata, con utilizzo efficace e, insieme, relativamente semplice di ogni tipo di componenti multimediali: immagini anche 3D, grafica business, animazioni a iosa.

Le applicazioni ottenibili sono di ogni genere, sia gestionali (trattamento di dati o documenti), che di intrattenimento. La base è data dalle librerie grafiche DirectX di Microsoft, incluse la grafica 3D e la grafica vettoriale nonché molte innovazioni specifiche di Windows Vista e Windows 7.

Primi passi in WPF. Il linguaggio XAML

Entrare nel nuovo mondo è immediato. Come al solito, basta nell’IDE Visual Studio dare un clic sull’icona specifica Applicazione WPF per rendersi subito conto della novità architetturale più rilevante:

Figura 1

Sono subito evidenti due parti. Si tratta, in verità, di due finestre distinte che per default sono esibite sovrapposte, data la loro stretta correlazione. Nella prima, che corrisponde grossomodo a una normale Windows Form, si possono inserire persino controlli tradizionali ma anche, e più vantaggiosamente, elementi moderni di tipo multimediale anche spinto. Agli uni e agli altri si possono associare routine d’evento tradizionali (più o meno? Scopritelo gente...) come Click, DoubleClick e quant’altro.

Più rilevante, concettualmente, la parte inferiore. Scritta nel nuovo linguaggio di markup XAML (eXtensible Application Markup Language), un derivato dello standard XML creato interamente da Microsoft, permette di descrivere nei minimi dettagli l’aspetto della finestra soprastante, inclusi i vari oggetti incorporati e altri aspetti come una griglia che ne definisce la suddivisione.

Detto en passant, si fa apprezzare una particolare, razionale struttura “a stack” dei vari componenti.

L’idea alla base corrisponde appieno al moderno principio di separare l’aspetto descrittivo da quello esecutivo, affidando il lavoro almeno nei casi più avanzati a due attori distinti: il designer e l’informatico. Anche il secondo, che ha l’esclusiva del codice, nelle situazioni ordinarie può disporre di nuovi strumenti che passa il convento .NET (a partire da un efficace intellisense nella sezione XAML e non solo) mentre il “creativo” può lavorare con più variegati tool artistici.

Come si comprende è un salto di qualità rispetto al modus operandi con le Windows Form, ove tutto è affidato allo sviluppatore tramite codice, anche per quanto riguarda gli aspetti grafici. I più bravi, e pazienti!, se la cavano con grande fatica, ma la maggioranza produce finestre alquanto grigie se non anonime.

La figura seguente (tratta, come la precedente dal primo tutorial su Wpfitalia di A. Del Sole) illustra un primo frutto semplice ma eloquente delle potenzialità di WPF, ottenuto da Alessandro con pochi clic.

Figura 2

Ma risultati davvero eclatanti si possono ottenere con questa tecnologia. Per averne un’idea si provi ad accedere alla British Library on-line

http://ttpdownload.bl.uk/app_files/xbap/BrowserApp.xbap

che la sfrutta davvero efficacemente, come mostra la figura che da lì abbiamo rubato:

Figura 3

Ma questa è solo una recensione, pertanto ci fermiamo qui. D’altronde gl’interessati all’approfondimento non hanno che da visitare Wpfitalia.it ove i contributi tutoriali abbondano fin d’ora (e anche su MSDN sono tutt’altro che scarsi).

Interessante infine, per i visitatori di Shareoffice che se ne occupano, il fatto che anche nelle applicazioni VSTO (Visual Studio Tools per Office) è possibile fruire di queste nuove interfacce anziché delle solite Windows Form. Non c’era da dubitarne, comunque segnaliamo due post di A. Del Sole a ciò dedicati:

http://community.visual-basic.it/alessandro/archive/2009/01/12/24583.aspx

http://community.visual-basic.it/alessandro/archive/2008/02/18/22010.aspx

Un utile libro introduttivo

Alessandro del Sole ha svolto opera di pioniere, parlando di WPF in corposi capitoli del seguente manuale, relativo a Visual Studio 2005/2008:

Alessandro Del Sole

PROGRAMMARE CON .NET FRAMEWORK 3.X

Ed. FAG Milano

http://www.fag.it/scheda.aspx?ID=21753

Pensiamo di raccomandarlo a quanti sono desiderosi di intraprendere l’affascinante avventura WPF.

Ambiguità sematica del ciclo For Each?

Anche questa è una divagazione di mezza estate. Riporto quasi pari pari il carteggio fra me e Francesco Balena.

Una cosuccia strana non scritta da nessuna parte. Il ciclo For Each... Next si direbbe che funzioni solo IN LETTURA, come nello snippet seguente:

Sub Main()

  Dim MiaLista As New List(Of Integer)

  Dim V() As Integer = {1, 2, 3, 4, 5}

  For i = 0 To UBound(V)

    MiaLista.Add(V(i))

  Next

  For Each el As Integer In MiaLista

    el *= 2 ' Accolta “sulla carta”, ma senza REALI conseguenze

  Next

  For Each el As Integer In MiaLista

    Console.WriteLine(el) ' Continua a indicare 1, 2, 3, 4, 5

  Next

  Console.WriteLine()

  ' Solo con gl’indici le cose vanno bene:

  For i = 0 To MiaLista.Count - 1

    MiaLista(i) *= 2

  Next

  For Each el As Integer In MiaLista

    Console.WriteLine(el) ' Indica 2, 4, 6, 8, 10

  Next

  Console.ReadLine()

End Sub

La stessa delusione di aspettative (ingenue?) si ha con le matrici, del tipo Dim (V).

Qualcuno avrà l’onestà di ammettere che non lo sapeva? Forse e, magari, i più esperti (per lo più dimentichi di segnalare la cosa all’inclita e al volgo) forniranno dotte delucidazioni.

Ma attenzione! Non è finita. Infatti con le Liste (e simili) di OGGETTI le cose funzionano come ci si attende:

Module Module1

  Class Persona

    Public Nome As String

  End Class

  Sub Main()

    Dim VettNomiPers() = {"Ciccio", "Maria", "Luigi", "Paola"}

    Dim Persone As New List(Of Persona)

    Dim i As Integer = 0

    Dim UnaPersona As New Persona

    ' Carica VettNomiPers nella lista Persone

    For Each NomePers As String In VettNomiPers

      UnaPersona.Nome = NomePers

      Persone.Add(UnaPersona)

      UnaPersona = New Persona

    Next

    For Each UnaPersona In Persone

      Console.WriteLine(UnaPersona.Nome) ' => "Ciccio", "Maria" ecc.

      UnaPersona.Nome = "Ciao" ' => "Ciao"

      Console.WriteLine(UnaPersona.Nome)

    Next

    Console.WriteLine()

    Console.WriteLine("LISTA MODIFICATA:")

    For Each UnaPersona In Persone

    Console.WriteLine(Persone(i).Nome) ' => Tutti Ciao

    Next

    Console.ReadLine()

  End Sub

End Module

NOTA – Funzionamento OK anche con ciclo finale indicizzato (ovvio) e con modifiche apportate a un eventuale campo numerico.

Come utenteilmente segnalerei la presenza di un problema semantico, con l’aggravante della contraddizione indicata nell’ultimo esempietto.

Do not forget, anyway.

LA (GIUSTA) REPLICA DI FRANCESCO BALENA:

Mi dispiace deluderti, ma questa feature è ben documentata. Basta andare a leggere il manuale ufficiale del linguaggio:

http://msdn.microsoft.com/en-us/library/5ebk1751.aspx

Modifying Collection Elements. The Current property of the enumerator object is ReadOnly (Visual Basic), and it returns a local copy of each collection element. This means that you cannot modify the elements themselves in a For Each...Next loop. Any modification you make affects only the local copy from Current and is not reflected back into the underlying collection. However, if an element is a reference type, you can modify the members of the instance to which it points. The following example illustrates this.

Il fatto che “sembri” funzionare con gli oggetti è una pura illusione, derivante probabilmente da un equivoco abbastanza comune tra i programmatori. Nel tuo esempio tu non modifichi la variabile “el” ma modifichi l’N-esimo elemento della lista a cui “el” punta. Non è un dettaglio da poco, anzi fa tutta la differenza.

Volendo fare una analogia, “el” è l’indirizzo fisico di un negozio con vetrina e ingresso, che oggi contiene un fruttivendolo. “el” è a sola lettura e infatti il numero civico di quella vetrina non cambierà mai, ma il contenuto di quel negozio può liberamente cambiare ed ospitare ad esempio una farmacia. Non a caso, si dice che una variabile “punta” a qualcosa, non che “contiene” qualcosa.

[ Per la cronaca, resta il fatto che in quasi nessun altro posto ho trovato queste precisazioni, comunque da NON obliare, anzi il più delle volte si lascia credere che For Each e For i = 0 To siano equivalenti... Beh dipende... ]

Un paio di divagazioni estive

Svolte in contatto, a volte un po’ tempestoso ma sempre proficuo, con preclari esperti d’Informatica, come il ben noto Francesco Balena e il ben informato Diego Cattaruzza, solerte redattore capo dell’ottimo sito Visual Basic Tips & Tricks (che mi ha onorato ospitando miei articoli).

La prima: obsolescenza delle vecchie funzioni VB6 (cum grano salis, anzi due). Si riferisce a un vizietto abitudinario di cui, confesso, sono afflitto anch’io come quelli che operano prevalentemente in ambito VBA, ergo VB6. Informo chi non lo sapesse che dal VB .NET in avanti le vecchie, care funzioni VB6 – come Asc, Chr e le altre di trattamento stringhe, o l’inattesa Ubound per il limite superiore di una matrice – vanno considerate obsolete e “moralmente” da sostituire, ad esempio, con la proprietà Lenght. Esempio:

' Vecchia versione:

For i = 0 To Ubound(MiaMatr)

' Versione moderna

For i = 0 To MiaMatr.Lenght - 1

Per chi vuole aggiornarsi (cosa che ovviamente, con Office, riguarda i VSTO e non le normali macro VBA) indico un prezioso elenco stilato da Diego Cattaruzza:

Tabella funzioni da VB6 a VB .NET

( su http://www.visual-basic.it/areaarticoli.asp )

Che dire? Diego predica bene, anzi ha ragione, salvo un’osservazione e una strana eccezione:

• La libreria Visual Basic (delle vecchie funzioni) non solo è tuttora supportata fino a VB 2010 p.v. , ma lo è per default (con Francesco Balena che sembra sostenere che funzioni antiche sono a volte più prestanti);
• La funzione Mid è scomparsa in lettura ma continua a essere supportata anche disabilitando la libreria Visual Basic in scrittura

Esempi:

MioCar = Mid("Ambaraba", 5, 1) 'Non più supportata

MiaStr = "Ambaraba"

Mid(MiaStr, 5, 1) = "*" ' SUPPORTATO! (MiaStr diventa "Amba*aba”)

Nel corso dello scambio email un terzo guru di VB T&T sosteneva l’obsolescenza anche di Redim. Creando, involontariamente credo, un po’ di confusione in quanto tale parolina chiave non fa parte della libreria Visual Basic e, soprattutto, è viva e vegeta.

Per chiarire la vexata quaestio propongo la tabella seguente:

La novità espressa dalla seconda riga può indurre a pensare che Redim nel nuovo mondo non serva più. Non è esatto, ha richiamato Francesco, con l’esempio seguente:

Sub ExpandArray(ByRef arr() As Integer)

  ReDim arr(arr.Length * 2 - 1)

End Sub

In questo caso non si può sostituire Redim con Dim.

A mia volta mi permetto due ulteriori indicazioni. La prima è un richiamo alle variabili definite a livello modulo (Sezione Dichiarazioni). La seconda è l’ineludibile impiego di Redim Preserve in molte applicazioni dinamiche. L’esempio seguente completa l’osservazione di Francesco:

Module Module1

  Sub ExpandArray(ByRef Arr() As Integer)

    Dim Lung = Arr.Length

    ReDim Preserve arr(Lung * 2 - 1)

    For i As Integer = 0 To UBound(arr)

      If i >= Lung Then Arr(i) = i * i ' Quadrati nelle celle aggiunte

        ' MessageBox.Show (Arr(i)) ' Servita per debug

    Next

  End Sub

  Sub Main()

    Dim MioArr(3) As Integer

    For i As Integer = 0 To UBound(MioArr)

       MioArr(i) = i ' <= 0, 1, 2, 3

     Next

    ExpandArray(MioArr)

    For i As Integer = 0 To UBound(MioArr)

      MessageBox.Show(MioArr(i)) ' => 0, 1, 2, 3, 16, 25, 36, 49

    Next

  End Sub

End Module

SEGNALAZIONE UTILE. L'amico Emanuele (Mattei! chi altro potrebbe essere?) ha varato il sito professionale www.donetromacesta.org al quale ho pensato di offrire un piccolo contributo su Excel + VBA. Eccone il link:

Controlli e ActionPanes nei VSTO di Word

Incorporare controlli su un foglio di lavoro è una pratica accettabile, che tra l’altro ha il pregio dell’immediatezza, laddove sono posti accanto ai dati da elaborare con la macro (o il codice “managed” in ambiente VSTO, Visual Studio Tools per Office). Una controindicazione è, parlando in generale, il fatto che i controlli di tipo ActiveX e assimilati compaiono anche in stampa, né sembra possibile occultarli anche solo pro tempore. Si provi infatti la seguente macro, che ipotizza la presenza sul foglio di lavoro sia di controlli “classici” di Excel che di tipo ActiveX:

Sub NascondiSvela(Vis As Boolean)

   For Each Sh In Me.Shapes

    Sh.Visible = Vis

  Next

End Sub

Sub Stampa()

  NascondiSvela False

  Me.PrintPreview

  NascondiSvela True

End Sub

Come non ci vuol molto a capire la prima Sub al primo richiamo con Vis = False nasconde tutte le forme, inclusi i controlli ActiveX, anch’essi assimilati a Shapes e inclusi in tale insieme, mentre con Vis = True li visualizza tutti di nuovo. Pertanto l’istruzione centrale di anteprima (o di stampa tout court) dovrebbe essere corretta, giusto? Sbagliato. I controlli classici non sono stampati ma quelli ActiveX anche se messi fuori vista vengono di fatto stampati.

Tuttavia l’inconveniente può essere ovviato (o inesistente) in Excel, dove esistono più fogli di lavoro, basta che i dati da stampare si trovino su un foglio (ad esempio riepilogativo) esente da controlli incorporati.

Il caso Word (con difficoltà iniziali varie)

La situazione è meno felice in Word, ove il documento è unico, soprattutto perché qui non esistono i controlli-classici di Excel, ma soltanto gli ActiveX. Non occultabili a monte della stampa, come già visto con Excel. La situazione appare imbarazzante quando si lavora nel mondo VSTO. Una soluzione brutale l’avrei anche trovata e la riporto in fondo al presente post, ma non pare troppo soddisfacente. Prima di proseguire trovo importante una premessa. I VSTO tradiscono diverse aspettative per chi pensa di ottenerne una sorta di applicativi office-oriented. Ecco i punti più imbarazzanti:

• In Excel, il mancato supporto di funzioni d’utente (UDF, User Defined Function) implementate con codice .NET;
• In Word, all’impossibilità di associare a routine scorciatoie di tastiera – comode e “naturali” visto che la digitazione qui regna sovrana - si unisce l’assenza di tali routine nel modulo Normal.dot, che ne consente l’utilizzo con qualunque documento.

In questi casi (e altri di cui non mi sovviene) l’imbarazzo deriva dal fatto che tali preziose funzionalità restano possibili con il buon vecchio sistema di macro VBA anche con un “applicativo” VSTO. Ma in tal modo la security del managed code va un poco a farsi benedire. O no?

Rimanendo a quel che passa il convento Word VSTO, che strumenti ci offre per ottenere un qualche MioDoc.xlx che abbia un minino di valenza applicativa, magari “dedicata” e semichiusa? A dire il vero, le possibilità sono notevolissime, basti pensare al trattamento di archivi Open XML su disco con la specifica API SDK 1.0 + LINQ o la nuova SDK 2.0 “strongly typed”. Prossimamente conto di offrirne almeno un esempio, in cui un intervallo o una tabella Excel vengono importati nel documento Word. Ma la domanda cruciale è la seguente:

Come lanciare in modo semplice funzionalità del genere?

Confesso che all'inizio non ho avuto modo né tempo per esaminare soluzioni avanzate, in primo luogo un Ribbon opportunamente personalizzato. Fra le “semplici” evocate testé dalla domanda comincio con l'annoverare due possibilità:

Ø  Controlli ActiveX incorporati in cima al documento, tipicamente un paio di pulsanti, Button1 e Button2;

Ø  La finestra Azione documenti (Actions pane).

Il secondo metodo si presenta più allettante, in quanto tale pannello si colloca alla destra del documento e promette di scatenare le azioni da noi desiderate evitando di incorporare alcunché nel documento. Ma qui cominciano le dolenti note, almeno in prima battuta (per fortuna, in fondo al post c'è il lieto fine):

1)      Non è possibile caricare l’Actions pane nell’IDE VSTO di Word, lo si può fare solo con il Word “normale”;

2)      esso non viene in alcun modo “visto” da macro VBA, contrariamente a quel che avviene nel mondo VSTO.

3)      Nel Word normale non c’è alcun verso di inserire controlli nell’Actions pane, mentre l’operazione si direbbe consentita in ambiente VSTO, perché all'inizio non si riesce a farlo (ma il modo esiste, v. alla fine!)

Le operazioni di cui al primo punto sono tediose e per pigrizia non le riporto in dettaglio. Dico solo che si parte col pulsante Office, attivando Opzioni di Word... quindi Componenti aggiuntivi ecc. Dopo di che per visualizzare il sospirato pannello si agisce sulla scheda Sviluppo seguita da Pacchetti di espansione e via di seguito, operazioni queste fattibili pure nei VSTO (ma che confusione, non è vero?).

Un po’ di codice managed

Nei VSTO di Word tutte le routine, di regola, sono racchiuse nella classe ThisDocument. Per non scontentare impazienti e frettolosi riporto subito i miei primi tentativi esplorativi, riusciti.

Public Class ThisDocument

    Private Sub ThisDocument_Startup(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Startup

        If MessageBox.Show("Cucù, sono " & Me.Name & _

         vbLf & "Due più due = quattro?", , MessageBoxButtons.YesNo) _

         = DialogResult.Yes Then

            MsgBox("Bravo! Sette più")

        End If

        ActiveWindow.ActivePane.View.Zoom.Percentage = 100

        ActionsPane.Show()

    End Sub

    Private Sub ThisDocument_Shutdown(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Shutdown

    End Sub

    Private Sub ActionsPane_Click(ByVal sender As Object, ByVal e As System.EventArgs) Handles ActionsPane. Click

      MsgBox("Action pan cliccato!")

    End Sub

    Private Sub ActionsPane_DoubleClick(ByVal sender As Object, ByVal e As System.EventArgs) Handles ActionsPane.DoubleClick

        MsgBox("Hai dato un doppio clic sull'ActionsPane. Bravo!")

    End Sub

    Private Sub ActionsPane_MouseDoubleClick(ByVal sender As Object, ByVal e As System.Windows.Forms.MouseEventArgs) Handles ActionsPane.MouseDoubleClick

        MsgBox("Hai dato un doppio clic. Bravo!")

    End Sub

    Private Sub Button1_Click(ByVal sender As Object, ByVal e As System.EventArgs) Handles Button1.Click

        MsgBox("Bubbusette!")

    End Sub

    Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button2.Click

        MsgBox("Bubbuotto!")

    End Sub

End Class

Premesso che in testa al documento erano stati inseriti due controlli Button (scegliere nella sezione Controlli comuni o anche Windows Form), le routine messaggistiche ad essi abbinate sono banali, anzi ridicole. Più interessante la Sub dell’evento ThisDocument_Startup ovviamente equivalente alla Document_Open di Word normale entrambe scatenantesi al caricamento del documento. Interessanti e, come ripeto, possibili solo coi VSTO non tanto le prime istruzioni di squallido umorismo bensì le ultime due, entrambe richieste per visualizzare il sospirato riquadro di cui si parla. Richieste e, direi, indispensabili affinché abbiano concreto utilizzo le altre, relative a due degli eventi dell’oggetto ActionsPane. Questi sono una vera caterva, come è facile scoprire.

Io mi sono limitato ai tre più semplici, abbinando a ciascuno stupidissimi messaggi. Mi sarei anche accontentato di surrogare con essi –nell’incapacità autolesionisticamente ammessa di inserire controlli nel fatidico pannello – un paio di funzionalità magari anche potenti & evolute. Purtroppo si incappa in altre due non del tutto piacevoli sorprese:

• L’evento Click predomina sugli altri due, e li “oscura”per cui, volendoli usare occorre rinunciare al Click;
• In compenso gli altri due sono sinonimi per cui una doppia cliccata li scatena entrambi, uno di seguito all’altro (questo punto non è grave né del tutto inatteso, resta solo la domanda sul motivo per cui un medesimo evento abbia due nomi distinti, sottigliezza che non sono in grado di comprendere...).

Rimanendo nel quadro dei tentativi iniziali ecco poi, sotto forma di macro VBA, il codice brute-force per evitare di stampare i due pulsanti ipotizzati in cima al documento, nelle sue prime due righe:

Sub MiaStampa()

  Selection.HomeKey Unit:=wdStory

  Selection.MoveDown Unit:=wdLine, Count:=2, Extend:=wdExtend

  Selection.Cut

  MsgBox "Adesso stampo!"

  . . .  istruzioni di Stampa . . .

  Selection.Paste

End Sub

La brutalità dipende dal taglio (Cut) delle prime due righe, previa selezione delle medesime e, con esse, dei due bottoni. Niente paura, perché a valle della stampa essi vengono re-incollati (Paste)assieme alle due righe. Addirittura la routine funziona anche se evocata da uno dei pulsanti. Provare per credere con:

Private Sub CommandButton1_Click()

  MiaStampa

End Sub