Di seguito tutti gli interventi pubblicati sul sito, in ordine cronologico.
 
 

Vi sono diversi approcci per verificare se un dato file esista e se esso sia in uso da un'altra applicazione.

Il metodo forse più sicuro per garantirci da eventuali problemi è quello di utilizzare dapprima il metodo System.IO.Exists messo a disposizione da .NET per verificarne l'esistenza che restituisce un booleano in caso affermativo.

Successivamente proviamo ad accedere a quel file in modalità esclusiva; se avremo successo, significa che quel file non è già stato aperto da nessun'altra applicazione, in caso contrario siamo in presenza di una concorrenza di accessi (e quindi attenzione nelle operazioni di salvataggio/eliminazione).

Alla funzione passiamo come parametri il nome del file completo di path di cui vogliamo verificare l'esistenza; la funzione restituisce True se il file esiste e non è in uso , False negli altri due casi.


    Private Function FileFree(ByVal nomefile As String) As Boolean
        If System.IO.File.Exists(nomefile) Then
            Try
                Dim ObjFs As New System.IO.FileStream(nomefile, IO.FileMode.Open, IO.FileAccess.ReadWrite, IO.FileShare.None)
                ObjFs.Close()
                Return True              ' Il file esiste e non è aperto da altre applicazioni
            Catch ObjEx As Exception
                Return False             ' Il file esiste ma è in uso da almeno un'altra applicazione (il file è in LOCK)
            End Try
        Else
            Return False                 ' Il file non esiste
        End If
    End Function

Utilizzare gli strumenti messi a disposizione da windows potrebbe non dare risultati veritieri perchè
la API incaricata di verificare la connessione potrebbe dare esito negativo se è stato configurato male o non è stato configurato Internet Explorer.
La soluzione è quella di testare il collegamento con un sito sicuramente funzionante e capire in questo modo
se il computer è collegato correttamente alla rete.

La seguente funzione effettua questo tipo di verifica. Prova a collegarsi con un sito arbitrario da voi scelto e nel caso la comunicazione
abbia esito positivo (connessione funzionante) restituisce un booleano TRUE, altrimenti FALSE.


Function ConnectionOn() As Boolean

Dim UrlTest As New System.Uri("http://www.google.com/")
' Setup WebRequest
Dim Risposta As System.Net.WebResponse
Dim Richiesta As System.Net.WebRequest
Richiesta = System.Net.WebRequest.Create(UrlTest)

Try
Risposta = Richiesta.GetResponse
Risposta.Close()
Richiesta = Nothing
Return True
Catch ex As Exception
Risposta.Close()
Richiesta = Nothing
Return False
End Try


La funzione, dopo aver definito gli oggetti Richiesta e Risposta e l'indirizzo di prova (ricordate di sceglierne uno sicuramente
funzionante...) prova a richiedere una risposta (risposta = richiesta.GetResponse) a fronte di una interrogazione.

