A DotNet Raider

My adventures in the .NET world!
posts - 38, comments - 11, trackbacks - 0

domenica 28 maggio 2023

Dapr - An introduction to the runtime

Dapr, standing for Distributed Application Runtime, is an open-source event-driven runtime that simplifies the building of resilient microservices-based applications.

It's designed to work with any programming language, any infrastructure, and any cloud provider (Azure, AWS, GCP) and it's part of the Cloud Native Computing Foundation (CNCF) project.

Its main goal is to abstract the complexity of distributed systems and allows developers to focus on business logic rather than the underlying infrastructure (warning: just because the complexity is 'hidden' doesn't mean you should not be aware of what it is and how you would solve it).

These abstractions are called 'Building blocks' and provide APIs for common functionalities like State Management, Service Discovery & Invocation, Publish & Subscribe, Observability, and many others.

No alt text provided for this image

The implementation of a building block is called 'component' and there are several of them ready to use, all configurable using external YAML files and all easily interchangeable.

For example, for the publish\subscribe feature, we have components for RabbitMQ, Redis, AWS SNS/SQS, or GCP Pub/Sub.

No alt text provided for this image

Dapr will run as an external process\container (called Sidecar) and our application will interact with it using HTTP\GRPC or the SDKs available for the main programming languages (.NET, Java, Node, Python, Go).

No alt text provided for this image

We can also use a CLI and a Dashboard to initialize, run, and tests Dapr applications.

No alt text provided for this image

No alt text provided for this image

You can read the full documentation on the official website.

In the next article, we'll see how we can build a sample application using DAPR.

posted @ domenica 28 maggio 2023 17:55 | Feedback (0) | Filed Under [ Dapr Microservices ]

mercoledì 4 gennaio 2017

Accedere a siti su IIS Express dall’esterno

Come sapete non è possibile, salvo configurazioni un pò macchinose, accedere a siti ospitati su IIS Express dall'esterno (altri PC\VM\dispositivi). Esiste tuttavia un modo molto più semplice, che richiede l’installazione di un proxy via NPM npm install -g iisexpress-proxy Una volta installato, basta eseguire il comando iisexpress-proxy 51123 to 3000 Dove
  • 51123 è la porta IIS a cui il sito è raggiungibile (che è dinamica)
  • 3000 è la porta al quale il sito risponderà all’esterno, usando l’ip della scheda di rete primaria.
Se l’ip del mio PC è 192.168.230.126, Il sito sarà ora raggiungibile dall’esterno all’indirizzo: http://192.168.230.126:3000 Su GitHub trovate i dettagli del progetto.

posted @ mercoledì 4 gennaio 2017 17:40 | Feedback (0) | Filed Under [ VISUAL STUDIO ASP.NET Xamarin ]

giovedì 22 ottobre 2015

Parsing di file CSV

Molte volte capita di dover effettuare il parsing di file CSV.

L’implementazione può diventare complessa a piacere (basti pensare all’escape dei caratteri, personalizzazione dei delimitatori, etc) e per questo esistono già librerie che ci permettono di effettuare questa operazione facilmente.

Non tutti sanno (ecco il perchè di questo post) che il framework .NET fornisce già questa funzionalità .

La classe in questione è TextFieldParser, contenuto nell’assembly Microsoft.VisualBasic.

using (TextFieldParser parser = new TextFieldParser(@"C:\temp\sample.csv"))
            {
                parser.CommentTokens = new[] { "#" };
                parser.SetDelimiters(";");
                parser.HasFieldsEnclosedInQuotes = true;

                // Skip over header line.
                //parser.ReadLine();

                while (!parser.EndOfData)
                {
                    string[] fields = parser.ReadFields();
                    if (fields != null)
                    {
                        var specificCulture = System.Globalization.CultureInfo.CreateSpecificCulture("it-IT");
                        var foo = new 
                        {
                            Field1 = fields[0],
                            Field2 = int.Parse(fields[1], specificCulture),
                            Field3 = double.Parse(fields[1], specificCulture),
                            Field4 = DateTime.Parse(fields[1], specificCulture),
                        };
                    }
                }
            }

posted @ giovedì 22 ottobre 2015 16:51 | Feedback (1) |

martedì 20 ottobre 2015

Creare servizi Windows con Topshelf

Da un pò di tempo, quando devo creare un Windows Service, utilizzo la libreria Topshelf, che permette di sviluppare una normale applicazione console e, una volta impostate le opportune configurazioni mediante sintassi fluent, installarla facilmente come windows service, senza tool esterni quali installutil.

Un’applicazione console, oltre ad essere più facile da debuggare, è anche eseguibile direttamente (a differenza di un windows service).

Vediamo quindi come creare un servizio.

1) Apriamo Visual Studio e selezionamo il progetto di tipo “Applicazione console”

 

