text:

A ben pensarci, un'alternativa meno overkill (ma anche piu'
"procedurale") sarebbe fare quella mappatura con una funzione statica
e uno switch:
  static int ColorToIndex(Color color)
  {
      switch(color)
      {
          default:
          case Color.Red: return 0;
          case Color.Yellow: return 1;
          case Color.Blue: return 2;
      }
  }
La funzione in questione puo' essere anche definita come extension
method della enum Color...
-LV


title: Re: Generics constraint VS subclassing

author: Julio Di Egidio

text:
On Monday, 2 September 2013 08:42:10 UTC+1, Giulio Petrucci wrote:
>
> Forse è davvero talmente facile che non riesco a capirlo ma... che
> differenza c'è tra questo:
>      public void MyMethod<T>(T item) where T : SomeType { ... }
> e questo:
>      public void MyMethod(SomeType item) { ... }
> ?

Forse qui la differenza e' piu' evidente:

     public T MyMethod<T>(T item) where T : SomeType { ... }
     public SomeType MyMethod(SomeType item) { ... }

Ma lo stesso vale nel corpo del metodo e altrove: essenzialmente, con i
generics hai tipizzazione stretta.

(BTW, vedo questo tuo messaggio solo da Google Groups.)

Julio


title: [VB.net] Prevenire codice rientrante

text:
Come fate, di prassi, a evitare che una routine, tramite
gestione GUI ed event-handlers asincroni, possa venire
chiamata in modo multiplo, ossia prima che sia stata servita
del tutto la chiamata precedente ?
In particolare mi interessa se ci sia qualche attributo,
qualche opzione (meglio se locale) per fare ciò, e non tanto
l'inserimento MANUALE, nel codice, di qualche sorta di
flag-semaforo che semplicemente dirotta le chiamate
successive ad una in sospeso verso l'exit point della procedura
SE si può fare, ovviamente.
Ah, sto usando VB, ma anche una risposta per VC++ mi
starebbe bene, a volte uso pure quello anche se ormai raramente
ciao e grazie in anticipo
Soviet_Mario


title: [VB.net] Prevenire codice rientrante

author: Raffaele Rialdi [MVP]

text:

Non esiste alcun attributo per quello scopo e in linea di massima non
ne vedo neppure l'esigenza così frequente.
Tramite codice puoi fare tutto con lock(..) {..} che essendo una
critical section è il modo più 'light' di eseguire il controllo
--
Raffaele Rialdi
Microsoft .NET MVP
http://mvp.support.microsoft.com
 -
http://italy.mvps.org
 UGIdotNET - User Group Italiano .NET
http://www.ugidotnet.org
 Weblog:
http://blogs.ugidotnet.org/raffaele


title: [VB.net] Prevenire codice rientrante

text:
Il 26/12/2010 13:40, Raffaele Rialdi [MVP] ha scritto:
>> Come fate, di prassi, a evitare che una routine, tramite gestione GUI
>> ed event-handlers asincroni, possa venire chiamata in modo multiplo,
>> ossia prima che sia stata servita del tutto la chiamata precedente ?
>>
>> In particolare mi interessa se ci sia qualche attributo, qualche
>> opzione (meglio se locale) per fare ciò, e non tanto l'inserimento
>> MANUALE, nel codice, di qualche sorta di flag-semaforo che
>> semplicemente dirotta le chiamate successive ad una in sospeso verso
>> l'exit point della procedura
>>
>> SE si può fare, ovviamente.
>> Ah, sto usando VB, ma anche una risposta per VC++ mi starebbe bene, a
>> volte uso pure quello anche se ormai raramente
>
> Non esiste alcun attributo per quello scopo e in linea di massima non ne
> vedo neppure l'esigenza così frequente.
si, alla fin fine sono solo tre routine che dovrebbero
essere interrompibili (se no bloccano tutto) ma non
rientranti. Però per quelle mi serve. Ora come ora mettevo
una banale variabile statica interna a mo di semaforo, ma mi
pare un sistema poco elegante
>
> Tramite codice puoi fare tutto con lock(..) {..} che essendo una
> critical section è il modo più 'light' di eseguire il controllo
ah ecco, c'è un'istruzione LOCK ... non lo sapevo. Grazie,
ora vado a spulciare l'help per vedere di impararlo. Date le
graffe mi pare un esempio del C/C++, cmq verifico se esista
qualcosa di analogo anche per VB. Del resto Try Catch End
Try l'hanno messo nel basic, per cui spero
ciao e grazie
Soviet
>


title: [VB.net] Prevenire codice rientrante

text:
> si, alla fin fine sono solo tre routine che dovrebbero essere interrompibili
> (se no bloccano tutto) ma non rientranti. Però per quelle mi serve. Ora come
> ora mettevo una banale variabile statica interna a mo di semaforo, ma mi pare
> un sistema poco elegante
se il metodo in oggetto non è statico, non usare una static ma una
normale var di istanza.
Basta una cosa del genere nella tua classe:
private object _sync = new object();
Tutte le eeclass (aka reference value) sono dotate dal clr di una dword
di sincronizzazione usata tipicamente per questi scopi.
> ah ecco, c'è un'istruzione LOCK ... non lo sapevo. Grazie, ora vado a
> spulciare l'help per vedere di impararlo. Date le graffe mi pare un esempio
> del C/C++, cmq verifico se esista qualcosa di analogo anche per VB. Del resto
> Try Catch End Try l'hanno messo nel basic, per cui spero
In VB.net lo statement si chiama SyncLock



title: [VB.net] Prevenire codice rientrante

text:
Il 26/12/2010 15:59, Raffaele Rialdi [MVP] ha scritto:
>> si, alla fin fine sono solo tre routine che dovrebbero essere
>> interrompibili (se no bloccano tutto) ma non rientranti. Però per
>> quelle mi serve. Ora come ora mettevo una banale variabile statica
>> interna a mo di semaforo, ma mi pare un sistema poco elegante
>
> se il metodo in oggetto non è statico, non usare una static ma una
> normale var di istanza.
> Basta una cosa del genere nella tua classe:
> private object _sync = new object();
perché object ? Io usavo una variabile booleana e settavo a
true se il codice entrava, false all'uscita regolare. La
staticità mi serviva per avere una copia sola della
variabile data, se no ad ogni chiamata una procedura data
avrebbe ricevuto la sua copia vergine. Cmq, come anche dico
dopo, anche il codice stesso è shared. Ma che poi, il codice
come lifetime è per forza statico no ? Cioè, ammesso di non
usare threads
> Tutte le eeclass (aka reference value) sono dotate dal clr di una dword
> di sincronizzazione usata tipicamente per questi scopi.
anche le procedure ?
>
>> ah ecco, c'è un'istruzione LOCK ... non lo sapevo. Grazie, ora vado a
>> spulciare l'help per vedere di impararlo. Date le graffe mi pare un
>> esempio del C/C++, cmq verifico se esista qualcosa di analogo anche
>> per VB. Del resto Try Catch End Try l'hanno messo nel basic, per cui
>> spero
>
>
> In VB.net lo statement si chiama SyncLock
>
grazie di nuovo ... in effetti stavo trovando tutt'altro
(cmq le procedure erano private shared, ergo presumo
statiche, anche se di scope ristretto alla classe. O mi
sbaglio ? Non ho eccessiva confidenza con il lifetime del VB)
Ora riguardo sotto SyncLock
ciao
Soviet


title: [VB.net] Prevenire codice rientrante

text:
Soviet_Mario wrote:
> perchï¿œ object ? Io usavo una variabile booleana e settavo a true se il codice
> entrava, false all'uscita regolare. La staticitï¿œ mi serviva per avere una
> copia sola della variabile data, se no ad ogni chiamata una procedura data
> avrebbe ricevuto la sua copia vergine. Cmq, come anche dico dopo, anche il
> codice stesso ï¿œ shared. Ma che poi, il codice come lifetime ï¿œ per forza
> statico no ? Cioï¿œ, ammesso di non usare threads
Con la booleana c'ï¿œ la possibilitï¿œ che del codice sia eseguito
realmente in modo contemporaneo e quindi non puï¿œ essere garantita
l'esecuzione univoca.
Se non usi threads e la funzione e ricorsiva, rischi di andare in
condizione di deadlock, sia usando la boolean che lock
Lo static ti fornisce l'univocitï¿œ per tutto il tuo appdomain mentre
spesso ï¿œ desiderabile avere l'univocitï¿œ per istanza dell'oggetto (cioï¿œ
per quel set di dati che l'oggetto sta incapsulando).
In C# sarebbe una cosa di questo genere:
public class Qualcosa
{
 private object _sync = new object();
 private void MyMethod()
 {
  lock(_sync)
  {
   ...
  }
 }
}
>> Tutte le eeclass (aka reference value) sono dotate dal clr di una dword
>> di sincronizzazione usata tipicamente per questi scopi.
>
> anche le procedure ?
che intendi per procedure?
I reference type godono di questa proprietï¿œ e infatti sono gli unici
usabili in lock/SyncLock
> grazie di nuovo ... in effetti stavo trovando tutt'altro
> (cmq le procedure erano private shared, ergo presumo statiche, anche se di
> scope ristretto alla classe. O mi sbaglio ? Non ho eccessiva confidenza con
> il lifetime del VB)
si, shared in
vb.net
 significa static



title: [VB.net] Prevenire codice rientrante

text:
Il 26/12/2010 17:12, Raffaele Rialdi [MVP] ha scritto:
> Soviet_Mario wrote:
>> perché object ? Io usavo una variabile booleana e settavo a true se il
>> codice entrava, false all'uscita regolare. La staticità mi serviva per
>> avere una copia sola della variabile data, se no ad ogni chiamata una
>> procedura data avrebbe ricevuto la sua copia vergine. Cmq, come anche
>> dico dopo, anche il codice stesso è shared. Ma che poi, il codice come
>> lifetime è per forza statico no ? Cioè, ammesso di non usare threads
>
> Con la booleana c'è la possibilità che del codice sia eseguito realmente
> in modo contemporaneo
beh, il controllo del semaforo è però messo come prima
istruzione eseguibile della routine, ergo è vero che può
essere richiamata mentre ancora la vecchia istanza gira, ma
la nuova esce immediatamente, ergo è una chiamata a vuoto
senza effetti collaterali. Perlomeno non che riesca a
immaginarne. Le sub in questione hanno un unico entry point
... e li si decide se la chiamata va servita o rifiutata
> e quindi non può essere garantita l'esecuzione
> univoca.
> Se non usi threads
si, niente threads. E' un programma strutturalmente
semplicissimo.
Costruisci la struttura di directory e files di dischi
selezionati, applichi filtri su data, dimensioni, tipi,
esclusioni, generi lista di filenames, poi eventualmente
richiamo di una routine di compressione GZIP prefabbricata.
Concettualmente semplice. L'unico problema nasce dal non
voler bloccare la gui (e l'OS) e dalla durata temporale di
certe chiamate, tipo la scansione disco e ricostruzione
della struttura, e ancorpiù la compressione vera e propria.
Dentro ci sono un bel po' di Application.DoEvents() (anche
se non funzionano manco tanto bene, il perché non so ancora)
> e la funzione e ricorsiva,
no, non è ricorsiva, ma nessuno impedisce di schiacciare a
breve distanza di tempo il bottone che richiama la routine
di bakup, prima che la vecchia chiamata sia stata servita
> rischi di andare in
> condizione di deadlock, sia usando la boolean che lock
>
> Lo static ti fornisce l'univocità per tutto il tuo appdomain
si ... inoltre è locale alla routine, per cui lo scope è
estremamente ristretto.
> mentre
> spesso è desiderabile avere l'univocità per istanza dell'oggetto (cioè
> per quel set di dati che l'oggetto sta incapsulando).
Si, vero, ma la mia necessità era molto più banale
>
> In C# sarebbe una cosa di questo genere:
>
> public class Qualcosa
> {
> private object _sync = new object();
> private void MyMethod()
> {
> lock(_sync)
Dal che desumo di non essere riuscito a spiegarmi troppo
bene, ma dopo ritento :)
> {
> ...
> }
> }
> }
>
>>> Tutte le eeclass (aka reference value) sono dotate dal clr di una dword
>>> di sincronizzazione usata tipicamente per questi scopi.
>>
>> anche le procedure ?
>
> che intendi per procedure?
function e sub (in VB).
Ma mi rendo conto ora di essermi forse spiegato malissimo.
Il mio problema non è nella concorrenza dell'accesso a dati
condivisi.
Piuttosto della concorrenza di esecuzione del codice da
eventi asincroni generati dalla gui. Devo solo garantire che
alcune procedure (che per inciso non sono ricorsive, sono
solo lunghette e non bloccanti, nel senso che rendono di
tanto in tanto in controllo alla gui stessa con
Application.DoEvents() per non bloccarla completamente).
Non avevo eccessiva voglia di disabilitare i menu che
richiamano le routine pesanti, perché questa soluzione
esterna mi sembra poco robusta : dovessi aggiungere qualche
altro bottone che le richiama, dovrei ricordarmi di
inattivarlo e riattivarlo. Invece una garanzia interna alla
funzione prescindeva dal ridisegno della gui e delle
relazioni tra le due parti.
Per inciso x ora faccio una roba del genere
private shared sub Foo (parametri)
     static JustRunning as boolean = false
     if (JustRunning = true) then
         return
     else
         JustRunning = true
     end if
     .........
     ISTRUZIONI corpo routine
     .........
     JustRunning = false
     return
end sub
in realtà ci sono molti exit point dentro, e per ciascuno mi
devo ricordare di mettere a false il flag semaforo subito
prima di uscire, e già è una cosa che mi pare error prone se
la sub ha un corpo di più di due pagine. Cmq se non altro ho
da guardare in un solo blocco omogeneo di codice. L'idea di
disabilitare i controlli che richiamano la procedura dopo
averla invocata, e riabilitarli al rientro, mi risulta
raccapricciante :-)
> I reference type godono di questa proprietà e infatti sono gli unici
> usabili in lock/SyncLock
>
Io però devo bloccare del codice eseguibile, più che
l'accesso a dati critici
>
>> grazie di nuovo ... in effetti stavo trovando tutt'altro
>> (cmq le procedure erano private shared, ergo presumo statiche, anche
>> se di scope ristretto alla classe. O mi sbaglio ? Non ho eccessiva
>> confidenza con il lifetime del VB)
>
> si, shared in
vb.net
 significa static
