1. Creare un database su SQL Server Standard o Enteprise.
2. Successivamente, con SQL Management Studio Express creare una copia di backup del database per ripristinarlo su un’altra macchina.
3. Cercare di ripristinare il backup effettuato sulla nuova macchina (utilizzando sempre SQL Management Studio Express) ed ottenete un messaggio di errore che tra le righe riporta Accesso Negato.

Ci ho pensato parecchio, un problema cosi da cosa può dipendere? Allora ho provato a seguire una strada diversa. Mi sono collegato direttamente alla macchina server che monta motore di database ed SQL Management Studio, da qui creo il backup. Successivamente, sulla macchina dove voglio ripristinare il backup, eseguo l’operazione senza alcun problema, questa volta utilizzando SQL Management Express.

Ora mi chiedo, ci sono differenze? Sicuramente ma avrò perso qualche passaggio, un backup viene visto in maniera molto differente se effettuato da una versione Express ad una Studio! Questa è una piccola nota, nel caso vi dovesse accedere quanto è successo a me, potete sempre tentare questa strada, attualmente sto analizzando il problema per capire “dove sbaglio” (perchè sicuramente dipende, come dicevo prima, dalla mia inettitudine ).

Share on Facebook

Il connection pooling è una cache delle connessioni mantenute dal database, queste rimangono in memoria per un determinato periodo di tempo T, durante il quale il db, per richieste esterne, può erogare ottenendo cosi un servizio più veloce.

Il concetto è semplice, il server di database non chiude subito le connessioni al db, al contrario le lascia aperte in attesa che qualcuno possa richiederle. Come si attiva questo meccanismo? Basta modificare attentamente la connection string all’interno del web.config della nostra applicazionie come nel seguente esempio:

<configuration>
 <connectionStrings>
  <add name="Connessione"
            ConnectionString="Server=localhost;Integrated Security=SSPI;Pooling=true;Min Pool Size=1; Max Pool Size=10" />
 </connectionStrings>
</configuration>

Sostanzialmente sono stati inseriti tre parametri all’interno della connessione:

• Min Pool Size: numero minimo di connessioni su cui applicare il pooling (quindi cache e riutilizzo);
• Max Pool Size: numero massimo di connessioni su cui applicare il pooling;
• Pooling: con questa proprietà stiamo attivando il meccanismo di pool per la ConnectionString;

Attenzione, Min Pool Size e Max Pool Size, hanno importanza assoluta. Questi due valori vanno impostati dopo un attento studio in quanto determinano proprio l’aumentare o meno delle performance del server sql, se configurati male possono creare più rallentamenti che benefici. Se per esempio ho un’applicazione web in cui sò per certo che avrò un numero di connessioni minime simultanee di 10 persone, logicamente imposterò il mio Min Pool Size = 10.
Spero possa aiutarvi! Enjoy!

Share on Facebook

internal class Shuffle<T>
{
    internal List<T> Execute(List<T> list)
    {
        return Execute(list, list.Count);
    }

    internal List<T> Execute(List<T> list, int size)
    {
        List<T> values = new List<T>(size);
        Random r = new Random();
        int index = 0;
        while ((list.Count > 0) && (values.Count < size))
        {
            index = r.Next(list.Count);
            values.Add(list[index]);
            list.RemoveAt(index);
        }
        r = null;
        return values;
    }

    internal List<T> Execute(List<T> list, double perc)
    {
        int size = Round(perc * list.Count);
        return Execute(list, size);
    }

    internal static int Round(double d)
    {
        Random r = new Random();
        double rvalue = r.NextDouble();
        int id = unchecked((int)(Math.Floor(d)));
        double pd = (d - Math.Floor(d));
        r = null;

        return (rvalue > pd) ? id : id + 1;
    }

}

Uno dei tanti modi per usare i Generics.

Share on Facebook

Partiamo da una lista dei principali steps di cui si compone la generazione di una pagina web asp.net:

1. Inizializzazione
2. Costruzione dei controlli
3. Gestione dello stato
4. Gestione degli eventi (event handler)
5. Disegno della pagina (rendering)

Dove tutto ha inizio.

Ma da dove parte tutto? Semplice! Da una richiesta Page Request, il framework, in base alle impostazioni decide se inizializzare nuovamente la pagina o prenderne una copia dalla cache (vi consiglio di leggere qualcosa a riguardo: caching, outputCache); proprietà della pagina come Request e Response vengono impostate, la Request viene inizializzata in base al tipo di richiesta, cioè se la pagina viene caricata per la prima volta o se è in PostBack (tra le proprietà della pagina ce n’è proprio una che si chiama IsPostBack, ovviamente sarebbe opportuno leggere qualcosa anche su questa variabile che differisce come significato dall’argomento outputCahce) ed infine vengono caricate le proprietà relative alla Cultura (ICulture).

Il caricamento

Subito dopo vengono inizializzati tutti i controlli presenti nella pagina, per riassumere: tutti gli elementi html con attributo runat=”server” ed identificati da un ID univoco.
Poi si passa al Caricamento, Load, se la pagina è in PostBack i dati dei controlli vengono caricati dal ViewState (solamente se nella direttiva Page, EnableViewState è impostato a true), in caso contrario viene eseguita la logica descritta dallo sviluppatore.

