FT: Buon Natale e felice anno nuovo

Questo è il fuori tema più bello che mi piace, anche perché anticipa un periodo di festa e soprattutto di recupero delle forze per il sottoscritto.
Il Natale, una festa speciale, ma che ci deve far anche riflettere sul bene del prossimo e soprattutto sul nostro modo di aiutare.
Quest'anno devo ammetterlo è stato un anno positivo, e con grandi cambiamenti, nel lavoro e nella vita privata. Tanti i successi, ma anche lo stress con alcune persone, che anziché comprendere l'amore per il prossimo, spinti da invidia o insicurezza personale che cercano di rendere questo mondo brutto.
Molto positivo è stato anche l'impegno nel volontariato che ho potuto affrontare nuovi scenari, oltre alla casa famiglia, di cui stiamo collaborando, nuove attività di volontariato soprattutto in ambito di educazione ambientale, dove finalmente ho attivato degli eventi e percorsi formativi molto interessanti.
La più grande delusione però è venuta dalle istituzioni, quest'anno proprio per il mio volontariato che mi ha permesso di conoscere e vedere alcuni aspetti negativi nella pubblica amministrazione, in primis, dipendenti del Comune di Roma e del Municipio, non solo gente poco preparata, ma soprattutto menefreghismo al massimo. Altro aspetto che ognuno di noi, almeno da chi ha grandi sentimenti non vorrebbe vedere è stato nel notare in questi posti il malcostume e corruzione, aspetti che si cerca di estirpare ma poi per vari aspetti diventa quasi impossibile.
Ma ho avuto modo anche di conoscere persone speciali, di grande valore, persone anche nella PA dei Ministeri o altri enti pubblici, che non solo hanno grande preparazione ma doti umani, da renderli speciali e soprattutto tenerli come grandi amici, perché ritengo che i valori umani e gli amici sono il regalo più bello che si può ricevere, un regalo speciale da tenere sotto l'albero.
Sul piano professionale, ho avuto modo di affrontare e lavorare con l'ultima tecnologia .Net avvicinarmi al mondo MVC ma anche ad altri Framework, insomma questo ultimo semestre molto interessante e costruttivo.
Per la prima volta in vita mia, ho una console, e già, ho acquistato la XBOX ONE S, l'acquisto motivato da due aspetti, uno per lo svago (giochi e video) e l'altro per valutare lo sviluppo software gaming o applicazioni, che spero per il prossimo anno di scrivere qualche tutorial.
Insomma devo dire un anno molto positivo.
Spero nel nuovo anno di continuare con il volontariato, questa volta più mirato all'ambiente, conoscere persone speciali come ho avuto piacere quest'anno e soprattutto accrescere la mia conoscenza, che è sempre un aspetto importante.
Mi fermerò qualche giorno nello scrivere nel blog, godendomi un po' la vita privata, le festività e soprattutto il clima e sapore del Natale, perché in fondo questo è un periodo speciale, per poi riprendere con nuovi articoli, notizie e trucchi sulla programmazione .Net, mondo informatico e tanto altro.
Auguro a tutti i miei lettori ma soprattutto amici e cari, un Natale speciale, e che il nuovo anno porti tutto ciò che desiderano.
Che l'amore non manchi mai......

C# Utilizzo del framework Caliburn in WPF

Si riporta l'articolo scritto per il sito https://www.iprogrammatori.it/articoli/programmazione/art_c-utilizzo-del-framework-caliburn-in-win_1544.aspx


In questo articolo vedremo come creare una semplice applicazioni in WPF (Windows Presentation Foundation) con il linguaggio C# per rilevare il testo digitato in una casella di testo, utilizzeremo come ambiente di sviluppo “Visual Studio 2017 Community”.
Il Framework Caliburn, qui il sito ufficiale http://caliburnmicro.com/ permette la stesura di applicazioni utilizzando un pattern simile a MVC, nel quale dividere in più classi ( file) ciò che riguarda la visualizzazione, la gestione degli eventi (codice) e il modello.
Un modo per semplificare la stesura di codice scalabile.