Nel costrutto Try...Catch è racchiusa la verifica della connessione: se abbiamo risposta la funzione restituisce TRUE,
altrimenti (Catch cattura l'errore derivante dal fallimento della negoziazione) FALSE.

Con alcune semplici istruzioni in più sarebbe possibile aggiungere un timer per il controllo periodico della connessione,
magari con la scrittura di un file di log che tiene traccia degli stati della connection.

L'utilizzo di feed RSS è diffuso in tutte le tipologie di siti o portali a livello mondiale.
RSS è un formato per la distribuzione di contenuti sul Web ed è strutturato come un'applicazione XML, perciò deve essere conforme
alle specifiche XML (http://www.w3.org/TR/REC-xml)
Con poche righe di codice è possibile creare veloce un flusso RSS prelevando i dati da un database.
Vediamo prima come è strutturato un semplice file RSS:




I miei annunci
L'elenco degli annunci di questa settimana

Automobile
Vendesi auto modello Topolino
http://miosito/annunci/topolino.htm
http://miosito/annunci/images/topolino.htm






Per la serializzazione del corpo centrale (quella dell'annuncio vero e proprio), possiamo costruire una semplice
applicazione asp che ciclando sugli elementi di un database crei il feed RSS.

<%
' Definizione stringa di connessione al db ed inizializzazione della connessione
str_conn = "DRIVER={Microsoft Access Driver (*.mdb)};DBQ=" & server.MapPath("/db") & "\bacheca.mdb"
Set Conn = Server.CreateObject("ADODB.Connection")
Conn.ConnectionTimeout = 5
Conn.CommandTimeout = 1 '
Conn.Open str_conn


' Definizione stringa sql, parametri recordset
str_sql ="SELECT * FROM annunci ORDER BY data_pub DESC"
Set rs_feed = Server.CreateObject("ADODB.RecordSet")
rs_feed.CursorLocation=3
rs_feed.CacheSize=5
rs_feed.Open str_sql, Conn, 1,1


' Costruzione del feed
str_feed = "I miei annunciL'elenco degli annunci di questa settimana"

' Dopo aver impostato il prologo tipico dei files XML, ciclo suglie elementi della tabella del db
If Not rs_feed.oef then
Do until rs.eof
str_feed = str_feed & "" & rs_feed("articolo") & "" & rs_feed("messaggio") & "" &_
"" & rs_feed("link") & "" & rs_feed("foto") & ""
rs_feed.movenext
Loop
End If

' Chiudo il file
str_feed = str_feed & ""

Response.Write str_feed

' Chiudo il recordset e la connessione alla fine delle operazioni
rs_feed.close
set rs_feed = Nothing
Conn.Close
set Conn=nothing
%>

Tra gli strumenti a disposizione degli sviluppatori spicca sicuramente il Dataset, presente in .NET sin dalla sua prima versione;
un Dataset è un contenitore di dati disconnesso, cioè indipendente dalla fonte dati cui si relaziona.
Ad una prima approssimazione si potrebbe dire che un Dataset può venir usato come un array ottimizzato per la gestione dei dati provenineti da una o più
tabelle di un database.
Ogni tabella coinvolta viene rappresentata dalla proprietà Datatable mentre ad ogni record/tupla viene ci si riferisce con la proprietà DataRow.

Essendo per sua natura disconnesso, il Dataset ottiene i dati dall'oggetto Dataadapter  che diviene quindi l'interfaccia tra il database vero e proprio e il Dataset.

Vediamo con un semplice esempio come sia possibile caricare un Dataset ed utilizzare le sue proprietà/metodi di base:

            // Definiamo una nuova connessione con i parametri di accesso al database
        System.Data.SqlClient.SqlConnection sqlConnection1 = new System.Data.SqlClient.SqlConnection();
        sqlConnection1.ConnectionString = "Data Source=MIOPC;Initial Catalog=Frutta;User ID=yyyyyyyy;Password=xxxxxxx";
        string StrSql = "SELECT * FROM Frutta";
            // un contatore per ciclare sulle righe del Dataset
        integer indice;
        indice=0;
       
            // Definizione dell'interfaccia DataAdapter DAFRUTTA
        SqlDataAdapter daFrutta = new SqlDataAdapter(StrSql, sqlConnection1);
            // Creo un nuovo DataSet  DSFRUTTA
        DataSet dsFrutta = new DataSet();
        
            // Riempiamo il Dataset dsFrutta con i risultati della query SQL
            // dalla tabella frutta
        daFrutta.Fill(dsFrutta, "frutta");
        
            // Ciclando sulle righe del Dataset otteniamo tutti i record
            // dsFrutta.Tables[0].Rows.Count significa: il totale delle righe della tabella 0 (cioè l'unica, 'Frutta', del Dataset).
            // notare il '-1' perchè la prima riga del Dataset è la 0-esima.

        While (indice < dsFrutta.Tables[0].Rows.Count-1)
        {
            // dsFrutta.Tables[0].Rows[indice]["NomeFrutto"] significa:
            // il campo "NomeFrutto" della indice-sima riga della 0-esima tabella ("Frutta") del Dataset
            System.Console.Write(dsFrutta.Tables[0].Rows[indice]["NomeFrutto"] + "  ");
            System.Console.WriteLine(dsFrutta.Tables[0].Rows[indice]["Vitamine"]);
            indice++;
         }
         

Con queste semplici righe di codice è possibi


le relazionarsi ad una o più tabelle di un database, memorizzare i risultati di una query e lavorare sulle righe del dataset.
Nelle successive sezioni dedicate ai Dataset ci si soffermerà su altre (e più interessanti) features di tali oggetti.

Supponiamo di voler implementare uno strumento che permetta l'aggiornamento o l'inserimento di dati su più tabelle.

Questo diventa estremamente utile nel caso si debbano costruire dei sistemi per la migrazione di dati da un database ad un altro (o tra diverse tabelle dello stesos database) e per una qualsiasi ragione non si possa fruire degli strumenti DTS integrati in SQL Server.

Una possibile soluzione molto dispendiosa è quella di costruire un programma compilato che prelevi i dati da un database, li tratti, gestisca chiavi primarie ed esterne, mantenga i vincoli di integrità eventualmente le trasformazioni tra tipi di dato non implicite e che, oltre a tutto questo, risulti anche efficiente (questo è indispensabile se si lavora con centinaia di migliaia o milioni di righe).

Una buona soluzione, è quella di scrivere una Stored Procedure.
Se si volesse utilizzare una serie di select con assegnazione di variabili e tutto il resto, però, le prestazioni ne risentirebbero parecchio.
Per realizzare una sp efficace è opportuno utilizzare, a questo punto, i cursori.
I cursori sono un costrutto speciale di SQL Server che permette l'accesso ai dati riga-per-riga, al contrario delle
normali interrogazioni mediante select che restituisco un set di righe.
Utilizzare i cursori è molto semplice; li si impiega come si farebbe utilizzando, ad esempio, un dataset e interagendovi come si farebbe con un qualsiasi altro linguaggio di programmazione con cicli e condizioni.


I passaggi chiave per l'utilizzo di un cursore sono:

1. DEFINIZIONE/CREAZIONE di un CURSORE
DECLARE MioCursore CURSOR FOR SELECT * FROM MiaTabella

2. ATTIVARE il CURSORE
OPEN MioCursore

3. PRELEVO la prossima riga
FETCH NEXT FROM MioCursore

4. Finchè trovo nuove righe...
WHILE @@FETCH_STATUS = 0

5. Continuo con le operazioni
FETCH NEXT FROM MioCursore

6. CHIUDO il CURSORE
CLOSE MioCursore

7. RIMUOVO il CURSORE dalla memoria
DEALLOCATE MioCursore


ESEMPIO:
Ho una tabella MiaTabella con 4 campi di nome Campo1(int), Campo2(nvarchar(10)), Campo3(int) e Campo4(int).
Voglio eseguire una select su ogni riga con clausola WHERE sulla chiave primaria Campo1.


DECLARE MioCursore CURSOR FOR SELECT campo1 FROM MiaTabella
DECLARE @Campo1 int

OPEN MioCursore
FETCH NEXT FROM MioCursore into @Campo1
WHILE @@FETCH_STATUS = 0
BEGIN
SELECT * FROM MiaTabella where Campo1=@Campo1
FETCH NEXT FROM MioCursore into @Campo1
END

CLOSE MioCursore
DEALLOCATE MioCursore


Il risultato dell'utilizzo dei cursori è visibile nella snapshot di sinistra, mentre quello di una normale SELECT a destra.