RAVAL — Roberto Avalonia Library

Versione 2.10.0 · .NET 10 · Avalonia 12.1.4

RAVAL.dll è la libreria del libro «AVALONIA SOLO IN CODICE» di Ing. Roberto Arato: le funzioni in più per Avalonia, soprattutto grafiche e di conversione. Le estensioni fluenti per costruire le interfacce in C# senza XAML, gli stili scritti in codice, un grafico a curve con i marcatori, le tabelle e gli elenchi di proprietà, le figure a qualunque risoluzione, i numeri con i prefissi SI e i colori, il log e le impostazioni in JSON o INI di ogni applicazione, e un server di API JSON su Kestrel. Dipende da .NET, da Avalonia e dal framework ASP.NET Core dell'SDK, tutti con licenza MIT.

Quello che sta in RAVAL serve a molti programmi e si spiega in un capitolo: niente di legato a un dominio (le microonde stanno in ASTRIP, non qui), niente di grande da nascondere dentro una scatola.

Cosa contiene

Tutto sta nel namespace RAVAL: basta using RAVAL;.

Il tutorial completo, dal linguaggio C# (con un capitolo intero su thread, Task e await) fino a un cruscotto con grafici disegnati a mano, a un server di API e alla finestra di uno strumento di misura fatta con i pezzi pronti della 2.1 (capitolo 15) e al log con le impostazioni (capitolo 16), è DOC/TUTORIAL.md: è il testo di partenza del libro. Le sue figure sono in DOC\immagini e le disegna il codice di ESEMPI_RAVAL.

Il riferimento di tutte le classi e di tutti i metodi, in inglese come la libreria, è DOC/API.md e, per il sito, la pagina unica DOC\sito\raval-api.html (stili dentro, tema chiaro e scuro, indice a sinistra). Non si scrive a mano: lo genera DOC_RAVAL dalle classi pubbliche di RAVAL.dll e dai commenti /// di RAVAL.xml, quindi dice sempre quello che fa il codice. Va rigenerato dopo ogni modifica alla libreria; DOC_RAVAL restituisce 2 se un membro pubblico non ha il commento. Ogni classe è divisa in costruttori, campi, proprietà, eventi e metodi, perché anche gli eventi (RChart.MarkersChanged) e le costanti (RStyles.Monospace) sono parte di quello che si usa; le estensioni di RAva sono divise per argomento (tabella Argomenti in DOC_RAVAL\Riferimento.cs: un nome che non c'è finisce in «Other», e lì si vede che va aggiunto).

La soluzione

RAVAL\
├─ RAVAL.slnx
├─ Directory.Build.props      la versione, una sola per tutti i progetti
├─ RAVAL\                     la libreria (RAVAL.dll)
├─ TEST_RAVAL\                la prova: estensioni e temi
├─ ESEMPI_RAVAL\              gli esempi del tutorial, che disegnano le figure
├─ DOC_RAVAL\                 scrive il riferimento (DOC\API.md) e il sito (DOC\sito)
├─ DOC\                       tutorial, schede delle classi, figure, riferimento, il sito generato
└─ deploy\                    il virtual host di Apache di raval.aratoingegneria.it

dotnet build RAVAL.slnx
dotnet run --project TEST_RAVAL                       # 0 se tutte le prove passano; i PNG in bin\...\uscita
dotnet run --project ESEMPI_RAVAL                     # rigenera tutte le figure in DOC\immagini
dotnet run --project ESEMPI_RAVAL -- --finestra       # il primo programma del tutorial, con la finestra vera
dotnet run --project ESEMPI_RAVAL -- --csharp         # gli esempi del capitolo 1, il linguaggio
dotnet run --project ESEMPI_RAVAL -- --thread         # gli esempi del capitolo 2: thread, Task, await
dotnet run --project ESEMPI_RAVAL -- --copertina <cartella> <immagini>   # copertina del libro, 300 dpi
dotnet run --project DOC_RAVAL                        # rigenera il riferimento e il sito; 0 se ogni membro ha il commento
dotnet run --project DOC_RAVAL -- --anteprima         # il sito su http://localhost:8090/, come sul server