La validazione

Validation, viene richiamato il metodo di Validazione di ogni controllo per capire se questo ha subito variazioni problematiche. Se la pagina è in PostBack, vengono eseguiti i metodi chiamanti (es. pressione di un bottone a cui è collegato un evento).

Il disegno

Finalmente arriviamo al Disegno vero è proprio, Rendering, attraverso il quale la pagina viene disegnata, un OutputStream carica al suo interno il contenuto HTML generato da ogni controllo presente in essa(si perchè ognuno di essi contiene un metodo che si chiama RenderControl che accetta un HttpTextWriter su cui rilascia codice html per quanto riguarda “se stesso”) e poi di volta in volta per tutti gli altri elementi presenti.

Il rilascio

Alla fine, viene avviata un operazione di “pulizia” (si perchè il framework vuole ordine), cosi si passa al processo di Unload. Una volta che la pagina è stata disegnata ed inviata al richiedente tutte le sue proprietà vengono rilasciate (si parla proprio di Dispose).

Molto importante in questo contesto è il concetto di Event wire-up, ASP.NET cerca di trovare dei metodi che corrispondono ad una denominazione convenzionale (Page_Load, Pag_Init etc.), è possibile attivare o meno questo comportamento (che per Default è lo è già) impostando la proprietà (nella System.Page) AutoEventWireup su true/false.
Con questo breve articolo ho cercato di fornire qualche spiegazione in più, utile durante quei lunghi debug dove delle volte ci riesce davvero difficile capire dove risieda il problema ma più in generale anche per avere più chiarezza sulle strumentazioni che si utilizzano!

Share on Facebook

Non continuo a parlavi di questo assurdo discorso, ma effettivamente qui al sud è un pò cosi, se non fai un lavoro in cui la sera torni a casa stanco per la fatica fisica, non è un lavoro, semplicemente stai facendo ciò che ti piace e se lo fai significa che è automaticamente gratis! No comment

Share on Facebook

Il primo è una persona che fà del suo lavoro un’arte, ci mette tutta la sua passione, le sue risorse, la sua buona volontà, per produrre qualcosa che successivamente riterrà essere “una sua creazione”, penso di aver incontrato davvero poche persone che si possano chiamare “Artisti del Software”, al contrario, mi sono ritrovato a lavorare moltissime volte con gli atleti, voi vi chiedere ma chi sono?. Persone che si caratterizzano per la velocità con cui producono software e successivamente per la stessa lentezza con cui sono costretti a risolvere problemi non previsti(?). Paragonate un atleta sviluppatore a me che vado in palestra il primo giorno, prefisco evitare i consigli del personal trainer ed inizio subito ad allenarmi iniziando con una corsa di 40 minuti e subito dopo una quantità industriali di pesi, arrivo a fine allenamento soddisfatto e stanco per quanto fatto, il giorno dopo mi ritrovo a fare i conti con l’acido lattico nei muscoli ed il dolore che mi rende impossibile qualsiasi movimento. In realtà l’atleta sviluppatore ha come obiettivo sviluppare e rilasciare in tempi record ed applica perfettamente il mio modo di fare in palestra (tradotto: copia codice, cerca di arrangiare il software, evita l’informazione e l’aggiornamento a favore di tecniche antiquate ma che lui conosce bene, etc. etc.).
Perchè scrivo questo post? Perchè ultimamente mi piace visitare forum e fornire aiuto (nel limite del possibile) ed è proprio qui che ho notato un enorme squadra di atleti, anche qualche artista ma ormai rassegnato al fatto di non poter pretendere di “spiegare” qualcosa perchè poi possa diventare una lezione per gli altri, questa è una cosa davvero molto triste, io non mi ritengo un artista ma ogni giorno cerco di esserlo, l’informazione, la conoscenza, l’incessante bisogno di sapere dovrebbero essere la matita con cui noi progettiamo applicazioni, ma oggi proprio non è possibile…

Share on Facebook

CREATE VIEW MyView AS
	SELECT Column1,Column2 FROM Database.dbo.Table

Successivamente creo un’altra vista quasi identica che per determinati motivi si “appoggia” direttamente alla prima facendo una SELECT * (START premettendo che è sbagliato eseguire una select in questo modo in quanto a risentirne di più sono proprio le performance del server SQL).

CREATE VIEW MyView2 AS
	SELECT * FROM MyView

Dopo un pò di tempo torno sulla prima view e ne modifico le colonne, ne aggiungo di nuove. Cosa succede? Che MyView2 interrogata, mi risponde riportando solo le vecchie colonne e non le nuove. Questo succede perchè lo schema della vista non è stato aggiornato correttamente, per ovviare a questa situazione basta un semplice comando:

EXEC sp_refreshview @view = N'MyView2'

Successivamente, la vista contiene l’elenco delle colonne aggiornate!

Share on Facebook