>
P.S. non c'entra una mazza, ma ho scoperto che accodando
files ad un unico stream compresso (GZip) esso non può,
necessariamente, tenere traccia dell'origine dei vari
chunks, ergo sto aggiungendo la generazione di un file
indice, per poter ricostruire uan struttura.
Questo programma è nato da un'esigenza forse triviale : con
molti compressori (tutti quelli che ho provato) che
funzionano anche via files di listing, ho notato che file
diversi per percorso ma di stesso nome, mi generano
condizione di errore o sovrascritture. Con un backup di
pagine web da siti è micidiale, ci saranno centinaia di
index.html per fare un esempio, ma devono poter essere
archiviati in copie distinte senza sovrascritture, ergo mi
son detto, me lo faccio a mano, e poi si sta facendo lunga.
ciao e grazie delle varie consulenze
Soviet


title: [VB.net] Prevenire codice rientrante

text:
> beh, il controllo del semaforo è però messo come prima istruzione eseguibile
> della routine, ergo è vero che può essere richiamata mentre ancora la vecchia
> istanza gira, ma la nuova esce immediatamente, ergo è una chiamata a vuoto
> senza effetti collaterali. Perlomeno non che riesca a immaginarne. Le sub in
> questione hanno un unico entry point ... e li si decide se la chiamata va
> servita o rifiutata
beh se già usi un semaforo allora il boolean non ti serve a nulla
> si, niente threads. E' un programma strutturalmente semplicissimo.
> Costruisci la struttura di directory e files di dischi selezionati, applichi
> filtri su data, dimensioni, tipi, esclusioni, generi lista di filenames, poi
> eventualmente richiamo di una routine di compressione GZIP prefabbricata.
> Concettualmente semplice. L'unico problema nasce dal non voler bloccare la
> gui (e l'OS) e dalla durata temporale di certe chiamate, tipo la scansione
> disco e ricostruzione della struttura, e ancorpiù la compressione vera e
> propria.
> Dentro ci sono un bel po' di Application.DoEvents() (anche se non funzionano
> manco tanto bene, il perché non so ancora)
per questo genere di lavori il multithreading è l'unico modo di rendere
fluida l'esecuzione, magari mantenendo ad una priorità più bassa i
worker thread evitando di divorare troppa cpu.
BTW i veri programmi di backup usano le shadow copy e/o le backup api
in modo da non avere problemi sui file in uso.
> Ma mi rendo conto ora di essermi forse spiegato malissimo.
> Il mio problema non è nella concorrenza dell'accesso a dati condivisi.
> Piuttosto della concorrenza di esecuzione del codice da eventi asincroni
> generati dalla gui.
occhio che se mi parli di eventi asincroni implica automaticamente
multithreading
> Non avevo eccessiva voglia di disabilitare i menu che richiamano le routine
> pesanti, perché questa soluzione esterna mi sembra poco robusta : dovessi
> aggiungere qualche altro bottone che le richiama, dovrei ricordarmi di
> inattivarlo e riattivarlo. Invece una garanzia interna alla funzione
> prescindeva dal ridisegno della gui e delle relazioni tra le due parti.
Di norma vanno fatte entrambe le cose altrimenti l'utente non può
capire che la funzionalità è momentaneamente non disponibile.
> in realtà ci sono molti exit point dentro, e per ciascuno mi devo ricordare
> di mettere a false il flag semaforo subito prima di uscire, e già è una cosa
> che mi pare error prone se la sub ha un corpo di più di due pagine. Cmq se
> non altro ho da guardare in un solo blocco omogeneo di codice. L'idea di
> disabilitare i controlli che richiamano la procedura dopo averla invocata, e
> riabilitarli al rientro, mi risulta raccapricciante :-)
mi pareva usassi un semaforo ... se così è puoi semplicemente fare:
using(semaforo)
{
 ....
}
Lo using statement esiste anche in vb:
http://msdn.microsoft.com/en-us/library/htd05whh.aspx
> Io però devo bloccare del codice eseguibile, più che l'accesso a dati critici
lock, cioè le critical section, non fanno altro che impedire che un
altro thread possa eseguire lo stesso pezzo di codice.
La peculiarità di lock è di far attendere in una funzione di wait il
thread che tenti di eseguire il codice che attualmente è già accesso da
altri.
Con altri oggetti di sincronizzazione puoi fare un semplice test e
decidere se uscire o aspettare.
Alla fine dei conti non esiste la distinzione tra protezione di codice
o dati visto che i dati devono essere protetti da codice in esecuzione.
Quindi tutti i sistemi di sincronizzazione sono relativi al codice,
critical section comprese.
> P.S. non c'entra una mazza, ma ho scoperto che accodando files ad un unico
> stream compresso (GZip) esso non può, necessariamente, tenere traccia
> dell'origine dei vari chunks, ergo sto aggiungendo la generazione di un file
> indice, per poter ricostruire uan struttura.
Infatti questo è il sistema che usano tutti.
Se oltre a zippare vuoi anche mantenere una relazione tra i vari
elementi all'interno dell'archivio, esiste apposta la classe Package
che implementa lo standard ISO delle Open Packaging Conventions (OPC)
usato tra gli altri dai formati OOXML (docx, xlsx, pptx).
> Questo programma è nato da un'esigenza forse triviale : con molti compressori
> (tutti quelli che ho provato) che funzionano anche via files di listing, ho
> notato che file diversi per percorso ma di stesso nome, mi generano
> condizione di errore o sovrascritture. Con un backup di pagine web da siti è
> micidiale, ci saranno centinaia di index.html per fare un esempio, ma devono
> poter essere archiviati in copie distinte senza sovrascritture, ergo mi son
> detto, me lo faccio a mano, e poi si sta facendo lunga.
I file mht di IE fanno grossomodo la stessa cosa
> ciao e grazie delle varie consulenze
prego, ciao



title: [VB.net] Prevenire codice rientrante

text:
Il 27/12/2010 22:13, Raffaele Rialdi [MVP] ha scritto:
premesso che mi sei stato molto utile e mi hai dato parecchi
spunti generali
>> beh, il controllo del semaforo è però messo come prima istruzione
>> eseguibile della routine, ergo è vero che può essere richiamata mentre
>> ancora la vecchia istanza gira, ma la nuova esce immediatamente, ergo
>> è una chiamata a vuoto senza effetti collaterali. Perlomeno non che
>> riesca a immaginarne. Le sub in questione hanno un unico entry point
>> ... e li si decide se la chiamata va servita o rifiutata
>
> beh se già usi un semaforo allora il boolean non ti serve a nulla
:-) Intendevo uno fatto a mano, eh he he. Non sapevo nemmeno
che esistesse un costrutto prefabbricato per i semafori in
VB, come ho letto in fondo al messaggio.
Ora che lo so, mi guardo pure quello.
Ignoro parecchie caratteristiche del VB attuale, in effetti.
Ad es. ero convinto che la "direttiva" using (non so manco
se dire direttiva sia corretto) fosse solo un'indicazione al
compilatore di usare certi simboli come abbreviazioni di
nomi in scope completi lunghi e tediosi (tipo il namespace
system.io.etc.etc).
Ma ora mi studio la sintassi che suggerisci, che sarebbe
molto più robusta del codice manuale che metto io.
>
>> si, niente threads. E' un programma strutturalmente semplicissimo.
>> Costruisci la struttura di directory e files di dischi selezionati,
>> applichi filtri su data, dimensioni, tipi, esclusioni, generi lista di
>> filenames, poi eventualmente richiamo di una routine di compressione
>> GZIP prefabbricata.
>> Concettualmente semplice. L'unico problema nasce dal non voler
>> bloccare la gui (e l'OS) e dalla durata temporale di certe chiamate,
>> tipo la scansione disco e ricostruzione della struttura, e ancorpiù la
>> compressione vera e propria.
>> Dentro ci sono un bel po' di Application.DoEvents() (anche se non
>> funzionano manco tanto bene, il perché non so ancora)
>
> per questo genere di lavori il multithreading è l'unico modo di rendere
> fluida l'esecuzione, magari mantenendo ad una priorità più bassa i
> worker thread evitando di divorare troppa cpu.
Si hai perfettamente ragione. Ma siccome non è sw
commerciale, è un'utilità che mi scrivo a mio uso e consumo,
non mi sono posto il problema di un'implementazione con
tutti i crismi. Usare una caratteristica adatta ma per me
del tutto nuova, credo mi avrebbe fatto correre più rischi
di un sistema in sé meno adatto ma più famigliare, diciamo.
Cmq è vero che quelle interminabili elaborazioni disco sono
un contesto perfetto per un thread a bassa priorità.
>
> BTW i veri programmi di backup usano le shadow copy e/o le backup api in
> modo da non avere problemi sui file in uso.
>
Già ... non ho mai usato questi servizi. Già che hai fatto
tanto, mi diresti anche se una qualche parte di questi
servizi tipo la VSS e api varie è wrappata in qualche parte
dei namespaces di .net ? Io ne ho esplorata davvero una
frazione minimale sinora, e non è banale cercare un ago in
un pagliaio, se nemmeno sai come si chiama, questo ago.
Ah, altro consiglio, OT rispetto al post ma già che ci sono
te lo chiedo qui.
Sai mica se esista una qualche libreria free o anche
sorgente, per implementare dei mini file-systems incapsulati
in singolo file ? Mi pare che si chiamino self contained
file systems, ma in VB non ne ho mai letto
>
>> Ma mi rendo conto ora di essermi forse spiegato malissimo.
>> Il mio problema non è nella concorrenza dell'accesso a dati condivisi.
>> Piuttosto della concorrenza di esecuzione del codice da eventi
>> asincroni generati dalla gui.
>
> occhio che se mi parli di eventi asincroni implica automaticamente
> multithreading
>
beh, di fatto credo che in modo implicito la gui e i suoi
eventi girino in parallelo anche senza lanciare thread
manualmente, no ?
>
>> Non avevo eccessiva voglia di disabilitare i menu che richiamano le
>> routine pesanti, perché questa soluzione esterna mi sembra poco
>> robusta : dovessi aggiungere qualche altro bottone che le richiama,
>> dovrei ricordarmi di inattivarlo e riattivarlo. Invece una garanzia
>> interna alla funzione prescindeva dal ridisegno della gui e delle
>> relazioni tra le due parti.
>
> Di norma vanno fatte entrambe le cose altrimenti l'utente non può capire
> che la funzionalità è momentaneamente non disponibile.
Anche questo è vero, ma sottolineo che l'unico utente a
poter subire le storture di sw scritto un po' alla veloce
sono io medesimo. Al massimo inserisco un BEEP quando la
chiamata ritorna false :)
>
>> in realtà ci sono molti exit point dentro, e per ciascuno mi devo
>> ricordare di mettere a false il flag semaforo subito prima di uscire,
>> e già è una cosa che mi pare error prone se la sub ha un corpo di più
>> di due pagine. Cmq se non altro ho da guardare in un solo blocco
>> omogeneo di codice. L'idea di disabilitare i controlli che richiamano
>> la procedura dopo averla invocata, e riabilitarli al rientro, mi
>> risulta raccapricciante :-)
>
> mi pareva usassi un semaforo ... se così è puoi semplicemente fare:
> using(semaforo)
> {
> ....
> }
>
> Lo using statement esiste anche in vb:
>
http://msdn.microsoft.com/en-us/library/htd05whh.aspx
si, lo conoscevo ... ma evidentemente non bene, dato che
ritenevo si usasse solo per esporre allo scope attivo
simboli pesantemente annidati in namespaces tediosi da
leggere per intero.
Ora vedo di studiarmi quella sintassi che mi hai suggerito
>
>
>> Io però devo bloccare del codice eseguibile, più che l'accesso a dati
>> critici
>
> lock, cioè le critical section, non fanno altro che impedire che un
> altro thread possa eseguire lo stesso pezzo di codice.
> La peculiarità di lock è di far attendere in una funzione di wait il
> thread che tenti di eseguire il codice che attualmente è già accesso da
> altri.
il che è esattamente quanto mi serve, ok
> Con altri oggetti di sincronizzazione puoi fare un semplice test e
> decidere se uscire o aspettare.
>
> Alla fine dei conti non esiste la distinzione tra protezione di codice o
> dati visto che i dati devono essere protetti da codice in esecuzione.
> Quindi tutti i sistemi di sincronizzazione sono relativi al codice,
> critical section comprese.
>
>> P.S. non c'entra una mazza, ma ho scoperto che accodando files ad un
>> unico stream compresso (GZip) esso non può, necessariamente, tenere
>> traccia dell'origine dei vari chunks, ergo sto aggiungendo la
>> generazione di un file indice, per poter ricostruire uan struttura.
>
> Infatti questo è il sistema che usano tutti.
ah ... mi pareva una cosa abborracciata.
> Se oltre a zippare vuoi anche mantenere una relazione tra i vari
> elementi all'interno dell'archivio,
non so se ho capito esattamente cosa intendi per
"relazione", ma devo memorizzare informazioni relative al
path completo, anche se nell'archivio i dati sono poi
appiattiti e accodati di fila. Quando riapro l'indice vorrei
poter capire le varie copie di files omonimi dove stavano in
origine (e date varie, size compressa e non etc).
> esiste apposta la classe Package che
> implementa lo standard ISO delle Open Packaging Conventions (OPC)
che ignoravo pure queste. Sei una miniera di spunti utili !
> usato
> tra gli altri dai formati OOXML (docx, xlsx, pptx).
non ne conosco nessuno, suppongo siano formati Microsoft.
Come documenti uso solo openoffice, anche perchè lo abbiamo
anche a scuola.
>
>> Questo programma è nato da un'esigenza forse triviale : con molti
>> compressori (tutti quelli che ho provato) che funzionano anche via
>> files di listing, ho notato che file diversi per percorso ma di stesso
>> nome, mi generano condizione di errore o sovrascritture. Con un backup
>> di pagine web da siti è micidiale, ci saranno centinaia di index.html
>> per fare un esempio, ma devono poter essere archiviati in copie
>> distinte senza sovrascritture, ergo mi son detto, me lo faccio a mano,
>> e poi si sta facendo lunga.
>
> I file mht di IE fanno grossomodo la stessa cosa
non conosco nemmeno questo formato. Se pure di questo esiste
qualche classe wrapper in VB che mi possa evitare di
riscrivere a mano un file system minimale ...
ma mi pare che già la class PAckage che dicevi faccia
concettualmente la stessa cosa, vero ? I chunk di contenuto
che ci si ficcano dentro possono essere tenuti in ordine
gerarchico come in una struttura di dir ?
Vabbè, ora vado a guardare se trovo qualcosa autonomamente, cmq
>
>> ciao e grazie delle varie consulenze
>
> prego, ciao
>
Ri-grazie !
Ciao
CCCP