2) Creiamo una nuova classe che esponga 2 metodi che verranno chiamati allo start e allo stop del servizio

internal class MyConsoleService 
    { 
        public void Start() 
        { 
            System.IO.File.AppendAllText("MyConsoleService.text", string.Format("MyConsoleService start {0}{1}", DateTime.Now, Environment.NewLine)); 
        }

        public void Stop() 
        { 
            System.IO.File.AppendAllText("MyConsoleService.text", string.Format("MyConsoleService start {0}{1}", DateTime.Now, Environment.NewLine)); 
        } 
    }

 

3) Nel metodo Main della classe Program, andiamo a definire i parametri di configurazione del nostro servizio (vi rimando alla documentazione per la spiegazione dettagliata)

class Program 
    { 
        static void Main(string[] args) 
        { 
            HostFactory.Run(hostConfigurator => 
            { 
                hostConfigurator.Service<MyConsoleService>(serviceConfigurator => 
                { 
                    serviceConfigurator.ConstructUsing(() => new MyConsoleService()); 
                    serviceConfigurator.WhenStarted(service => service.Start()); 
                    serviceConfigurator.WhenStopped(service => service.Stop()); 
                });

                hostConfigurator.RunAsNetworkService(); 

                hostConfigurator.StartAutomatically(); // Autostart del Servizio

                hostConfigurator.SetDisplayName("MyConsoleApp Service"); // Nome visualizzato nell'elenco servizi di services.msc 
                hostConfigurator.SetDescription("Servizio creato utilizzando Topshelf"); //  Descrizione visualizzata nell'elenco servizi di services.msc 
                hostConfigurator.SetServiceName("MyConsoleAppService"); // Nome del servizio 
            }); 
        } 
    }

4) Per installare il servizio lanciamo l’exe con il parametro install (digitare il parametro help per vedere l’elenco completo dei comandi)

 

5) Apriamo la console dei servizi di WIndows e verifichiamo la corretta installazione del servizio

6) Avviamo il servizio e controlliamo la creazione del file

 

Come potete vedere Topshelf è molto versatile quanto poco invasivo (solo il passo 3 è relativo alla configurazione dell’infastruttura).

Dategli un’occhiata e dimenticherete presto come si crea un windows service, il relativo installer e il tool installutil.

posted @ martedì 20 ottobre 2015 11:53 | Feedback (1) | Filed Under [ VISUAL STUDIO MISC ]

martedì 16 giugno 2015

Intercettare l'esecuzione di query con Entity Framework Code First

Recentemente ho avuto la necessità di intercettare e manipolare le query generate da Entity Framework.

In particolare dovevo assicurarmi che non venissero estratte dal database le entità la cui proprietà Disabled fosse true (cancellazione logica).

Dalla versione 6 è possibile innestarsi nella pipeline di EntityFramework ereditando dalla classe DefaultExpressionVisitor ed eseguento l'override del metodo Visit, che si occupa di generare l'expression tree che poi verrà convertito in SQL.

Sostanzialmente, se il tipo di entità ha una proprietà Disabled, imposto un filtro verificando che non sia uguale a true.

Per iniettare questo comportamento nella pipeline, basta implementare l'interfaccia IDbCommandTreeInterceptor e aggiungerla mediante il metodo DbInterception.Add(new SoftDeleteInterceptor()).

Ora ogni query di EntityFramework non estrarrà le entità disabilitate.

La cosa è molto utile anche in caso di estrazioni di alberi di oggetti, in quanto se un'entità disabilitata, non si otterrano neanche le entità children, in quanto viene a mancare la condizione di join.

posted @ martedì 16 giugno 2015 11:21 | Feedback (0) | Filed Under [ O/RM SQL Server ]

giovedì 5 febbraio 2015

Generare il modello EDMX con EF CodeFirst

A volte potrebbe tornare utile avere la rappresentazione visuale del modello CodeFirst che stiamo utilizzando, ovvero datto il DbContext CodeFirst, ottenere il file EDMX corrispondente:

EDMX

Il tutto è facilmente ottenibile con poche righe di codice: