Caselle di testo dinamiche inserite in un UserForm

Recentemente mi è stata posta questa domanda: “Si può inserire in una UserForm un numero variabile, fissato a run-time (magari tramite opportuna macro VBA) di caselle di testo?” La richiesta è inusuale, visto che il più delle volte una UserForm viene definita al tempo di progetto. Con un po’ di pazienza, frugando nella Guida dell’Editor VBA, ho trovato la risposta, di cui riporto un tipico esempio in fondo a questo post. Adattandolo al caso che tormentava il nostro amico ho escogitato una prima macro di test, sull’evento Click dell’unico pulsante di una UserForm1, per il resto vuota di altri controlli:

Private Sub CommandButton1_Click()

    Dim miaTxtBox As Control

    Set miaTxtBox = Controls.Add("Forms.TextBox.1", "miaCasella", True)

    With miaTxtBox

      .Left = 18

      .Top = 150

      .Width = 175

      .Height = 20

    End With

    Me.Controls("miaCasella").Value = InputBox("Scrivi...")

End Sub

L’istruzione basilare, grassettata, ha la seguente sintassi:

Controls.Add(“<Tipo ctrontrollo>”, “Nome”,

E ha l’effetto di aggiungere (metodo Add) all’insieme dei Controls una TextBox definita come “Forms.Textbox.1” – mentre analoghe sintassi valgono per altri controlli come il "MSForms.CommandButton.1” esemplificato dalla Guida e altri di pari eloquenza. Il terzo argomento va prudentemente posto a True assicurando la visibilità della neonata casella impostata nella MiaTxtBoz (di tipo Control, ovviamente). Dopo di che a MiaTxtBox sono assegnati, dinamicamente, proprietà relative al posizionamento e alle dimensioni e, infine, vi viene inserito il valore stabilito dall’utente in risposta a una InputBox.

Come i più svegli subito notano nell’ultima istruzione si ricorre, in alternativa a miaTextBox, al nome “miaCasella”, secondo nome facoltativo di Controls.Add.

Se poi si vuole lanciare la UserForm1 non resta che lanciare una macro bene nota come questa:

Sub UserFormDinamica()

   Load UserForm1

   UserForm1.Show

End Sub

Una variante appena un po’ più elaborata è la seguente, che crea ben due (“e regali..”, dicono a Livorno) casellineficcandovi due scemenze:

Dim CaselleAggiunte As Boolean

Private Sub CommandButton1_Click()

  If Not CaselleAggiunte Then

    Me.Controls.Add "Forms.TextBox.1", "Casella1", True

    Me.Controls.Add "Forms.TextBox.1", "Casella2", True

    With Me.Controls("Casella2")

      .Left = 50

      .Top = 50

    End With

    CaselleAggiunte = True

  End If

  Me.Controls("Casella1") = "ambarabà"

  Me.Controls("Casella2") = "Ciccì coccò"

End Sub

Il punto più rilevante è dato dalle istruzioni “creative” la cui sintassi è nata dalla scoperta che non occorre nessuna variabile per registrare il nuovo controllo, basta invocare il medoto Add  dell’insieme Controls dell’UserForm  corrente, ovvero Me.Controls.

Creazione dinamica di N casella all’apertura dell’UserForm

Dopo i precedenti esperimenti, torniamo all’esigenza iniziale ovvero, ricordate?, aggiungere un numero di TexBox definite di volta in volta. In tale prospettiva, si compiano le mosse seguenti:

1.       Creare un UserForm2

2.       Aggiungervi come prima un solo CommandButton1, magari dotato di Caption “Caselle dinamiche” in luogo del default “UserForm2”;

3.       Digitare la macro dell’evento Initialize:

Private Sub UserForm_Initialize()

  Dim i As Integer, N As Integer

  Dim NomeCasella As String

  Dim Cima As Integer

  N = Range("NumCaselle")

  Cima = 10

  Me.Height = N * 25 + 75

  CommandButton1.Top = Me.Height - 50

  ' If N > 10 Then N = 10 ' Limitazione num. caselle? Non serve col combo...

    For i = 1 To N

      NomeCasella = "Casella" & i

      Me.Controls.Add "Forms.TextBox.1", NomeCasella, True

      With Me.Controls(NomeCasella)

        .Left = 50

        .Height = 20

        .Width = 150

        .Top = Cima

      End With

      Cima = Cima + 25

    Next

End Sub

Commenti tacitiani. Il valore N è attinto da una cella del foglio di lavoro preliminarmente battezzata “NumCaselle”, ove l’utente dovrà stabilire appunto il desiato numero caselle. Il clou sta nel ciclo For i = 1 To N in seno al quale vengono via via fissato un NomeCasella pari a “ Casella” & i vale a dire “Casella1”, “Casella2” e così via. Il dimensionamento Me.Heigth dell’altezza del Form in modo da adeguarsi alle N caselle (ciascuna di altezza, Height, pari a 20) + 5 spazi tra le stesse è lasciato all’esegesi autogestita. Idem il posizionamento del Top del CommandButton1, sottostante alla N caselline ma senza sparire.

E la Sub dell’evento Click di quest’ultimo? Eccone una ipotetica, che segnala (MsgBox) i nomi delle N caselle create inserendovi man mano numeri casuali. Tanto per fare qualcosa, nei casi personali ognuno personalizzerà questa faccenda.

Private Sub CommandButton1_Click()

  Dim Ctrl As Control

  For Each Ctrl In Me.Controls

    If Left(Ctrl.Name, 7) <> "Command" Then

      Randomize

      Ctrl = Int(Rnd * 100000 + 100)

      MsgBox Ctrl.Name

    End If

  Next

End Sub

Concludo suggerendo, in luogo del controllo del numero massimo N = 10, un combo box sul foglio di lavoro associato alla predetta cella di nome”NumCaselle”.

Ultimissima variante

Consiste nell’omissione del secondo argomento di Controls.Add, nel qual caso la caselle di testo via via create assumono i nomi default o standard che dir si voglia “TextBox1” ,” TextBox2”, eccetera.

Private Sub UserForm_Initialize()

  Dim i As Integer, N As Integer

  Dim Cima As Integer

  N = Range("NumCaselle")

  Cima = 10

  Me.Height = N * 25 + 75

  CommandButton1.Top = Me.Height - 60

    For i = 1 To N

      Me.Controls.Add "Forms.TextBox.1", , True

      With Me.Controls(i)

        .Left = 50

        .Height = 20

        .Width = 150

        .Top = Cima

      End With

      Cima = Cima + 25

    Next

End Sub

L’esempio della Guida

Esempio dell'evento AddControl e del metodo Add

In questo esempio il metodo Add viene utilizzato per aggiungere un controllo a un form in fase di esecuzione. L'evento AddControl viene utilizzato per verificare se il controllo è stato aggiunto.

Per eseguire l'esempio, copiare il codice riportato di seguito nella sezione Dichiarazioni di un form. Verificare che il form contenga:

·         Un controllo CommandButton (CommandButton1).

·         Un controllo Label (Label1).

Dim Mycmd as Control

Private Sub CommandButton1_Click()

    Set Mycmd = Controls.Add("Forms.CommandButton.1") ', CommandButton2, Visible)

    Mycmd.Left = 18

    Mycmd.Top = 150

    Mycmd.Width = 175

    Mycmd.Height = 20

    Mycmd.Caption = "This is fun." & Mycmd.Name 

End Sub

Private Sub UserForm_AddControl(ByVal Control As _

    MSForms.Control)

    Label1.Caption = "Control was Added."

End Sub

La versione 2010 di Visual Studio nel tempo è diventata un mostro a causa di modifiche sintattiche (non sempre in dispensabili, a parere mio...) e arricchimnenti notevoli, come LINQ o i più recenti WPF (Windows Presentation Foundation) e WCF (Windows Communication Foundation. Ricordo qui che WPF e WCF costituiscono "fondamenti" davvero fondamentali, che rinnovano fino a rendere obloseti arnesi precedenti, comne le Windows Form.

In queste condizioni la letteratura specifica ha, fatalmente, proliferato in modo preoccupante sia per i tempi di apprendimento che per le... tasche di sviluppatori in erba o di madio calibro. Da un lato il mercato offre bibbie onnicomprensive di vari chilogrammi, dall'altro testi dedicati più profondi e non sempre troppo leggeri.

Il manuale che qui segnalo segue l'approccio molto audace della (discreta) esaustività unita ad un impaginato ridotto. Eccone i connotati , che fin nel titolo proclama l'ambizione delle intenzioni:

VISUAL BASIC 2010 - Guida completa per lo sviluppatore

HOEPLI Informatica

di D. Bochicchio, C. Civera, M. De sanctis, R. Golia, A. Leoncini, M. Leoncini, S. Mostarda

€ 39,90

Circa l’esaustività si nota l’assenza dei VSTO (Visual Studio Tools per Office), che chi scrive non disapprova, avendone sperimentato la natura brillante unita però a macchinosità, difficoltà di deployment e lacune come le funzioni d’utente (che richiedono le pur vecchie macro VBA).

Per il resto manca lo spazio per commenti dettagliati. In sintesi riteniamo di poter testimoniare che l’approccio seguito – poche parole e snippet d’esempio corti ma in entrambi i casi ben scelti per significatività – si lascia ben apprezzare.  Il risultato è che il lettore non proprio alle primissime armi ma che ha già nozioni di base senza aver avuto il tempo materiale di digerire i pesanti malloppi di cui sopra abbastanza presto si sente confortato nel suo percorso di apprendimento. Perviene così abbastanza presto ai due capitoli fondamentali, quello sulle Collection e quello su Delegate ed eventi, entrambi esposti con chiarezza e, stavolta, con poche scorciatoie.

A quel punto l’avventura prosegue con calma e proficuamente su ADO, Entity Framework, ASP.NET Windows Communication Foundation fino a temi molto seri come multithreading ed esecuzione parallela e Windows Azure. Vi è più che basta come bigino, anzi come testo base di consultazione, tanto più che il Web e MSDN forniscono tutto o quasi quel che occorre a chi diventa professionista.

A very useful and complete WPF handbook, by Manning

The book from MANNING I am going to review:

WPF in Action with Visual Studio 2008

By Arlen Feldman and Maxx Daymon

November, 2008 - 520 pages

Printed book: $ 44.99

E-book PDF: $ 27.50

http://www.manning.com/feldman2/

In this site two free PDF files can be download:
Chapter 2 (introduction to PDF) and Chapter 7
0,8 MB of source code can be dowloaded

WPF (Windows Presentation Foundation) is a technology Microsoft created in order to encourage a next generation of Window Forms (and of Web pages, created with SilverLigth) with a lot of enhancements in terms of multimedia features and structural ones, too . It is not very new, for its first edition was issued in Windows 2005, but till now it was adopted by not many developers, in Italy. The main reason is clear, in my opinion: WPS implies a paradigm strongly different with respect of classic Windows Forms, so people has much work to do and much time to spend for learning and mastering it.

The new XAML declarative language, derived from XML, in conjunction with imperative “code behind” in C# or VB languages, is appealing but you have not only to change mentality, what is obvious, but you also need understand a lot of subtle concepts as relative margins and many controls containers - StackPanel, Grid, DockPanel, Canvas etc. – and their combinations!, to mention only the first ones a new user meet with.

There are two other practical difficulties:

• the project pane, astonishing in itself, is hard in use (so I like better do the job in the XAML…);
• Intellisense often presents too many options, without a good filtering of those correct in a given context.

Microsoft supports WPF with many articles and posts in MSDN etc. but what is most important is a systematic BOOK ON WPF or on VISUAL STUDIO 2010 with large chapters onWPF. Till now none is in Italian and this situation will continue in the future, in my opinion.

WPF in action in two word

Written in a witty, engaging style, WPF in Action with Visual Studio 2008 can be read cover-to-cover or used to reference specific problems and issues. The approach is systematic and rational, but at the same time it start from practical and always focused on how you'll use WPF in real development scenarios. You'll learn how to handle the many new issues presented by the extreme flexibility of WPF. The authors also provide numerous tips and suggestions for how to work efficiently.

MAIN CONTENTS:

• WPF using Visual Studio 2008
• Real-world example applications
• Tips and techniques
• Advice for Windows Forms developers
• Drawing and animation
• Command handling and data-binding
• XBAP and ClickOnce

Visiting the Manning site you can find many frequently asked questions
http://www.manning.com/about/faq.html

Finally a little example from the Manning ‘s book:

“The abstract Drawing class in .NET has several different derivations for different purposes.

Types of Drawings

Class Purpose

ü  ImageDrawing Used to hold a graphic, such as a bitmap. This is the low-level, lower-overhead class to use to hold an Image—versus the Image class, which has all the event support, layouts, and so on;

ü  VideoDrawing Lets you “draw” a video clip that can be played, started, stopped, and so on;

ü  GeometryDrawing A drawing made up of various shapes such as curves. This is what was used to create the magnifying glass from figure 14.13;

ü  GlyphRunDrawing Lets you draw text with extreme accuracy—you’d use this if you were going to build a typesetting application;

ü  DrawingGroup Groups multiple drawings together.

These different types of drawings can be defined in XAML. An ImageDrawing might look like this:

<ImageDrawing Rect="0,0,100,100" ImageSource="C:\WINDOWS\Web\Wallpaper\Bliss.bmp"/>

“

QUESTA "RICETTA" NASCE DALLA RICHIESTA FATTAMI DA UNO SVILUPPATORE DI MODELLI EXCEL CON VBA, SPECIALIZZATO IN PROBLEMI DI STUDI DENTISTICI:

Paolo Bortolini

Sito: www.studiobortolini.com

Blog: http://managementodontoiatria.wordpress.com/

A onor del vero, dopo avergliela escogitata e proposta, mi ha de visu mostrato che nel frattempo anch'egli era suppergiù pervenuto ad un'idea stostanzialmente consimile... (succede, non s'inventa nulla a questo Excel-mondo).

Calcoli tradotti al volo in valori (ricetta originale!)

Si abbia una tabella del tipo seguente - con dati fasulli, colonne e righe omesse –sulla cui parte destra (da colonna H in avanti) si vogliono riportare formule anche complesse copiate in basso su tutti i record.

Il problema che subito si presenta deriva dal fatto che le migliaia di righe in ballo sono troppe, con due conseguenze poco simpatiche: le formule appesantiscono il file e, peggio ancora, rallentano paurosamente l’esecuzione.

Prima soluzione (inadeguata)

Partendo dal normale intervallo della bozza affidatami dal committente, ovvero non da una tabella “canonica” (ListObject in VBA), ho dapprima pensato a una macro che, partendo da una prima riga contenente essa soltanto le formulacce da colonna H in poi, le ricopiasse in basso per tutte le righe sottostanti da 2 a 12500 (o giù di lì). Peggio che andar di notte, ovviamente: si registravano tempi biblici di ricalcolo.

Poi mi sono detto che salvare i risultati in termini di VALORI poteva comunque essere utile, in vista di ulteriori elaborazioni con altri programmi come Access o applicazioni sviluppate in Visual Studio. Ed ecco allora le macro VBA con le quali ho tentato di concretizzare l’idea. Si esamini anzitutto la seguente, seguita dalla sua brava Sub di prova.

Sub IncollaSpeciale(Scarto As Integer)

  Dim RigaFrm As Range, RigaDest As Range

  Set RigaFrm = Range("RigaFormule")

  Set RigaDest = RigaFrm.Offset(Scarto)

  RigaFrm.Copy RigaDest

  RigaDest.Copy

  RigaDest.PasteSpecial Paste:=xlPasteValues

  Application.CutCopyMode = False

End Sub

Sub ProvaIncollaSpeciale()

   IncollaSpeciale 3

End Sub

La IncollaSpeciale applica appunto all’intervallo preliminarmente denominato “RigaFormule” (nella figura precedente potrebbe avere coordinate quali H1:M1 o simili) contenenti le fatidiche formule a riga 2 da H in poi) il comando omonimo Copia seguito da Incolla Speciale con opzione Valori. Tali operazioni si traducono in VBA in queste successive istruzioni: a) proprietà Copy applicato a RigaForm che registra il Range(“RigaFormule”) assegnandole come destinazione una RigaDest shiftata secondo l’argomento Scarto; b) a tale RigaDest è di nuovo applicato Copy; c) quindi, sempre RigaDest, è assoggettato a PasteSpecial con opzione Paste:=xlPasteValue che, come qui si desidera,incolla i valori e non le formule; d) chiude un (inevitabile) Application.CutCopyMode = False che elimina la dannata casella ruotante che altrimenti continuerebbe a girare attorno all’origine (o alla destinazione? Verificate voi stessi...).