title: [VB.net] Prevenire codice rientrante

text:
> :-) Intendevo uno fatto a mano, eh he he. Non sapevo nemmeno che esistesse un
> costrutto prefabbricato per i semafori in VB, come ho letto in fondo al
> messaggio.
> Ora che lo so, mi guardo pure quello.
> Ignoro parecchie caratteristiche del VB attuale, in effetti.
Sono wrapper delle win32 del sistema operativo, quindi usabili da
qualsiasi linguaggio nativo o managed
> Ad es. ero
> convinto che la "direttiva" using (non so manco se dire direttiva sia
> corretto) fosse solo un'indicazione al compilatore di usare certi simboli
> come abbreviazioni di nomi in scope completi lunghi e tediosi (tipo il
> namespace system.io.etc.etc).
In C# using è sia una direttiva  (quella dei namespace come scrivevi)
che uno statement (quello che ho scritto nel precedente post).
In VB la direttiva using si chiama imports, mentre lo statement si
chiama sempre using.
> Ma ora mi studio la sintassi che suggerisci, che sarebbe molto più robusta
> del codice manuale che metto io.
lo statement using non fa altro che dire al compilatore di generare del
codice con un try/finally. Nel try c'è tutto quello che metti dentro il
blocco, dentro il finally c'è la chiamata al metodo Dispose.
Per questo motivo lo statement using è utilizzabile solo su classi che
implementano IDisposable:
using(classe che implementa IDisposable)
{
} // alla chiusura del blocco viene chiamata la Dispose anche in caso
di eccezione
> Già ... non ho mai usato questi servizi. Già che hai fatto tanto, mi diresti
> anche se una qualche parte di questi servizi tipo la VSS e api varie è
> wrappata in qualche parte dei namespaces di .net ? Io ne ho esplorata davvero
> una frazione minimale sinora, e non è banale cercare un ago in un pagliaio,
> se nemmeno sai come si chiama, questo ago.
No le shadow copy non sono wrappate in .net che io sappia.
> Ah, altro consiglio, OT rispetto al post ma già che ci sono te lo chiedo qui.
> Sai mica se esista una qualche libreria free o anche sorgente, per
> implementare dei mini file-systems incapsulati in singolo file ? Mi pare che
> si chiamino self contained file systems, ma in VB non ne ho mai letto
Per fare il mount di un volume ci vuole un driver come fanno diverse
utility. Altro non saprei.
> beh, di fatto credo che in modo implicito la gui e i suoi eventi girino in
> parallelo anche senza lanciare thread manualmente, no ?
No, non sarebbe possibile perché la GUI deve gestire tutto nel thread
che ha creato la message pump.
Per quanto riguarda WPF ci sono dei working thread secondari ma che
sono del tutto nascosti e che comunque non risolvono i problemi di cui
sopra (cioè tutti gli eventi sono comunque generati nel thread
principale).
> non so se ho capito esattamente cosa intendi per "relazione", ma devo
> memorizzare informazioni relative al path completo, anche se nell'archivio i
> dati sono poi appiattiti e accodati di fila. Quando riapro l'indice vorrei
> poter capire le varie copie di files omonimi dove stavano in origine (e date
> varie, size compressa e non etc).
per relazione intendo delle dipendenze. Per esempio un file html ha
delle dipendenze sulle immagini. Se cancelli il file html vorrai anche
cancellare tutti i file dipendenti. Il Package ti consente di definire
quali siano i file dipendenti e poterli rimuovere quando nessuno li
referenzia più.
> non ne conosco nessuno, suppongo siano formati Microsoft. Come documenti uso
> solo openoffice, anche perchè lo abbiamo anche a scuola.
Sono formati standard ISO, promossi da Microsoft ma assolutamente
standard.
> non conosco nemmeno questo formato. Se pure di questo esiste qualche classe
> wrapper in VB che mi possa evitare di riscrivere a mano un file system
> minimale ...
Non credo esista un wrapper
> ma mi pare che già la class PAckage che dicevi faccia concettualmente la
> stessa cosa, vero ? I chunk di contenuto che ci si ficcano dentro possono
> essere tenuti in ordine gerarchico come in una struttura di dir ?
> Vabbè, ora vado a guardare se trovo qualcosa autonomamente, cmq
Sono formati diversi ma per alcune cose si assomigliano.
Si, puoi gestire le gerarchie.
Prego, ciao



title: POP3 gestire email in entrata

author: Il Recapito Espresso

text:
Salve a tutti,
tramite POP3 riesco a ricevere le email.
Problemi li incontro quando una email mi ritorna indietro come "Mail
delivery service", in quanto non trovo, in questa email di ritorno,
l'indirizzo email che ha causato questo messaggio.
Come risolvo?
Saluti
Fabio


title: Creazione stringhe

author: BlackSun

text:
Ciao,
ho una datatable formata da N colonne e circa 1000 righe e devo creare
un'unica stringa con tutti i valori delle celle delle righe o parte di
esse.
Essendo le stringhe immutabili e ad ogni concatenazione se ne crea una
nuova diventerebbe troppe.
A questo punto ho pensato di usare il seguente codice:
Dim stringa As New System.Text.StringBuilder
For Each cella In colonneDT
     stringa.Append(dati.Rows(riga).Item(cella))
     stringa.Append("---")
Next
e poi lavoro con stringa.ToString()
Secondo voi e' una buona tecnica oppure no?
Grazie mille
Ciao BlackSun


title: Creazione stringhe

author: dedalus

text:
On 31/05/2011 10:13, BlackSun wrote:
> Secondo voi e' una buona tecnica oppure no?
Si, la classe StringBuilder esiste proprio per questo.
Ciao


title: Creazione stringhe

text:
Ciao,
> On 31/05/2011 10:13, BlackSun wrote:> Secondo voi e' una buona tecnica oppure no?
>
> Si, la classe StringBuilder esiste proprio per questo.
Ok.. grazie del feedback :-)
Ciao BlackSun


title: Creazione stringhe

author: Axeman

text:
Il 31/05/2011 10:13, BlackSun ha scritto:
> Dim stringa As New System.Text.StringBuilder
[...]
> Secondo voi e' una buona tecnica oppure no?
Visto che lo StringBuilder esiste esattamente per questo motivo, direi
che si, č una buona tecnica... :-)


title: Creazione stringhe

author: LudovicoVan

text:
"BlackSun" <
blac...@email.it
> wrote in message
news:5fd41b42-269a-4145...@f15g2000yqe.googlegroups.com...
> Secondo voi e' una buona tecnica oppure no?
Considera che DataTable ha la serializzazione built-in: se e' adeguata al
tuo scenario, e' preferibile ad un metodo custom.
-LV

--- Posted via news://
freenews.netfront.net/
 - Complaints to
ne...@netfront.net
 ---


title: c++.NET problema chiusura form

author: Minnozzi Corrado

text:
Salve, ho fatto una form con un pulsante; cliccando sul pulsante la form si
deve chiudere.
Ho scritto questo codice dove FormAbout è la classe della form
ma non si chiude:
private: System::Void AboutOK_Click(System::Object^  sender,
System::EventArgs^  e) {
                 FormAbout ^ChiudiForm = gcnew FormAbout();
                 ChiudiForm->Close();
             }


title: c++.NET problema chiusura form

author: Mauro Servienti [MVP]

text:
Ciao Minnozzi Corrado,
You wrote on 13/11/2010 :
> Salve, ho fatto una form con un pulsante; cliccando sul pulsante la form si
> deve chiudere.
> Ho scritto questo codice dove FormAbout ï¿œ la classe della form
> ma non si chiude:
>
> private: System::Void AboutOK_Click(System::Object^  sender,
> System::EventArgs^  e) {
>                  FormAbout ^ChiudiForm = gcnew FormAbout();
>
>                  ChiudiForm->Close();
>              }
ChiudiForm ï¿œ una nuova form ovvio che la tua non si chiuda, Close devi
chiamarlo sull'istanza corrente.
.m
--
Mauro Servienti
{C67C0157-5D98-4733-A75E-93CAEE4BADC8}
Microsoft MVP - Visual C# / MCTS
http://mvp.support.microsoft.com
blog @
http://milestone.topics.it
whynot [ at ] topics [ dot ] it


title: c++.NET problema chiusura form

text:
"Mauro Servienti [MVP]"  ha scritto nel messaggio
news:mn.6b1f7dab8...@online.nospam...
Ciao Minnozzi Corrado,
You wrote on 13/11/2010 :
> Salve, ho fatto una form con un pulsante; cliccando sul pulsante la form
> si
> deve chiudere.
> Ho scritto questo codice dove FormAbout è la classe della form
> ma non si chiude:
>
> private: System::Void AboutOK_Click(System::Object^  sender,
> System::EventArgs^  e) {
>                  FormAbout ^ChiudiForm = gcnew FormAbout();
>
>                  ChiudiForm->Close();
>              }
ChiudiForm è una nuova form ovvio che la tua non si chiuda, Close devi
chiamarlo sull'istanza corrente.
.m
--
Mauro Servienti
{C67C0157-5D98-4733-A75E-93CAEE4BADC8}
Microsoft MVP - Visual C# / MCTS
http://mvp.support.microsoft.com
blog @
http://milestone.topics.it
whynot [ at ] topics [ dot ] it
Ti ringrazio, ho fatto così:
private: System::Void AboutOK_Click(System::Object^  sender,
System::EventArgs^  e) {
                 this->Close();
             }
e ora è ok, mi sei stato di grande aiuto grazie di nuovo


title: c++.NET problema chiusura form

text:
Ciao Corrado,
You wrote on 13/11/2010 :
> Ti ringrazio, ho fatto così:
> private: System::Void AboutOK_Click(System::Object^  sender,
> System::EventArgs^  e) {
>                  this->Close();
>              }
> e ora è ok, mi sei stato di grande aiuto grazie di nuovo
di nulla, prego :-)



title: c++.NET problema chiusura form

author: Alessandro Riolo

text:
"Minnozzi Corrado" <
corrado...@interfree.it
> wrote
> e ora è ok, mi sei stato di grande aiuto grazie di nuovo
* "CORSO di QUOTAGGIO per newbie"
http://web.tiscali.it/mom/usenet-it/faq/quotaggio.txt
* "Cosa significa 'quotare' o 'citare'? "
http://www.faqintosh.com/faq.cgi?Faq=0189
* "Guida ai ng - Il Quoting"
http://usenet.marco5x.net/usenet/quoting.php
* "Il quoting: questo sconosciuto"
http://it.geocities.com/usenetitalia/quoting.html
* "Il "quoting", questo sconosciuto!"
http://digilander.libero.it/ifst/html/Quoting.html
* "QuotarBene", Piccola guida per imparare a quotare
http://wiki.news.nic.it/QuotarBene
--
ale
http://ale.riolo.co.uk


title: Prelevare il colore di un pixel da un filmato

author: roby

text:
Ciao a tutti.
Ho un problema forse già affrontato ma di cui non riesco a trovare
documentazione.
Ho la necessità di prevelare il colore di un pixel o di una piccola porzione
di pixel per misurarne il colore medio in una determinata porzione di un
filmato.
Il problema è che utilizzando la api getpixel o lavorando con la getpixel di
Bitmap non viene rilevato il colore del pixel.
In realtà è il mio primo approccio nel campo dei video e non ho le
conoscenze adeguate.
Comunque :
sto provando con questa funzione, devo dire non velocissima :

Public Function GetColorPixel(ByVal x As Integer, ByVal y As Integer) As
Integer
        Dim winDc As Integer = GetWindowDC(GetDesktopWindow)
        Dim color As Integer = GetPixel(winDc, x, y) '.ToString
        Return color
End Function

molto più veloce questa :
   Function GetScreenPixel(ByVal pt As Point) As Color
        Using bmp As New Bitmap(1, 1)
            Using g As Graphics = Graphics.FromImage(bmp)
                g.CopyFromScreen(pt, Point.Empty, New Size(1, 1))
                Return bmp.GetPixel(0, 0)
            End Using
        End Using
    End Function

ma entrambe ritornano il colore black su filmati.

Il problema è che l'operazione deve essere velocissima in quanto devo
sontestualmente modificare il colore, con una frequenza di qualche centesimo
di secondo.
Forse la strada è nell'utilizzo delle directx?

Qualcuno mi saprebbe aiutare?
Grazie mille.


text:
roby wrote:
> Ho la necessità di prevelare il colore di un pixel o di una piccola porzione
> di pixel per misurarne il colore medio in una determinata porzione di un
> filmato.
> Il problema è che utilizzando la api getpixel o lavorando con la getpixel di
> Bitmap non viene rilevato il colore del pixel.

Non puoi usare le classi GDI/GDI+ per un video.
Puoi usare DirectShow oppure Windows Media Foundation (da Vista in
poi).
Entrambi lavorano a pipeline dove il flusso parte dalla sorgente del
segnale (lettura file), passa da uno o più encoder e arriva infine
tipicamente alla scheda audio che riproduce il suono.

Diciamo che vuoi lavorare con DirectShow, in questo caso dovrai
sviluppare un filter che si mette in mezzo nella pipeline e intercetta
tutti i frame. Quello è il punto nel quale hai a disposizione la
singola immagine da cui poter ricavare le informazioni che ti servono.

Se cerchi 'directshow filter C#' troverai diverso materiale in giro...

--
Raffaele Rialdi
http://www.iamraf.net

Weblog:
http://blogs.ugidotnet.org/raffaele

Microsoft MVP profile
https://mvp.support.microsoft.com/profile/raffaele

UGIdotNET -
http://www.ugidotnet.org/


author: dmaxime

text:
> molto più veloce questa :
>     Function GetScreenPixel(ByVal pt As Point) As Color
>          Using bmp As New Bitmap(1, 1)
>              Using g As Graphics = Graphics.FromImage(bmp)
>                  g.CopyFromScreen(pt, Point.Empty, New Size(1, 1))
>                  Return bmp.GetPixel(0, 0)
>              End Using
>          End Using
>      End Function

Ciao,
io ho provato questo esempio e, per un filmato riprodotto con wmp,
funziona. E' pari al tuo esempio:

http://www.youtube.com/watch?v=oyME_Pa_o8k


text:
Grazie mille!
Nell'attesa stavo tentando di capire con Diretshow e devo dire che è davvero
un mondo interessante.
A riguardo del graphBuilder magari se posso ti chiederò qualche dritta se
incontro problemi (direi certamente)!
Ciao!


text:
Si, vero. Ma in genere i player dvbt utilizzano directx dove l'esempio non
può funzionare.
Sto vedendo con directshow che è credo la strada migliore con la speranza
che tutto si possa fare con la velocità richiesta.
Ciao e grazie.


text:
Ciao,
io ho creato un filtro che mi visiona un canale dbv-t. Ora non ho le
conoscenze adeguate per inserire il filtro ova possa rilevare pixel ed
eventualmente modificarne il colore.
Sfrutto la tua pazienza per chiederti, posto che il graphbuilder è questo e
che abbia fatto un lavoro nella direzione giusta, che filtro devo frapporre
(forse tra il 4 e il 9 connection 7)?
--------------------------------------------------
  Filters
--------------------------------------------------
  1. DVBT Network Provider
  2. AF9015 BDA Filter
  3. MPEG2 Demultiplexer
  4. HT MPEG Video Decoder
  5. ArcSoft Audio Decoder
  6. BDA MPEG2 Transport Information Filter
  7. MPEG-2 Sections and Tables
  8. DirectSound Renderer
  9. Video Mixing Renderer Filter 9

--------------------------------------------------
  Connections
--------------------------------------------------
  1. [DVBT Network Provider]/(Antenna Out) -> [AF9015 BDA Filter]/(Antenna
In Pin)
  2. [AF9015 BDA Filter]/(MPEG2 Transport) -> [MPEG2 Demultiplexer]/(MPEG-2
Stream)
  3. [MPEG2 Demultiplexer]/(1) -> [BDA MPEG2 Transport Information
Filter]/(Input)
  4. [MPEG2 Demultiplexer]/(2) -> [HT MPEG Video Decoder]/(XForm In)
  5. [MPEG2 Demultiplexer]/(3) -> [ArcSoft Audio Decoder]/(XForm In)
  6. [MPEG2 Demultiplexer]/(5) -> [MPEG-2 Sections and Tables]/(In)
  7. [HT MPEG Video Decoder]/(XForm Out) -> [Video Mixing Renderer Filter
9]/(VMR Input0)
  8. [ArcSoft Audio Decoder]/(XForm Out) -> [DirectSound Renderer]/(Audio
Input pin (rendered))

Grazie!
Roby

"Raffaele Rialdi [MVP]" <
malta@n0spam_vevy.com
> ha scritto nel messaggio
news:mn.2d617dbb1...@n0spamvevy.com...



text:
roby wrote:
> Ciao,
> io ho creato un filtro che mi visiona un canale dbv-t. Ora non ho le
> conoscenze adeguate per inserire il filtro ova possa rilevare pixel ed
> eventualmente modificarne il colore.
> Sfrutto la tua pazienza per chiederti, posto che il graphbuilder è questo e
> che abbia fatto un lavoro nella direzione giusta, che filtro devo frapporre
> (forse tra il 4 e il 9 connection 7)?
> --------------------------------------------------
>   Filters
> --------------------------------------------------
>   1. DVBT Network Provider
>   2. AF9015 BDA Filter
>   3. MPEG2 Demultiplexer
>   4. HT MPEG Video Decoder
>   5. ArcSoft Audio Decoder
>   6. BDA MPEG2 Transport Information Filter
>   7. MPEG-2 Sections and Tables
>   8. DirectSound Renderer
>   9. Video Mixing Renderer Filter 9
>

Da quanto racconti hai costruito un grado di filtri già installati.
Questo è certamente il primo passo.
Adesso dovresti creare un tuo nuovo filter che si piazzi prima del
renderer in cui intercetti il flusso (solo video) dei frame.

Prima di tutto leggiti un po' di doc qui:
http://msdn.microsoft.com/en-us/library/ms788163

Poi in giro trovi già molti esempi sia C++ che C# su come creare quel
tipo di filtro.
Dovrai fare un po' di prove ma la cosa positiva è che, una volta
registrato, potrai testarlo direttamente inserendolo visualmente nel
grafo che hai già creato.



text:
Si, con questi filtri creo il player : mi connetto al canale digitale e lo
mando in esecuzione.
Mi rinfranca la tua risposta anche se da qui a vedere il lavoro finito ho da
capire quale filtro devo sistemare e soprattutto come intercettare
l'immagine.
Grazie.


text:

Butta un occhio su questo:
http://www.codeproject.com/KB/audio-video/framegrabber.aspx

altra possibile soluzione:
http://msdn.microsoft.com/en-us/library/ms787697

Libreria che semplifica tutto:
http://splicer.codeplex.com/

Altra libreria (forse la più famosa):
http://directshownet.sourceforge.net/about.html

La corrispondente per Media Foundation:
http://mfnet.sourceforge.net/




text:
Grazie per l'aiuto prezioso.
Ciao!


text:
roby wrote:
> Grazie per l'aiuto prezioso.
> Ciao!

Prego!



title: Cattura frame di un filmato flash

text:
Salve a tutti.
Ho la necessità di catturare i frame di uno stream video in esecuzione su
Flashplayer.

Per esempio :
aprire un qualsiasi filmato su youtube ed in temporeale replicare il filmato
in una picturebox.

Non ho la possibilità di importare lo stream nella mia applicazione,
pertanto devo costruire uno strumento di cattura della porzione di screen
per ribaltarla su una picturebox, ovviamente senza intaccare la normale
esecuzione dello stream.

Ho provato utilizzando algoritmi veloci, utilizzando directx ma niente. Il
risultato non è un filmato fluido, quindi nun accettabile.

Qualcuno può darmi indicazioni??

Grazie mille e saluti.


title: NUnit e Windows Phone 7

author: Andrea Angella

text:
Salve a tutti,
sto utilizzando la versione RC dei tool per Windows Phone Mango.
Ho una applicazione Windows Phone 7.1. Separatamente ho una class
library come progetto di tests per l'applicazione Windows Phone 7.1
che viene referenziata (Visual Studio mostra un punto esclamativo).
Tutto compila perfettamente ma quando lancio il test runner mi viene
segnalato un errore di caricamento dell'assembly.
Cercando in rete vengo rimandato ad altri framework specifici. Sono un
po' confuso.
In che modo e' possible scrivere unit tests per le proprie
applicazioni Windows Phone 7 ?
Grazie


title: NUnit e Windows Phone 7

text:
Ciao Andrea,
You wrote on 02/09/2011 :
> Ho una applicazione Windows Phone 7.1. Separatamente ho una class
> library come progetto di tests per l'applicazione Windows Phone 7.1
> che viene referenziata (Visual Studio mostra un punto esclamativo).
> Tutto compila perfettamente ma quando lancio il test runner mi viene
> segnalato un errore di caricamento dell'assembly.
>
> Cercando in rete vengo rimandato ad altri framework specifici. Sono un
> po' confuso.
>
> In che modo e' possible scrivere unit tests per le proprie
> applicazioni Windows Phone 7 ?
da quel che ho capito e per le 3 prove in croce che ho fatto devi usare
un test runner ad hoc.
> Grazie
.m
--
Mauro Servienti
{C67C0157-5D98-4733-A75E-93CAEE4BADC8}
Microsoft MVP - Visual C# / MCTS
http://mvp.support.microsoft.com/profile/mauro
blog @
http://milestone.topics.it
whynot [ at ] topics [ dot ] it


title: NUnit e Windows Phone 7

text:
Ciao Mauro, grazie.

Ho provato "NUnit for Windows Phone" su codeplex e funziona anche se e' scomodo.
http://nunitwindowsphone7.codeplex.com/

Non so quali siano le altre opzioni.


title: NUnit e Windows Phone 7

text:
Ciao Andrea Angella,

lo so che ï¿œ scomodo, ma non conosco altre strade.



title: Caricamento MailMessage

author: Gabryy

text:
Vorrei sapere come implementare il caricamento da file eml in
mailmessage e il salvataggio.
Praticamente implementare
MailMessage.load e
MailMessage.save,

naturalmente in modo free.

Thank you

--- news://
freenews.netfront.net/
 - complaints:
ne...@netfront.net
 ---


title: WPF - Bindare elementi contextmenu ad un selecteditem

author: Fabio

text:
Salve a tutti
ho una datagrid della quale una volta selezionato un elemento vorrei
visualizzare il valore di una proprietà.
Per essere più chiaro, il mio elemento selezionato contiene una
colonna che mi interessa della quale vorrei poter impostare il valore.
Io ho inserito un contextmenu (il cui datacontext è impostato sul
selecteditem) che contiene due menuitem checkable che tramite un
converter mi dovrebbe dire quale valore è impostato.
Non funziona.
Allego il codice che uso:
			<DataGrid.ContextMenu>
                <ContextMenu DataContext="{Binding
dgListaOrdini.SelectedItem}">
                	<RadioButton Content="Ritirato" IsChecked="{Binding
Esito, Converter={StaticResource EsitoPositivoConverter}, Mode=TwoWay,
UpdateSourceTrigger=PropertyChanged}"
                                 />
                	<RadioButton Content="Nullo" IsChecked="{Binding
Esito, Converter={StaticResource EsitoNegativoConverter}, Mode=TwoWay,
UpdateSourceTrigger=PropertyChanged}"/>
                </ContextMenu>
            </DataGrid.ContextMenu>
Saluti
Fabio


text:

Trovato:
http://stackoverflow.com/questions/1021825/bind-contextmenus-menuitem-visibility-to-listview-selection
Saluti
Fabio


title: disabilitare l'esecuzione di script in una directory del sito

author: neroMalpelo

text:
Salve

vorrei sapere se e' possibile disabilitare l'esecuzione di qualsiasi
script lato server per una directory (e sotto directory) posta nella
root del sito.
IL sito gira su IIS 7 e sono in esecuzione delle pagine con script (e
queste devono rimanere) ma in una sottodirectory vorrei che non vengano
mandate in esecuzione alcun tipo di script lato server.

saluti a tutti


text:
"neroMalpelo" <
nerom...@virgilio.it
> wrote in message
news:50a3be53$0$13275$4faf...@reader2.news.tin.it...

Ciao, non ho smanettato con IIS7 piu' di tanto per cui vado a naso: forse si
tratta di rendere il folder in questione una Web Application (intendo dalla
console di IIS) e poi disabilitare tutti i Modules relativi ad
ASP.NET
 (e
quant'altro, per esempio CGI, ecc.: il fatto e' che non mi ricordo un modo
semplice di disabilitare
ASP.NET
 per un sito in IIS7).  Anzi, forse te la
cavi piu' semplicemente impostando i permessi della cartella in questione (e
dei file e sotto-cartelle) rimuovendo l'utente dell'appliication pool (che
e' quello sotto cui il sito gira) e lasciando solo l'utente IIS anonimo.

In ogni caso c'e' uno smell associato alla tua domanda, al livello di
architettura...

-LV


title: C# e db

author: GennarinOSpion

text:
ciao,

a parte SqlServer e mysql, ci sono versioni 'più light' e magari free di
database che possono essere interfacciati a C#, non necessariamente di
tipo server?

grazie


title: C# e db

text:

Sql Compact non ha bisogno di installazioni e lavora su un singolo
file.
Il vantaggio rispetto ad altri soluzioni lite è che compact sql ha
maggiore supporto dei tool (per esempio puoi usarlo con entity
framework).

--
Raffaele Rialdi
http://www.iamraf.net

Weblog:
http://blogs.ugidotnet.org/raffaele

Microsoft MVP profile
https://mvp.support.microsoft.com/profile/raffaele

UGIdotNET -
http://www.ugidotnet.org/


title: C# e db

text:
Il 21/10/2011 19:25, Raffaele Rialdi [MVP] ha scritto:
> Sql Compact non ha bisogno di installazioni e lavora su un singolo file.
> Il vantaggio rispetto ad altri soluzioni lite è che compact sql ha
> maggiore supporto dei tool (per esempio puoi usarlo con entity framework).

thx! :)


title: C# e db

author: RobertoA

text:
"GennarinOSpion" <
Gennari...@n.it
> ha scritto nel messaggio
news:j7sjmh$csd$1...@speranza.aioe.org...

Dai un'occhiata a Firebird, la versione embedded permette di avere un db
completo di funzioni di alto livello con una sola dll
Inoltre i dati stanno dentro un unico file, molto semplice quindi passare
archivi da una parte all'altra durante le fasi di debug iniziale
Open source, gratuito anche per scopi commerciali, multi piattaforma,
robusto, backup a caldo, ecc, ecc...
RobertoA


title: C# e db

author: Enzo Campanella

text:
"GennarinOSpion"  ha scritto nel messaggio
news:j7s87u$dpm$1...@speranza.aioe.org...

Puoi usare PostgreSql giunto alla versione 9.1.
E' completamente gratuito anche per scopi commerciali.
NpgSql.dll è il connector per il framework.

Enzo.


title: A che livello mettere la localizzazione?

author: Giulio Petrucci

text:
Ciao a tutti,
con dei colleghi stiamo lavorando ad una applicazione web piuttosto
complessa che dovrà essere installata (già da subito) in tre nazioni
differenti, con tre lingue differenti. :-)
Ogni metodo del service layer ritorna una oggetto di tipo:
class MethodResult<T> {
	T Result { get; }
	bool Success { get; }
	string[] ErrorMessages { get; }
}
stiamo discutendo "alacremente" :-) sulla questione: in ErrorMessages ci
vanno stringhe già tradotte/localizzate o è meglio inserire un codice di
errore e delegare l'interpretazione al presentation layer? Esiste
qualche guideline ufficiale?
Grazie,
Giulio
--


author: GM

text:
Il 12/05/2011 17.04, Giulio Petrucci ha scritto:
> Ciao a tutti,
>
> con dei colleghi stiamo lavorando ad una applicazione web piuttosto
> complessa che dovrà essere installata (già da subito) in tre nazioni
> differenti, con tre lingue differenti. :-)
>
> Ogni metodo del service layer ritorna una oggetto di tipo:
>
> class MethodResult<T> {
> T Result { get; }
> bool Success { get; }
> string[] ErrorMessages { get; }
> }
>
Ti do i miei 2 cents, ma prima una curiosità:
perché quella sovrastruttura e non una exception per gestire
l'insuccesso e il corrispondente errore?
> stiamo discutendo "alacremente" :-) sulla questione: in ErrorMessages ci
> vanno stringhe già tradotte/localizzate o è meglio inserire un codice di
> errore e delegare l'interpretazione al presentation layer? Esiste
> qualche guideline ufficiale?
>
Io propendo per la delega ai layer più alti. Ma più che di un "codice"
preferirei parlare della "formattazione". Cioè passare un qualcosa che
contiene l'id del messaggio ma anche eventuali parametri per la
formattazione. Qualcosa che ti permetta di scrivere stringhe tipo:
"Attenzione, il semaforo 25 è rosso" dove il numero 25 e la stringa
"rosso" sono parametri passati alla "format" finale. E dove il parametro
"rosso" potrebbe non essere direttamente una stringa ma a sua volta un
ID da pescare dalle risorse localizzate.
Chiederai: perché tutta questa complicazione? Per poterti permettere di
scrivere ad esempio due log: il primo nella lingua dell'applicazione, il
secondo nella lingua "neutra" dello sviluppatore.
Io ho dovuto fare così perché altrimenti quando mi mandavano dei log in
russo non ci capivo nulla.
Non so se esista in giro qualcosa di precotto, io in c++ nativo mi sono
dovuto arrangiare...
HTH


text:
Ciao GM,
On 5/12/2011 5:40 PM, GM wrote:
> Ti do i miei 2 cents, ma prima una curiosità:
> perché quella sovrastruttura e non una exception per gestire
> l'insuccesso e il corrispondente errore?
In che senso? Con uno Status (una enum per esempio) ho una serie di
valori "codificati" che indicano un ventaglio di possibilità. Dovrei
fare la stessa cosa con una sottoclasse di Exception per ogni possibilità?
Il problema generale comunque è questo: a seconda di un particolare
stato del ritorno di un metodo del service layer, il presentation layer
deve ridirezionare su altra view, formattare il testo in maniera
particolare, oppure semplicemente visualizzare un messaggio. Credo che
il tutto rientri in quel gran calderone che si chiama "navigazione"
ma... onestamente non è che ci capisca tanto! :-)
> Io propendo per la delega ai layer più alti. Ma più che di un "codice"
> preferirei parlare della "formattazione". Cioè passare un qualcosa che
> contiene l'id del messaggio ma anche eventuali parametri per la
> formattazione. Qualcosa che ti permetta di scrivere stringhe tipo:
> "Attenzione, il semaforo 25 è rosso" dove il numero 25 e la stringa
> "rosso" sono parametri passati alla "format" finale. E dove il parametro
> "rosso" potrebbe non essere direttamente una stringa ma a sua volta un
> ID da pescare dalle risorse localizzate.
Sono sincero ma... non ho capito tutto. :-)
Facendo un esempio:
ISemaphoreService {
	... Check()
}
il metodo check cosa ritorna? Come diventa nel caso da te citato
l'oggetto ritornato? L'approccio proposto "a pelle" mi fa riflettere su
una cosa: sia il PL che il SL conoscono le chiavi delle risorse, giusto?
> Chiederai: perché tutta questa complicazione? Per poterti permettere di
> scrivere ad esempio due log: il primo nella lingua dell'applicazione, il
> secondo nella lingua "neutra" dello sviluppatore.
Capisco. La mia idea era infatti questa:
class MyService
{
	MethodResult MyMethod()
	{
		//fai un sacco di cose e logghi in inglese;
		...
		//qui succede un'eccezione:
		var mr = new MethodResult { Success = false, Result = null };
		var msg = ThrowHelper.GetSfigherrimaMessage(...);
		//il throw helper ritorna un messaggio language-dependent
		mr.ErrorMessages = new string[] { msg };
		return mr
	}
}
il problema però è che così non posso proprio gestire la navigazione da
"dentro" al servizio. :-( Sia chiaro: onestamente non so nemmeno se sia
giusto gestire la navigazione da dentro al servizio, ma l'alternativa è
far passare quel tot di conoscenza che basta al PL per gestirla (i.e. i
famosi enum per definire lo status della richiesta)
> Io ho dovuto fare così perché altrimenti quando mi mandavano dei log in
> russo non ci capivo nulla.
Quanto ri capisco... :-)
Ciao,
Giulio
--


text:
"Giulio Petrucci" <sis...@nonono.boh> wrote in message
news:4dcbf716$0$38646$4faf...@reader1.news.tin.it...
> stiamo discutendo "alacremente" :-) sulla questione: in ErrorMessages ci
> vanno stringhe già tradotte/localizzate o è meglio inserire un codice di
> errore e delegare l'interpretazione al presentation layer?
Ti dico la mia: delegherei al presentation layer in modo da passare in giro
un codice piuttosto che una stringa; per semplicita', tornerei direttamente
il resourcekey/ResourceID che punta al messaggio di errore nelle risorse
localizzate.
-LV

--- Posted via news://
freenews.netfront.net/
 - Complaints to
ne...@netfront.net
 ---


text:
"LudovicoVan" <
ju...@diegidio.name
> wrote in message
news:iqhsfo$1in5$1...@adenine.netfront.net...
> delegherei al presentation layer in modo da passare in giro un codice
> piuttosto che una stringa
Pensandoci meglio, mi sembra che il presentation layer sia in ogni caso il
luogo deputato (possibilmente nel markup).



text:
Ciao LudovicoVan,
On 5/13/2011 2:02 AM, LudovicoVan wrote:
> Ti dico la mia: delegherei al presentation layer in modo da passare in
> giro un codice piuttosto che una stringa; per semplicita', tornerei
> direttamente il resourcekey/ResourceID che punta al messaggio di errore
> nelle risorse localizzate.
Ok, grazie della dritta, credo di aver capito l'antifona. :-)
Tuttavia volevo "armonizzare" questo suggerimento con quello di GM.
Supponiamo che sia nel caso di dover avere un messaggio "parametrico",
quindi nel file di risorse avrò un format per un messaggio di errore. In
generale al PL dovranno essere passati:
1. un id per il format dell'errore
2. una lista di parametri che possono essere:
	2.1 valori veri e propri
	2.2 id di valori da prendere dalle risorse
C'è qualcuno che si è trovato in questa situazione? Qualche spunto?
Grazie,
Giulio
--


text:
Ciao GM,
You wrote on 12/05/2011 :
> perché quella sovrastruttura e non una exception per gestire l'insuccesso e
> il corrispondente errore?
+1
.m
--
Mauro Servienti
{C67C0157-5D98-4733-A75E-93CAEE4BADC8}
Microsoft MVP - Visual C# / MCTS
http://mvp.support.microsoft.com/profile/mauro
blog @
http://milestone.topics.it
whynot [ at ] topics [ dot ] it


text:
Ciao Giulio Petrucci,

faccio quello che va controcorrente, a prima vista anche io direi che
passa verso l'alto un codice di errore (io preferirei una exception, ma
ci sono casi in cui va bene come lo stai approcciando, se vuoi ne
parliamo.) ma in questo modo hai un problema di fondo, finchè non
arrivi al presentation layer hai in mano solo un codice di errore e
quindi se vuoi loggare qualcosa devi convertirlo da codice_errore a
stringa_umanamente_leggibile (magari localizzata) quindi operazione
doppia.
Io dal canto mio farei viaggiare verso l'alto entrambe le cose, quindi
sia il codice di errore che il messaggio già bello formattato e
locallizato (ed eventualmente anche i parametri per riformattarlo e
localizzarlo in un'altra lingua se è uno scenario sensato).
> Grazie,
> Giulio



text:
Ciao Mauro,
On 5/13/2011 9:46 AM, Mauro Servienti [MVP] wrote:
> faccio quello che va controcorrente, a prima vista anche io direi che
> passa verso l'alto un codice di errore (io preferirei una exception, ma
> ci sono casi in cui va bene come lo stai approcciando, se vuoi ne
> parliamo.)
Ok, parliamone. :-)
Scherzi a parte, anche se "in differita" magari con il vostro bagaglio
di esperienze potete darmi qualche buona imbeccata.
> ma in questo modo hai un problema di fondo, finchè non arrivi
> al presentation layer hai in mano solo un codice di errore e quindi se
> vuoi loggare qualcosa devi convertirlo da codice_errore a
> stringa_umanamente_leggibile (magari localizzata) quindi operazione doppia.
No, aspetta... internamente al service layer, prima di mandare fuori il
risultato del metodo, *tutto* viene loggato in formato umanamente
leggibile e in lingua "neutra".
> Io dal canto mio farei viaggiare verso l'alto entrambe le cose, quindi
> sia il codice di errore che il messaggio già bello formattato e
> locallizato (ed eventualmente anche i parametri per riformattarlo e
> localizzarlo in un'altra lingua se è uno scenario sensato).
Interessante. :-)
Provo a sviluppare un altro po' la discussione. Confesso di fare fatica
a capire come indicare in maniera chiara e sopratutto senza duplicare
logica sparpagliata un po' qua e un po' là tutte queste cose qui.
L'esempio postato da GM è molto didattico: "Il semaforo numero 25 è
rosso". Ora, mentre 25 è sempre quello :-) la parola "rosso" può
diventare "red", "rouge", "rojo", "vermelho". Quindi in portoghese il
mio messaggio dovrebbe essere generato dal format: "O semàforo {0} està
vermelho {1}" richiamato con 25 e "vernelho". Il mio oggetto ritornato
dovrebbe contenere:
1. Codice di errore
2. chiave del format
3. lista di parametry che possono essere stringhe da inserire
direttamente o chiavi di altre risorse
Potete linkarmi a qualche esempio di codice che realizzi qualcosa del
genere?
Grazie,
Giulio
--


author: emidio

text:
Essendo io uno dei "colleghi" mi intrometto nella discussione e
rispondo al perché su quella struttura. Quella struttura ha il fine di
uniformare le risposte dei servizi in modo da avere disponibile, oltre
al risultato dell'operazione, anche la motivazione del risultato. In
questo modo abbiamo la possibilità di gestire allo stesso modo errori
dovuti ad eventuali eccezioni, o errori dovuti a logiche applicative
che non permettono l'esecuzione dell'operazione richiesta...
La mia proposta era questa
    public class ActionResult<T>
    {
        public ResultCodes ResultCode;
        public T Result;
        public string Description;
    }
che ha, oltre al codice di errore definito dall'enum ResultCodes,
anche un'eventuale descrizione dell'errore.


text:
Il 13/05/2011 13.58, Giulio Petrucci ha scritto:
...
>
> L'esempio postato da GM è molto didattico: "Il semaforo numero 25 è
> rosso". Ora, mentre 25 è sempre quello :-) la parola "rosso" può
> diventare "red", "rouge", "rojo", "vermelho". Quindi in portoghese il
> mio messaggio dovrebbe essere generato dal format: "O semàforo {0} està
> vermelho {1}" richiamato con 25 e "vernelho". Il mio oggetto ritornato
> dovrebbe contenere:
>
> 1. Codice di errore
> 2. chiave del format
> 3. lista di parametry che possono essere stringhe da inserire
> direttamente o chiavi di altre risorse
>
Come ti dicevo, io feci la cosa in C++ nativo, quindi qui è un po diverso...
in dot net tutto dovrebbe essere semplificato dalla IFormattable,
CultureInfo e ResourceManager.
Se non sbaglio la String.Format è in grado di accettare un array di
parametri che se sono di tipo IFormattable vengono gestiti in un certo
modo. Io proverei a vedere se è possibile agganciarsi qui e
eventualmente implementare un tipo ResString che implementa
IFormattable, incapsula un ID e va a pescare la stringa dalle risorse
giuste. Non mi stupirei se questa cosa esistesse già...


text:
"Giulio Petrucci" <sis...@nonono.boh> wrote in message
news:4dccdc07$0$38643$4faf...@reader1.news.tin.it...
> On 5/13/2011 2:02 AM, LudovicoVan wrote:
>
>> Ti dico la mia: delegherei al presentation layer in modo da passare in
>> giro un codice piuttosto che una stringa; per semplicita', tornerei
>> direttamente il resourcekey/ResourceID che punta al messaggio di errore
>> nelle risorse localizzate.
>
> Ok, grazie della dritta, credo di aver capito l'antifona. :-)
> Tuttavia volevo "armonizzare" questo suggerimento con quello di GM.
> Supponiamo che sia nel caso di dover avere un messaggio "parametrico",
> quindi nel file di risorse avrò un format per un messaggio di errore. In
> generale al PL dovranno essere passati:
> 1. un id per il format dell'errore
> 2. una lista di parametri che possono essere:
> 2.1 valori veri e propri
> 2.2 id di valori da prendere dalle risorse
Piuttosto che tornare un oggetto "Result", solleverei una eccezione in caso
di "errore". Nello scenario che andate delineando, probabilmente userei due
tipi eccezioni derivate dalla stessa classe base, per distinguere fra
eccezioni di sistema e violazioni di business rules. Tali eccezioni custom
dovrebbero incapsulare, oltre ai dettagli della eventuale eccezione
sottostante (e quindi della eventuale cascata di inner exceptions), tutte le
info aggiuntive necessarie, ad esempio, alla localizzazione.
Il logging sono d'accordo che non e' un problema: si logga in lingua neutra,
quindi in Inglese, e si loggano le info dettagliate della eccezione (e delle
eventuali inner exceptions) e del contesto in cui si e' verificata. Al
presentation layer ripeto che farei arrivare solo "codici": e' compito del
PL tradurre tali indicazioni in messaggi (localizzati) per l'utente.
Su questo ultimo punto, cioe' su cosa effettivamente tornare al PL, a mio
avviso non esiste una regola fissa, occorre considerare i requisiti e il
solito ammonimento a non sovra-ingegnerizzare. Comunque, mi piace l'idea che
le stringhe localizzate siano piuttosto dei format: eviterei pero' cose come
da tuo punto 2.2, cioe' mi limiterei alla logica base format piu' array di
oggetti valore, in modo da avere bassa complessita' anche al costo di
qualche duplicazione nei testi da dover inserire (anche l'archivio risorse
va gestito e non deve essere necessario essere dei super-esperti per farlo).
Resterebbe da decidere se nelle exception vanno direttamente l'id della
risorsa e l'array di parametri, oppure se vale la pena fare un qualcosa di
leggermente piu' strutturato/disaccoppiato e avere, per esempio, una
gerarchia di eccezioni piu' fine (contro codici di errore) in cui sono
definite proprieta' rilevanti alla eccezione specifica (contro l'array di
parametri), e poi avere un po' di logica al livello di PL che mappa
l'eccezione e le sue proprieta' appunto e di nuovo all'id del format e
all'array di parametri.
Comunque stiamo spaccando il capello: nel quotidiano non approccio lo
sviluppo cosi' prevalentemente a tavolino. Quando devo implementare una
funzionalita', tendo a partire  da soluzioni elementari e non
particolarmente stutturate, che poi sottopongo a cicli di ristrutturazione e
raffinamento dettati piu' che altro dall'evolversi del sistema. In
particolare, e' solo analisi che mi piace fare il piu' possibile up-front,
mentre design e codice li affronto in modo il piu' possibile incrementale...



text:
Ciao emidio,

ok, tutto chiaro, gaurda la risposta che ho dato a Giulio che include
anche un ragionamento su questo.



text:
Ciao Giulio Petrucci,
You wrote on 13/05/2011 :
> Ciao Mauro,
>
> On 5/13/2011 9:46 AM, Mauro Servienti [MVP] wrote:
>> faccio quello che va controcorrente, a prima vista anche io direi che
>> passa verso l'alto un codice di errore (io preferirei una exception, ma
>> ci sono casi in cui va bene come lo stai approcciando, se vuoi ne
>> parliamo.)
>
> Ok, parliamone. :-)
> Scherzi a parte, anche se "in differita" magari con il vostro bagaglio di
> esperienze potete darmi qualche buona imbeccata.
>
il problema di passare verso l'alto un codice di errore e non una
exception è che se l'utilizzatore ignora (banalmente perchè si
dimentica) il codice di errore buonanotte al secchio :-)
Ora, io parto dal presupposto che una gracefull-death sia concessa solo
solo allo strato di presentazione, in ogni altro strato *deve* sbombare
se c'è qualcosa che non va perchè significa che qualcuno che sta prima
non ha fatto bene il suo lavoro. Quindi ad esempio la validazione a
livello di presentation prevede i messaggi di errore che informano
l'utente in maniera gentile ma se una strato di servizi quando
_ri_esegue la validazione trova un errore io ritengo sia sacrosanta una
exception, è meglio che muoia tutto piuttosto che avere uno stato
inconsistente dei dati perchè qualcuno nel mezzo si è scordato una
validazione o semplicemente di controllare un codice di errore.
Una buona via di mezzo potrebbe essere questa:
class OperationResult<T>
{
   T _unsafeResult;
   public OperationResult( T result, Exception error )
   {
       //bla bla...
   }
   public Exception Fault{ get; private set; }
   public Boolean IsFault{ get{ return this.Exception != null; } }
   public T Result
   {
      get
      {
         if( this.IsFault )
         {
            throw this.Exception;
         }
         return this._unsafeResult;
      }
   }
}
che è il modello tipicamente usato dalle operazioni asincrone o dai
servizi Wcf proprio quando invocati in maniera asincrona. Che difetto
ha? fondamentalmente uno solo, a naso, che se viene scatenata
l'eccezione, lo stak trace riporta come sorgente dell'eccezione la
proprietà "Result" e non l'effettiva location in cui è stata generata.
questa cosa si aggira tipicamente innestando l'exception originale come
inner exception di quella scatenata da Result.
>> ma in questo modo hai un problema di fondo, finchè non arrivi
>> al presentation layer hai in mano solo un codice di errore e quindi se
>> vuoi loggare qualcosa devi convertirlo da codice_errore a
>> stringa_umanamente_leggibile (magari localizzata) quindi operazione doppia.
>
> No, aspetta... internamente al service layer, prima di mandare fuori il
> risultato del metodo, *tutto* viene loggato in formato umanamente leggibile e
> in lingua "neutra".
ok, ottimo.
>> Io dal canto mio farei viaggiare verso l'alto entrambe le cose, quindi
>> sia il codice di errore che il messaggio già bello formattato e
>> locallizato (ed eventualmente anche i parametri per riformattarlo e
>> localizzarlo in un'altra lingua se è uno scenario sensato).
>
> Interessante. :-)
>
> Provo a sviluppare un altro po' la discussione. Confesso di fare fatica a
> capire come indicare in maniera chiara e sopratutto senza duplicare logica
> sparpagliata un po' qua e un po' là tutte queste cose qui.
> L'esempio postato da GM è molto didattico: "Il semaforo numero 25 è rosso".
> Ora, mentre 25 è sempre quello :-) la parola "rosso" può diventare "red",
> "rouge", "rojo", "vermelho". Quindi in portoghese il mio messaggio dovrebbe
> essere generato dal format: "O semàforo {0} està vermelho {1}" richiamato con
> 25 e "vernelho". Il mio oggetto ritornato dovrebbe contenere:
>
> 1. Codice di errore
> 2. chiave del format
> 3. lista di parametry che possono essere stringhe da inserire direttamente o
> chiavi di altre risorse
>
> Potete linkarmi a qualche esempio di codice che realizzi qualcosa del genere?
secondo me non hai bisogno di sparpagliare logica, parti sempre
dall'error code (un valore numerico o un'enumerazione) passi
quell'error code a qualcuno tipo un
IFaultProvider.Format( Int32 errorCode, CultureInfo culture,
Func<String, String> formatterCallback  );
quindi puoi scrivere una cosa del tipo:
var msg = formatter.Format( errorCode, new CultureInfo( "en-US" ), s=>
String.Format( s, v1, v2 ) );
dove v1 e v2 sono valori "locali" a dove si è verificato il problema,
naturalmente devi sapere up-front che la stringa localizzata è
"formattabile".



text:
Ciao LV,
On 5/14/2011 3:11 PM, LudovicoVan wrote:
> Piuttosto che tornare un oggetto "Result", solleverei una eccezione in
> caso di "errore". Nello scenario che andate delineando, probabilmente
> userei due tipi eccezioni derivate dalla stessa classe base, per
> distinguere fra eccezioni di sistema e violazioni di business rules.
> Tali eccezioni custom dovrebbero incapsulare, oltre ai dettagli della
> eventuale eccezione sottostante (e quindi della eventuale cascata di
> inner exceptions), tutte le info aggiuntive necessarie, ad esempio, alla
> localizzazione.
Capito.
Quindi (ad esempio) avrei una cosa tipo:
class MyBusinessException : Exception
{
	String MessageFormatId { get; }
	MessageFormatParam[] Params { get; }
}
class MessageFormatParam
{
	bool IsResourceKey { get; }  //se TRUE cerca nelle risorse con la
chiave contenuta in .Value
	object Value { get; }
}
E' questo che intendi?
> mi limiterei alla logica base
> format piu' array di oggetti valore,
In che modo?
> Resterebbe da decidere se nelle exception vanno direttamente l'id della
> risorsa e l'array di parametri, oppure se vale la pena fare un qualcosa
> di leggermente piu' strutturato/disaccoppiato e avere, per esempio, una
> gerarchia di eccezioni piu' fine (contro codici di errore) in cui sono
> definite proprieta' rilevanti alla eccezione specifica (contro l'array
> di parametri), e poi avere un po' di logica al livello di PL che mappa
> l'eccezione e le sue proprieta' appunto e di nuovo all'id del format e
> all'array di parametri.
La storia delle eccezioni specializzate mi "spaventa" un po'. Non si
rischia di cadere nel caso della sovraingegnerizzazione di ui parlavi prima?
Ciao,
Giulio
--


