Il blog di Nicola

Ho aggiornato Ubuntu dalla 9.10 alla 10.4 in architettura a 64 bit, e il plugin per Flash è sparito. In Firefox non era neanche più presente nella pagina about:plugins.
Se vi capita lo stesso lo stesso problema andate diretti al link sotto (e non provate a scaricare il plugin dal sito della Adobe, perchè vi spernacchiano e basta).

La soluzione è qui: https://help.ubuntu.com/community/AMD64/FirefoxAndPlugins.

Per me ha funzionato.

Ecco un esempio di come creare in fase di sviluppo e di come leggere in fase di esecuzione un file di testo come risorsa all’interno dello stesso assembly.

Creare il Resources File:

- Creare un progetto di test con Visual Studio

- Impostare il nome dell’assembly ed il nome del namespace di default.

- Aggiungere al progetto un oggetto di tipo “Resources File”. Nel mio caso si chiama “license”

- Aggiungere al nuovo contenitore di risorse creato un nuovo file di testo. Nel mio esempio GPLlicense.txt

Nel solution explorer compare il nuovo file (ed anche su filesystem).

Leggere il file di testo dal Resources File a runtime

private void GetResourceFile(string nomeFile)
{
   try
   {
      System.Reflection.Assembly assembly;
      assembly = this.GetType().Assembly;
 
      ResourceManager resourceManager = 
                              new ResourceManager("Nicola.TestResources.license",
                                                              assembly);
 
      String s = resourceManager.GetString(nomeFile);
      Console.WriteLine(s.ToString());
   }
   catch (Exception e)
   {
      Console.WriteLine(e.Message);
   }
}

Il risultato:

Cosa sono le unmanaged resource: sono le risorse non gestite direttamente dal Garbace Collector. Due classici esempi sono i file e i font. La gestione di queste risorse è a carico del programmatore e può essere gestita attraverso i metodi Finalize and Dispose, per evitare memory leaks e risorse bloccate.

Cos’è l’interfaccia IDisposable: L’interfaccia IDisposable definisce un metodo (dispose) per il rilascio delle risorse allocate. L’implementazione di questa interfaccia in una unmanaged resource, permette di gestirne al meglio il ciclo di vita e la deallocazione di tutte le risorse coinvolte.

Cos’è lo statement using: using assicura che che gli oggetti IDisposable vengano usati correttamente. Ovvero, si assicura che venga sempre chiamato il metodo dispose() di un oggetto IDisposabile, anche in caso di eccezioni.

Ecco un classico esempio di utilizzo di using:

// Leggo una riga da un file di testo
string riga;
using (StreamReader reader = new StreamReader(@"c:\file.txt"))
{
   riga = reader.ReadLine();
}
 
// Scrivo una riga su file di testo:
using (StreamWriter myStream = new StreamWriter(_path, true))
{
   myStream.Write(sText);
}

Al termine di using non rimane nessuna traccia dell’oggetto reader instanziato, ed il suo metodo dispose() è stato chiamato. Ecco perchè using può essere usato solo con classi che implementano l’interfaccia IDisposable.

Ecco come può essere la gestione della scrittura di una stringa su file di testo inserendo using all’interno di un try/catch/finally:

String exception = "";
try {
   using (StreamWriter myStream = new StreamWriter(_path, true)) {
   myStream.Write(sText);
}
catch (IOException ioe) {
   exception = ioe.ToString();
}
...
...
...
catch (SecurityException se) {
   exception = se.ToString();
}
finally
{
   if (!"".Equals(exception)) Console.WriteLine(exception); }
}

Ecco un esempio di classe IDisposable e del relativo utilizzo di using:

public class Prova : IDisposable
{
   UnaMiaRisorsa risorsa;
   public Prova() {
   risorsa = new UnaMiaRisorsa(...);
   ...
   ...
   ...
 
   public void UtilizzaRisorsa() {
      // Utilizzo la mia risorsa
   }
 
   public void Dispose()
   {
      // Lasciamo libere le risorse. Ad esempio:
      UnaMiaRisorsa = null;
   }
}

Ed ecco come usiamo Prova

using (Prova prova = new Prova) {
   prova.UtilizzaRisorsa();
}

Se avete una serie di file del tipo: giacomino.avi.001, giacomino.avi.002, giacomino.avi.003 ecc e volete vedere giacomino.avi, qui c’è la soluzione:

http://www.doctort.org/adam/nerd-notes/concatenating-avi-files.html

che consiste fondamentalmente in queste due righe:

cat giacomino.* > tmpavi
mencoder -forceidx -oac copy -ovc copy tmpavi -o giacomino.avi

Mi sono imbattuto in questa problematica: utilizzare una SELECT TOP all’interno di un ciclo, in cui il numero di record da utilizzare è assegnato ad una variable.
Questo è l’esempio che non funziona:

DECLARE @num INT
 
DECLARE c_curs CURSOR FOR
   [...]
OPEN c_curs
 
FETCH NEXT FROM c_curs
INTO @num
 
WHILE @@FETCH_STATUS = 0
BEGIN
   [...]
   SELECT TOP @num [...] ORDER BY NEWID()
 
   FETCH NEXT FROM c_curs
   INTO @anno, @num
END
 
CLOSE c_curs
DEALLOCATE c_curs

Ho risolto utilizzando ROWCOUNT che è invece parametrico:

SET ROWCOUNT @num
SELECT [...] ORDER BY NEWID()
SET ROWCOUNT 0
 
FETCH NEXT FROM c_curs
INTO @num

E’ importante ricordarsi di ripristinare il valore di ROWCOUNT a 0.

Curiosando in rete ho trovato questo articolo che spiega meglio il problema, e offre più di una soluzione: http://sqlserver2000.databases.aspfaq.com/how-do-i-use-a-variable-in-a-top-clause-in-sql-server.html