The operation cannot be completed. “Puntatore non valido”

Se per caso vi dovesse capitare con Visual Studio 2012 di ricevere il messaggio: The operation cannot be completed. “Puntatore non valido”, quando state tentando di visualizzare un file di risorse .resx, per ripristinarlo, vi basta aprire il file incriminato con un editor di testo e rimuovere tutti gli elementi “data”, dell’xml che contengono l’attributo type="System.Resources.ResXNullRef, System.Windows.Forms".
Es. va eliminato:

<data name="lblLavoroSuLinea.Image" type="System.Resources.ResXNullRef, System.Windows.Forms">
    <value />
</data>

Rimuovere elementi da una lista in maniera intelligente

Di solito quando vogliamo fare eseguire un operazione e poi rimuovere degli elementi da una lista, come facciamo?

Verrebbe naturale di fare un ciclo su ogni elemento della lista, eseguire l’operazione e rimuovere l’elemento:

foreach (Command c in itsCommands)
{        
    c.Execute();
    itsCommands.Remove(c);
}

Purtroppo però così facendo otteniamo un eccezione che ci avvisa che la collezione è stata modificata (in effetti abbiamo rimosso un elemento) e quindi l’operazione di ciclo sulla collezione non è più valida.

Come soluzione al problema si potrebbe crea un altra collezione con gli elementi da rimuovere ed eseguire un altro ciclo per eliminare i comandi eseguiti:

Commands itsCommandsForDelete = new Commands();

foreach (Command c in itsCommands)
{
    c.Execute();
    itsCommandsForDelete.Add(c);
}

foreach (Command c in itsCommandsForDelete)
{
    itsCommands.Remove(c);
}

Questa soluzione non è molto performante perchè ci obbliga ad eseguire il ciclo su ogni elemento per due volte.

Ecco una soluzione alternativa per eseguire il tutto in un solo ciclo:

while (itsCommands.Count > 0)
{
    Command c = (Command) itsCommands[0];
    itsCommands.RemoveAt(0);
    c.Execute();
}

Carta di credito su internet

Spesso le informazioni che ci arrivano dai media e soprattutto dai telegiornali, sono storie sentite raccontare da altri, gonfiate e mal capite ed esposte che incutono paura al consumatore. Ad esempio:

E'sicuro usare la carta di credito su internet?

Il giorno prima di Pasqua ho avuto una discussione con amici di mio padre, i quali, non si fidano ad usare la carta di credito su web, perché hanno sentito al tg che non va bene e che si viene spesso e volentieri truffati.

La mia prima reazione è stata quella di tentare di rassicurarli spiegando che in realtà, esitono anche siti famosi e sicuri, nei quali si hanno vantaggi economici e si trovano prodotti altrimenti introvabili.

Un altro aspetto negativo è che questa mancanza di fiducia è alimentata dall'idea di voler tastare con mano il prodotto, prima di comprarlo.

Inoltre si ha il timore che una volta effettuato l'acquisto non ci siano garanazie nel caso arrivasse rotto o difettoso.

Per esperienza, sono anni ormai che faccio acquisti su internet e non ho mai avuto problemi. Per prima cosa se mi piace un prodotto, mi reco al primo centro commerciale per tastarmelo e provarlo. Nel caso non fosse disponibile, cerco eventuali video ed informazioni su YouTube o nei blog del settore di competenza.
Se decido di effettuare l'acquisto ci sono due strade da percorrere:

La prima è l'acquisto da siti più famosi tipo Amazon. Qui mi sento sicuro al 100% perché non ho mai avuto problemi ed inoltre quasi sempre il prezzo è nettamente inferiore rispetto ai comuni centri commerciali (per alcuni prodotti ho risparmiato anche 200 euro). Su amazon inoltre il prezzo di un prodotto è molto variabile di giorno in giorno.

E tutto semplicissimo. Mi basta accede al sito con le mie credenziali, guardare i prodotti, metterli nel carrello virtuale, completare l'acquisto fornendo il numero della carta di credito (la prima volta, poi viene memorizzata sul sito), e attendere il pacco comodo a casa in poltrona.