text:
Ciao Mauro,
On 5/16/2011 9:31 AM, Mauro Servienti [MVP] wrote:
> il problema di passare verso l'alto un codice di errore e non una
> exception è che se l'utilizzatore ignora (banalmente perchè si
> dimentica) il codice di errore buonanotte al secchio :-)
Inoppugnabile. :-)
> Ora, io parto dal presupposto che una gracefull-death sia concessa solo
> solo allo strato di presentazione, in ogni altro strato *deve* sbombare
> se c'è qualcosa che non va perchè significa che qualcuno che sta prima
> non ha fatto bene il suo lavoro. Quindi ad esempio la validazione a
> livello di presentation prevede i messaggi di errore che informano
> l'utente in maniera gentile ma se una strato di servizi quando
> _ri_esegue la validazione trova un errore io ritengo sia sacrosanta una
> exception, è meglio che muoia tutto piuttosto che avere uno stato
> inconsistente dei dati perchè qualcuno nel mezzo si è scordato una
> validazione o semplicemente di controllare un codice di errore.
Ok, credo di aver capito. :-)
Ora, ci sarebbe da aprire un branch nella discussione: perché eseguire
*due* validazioni? Ma ti/vi risparmio... :-)
> Una buona via di mezzo potrebbe essere questa:
[cut]
> che è il modello tipicamente usato dalle operazioni asincrone o dai
> servizi Wcf proprio quando invocati in maniera asincrona. Che difetto
> ha? fondamentalmente uno solo, a naso, che se viene scatenata
> l'eccezione, lo stak trace riporta come sorgente dell'eccezione la
> proprietà "Result" e non l'effettiva location in cui è stata generata.
> questa cosa si aggira tipicamente innestando l'exception originale come
> inner exception di quella scatenata da Result.
Capito.
Anche se - mi pare - che non sia una buona cosa innestare le inner
exception e farle propagare fino al PL, sbaglio?
> secondo me non hai bisogno di sparpagliare logica, parti sempre
> dall'error code (un valore numerico o un'enumerazione) passi quell'error
> code a qualcuno tipo un
>
> IFaultProvider.Format( Int32 errorCode, CultureInfo culture,
> Func<String, String> formatterCallback );
>
> quindi puoi scrivere una cosa del tipo:
>
> var msg = formatter.Format( errorCode, new CultureInfo( "en-US" ), s=>
> String.Format( s, v1, v2 ) );
>
> dove v1 e v2 sono valori "locali" a dove si è verificato il problema,
> naturalmente devi sapere up-front che la stringa localizzata è
> "formattabile".
Vediamo se ho capito:
1. inietto IFaultProvider nel presentation layer
2. nell'eccezione sollevata/oggett di ritorno ci metto il codice di
errore e la stringa lambda expression per la formattazione (la
cultura... non lo so, ha senso che il SL sappia in che lingua stiamo
lavorando?)
Corretto?
Grazie,
Giulio
--


text:
Ciao Giulio,
You wrote on 16/05/2011 :
>> Ora, io parto dal presupposto che una gracefull-death sia concessa solo
>> solo allo strato di presentazione, in ogni altro strato *deve* sbombare
>> se c'è qualcosa che non va perchè significa che qualcuno che sta prima
>> non ha fatto bene il suo lavoro. Quindi ad esempio la validazione a
>> livello di presentation prevede i messaggi di errore che informano
>> l'utente in maniera gentile ma se una strato di servizi quando
>> _ri_esegue la validazione trova un errore io ritengo sia sacrosanta una
>> exception, è meglio che muoia tutto piuttosto che avere uno stato
>> inconsistente dei dati perchè qualcuno nel mezzo si è scordato una
>> validazione o semplicemente di controllare un codice di errore.
>
> Ok, credo di aver capito. :-)
> Ora, ci sarebbe da aprire un branch nella discussione: perché eseguire *due*
> validazioni? Ma ti/vi risparmio... :-)
io ho questo assioma: ogni volta che la chiamata supera un boundary
(services-boundary) quindi esce dal processo corrente per essere
gestita da un altro (ad esempio un servizio WCF) parto dal presupposto
che non ho nessuna garanzia che sia solo ed esclusivamente la mia app a
chiamare quel boundary ergo non mi fido di nulla e di nessuno e se
fallisce qualcosa -> exception
>> Una buona via di mezzo potrebbe essere questa:
> [cut]
>> che è il modello tipicamente usato dalle operazioni asincrone o dai
>> servizi Wcf proprio quando invocati in maniera asincrona. Che difetto
>> ha? fondamentalmente uno solo, a naso, che se viene scatenata
>> l'eccezione, lo stak trace riporta come sorgente dell'eccezione la
>> proprietà "Result" e non l'effettiva location in cui è stata generata.
>> questa cosa si aggira tipicamente innestando l'exception originale come
>> inner exception di quella scatenata da Result.
>
> Capito.
> Anche se - mi pare - che non sia una buona cosa innestare le inner exception
> e farle propagare fino al PL, sbaglio?
"dipende": innestare le exception ti può esporre a dei rischi di
security perchè riveli verso l'alto dettagli interni.
>> secondo me non hai bisogno di sparpagliare logica, parti sempre
>> dall'error code (un valore numerico o un'enumerazione) passi quell'error
>> code a qualcuno tipo un
>>
>> IFaultProvider.Format( Int32 errorCode, CultureInfo culture,
>> Func<String, String> formatterCallback );
>>
>> quindi puoi scrivere una cosa del tipo:
>>
>> var msg = formatter.Format( errorCode, new CultureInfo( "en-US" ), s=>
>> String.Format( s, v1, v2 ) );
>>
>> dove v1 e v2 sono valori "locali" a dove si è verificato il problema,
>> naturalmente devi sapere up-front che la stringa localizzata è
>> "formattabile".
>
> Vediamo se ho capito:
> 1. inietto IFaultProvider nel presentation layer
> 2. nell'eccezione sollevata/oggett di ritorno ci metto il codice di errore e
> la stringa lambda expression per la formattazione (la cultura... non lo so,
> ha senso che il SL sappia in che lingua stiamo lavorando?)
dipende da voi, in molti casi, se ad esempio il service layer deve fare
ragionamenti/filtri sulla base della culture.
> Corretto?
si, direi che il concetto di fondo è giusto.



text:
On Monday, 16 May 2011 15:56:10 UTC+1, Giulio Petrucci  wrote:
> > mi limiterei alla logica base
> > format piu' array di oggetti valore,
>
> In che modo?
Come ti dicevo, non implementerei cosa come da tuo punto 2.2, terrei la struttura flat. Qualcosa di questo genere quindi:
class MyBusinessException : Exception
{
    ...
    String MessageFormatId { get; }
    Object[] MessageParams { get; }
}
> > Resterebbe da decidere se nelle exception vanno direttamente [...]
>
> La storia delle eccezioni specializzate mi "spaventa" un po'. Non si
> rischia di cadere nel caso della sovraingegnerizzazione di ui parlavi prima?
Usare eccezioni in questo caso e' semplicemente the way to go in .Net, con una serie di ricadute architetturali cui altri hanno gia' accennato: per non dire che, ad occhio, e' quasi sicuro che di codice ne scrivete semmai di meno.
Il rischio di sovra-ingegnerizzazione stava altrove: << eviterei pero' cose come da tuo punto 2.2 >> e le altre considerazioni sul design minuzioso up-front. E' sufficiente una decente padronanza della tecnologia in uso con i suoi idiomi di base per non uscire dai binari. Evito ulteriori digressioni sui vantaggi di un approccio incrementale nelle fasi cosiddette tecniche (design, coding, testing).
-LV


text:
On Monday, 16 May 2011 18:00:59 UTC+1, Mauro Servienti [ MVP ]  wrote:
> "dipende": innestare le exception ti può esporre a dei rischi di
> security perchè riveli verso l'alto dettagli interni.
Sei esposto a rischi *se* riveli verso l'esterno dettagli interni: non fa una piega che _le eccezioni non devono uscire dai boundaries_, ma cio' non comporta nessun problema intrinseco alle inner exception e che queste vadano ignorate/droppate.
-LV


text:
Ciao LudovicoVan,

ovvio, è quello che ci scrivi il problema non le InnerException in sè.
> -LV



text:
Ciao Mauro,
On 5/16/2011 7:00 PM, Mauro Servienti [MVP] wrote:
> io ho questo assioma: ogni volta che la chiamata supera un boundary
> (services-boundary) quindi esce dal processo corrente per essere gestita
> da un altro (ad esempio un servizio WCF) parto dal presupposto che non
> ho nessuna garanzia che sia solo ed esclusivamente la mia app a chiamare
> quel boundary ergo non mi fido di nulla e di nessuno e se fallisce
> qualcosa -> exception
Uhm... assioma interessante. :-)
E' una buona controparte dell'altro che dice: "a meno che non abbia
venduto al cliente qualcosa che debba poter essere "consumato" da
qualche altro servizio e il cliente lo fa e distrugge tutto, è un
problema suo." <eg>
> "dipende": innestare le exception ti può esporre a dei rischi di
> security perchè riveli verso l'alto dettagli interni.
Ok.
> dipende da voi, in molti casi, se ad esempio il service layer deve fare
> ragionamenti/filtri sulla base della culture.
Giusto.
Ciao e grazie,
Giulio
--


text:
Ciao LV,
On 5/16/2011 9:25 PM, LudovicoVan wrote:
> Come ti dicevo, non implementerei cosa come da
> tuo punto 2.2, terrei la struttura flat. Qualcosa di
> questo genere quindi:
>
> class MyBusinessException : Exception
> {
>      ...
>
>      String MessageFormatId { get; }
>      Object[] MessageParams { get; }
>
> }
Ok, riprendendo l'esempio fatto da GM: "Il semaforo 25 è rosso" che in
portoghese mi diventa "O semáforo número 25 está vermelho"; 25 è
universale mentre il colore dovrebbe essere passato come chiave di una
particolare risorsa. Ovviamente con un object semplice non me la cavo... :-)
Comunque a parte questo, mi sembra tutto chiaro.
Grazie per i suggerimenti,
Giulio
--


text:
Ciao Mauro,
On 5/16/2011 9:31 AM, Mauro Servienti [MVP] wrote:
  [cut]
Alla luce di quanto è seguito nel thread, mi permetto di aggiungere una
domanda. E se il servizio in questione fosse (ad esempio) un servizio WCF?
Ciao,
Giulio
--


text:
On Tuesday, 17 May 2011 10:22:32 UTC+1, Giulio Petrucci  wrote:
> On 5/16/2011 7:00 PM, Mauro Servienti [MVP] wrote:
>
> > "dipende": innestare le exception ti può esporre a dei rischi di
> > security perchè riveli verso l'alto dettagli interni.
>
> Ok.
Come gia' detto, non e' OK: quella affermazione semplicemente non e' corretta.
-LV


text:
On Tuesday, 17 May 2011 05:13:38 UTC+1, Mauro Servienti [ MVP ]  wrote:
> You wrote on 16/05/2011 :
> > On Monday, 16 May 2011 18:00:59 UTC+1, Mauro Servienti [ MVP ]  wrote:
> >
> >> "dipende": innestare le exception ti può esporre a dei rischi di
> >> security perchè riveli verso l'alto dettagli interni.
> >
> > Sei esposto a rischi *se* riveli verso l'esterno dettagli interni: non fa una
> > piega che _le eccezioni non devono uscire dai boundaries_, ma cio' non
> > comporta nessun problema intrinseco alle inner exception e che queste vadano
> > ignorate/droppate.
>
> ovvio, è quello che ci scrivi il problema non le InnerException in sè.
Menzionare le inner exception in questo caso e' proprio fuorviante: sono le *exception*, senza ulteriori qualificazioni, che non devono attraversare i bounday inter-componente (e il tuo codice per OperationResult<T>
andrebbe spiegato meglio che e' da intendersi intra-bounday).
-LV


text:
On Tuesday, 17 May 2011 11:55:51 UTC+1, Giulio Petrucci  wrote:
> Ok, riprendendo l'esempio fatto da GM: "Il semaforo 25 è rosso" che in
> portoghese mi diventa "O semáforo número 25 está vermelho"; 25 è
> universale mentre il colore dovrebbe essere passato come chiave di una
> particolare risorsa. Ovviamente con un object semplice non me la cavo...
Basterebbe passare un oggetto Color: la mappatura dovrebbe essere comunque compito del PL.
> Comunque a parte questo, mi sembra tutto chiaro.
Benissimo.
-LV


text:
Ciao LV,
On 5/17/2011 2:52 PM, LudovicoVan wrote:
> Come gia' detto, non e' OK: quella affermazione semplicemente non e' corretta.
Cambiando discorso: sono solo io che continuo a vedere le tue risposte
non ordinate nel thread? Gli altri?
Ciao,
Giulio
--


text:
Il 17/05/2011 12.55, Giulio Petrucci ha scritto:
> Ciao LV,
>
> On 5/16/2011 9:25 PM, LudovicoVan wrote:
>> Come ti dicevo, non implementerei cosa come da
>> tuo punto 2.2, terrei la struttura flat. Qualcosa di
>> questo genere quindi:
>>
>> class MyBusinessException : Exception
>> {
>> ...
>>
>> String MessageFormatId { get; }
>> Object[] MessageParams { get; }
>>
>> }
>
> Ok, riprendendo l'esempio fatto da GM: "Il semaforo 25 è rosso" che in
> portoghese mi diventa "O semáforo número 25 está vermelho"; 25 è
> universale mentre il colore dovrebbe essere passato come chiave di una
> particolare risorsa. Ovviamente con un object semplice non me la cavo...
> :-)
Non ne sarei sicurissimo... Te la butto li:
class ResString : IFormattable
{
     public ResString(string stringID, System.Resources.ResourceManager
rm, params Object[] args)
     {
         this.StringId = stringID;
         this.rm = rm;
         this.args = args;
     }
     public string ToString(string format, IFormatProvider formatProvider)
     {
         if(format == null)
             format = rm.GetString(StringId, formatProvider as
System.Globalization.CultureInfo);
         return string.Format(formatProvider, format, args);
     }
     private string StringId;
     private System.Resources.ResourceManager rm;
     private Object[] args;
}
class Program
{
     static void Main(string[] args)
     {
         ResString col = new ResString("colorRed",
Resource1.ResourceManager);
         ResString Msg = new ResString("msg", Resource1.ResourceManager,
25, col);
         System.Globalization.CultureInfo ci = new
System.Globalization.CultureInfo("en");
         Console.WriteLine(Msg);
         Console.WriteLine(Msg.ToString(null, ci));
         Console.WriteLine(Msg.ToString("sem:{0} color:{1}", null));
         Console.WriteLine(Msg.ToString("sem:{0} color:{1}", ci));
     }
}


