Quando si sviluppano applicazioni Asp.Net Core con Azure può verificarsi il seguente messaggio di errore "System.MissingMethodException: 'Method not found: 'Void Microsoft.AspNetCore.Mvc.RazorPages.RazorPagesOptions.set_AllowAreas(Boolean)'." questo perchè la versione del pacchetto "Microsoft.AspNetCore.Authentication.AzureAD.UI" non è aggiornato con la versione del Framework.
Aggiornare con l'ultima versione tramite Nuget, e rieseguire la propria applicazione.
"Parametri":
{
"ResponsabileArea":
"Luigi",
"Direttore":
"Emanuele",
"ResponsabilePersonale":
"Olga",
"Aree": [ "Tenica",
"Amministrazione", "Personale" ]
}
{
"Logging": {
"LogLevel": {
"Default":
"Information",
"Microsoft":
"Warning",
"Microsoft.Hosting.Lifetime":
"Information"
}
},
"AllowedHosts": "*",
"Parametri": {
"ResponsabileArea":
"Luigi",
"Direttore":
"Emanuele",
"ResponsabilePersonale":
"Olga",
"Aree": [ "Tenica",
"Amministrazione", "Personale" ]
}
}
C#
public void
ConfigureServices(IServiceCollection services)
{
string ValoreResponsabileArea =
Configuration.GetValue<string>("Parametri:ResponsabileArea");
string ValoreDirettore =
Configuration.GetValue<string>("Parametri:Direttore");
string ValoreResponsabilePersonale
= Configuration.GetValue<string>("Parametri:ResponsabilePersonale");
services.AddControllersWithViews();
}
C#
public class Parametri
{
public string ResponsabileArea { get;
set; }
public
string Direttore { get; set; }
public string ResponsabilePersonale {
get; set; }
public List<string> Aree { get;
set; }
}
C#
public void
ConfigureServices(IServiceCollection services)
{
Parametri parametri =
Configuration.GetSection("Parametri").Get<Parametri>();
services.AddControllersWithViews();
}
C#
public class Parametri
{
public string ResponsabileArea { get;
set; }
public static string Direttore { get;
set; }
public string ResponsabilePersonale {
get; set; }
public List<string> Aree { get;
set; }
}
C#
public void
ConfigureServices(IServiceCollection services)
{
Parametri parametri =
Configuration.GetSection("Parametri").Get<Parametri>();
services.AddControllersWithViews();
}
HomeController.cs
public
IActionResult Index()
{
ViewBag.Direttore =
Parametri.Direttore;
return View();
}
Index.cshtml
@{
ViewData["Title"] = "Home
Page";
}
<div
class="text-center">
<h1
class="display-4">Pagina esempio</h1>
<p>Il nome del direttore : @ViewBag.Direttore .</p>
</div>
@model
string
@{
ViewData["Title"] = "Home
Page";
}
<div
class="text-center">
<h1
class="display-4">Gestione Cookie</h1>
<p>Gestione dei cookie</p>
<br />
<a
href="@Url.Action("AggiungiCookie", "Home")">Aggiungi
Cookie</a>
<a
href="@Url.Action("RilevaCookie",
"Home")">Rileva Valore Cookie</a>
<a
href="@Url.Action("EliminaCookie",
"Home")">Elimina Cookie</a>
<br /><br /> Valore cookie
rilato:<br />
@{
if (Model != null)
{
<div>@Model</div>
}
}
</div>
Controller
C#
public
IActionResult AggiungiCookie()
{
string chiaveCookie =
"NomeChiave";
string ValoreCookie =
"Valore";
CookieOptions objCookie = new
CookieOptions();
objCookie.Expires =
DateTime.Now.AddDays(20);
Response.Cookies.Append(chiaveCookie,
ValoreCookie, objCookie);
return View("Index");
}
public
IActionResult RilevaCookie()
{
string ValoreRilevato =
Request.Cookies["NomeChiave"];
return View("Index",
ValoreRilevato);
}
C#
public IActionResult EliminaCookie()
{
string chiaveCookie =
"NomeChiave";
string ValoreCookie =
"Valore";
CookieOptions objCookie = new
CookieOptions();
objCookie.Expires =
DateTime.Now.AddDays(-1);
Response.Cookies.Append(chiaveCookie, ValoreCookie, objCookie);
return View("Index");
}
Si riporta l'articolo scritto per il sito https://www.iprogrammatori.it/articoli/microsoft-net-framework/art_aspnet-core-mvc-la-validazione-dei-controlli-in-c-in-net-5_1754.aspx
In questo articolo vedremo come effettuare la validazione dei controlli di tipo caselle di testo nelle applicazioni di tipo Asp.Net MVC Core.
Utilizzeremo l’ultima versione del Framework, la 5, con il linguaggio di programmazione C# e l’ambiente di sviluppo Visual Studio 2019.
Quando si sviluppano applicazioni web, può tornare utile impostare nel modello, ossia la classe che farà da modello per la pagina web, alcuni attributi come l’obbligo di scrivere nel campo, oppure che rispetta un determinato intervallo come può essere per i campi di tipo intero, oppure che rispetta una certa formattazione come possono essere i campi per il codice fiscale o indirizzo email o altro.Questi messaggi saranno visualizzati a video, non appena si proverà ad inserirli.
Il tutto sarà come mostrato in figura 1.
Figura 1 - La pagina con i controlli ed i messaggi di validazione.
Creazione del progetto
Si crea un nuovo progetto Asp.net MVC Core, selezionando come versione del Framework la 5, che al momento in cui stiamo scrivendo l’articolo è l’ultima. Come linguaggio di programmazione selezionare C# nell'ambiente di sviluppo Visual Studio 2019 community.
Stesura del codice
Dopo aver creato il progetto, occorre fare click sulla cartella “Models” e tramite il tasto destro, selezionare dal menu che viene visualizzato la voce “Aggiungi” e nel sottomenu la voce “Classe”.
La classe sarà il modello che utilizzeremo nella pagina, ossia nella View, con i campi che avranno obbligatorietà oppure che devono rispettare alcuni criteri.
Dopo aver fatto click sul nome “Classe”, digitiamo come nome classe “Anagrafica”.
Il modello avrà delle proprietà, di tipo “intero” e “string” con attributi per visualizzare a seconda del campo un determinato messaggio.
Qui di seguito si riporta la classe “Anagrafica” con i vari campi
C#
public class
Anagrafica
{
[Required(ErrorMessage = "Campo
Nome obbligatorio")]
public string Nome { get; set; }
[Required(ErrorMessage = "Campo
Cognome obbligatorio")]
public string Cognome { get; set; }
[Required(ErrorMessage = "Campo
Età obbligatorio")]
[Range(0, 110, ErrorMessage
="Valore non valido")]
public int? Eta { get; set; }
[StringLength(16,ErrorMessage ="Il
codice fiscale dev'essere composto da 15 caratteri")]
[RegularExpression(@"^.*[A-Z]{6}\d{2}[A-Z]\d{2}[A-Z]\d{3}[A-Z]$",
ErrorMessage ="formato codice fiscale errato")]
public string CodiceFiscale { get; set;
}
}
Come si vede dal frammento di codice precedente, abbiamo campi obbligatori di tipo string come il campo “Nome” e “Cognome”. Un campo di tipo “Intero” denominato “Eta” che è obbligatorio e che deve rispettare un determinato intervallo, altrimenti visualizza un messaggio, un campo di tipo string, in cui deve rispettare una determinata formattazione ed avrà una lunghezza massima di 16 caratteri.
Terminata la creazione della classe del modello per la gestione delle informazioni, non ci resta che completare il codice, sia lato della pagina stessa e sia per la gestione dei dati.
Nel file controller, si crea un metodo che passato il modello creato in precedenza, verifica se i dati sono validi, ossia rispettano i criteri che abbiamo configurato per ogni singola proprietà, quale la valorizzazione della stessa, oppure rispetta l’espressione regolare o l’intervallo dei dati. Inoltre si farà un controllo se il valore inserito nella casella Nome è uguale a “Emanuele”, in tal caso verrà visualizzato un messaggio di errore. Questo esempio di codice può essere usato con la gestione dei dati, prima che avvenga l’inserimento nel database, fornendo all’utente un messaggio che il dato inserito (per esempio creazione di un account) è già presente nella base dati.
Nel file Controller, denominato “HomeController”, scriviamo un metodo post, con il quale tramite la proprietà “IsValid” verifichiamo se i dati inseriti nella form sono corretti, in tal caso vengono rilevati i vari valori verificando al tempo stesso che il campo “Nome” è diverso da “Emanuele”, in caso contrario visualizzerà all’utente un messaggio di errore.
Nel caso che invece il modello non è valido perché presenti gli errori, viene visualizzato il codice per rilevare il testo dell’errore, anche se questo codice non servirebbe, perché il messaggio di errore verrà visualizzato a video nella pagina, ma lo scriviamo per fornire al lettore informazioni utili nel caso che vuole gestire tramite un log o altro, le informazioni di errore dell’inserimento dati del form.
Qui di seguito il metodo da per la gestione dei dati.
HomeController.cs
[HttpPost]
public IActionResult Inserisci(Anagrafica
anagrafica)
{
if (ModelState.IsValid )
{
string Nome = anagrafica.Nome;
string Cognome =
anagrafica.Cognome;
int eta = anagrafica.Eta.Value;
string codiceFiscale =
anagrafica.CodiceFiscale;
if (Nome ==
"Emanuele")
{
ModelState.AddModelError("Nome", "Nome presente sulla
base dati.");
return View("Index",
anagrafica);
}
return View("Index");
}
else
{
foreach (var Elemento in
ModelState.Values)
{
foreach (var Errore in Elemento.Errors)
{
string ErroreRilevato =
Errore.ErrorMessage;
}
}
}
return View("Index");
}
Siamo giunti quasi alla conclusione dell’articolo, non ci resta che scrivere la form per l’inserimento dei dati e la gestione dell’evento click del pulsante e del modello.
Facciamo click sul file denominato “Index.cshtml”, in alto, sopra ad ogni dichiarazione, scriviamo il riferimento al modello.
Qui di seguito le suddette dichiarazioni.
Index.cshtml
@model
Anagrafica
Terminata l'aggiunta del modello, nel div, dobbiamo inserire un tag form, dove come action si fa riferimento al metodo creato in precedenza e di tipo post.
Nel form, avremo un metodo di tipo “ValidationSummary” che permette di visualizzare in maniera tabellare, come un sommario, gli errori rilevati nella form, visualizzando il messaggio per ogni proprietà, inoltre per ogni casella di testo, ossia un controllo TextBox, tramite il metodo “ValidateMessage” visualizzerà il messaggio di errore, nel caso che non rispetta i criteri impostati nelle proprietà.
Qui di seguito la form completa del file Index.cshtml
@model
Anagrafica
@{
ViewData["Title"] = "Home
Page";
}
<div
class="text-left">
<h1
class="display-4">Esempio campi obbligatori</h1>
<form action="Home/Inserisci"
method="post">
@Html.ValidationSummary(false,
"", new { @class = "text-danger" })
<label>Nome</label><br
/>
@Html.TextBox("Nome") <br
/>
@Html.ValidationMessage("Nome")
<label>Cognome</label><br />
@Html.TextBox("Cognome")
<br />
@Html.ValidationMessage("Cognome")
<br />
<label>Eta</label><br
/>
@Html.TextBox("Eta") <br
/>
@Html.ValidationMessage("Eta")
<br />
<label>Codice
Fiscale</label><br />
@Html.TextBox("CodiceFiscale") <br />
@Html.ValidationMessage("CodiceFiscale")
<button id="BtnEsegui"
type="submit">Esegui</button>
</form>
</div>
Conclusioni
Ora non resta che eseguire il nostro applicativo e fare le varie prove, verificando la correttezza della validazione dei dati, e fare la prova anche inserendo nella casella “Nome” il testo “Emanuele”.
L’articolo ha voluto fornire al lettore informazioni utili sulla gestione dei campi, che in Asp.Net MVC Core, è completamente diverso dal precedente sviluppo con la tecnologia Asp.Net.
Oltre a visualizzare i messaggi di errore per i singoli campi, si è visto come utilizzando il metodo “ValidationSummary” è possibile visualizzare la lista degli errori, in maniera tabellare come un sommario.
Si riporta l'articolo scritto per il sito https://www.iprogrammatori.it/articoli/microsoft-net-framework/art_c-aspnet-mvc-core-visualizzare-anteprima-di-immagine-con-net-5_1751.aspx
In questo articolo vedremo come impostare nelle nostre pagine web, in particolare con la tecnologia Asp.Net MVC e l’ambiente di sviluppo Visual Studio 2019 Community, la possibilità di selezionare un file immagine nel nostro pc, e visualizzarne l’anteprima.
Inoltre sarà possibile dallo stream dati del file immagine, salvare su un percorso del nostro computer il file che viene visualizzato in anteprima
Il linguaggio di programmazione che utilizzeremo è C#, con l’ultima versione del Framework che è la .Net 5
In figura 1, il risultato dell’anteprima dell’immagine.
Figura 1 - La form dei dati
Creazione del progetto
Si crea un nuovo progetto di tipo Asp.Net MVC Core selezionando la versione del Framework 5.
La pagina web sarà formato da due campi di testo, che contengono informazioni come nome e cognome, ed un controllo per il caricamento dei file ed un tag di tipo immagine ed un campo nascosto dove andremo a salvare lo stream della foto. Il pulsante Inserisci permetterà di passare al controller le informazioni relative ai campi e lo stream del file immagine.
Stesura di codice
Dopo aver creato il progetto, dobbiamo creare una classe per la gestione dei dati, che sarà utilizzata nel controller, questo modello sarà utilizzato nella pagina web.
Nella cartella “Model” facciamo click con il tasto destro e dal menu che viene visualizzato, selezioniamo “Classe” dal sotto menu “Nuovo Elemento”, impostiamo un nome alla classe, nel nostro caso denominata “Anagrafica” e si creano 4 proprietà, tre di tipo string ed una di tipo byteArray che sarà utilizzata per la gestione dei dati.
Qui di seguito le suddette dichiarazione della classe “Anagrafica”
C#
public class Anagrafica
{
public string Nome { get; set; }
public string Cognome { get; set; }
public byte[] Logo { get; set; }
public string LogoStream { get; set; }
}
Le proprietà del modello Anagrafica, si possono utilizzare anche per gestire i dati nel caso che si fa uso di un database e quindi per le operazioni relative ad inserimento, lettura, agigornamento e cancellazione.
Questo modello che abbiamo appena creato lo utilizzeremo nella pagina web.
Nella cartella View, facciamo click sulla pagina denominata "Index” ed utilizzeremo questo modello
Qui di seguito il frammento di codice per la creazione della pagina di inserimento.
Nella pagina Index.cshtml, scriviamo, in alto sopra ad ogni dichiarazione, il riferimento a questo modello, in modo che possiamo utilizzarlo nella nostra pagina web.
Il tutto sarà come il frammento qui di seguito.
@model Anagrafica
Qui di seguito il codice relativo alla pagina web, in cui vengono definitivi campi, il pulsante e la gestione dei dati e dell'immagine quando viene fatto click sul pulsante "Inserisci".
Cshtml:
<div
class="text-center">
Esempio Anteprima Immagine
<br />
@using (Html.BeginForm("InserisciAnagrafica",
"Home", FormMethod.Post))
{
<label>Nome</label>
@Html.TextBox("Nome")
<br />
<label>Cognome</label>
@Html.TextBox("Cognome")
<br />
<label>Immagine</label>
<input type="file"
accept="*.jpg" name="Immagine" id="Immagine"
onchange="Anteprima(this)" /><br />
<br /><img id="Logo"
style="width:100px; height:100px"
src="#" alt="Anteprima" name="Logo" /><br />
<input type="hidden"
id="LogoStream" name="LogoStream" />
<button type="submit"
id="Inserisci">Inserisci</button>
}
</div>
Il controllo input file permette di visualizzare nella finestra di dialogo solo i file di tipo “.jpg” per aver impostato nella proprietà “accept” il valore “*.jpg”. La proprietà “OnChange” è impostata su una funzione Javascript che permette di visualizzare l’anteprima dell’immagine.
La funzione “Anteprima” di Javascript, verifica se il file è di tipo Jpg, ed in tal caso, rileva lo stream dati del file, impostandolo nel tag di tipo immagine e nel controllo nascosto che sarà utilizzato per generare il file immagine.
Qui di seguito il frammento di codice delle suddette operazioni.
<script>
function Anteprima(Input) {
var file = Input.files[0];
if (file) {
var Estensione = ['jpg'];
if
($.isArray(file.name.split('.').pop().toLowerCase(), Estensione)==-1) {
Alert('File non valido.');
return;
}
var reader = new FileReader();
reader.onload = function () {
$("#Logo").attr("src", reader.result);
$("#LogoStream").val(reader.result);
}
reader.readAsDataURL(file);
}
}
</script>
Terminata la parte relativa alla pagina web, dobbiamo scrivere il codice che dal controller rileva le informazioni dalla pagina al click del pulsante.
Il metodo di tipo “Post” accetta come parametro il modello precedentemente creato, dove nella proprietà “LogoStream” viene passata la stringa relativa allo stream dati dell’immagine, che verrà convertita in array di byte.
Nel seguente codice, oltre alle informazioni ai dati inseriti nei campi verrà salvato il file di tipo immagine su disco locale, oppure nel caso che si fa uso di una base dati, utilizzare l'array di byte per salvarle in qualche campo.
Qui di seguito il metodo “InserisciAnagrafica” nel controller “home” che verrà richiamato dalla pagina web, passando il modello “Anagrafica” con i dati inseriti nella pagina.
Controller
C#
[HttpPost]
public ActionResult
InserisciAnagrafica(Anagrafica anagrafica)
{
if
(!string.IsNullOrEmpty(anagrafica.LogoStream))
{
int valore = anagrafica.LogoStream.IndexOf(',') + 1;
byte[] byteArray = Convert.FromBase64String(anagrafica.LogoStream[valore..^0]);
System.IO.File.WriteAllBytes("C:\\Varie\\MioFile.jpg",
byteArray);
}
return View("Index");
}
Conclusioni
L’articolo ha voluto fornire al lettore una tecnica per aggiungere alle proprie applicazioni web di tipo Asp.Net MVC o Asp.Net MVC Core, la possibilità di visualizzare le immagini rilevate dal proprio pc, per poi salvarle o su pc o in una base dati.
Questo scenario si può applicare in tutte quelle applicazioni con il quale prima di salvare i dati, devono verificare se l’immagine selezionata è corretta o altro, fornendo un’anteprima.
Quando si sviluppa in Asp.Net MVC Core, e si vogliono visualizzare alcuni messaggi di errore perchè non rispettano un intervallo oppure perchè sono obbligatorio, per il campo di tipo Int, si può verificare che venga visualizzare il messaggio "The Value '' is invalid".
Per risolvere questo occorre rendere il campo nullable ed impostare gli attributi di campo richiesto e range.
Qui di seguito le suddette operazioni per un campo che è obbligatorio e che deve rientrare in un intervallo.
[Required(ErrorMessage = "Campo Età obbligatorio")]
[Range(0, 110, ErrorMessage ="Valore non valido")]
public int? Eta { get; set; }
Si riporta l'articolo scritto per il sito https://www.iprogrammatori.it/articoli/microsoft-net-framework/art_utilizzo-di-stored-procedure-con-entity-framework-core-in-aspnet-core_1747.aspx
In questo articolo vedremo come utilizzare le stored procedure realizzate in Microsoft Sql Server, in Asp.Net MVC core tramite il linguaggio di programmazione C# e versione del Framework 5.0.
Come ambiente di sviluppo utilizzeremo Visual Studio 2019 Community, un ambiente gratuito per lo sviluppo di vari progetti.
L’articolo vuole fornire le basi per la creazione di applicazioni web con l’ultima versione del Framework utilizzando Entity Framework Core.
Vedremo come accedere alla fonte dati, partendo dalla creazione di una classe.
La schermata per visualizzare i dati sarà simile alla figura 1.
Figura 1 – Pagina per la visualizzazione dei dati.
Creazione della Stored Procedure
Utilizzeremo la tabella Anagrafica, già utilizzata in vari articolo, che è composta da 4 colonne, IdAnagrafica, che è un campo chiave, nome, cognome e Ruolo che sono campi di tipo Varchar 50.
La stored Procedure che si crea, permette di selezionare i record che corrispondo al parametro passato.
Qui di seguito la SP per la ricerca dei dati nella tabella Anagrafica
CREATE PROCEDURE [dbo].[Trova]
@Nome
VARCHAR(50)
AS
BEGIN
SET NOCOUNT ON;
IF(@Nome IS NULL OR @Nome = '')
SELECT * from
Anagrafica
ELSE
SELECT * from
Anagrafica
where Nome like '%' + @Nome + '%'
END
Terminata la creazione della SP e verificato il corretto funzionamento dobbiamo creare il progetto.
Creazione del progetto
Si crea un nuovo progetto di tipo Asp.Net Core MVC con versione del Framework 5.0.
Dopo aver aperto visual Studio 2019 Community, selezionare il modello “app web Asp.Net Core (Model-View-Controller) , il tutto come mostrato in figura 2
Figura 2 – Il modello da selezionare.
Facciamo click sul pulsante “Avanti” ed impostiamo un nome, di nuovo click sul pulsante “Avanti” e selezioniamo la versione 5.0, a questo punto click sul pulsante “Fine”.
Una volta creato il progetto, occorre aggiungere i riferimenti a Nuget, in particolare ad Entity Framework e precisamente a “Microsoft.EntityFrameworkCore.SqlServer”, il tutto come mostrato in figura 3.
Figura 3 – Il rifermento a Entity Framework Sql Server
Ora non resta che scrivere il codice per la gestione dei dati, creando classi appositamente per la gestione dell’entità e dei dati.
Stesura del codice
Si crea un nuova classe denominata “Anagrafica” che avrà la funzionalità di gestire i dati della tabella “Anagrafica” creata in precedenza.
La classe avrà le proprietà con lo stesso nome delle colonne della tabella e dello stesso tipo.
Qui di seguito la dichiarazione di tale classe.
public class
Anagrafica
{
public
Int32 IDAnagrafica { get; set; }
public
string Nome { get; set; }
public string Cognome { get; set; }
public string Ruolo { get; set; }
}
Terminata la creazione della classe per la gestione dei dati, dobbiamo creare il contesto, ossia una classe che permette di gestire l’entità appena creata con la base dati, e quindi il mapping e la creazione del metodo per la ricerca dei dati, invocando la Stored Procedure appena creata.
La Stored Procedure sarà invocata utilizzando il metodo “FromSqlRaw” che è l’estensione dello spazio dei nomi di EntityFrameworkCore inserito precedentemente.
Si crea una nuova classe denominata “DBCtx” che dovrà gestire i dati.
La classe sarà come riportato qui di seguito.
C#
using
System.Linq;
using
Microsoft.EntityFrameworkCore;
namespace
WebArtEFCore
{
public class DBCtx : DbContext
{
public
DBCtx(DbContextOptions<DBCtx> options)
: base(options)
{
}
protected override void
OnModelCreating(ModelBuilder modelBuilder)
{
modelBuilder.Entity<Anagrafica>(entita
=>
{
entita.HasKey(p =>
p.IDAnagrafica);
});
}
public DbSet<Anagrafica>
Anagrafiche { get; set; }
public IQueryable<Anagrafica>
Ricerca(string Nome)
{
return
this.Anagrafiche.FromSqlRaw("EXECUTE Trova {0}", Nome);
}
}
}
Come si è visto nel frammento di codice precedente, si è creata una classe che avrà il compito di fare da “ponte” tra l’applicativo ed il database, con questa classe che gestisce la fonte dati. A differenza di quando si usa l’autocomposizione di Entity Framework che crea in automatico la classe per il mapping, ossia la classe del contesto (DBcontext) in questo scenario siamo noi a creare la gestione della fonte dati.
Il metodo FromSqlRaw permette di eseguire stored procedure ed istruzioni SQL , nel nostro caso, esegue la nostra stored Procedure passando un valore.
La classe DbSet fornisce alla classe che abbiamo creato in precedenza i metodi per la gestione dell’entità nei confronti della base dati, che avviene tramite lo spazio dei nomi “Microsoft.EntityFrameworkCore”.
Ora che abbiamo terminato la parte di stesura codice per la gestione delle query e dell’estrapolazione dei dati, dobbiamo impostare la connessione al database, la connectionstring.
Facciamo click sul file denominato “appsettings.json” ed impostiamo il tag “ConnectionString”, qui di seguito si riporta il codice completo di questo file con la connessione alla base.
{
"Logging": {
"LogLevel": {
"Default":
"Information",
"Microsoft":
"Warning",
"Microsoft.Hosting.Lifetime":
"Information"
}
},
"ConnectionStrings": {
"MyConn": "Data Source=NomeServer\\SQLEXPRESS;Initial
Catalog=Dati;Integrated security=true"
},
"AllowedHosts": "*"
}
Ora impostiamo il riferimento della connectionstrings alla nostra classe, andiamo nel file “Startup.cs” e nell’evento “ConfigureServices” aggiungiamo l’istruzione per impostare tale connessione alla nostra classe.
Qui di seguito il frammento di codice delle suddette dichiarazioni.
C#
public void ConfigureServices(IServiceCollection services)
{
services.AddControllersWithViews();
services.AddMvc();
string conStr = this.Configuration.GetConnectionString("MyConn");
services.AddDbContext<DBCtx>(options => options.UseSqlServer(conStr));
}
Ora dobbiamo gestire questi dati sia nella parte della pagina e sia nel controller.
Andiamo nel controller, nel file denominato “HomeController.cs” e dichiariamo un oggetto per questo controller che fa riferimento alla classe Context.
Qui di seguito le dichiarazione di quanto anticipato.
C#
DBCtx contesto;
Nel costruttore inizializziamo il nostro oggetto impostando il riferimento alla connectionStrings, qui di seguito tale dichiarazione.
C#
public
HomeController(DBCtx _context)
{
contesto = _context;
}
Ora non resta che creare negli eventi Index, il caricamento dei dati, in uno il caricamento di tutti dati quando si apre la pagina, mentre un altro evento index di tipo “Post” quando si vuole effettuare una ricerca per nome.
Qui di seguito i frammenti di codice delle suddette dichiarazioni.
C#
public
IActionResult Index()
{
List<Anagrafica> Anagrafiche =
contesto.Ricerca("").ToList();
return View(Anagrafiche);
}
[HttpPost]
public IActionResult Index(string Nome)
{
List<Anagrafica> Anagrafiche
= contesto.Ricerca(Nome).ToList();
return View(Anagrafiche);
}
Ora passiamo nella parte view, in particolare nel file “Index.cshtml”, e scriviamo il codice per visualizzare a video una tabella con i dati ed i campi per la ricerca.
Qui di seguito si riporta il codice completo della pagina index con il quale vengono visualizzati i dati della base dati in forma tabellare.
Index.cshtml
@{
ViewData["Title"] = "Home Page";
}
@model
List<Anagrafica>;
<div
class="text-center">
<h1
class="display-4">Esempio di utilizzo SP</h1>
<form method="post"
asp-controller="Home" asp-action="Index">
<span>Filtra per
nome:</span><input type="text" name="Nome" />
<input type="submit"
value="Cerca" />
<br />
<br />
<table cellpadding="0"
cellspacing="0">
<tr>
<th>Id</th>
<th>Nome</th>
<th>Cognome</th>
<th>Ruolo</th>
</tr>
@foreach (Anagrafica elemento in
Model)
{
<tr>
<td>@elemento.IDAnagrafica</td>
<td>@elemento.Nome</td>
<td>@elemento.Cognome</td>
<td>@elemento.Ruolo</td>
</tr>
}
</table>
</form>
</div>
Il codice è facilmente comprensibile, dopo aver creato un oggetto di tipo list “Anagrafica” effettua un ciclo di tutti record creando una tabella. Tramite il metodo post di “Index” passando come valore il testo presente nella casella di testo, effettua la ricerca dei dati invocando la storedprocedure.
Conclusioni
L’articolo ha voluto fornire al lettore le basi per creare applicazioni web multipiattaforma con Asp.Net CORE MVC e l’uso di Entity Framework Core, senza utilizzo dell’autocomposizione ma creando tutto da codice la mappatura dei dati tra l’applicazione ed il database.
Un articolo che fornisce le basi per iniziare a scrivere applicazioni in questo ambito, che sarà sempre più utilizzato.
Post
Tutti i commenti
Le opere pubblicate in questo blog sono sotto la licenza Creative Commons. Attribuzione- No commerciale e no derivate.