Ed ecco la macro centrale che utilizza la copia in basso dei valori, lasciando in vita la riga 2 di formule, secondo un certo numero di record NumRec come argomento.

Sub CopiaDati(NumeroRec As Integer)

  Dim Inizio As Date

  Inizio = Now()

  SvuotaRigheMenoUna

  Application.ScreenUpdating = False

  Dim i As Integer

  For i = 1 To NumeroRec

    IncollaSpeciale i

  Next

  MsgBox "Inizio: " & Inizio & vbLf & "Fine: " & Now()

End Sub

A questo punto non voglio tediare gli esperti cui mi rivolgo con commenti che ora ritengo superflui. Costoro potranno divertirsi a sfruttare CopiaDati passandole un NumRec pari alle righe meno una del nostro elenco, nonché a creare una macro SvuotaRigheMenoUna che, appunto, ripulisce tutte le celle che stanno sotto la riga 2 a partire da colonna H (o quel che l’è).

La pensata precedente può essere interessante per situazioni intermedie, diciamo con non più di 200-300 righe, ma purtroppo delude in gran parte le speranze. Infatti se garantisce un minor appesantimento di formule l’esecuzione del codice presenta riduzioni di tempo piuttosto scarse, come indicano - provare per credere – le istruzioni iniziale Inizio = Now e finale MsgBox ecc. che segnalano circa 10 minuti già con un migliaio di righe.

Altro tentativo fallito

Successivamente ho sperimentato la variante consistente nel tradurre il fatidico intervallo in una Tabella , mediante l’apposito comando (in Excel 2007 posto nella scheda omonima) che automaticamente affibbia il nome default Tabella1. La cosa è in ogni caso interessante per due motivi:

1)      offre gratuitamente filtri automatici sui vari campi e funzionalità di filtro avanzato nonché l’automatico arruolamento come nuovo record di tale Tabella1 ogni volta che si aggiunge qualcosa sotto l’ultima riga precedente;

2)      riporta, sempre automaticamente, le formule inserite (da H in poi, sempre per stare al nostro caso) in tutti i record vecchi o nuovi.

Ma purtroppo anche in questo caso i tempi di ricalcolo si rivelano altresì solo leggermente più contenuti: confidavo in un qualche sistema di ottimizzazione offerto da Excel con le tabelle, alias ListObject. Aspettativa ingenua (miracoli non se ne fanno, neanche in casa Microsoft), almeno con le molte e complesse formule della nostra riga da H in poi e i tempi gli appesantimenti del file restano inaccettabili.

Eureka! Ovvero un uovo di Colombo

Per giunta il mio incontentabile committente pretendeva che venisse esportato su un diverso foglio l’intervallo di righe relative a un certo criterio (principalmente quelle compresi fra due date fissate dall’utente finale). Di qui il secondo uovo di Colombo, più complicato perché richiede codice VBA, ma comunque brillante.