text:
Ciao LV,
Mi pare che quanto scrivi qui:
On 5/17/2011 2:54 PM, LudovicoVan wrote:
> Menzionare le inner exception in questo caso e' proprio fuorviante:
> sono le *exception*, senza ulteriori qualificazioni, che non devono
> attraversare i bounday inter-componente (e il tuo codice per
> OperationResult<T> andrebbe spiegato meglio che e' da intendersi
> intra-bounday).
Cercando di recuperare quello che scrivi altrove:
> Usare eccezioni in questo caso e' semplicemente the way to go
La domanda iniziale è: come fa il service layer a notificare al
presentation layer che qualcosa è andato storto? Se possiamo considerare
la comunicazione SL-PL come "intra-boundary", allora non dovrebbero
viaggiare eccezioni.
Diciamo che sono confuso, via. :-)



text:
Ciao GM,
On 5/17/2011 3:30 PM, GM wrote:
> Non ne sarei sicurissimo... Te la butto li:
[cut]
Grazie mille dell'esempio: un po' di codice scritto è sempre
esplicativo! :-)
Rettifico però il problema: più che sul *cosa* fare, mi sento in
difficoltà sul *come* farlo. Andando al codice:
interface IFooService {
	XXX DoSomethingWithMyFoo(String fooId);
}
questo servizio è consumato da un Controller. Con riferimento
all'esempio da te postato,
1. cosa dovrei metterci in XXX?
2. chi si occupa di generare le ResString, con conoscenza della cultura
corrente, ecc ecc...?
ciao e grazie mille,
Giulio
--


text:

ResString è il tuo messaggio. Incapsula l'id della stringa e l'elenco
degli argomenti di formattazione. Alcuni di questi argomenti potrebbero
essere a loro volta dei ResString il che ti permette di creare
bellissimi giochini ricorsivi tipo:
"Il messaggio delle ore {0} era: {1}"
che costruisci passando due argomenti: un DateTime e un ResString che
contiene la celeberrima :"Il semaforo numero {0} è {1}" che a sua volta
costruisci passando 25 e un ulteriore ResString che incapsula l'id della
stringa "rosso"
ResString col = new ResString("colorRed", Resource1.ResourceManager);
ResString Msg2 = new ResString("msg2", Resource1.ResourceManager, 25, col);
ResString Msg = new ResString("msg1", Resource1.ResourceManager,
System.DateTime.Now, Msg2);
Supponiamo che nelle risorse ci siano le stringhe:
colorRed	rosso
msg1	il messaggio delle ore {0:t} era "{1}"
msg2	il semaforo {0} è {1}
e in inglese:
colorRed	red
msg1	"{1}" was the {0:t} message
msg2	the semaphore number {0} is {1}
Chi riceve un ResString può formattarlo e eventualmente passare una
cultura con cui vorrebbe vedere il messaggio. Sfruttando il meccanismo
di fallback del resourcemanager il messaggio viene formattato e la
stessa ResString iniziale diventa:
il messaggio delle ore 17.43 era "il semaforo 25 è rosso"
oppure supponendo di passare alla ToString la cultura en
"the semaphore number 25 is red" was the 5:43 PM message
HTH


text:
On Tuesday, 17 May 2011 14:38:33 UTC+1, Giulio Petrucci  wrote:
> La domanda iniziale è: come fa il service layer a notificare al
> presentation layer che qualcosa è andato storto?
La risposta base resta: sollevando eccezioni.
> Se possiamo considerare
> la comunicazione SL-PL come "intra-boundary", allora non dovrebbero
> viaggiare eccezioni.
Al contrario, e' se la comunicazione e' *inter*-componente che eccezioni dettagliate non dovrebbero propagarsi. -- Inter-componente significa fra componenti diversi, intra-componente (o intra-boundary) significa all'interno di un singolo componente.
> Diciamo che sono confuso, via. :-)
Parte della confusione forse nasce dal fatto che, ad esempio, il boundary SL-PL puo' essere sia inter- che intra-: dipende dai casi e dalle specifiche esigenze di sicurezza.
Un'altra possibile fonte di confusione e' che, anche nel caso la comunicazione in questione e' inter-componente (ovvero anche nel caso ci sia necessita' di evitare propagazione di dettagli), si possono comunque propagare eccezioni. L'accorgimento sta nel non propagare le eccezioni originali, cioe' quelle interne e dettagliate, bensi' sul boundary intercettarle e rilanciare eccezioni specifiche per l'esterno, con i dati strettamente necessari.
Nota che ho detto "si possono", non "si devono": di varianti sulle implementazioni specifiche ce ne sono piu' o meno a volonta.
HTH,
-LV
P.S. Ovviamente sto postando da Google Groups...


text:
On Tuesday, 17 May 2011 16:48:25 UTC+1, GM  wrote:
> ResString è il tuo messaggio. Incapsula l'id della stringa e l'elenco
> degli argomenti di formattazione. Alcuni di questi argomenti potrebbero
> essere a loro volta dei ResString il che ti permette di creare
> bellissimi giochini ricorsivi tipo: <snip>
L'idea e' "bella" e persino semplice da realizzare: glielo spieghi poi tu pero' al copy-writer di turno, il quale probabilmente partira' dai testi in Inglese per tradurre in un'altra lingua, come funziona quel "bellissimo giochino ricorsivo"... In realta', non dico che sia necessariamente da evitare, pero' desideravo segnalare che certi impatti non vanno sottovalutati: se fossi responsabile del progetto e il progetto stesso fosse non banale (cioe' con decine e decine di messaggi diversi), semplicemente non avallerei una scelta del genere.
Anyway, my 2c.
-LV


text:
Ciao LV,
On 5/17/2011 9:48 PM, LudovicoVan wrote:
> Al contrario, e' se la comunicazione e' *inter*-componente che
> eccezioni dettagliate non dovrebbero propagarsi. -- Inter-componente
> significa fra componenti diversi, intra-componente (o intra-boundary)
> significa all'interno di un singolo componente.
Ok, ci siamo.
> Nota che ho detto "si possono", non "si devono": di varianti sulle
> implementazioni specifiche ce ne sono piu' o meno a volonta.
Sai linkarmi a qualche documento/guideline/bestpractice?
Grazie e buona giornata,
Giulio
--


text:
Ciao GM,
On 5/17/2011 5:48 PM, GM wrote:
[cut]
> Chi riceve un ResString può formattarlo e eventualmente passare una
> cultura con cui vorrebbe vedere il messaggio
Ecco, il punto sta proprio sul *chi*. :-)
Se al PL arrivano le ResString, significa che la conoscenza delle
risorse sta sia nel PL che nel Service Layer. Come approccio non è che
mi faccia impazzire perchè significa duplicare le cose. Oppure ho
proprio sbagliato a capire?



author: Julio P. Di Egidio

text:
"Giulio Petrucci"  wrote in message
news:4dd4c38e$0$18245$4faf...@reader2.news.tin.it...
> Sai linkarmi a qualche documento/guideline/bestpractice?
La tua discussione che abbiamo avuto e' piuttosto ampia quindi non saprei...
Prova a guardare questi due link per alcune guidelines:
http://msdn.microsoft.com/en-us/library/5b2yeyab.aspx
http://msdn.microsoft.com/en-us/library/ms229014.aspx
Potresti anche a fare qualche ricerca sul Web.



title: DataGridView

text:
E ora una domanda banale e meno filosofica del solito ...
Nel controllo DataGridView, c'è un modo per disabilitare
l'ordinamento automatico delle righe, quando si fa click
sulle intestazioni di colonna ?
grazie
Soviet


title: DataGridView

author: Raffaele Rialdi [MVP]

text:

winform, wpf o
asp.net
?
--
Raffaele Rialdi
http://www.iamraf.net
Weblog:
http://blogs.ugidotnet.org/raffaele
Microsoft MVP profile
https://mvp.support.microsoft.com/profile/raffaele
UGIdotNET -
http://www.ugidotnet.org/


title: DataGridView

text:
Il 23/01/2011 20:04, Raffaele Rialdi [MVP] ha scritto:
> Soviet_Mario wrote:
>> E ora una domanda banale e meno filosofica del solito ...
>> Nel controllo DataGridView, c'è un modo per disabilitare l'ordinamento
>> automatico delle righe, quando si fa click sulle intestazioni di
>> colonna ?
>> grazie
>> Soviet
intanto grazie ... hai risposto a ciascuno dei dubbi che ti
ho postato ! Mica niente insomma
>
> winform, wpf o
asp.net
?
uhm bella domanda. Non so. Uso il VB.net per fare eseguibili
standalone, diciamo, e ho un form di un progetto gui per
windows su cui ho piazzato dei controlli, tra cui un
DataGridView.
Per assonanza direi la prima quindi, ma non so, e non so se
ho dato elementi per dirlo.
E' un controllo monumentale, e credo sovradimensionato per
la mia esigenza di mostrare solo una tabella righe e colonne
senza neanche input, ma non sapevo che altro controllo usare
(anni fa usavo MsFlexGrid, o Grid, ma non so se esistano
ancora, cercavo di usare solo i mattoni standard della
tavolozza, e niente vecchi OCX neppure se compatibili)
Sorry se non sono stato chiaro manco stavolta
ciao
Soviet
>


title: DataGridView

text:
Soviet_Mario wrote:
>> winform, wpf o
asp.net
?
>
> uhm bella domanda. Non so. Uso il VB.net per fare eseguibili standalone,
> diciamo, e ho un form di un progetto gui per windows su cui ho piazzato dei
> controlli, tra cui un DataGridView.
> Per assonanza direi la prima quindi, ma non so, e non so se ho dato elementi
> per dirlo.
> E' un controllo monumentale, e credo sovradimensionato per la mia esigenza di
> mostrare solo una tabella righe e colonne senza neanche input, ma non sapevo
> che altro controllo usare (anni fa usavo MsFlexGrid, o Grid, ma non so se
> esistano ancora, cercavo di usare solo i mattoni standard della tavolozza, e
> niente vecchi OCX neppure se compatibili)
> Sorry se non sono stato chiaro manco stavolta
> ciao
> Soviet
Senza sapere su che tecnologia è basato il tuo progetto, è
letteralmente impossibile rispondere. Il linguaggio è insignificante
per capirlo.
"progetto gui per windows" esclude
asp.net
 ma è ancora troppo poco.
Guarda le classi base delle finestre/form e dal namespace dovresti
capire di cosa stiamo parlando.



title: DataGridView

author: Andrea [Work]

text:
Il Sun, 23 Jan 2011 18:34:43 +0100, Soviet_Mario ha scritto:
> Nel controllo DataGridView, c'� un modo per disabilitare
> l'ordinamento automatico delle righe, quando si fa click
> sulle intestazioni di colonna ?
Parlando di una datagridview "estesa" ho implementato questo metodo:
|             Public Sub SetAllColumnsSortMode(ByVal sortMode As DataGridViewColumnSortMode)
|                 For Each col As DataGridViewColumn In Me.Columns
|                     col.SortMode = sortMode
|                 Next
|             End Sub
Ti basta prendere il ciclo interno e impostare a
DataGridViewColumnSortMode.Programmatic


title: DataGridView

text:
Il 24/01/2011 11:50, Andrea [Work] ha scritto:
> Il Sun, 23 Jan 2011 18:34:43 +0100, Soviet_Mario ha scritto:
>
>> Nel controllo DataGridView, c'è un modo per disabilitare
>> l'ordinamento automatico delle righe, quando si fa click
>> sulle intestazioni di colonna ?
>
> Parlando di una datagridview "estesa" ho implementato questo metodo:
>
> |             Public Sub SetAllColumnsSortMode(ByVal sortMode As DataGridViewColumnSortMode)
> |                 For Each col As DataGridViewColumn In Me.Columns
> |                     col.SortMode = sortMode
Ohh là ! Bene ... scorrendo la lista di proprietà e metodi
di decine di pagine tooltip, questo SortMode mi era proprio
sfuggito.
GRAzie spero che funga.
> |                 Next
> |             End Sub
>
> Ti basta prendere il ciclo interno e impostare a
> DataGridViewColumnSortMode.Programmatic
che vorrrebbe dire : lascia che ci pensi io, vero ? Ossia,
se non faccio niente, non fare niente di default ?
Cmq provo
grazie
ciao
CCCP


title: [SEMI OT] Curiosità tariffe

author: gianluca gravina

text:
Ciao a tutti,
Scusate per la domanda un po' OT ...
Una curiosit� in merito alle tariffe applicabili per la realizzazione di
un sito.
Non � per me, ma mi � stato chiesto da un amico una stima di massima
(molto di massima visto che i requisiti non sono molto chiari) per la
realizzazione di un sito con relativa parte db.
Ora a prescindere dal linguaggio, dall'hosting, dal db utilizzato,
insomma per fare una cosa pi� RAD possibile, quali potrebbero essere le
tariffe giornaliere per un lavoro di questo tipo ?
Riassumo la domanda, una volta fatta la stima, quanto chiedereste al giorno?
Grazie mille,
Gianluca