In caso di prodotto rotto o difettoso si hanno 30 giorni per restituirlo e farselo rimborsare. Passati i 30 giorni (ed entro 2 anni dati dalla garanzia e come qualsiasi altro prodotto acquistato in un normale negozio) bisogna cercare il più vicino centro di assistenza che si occupa della marca del prodotto acquistato (basta una piccola ricerca su Google per trovarlo).

Nel secondo caso cioè quello di siti sconosciuti ci sono un paio di regole da seguire ma niente di complicato:

- Prima di tutto dobbiamo fare una ricerca, per capire l'opinione della gente riguardo al negozio, se si sono trovati bene, in quanto tempo la merce ordinata è arrivata, se hanno avuto esperienze negative, se c'è e se è buona l'assistenza post vendita. Riassumendo è importante conoscere la reputazione online del negozio (feedback positivi e negativi).

- Bisogna confrontare l'offerta con quella di altri negozi e se è eccessivamente bassa stare molto attenti perché si tratta di una provabile trappola, o ci sono delle clausole nascoste. Molte volte ad esempio la tecnica di marketing usata è proporre un prezzo molto basso rispetto alla concorrenza, ma prima di terminare l'acquisto vi vengono richieste spese di spedizione molto alte che riportano la spesa totale allo stesso livello o superiore a quella dei concorrenti.

- Controllate che sia presente un servizio post vendita e che i numeri di telefono esitano veramente (si può contollare sul sito delle pagine bianche).

Una volta che avete appreso abbastanza informazioni e vi fidate, effettuate l'acquisto.

Se proprio vi va male denunciate l'accaduto alla polizia postale.

String format .NET semplificato e naturale

Molte volte ci troviamo a dover inserire delle stringhe in una stringa più grande (di solito una frase, per notificare un messaggio all’utente dell’applicazione).
Per fare ciò usiamo il metodo “String.Format()” che accetta in input la stringa da formattare, e un array contenete le altre stringhe da inserire, al posto di segna posti speciali, costruiti con la regola: {indice dell’array}.
Es.:

MessageBox.Show(String.Format("Errore numero {0}, l'utente {1}, non ha i permessi di lettura del file
 {2}, inoltre {1}, non appartiene al ruolo {3}", new String[]{"123", "Mario", "file.txt", "admin"}));

Di solito la scrittura di questo codice avviene nella seguente maniera:

1. Si scrive: MessageBox.Show(
2. Si pensa al messaggio e si inizia a scriverlo: "Errore numero …
3. Ci si accorge che il messaggio dovrà contenere dei pezzi di stringa all’interno della stringa principale.
4. Si aggiungono i segna posto per i pezzi di stringa: numero {0}, l'utente {1}, non
5. Completata la frase, ci si posiziona all’inizio della frase stessa.
6. Si digita String.Format(
7. Si va alla fine della frase e si chiude la parentesi )

Come si vede a lungo andare si perde molto tempo a compiere tale operazione e non è del tutto naturale, perché ci impegna a cercare l’inizio della frase scritta per aggiungere un pezzo di codice e a tornare alla fine di essa, per chiudere la parentesi.
Per risparmiare tempo e trovare più naturalezza nella scrittura, ho implementato la seguente classe per estendere la classe System.String:

namespace System
{
    /// <summary>
    /// Estensioni per le classi stringa
    /// </summary>
    public static class StringEx
    {
        /// <summary>
        /// Formatta la stringa
        /// </summary>
        /// <param name="pValue">Stringa</param>
        /// <param name="args">Parametri</param>
        /// <returns>Stringa formattata</returns>
        public static string Formatting(this String pValue, params object[] args)
        {
            return String.Format(pValue, args);
        }

        /// <summary>
        /// Formatta la stringa
        /// </summary>
        /// <param name="pValue">Stringa</param>
        /// <param name="format">Format provider</param>
        /// <param name="args">Parametri</param>
        /// <returns>Stringa formattata</returns>
        public static string Formatting(this String pValue, IFormatProvider format, params object[] args)
        {
            return String.Format(format, pValue, args);
        }
    }
}

Ora potere scrivere lo stesso codice dell’esempio di prima in maniera naturale, senza bisogno di tornare a cercare dove inizia la vostra Stringa:

MessageBox.Show("Errore numero {0}, l'utente {1}, non ha i permessi di lettura del file {2}, inoltre {1},
 non appartiene al ruolo {3}".Formatting(new String[] { "123", "Mario", "file.txt", "admin" }));

Implementare il Databindings di oggetti

Oggi mi è capitato di dover implementare il databindings di un controllo che ne era sprovvisto (il treenode). Per aggiungere il databindings ad un oggetto TreeNode, come nel mio caso, ma anche per qualsiasi altro oggetto, basta implementare l’interfaccia IBindableComponent.

In questo modo potete usare il Binding su tutte le proprietà del TreeNode; in particolare a me interessava collegare la proprietà “Name” di un mio oggetto alla proprietà “Text” di un TreeNode.

Ecco un esempio in C# dell’implementazione del databindings per la proprietà “Text” di un oggetto TreeNode:

public class TreeNodeBind : TreeNode, IBindableComponent
    {
        //Implementazione dei costruttori base
        public TreeNodeBind()
            : base()
        {
        }

        public TreeNodeBind(string text) 
            : base(text)
        {
        }

        public TreeNodeBind(string text, TreeNode[] children)
            : base(text, children)
        {
        }

        public TreeNodeBind(string text, int imgIndex, int selImgIndex) 
            : base(text, imgIndex, selImgIndex)
        {
        }

        public TreeNodeBind(string text, int imgIndex, int selImgIndex, TreeNode[] children)
            : base(text, imgIndex, selImgIndex, children)
        {
        }

        //Implementazione di IBindableComponent
        #region IBindableComponent Members

        private BindingContext _bindingContext;
        private ControlBindingsCollection _dataBindings;

        [Browsable(false)]
        public BindingContext BindingContext
        {
            get
            {
                if (_bindingContext == null)
                {
                    _bindingContext = new BindingContext();
                }
                return _bindingContext;
            }
            set
            {
                _bindingContext = value;
            }
        }

        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        public ControlBindingsCollection DataBindings
        {
            get { return _dataBindings ?? (_dataBindings = new ControlBindingsCollection(this)); }
        }

        public ISite Site { get; set; }

        public event EventHandler Disposed;

        public void Dispose()
        {
            if (Disposed != null)
                Disposed(this, EventArgs.Empty);
        }

        #endregion
    }

Ora potete creare ed usare nodi di tipo TreeNodeBind che supportano il Binding:

TreeNodeBind nodoBind = new TreeNodeBind();
nodoBind.DataBindings.Add(new System.Windows.Forms.Binding("Text", oggettoConDati, "Name", true));
tree.Nodes.Add(nodoBind);

Sviluppo Python su Android con SL4A

In questo articolo vi parlerò di come collegare un dispositivo Android al vostro PC windows per utilizzare da remoto SL4A, un programma che invia istruzioni in diversi linguaggi scripting (fra cui Python) ad Android tramite chiamate RPC e permette di scrivere programmi o pezzi di script direttamente sul dispositivo.

Per prima cosa scaricare e installare SL4A sul dispositivo Android. Lo potete trovare qui:
http://code.google.com/p/android-scripting/downloads/list
file: sl4a_r4.apk (o ultima versione)

Scarichiamo anche l'ultimo interprete del linguaggio Python:
http://code.google.com/p/python-for-android/downloads/list
file: PythonForAndroid_r6.apk (o ultima versione)

Sul PC installate Android SDK:
http://developer.android.com/sdk/index.html

Sul PC avviate Android SDK Manager e installate il driver USB:

Sul device andare in: "Impostazioni" -> "Applicazioni" -> "Sviluppo" -> e spuntare l'opzione "Debug USB"

Sul PC aggiungete "C:\Program Files (x86)\Android\android-sdk\tools\" alla variabile ambiente di windows PATH

Dal prompt di windows digitare "gestione dispositivi" e su "Altri dispositivi" tasto destro e "Aggiornamento software driver"
fare cerca nel computer nella cartella: "C:\Program Files (x86)\Android\android-sdk\extras\google\usb_driver" (o dove avete installato l'sdk)

Se il dispositivo non viene riconosciuto fate proprietà -> dettagli e annotardi le 2 righe con gli hardware id:

Aprite il file "android_winusb.inf" per inserire gli hardware id annotati in precedenza:.

Per il tablet iconia A500 come il mio aggiungete le seguenti righe:

(sia alla fine sella sezione [Google.NTx86] che di [Google.NTamd64])

;
;Iconia A500
%SingleAdbInterface% = USB_Install, USB\VID_0502&PID_3325
%CompositeAdbInterface% = USB_Install, USB\VID_0502&PID_3325&MI_01

ripetete il riconoscimento del driver, tramite aggiornamento ed ora verrà trovato:

fate una prova lanciando il comando dal prompt di windows (con privilegi di amministratore): adb devices
dovrebbe restituirvi una stringa che rappresenta l'id del dispositivo connesso

Avviamo SL4A dal dispositivo Android. Ora dal menu del programma selezionate: View -> Interpreters
premiamo di nuovo il bottone menu, selezioniamo "start server". Selezioniamo "private" (public è usato per la connessione via wifi).

Ora siamo pronti alla connessione:
per prima cosa dobbiamo creare la seguente variabile d'ambiente per utente: AP_PORT con valore di default: 9999, poi abilitare il port forwarding

Nel caso abbiate un tablet cliccate sull'icona di SL4A nella tray e poi nel riquadro nero che compare per vedere a video il numero della porta usata dal server del dispositivo:

Aggiungiamo alla variabile d'ambiente PATH anche il percorso del file della shell Python Es.: ";C:\Python26"

Nella cartella lib della cartella dove avete installato Python Es.: "C:\Python26\Lib" salviamo il file "android.py"

Sul PC lanciamo un prompt windows come amministratore e digitiamo:

set AP_PORT=9999
adb forward tcp:9999 tcp:[numero di porta server SL4A]
python

Ora la vostra shell Python esegue i comandi sul dispositivo Android.

Ecco il codice per una piccola prova che stampa sul video del dispositivo il messaggio "Ciao sono il PC!"

import android  # dal file android.py che abbiamo aggiunto sul PC
droid = android.Android()
droid.makeToast("Ciao sono il PC!")

Appunti base relativi ai Design Patterns

Appunti sui Design patterns:

appunti design patterns

I design patterns sono suddivisi in queste tre principali categorie:

Creationals (Creazionali):

• Permettono di astrarre il processo di creazione degli oggetti
• Rendono un sistema indipendente da come i suoi oggetti sono stati creati, composti e rappresentati
• Incapsulano la conoscenza sulle classi concrete che un sistema usa
• Nascondono l'implementazione delle classi e della loro creazione

da immagine appunti design patterns

1.1, Creational
  1.1.1, AbstractFactory
    1.1.1.1, Crea oggetti che appartengono alla stessa famiglia e sono connessi o dipendenti tra loro
    1.1.1.2, Possibilità di utilizzare una famiglia diversa di prodotti a seconda della factory usata. L'interfaccia del client non cambia
  1.1.2, FactoryMethod
    1.1.2.1, Fornische un interfaccia per creare un oggetto ma sono le sottoclassi a decidere cosa istanziare
  1.1.3, Prototype
    1.1.3.1, Crea nuovi oggetti clonando quello base
  1.1.4,  Builder
    1.1.4.1, Separa la costruzione di un oggetto complesso dalla sua rappresentazione.  Lo stesso costruttore puó creare più rappresentazioni diverse
  1.1.5, Singleton 
    1.1.5.1, Fa in modo che una classe abbia una sola istanza e possa essere usata da tutti

Structural (Strutturali):

• Sono dedicati alla composizione di classi e oggetti per creare delle strutture più grandi
• Gli Structural class pattern utilizzando l'ereditarietà per creare interfacce o implementazioni
• Gli Structural object pattern descrivono il modo in cui comporre gli oggetti per realizzare nuove funzionalità

da immagine appunti design patterns

1.2, Structural
  1.2.1, Proxy
    1.2.1.1, Inizializzare un oggetto solo quando viene chiamato il metodo
  1.2.2, Bridge
    1.2.2.1, Separa cosa si puó fare da cosa si fà
    1.2.2.2, Permette di eseguire la stessa operazione ma in maniera diversa a seconda del caso
    1.2.2.3, Costruisce un oggetto composto da varie parti.  Le parti che servono sono dinamiche a seconda del builder usato
  1.2.3, Facade
    1.2.3.1, Interfaccia di alto livello per richiamare sottosistemi diversi
  1.2.4, Adapter
    1.2.4.1, Adatta l'interfaccia di un elemento alla richiesta del client
  1.2.5, Decorator
    1.2.5.1, Aggiunge metodi all'oggetto in maniera dinamica
    1.2.5.2, Propone alternativa all'ereditarietà (anche multipla)
  1.2.6, Flyweight
    1.2.6.1, Condivide la parte riusabile di un oggetto
    1.2.6.2, La factory estra un oggetto dalla collezione interna o lo crea nuovo per risparmiare memoria, istanziando l'oggetto normalmente si accede alla parte non condivisa
  1.2.7, Composite
    1.2.7.1, Crea oggetti in strutture ad albero
    1.2.7.2, Esempio: il trapezio è composto da 2 triangoli e un rettangolo

Behavioral (Comportamentali):

• Si focalizzano sul controllo di flusso degli oggetti
• Descrivono le comunicazioni fra gli oggetti
• Aiutano a valutare le responsabilità assegnate agli oggetti
• Suggeriscono modi per incapsulare algoritmi dentro classi

da immagine appunti design patterns

1.3, Behavioral
  1.3.1, TemplateMethod
    1.3.1.1, Permette di variare una parte di un algoritmo e non toccare il resto
  1.3.2, Strategy
    1.3.2.1, Crea una classe con algoritmi intercambiabili ma interfaccia per richiamarli uguale
  1.3.3, Observer
    1.3.3.1, Crea eventi che si scatenano in tutti gli oggetti registrati quando viene notificato dall'oggetto principale
  1.3.4, Mediator
    1.3.4.1, Permette l'iterazione fra oggetti senza che uno abbia a che fare con l'altro
    1.3.4.2, L'oggetto principale incapsula l'iterazione fra gli oggetti contenuti
  1.3.5, State
    1.3.5.1, Cambia il comportamento a run-time dell'oggetto a seconda dello stato in cui si trova
  1.3.6, Interpreter
    1.3.6.1, Trasforma una sintassi, un linguaggio in entrata e interpretandone le espressioni produce un risultato in uscita
    1.3.6.2, L'interpreter precisa come valutare le frasi in una determinata lingua o linguaggio
  1.3.7, Visitor
    1.3.7.1, Rappresenta un operazione che puó essere eseguita sugli elementi di una struttura oggetto. 
    1.3.7.2, Permette di definire una nuova operazione senza modificare la struttura stessa
    1.3.7.3, Delega una funzionalità a una gerarchia di classi senza inquinarle
    1.3.7.4, Separa un algoritmo dalla struttura di oggetti compositi a cui è applicato
    1.3.7.5, Il visitor incapsula la funzionalità e la gerarchia viene dotata solo di un metodo per accedere ad uno di questi visitor
  1.3.8, Command
    1.3.8.1, Isola la porzione di codice che effettua un azione dal codice che ne richiede l'esecuzione; l'azione è incapsulata nell'oggetto command
    1.3.8.2, Utile da usare per associare azioni dell'interfaccia grafica(esempio click sul un bottone) al codice che esegue l'azione
  1.3.9, Iterator
    1.3.9.1, Fornisce un metodo per accedere agli oggetti di una collezione senza esporli direttamente
  1.3.10, Memento
    1.3.10.1, Estrae lo stato di un oggetto per ripristinarlo successivamente (come undo)
  1.3.11, Chain of responsability
    1.3.11.1, Separa oggetti che fanno le richieste da quelli che le gestiscono
    1.3.11.2, Usa un determinato oggetto che si incarica di soddisfare la richiesta effettuata