Stesura del codice

Si crea un nuovo progetto di tipo “Windows presentation Foundation” selezionando la categoria “Desktop Classico per Windows” nei modelli quello con la voce “app WPF (.Net Framework)”, a questo punto nel progetto che verrà creato, eliminare il file “MainWindow.xaml”.
Aggiungiamo al progetto il framewok “Caliburn” dal menu “Strumenti” selezioniamo la voce “Gestione Pacchetti Nuget” e poi il sottomenu “Gestisci pacchetti Nuget per la soluzione”.
Nella finestra che viene aperta, scriviamo nella casella “Caliburn” a questo punto selezioniamo la versione più recente della voce “Caliburn.Micro” .
In questo modo verranno aggiunti i riferimenti e nel progetto possiamo utilizzare tale Framework.
Ora andremo a creare nel progetto alcune classi che ci permetteranno di utilizzare tale Framework.
Selezioniamo dalla finestra “Esplora soluzione” il progetto, e dal menu di scelta rapida, selezioniamo dal menu “Aggiungi” il sottomenu “Classe”.”
Il nome che daremo al file ed alla classe sarà “AppViewModel” questa classe avrà il compito di gestire gli eventi, ossia notifiche che si verificano nella parte grafica della nostra applicazione, il comportamento su cui eseguire determinate azioni.
La classe eredita dalla classe “PropertyChangedBase” che controllo e notifica tutti i cambiamenti che avvengono alle proprietà che abbiamo realizzato.
Una proprietà avrà il compito di rilevare il testo, mentre un'altra, avrà solo la particolarità di restituire il testo.
Ma vediamo in dettaglio meglio questa classe per poi esaminarla in dettaglio.

using Caliburn.Micro;

using System.Windows;

 

namespace WpfTest

{

  public  class AppViewModel : PropertyChangedBase

    {

        string testo;

 

        public string Testo  {

            get { return testo; }

            set {

                testo = value;

                NotifyOfPropertyChange(() => Testo);

                NotifyOfPropertyChange(() => OttieniTesto);

            }

 

    }

        public string OttieniTesto {

            get { return "Testo Inserito: " + testo; }

        }

    }

}

Come si vede dal frammento di codice precedente, abbiamo creato una classe che eredita dalla classe "PropertyChangedBase" presente nello spazio dei nomi "Caliburn.Micro" come visibile in alto sopra ad ogni dichiarazione.
In questa classe abbiamo due proprietà, una che restituisce il testo, ed è quella denominata "OttieniTesto" mentre un’altra avrà verifica il cambiamento della proprietà "Testo" per Notificarlo, o meglio aggiornare costantemente la proprietà denominata "OttieniTesto".
Questo avviene tramite la parola chiave "NotifyOfPropertyChange().
A questo punto dobbiamo creare un’altra classe.
Si crea un nuova classe con la quale andremo a gestire questa appena creata.
Il nome che daremo al file è alla classe sarà "AppBootstrapper" che eredita dalla classe "BootstrapperBase".
Qui di seguito si riporta la classe, nel quale tramite l’evento "OnStartUp" avrà il compito di avviare ed eseguire la classe di tipo "ViewModel" per la visualizzazione della nostra applicazione.
Si riporta il codice completo di tale classe.

C#

 

 

using Caliburn.Micro;

using System.Windows;

 

namespace WpfTest

{

   public class AppBootstrapper : BootstrapperBase

    {

        public AppBootstrapper()

        {

            Initialize();

 

 

        }

 

        protected override void OnStartup(object sender, StartupEventArgs e)

        {

            DisplayRootViewFor<AppViewModel>();

           

        }

 

 

    }

}

A questo punto dobbiamo creare il terzo elemento, dopo la gestione del codice, quella della vista ora dobbiamo creare la parte grafica, dove saranno presenti i controlli.
Sempre dalla finestra di “Esplora risorse” si seleziona la voce “Nuovo” nel sottomenu, selezioniamo “Controllo Utente”.
Assegniamo come nome “AppView”.
Nella parte XAML inseriamo due controlli, uno di tipo “TextBlock” e l’altro di tipo “Textbox” .
Per il controllo “TextBlock” impostiamo nella proprietà “Name” il valore “OttieniTesto”, mentre per il controllo “TextBox” impostiamo nella proprietà “Name” il valore “Testo”.
Qui di seguito riportiamo il codice completo.