L’idea appena detta si concretizza con un record ausiliario posto su colonne lontane da quelle del database. Si tratta di una cosa del genere, che ripropone a parte un tipico record della nostra Tabella1:

Si fa presente che le prime 7 celle costituiscono campi di input, mentre quelle accanto, da colonna AF in avanti contengono le dannate formule. Orbene, prima di esaminare la prima basilare macro si sappia che agli intervalli delle une e delle altre sono stati affibbiati i nomi QuestoRecord e, rispettivamente, QuesteFormule. Eloquenti, direi.

Ed ecco la macro in parola, seguita da una SvuotaRighe a sua volta richiamata dalla prima con evidente finalità:

Sub AggiornaValori()

  If ActiveCell.Column <> 8 Then

    MsgBox "Cella attiva DEVE essere in colonna H!", vbCritical

    Exit Sub

  End If

  Dim SetteCelle As Range

  With ActiveCell

    Set SetteCelle = Range(.Offset(0, -1), .Offset(0, -7))

  End With

  SetteCelle.Copy Range("QuestoRecord")

  Range("QuesteFormule").Copy

  ActiveCell.PasteSpecial Paste:=xlPasteValues

  Application.CutCopyMode = False

End Sub

Sub SvuotaRighe()

  Dim PrimaCella As Range, UltimaCella As Range

  With Range("RigaFormule")

    Set PrimaCella = .Cells(1, 1)

    Set UltimaCella = .Cells(.Count)(1, 1)

  End With

  If IsEmpty(PrimaCella) Then Exit Sub

  If IsEmpty(PrimaCella.Offset(1, 0)) Then

    Range(PrimaCella, UltimaCella).Clear

  Else

    Range(PrimaCella.End(xlDown), UltimaCella).Clear

  End If

End Sub

Commenti. Tacitiani e limitati alla Sub AggiornaValori (la seconda è affidata all’esegesi autogestita). La variabile SetteCelle serve a registrare l’intervallo delle prime celle dei campi di input (il valore 7 deriva dal caso trattato e va allineato a situazioni differenti). La macro s’incarica poi di copiare il Range SetteCelle nel Range QuestoRecord , con conseguente calcolo delle specifiche formule nella zona QuesteFormule, che a loro volta vengono incollate col PasteSpecial di soli valori nella cella attiva.

Qualcuno obietterà che l’utente potrebbe dimenticare di lanciare AggiornaValori. Eccolo accontentato con una macro che li aggiorna tutti, circostanza nella quale il distrattone potrebbe andarsi a prendere un caffè, una tantum si spera!

Sub AggiornaTuttiValori()

  Dim Inizio As Date

  Inizio = Now()

  Load UserForm1

  UserForm1.Show

  Dim CampoCosti As Range, i As Integer

  Dim SetteCelle As Range

  Set CampoCosti = _

  Foglio1.ListObjects("Tabella1").ListColumns("COSTI GENERALI").Range

    On Error Resume Next ' Patch dovuta a causa dell'orribile caso #DIV/0!

    For i = 2 To CampoCosti.Cells.Count

    If CampoCosti.Cells(i) = "" Then

      With CampoCosti.Cells(i)

        Set SetteCelle = Range(.Offset(0, -1), .Offset(0, -7))

      End With

      SetteCelle.Copy Range("QuestoRecord")

      Range("QuesteFormule").Copy

      CampoCosti.Cells(i).PasteSpecial Paste:=xlPasteValues

      Application.CutCopyMode = False

    End If

  Next

  UserForm1.Hide

  Unload UserForm1

  Range("A3").Select

  MsgBox "Inizio: " & Inizio & vbLf & "Fine: " & Now()

End Sub

Anche qui mi astengo da commenti, in modo pilatesco quanto pigro. Preciso anzi che ho preparato una versione che, per limitare il predetto coffee break, esclude i record già sistemati. La lascio per esercizio. Piuttosto si esamini quest’altra macro, relativa all’evento DoubleClick del Worksheet ove risiede la tabella:

Private Sub Worksheet_BeforeDoubleClick(ByVal Target As Range, Cancel As Boolean)

    If Target.Column = 8 Then AggiornaValori

    Cancel = True

End Sub

Come a tutti è chiaro, essa agisce ogni volta che si dà una doppia cliccata su una cella di colonna H (quella del campo contenente la prima formulaccia).

L’evento risolutore. Alla fine, riflettendo, ci si rende conto che le macro precedenti meno AggiornaValori e la sua ancella SvuotaRighe sono pleonastiche o quasi. Questo perché l’evento che sistema tutto o quasi (*) è l’evento Change sempre del foglio della Tabella1:

Private Sub Worksheet_Change(ByVal Target As Range)

  If Intersect(Target, Range("Tabella1")) Is Nothing _

    Or Target.Column = 8 Then Exit Sub

  Range("H" & Target.Row).Select

  AggiornaValori

End Sub

Qui si fanno solo due osservazioni: a) una tabella canonica ha la virtù che se si digita qualcosa in una riga subito sotto questa viene automaticamente inserita come nuovo record; b) può essere importante che i valori da colonna H in poi vengano aggiornati (come avverrebbe con formule) qualora l’utente modifichi in seguito qualche dato di input. A buon intenditor...

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