Il tuo collega scrive un “contratto” a cui chi vuole può partecipare mettendo una firma. Riassumendo, questo documento dice che:

Qualsia parolaccia e/o volgarità detta in ufficio viene punita con il versamento di 0,10 €, le bestemmie pagano 1 €.

Tu firmi il contratto con la speranza che da oggi non ti altererai più durante l’orario di lavoro (bug, codice che non funziona, il cliente che ti chiama sul cellulare personale perchè vuole sapere), alla fine attendi che qualcosa succede, mentre guardi i tuoi colleghi che di volta in volta versano soldi, ad un certo punto tocca anche a te!
Sono passati 3 giorni, da quando lunedi abbiamo avviato questa simpatica iniziativa, ho già versato 80 centesimi, ringrazio i miei colleghi per il loro “impegno” (si perchè si sono davvero dati da fare) per fregarmi.
Morale? Appena il galateo d’ufficio avrà fregato abbastanza soldi, organizziamo una cena.

Su richiesta del promotore di questa “iniziativa”, vorrei ringraziare Claudio Vicenti per il suo operato.

Share on Facebook

Il web.config viene(solitamente) utilizzato per la configurazione dei parametri necessari al corretto funzionamento dell’applicazione (il classico esempio è la ConnectionString), questi, devono poter essere facilmente modificabili da parte dello sviluppatore in fase di test e/o installazione [evitando di dover avere a portata di mano i sorgenti in cui modificare le famose "COSTANTI" e dover subito dopo ricompilare tutto, trasferire etc. etc. :@ (si, alla fine ci si incazza per dover effettuare una semplice modifica)].

Mi capita molte volte di avere delle(grosse) incognite durante lo sviluppo di web-application. Lavorando in ambito ospedaliero e dovendo interfacciare le mie applicazioni con altre sorgenti dati, non sò mai di preciso, nel momento in cui installerò l’applicazione, quale server, quale password, insomma “CHI,COSA (mi manca il quando) e PERCHÈ?”. Per questo sfrutto il web.config a mio favore, cerco di spiegarvi come attraverso questo esempio:
ho un’applicazione x che deve reperire dei dati Anagrafici da un db posizionato
sul server [ServerCheNonConosco] sul database [DatabaseAncoraIgnoto].

Quindi il mio obiettivo è configurare il web.config in modo tale da potergli passare dati reali nel momento stesso in cui sarò a conoscenza di questi (nel frattempo emulo il tutto utilizzando server demo).

Il primo passo è agire direttamente sul web.config:

Alcune note su quanto scritto: i nomi sono frutto della mia immaginazione, nello sviluppo, durante la creazione del web.config utilizzare nomi appropiati che siano il più descrittivi possibile rispetto alla funzionalità svolta, utilizzare anche i commenti se necessario. Per quanto riguarda la ConnectionString ricordate sempre di crittografare per avere una maggiore sicurezza.

Passiamo alla pratica, ho sfruttato la sezione appSettings per memorizzare alcuni “parametri”, infatti all’interno di questo elemento possiamo inserire coppie di dati (Chiave, Valore) che successivamente possiamo reperire dall’applicazione stessa. Il passo successivo è implementare nel nostro progetto quanto necessario per leggere questi valori.

namespace MioProgetto
{
	internal sealed class WebConfig
	{
		// Preleva un valore dal web.config
		internal static string GetValue(string appSettingName)
		{
			return ConfigurationManager.AppSettings[appSettingName];
		}

		internal static string ServerCheNonConosco
		{
			get { return GetValue("ServerCheNonConosco"); }
		}

		internal static string DatabaseAncoraIgnoto
		{
			get { return GetValue("DatabaseAncoraIgnoto"); }
		}

		internal static string ConnectionString
		{
			get
			{
				ConnectionStringSettings css = ConfigurationManager.ConnectionStrings["RemoteConnectionString"];
                    		SqlConnectionStringBuilder sb = new SqlConnectionStringBuilder(css.ConnectionString);
                    		sb.DataSource = ServerCheNonConosco;
		                sb.InitialCatalog = DatabaseAncoraIgnoto;
	                    	string connectionString = sb.ConnectionString;
		                sb = null;
                    		css = null;
                    		return connectionString;
			}
		}
	}
}

Voi direte? Ma non è più semplice ricostruire la connection string ogni qual volta i dati cambiano?, ma poi c’è da crittografare, quindi ci si dovrà riconnettere al server, effettuare le operazioni necessarie a reperire la connessione, modificarla e crittografarla! Con questo metodo abbiamo creato un oggetto che fornisce in ogni momento (all’interno della web-application) le informazioni necessarie per la connessione, sfruttando il web.config! Se pensi che esista un metodo alternativo o modalità migliori per eseguire queste operazioni e vuoi dirmelo, non esitare, in qualche modo (commenti, email) fammi conoscere la tua opinione!

Share on Facebook

Evitando ripetizioni e quant’altro, potete reperire informazioni più dettagliate sull’operato direttamente qui.

UN AIUTO IMPORTANTE PER HAITI

Share on Facebook