<UserControl x:Class="WpfTest.AppView"

             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006">

    <Grid Width="738" Height="356" Background="LightBlue">

        <TextBlock Name="OttieniTesto" HorizontalAlignment="Left" Margin="309,172,0,0" TextWrapping="Wrap" Text="TextBlock" VerticalAlignment="Top" Height="51" Width="180"/>

        <TextBox Name="Testo" HorizontalAlignment="Left" Height="23" Margin="219,247,0,0" TextWrapping="Wrap" Text="TextBox" VerticalAlignment="Top" Width="120"/>

    </Grid>

</UserControl>

Mentre nel file di tipo ".cs" inizializziamo i controlli.

public partial class AppView : UserControl

    {

        public AppView()

        {

            InitializeComponent();

        }

    }

Siamo giunti quasi alla fine del nostro applicativo.
Prima di procedere all’esecuzione dobbiamo apportare alcune modifiche al file "App.Xaml" con il quale indicare il file da eseguire.
Qui di seguito si riporta il codice completo del file "XAML" da notare l’attributo local che indica lo spazio dei nomi presenti nei vari file.
Mentre all’interno del nodo "ResourceDictionary", il nodo Local riporta il nome della classe bootstrapper.

<Application x:Class="WpfTest.App"

             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

              xmlns:local="clr-namespace:WpfTest"

             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">

    <Application.Resources>

        <ResourceDictionary>

            <ResourceDictionary.MergedDictionaries>

                <ResourceDictionary>

                    <local:AppBootstrapper x:Key="bootstrapper" />

                </ResourceDictionary>

            </ResourceDictionary.MergedDictionaries>

        </ResourceDictionary>

    </Application.Resources>

</Application>

Qui di seguito si riporta il codice .cs

  public partial class App : Application

    {

        public App()

        {

            InitializeComponent();

        }

    }

Ora non ci resta che eseguire il nostro applicativo e scrivere nella casella di testo un valore per mettere in pratica quanto scritto nelle varie classi.

Conclusioni

L’articolo ha voluto fornire una semplice tecnica di utilizzo del Framework Caliburn.Micro, per avvicinare il lettore a questo modo di scrivere applicazioni in ambito Windows Presentazione Foundation utilizzando il patern MVC.
Tanti i Framework che permettono una valida gestione delle interfacce di tipo WPF ma questo risulta molto valido.

strumento online gratuito per rilevare il testo da un file immagini

Altro interessante strumento che permette di estrapolare da un file immagine, del testo, è il seguente sito http://www.free-ocr.com/ dopo aver selezionato il file dal proprio pc o da un sito, si seleziona la lingua del testo dell'immagine e tramite il pulsante "start" verrà effettuato il rilevamento.
Un sito, in lingua inglese ma ben fatto.

Giochi xbox, pc gratuiti o demo

Oggi vi segnalo un sito nel quale, oltre ad acquistare video gaming per console o pc, anche la possibilità di scaricarli gratuiti, versione complete gratuite o demo.

Dal seguente sito https://www.origin.com/ita/it-it/store nella sezione "giochi gratuiti" selezionando il menu "Offre la ditta" avrete la possibilità di scaricare giochi completi e gratuitamente.
Il sito è in lingua italiana.

Per maggiori informazioni ed altro visitate il sito indicato.

Download Avira Free Antivirus

Dal seguente sito https://www.avira.com/it/free-antivirus-security-suite-acq potete scaricare un programma gratuito di Antivirus.
Avira è un antivirus molto usato che offre protezione ed ottime prestazioni.

La versione è gratuita ed in lingua italiana.

strumento gratuito di ocr per rilevare il testo dalle immagini