Il sito, raval.aratoingegneria.it

DOC_RAVAL scrive in DOC\sito tutto il sito, in italiano (pagina.html) e in inglese (pagina-en.html):

• home, funzioni, documentazione, schermate e download;
• il tutorial, le schede e il README convertiti dal Markdown (DOC_RAVAL\Markdown.cs, con le ancore di GitHub, così gli indici funzionano);
• il riferimento delle API;
• il tutorial in PDF, stampato da Edge senza finestra dalla pagina stessa, con il foglio di stile per la stampa;
• il pacchetto da scaricare: la DLL con la documentazione;
• gli esempi dei libri «Avalonia solo in codice». Li prepara la sessione AVA_BOOK in ..\AVA_BOOK\PACCHETTI, insieme a pacchetti.json (file, lingua, titolo, descrizione, volume); il generatore li copia in download\libri\ e li mostra nella pagina della loro lingua. Se la cartella non c'è, la sezione non c'è.

I sorgenti di RAVAL non sono pubblici (decisione di Roberto del 6/11/2026): sul sito si scaricano solo dietro la login delle statistiche.

• Il pacchetto dei sorgenti va in DOC\sito\riservato\, fuori da git; RavalSito serve /riservato/ solo con utente e password, e lo elenca nella pagina /stat/.
• Gli esempi dei libri devono usare la DLL, non i sorgenti. Il generatore apre ogni zip: uno che contiene sorgenti della libreria (un .cs sotto una cartella RAVAL/) non va nella pagina pubblica ma in riservato\libri\.
• Nessuna pagina pubblica nomina i file riservati.

La versione, le classi e le firme le prende dalla DLL, quindi il sito dice sempre quello che c'è. Le figure per il web (al massimo 1600 pixel) le scrive ESEMPI_RAVAL in DOC\sito\immagini mentre disegna quelle dei libri. I pacchetti e il PDF (DOC\sito\download\) non stanno in git: si rifanno a ogni generazione.

Sul server (nex-sito, aratoingegneria.it) i file del sito stanno in /opt/raval-sito/www e li serve RavalSito, un piccolo servizio come quello di NEX. Il servizio conta pagine viste e scaricamenti, anche per paese, lato server, senza cookie e senza script nelle pagine; le statistiche si vedono in /stat/, con utente e password. Usa la RLIB, quindi è un progetto privato a parte, ..\RAVAL_SITO, con il suo LEGGIMI. Davanti c'è Apache come proxy (deploy\raval.aratoingegneria.it.conf e la copia HTTPS), con il certificato di Let's Encrypt che si rinnova da solo. Per pubblicare, dopo aver generato il sito:

tar -C DOC/sito -czf - . | ssh nex-sito "tar -xzf - -C /opt/raval-sito/www"

Il servizio serve i file nuovi subito, senza riavvio.

TEST_RAVAL e ESEMPI_RAVAL disegnano senza schermo: Avalonia.Headless con il disegno vero di Skia (UseHeadlessDrawing = false). TEST_RAVAL legge l'immagine della finestra con CaptureRenderedFrame; ESEMPI_RAVAL ridisegna la finestra con RImage.Render ad almeno 300 dpi e 2400 pixel di larghezza, la regola delle figure dei libri. TEST_RAVAL controlla le proprietà impostate da ogni estensione (anche l'errore chiaro di quelle usate sul controllo sbagliato), che ogni evento arrivi al metodo con il valore giusto, che RAva.Every scatti, e che i colori legati con Resource (dati con RThemes) cambino da soli tra tema chiaro e scuro. Per RServer prova percorsi, parametri, corpo JSON, codici di errore, l'avvio con Run in un thread e i metodi sul thread dell'interfaccia, chiamando davvero il server con un HttpClient.

Usarla come DLL

Nella stessa soluzione basta il riferimento al progetto:

<ProjectReference Include="..\RAVAL\RAVAL\RAVAL.csproj" />

Da un'altra soluzione si usa la DLL compilata, con HintPath:

<ItemGroup>
  <PackageReference Include="Avalonia" Version="12.1.4" />
  <Reference Include="RAVAL">
    <HintPath>..\RAVAL\RAVAL\bin\Debug\net10.0\RAVAL.dll</HintPath>
  </Reference>
</ItemGroup>

• I riferimenti a una DLL non sono transitivi: il programma deve avere da sé il pacchetto Avalonia. Per usare RServer serve anche <FrameworkReference Include="Microsoft.AspNetCore.App" />; chi non lo usa non ne ha bisogno, perché l'assembly di ASP.NET non viene mai caricato.
• Con l'HintPath una modifica a RAVAL arriva al programma solo dopo aver ricompilato RAVAL. I binari non sono nel repository (.gitignore): su un PC nuovo si compila prima RAVAL.slnx.
• Accanto a RAVAL.dll c'è RAVAL.xml, la documentazione dei membri per i suggerimenti dell'editor.

Regole del codice

Le stesse del libro, e valgono per ogni file:

• niente lambda (x => ..., delegate, gestori anonimi): metodi con un nome, piccole classi con i campi del contesto, foreach al posto di LINQ con predicati. I membri con corpo a espressione (public int X => 5;) vanno bene;
• un commento su ogni funzione (/// <summary> per le pubbliche), che dice cosa fa e perché;
• commenti in riga allineati alla colonna 90;
• in RAVAL\UI le righe stanno entro 80 caratteri (i commenti a fine riga alla colonna 90 e l'intestazione a parte): il libro mostra quei file come figure, e una riga più lunga verrebbe tagliata;
• l'intestazione con il logo in testa a ogni sorgente, con Name e Description aggiornati; la riga del copyright dice Copyright (c) 2026 Ing. Roberto Arato. MIT License: see the LICENSE file. nella libreria, ... Licenza MIT: vedi il file LICENSE. in esempi e prove (non «Tutti i diritti riservati», che contraddirebbe la licenza: chi copia un solo file deve sapere a quali condizioni può usarlo);
• la libreria è in inglese: nomi, commenti e messaggi di errore, come Avalonia; un'estensione ha il nome della proprietà che imposta. Restano in italiano i documenti in DOC\ e il codice di ESEMPI_RAVAL e TEST_RAVAL, che servono al libro italiano;
• 0 avvisi alla compilazione.

Versione

Una sola, in Directory.Build.props (<Version>), per la libreria e per i programmi di prova. Si alza all'inizio di una serie di modifiche, non alla fine: così la versione stampata da TEST_RAVAL dice subito se il codice che gira è quello nuovo. Il numero stampato è solo la versione, senza l'impronta del commit (IncludeSourceRevisionInInformationalVersion spento). Anche questo README e il tutorial riportano lo stesso numero.

• 1.0.0: prima versione (estensioni, visualizzatore HTML, classi PDF).
• 1.1.0: RAVAL tiene solo gli strumenti per scrivere codice Avalonia. Visualizzatore HTML, classi PDF e miniature dei PDF sono usciti dalla libreria, e con loro i capitoli 12 e 13 del tutorial.
• 1.2.0: testo e cornici (Corpo, Grassetto, Colore, Bordo, Imbottitura, Sfondo...), pannelli pronti (InRiga, InColonna, Griglia), eventi senza lambda (AlCambioTesto, AlInvio, AlSpunta, AlCambioSelezione, Ogni, AlCambioTema), colori (RAva.Pennello, RTemi). RAva è divisa per gruppo in più file (partial); nel tutorial il capitolo 12 le spiega con una rubrica.
• 1.3.0: RServer (API JSON su Kestrel) con RRichiesta, RRisposta, RErroreHttp; avvio senza await (Avvia/Ferma), con un thread (Esegui) o con await. Nel tutorial il capitolo 2 nuovo su thread, Task e await (esempi --thread e sei diagrammi) e il capitolo 14 sul server.
• 1.3.1: i sorgenti di RAVAL\UI portati entro 80 caratteri per riga, per le figure del libro; nessuna funzione cambiata.
• 1.3.2: il commento di AlInvio e il tutorial dicono come si comporta davvero Invio in una TextBox (una riga: passa; AcceptsReturn: va a capo e lo segna gestito) e l'ordine inverso dei gestori della stessa fase; misurati con la tastiera finta in TEST_RAVAL\ProveInvio.cs. Nessuna funzione cambiata.
• 1.3.3: licenza MIT (file LICENSE, PackageLicenseExpression nel .csproj, README, tutorial); il codice si scarica da https://raval.aratoingegneria.it. Nessuna funzione cambiata.
• 1.3.4: Sfondo e Imbottitura valgono anche per il TextBlock, che in Avalonia 12 ha Background e Padding (segnalato da AVA_BOOK); prima davano l'errore «non ha questa proprietà».
• 1.3.5: le intestazioni di tutti i sorgenti dicono «Licenza MIT: vedi il file LICENSE» al posto di «Tutti i diritti riservati». Nessuna funzione cambiata.
• 1.3.6: voci dei menu (RAVAL\UI\RAvaMenu.cs, chieste da AVA_BOOK): AlClic per il MenuItem e Tasto("Ctrl+S"), che mette insieme InputGesture e HotKey; provate in TEST_RAVAL\ProveMenu.cs.
• 1.3.7: accessibilità (RAVAL\UI\RAvaAccesso.cs, chiesta da AVA_BOOK): Nome(s) per il nome che annuncia il lettore di schermo; Contenuto("_Prenota") mette anche il nome «Prenota», perché Avalonia lo annuncerebbe con il trattino. Provate in TEST_RAVAL\ProveAccesso.cs.
• 1.3.8: il titolare del copyright è Ing. Roberto Arato: intestazioni dei sorgenti, LICENSE, <Copyright> in Directory.Build.props, README. Nessuna funzione cambiata.
• 1.3.9: anche <Company> e i testi (README, tutorial) nominano solo Ing. Roberto Arato; il nome della ditta resta nel logo e in copertina. Nessuna funzione cambiata.
• 2.0.0: RAVAL è in inglese per tutti, anche per il libro italiano: classi, estensioni, commenti dei sorgenti e messaggi di errore. Le estensioni hanno il nome della proprietà che impostano (Margin, Content, Background...), gli eventi On... (OnClick, OnEnter...), i pannelli pronti HStack, VStack, Grid; le classi sono RThemes, RRequest, RResponse, RHttpError. Il JSON degli errori è { "error": "..." }. Non è compatibile con la 1.x: la tabella dei nomi vecchi e nuovi è in DOC/NOMI_2.0.md. Il riferimento delle classi per il sito lo genera DOC_RAVAL.
• 2.1.0: le funzioni grafiche e di conversione (chieste da ASTRIP): RChart con RSeries, RLimit e i marcatori al clic, RTicks (divisioni 1-2-5), RImage (figure a qualunque dpi), RFormat (prefissi SI scritti e riletti), RColor (mescolare, esadecimale, luminanza, tavolozza), RTable e RPropertyList, RStyles (stili in codice senza lambda, Clean, Accent) e in RAva Caption, Card, Bar, ToolbarButton, CodeBox. Provate in TEST_RAVAL/ProveGrafica.cs; scheda in DOC/RGrafica.md.
• 2.1.1: RCsv: le colonne di numeri, le curve di un RChart e le righe di una RTable in CSV, con le virgolette di RFC 4180, e la lettura.
• 2.1.2: una curva di RChart senza nome si disegna ma resta fuori dalla legenda e dalle letture dei marcatori (le nuvole del Monte Carlo).
• 2.1.3: RTable non esce più dall'array quando le colonne cambiano dopo le righe: le celle che mancano restano vuote (trovato da ASTRIP, che rifà le colonne della tabella dei marcatori).
• 2.1.4: RImage disegna a 96 dpi su una bitmap già grande quanto la risoluzione chiesta, con la scala come trasformazione: a 300 dpi RenderTargetBitmap perdeva le scritte disegnate dopo un ritaglio (la legenda e i marcatori di RChart). RChart lascia a destra lo spazio per l'ultima etichetta dell'asse.
• 2.1.5: RImage.SavePng scrive nel PNG la risoluzione vera (blocco pHYs in pixel al metro, con il suo CRC), come chiedono i libri; RImage.SetDpi e RImage.Dpi per i PNG fatti altrove.
• 2.1.6: documentazione allineata alla libreria. Il riferimento (DOC_RAVAL) scrive anche gli eventi e i campi pubblici, che prima mancavano, e mette i pezzi pronti di RAva sotto «Ready-made look»; il tutorial ha il capitolo 15 nuovo, uno strumento di misura con RChart, RTable, RPropertyList, RFormat, RCsv, RImage e RStyles (esempio ESEMPI_RAVAL\Esempi\Strumento.cs, figure 15_strumento), e gli inciampi passano al capitolo 16. Nessuna funzione della libreria cambiata.
• 2.2.0: log e impostazioni, scritti da zero con licenza MIT (le idee vengono dal modo di lavorare dei programmi dell'autore, il codice no): RLog con i livelli, i colori (sulla console e nella finestra, anche a 24 bit e per singola riga), il file che ruota e un thread suo, RLogView per vederlo dal vivo, RSettings in JSON (RJsonSettings) o INI (RIniSettings) con le stesse chiamate, Remember per la finestra che riapre dov'era, RRecentFiles per i file recenti; RStyles.Apply(controllo) per gli stili di un solo controllo. Prove in TEST_RAVAL\ProveApp.cs, scheda DOC/RApp.md, capitolo 16 del tutorial (esempio Registro.cs); gli inciampi passano al 17.
• 2.3.0: l'albero. RTreeNode (testo, valore, chiave del percorso, figli aggiunti o letti da un caricatore la prima volta che servono; FromJson, FromXml, FromFolder) e RTree, un TreeView riempito in codice che costruisce le voci solo quando un nodo si apre (centomila valori JSON in meno di due decimi di secondo), con scelta, Opened, Find per percorso, filtro e casella di ricerca. Prove in TEST_RAVAL\ProveAlbero.cs, scheda DOC/RGrafica.md, capitolo 17 del tutorial (esempio Albero.cs); gli inciampi passano al 18.
• 2.4.0: i dati dell'albero senza Avalonia. RNode (cartella Data) legge JSON e XML in una classe sola, con le letture per percorso e predefinito (GetInt("server.port", 5080), "server/@port"), la modifica (Set, Add, Remove), la scrittura (ToJson, ToXml, Save) e il passaggio da un formato all'altro. RTreeNode.FromJson e FromXml passano da RNode, che resta nel Tag di ogni nodo (prima c'era il JsonNode o l'XElement); nuovi RTreeNode.FromNode e RTree.LoadNode. Scheda DOC/RDati.md, paragrafo 17.3 del tutorial, prove Dati in TEST_RAVAL\ProveAlbero.cs.
• 2.5.0: dialoghi e file in una riga. RDialog (Info, Warning, Error con i dettagli dell'eccezione e la riga nel log, Confirm, Ask, Choose; testi cambiabili per un'altra lingua) con la finestra RDialogBox, la cui risposta (Answer) vale −1 per Esc e crocetta. RFiles apre i selettori di file e cartelle con i tipi scritti «nome|.a;.b» e risponde con il percorso; ReadText e WriteText per i file di testo. Scheda DOC/RDialoghi.md, capitolo 18 del tutorial (esempio Appunti.cs), prove in TEST_RAVAL\ProveDialoghi.cs; gli inciampi passano al 19. I commenti /// di RTree e RTreeNode ora stanno anche loro negli 80 caratteri di UI.
• 2.5.1: manutenzione, senza funzioni nuove.
  • RImage rispetta l'opacità dei controlli: prima un valore attenuato o una riga di stato al 75% uscivano pieni nelle immagini.
  • RChart.Culture (predefinita: invariante) fa scrivere assi e marcatori con il punto, come tabella e CSV; prima usava la virgola del computer.
  • RSettings in JSON scrive gli accenti come sono, non come à.
  • Le figure di ESEMPI_RAVAL escono ad almeno 300 dpi e 2400 pixel (prima 96 dpi, sotto la regola dei libri), e gli esempi dei componenti hanno lo stile Clean: i bottoni della barra non sono più grigi.
  • Prove in TEST_RAVAL\ProveCorrezioni.cs.
• 2.6.0: appunti e trascinamento. RClipboard: testo, tabelle con le tabulazioni da e verso un foglio di calcolo (SetTable, GetTable, Tsv, Cells), immagini, file come percorsi. RDrop: i file lasciati su un controllo arrivano a un metodo, solo quelli dei modelli («*.csv»); il puntatore dice subito se il controllo li accetta, e la classe drop (con droparea in RStyles.Clean) colora il riquadro. Scheda DOC/RDialoghi.md, capitolo 19 del tutorial (esempio Scambio.cs), prove in TEST_RAVAL\ProveAppunti.cs; gli inciampi passano al 20.
• 2.7.0: tabelle grandi e oggetti.
  • RVirtualTable: un ListBox virtualizzato con colonne a larghezza fissa. LoadCsv, ordine per valore o alfabetico, filtro, scelta sempre riferita a Rows. Centomila righe si aprono in 0,3 s e si ordinano in 0,2.
  • RPropertyList.Show(oggetto): le proprietà pubbliche, modificabili, riscritte nell'oggetto con la conversione al tipo, Rejected per i testi che non si convertono, attributi di System.ComponentModel.
  • RFormat.TryParse, e Parse che legge «10 MHz» anche senza unità indicata.
  • Capitolo 20 del tutorial (esempio Archivio.cs), prove in TEST_RAVAL\ProveVirtuale.cs; gli inciampi passano al 21.
• 2.8.0: gli altri grafici.
  • RSmithChart e RPolarChart vengono dal simulatore ASTRIP (MIT), tradotti e completati: zoom e spostamento della vista, marcatori con frequenza, Z e VSWR, cerchi colorati, esportazione a 300 dpi; il polare in dB, con lo zero in alto e il verso orario per i diagrammi d'antenna.
  • RSmithMath (cartella RF, senza Avalonia): Γ, Z, VSWR, i cerchi della griglia, stabilità, Rollett, guadagno unilaterale e rumore.
  • RBarChart, barre affiancate o impilate; RHeatMap, la mappa di colori con quattro scale.
  • Capitolo 21 del tutorial (esempio GraficiRF.cs), prove in TEST_RAVAL\ProveGraficiRF.cs; gli inciampi passano al 22.
• 2.9.0: RChart fa anche il plotter XY e il registratore.
  • RSeries.Style (linea, punti o tutti e due) con ascisse in qualunque ordine; At per bisezione.
  • TimeAxis con le divisioni su tempi tondi (RTime); MinX e MaxX.
  • RLiveSeries per i dati dal vivo da qualunque thread, ridisegnati a lotti, con la finestra che scorre.
  • Zoom con la rotella, spostamento trascinando, doppio clic per tornare: il marcatore si mette al rilascio di un clic fermo.
  • Le etichette d'ascissa che si toccherebbero si saltano; nella legenda le serie a punti hanno un pallino.
  • Paragrafo 21.4 del tutorial (esempio Registratore.cs), prove in TEST_RAVAL\ProveCurve.cs.
• 2.10.0: tema e lingue, scritti da zero (le idee di RTRANSLATE, non il codice).
  • RThemes.Standard(), la tavolozza grafite di ASTRIP resa standard.
  • RTheme: chiaro, scuro o come il sistema, ricordato in RSettings, menu e bottone sole/luna, cambio senza riavviare.
  • RLang: un file per lingua (JSON o INI via RSettings), T con il testo predefinito e le chiavi mancanti aggiunte al file, Tr per i controlli che cambiano lingua da soli, i testi di RAVAL già in italiano.
  • Paragrafi 16.6 e 16.7 del tutorial, scheda DOC/RApp.md, prove in TEST_RAVAL\ProveLingue.cs.

Note per chi ci lavora

• Nel file XML dei commenti una matrice si scrive System.Double[0:,0:], non System.Double[]: un generatore che tratta double[,] come double[] non trova il commento di RHeatMap.SetValues. DOC_RAVAL scrive le dimensioni, e nelle firme double[,].
• Senza schermo CaptureRenderedFrame dà solo i pixel della finestra, cioè 96 dpi, qualunque sia la risoluzione voluta: per le figure dei libri si ridisegna la finestra con RImage.Render. E un disegno a mano dell'albero visuale deve applicare l'Opacity di ogni elemento (PushOpacity): non la applica nessun altro, e le cose attenuate escono piene.
• Un indicizzatore (this[...]) nel file XML dei commenti ha i tipi dei parametri nell'identificatore («P:RAVAL.RNode.Item(System.String)»), come un metodo, e la riflessione lo chiama Item: DOC_RAVAL li aggiunge, se no l'indicizzatore risulta senza commento e la firma esce come «Item».
• Senza schermo i menu non si vedono se non si mette Popup.ShouldUseOverlayLayer = true in uno stile: lo fa ESEMPI_RAVAL\Program.cs.
• La scorciatoia di un MenuItem vuole HotKey, e la voce messa con Items.Add: InputGesture scrive soltanto il tasto; con ItemsSource le voci di un sottomenu chiuso non sono ancora nell'albero e HotKey non scatta (vedi DOC/RAva.md).
• Il colore di Resource cambia solo dopo un giro del dispatcher: in una prova senza schermo, dopo aver cambiato RequestedThemeVariant bisogna far girare Dispatcher.UIThread.RunJobs() prima di leggere la proprietà (vedi TEST_RAVAL\Prove.cs).
• Senza schermo i DispatcherTimer scattano solo nel ciclo vero: RunJobs() non basta, serve Dispatcher.UIThread.PushFrame fermato da un altro thread (classe Attesa in TEST_RAVAL\Prove.cs).
• Le estensioni su proprietà che stanno su classi diverse (FontSize, Padding, Background...) valgono per ogni Control e guardano il tipo vero; su un controllo che non ha la proprietà lanciano InvalidOperationException con scritto per chi valgono, invece di non fare niente.
• Stop() del server chiamato dal thread dell'interfaccia si bloccava per sempre quando era StopAsync().GetAwaiter().GetResult(): ASP.NET torna sul contesto di chi chiama. Ora è Task.Run(StopAsync)...: vedi DOC/RServer.md e il §2.9 del tutorial.
• La versione 1.0.0 nella storia del repository contiene ancora le classi PDF e l'HTML. Se il repository diventa pubblico, quella storia va tolta prima (repository nuovo dalla 1.1.0).

Licenza

MIT (file LICENSE): Copyright (c) 2026 Ing. Roberto Arato. Nei testi, nel copyright e nelle proprietà dell'assembly (Authors, Company, Copyright) compare solo Ing. Roberto Arato; il nome della ditta resta soltanto nel logo e in copertina.

RAVAL accompagna un libro pubblico, e i lettori devono poter usare il codice nei loro programmi, anche commerciali, come fanno con Avalonia, che ha la stessa licenza. L'unico obbligo è conservare la nota di copyright e il testo della licenza nelle copie del codice. Il codice di RAVAL e degli esempi del libro si scarica da https://raval.aratoingegneria.it.

Restano fuori da RAVAL, e privati, i componenti di casa che non servono a scrivere codice Avalonia (visualizzatori, generatori di documenti): la licenza MIT vale solo per quello che sta in questo repository.