Il seguente sito http://www.newocr.com/ permette di estrapolare da un file immagini il testo.
Dopo aver selezionato il file dal proprio pc, in automatico, verrà fornita la lingua del testo che vogliamo utilizzare nell'estrapolazione del testo.
Possiamo aggiungere altre lingue.

Dopo averla selezionata, tramite il pulsante upload+ocr sarà possibile estrapolare il testo, e scaricarlo in formato, testo o word o altro formato.

.Net UWP una app per gestire video ed audio

Si riporta l'articolo scritto per il sito https://www.iprogrammatori.it/articoli/programmazione/art_net-46-realizzare-una-app-per-la-gestion_1541.aspx


In questo articolo vedremo come realizzare in Visual Studio 2017, versione community, un progetto di tipo app, in particolare una Universal Windows Platform (UWP) tramite il linguaggio di programmazione VB.Net e C#.

Creazione del progetto

Si crea un nuovo progetto di tipo Universal Windows Platform, tramite il linguaggio di proprio gradimento.
Dopo la creazione selezioniamo il file di tipo “MainPage.xaml”.

Stesura del codice

Dopo aver selezionato il file di tipo “MainPage.xaml” che permette di visualizzare la parte grafica della nostra app, aggiungiamo un controllo di tipo pulsante ed un controllo di tipo Textblock, dove verrà riportato del testo. A questo punto dopo aver selezionato il controllo pulsante,  nella finestra delle proprietà, facciamo doppio click sull’evento “Click” in modo che viene visualizzata la parte del codice.
Qui di seguito si riporta il frammento di codice dell’evento click di tale pulsante, per entrambi i linguaggi.

VB.Net

Private Async Sub button_Click(sender As Object, e As RoutedEventArgs)

        Dim mediaElement As New MediaElement()

        Dim synthSpeech = New Windows.Media.SpeechSynthesis.SpeechSynthesizer()

        Dim streamSpeechSynthesis As Windows.Media.SpeechSynthesis.SpeechSynthesisStream = Await synthSpeech.SynthesizeTextToStreamAsync("Ciao ragazzi!")

        mediaElement.SetSource(streamSpeechSynthesis, streamSpeechSynthesis.ContentType)

        mediaElement.Play()

        textBlock.Text = mediaElement.NaturalDuration.TimeSpan.TotalMilliseconds.ToString()

    End Sub

C#

private async void button_Click(object sender, RoutedEventArgs e)

        {

            MediaElement mediaElement = new MediaElement();

            var synthSpeech = new Windows.Media.SpeechSynthesis.SpeechSynthesizer();

            Windows.Media.SpeechSynthesis.SpeechSynthesisStream streamSpeechSynthesis = await synthSpeech.SynthesizeTextToStreamAsync("Ciao ragazzi!");

            mediaElement.SetSource(streamSpeechSynthesis, streamSpeechSynthesis.ContentType);

            mediaElement.Play();

            textBlock.Text =  mediaElement.NaturalDuration.TimeSpan.TotalMilliseconds.ToString();

        }

Come si vede dal codice precedente, si crea un oggetto di tipo “MediaElement”, uno di tipo SpeechSyntesizer con il quale andremo ad eseguire la lettura del testo tramite voce di default del pc.
Il metodo “Play” permette l’esecuzione della riproduzione del testo tramite voce.
Aggiungiamo nella nostra pagina, o form, tre pulsanti, ed un controllo di tipo “mediaElement”.
I pulsanti, avranno il compito rispettivamente di avviare l’esecuzione di un video, di metterlo in pausa o di fermarlo.
Mentre il controllo di tipo “MediaElement” di visualizzare il video.
Aggiungiamo nel nostro progetto, anche un file di tipo video.
Impostiamo nei vari pulsante, la proprietà “text” con i valori “Play”, “Ferma” e “Pausa” per ogni pulsante.
Qui di seguito si riporta il codice completo per la parte XAML

 Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">

        <Button x:Name="button" Content="Messaggio" HorizontalAlignment="Left" Margin="55,237,0,0" VerticalAlignment="Top" Click="button_Click"/>

        <MediaElement x:Name="mediaElementControl" Source="Media\WP_20170505_001.mp4" HorizontalAlignment="Left" Height="100" Margin="155,210,0,0" VerticalAlignment="Top" Width="100" MediaOpened="mediaElement_MediaOpened"/>

        <TextBlock x:Name="textBlock" HorizontalAlignment="Left" Margin="55,269,0,0" TextWrapping="Wrap" Text="TextBlock" VerticalAlignment="Top"/>

        <Button x:Name="BtnPlay" Content="Play" HorizontalAlignment="Left" Margin="55,294,0,0" VerticalAlignment="Top" Click="BtnPlay_Click"/>

        <Button x:Name="BtnPausa" Content="Pausa" HorizontalAlignment="Left" Margin="55,331,0,0" VerticalAlignment="Top" Width="62" Click="BtnPausa_Click"/>

        <Button x:Name="BtnFerma" Content="Ferma" HorizontalAlignment="Left" Margin="55,368,0,0" VerticalAlignment="Top" Click="BtnFerma_Click"/>

 

    </Grid

Per il pulsante “Play” facciamo doppio click sull’evento click, in modo che passiamo in visualizzazione codice e scriviamo le istruzioni per avviare il video.

VB.Net

Private Sub BtnPlay_Click(sender As Object, e As RoutedEventArgs)

        mediaElementControl.Play()

       

    End Sub

C#

private void BtnPlay_Click(object sender, RoutedEventArgs e)

        {

            mediaElementControl.Play();

            

        }

Nel frammento di codice precedente, viene eseguito il metodo “Play” del controllo “MediaElement” posizionato in precedenza, ed impostato il percorso e nome del file video nella proprietà “Source”
Per ogni evento click del pulsante, utilizzeremo eventi, quale quello di pausa o ferma esecuzione del video, del controllo MediaElement.
Qui di seguito il frammento di codice di tali istruzioni.

VB.Net

Private Sub BtnPausa_Click(sender As Object, e As RoutedEventArgs)

        mediaElementControl.Pause()

 

    End Sub

 

    Private Sub BtnFerma_Click(sender As Object, e As RoutedEventArgs)

        mediaElementControl.Stop()

    End Sub

C#

   private void BtnFerma_Click(object sender, RoutedEventArgs e)

        {

            mediaElementControl.Stop();

        }

 

        private void BtnPausa_Click(object sender, RoutedEventArgs e)

        {

            mediaElementControl.Pause();

        }

Vediamo per concludere l’evento “MediaOpened” che si verifica quando il controllo MediaElement, prende lo stato attivo, ossia carica nella parte grafica l’immagine.

VB.Net

Private Sub mediaElement_MediaOpened(sender As Object, e As RoutedEventArgs)

        textBlock.Text = mediaElementControl.NaturalDuration.TimeSpan.TotalSeconds.ToString()

    End Sub

C#

private void mediaElement_MediaOpened(object sender, RoutedEventArgs e)

        {

            textBlock.Text = mediaElementControl.NaturalDuration.TimeSpan.TotalSeconds.ToString();

 

        }

Ora non ci resta che eseguire la nostra applicazione, ricordandoci di impostare nel nostro sistema operativo Windows 10 la modalità sviluppatore che permette l’esecuzione delle APP, in modo che possiamo testarle sul nostro dispositivo.

Conclusioni

L’articolo ha voluto fornire al lettore le basi per la multimedialità in particolare la gestione dei video, ed il sistema vocale, per rendere le nostre applicazioni di tipo  app con funzionalità vocale.
Le potenzialità offerte dal nuovo .Net, in particolare delle UWP, sono notevoli offrendo ai programmatori classi, di grande utilità che permettono di utilizzare a pieno le funzionalità offerte dal nuovo sistema operativo Windows 10.
La parte che riguarda la multimedialità offre molto e si possono creare applicazioni di una certa complessità, l'articolo ha voluto solo fornire al lettore come con poco si possono creare applicazioni di un certo tipo.