title: clonare un oggetto

author: Andrea Saltarello

text:
Il 10/12/2010 16:51, Virtual ha scritto:
> grazie,
>
> mi chiedevo se semplicemente avendo un oggetto_1 con dei dati, creando
> una istanza dello stesso tipo oggetto_2 potevo clonarlo con un solo
> comando.
no, non puoi farlo. La tecnica più vicina a quanto hai detto consiste
nell'usare il BinaryFormatter per fare un dump dell'oggetto dentro un
MemoryStream, e poi usare ancora il formatter per ottenere il "clone" a
partire dallo stream. Ma è lento (vedi msg di Raf) ed insicuro (non
tutto lo stato dell'oggetto potrebbe essere clonabile: dipende dalla sua
implementazione)
--
.A
GUISA -
http://www.guisa.org
UGIdotNET -
http://www.ugidotnet.org
Read my blog at:
http://blogs.ugidotnet.org/pape


title: clonare un oggetto

author: Raffaele Rialdi [MVP]

text:
Virtual wrote:
> grazie,
>
> mi chiedevo se semplicemente avendo un oggetto_1 con dei dati, creando una
> istanza dello stesso tipo oggetto_2 potevo clonarlo con un solo comando.
> con una istruzione di tipo:
>
> objtype oggetto_2 = new  objtype();
> clone(oggetto_2, oggetto_1);
Oltre a quanto già detto da Andrea, cerca di farti un esempio in mente.
Che succede se uno dei membri della classe è un dataset. Il clone deve
fare una copia completa di tutto il dataset che ci sta dietro (deep
copy) oppure copiare solo il *reference* (shallow copy).
La decisione è enorme perché il grafo (dataset e altre classi in
gerarchia) che ci stanno dietro potrebbero essere anche da gigabyte.
Tutto ciò che è reference type implica questa decisione, stringhe
comprese che però sono "speciali" in quanto immutabili, di conseguenza
deep o shallow fa poca differenza sul risultato (non sulla memoria
occupata ovviamente).



title: clonare un oggetto

author: Virtual

text:
si potrebbero ad esempio definire degli attributi per i membri come si fa
quando si vuole passare un oggetto ad una Propertygrid.. clonabile o non
clonabile...
--
"Raffaele Rialdi [MVP]" <
malta@n0spam_vevy.com
> ha scritto nel messaggio
news:mn.54397dac7...@n0spamvevy.com...



title: clonare un oggetto

text:
Virtual wrote:
> si potrebbero ad esempio definire degli attributi per i membri come si fa
> quando si vuole passare un oggetto ad una Propertygrid.. clonabile o non
> clonabile...
Certo, e infatti questo è l'approccio dei serilizzatori binario e xml
che permettono di stabilire la "forma" della serializzazione
semplicemente decorando i membri della classe con attributi.
Peccato che tutto questo implichi l'uso di reflection e quindi
abissalmente più lenta rispetto ad una soluzione ad-hoc che però pesa
sul developer.
La soluzione per scrivere meno codice e avere le max performance può
stare nel generare delle classi di clonazione in modo automatico, per
esempio utilizzando i template T4 di visual studio. Ovviamente il modo
in cui creare questi template è tutta da inventare (ma è anche il bello
del nostro lavoro)



title: clonare un oggetto

text:
grazie
--
"Raffaele Rialdi [MVP]" <
malta@n0spam_vevy.com
> ha scritto nel messaggio
news:mn.5caf7dacc...@n0spamvevy.com...



title: clonare un oggetto

author: GM

text:
Il 10/12/2010 16.51, Virtual ha scritto:
> grazie,
>
> mi chiedevo se semplicemente avendo un oggetto_1 con dei dati, creando
> una istanza dello stesso tipo oggetto_2 potevo clonarlo con un solo
> comando.
> con una istruzione di tipo:
>
> objtype oggetto_2 = new objtype();
> clone(oggetto_2, oggetto_1);
>
>
Suppongo che tu stia lavorando in c#...
...perché se lavorassi in c++ sapresti dell'esistenza dei costruttori di
copia e/o operatori di assegnamento...
In c++ in tanti casi il costruttore di copia ce l'hai gratis, ma nulla
vieta di fartelo a manina anche in c#:
http://msdn.microsoft.com/en-us/library/ms173116(VS.80).aspx
Il vero svantaggio è che devi poi ricordarti di tenerlo "aggiornato"
quando aggiungi eventuali campi...


title: clonare un oggetto

author: LudovicoVan

text:
On Dec 10, 3:51 pm, "Virtual" <
m...@tin.it
> wrote:
> grazie,
>
> mi chiedevo se semplicemente avendo un oggetto_1 con dei dati, creando una
> istanza dello stesso tipo oggetto_2 potevo clonarlo con un solo comando.
> con una istruzione di tipo:
>
> objtype oggetto_2 = new  objtype();
> clone(oggetto_2, oggetto_1);
Per una shallow copy esiste Object.MemberwiseClone:
<
http://msdn.microsoft.com/en-us/library/
system.object.memberwiseclone.aspx>
Nei Remarks trovi alcune considerazioni su come implementare una deep
copy.
-LV


title: clonare un oggetto

text:
si, in effetti è la soluzione migliore,
grazie
"GM" <
G...@no.spam.it
> ha scritto nel messaggio
news:4d07b2d1$0$34301$4faf...@reader3.news.tin.it...



title: clonare un oggetto

text:
On Dec 16, 1:37 pm, "Virtual" <
m...@tin.it
> wrote:
> "GM" <
G...@no.spam.it
> ha scritto nel messaggionews:4d07b2d1$0$34301$4faf...@reader3.news.tin.it...
>
> > ...perch se lavorassi in c++ sapresti ...
>
> si, in effetti la soluzione migliore,
Passare a C++?
:P
-LV


title: [.NET] Directory.GetFiles da errore su cartelle apple/Mac

author: Andrea [Work]

text:
Salve a tutti,
devo scansionare delle cartelle su un NAS/Server che � apple.
Ci sono dei file .Ds_Store e roba simile (ma questi non danno problemi)

Su qualche cartella, se uso Directory.GetFiles ottengo l'errore che il nome
del file non pu� essere vuoto o soli spazi.

Se copio la cartella in locale nel pc windows non ci sono problemi, se
questa cartella la ricopio in un nuovo percorso sul server, ci sono
nuovamente problemi.
Alcune cartelle invece non hanno problemi. Ad occhio (anche da mac) non si
vede nulla di strano.

Ho usato senza successo:
 Directory.GetFileSystemEntries
 My.Computer.FileSystem.GetFiles
 Directory.GetFiles

 Dim di As New DirectoryInfo(TextBox1.Text)
 For Each fi As FileInfo In di.GetFiles()

E anche una funzione ricorsiva che si blocca non appena accede a quelle
cartelle.

Avete qualche consiglio?
Grazie


title: Disconnessione lenta socket

author: Stefano

text:
Ciao,
nella mia applicazione scritta in C# 4.0, ho notato che la
disconnessione dal socket ï¿œ piuttosto lenta (anche minuti)
Ovvero il tempo che intercorre tra:

m_socket.Shutdown(SocketShutdown.Both);
                m_socket.BeginDisconnect(true, new
AsyncCallback(m_OnDisconnectCallback), m_socket);

e l'eventi di callback m_OnDisconnectCallback ï¿œ particolarmente alto.
A cosa potrebbe essere dovuto?
Ciao. Stefano.


title: Disconnessione lenta socket

author: Julio Di Egidio

text:
"Stefano" <
ormaioc...@tin.it
> wrote in message
news:koq639$vej$1...@speranza.aioe.org...

E' "by design":

<
https://en.wikipedia.org/wiki/Berkeley_sockets#Terminating_sockets
>

Julio


title: Disconnessione lenta socket

text:
Julio Di Egidio scriveva il 06/06/2013 :

>
> E' "by design":
>
> <
https://en.wikipedia.org/wiki/Berkeley_sockets#Terminating_sockets
>
>
> Julio

Grazie, letto, interessante.
Nel mio caso ho visto che il rallentamento era dovuto alla serie di
chiamate nell'evento callback di ricezione nella classe asincrona che
ho creato.
Il metodo shutdown - opportunamente configurato - chiude il socket dopo
aver "smaltito" tutti i messaggi in invio/ricezione, quindi richiama
immediatamente il metodo asincrono di ricezione.
Nel mio caso, per mala progettazione, entrava in loop e quindi in
timeout.
Ho evitato il loop effettuando un test sullo stato della connessione e
comportandomi di conseguenza.
Grazie, ciao. Stefano.


title: Disconnessione lenta socket

text:
"Stefano" <
ormaioc...@tin.it
> wrote in message
news:koqfao$rb9$1...@speranza.aioe.org...
> Julio Di Egidio scriveva il 06/06/2013 :
>
>> E' "by design":
>> <
https://en.wikipedia.org/wiki/Berkeley_sockets#Terminating_sockets
>
>
> Grazie, letto, interessante.
> Nel mio caso ho visto che il rallentamento era dovuto alla serie di
> chiamate nell'evento callback di ricezione nella classe asincrona che ho
> creato.

Ho risposto alla tua domanda iniziale, dove parlavi di tempo intercorso fra
la BeginCallback e l'invocazione della callback stessa.  Ma lieto che hai
risolto.  I socket sono un argomento interessante, e a volte un bel
grattacapo.

Julio


title: Menù a scomparsa applicazione desktop

author: Emanuele Vecchi

text:
Salve a tutti, sto sviluppando un'allpicazione desktop e vorrei fare
un menù particolare ma non so che direzione prendere.
Il menù in questione vorrei farlo apparire come un'icona in alto sullo
schermo (con una semplice scritta tipo "Espandi menù" ed un'icona) che
al relativo clic faccia apparire, tramite scroll verso il basso,
l'intero menù dell'appicazione e, tramite una nuova pressione
dell'icona principale del menù, quest'ultimo tori a "nascondersi" alla
posizione originale.
Ho preparato anche 2 immagini per spiegare meglio la mia idea, se
necessario le posso postare.
Grazie dell'aiuto


title: [WCF] WCF o no? (Dummy inside)

author: Giulio Petrucci

text:
Ciao a tutti,
vi espongo brevemente il mio scenario (che fa comunque il paio con
quello che ho esposto nel thread "Gestione delle transazioni".
Ho un dominio [1] che rappresenta una rubrica telefonica comune a
diverse applicazioni:
- un client X (WPF o Web) di posta elettronica che si basa sulla rubrica
dato che i contatti sono dotati anche di indirizzo e-mail
- un client Y Web che permette di editare la rubrica
- un demone Z windows (o comunque qualcosa che "giri sempre") che compie
dei task periodici sulola ribrica (es: vede quanti contatti festeggiano
oggi il compleanno e manda a tutti un SMS di auguri, oppure una mail di
auguri in prossimità del Natale, ecc ecc...)
Attualmente le stesse librerie che implementano il Dal, il business
layer, ecc ecc... sono oggetto di *tre* diversi deployment. A occhio mi
verrebbe da dire che una significativa miglioria potrebbe essere quella
di installare una specie di "backoffice" comune che giri magari in un
servizio WCF con cui il client di posta e il client web dialogano e che
"ospita" il demone.
Ora iniziano le domande:
1. secondo voi è un approccio fattibile?
2. se fattibile, è valido?
3. Attualmente le applicazioni X e Y hanno un presentation layer che
dialoga con un service layer tramite Dto. Quindi avrò una cosa tipo:
class ContactDto { ... }
interface IContactService
{
     ContactDto GetById(object id);
}
class FooDto { ... }
IFooService
{
	FooDto GetByLabel(string label);
}
interface IGreetingsMessageService
{
	string GetBirthdayMessage(object contactId);
}
i vari servizi vengono iniettati in un container Unity al bootstrap
delle applicazioni, in ogni presentation layer (Controller, ViewModel,
ecc ecc...) vengono iniettati i servizi che servono. Posso replicare la
stessa cosa in un hosting WCF? Cioè, posso avere IContactService,
IFooService, IGreetingService in un unico punto e "risolverli" (in uno
scenario DI + IoC)?
4. come posso verificare che sia solo l'applicazione X ad accedere al
dato metodo del dato servizio? E' possibile poi implementare una
autenticazione a più livelli (del tipo: l'app X può accedere al metodo
blablabla ma solo se l'utente loggato in X è un admin)?
Grazie in anticipo,
Giulio
[1] ovviamente si tratta di un esempio. :-)
--


title: [WCF] WCF o no? (Dummy inside)

text:
On Mar 1, 11:38 am, Giulio Petrucci <sis...@nonono.boh> wrote:
> Ciao a tutti,
>
> vi espongo brevemente il mio scenario (che fa comunque il paio con
> quello che ho esposto nel thread "Gestione delle transazioni".
Sarebbe stato opportuno continuare li', visto che qui stai dando i
dettagli di quel problema...
> Ho un dominio [1] che rappresenta una rubrica telefonica comune a
> diverse applicazioni:
> - un client X (WPF o Web) di posta elettronica che si basa sulla rubrica
> dato che i contatti sono dotati anche di indirizzo e-mail
> - un client Y Web che permette di editare la rubrica
> - un demone Z windows (o comunque qualcosa che "giri sempre") che compie
> dei task periodici sulola ribrica (es: vede quanti contatti festeggiano
> oggi il compleanno e manda a tutti un SMS di auguri, oppure una mail di
> auguri in prossimità del Natale, ecc ecc...)
>
> Attualmente le stesse librerie che implementano il Dal, il business
> layer, ecc ecc... sono oggetto di *tre* diversi deployment. A occhio mi
> verrebbe da dire che una significativa miglioria potrebbe essere quella
> di installare una specie di "backoffice" comune che giri magari in un
> servizio WCF con cui il client di posta e il client web dialogano e che
> "ospita" il demone.
>
> Ora iniziano le domande:
> 1. secondo voi è un approccio fattibile?
Tutto si puo' fare.
> 2. se fattibile, è valido?
Se per valido intendi efficace, direi proprio di no.
Implementerei tutta la logica, operativa ma anche di servizio
(autenticazione, logging, ecc.) in un unico applicativo (e'
semplicemente una "Rubrica") esposto da WCF: cioe', in un gergo che
puo' esserti piu' familiare, due soli layer principali, model e
application. Dopodiche' qualunque client ti occorra sviluppare avra'
una logica super-leggera di pura presentazione.
Considerazione a margine per i piani alti: invece di organizzare tutti
quei corsi su pattern e framework e salti mortali per andare su
Nettuno passando da Andromeda, sarebbe il caso di concentrarsi sul
"keep it simple", che e' davvero lo skill piu' importante nonche' il
piu' sottovalutato.
My 2c anyway,
-LV



title: [WCF] WCF o no? (Dummy inside)

text:
Ciao Ludovico,
On 3/1/2011 1:47 PM, LudovicoVan wrote:
> Sarebbe stato opportuno continuare li', visto che qui stai dando i
> dettagli di quel problema...
No. Il cambio di thread è stato ragionato: qui si sta parlando di altro
(i.e. architettura). :-)
>> 2. se fattibile, è valido?
>
> Se per valido intendi efficace, direi proprio di no.
>
> Implementerei tutta la logica, operativa ma anche di servizio
> (autenticazione, logging, ecc.) in un unico applicativo (e'
> semplicemente una "Rubrica") esposto da WCF: cioe', in un gergo che
> puo' esserti piu' familiare, due soli layer principali, model e
> application. Dopodiche' qualunque client ti occorra sviluppare avra'
> una logica super-leggera di pura presentazione.
Ecco... e questo era *esattamente* quello che volevo fare io e di cui
chiedevo la fattibilità. :-)
> Considerazione a margine per i piani alti:
"piani alti"? O_o
> invece di organizzare tutti
> quei corsi su pattern e framework e salti mortali per andare su
> Nettuno passando da Andromeda, sarebbe il caso di concentrarsi sul
> "keep it simple", che e' davvero lo skill piu' importante nonche' il
> piu' sottovalutato.
In che senso? Nella mia (limitata) esperienza, una ampia conoscenza di
"pattern e framework e salti mortali" mi aiuta a centrare sempre la
soluzione più semplice. Se fossi stato più skillato, magari non avrei
usato le tre applicazioni diverse in prima istanza. :-)
Tornando a bomba sul mio problema: credo che ora il problema più grande
sia l'autenticazione "a due livelli"... pensi/ate che sia possibile
senza troppi spargimenti di sangue? ;-)
Ciao,
Giulio
--


title: [WCF] WCF o no? (Dummy inside)

text:
On Mar 1, 1:52 pm, Giulio Petrucci <sis...@nonono.boh> wrote:
> On 3/1/2011 1:47 PM, LudovicoVan wrote:
>
> > Sarebbe stato opportuno continuare li', visto che qui stai dando i
> > dettagli di quel problema...
>
> No. Il cambio di thread è stato ragionato: qui si sta parlando di altro
> (i.e. architettura). :-)
Cambiando architettura come da questo thread, ti si semplifica
drasticamente anche il problema delle transazioni, che diventa interno
all'unico strato di servizio. Comunque OK sul cambio di thread, con il
"senno di prima" penso tu abbia ragione.
> > Implementerei tutta la logica, operativa ma anche di servizio
> > (autenticazione, logging, ecc.) in un unico applicativo (e'
> > semplicemente una "Rubrica") esposto da WCF: cioe', in un gergo che
> > puo' esserti piu' familiare, due soli layer principali, model e
> > application. Dopodiche' qualunque client ti occorra sviluppare avra'
> > una logica super-leggera di pura presentazione.
>
> Ecco... e questo era *esattamente* quello che volevo fare io e di cui
> chiedevo la fattibilità. :-)
Non e' uguale: il windows service (o comunque il processo schedulato)
che manda le email a scadenza ecc. ecc. lo intendevo fra i vari
*client*. Sotto WCF ci metterei davvero *solo* il "model" e i servizi
*base*, tipo appunto l'autenticazione/autorizzazione, e null'altro.
> > Considerazione a margine per i piani alti:
>
> "piani alti"? O_o
>
> > invece di organizzare tutti
> > quei corsi su pattern e framework e salti mortali per andare su
> > Nettuno passando da Andromeda, sarebbe il caso di concentrarsi sul
> > "keep it simple", che e' davvero lo skill piu' importante nonche' il
> > piu' sottovalutato.
>
> In che senso? Nella mia (limitata) esperienza, una ampia conoscenza di
> "pattern e framework e salti mortali" mi aiuta a centrare sempre la
> soluzione più semplice.
Si', ma solo a partire dal quindicesimo anno di pratica... :)
> Se fossi stato più skillato, magari non avrei
> usato le tre applicazioni diverse in prima istanza. :-)
Appunto...!
> Tornando a bomba sul mio problema: credo che ora il problema più grande
> sia l'autenticazione "a due livelli"... pensi/ate che sia possibile
> senza troppi spargimenti di sangue? ;-)
Intendi a due ruoli? Guarda l'autenticazione/autorizzazione in WCF,
sono sicuro che si tratta ancora di uno scenario abbastanza base,
soprattutto dopo una semplificazione architetturale come sopra.
-LV


title: [WCF] WCF o no? (Dummy inside)

text:
Ciao Ludovico,
On 3/1/2011 9:55 PM, LudovicoVan wrote:
> Cambiando architettura come da questo thread, ti si semplifica
> drasticamente anche il problema delle transazioni, che diventa interno
> all'unico strato di servizio.
Esatto. :-)
> Non e' uguale: il windows service (o comunque il processo schedulato)
> che manda le email a scadenza ecc. ecc. lo intendevo fra i vari
> *client*. Sotto WCF ci metterei davvero *solo* il "model" e i servizi
> *base*, tipo appunto l'autenticazione/autorizzazione, e null'altro.
Capisco: anche io ero partito da una idea simile, poi però parlando con
i colleghi abbiamo elaborato l'altra soluzione. Il problema di fondo è
che il servizio che manda le e-mail ecc ecc... (che nel mio caso reale
fa qualcosa di molto più complesso, ovviamente :-)) ha bisogno di avere
conoscenza "in tempo reale" di quello che fanno le altre applicazioni
che parlano con il servizio WCF.
> Intendi a due ruoli?
No, intendo proprio due livelli di autenticazione.
Se l'utente è Admin dell'applicazione X può fare A e B, altrimenti solo
B. Se invece è Admin dell'applicazione Y può fare A, D, E, altrimenti
non può fare nulla.
Ciao,
Giulio
--


title: [WCF] WCF o no? (Dummy inside)

text:
On Mar 2, 9:45 am, Giulio Petrucci <sis...@nonono.boh> wrote:
> On 3/1/2011 9:55 PM, LudovicoVan wrote:
>
> > Cambiando architettura come da questo thread, ti si semplifica
> > drasticamente anche il problema delle transazioni, che diventa interno
> > all'unico strato di servizio.
>
> Esatto. :-)
Grazie! :P
> > Non e' uguale: il windows service (o comunque il processo schedulato)
> > che manda le email a scadenza ecc. ecc. lo intendevo fra i vari
> > *client*. Sotto WCF ci metterei davvero *solo* il "model" e i servizi
> > *base*, tipo appunto l'autenticazione/autorizzazione, e null'altro.
>
> Capisco: anche io ero partito da una idea simile, poi però parlando con
> i colleghi abbiamo elaborato l'altra soluzione. Il problema di fondo è
> che il servizio che manda le e-mail ecc ecc... (che nel mio caso reale
> fa qualcosa di molto più complesso, ovviamente :-)) ha bisogno di avere
> conoscenza "in tempo reale" di quello che fanno le altre applicazioni
> che parlano con il servizio WCF.
That smells anyway: il client dovrebbe comunque interrogare il core,
ed e' quest'ultimo che "sa in tempo reale", cioe' che mantiene lo
stato del work-flow nonche' gestisce sincronizzazione, concorrenza e
quant'altro.
Naturalmente non mi e' possibile essere meno generico senza una
conoscenza precisa dei requisiti in gioco, ma l'idea base spero che
sia chiara: si tratta di districare un po' meglio l'allocazione delle
responsabilita', lasciando nei client le sole funzioni di interfaccia
utente oppure di schedulazione di task.
> > Intendi a due ruoli?
>
> No, intendo proprio due livelli di autenticazione.
> Se l'utente è Admin dell'applicazione X può fare A e B, altrimenti solo
> B. Se invece è Admin dell'applicazione Y può fare A, D, E, altrimenti
> non può fare nulla.
Si puo' comunque riformulare in termini di un solo bacino utenti con
differenti ruoli: ovvero, di nuovo, si tratta di mettere al centro il
core/model, dopodiche' diventa tutto molto piu' lineare e standard.
-LV


title: [WCF] WCF o no? (Dummy inside)

text:
Ciao LV,
On 3/2/2011 12:16 PM, LudovicoVan wrote:
> That smells anyway: il client dovrebbe comunque interrogare il core,
> ed e' quest'ultimo che "sa in tempo reale", cioe' che mantiene lo
> stato del work-flow nonche' gestisce sincronizzazione, concorrenza e
> quant'altro.
>
> Naturalmente non mi e' possibile essere meno generico senza una
> conoscenza precisa dei requisiti in gioco, ma l'idea base spero che
> sia chiara: si tratta di districare un po' meglio l'allocazione delle
> responsabilita', lasciando nei client le sole funzioni di interfaccia
> utente oppure di schedulazione di task.
Ok, cerco di darti qualche dettaglio in più. :-)
I client in-quanto-tali hanno le sole funzioni di UI e fin qui non ci
sono problemi. Comunicano con il core tramite dei data contract che
altro non sono che dei grossi Dto che "planarizzano" ampie porzioni del
domain model. Concentriamoci sul "demone" che gira "a tempo
indeterminato". Astraendo all'inverosimile, la logica che dovrebbe
implementare è questa: ogni tot minuti controlla sul db quali sono i
prossimi contatti da raggiungere, li mette in ordine di priorità e li
contatta N per volta (con N >= 1). L'algoritmo che calcola la priorità
può essere molto complesso e necessità di conoscere una ampia parte del
dominio (di sicuro pià ampia di quella che necessità di conoscere il
demone). Stop. :-)
Il problema è che nella realtà il "contatto" non è necessariamente via
e-mail o SMS ma può prevedere un sistema molto complesso (gateway CCXML,
chiamate in outbound basate su VoiceXML che parlano tra loro mediante
CGI, bla bla bla...), quindi di fatto il mio "demone" non ha più il
controllo di quello che succede se non quando qualche altro attore
"bussa alla porta" e dice: "ok, io con il contatto X ho finito, lo puoi
lasciare". Questo perché solitamente i "canali" che la piattaforma
"fisica" mette a disposizione per le chiamate sono limitati, quindi
occorre gestirli in maniera oculata.
Dunque, in questo scenario, cosa dovrebbe stare "fuori" dai limiti del
servizio WCF? Ci sarebbe solo un demone che gira e
- dice al servizio WCF ogni tot: dammi il prossimo omino da chiamare;
dopodiché prende l'omino e lo chiama
- ogni tot chiede al servizio: "qualcuno ti ha avvisato che la chiamata
con l'omino X è finita?", e in caso affermativo torna al punto precedente.
Per questo (ti dicevo) non vedo l'utilità di avere tutto questo accrocco
"fuori" dai boundaries del servizio WCF.
> Si puo' comunque riformulare in termini di un solo bacino utenti con
> differenti ruoli
[cut]
Uhm... non mi è molto chiato (per ignoranza mia, sia chiaro). Puoi darmi
qualche dritta "introduttiva" (link, ecc ecc...)?
Grazie,
Giulio
--


title: [WCF] WCF o no? (Dummy inside)

text:
On Mar 2, 12:01 pm, Giulio Petrucci <sis...@nonono.boh> wrote:
> On 3/2/2011 12:16 PM, LudovicoVan wrote:
>
> > That smells anyway: il client dovrebbe comunque interrogare il core,
> > ed e' quest'ultimo che "sa in tempo reale", cioe' che mantiene lo
> > stato del work-flow nonche' gestisce sincronizzazione, concorrenza e
> > quant'altro.
>
> > Naturalmente non mi e' possibile essere meno generico senza una
> > conoscenza precisa dei requisiti in gioco, ma l'idea base spero che
> > sia chiara: si tratta di districare un po' meglio l'allocazione delle
> > responsabilita', lasciando nei client le sole funzioni di interfaccia
> > utente oppure di schedulazione di task.
>
> Ok, cerco di darti qualche dettaglio in più. :-)
Si', ma poi mi dai anche una percentule? ;))
> I client in-quanto-tali hanno le sole funzioni di UI e fin qui non ci
> sono problemi. Comunicano con il core tramite dei data contract che
> altro non sono che dei grossi Dto che "planarizzano" ampie porzioni del
> domain model. Concentriamoci sul "demone" che gira "a tempo
> indeterminato". Astraendo all'inverosimile, la logica che dovrebbe
> implementare è questa: ogni tot minuti controlla sul db quali sono i
> prossimi contatti da raggiungere, li mette in ordine di priorità e li
> contatta N per volta (con N >= 1). L'algoritmo che calcola la priorità
> può essere molto complesso e necessità di conoscere una ampia parte del
> dominio (di sicuro pià ampia di quella che necessità di conoscere il
> demone). Stop. :-)
La prioritizzazione allora dovrebbe essere responsabilita' appunto del
model: il "demone" si limita a chiedera una lista (gia' ordinata) dei
prossimi N contatti da processare e per quale via, e non ha bisogno di
sapere altro.
> Il problema è che nella realtà il "contatto" non è necessariamente via
> e-mail o SMS ma può prevedere un sistema molto complesso (gateway CCXML,
> chiamate in outbound basate su VoiceXML che parlano tra loro mediante
> CGI, bla bla bla...), quindi di fatto il mio "demone" non ha più il
> controllo di quello che succede se non quando qualche altro attore
> "bussa alla porta" e dice: "ok, io con il contatto X ho finito, lo puoi
> lasciare". Questo perché solitamente i "canali" che la piattaforma
> "fisica" mette a disposizione per le chiamate sono limitati, quindi
> occorre gestirli in maniera oculata.
Il demone quindi a sua volta delega ad ulteriori processori esterni
per l'effettivo contatto, a seconda del canale. I processori esterni
ritornano al demone stesso l'informazione che il contatto e' stato
processato. Il demone sa quindi quali contatti sono in fase di
processamento, quali sono stati processati (con successo o
fallimento), e infine sa quando tutti i contatti sono stati finalmente
processati (di nuovo, con successo o fallimento che sia). A quel punto
e solo a quel punto (cioe' a lista di N contatti processata)
ricontatta il model informandolo che quella lista contatti e' stata
appunto processata, in modo il model abbia possibilita' di aggiornare
il suo stato cosi' che ad una sucessiva richiesta di N contatti
restituisce N nuovi contatti e non quelli gia' processati.
> Dunque, in questo scenario, cosa dovrebbe stare "fuori" dai limiti del
> servizio WCF? Ci sarebbe solo un demone che gira e
> - dice al servizio WCF ogni tot: dammi il prossimo omino da chiamare;
> dopodiché prende l'omino e lo chiama
> - ogni tot chiede al servizio: "qualcuno ti ha avvisato che la chiamata
> con l'omino X è finita?", e in caso affermativo torna al punto precedente.
> Per questo (ti dicevo) non vedo l'utilità di avere tutto questo accrocco
> "fuori" dai boundaries del servizio WCF.
Se butti giu' uno schema, per esempio di responsabilita' e
collaborazioni, vedrai che l'approccio che ti propongo e' estremamente
piu' semplice e lineare. -- Di nuovo, con i limiti di uno che ha una
visione parziale del problema.
> > Si puo' comunque riformulare in termini di un solo bacino utenti con
> > differenti ruoli
>
> [cut]
>
> Uhm... non mi è molto chiato (per ignoranza mia, sia chiaro). Puoi darmi
> qualche dritta "introduttiva" (link, ecc ecc...)?
Link davvero non saprei, ma si tratta semplicemente di avere un unico
archivio utenti (corrispondenti a utenti reali come nel caso delle UI,
oppure a processi come nel caso del demone). A tali utenti vanno
associati dei ruoli, ciascuno con le opportune autorizzazioni.
Insomma, ci sono alcune varianti al livello implementativo
(organizzazione flat piuttosto che gerarchica dei ruoli), ma al
livello concettuale il tutto e' assolutamente canonico.
-LV


title: [WCF] WCF o no? (Dummy inside)

text:
Ciao Ludovico,
On 3/2/2011 5:29 PM, LudovicoVan wrote:
> Si', ma poi mi dai anche una percentule? ;))
Uhm... va bene!
L'X% di 0 è... :-)
Scherzi a parte: a me viene davvero poco da questo progetto.
Se ti accontenti, quando ci vediamo dal vivo a qualche workshop/ecc
ecc... ti offro una birra. :-)
> La prioritizzazione allora dovrebbe essere responsabilita' appunto del
> model: il "demone" si limita a chiedera una lista (gia' ordinata) dei
> prossimi N contatti da processare e per quale via, e non ha bisogno di
> sapere altro.
Ok. Quindi il demone (fuori dai boundaries WCF) chiede al model (che
invece sta "dentro" ai boundaries) di passargli i prossimi N contatti.
> Il demone quindi a sua volta delega ad ulteriori processori esterni
> per l'effettivo contatto, a seconda del canale. I processori esterni
> ritornano al demone stesso l'informazione che il contatto e' stato
> processato.
Ok... *come*?
Se il demone sta "dentro" al servizio WCF il gioco sarebbe fatto... :-)
> Il demone sa quindi quali contatti sono in fase di
> processamento, quali sono stati processati (con successo o
> fallimento), e infine sa quando tutti i contatti sono stati finalmente
> processati (di nuovo, con successo o fallimento che sia). A quel punto
> e solo a quel punto (cioe' a lista di N contatti processata)
> ricontatta il model informandolo che quella lista contatti e' stata
> appunto processata, in modo il model abbia possibilita' di aggiornare
> il suo stato cosi' che ad una sucessiva richiesta di N contatti
> restituisce N nuovi contatti e non quelli gia' processati.
Uhm... questo complicherebbe ulteriormente le cose.
Comunque, nel mio caso reale, questo non servirebbe perché i processi
esterni avrebbero già modificato il db da cui legge il model.
> Link davvero non saprei, ma si tratta semplicemente di avere un unico
> archivio utenti (corrispondenti a utenti reali come nel caso delle UI,
> oppure a processi come nel caso del demone).
Ah, ok... non so come si mappa un utente su un processo ma credo che
Google possa essere My Friend in questo caso. :-) Per il discorso delle
UI, onestamente, faccio pià fatica a "concepire" quello che mi serve. Le
due applicazioni hanno utenti diversi, e possono poter fare le stesse
cose... va be', vedrò di inventarmi qualche porcata. :-D
Ciao e grazie,
Giulio
--


title: [WCF] WCF o no? (Dummy inside)

text:
On Mar 2, 6:05 pm, Giulio Petrucci <sis...@nonono.boh> wrote:
> On 3/2/2011 5:29 PM, LudovicoVan wrote:
>
> > Si', ma poi mi dai anche una percentule? ;))
>
> Uhm... va bene!
> L'X% di 0 è... :-)
> Scherzi a parte: a me viene davvero poco da questo progetto.
> Se ti accontenti, quando ci vediamo dal vivo a qualche workshop/ecc
> ecc... ti offro una birra. :-)
Ehi, guarda che assolutamente scherzavo...
> > La prioritizzazione allora dovrebbe essere responsabilita' appunto del
> > model: il "demone" si limita a chiedera una lista (gia' ordinata) dei
> > prossimi N contatti da processare e per quale via, e non ha bisogno di
> > sapere altro.
>
> Ok. Quindi il demone (fuori dai boundaries WCF) chiede al model (che
> invece sta "dentro" ai boundaries) di passargli i prossimi N contatti.
>
> > Il demone quindi a sua volta delega ad ulteriori processori esterni
> > per l'effettivo contatto, a seconda del canale. I processori esterni
> > ritornano al demone stesso l'informazione che il contatto e' stato
> > processato.
>
> Ok... *come*?
Che intendi per "come"?? Push o pull!!
> Se il demone sta "dentro" al servizio WCF il gioco sarebbe fatto... :-)
Da quel punto di vista, dentro o fuori non farebbe nessuna differenza.
> > Il demone sa quindi quali contatti sono in fase di
> > processamento, quali sono stati processati (con successo o
> > fallimento), e infine sa quando tutti i contatti sono stati finalmente
> > processati (di nuovo, con successo o fallimento che sia). A quel punto
> > e solo a quel punto (cioe' a lista di N contatti processata)
> > ricontatta il model informandolo che quella lista contatti e' stata
> > appunto processata, in modo il model abbia possibilita' di aggiornare
> > il suo stato cosi' che ad una sucessiva richiesta di N contatti
> > restituisce N nuovi contatti e non quelli gia' processati.
>
> Uhm... questo complicherebbe ulteriormente le cose.
> Comunque, nel mio caso reale, questo non servirebbe perché i processi
> esterni avrebbero già modificato il db da cui legge il model.
Il tuo caso reale e' semplicemente un'altra architettura... In quella
che ti ho illustrato io al database accede solo e solamente il model.
Ibridi fra il tuo e il mio approccio semmai di sicuro ti complicano
ulteriormente le cose.
> > Link davvero non saprei, ma si tratta semplicemente di avere un unico
> > archivio utenti (corrispondenti a utenti reali come nel caso delle UI,
> > oppure a processi come nel caso del demone).
>
> Ah, ok... non so come si mappa un utente su un processo ma credo che
> Google possa essere My Friend in questo caso. :-) Per il discorso delle
> UI, onestamente, faccio pià fatica a "concepire" quello che mi serve. Le
> due applicazioni hanno utenti diversi, e possono poter fare le stesse
> cose... va be', vedrò di inventarmi qualche porcata.
Ma quale google e google d'Egitto! :) Una tabella utenti, con
username, password e ruolo associato (e magari, se serve, specifica
degli IP o canali autorizzati per quell'utente o ruolo, ecc.):
dopodiche' il client di turno semplicemente passa le credenziali e
viene autenticato/autorizzato. Again, tutto molto canonico.
-LV


title: [WCF] WCF o no? (Dummy inside)

text:

P.S. Su quel punto, guardati semplicemente l'autenticazione/
autorizzazione sotto WCF.
-LV


title: [WCF] WCF o no? (Dummy inside)

text:
Ciao Ludovico,
On 3/2/2011 7:32 PM, LudovicoVan wrote:
> Ehi, guarda che assolutamente scherzavo...
Va be'... ma una birretta non si nega a nessuno. :-)
> Che intendi per "come"?? Push o pull!!
Si, questo lo sapevo. :-)
Io intendevo il "mezzo" di comunicazione...
> Da quel punto di vista, dentro o fuori non farebbe nessuna differenza.
Be'... a quel punto sarebbe tutto più "raccolto", no? Che senso ha avere
un demone che gira e che parla con un servizio WCF, e altri applicativi
che parlano con il demone (magari mediante un'altra interfaccia WCF). Mi
verrebbe da dire - dal basso della mia ignoranza - che tanto vale avere
tutto dentro un unico boundary. Sbaglio?
> Il tuo caso reale e' semplicemente un'altra architettura... In quella
> che ti ho illustrato io al database accede solo e solamente il model.
Infatti sto cercando di ricondurmi a questo caso (ma il db potrebbe
essere modificato anche da altri applicativi non di mia competenza).
Grazie,
Giulio
--


title: [WCF] WCF o no? (Dummy inside)

text:
On Mar 3, 9:57 am, Giulio Petrucci <sis...@nonono.boh> wrote:
> On 3/2/2011 7:32 PM, LudovicoVan wrote:
>
> > Ehi, guarda che assolutamente scherzavo...
>
> Va be'... ma una birretta non si nega a nessuno. :-)
>
> > Che intendi per "come"?? Push o pull!!
>
> Si, questo lo sapevo. :-)
> Io intendevo il "mezzo" di comunicazione...
>
> > Da quel punto di vista, dentro o fuori non farebbe nessuna differenza.
>
> Be'... a quel punto sarebbe tutto più "raccolto", no? Che senso ha avere
> un demone che gira e che parla con un servizio WCF, e altri applicativi
> che parlano con il demone (magari mediante un'altra interfaccia WCF). Mi
> verrebbe da dire - dal basso della mia ignoranza - che tanto vale avere
> tutto dentro un unico boundary. Sbaglio?
Ovviamente si'!! Primo, a quel modo si torna al mono-layer, secondo se
le vai a disegnare (disegnale!) tu hai dipendenze circolari all over
the place.
Insomma non mi far pentire di averti dedicato tempo ed energie con
risposte di quella superficialita'. Un grazie mi e' sufficiente, di
birra ne ho gia' abbastanza.
> > Il tuo caso reale e' semplicemente un'altra architettura... In quella
> > che ti ho illustrato io al database accede solo e solamente il model.
>
> Infatti sto cercando di ricondurmi a questo caso (ma il db potrebbe
> essere modificato anche da altri applicativi non di mia competenza).
Se' davvero cosi', o il database e' propriamente incapsulato e piu' di
meta' dei problemi che mi hai posto non esistevano proprio, oppure non
c'e' verso di fare qualcosa di pulito. Comunque almeno la tua porzione
la devi architettare a dovere, e poi succeda quel che succeda almeno
non e' responsabilita' tua.
E adesso dimmi un semplice grazie e torna a lavorare.
-LV


title: [WCF] WCF o no? (Dummy inside)

text:
Ciao Ludovico,
On 3/3/2011 12:59 PM, LudovicoVan wrote:
> Ovviamente si'!! Primo, a quel modo si torna al mono-layer, secondo se
> le vai a disegnare (disegnale!) tu hai dipendenze circolari all over
> the place.
Comincio a capire.
Cosa intenti però come "dipendenza circolare"?



title: [WCF] WCF o no? (Dummy inside)

text:
On Mar 3, 1:37 pm, Giulio Petrucci <sis...@nonono.boh> wrote:
> Comincio a capire.
Io avevo gia' capito, ma siamo in uno spazio pubblico.
> Cosa inten[d]i però come "dipendenza circolare"?
Nella sua forma base: se A, B e C sono tre componenti del sistema, hai
una dipendenza circolare quando A->B, B->C e C->A, dove la freccia sta
per "dipende da".
Le dipendenze circolari, facilmente individuabili disegnando appunto
un grafo delle dipendenze, sono assolutamente da evitare sia al
livello concettuale che implementativo perche' rendono impossibile il
disaccoppiamento dei componenti e provocano effetti collaterali a
cascata (tutte le logiche si complicano esponenzialmente, e nei casi
peggiori hai il proverbiale effetto: correggo da una parte e mi si
rompe dall'altra), tanto che le tecniche di inversion of control sono
state pensate proprio a mitigare/risolvere tali circolarita', fermo
restando pero' che una buona impostazione di base evita i problemi a
monte e l'IoC come altri pattern dovrebbe essere applicato ai soli
casi limite dove altrimenti la circolarita' sarebbe proprio
inevitabile.
HTH,
-LV


title: [WCF] WCF o no? (Dummy inside)

text:
Ciao LudovicoVan,
On 3/3/2011 3:48 PM, LudovicoVan wrote:
> Io avevo gia' capito, ma siamo in uno spazio pubblico.
Già.



title: [WCF] WCF o no? (Dummy inside)

text:

Un semplice grazie non in firma era sufficiente.
-LV


title: Modificare visualizzazione

author: ferradini

text:
Senza volerlo, probabilmente per qualche involontaria pressione di qualche
combinazione di yasyi, ho attivato una visualizzazione degli spazi di
tabulazione.
ad esempio public void
viene visto come ....... public void
non sono punti allineati in basso ma al centro della riga.
Non riesco a eliminarne la visualizzazione. Qualche consiglio? Grazie
ferradini


title: Modificare visualizzazione

text:
"ferradini" <
liv...@interfree.it
> ha scritto nel messaggio
news:idcues$i9v$1...@tdi.cu.mi.it...

Dimenticavo l'ambiente è Vs 2010


title: Modificare visualizzazione

text:

Prova con Ctlr R W  (view whitespace)
--
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: VB net - Structured Enums

text:
Avete idea se qualche workaround consenta di emularle, o cmq
conoscete qualche tecnica per implementarne ?

Per structured enums intendo una gerarchia di costanti
accessibili con una sintassi abbastanza simile a quella di
una serie di namespaces nidificati, però maggiormente type
safe (e presumo anche più efficienti).

ciao e grazie
Soviet_Mario


title: VB net - Structured Enums

author: Mauro Servienti [MVP]

text:
Ciao Soviet_Mario,

You wrote on 18/11/2011 :
> Avete idea se qualche workaround consenta di emularle, o cmq conoscete
> qualche tecnica per implementarne ?

classi statiche (shared in vb) che espogono proprietà readonly di tipo
enum, potrebbero andare bene?

in c# sarebbe una del tipo:

static class Foo
{
   static class Bar
   {
       public static readonly MyEnumType Value = MyEnumType.Value;
   }
}

se ho capito bene cosa intendi

.m

--
blog @ //
milestone.topics.it


title: VB net - Structured Enums

text:
Il 19/11/2011 08:03, Mauro Servienti [MVP] ha scritto:
> Ciao Soviet_Mario,
>
> You wrote on 18/11/2011 :
>> Avete idea se qualche workaround consenta di emularle, o cmq conoscete
>> qualche tecnica per implementarne ?
>
> classi statiche (shared in vb) che espogono proprietà readonly di tipo
> enum, potrebbero andare bene?

non so ancora rispondere ... provo la soluzione che
gentilmente mi hai proposto. Se mi funge, ti ringrazio in
anticipo. Se no (a parte che ringrazio ugualmente) magari fo
un salto e provo a spiegare meglio.

Ciao
Soviet

>
> in c# sarebbe una del tipo:
>
> static class Foo
> {
> static class Bar
> {
> public static readonly MyEnumType Value = MyEnumType.Value;
> }
> }
>
> se ho capito bene cosa intendi
>
> ..m
>


title: VB net - Structured Enums

text:
Il 19/11/2011 08:03, Mauro Servienti [MVP] ha scritto:
> Ciao Soviet_Mario,
>
> You wrote on 18/11/2011 :
>> Avete idea se qualche workaround consenta di emularle, o cmq conoscete
>> qualche tecnica per implementarne ?
>
> classi statiche (shared in vb) che espogono proprietà readonly di tipo
> enum, potrebbero andare bene?

dunque ... non avevo le idee chiare (mea culpa).

In realtà il "concetto" che vorrei emulare, sarebbe una
sorta di UNION (che per inciso non so se esista, nel C#
com'era nel C++, facciamo pure che è irrilevante, tanto
penso che sia noto cosa siano le union del C++) type-safe.
Questa union dovrebbe contenere solo valori integral
"controllati" (provenienti da diverse ENUMs), ed un campo di
tipo (Type ?) per capire il tipo di contenuto ad un certo
istante (valori numerici uguali ma provenienti da diverse
enum avrebbero significati diversi).

Ora potrei usare un altro campo enum per tracciare il tipo,
ma non so se sarebbe comodo ai fini della scrittura di
routine generiche di recupero del valore.

So che mi sono spiegato ancora malissimo e non so fare di
meglio :-)

In compenso rilancio con un altro post
ciao
Soviet

>
> in c# sarebbe una del tipo:
>
> static class Foo
> {
> static class Bar
> {
> public static readonly MyEnumType Value = MyEnumType.Value;
> }
> }
>
> se ho capito bene cosa intendi
>
> ..m
>


title: VB net - Structured Enums

text:
Il 18/11/2011 22:31, Soviet_Mario ha scritto:

Mi servirebbe implementare un grafo (orientato), con
relazione uno->molti (ogni nodo può avere da zero a enne
nodi figli).
Però molte delle BRANCHE di questo grafo sarebbero identiche
(la ragione è semplice, rappresentano la sintassi di un
linguaggio scomposto in tokens, e molti costrutti sono
l'epilogo di vari punti di partenza).

Se avessi sotto mano i puntatori, questi incroci li
riuscirei ad immaginare.
Ma senza non riesco a capire come implementare un grafo del
genere senza avere un numero elevato di cloni fisici.

Non so se ho capito bene, ma ad es. usando una struttura
dati adeguata (tipo lista di liste), pensavo che se quando
costruisco un nodo uso NEW allora alloco realmente una nuova
copia fisica di dati collegata alla reference (il nome del
campo), mentre se non dichiaro come new ma uso semplicemente
l'assegnamento, sto solo facendo puntare una reference al
RValue (l'oggetto fisicamente presente).
E' vero questo ? La struttura è di sola lettura, ergo viene
costruita una sola volta e si mantiene consistente.

Se no, come si potrebbe costruire un grafo in cui sia
presente sempre e solo una copia di ciascun tipo di nodo, e
il resto solo puntatori ?

:-( Non ho mai padroneggiato net, e in un sei mesi che non
l'ho usato la ruggine è diventata spessa un metro
riciao
Soviet

> ciao e grazie
> Soviet_Mario
>


title: VB net - Structured Enums

text:
Ciao Soviet_Mario,

mollo, io e le union non andiamo per n ulla d'accordo, ci vuole Raff
:-)



title: VB net - Structured Enums

text:
Soviet_Mario wrote:
> Il 18/11/2011 22:31, Soviet_Mario ha scritto:
>
> Mi servirebbe implementare un grafo (orientato), con relazione uno->molti
> (ogni nodo può avere da zero a enne nodi figli).
> Però molte delle BRANCHE di questo grafo sarebbero identiche (la ragione è
> semplice, rappresentano la sintassi di un linguaggio scomposto in tokens, e
> molti costrutti sono l'epilogo di vari punti di partenza).
>

tieni conto che già esistono librerie per parsare e rappresentare
grammatiche. Non ricordo il nome ma qualcosa ricordo di averlo visto.

>
> Se avessi sotto mano i puntatori, questi incroci li riuscirei ad immaginare.
> Ma senza non riesco a capire come implementare un grafo del genere senza
> avere un numero elevato di cloni fisici.
>
> Non so se ho capito bene, ma ad es. usando una struttura dati adeguata (tipo
> lista di liste), pensavo che se quando costruisco un nodo uso NEW allora
> alloco realmente una nuova copia fisica di dati collegata alla reference (il
> nome del campo), mentre se non dichiaro come new ma uso semplicemente
> l'assegnamento, sto solo facendo puntare una reference al RValue (l'oggetto
> fisicamente presente).
> E' vero questo ? La struttura è di sola lettura, ergo viene costruita una
> sola volta e si mantiene consistente.
>
> Se no, come si potrebbe costruire un grafo in cui sia presente sempre e solo
> una copia di ciascun tipo di nodo, e il resto solo puntatori ?
>

Per essere sicuro se fare una new o riusare l'oggetto ti conviene usare
(come si fa anche in C++) il factory pattern --> costruttore privato e
metodo statico pubblico che genera o riusa le istanze.

Il comportamento standard di .net è semplice: i reference value (cioè
tutte le classi sono reference, quindi hai in mano un puntatore. Se lo
copi (a = b) non fai altro che duplicare il reference e non l'istanza.
Se vuoi creare un'istanza devi fare new, fine del gioco.

Se invece hai valuetype (le struct), hai in mano direttamente l'oggetto
che è allocato sullo stack (no gc) e ogni volta che fai (x = y) o lo
passi ad un metodo ne istanzi uno nuovo.

Se hai grafi complessi da costruire, devi necessariemente crearti una
tua struttura prevedendo liste di reference.

Se vuoi costruire un grafo strong-typed dinamicamente, ti conviene
generare dinamicamente il codice C# per quel grafo.

Non so bene cosa ci vuoi fare, quindi non so dirti di più....

--
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: VB net - Structured Enums

text:
Mauro Servienti [MVP] wrote:
> mollo, io e le union non andiamo per n ulla d'accordo, ci vuole Raff :-)
>

LOL, non ho capito cosa c'entrino le union, ma vabbè :)



title: VB net - Structured Enums

text:

Mi documenterò meglio. Credo di avere fatto già qualcosa di
simile per parti di oggetti shared da inizializzare solo una
volta, ma in modo autodidatta e piuttosto grossolano.

>
> Il comportamento standard di .net è semplice: i reference value (cioè
> tutte le classi sono reference, quindi hai in mano un puntatore. Se lo
> copi (a = b) non fai altro che duplicare il reference e non l'istanza.

ottimo. Quindi una modifica dello stato dell'unica copia
esistente, si ripercuote istantaneamente su tutte le
reference sparse, vero ? Non viene mai generata una copia locale

> Se vuoi creare un'istanza devi fare new, fine del gioco.

Ok. PRobabilmente della confusione mi è sorta leggendo che
le stringhe sono diventate "immutable" e vengono copiate e
reistanziate ad ogni modifica. Ma non avevo poi capito se
fossero oggetti valuetype, ref o altra ancora

>
> Se invece hai valuetype (le struct), hai in mano direttamente l'oggetto
> che è allocato sullo stack (no gc) e ogni volta che fai (x = y) o lo
> passi ad un metodo ne istanzi uno nuovo.

cioè se nella dichiarazione formale di argomenti lo dichiari
ByRef, viene ugualmente generata una copia locale e passato
come valore sullo stack alla routine ???

>
> Se hai grafi complessi da costruire, devi necessariemente crearti una
> tua struttura prevedendo liste di reference.
>
> Se vuoi costruire un grafo strong-typed dinamicamente, ti conviene
> generare dinamicamente il codice C# per quel grafo.
>
>
> Non so bene cosa ci vuoi fare, quindi non so dirti di più....
>

mi hai già dato molte spiegazioni e spunti. Ma non sono
sicuro di sapere cosa intendi per generare codice
dinamicamente (C# non l'ho nemmeno mai usato). Intuisco che
non c'entri niente coi template. Forse con le macro ?
In VB si può ? Ho visto che c'è una categoria di cose (tipo
TypeBuilder) che non ho mai usato, ti riferivi a queste
funzionalità ?
Ciao
e grazie
Soviet


title: VB net - Structured Enums

text:
Soviet_Mario wrote:
> ottimo. Quindi una modifica dello stato dell'unica copia esistente, si
> ripercuote istantaneamente su tutte le reference sparse, vero ? Non viene mai
> generata una copia locale
>

esatto, ma occhio che non sono sempre rose e fiori ;-)

>
> Ok. PRobabilmente della confusione mi è sorta leggendo che le stringhe sono
> diventate "immutable" e vengono copiate e reistanziate ad ogni modifica. Ma
> non avevo poi capito se fossero oggetti valuetype, ref o altra ancora
>

La stringa è un pessimo esempio di reference type.
Essendo immutabile tutti i metodi che modificano stringhe in realtà
creano nuove istanze. È una scelta (giusta) del framework.

>
> cioè se nella dichiarazione formale di argomenti lo dichiari ByRef, viene
> ugualmente generata una copia locale e passato come valore sullo stack alla
> routine ???
>

se forzi "ref" ovviamente viene passata by ref.
Il comportamento di default del framework è di passare by value, quindi
se passi un reference type ottieni di copiare un reference e non
l'oggetto.
Come racconto nei corsi ci sono 4 possibilità:
- ref type by val
- ref type by ref
- val type by val
- val type by ref

Puoi facilmente immaginare cosa avviene in ciascuno di questi casi

>
> mi hai già dato molte spiegazioni e spunti. Ma non sono sicuro di sapere cosa
> intendi per generare codice dinamicamente (C# non l'ho nemmeno mai usato).
> Intuisco che non c'entri niente coi template. Forse con le macro ?
> In VB si può ? Ho visto che c'è una categoria di cose (tipo TypeBuilder) che
> non ho mai usato, ti riferivi a queste funzionalità ?
>

Puoi generare codice C# in tanti modi. Il più semplice è via testo
(concateni con uno stringbuilder) ma è anche intricato.
Il più complesso è via "CodeDom".
Il futuro è via "Roslyn" che è attualmente in ctp.

Ma qui il discorso si allarga troppo :)



title: VB net - Structured Enums

text:

mmm, forse ... ma vediamo se immagino giusto però

Io immagino che semplicemente in ogni caso prevalga la
direttiva di dichiarazione nel parametro formale.
Se poi mi sbilancio a straparlare di cose che non capisco,
immagino anche che nei passaggi byval vengano generati dei
temporanei, il cui piazzamento in memoria potrebbe essere
diverso.
Tipo : il val type by val creato direttamente sullo stack (a
meno che non contenga stringhe e matrici che forse se ne
stanno per conto loro da qualche altra parte)
Mentre : ref type by val potrebbe essere istanziato con new
e distrutto al rientro.
Ma ho proprio sparato lì a caso. In realtà mi basta aver
capito la prima proposizione (che prevale cmq la direttiva
dei parametri della funzione)

>
>>
>> mi hai già dato molte spiegazioni e spunti. Ma non sono sicuro di
>> sapere cosa intendi per generare codice dinamicamente (C# non l'ho
>> nemmeno mai usato). Intuisco che non c'entri niente coi template.
>> Forse con le macro ?
>> In VB si può ? Ho visto che c'è una categoria di cose (tipo
>> TypeBuilder) che non ho mai usato, ti riferivi a queste funzionalità ?
>>
>
> Puoi generare codice C# in tanti modi. Il più semplice è via testo
> (concateni con uno stringbuilder) ma è anche intricato.

Nebbia totale. Non ho la minima idea di come una stringa in
memoria diventi codice sorgente (né in che fase questo venga
visto ... tipo, l'intellisense lo vedrebbe ?). Avresti
qualche termine di ricerca per poter cercare info ?

> Il più complesso è via "CodeDom".

non conosco nemmeno questo. Posso provare a vedere.

> Il futuro è via "Roslyn" che è attualmente in ctp.

Si forse questa roba è troppo avanzata.
Cmq grazie dei ripassi !
ciao
Soviet



title: VB net - Structured Enums

text:
Soviet_Mario wrote:
> Io immagino che semplicemente in ogni caso prevalga la direttiva di
> dichiarazione nel parametro formale.
>

no, per esempio il caso ref by ref significa che stai dereferenziando
due volte. È l'equivalente di ** in C++.

> Se poi mi sbilancio a straparlare di cose che non capisco, immagino anche che
> nei passaggi byval vengano generati dei temporanei, il cui piazzamento in
> memoria potrebbe essere diverso.
> Tipo : il val type by val creato direttamente sullo stack (a meno che non
> contenga stringhe e matrici che forse se ne stanno per conto loro da qualche
> altra parte)

il val by val semplicemente viene copiato

> Mentre : ref type by val potrebbe essere istanziato con new e distrutto al
> rientro.
> Ma ho proprio sparato lì a caso. In realtà mi basta aver capito la prima
> proposizione (che prevale cmq la direttiva dei parametri della funzione)

il ref by val copia il reference di conseguenza l'oggetto puntato può
essere usato (che in molti casi significa poter essere modificato) da
entrambi i reference.

>> Puoi generare codice C# in tanti modi. Il più semplice è via testo
>> (concateni con uno stringbuilder) ma è anche intricato.
>
> Nebbia totale. Non ho la minima idea di come una stringa in memoria diventi
> codice sorgente (né in che fase questo venga visto ... tipo, l'intellisense
> lo vedrebbe ?). Avresti qualche termine di ricerca per poter cercare info ?

Semplicemente perché il compilatore è disponibile nel
framework.net

anche senza sistema di sviluppo.
Quindi puoi creare una classe, compilarla, caricarla in memoria ed
eseguire il suo codice.

Ciao!



title: VB net - Structured Enums

text:
Il 22/11/2011 00:26, Raffaele Rialdi [MVP] ha scritto:
> Soviet_Mario wrote:
>> Io immagino che semplicemente in ogni caso prevalga la direttiva di
>> dichiarazione nel parametro formale.
>>

non ne ho azzeccata nemmeno una !

>
> no, per esempio il caso ref by ref significa che stai dereferenziando
> due volte. È l'equivalente di ** in C++.

si, ma in C++ se dereferenzi due volte un qualcosa che non è
dichiarato come puntatore a puntatore, ricevi un vaffanculo
dal compilatore.
Quindi cosa succede in net se dereferenzi due volte un
puntatore "semplice" ? Ti da la possibilità di spostare una
reference di memoria lasciando vaganti i dati a cui puntava
?? Un memory leak ? Non ho ancora capito questo punto

>
>
>> Se poi mi sbilancio a straparlare di cose che non capisco, immagino
>> anche che nei passaggi byval vengano generati dei temporanei, il cui
>> piazzamento in memoria potrebbe essere diverso.
>> Tipo : il val type by val creato direttamente sullo stack (a meno che
>> non contenga stringhe e matrici che forse se ne stanno per conto loro
>> da qualche altra parte)
>
> il val by val semplicemente viene copiato
>
>
>> Mentre : ref type by val potrebbe essere istanziato con new e
>> distrutto al rientro.
>> Ma ho proprio sparato lì a caso. In realtà mi basta aver capito la
>> prima proposizione (che prevale cmq la direttiva dei parametri della
>> funzione)
>
> il ref by val copia il reference

mi pare assurdo e inutile. A cosa serve creare un altra
reference (temporanea) per gli stessi dati allocati ?

> di conseguenza l'oggetto puntato può
> essere usato (che in molti casi significa poter essere modificato) da
> entrambi i reference.

andiamo bene ... cmq grazie molte perché mi hai scardinato
una nutrita serie di misconcepts veramente pericolosi

>
>>> Puoi generare codice C# in tanti modi. Il più semplice è via testo
>>> (concateni con uno stringbuilder) ma è anche intricato.
>>
>> Nebbia totale. Non ho la minima idea di come una stringa in memoria
>> diventi codice sorgente (né in che fase questo venga visto ... tipo,
>> l'intellisense lo vedrebbe ?). Avresti qualche termine di ricerca per
>> poter cercare info ?
>
> Semplicemente perché il compilatore è disponibile nel
framework.net

> anche senza sistema di sviluppo.

e viene invocato da dentro il codice stesso, per produrre
altro codice "online", cioè dinamicamente chiamabile non
appena tornati dalla chiamata al compilatore ?

Co-domanda : questo compilatore è parte dell'eseguibile o se
ne assume l'esistenza separatamente ? E se è la prima,
ammettendo di non invocarlo mai, non viene linkato, vero ?
Ma penserei la seconda ... mah

grazie delle dritte
Soviet



title: VB net - Structured Enums

author: dmaxime

text:

Ciao,
sono rimasto incuriosito dal tuo problema, ci ho giochicchiato un poco e
sono giunto ad un abbozzo di soluzione che potrebbe o divertirti o
interessarti. Il concetto è quello di sostituire i puntatori con delle
specie di handle. L'esempio che ti propongo è uno dei più classici:
caricamento ordinato di un albero binario (Button1) e stampa ordinata
(Button2). E' solo un abbozzo, quindi ti prego di non riderne in modo
eccessivamente sguaiato:

- 2 Button + 1 TextBox
-------------------------
     struct tree
     {
         public int tok;
         public int id_l;
         public int id_h;
     }

     public partial class Form1 : Form
     {
         Dictionary<int, tree> cGrafo = new Dictionary<int, tree>();
         static int next = 0;

         public Form1()
         {
             InitializeComponent();
         }

         private void button1_Click(object sender, EventArgs e)
         {
             List<int> lTok = new List<int>{
                                 7, 5, 2, 8, 6, 3
                             };
             int ID = 0, prev;
             tree cur;
             cGrafo.Clear();
             cGrafo.Add(0, new tree { tok = 0, id_l = -1, id_h = -1 });
             foreach (int i in lTok)
             {
                 cur = cGrafo[0];
                 prev = 0;
                 while(cur.tok != i)
                 {
                     if (i < cur.tok)
                     {
                         if (cGrafo.ContainsKey(cur.id_l))
                         {
                             prev = cur.id_l;
                             cur = cGrafo[cur.id_l];
                         }
                         else
                         {
                             cGrafo.Add(++ID, new tree() { tok = i, id_h
= -1, id_l = -1  });
                             cur.id_l = ID;
                             cGrafo[prev] = cur;
                         }
                     }
                     else if (i > cur.tok)
                     {
                         if (cGrafo.ContainsKey(cur.id_h))
                         {
                             prev = cur.id_h;
                             cur = cGrafo[cur.id_h];
                         }
                         else
                         {
                             cGrafo.Add(++ID, new tree() { tok = i, id_h
= -1, id_l = -1 });
                             cur.id_h = ID;
                             cGrafo[prev] = cur;
                         }
                     }
                 }

             }
         }

         private void button2_Click(object sender, EventArgs e)
         {
             SGrafo(0);
         }

         private bool SGrafo(int id)
         {
             if(cGrafo.ContainsKey(id))
             {
                 SGrafo(cGrafo[id].id_l);
                 listBox1.Items.Add(cGrafo[id].tok);
                 SGrafo(cGrafo[id].id_h);
                 return true;
             }
             return false;
         }
     }

-------------------------
Spero ti sia utile.


title: VB net - Structured Enums

text:
Il 23/11/2011 01:15, dmaxime ha scritto:
> Il 20/11/2011 15:06, Soviet_Mario ha scritto:
>> Il 18/11/2011 22:31, Soviet_Mario ha scritto:
CUT

> Ciao,
> sono rimasto incuriosito dal tuo problema, ci ho giochicchiato un poco e
> sono giunto ad un abbozzo di soluzione che potrebbe o divertirti o
> interessarti. Il concetto è quello di sostituire i puntatori con delle
> specie di handle. L'esempio che ti propongo è uno dei più classici:
> caricamento ordinato di un albero binario (Button1) e stampa ordinata
> (Button2). E' solo un abbozzo, quindi ti prego di non riderne in modo
> eccessivamente sguaiato:

Ciao ... figurati ! Anzi ti ringrazio molto dell'interessamento.
Ora ho una settimana di consigli di classe, ma appena
possibile mi studio il tuo codice (a colpo d'occhio mi pare
un albero binario ? Ma basterebbe mettere un'array di
handles invece che solo h e l, vero ?
Alla prox
ciao
Soviet

Ah ... PS. Non sei il primo che mi risponde in C#. In
effetti sto usando VB (e in C++ so programmare solo unmanaged)

riciao



title: VB net - Structured Enums

text:
> Ora ho una settimana di consigli di classe, ma appena possibile mi
> studio il tuo codice (a colpo d'occhio mi pare un albero binario ?

Lo è ma non sapevo cos'altro inventarmi per far le prove.

> Ma basterebbe mettere un'array di handles invece che solo h e l, vero ?

certo!

> Ah ... PS. Non sei il primo che mi risponde in C#. In effetti sto usando
> VB (e in C++ so programmare solo unmanaged)

Questo è il minore dei miei problemi, anzi, ne ho approfittato per
scriverla meglio e rendere ricorsivo anche l'inserimento. Sempre
mettendo 2 button e una listbox in un form:

Structure tree
     Dim token As Integer
     Dim id_l, id_h As Integer
End Structure

Public Class Form1
     Dim t As New AdmTree

     Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles Button1.Click
         Dim lTok As New List(Of Integer)(New Integer() { _
         7, 5, 2, 8, 6, 3, 4, 9, -2 _
         })
         For Each tok As Integer In lTok
             t.Add(tok)
         Next
     End Sub

     Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles Button2.Click
         Dim oList As New List(Of Integer)

         ListBox1.Items.Clear()

         ListBox1.Items.Add("Ascend")
         oList.Clear()
         t.GetAscendL(0, oList)
         For Each l As Integer In oList
             ListBox1.Items.Add(l)
         Next

         ListBox1.Items.Add("Descend")
         oList.Clear()
         t.GetDescendL(0, oList)
         For Each l As Integer In oList
             ListBox1.Items.Add(l)
         Next
     End Sub
End Class

Class AdmTree
     Private cGrafo As New Dictionary(Of Integer, tree)
     Private Changed As Boolean = False
     Private _ID As Integer = 0

     Public Sub Add(ByRef t As Integer)
         If cGrafo.ContainsKey(0) Then
             tInsert(0, t)
         Else
             cGrafo.Add(_ID, New tree() With {.token = t, .id_l = -1,
.id_h = -1})
         End If
         _ID += 1
     End Sub

     Private Function tInsert(ByVal id As Integer, ByRef t As Integer)
As Integer
         Dim _t As tree

         If cGrafo.TryGetValue(id, _t) Then
             If t > _t.token Then
                 _t.id_h = tInsert(_t.id_h, t)
             ElseIf t < _t.token Then
                 _t.id_l = tInsert(_t.id_l, t)
             End If
             If Changed Then
                 cGrafo(id) = _t
                 Changed = False
             End If
             tInsert = id
         Else
             cGrafo.Add(_ID, New tree() With {.token = t, .id_l = -1,
.id_h = -1})
             Changed = True
             tInsert = _ID
         End If
     End Function

     Public Function GetAscendL(ByVal id As Integer, ByRef l As List(Of
Integer)) As Boolean
         If cGrafo.ContainsKey(id) Then
             GetAscendL(cGrafo(id).id_l, l)
             l.Add(cGrafo(id).token)
             GetAscendL(cGrafo(id).id_h, l)
             Return True
         End If
         Return False
     End Function

     Public Function GetDescendL(ByVal id As Integer, ByRef l As List(Of
Integer)) As Boolean
         If cGrafo.ContainsKey(id) Then
             GetDescendL(cGrafo(id).id_h, l)
             l.Add(cGrafo(id).token)
             GetDescendL(cGrafo(id).id_l, l)
             Return True
         End If
         Return False
     End Function
End Class


title: VB net - Structured Enums

text:
Il 24/11/2011 16:04, dmaxime ha scritto:
>> Ora ho una settimana di consigli di classe, ma appena possibile mi
>> studio il tuo codice (a colpo d'occhio mi pare un albero binario ?

beh, che dire : avessi mai qualche dubbio di chimica, sei
creditore di ponderate risposte su ISC.
Veramente gentile
per ora scappo

ciao
Soviet

> cGrafo.Add(_ID, New tree() With {.token = t, .id_l = -1, ..id_h = -1})
> End If
> _ID += 1
> End Sub
>
> Private Function tInsert(ByVal id As Integer, ByRef t As Integer) As
> Integer
> Dim _t As tree
>
> If cGrafo.TryGetValue(id, _t) Then
> If t > _t.token Then
> _t.id_h = tInsert(_t.id_h, t)
> ElseIf t < _t.token Then
> _t.id_l = tInsert(_t.id_l, t)
> End If
> If Changed Then
> cGrafo(id) = _t
> Changed = False
> End If
> tInsert = id
> Else
> cGrafo.Add(_ID, New tree() With {.token = t, .id_l = -1, ..id_h = -1})



title: VB net - Structured Enums

text:
Soviet_Mario wrote:
> non ne ho azzeccata nemmeno una !

:)
Sorry ma ero tutta la settimana fuori per una conferenza ...

>> no, per esempio il caso ref by ref significa che stai dereferenziando
>> due volte. È l'equivalente di ** in C++.
>
> si, ma in C++ se dereferenzi due volte un qualcosa che non è dichiarato come
> puntatore a puntatore, ricevi un vaffanculo dal compilatore.
> Quindi cosa succede in net se dereferenzi due volte un puntatore "semplice" ?
> Ti da la possibilità di spostare una reference di memoria lasciando vaganti i
> dati a cui puntava ?? Un memory leak ? Non ho ancora capito questo punto
>

Ti manda a quel paese se chi crea il doppio ref e chi lo usa non hanno
fatto le cose per bene :)
Quando tu dichiari che un reference value  va passato by ref, il
compilatore fa le cose per bene e funziona tutto nel modo corretto.
Ricorda che i linguaggi .net sono nati per essere type safe (tranne
quando usi "unsafe" ovviamente)

>> il ref by val copia il reference
>
> mi pare assurdo e inutile. A cosa serve creare un altra reference
> (temporanea) per gli stessi dati allocati ?
>

Serve per poterlo usare localmente, altrimenti la funzione locale non
avrebbe visibilità sull'oggetto.
L'importante è distinguere (grazie a ref type e val type) tra la copia
del reference e la copia dell'oggetto.

>
> andiamo bene ... cmq grazie molte perché mi hai scardinato una nutrita serie
> di misconcepts veramente pericolosi
>

:)

>
> e viene invocato da dentro il codice stesso, per produrre altro codice
> "online", cioè dinamicamente chiamabile non appena tornati dalla chiamata al
> compilatore ?
>

Se vuoi si. Tu sai di averlo a disposizione anche su un'installazione
che è priva di sistema di sviluppo e se vuoi puoi usarlo.

> Co-domanda : questo compilatore è parte dell'eseguibile o se ne assume
> l'esistenza separatamente ? E se è la prima, ammettendo di non invocarlo mai,
> non viene linkato, vero ? Ma penserei la seconda ... mah
>

È semplicemente parte del framework per cui le sue dll vengono caricate
in memoria solo se le usi. Le normali app non lo usano.



title: VB net - Structured Enums

text:
Il 27/11/2011 12:19, Raffaele Rialdi [MVP] ha scritto:

CUT ALL

ri-grazie di tutte le spiegazioni
ciao
Soviet


title: ADO.NET e concorrenza

author: GennarinOSpion

text:
Ciao,

studiando
ADO.NET
 sto partendo dall'ide che permette di aggiungere un
datasource + dataset al progetto, per poi approfondire...

lavorando su un db di esempio Sql Compact Edition, da quello che ho
letto, se modifico dei record dalla mia app e salvo i dati nel db , e
subito dopo da un 'altra istanza della stessa app aperta
contemporaneamente, in cui sono stati inizialmente caricati gli stessi
dati, modifico lo stesso record e salvo i dati nel db, dovrei ottenere
un eccezione dovuto al controllo della concorrenza....

invece questo non accade, quindi in quale punto dell'applicazione devo
inserire il controllo "ottimistico??" per la gestione della concorrenza?

grazie


title: [Project] - Repository privati online

author: Andrea Angella

text:
?Ciao a tutti,
vorrei iniziare ad organizzare per bene i miei eventuali progetti privati e
utilizzare repository online per il versioning dei sorgenti.
La scelta non e' semplice in quando il numero di tecnologie e servizi in
questo senso e' cresciuto esponenzialmente.
Quali sono i differenti version control system da considerare (SVN,
Perforce, Mercurial, Git)?
Quali sono i differenti vendor e come scegliere ?
Voi cosa utilizzate? come gestite i vostri progetti personali privati?
Mi piacerebbe avviare una discussione prima di prendere una decisione,
Grazie,
Andrea


title: [Project] - Repository privati online

author: Alessandro Gambaro

text:
Ciao,
Io ho usato per mini progettino distribuito questo
https://www.projectlocker.com/site/scm
 - La versione base è free con dei limiti
 - Puoi usare git o svn
 - Dispone anche di altri servizi
Ciao,
Ale



title: [Project] - Repository privati online

text:
Andrea Angella wrote:
> ?Ciao a tutti,
Ciao Andrea,

Se sei online un sc distribuito fa molta differenza in quanto la
latenza di rete può essere estremamente noiosa.
Per fare un esempio Codeplex ha aggiunto il supporto a Mercurial
suppongo anche per questo motivo.
Git imho è inutilizzabile in quanto le rename diventano cancellazioni +
insert con il risultato che perdi la storia del file prima del rename.
Mercurial va molto bene e ci sono almeno due integrazioni con
vs.net

che funzionano benone.
Tolto il discorso sc, TFS2010 (e sottolineo la 2010), è un altro
pianeta. La basic è dentro tutti gli abbo msdn (che sono imho l'unico
modo sensato di comprare
vs.net
 professionalmente parlando).
Non sono a conoscenza di TFS "on the cloud" anche se ne ho sentito
parlare da diverse persone.
Se vuoi qualcosa di meno rispetto a tfs ma di più rispetto al semplice
sc, ontime è un bel prodotto. La versione online però non l'ho mai
provata:
http://www.axosoft.com/ontime/hosted
--
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: [Project] - Repository privati online

author: Antonio Di Motta

text:

Ciao, io mi sto trovando bene con
http://www.assembla.com
supporta SVN e GIT
numero illimitato di progetti e di utenti
limite di 2GB per i piani free.
Ciao
Antonio


title: [Project] - Repository privati online

author: ReadOnly

text:
On 09/12/2010 21:02, Alessandro Gambaro wrote:
> Ciao,
>
> Io ho usato per mini progettino distribuito questo
>
>
https://www.projectlocker.com/site/scm
>
>   - La versione base è free con dei limiti
>   - Puoi usare git o svn
>   - Dispone anche di altri servizi
Io ho un account su Projectlocker da 30$/Y (per 2.5Gb) che uso per una
dozzina di progetti e fin'ora mi sono trovato bene. La versione gratuita
ha come limiti lo spazio (500Mb), il numero di utenti sull'account (mi
pare 5) e la presenza di pubblicità nel portale.
--
r--r--r--


title: Api di SkyDrive

author: Stefano Paparesta

text:
Ciao a tutti,
esistono delle api UFFICIALI di SkyDrive ?
Grazie mille
Stefano


title: Api di SkyDrive

text:
Ciao Stefano,
You wrote on 18/05/2011 :
> Ciao a tutti,
> esistono delle api UFFICIALI di SkyDrive ?
WebDav (credo)
> Grazie mille
> Stefano
.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: C# inizializzatori

text:
Non ï¿œ assolutamente un problema, ma una curiositï¿œ. Come mai il
compilatore non considera un errore di sintassi una inizializzazione
come questa?

var obj = new
{
     a = 1,
     b = 2,
};

Notare la , dopo il 2. Ha un qualche significato il fatto che si possa
aggiungere una virgola inutile in fondo oppure ï¿œ semplicemente il
compilatore (C# 4, non ho verificato cosa fa il 3.5) molto tollerante? :-)

--
r--r--r--


title: C# inizializzatori

text:
Ciao ReadOnly,

You wrote on 11/07/2012 :
> Notare la , dopo il 2. Ha un qualche significato il fatto che si possa
> aggiungere una virgola inutile in fondo oppure ï¿œ semplicemente il compilatore
> (C# 4, non ho verificato cosa fa il 3.5) molto tollerante? :-)

l'avevo notato anche io, ï¿œ curiosamente tollerante, non ï¿œ da lui :-)

.m

--
blog @ //
milestone.topics.it


title: C# inizializzatori

author: Raffaele Rialdi [MVP]

text:
ReadOnly wrote:
> Notare la , dopo il 2. Ha un qualche significato il fatto che si possa
> aggiungere una virgola inutile in fondo oppure ï¿œ semplicemente il compilatore
> (C# 4, non ho verificato cosa fa il 3.5) molto tollerante? :-)
>

Semplicemente semplifica la generazione automatica del codice e la
trovo una chicca assolutamente pregevole.

Personalmente ho preso l'abitudine di mettere tutti gli elementi con la
virgola in fondo (anche negli enumeratori).
Risulta molto utile anche quando devi commentare un elemento senza
modificare il precedente.

--
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# inizializzatori

text:
"ReadOnly"  wrote in message
news:VrcLr.190200$GZ3.1...@tornado.fastwebnet.it...

> Ha un qualche significato il fatto che si possa
> aggiungere una virgola inutile in fondo

Opzionale e inutile non sono la stessa cosa.  Il compilatore *non* e'
affatto "tollerante", piuttosto quella sintassi e' consentita dalla
specifica del linguaggio.  Infine da notare che non solo in C# gli array
initializer e simili costrutti consentono una virgola anche dopo l'ultimo
elemento: cosi' e' anche in Javascript e in altri linguaggi, tra cui, per
alcuni costrutti, persino VB.Net...

-LV


title: C# inizializzatori

text:
Il 11/07/2012 13:31, LudovicoVan ha scritto:
> Il compilatore *non* e'
> affatto "tollerante", piuttosto quella sintassi e' consentita dalla
> specifica del linguaggio.

Ok, qualcuno ha deciso che la sintassi debba consentirlo e il
compilatore lavora di conseguenza... resta che mentre per JS (per dirne
uno) la cosa ï¿œ esplicita:

http://tinyurl.com/bpyjn7b

non mi sembra che questa feature sia citata nella documentazione
ufficiale di C#:

http://msdn.microsoft.com/en-us/library/bb384062

magari sono semplicemente 'ciecato (sï¿œ, lo sono...) ma non la vedo.

Per il resto concordo con Raffaele: ï¿œ comodissima per zappare parti di
inizializzazioni senza doversi preoccupare di sistemare la
punteggiatura, solo mi aspettavo di poterlo fare! :-)


title: C# inizializzatori

text:
"ReadOnly"  wrote in message
news:PigLr.190298$GZ3.1...@tornado.fastwebnet.it...

> magari sono semplicemente 'ciecato (sï¿œ, lo sono...) ma non la vedo.

Che t'aggi'a dicere?!  Guarda meglio...  O era un modo poco carino per
chiedermi di dirti dove e' scritto?  Stavi guardando nella language
reference, right?  (Speaking in general, vi confermate di una simpatia,
cortesia e spirito positivo rimarchevoli: nonche'  di un livello di
competenza che non ho parole, usually.)

> Per il resto concordo con Raffaele: ï¿œ comodissima per [...]

No worries, me too.

Cmq, se era una domanda la tua, prova a guardare meglio e poi prova a
chiedere di nuovo...

Good luck,

-LV


title: [asp.net]Forzare redirect

text:
Salve a tutti,
qual è il modo migliore per forzare la redirect verso una pagina al
verificarsi di una condizione?
Ho provato a sviluppare un semplice HTTPHandler che intercetti tutte
le chiamate, ma senza successo.
Qualche suggerimento?
Grazie a tutti per la collaborazione.
Francesco


title: [asp.net]Forzare redirect

text:
On Monday, April 11, 2011 12:20:58 PM UTC+1, F.Suma wrote:
> qual è il modo migliore per forzare la redirect verso una pagina al
> verificarsi di una condizione?
Non va bene un semplice Response.Redirect?
-LV


title: [asp.net]Forzare redirect

text:

Troppo semplice ;-)
Il problema è che la Response.Redirect devo gestirla in tutte le
pagine...
Sto vedendo se aggiro l'ostacolo implementando una classe che eredita
da Page e che implementa i controlli.
Poi le mie pagine.aspx, invece di implementare Page, implementeranno
la nuova classe...
Francesco


title: [asp.net]Forzare redirect

text:

È la soluzione più ovvia e semplice.
Cosa non ti funziona?
Potresti aver sbagliato la dichiarzione nel web.config ...
--
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: [asp.net]Forzare redirect

text:
On 12 Apr, 13:09, Raffaele Rialdi [MVP] <
malta@n0spam_vevy.com
> wrote:
> F.Suma wrote:
> > Salve a tutti,
> > qual è il modo migliore per forzare la redirect verso una pagina al
> > verificarsi di una condizione?
> > Ho provato a sviluppare un semplice HTTPHandler che intercetti tutte
> > le chiamate, ma senza successo.
> > Qualche suggerimento?
> > Grazie a tutti per la collaborazione.
> > Francesco
>
> È la soluzione più ovvia e semplice.
> Cosa non ti funziona?
Alla fine ho risolto in questo modo:
            If condizione Then
                handler =
PageParser.GetCompiledPageInstance(GetCurrentPageName(context),
Nothing, context)
                handler.ProcessRequest(context)
            Else
                handler =
PageParser.GetCompiledPageInstance("LoginMember.aspx", Nothing,
context)
                handler.ProcessRequest(context)
            End If
"GetCurrentPageName" restituisce il nome della pagina dal context
corrente.
Comunque volevo provare con la classe che estende Page.
Grazie...



title: [asp.net]Forzare redirect

text:
On Tuesday, April 12, 2011 12:06:44 PM UTC+1, F.Suma wrote:
> Il problema è che la Response.Redirect devo gestirla in tutte le
> pagine...
Allora non ti serve un HttpHandler, ti serve un HttpModule. Un HttpModule si pone lungo la catena della richiesta http, prima che la pagina o l'handler venga eseguito. Da un HttpModule hai accesso all'HttpContext, per cui puoi fare un po' tutto quello che vuoi compreso un Response.Redirect. Fra l'altro se non ricordo troppo male hai anche accesso alla Session: guarda la documentazione.
> Sto vedendo se aggiro l'ostacolo implementando una classe che eredita
> da Page e che implementa i controlli.
Un HttpModule mi sembrerebbe la soluzione piu' appropriata e pulita.
-LV


title: [asp.net]Forzare redirect

text:
F.Suma wrote:
> Alla fine ho risolto in questo modo:
>             If condizione Then
>                 handler =
> PageParser.GetCompiledPageInstance(GetCurrentPageName(context),
> Nothing, context)
>                 handler.ProcessRequest(context)
>             Else
>                 handler =
> PageParser.GetCompiledPageInstance("LoginMember.aspx", Nothing,
> context)
>                 handler.ProcessRequest(context)
>             End If
>
> "GetCurrentPageName" restituisce il nome della pagina dal context
> corrente.
>
>
> Comunque volevo provare con la classe che estende Page.
Se vuoi gestire qualsiasi tipo di richiesta, concordo con Ludivico che
httpmodule è il più indicato.
Se vuoi che
asp.net
 "scremi" per te la richiesta perché la vuoi
limitare alle sole aspx allora può bastare un handler.
Quando usi una di queste due soluzioni sei in mezzo alla pipeline di
asp.net
 e devi quindi scrivere il codice per ridare il controllo
all'handler di default se non puoi/vuoi gestire la tua richiesta.
Per farlo tipicamente si usa:
(IHttpHandler)BuildManager.CreateInstanceFromVirtualPath(..., ...)
che in pratica crea l'handler di default di competenza della richiesta
corrente.
In questo modo intercetti qualsiasi richiesta (ad esempio aspx), fai
quello che devi fare (log?, altro?) e poi lasci che l'handler di
default prosegua la sua strada.
--
Raffaele Rialdi
http://www.iamraf.net
Weblog:
http://blogs.ugidotnet.org/raffaele



title: [asp.net]Forzare redirect

text:
On Wednesday, April 13, 2011 9:29:55 AM UTC+1, Raffaele Rialdi [ MVP ] wrote:
> Se vuoi gestire qualsiasi tipo di richiesta, concordo con Ludivico che
> httpmodule è il più indicato.
> Se vuoi che
asp.net
 "scremi" per te la richiesta perché la vuoi
> limitare alle sole aspx allora può bastare un handler.
> Quando usi una di queste due soluzioni sei in mezzo alla pipeline di
>
asp.net
 e devi quindi scrivere il codice per ridare il controllo
> all'handler di default se non puoi/vuoi gestire la tua richiesta.
Se non ti sto fraintendendo, non e' necessario interferire con l'usuale flow della richiesta con un HttpModule: in particolare, l'handler target della richiesta viene invocato come di solito senza ulteriori interventi, a meno sempre di Response.Redirect, etc.
-LV


title: [asp.net]Forzare redirect

text:

Vero, dipende dai casi.
Per esempio io uso un http module per generare automaticamente una
pagina html che contiene i tag html 'link' usati da live writer per
sapere dove si trova il mannifest e il documento rsd.
Il module è più comodo anche per semplificare la configurazione nel
web.config
In questo caso dentro l'evento PreRequestHandlerExecute gli passi
l'handler.
L'handler tipicamente è il risultato di una
CreateInstanceFromVirtualPath oppure un'istanza della classe Page (che
è un IHttpHandler e quindi fa il suo lavoro).



title: Mono: accesso al file system

author: Enrico 'Henryx' Bianchi

text:
Per un applicativo che devo sviluppare, ho necessita` di interfacciarmi con
varie funzionalita` del sistema operativo ospitante. Nella fattispecie,
devo:

 - Listare il contenuto di una directory;
 - Estrarre vari attributi impostati in un file, tra cui ACL, permessi e
   cosi` via.

Ora, leggendo in giro vedo che la cosa e` abbastanza fattibile sotto
Windows, se non direttamente in .NET con l'uso delle librerie di sistema.
Considerando pero` che devo girare anche sotto ambiente linux, per Mono e`
lo stesso?

Enrico


title: Mono: accesso al file system

author: LudovicoVan

text:
"Enrico 'Henryx' Bianchi" <
henr...@yahoo.it
> wrote in message
news:jbqmdb$ube$2...@tdi.cu.mi.it...

> Per un applicativo che devo sviluppare, ho necessita` di interfacciarmi
> con
> varie funzionalita` del sistema operativo ospitante. Nella fattispecie,
> devo:
>
> - Listare il contenuto di una directory;
> - Estrarre vari attributi impostati in un file, tra cui ACL, permessi e
>   cosi` via.
>
> Ora, leggendo in giro vedo che la cosa e` abbastanza fattibile sotto
> Windows, se non direttamente in .NET con l'uso delle librerie di sistema.

Anche .Net fornisce tutte (o almeno quasi tutte, non ti garantisco i minimi
dettagli) le funzionalita' del sistema operativo, e non con semplici wrapper
bensi' con implementazioni native.  In particolare nei namespace System e
Microsoft.Windows.  Per le cose che menzioni sopra, puoi guardare nel
namespace System.IO le classi DirectoryInfo e FileInfo.

> Considerando pero` che devo girare anche sotto ambiente linux, per Mono e`
> lo stesso?

Non uso Mono ma, ad una rapida occhiata alla documentazione, pare proprio di
si', ovvero il namespace System.IO e' implementato in maniera (pressoche')
completa (come gran parte della BCL):

http://mono-framework.com/Compatibility

http://go-mono.com/status/status.aspx?reference=4.0&profile=4.0&assembly=System

http://docs.go-mono.com/

HTH,

-LV


title: [WPF][MVVM] Switch di viewmodel a runtime e DataTemplate

author: Marco Sabatini

text:
Ciao a tutti!
Sto cercando di fare un piccolo tutorial a MVVM per un collega, e gli ho detto di studiarsi il celeberrimo esempio "MVVMDemoApp" di Josh Smith:

http://msdn.microsoft.com/en-us/magazine/dd419663.aspx

Aveva la bella soluzione di mostrare delle view costruite con datatemplates: a seconda del dato da mostrare, wpf si sceglieva il template abbinato e sceglieva la view giusta (vedere allcustomers e newcustomer nell'esempio).

Tutto bello, tutto elegante. Ma non funziona cambiando al volo il tipo di dato sottostante: cioè, un nuovo dato (cioè il viewmodel sottostante) viene mostrato con la sua bella view selezionata dal datatemplate, ma se si cambia un viewmodel al volo (per esempio un viewmodel padre che abbia una property di tipo childviewmodel che cambi alla bisogna) il wpf non refresha, non ri-renderizza le view.

Qual è la strada migliore per risolvere la cosa senza aggiungere troppa "roba"? (leggo in giro di usare styles e triggers, template selectors, se fosse possibile vorrei fare qualcosa di più "didattico")

le idee che ho avuto io:
- distruggere la view e ricrearla (ma da command, nei viewmodel, accedere alle view... brrrrr....)
- scatenare un qualche refresh, non so in che modo...

Grazie per qualsiasi suggerimento
Marcosabba


text:
Il giorno mercoledì 11 giugno 2014 09:54:19 UTC+2, Marco Sabatini ha scritto:
[...]
> - distruggere la view e ricrearla
nel frattempo ho usato un itemscontrol bindato a una observablecollection che ogni volta viene svuotata (clear) e aggiunta del viewmodel che voglio mostrare.
Funziona. Se avete altre idee, grazie, per ora mi accontento :)
Ciao!


text:
Ciao Marco,

You wrote on 11/06/2014 :
> Tutto bello, tutto elegante. Ma non funziona cambiando al volo il tipo di
> dato sottostante: cioï¿œ, un nuovo dato (cioï¿œ il viewmodel sottostante) viene
> mostrato con la sua bella view selezionata dal datatemplate, ma se si cambia
> un viewmodel al volo (per esempio un viewmodel padre che abbia una property
> di tipo childviewmodel che cambi alla bisogna) il wpf non refresha, non
> ri-renderizza le view.

Questa cosa ï¿œ decisamente sospetta, a me ha sempre funzionato che ï¿œ un
piacere, riesci a mettere insieme un piccolo esempio che riproduce il
problema?

.m

--
blog @ //
milestone.topics.it


title: IL: chi era costui?

text:
Ciao a tutti,
mi piacerebbe poter iniziare a "esplorare" il mondo dell'IL di .NET.
Potete consigliarmi qualche buona guida introduttiva (sia d


title: IL: chi era costui?

text:

Il libro di Serge Lidin è la guida per l'assembler IL (ms press).
Ci sarebbe da capire cosa vuoi farci, perché nella maggior parte di
casi non hai dei vantaggi a scendere a quel livello ...
--
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: IL: chi era costui?

text:
Ciao Raf,
On 8/8/2011 10:32 AM, Raffaele Rialdi [MVP] wrote:
> Il libro di Serge Lidin è la guida per l'assembler IL (ms press).
Ho cercato l'autore e ho trovato sia il libro della MS press sia
l'altro... guardando le preview su Amazon mi sono sembrate decisamente
interessanti. :-)
> Ci sarebbe da capire cosa vuoi farci, perché nella maggior parte di casi
> non hai dei vantaggi a scendere a quel livello ...
Uhm... un incrocio tra un pure interesse accademico/speculativo e un
progetto che sto accarezzando mo(ooooooooooooo)lto alla lontana. Poi
magari, quando i tempi sono maturi, torno battere il ferro, state
tranquilli. :-D
Intanto grazie delle (come al solito preziose) segnalazioni.
Ciao,
Giulio
--


title: IL: chi era costui?

text:
Giulio Petrucci wrote:
> Ho cercato l'autore e ho trovato sia il libro della MS press sia l'altro...
> guardando le preview su Amazon mi sono sembrate decisamente interessanti. :-)
confermo, è un bel libro. La prima versione, relativa al fx 1.1, mi fu
regalato da UgiDotNet nel 2003 :))
Poi ho 'upgradato' con quello della 2.0
> Uhm... un incrocio tra un pure interesse accademico/speculativo e un progetto
> che sto accarezzando mo(ooooooooooooo)lto alla lontana. Poi magari, quando i
> tempi sono maturi, torno battere il ferro, state tranquilli. :-D
> Intanto grazie delle (come al solito preziose) segnalazioni.
okappa, buona lettura allora.
Ciao



title: iniziare con C#

author: vbMizio

text:
Ciao a tutti,
sto tentando di muovere i primi passi con C#, dopo un bel po' di tempo
passato con VB6 prima e con VB.Net poi.
Sto studiando su un libro molto incentrato sul linguaggio, dato che il FW ed
i concetti sono gli stessi di VB.Net.. insomma, non mi serve che mi venga
spiegato cosa sia una classe :-)
Il mio "problema" e' molto piu' banale, proprio da principiantissimo....
conoscere l'ambiente di sviluppo.
Abituato a Intellisense, autocompletamento e tutte queste belle cose che
mette a disposizione il VB, non riesco neanche a fare il classico "Hello
World" in C#.
Sapete indicarmi qualche tutorial, possibilmente free, in rete, per iniziare
"passo per passo" a conoscere l'ambiente di C#?
Attualmente sto usando il 2008, ma ho anche una licenza per VS2010., che
pero' ho aperto una volta sola :-)
Grazie a tutti.... Maurizio


title: iniziare con C#

text:

Ciao, secondo me potresti cominciare da questi due siti:
http://windowsclient.net/getstarted
http://www.asp.net/get-started
Ciao
Antonio


title: iniziare con C#

text:
On 12/16/2010 10:11 AM, vbMizio wrote:
> Sapete indicarmi qualche tutorial, possibilmente free, in rete, per
> iniziare "passo per passo" a conoscere l'ambiente di C#?
AFAIK è esattamente *lo stesso* che
VB.NET
, solo che si chiama Visual
Studio Express o Visual C# Express. :-)
Ciao,
Giulio
--


title: iniziare con C#

text:
Ciao e grazie per la risposta,
....
>AFAIK č esattamente *lo stesso* che
VB.NET
, solo che si chiama Visual
Studio Express o Visual C# Express. :-)
....
dici quindi che mi sono impegnato troppo poco? :-)
Boh, io mi ci sono messo sopra, ho provato a fare una str***ta qualunque, ma
ho grossi problemi.
Mi mancano proprio le basi-basi-basi :-)
Ciao


title: iniziare con C#

author: Innuendo

text:
Il 16/12/2010 11:14, vbMizio ha scritto:
> Boh, io mi ci sono messo sopra, ho provato a fare una str***ta
> qualunque, ma ho grossi problemi.
> Mi mancano proprio le basi-basi-basi :-)
Ma per esempio, cosa � che riesci a fare in
VB.NET
 e non in C# ?
ciao
Mauro


title: iniziare con C#

text:
Ciao Mauro,
....
>Ma per esempio, cosa è che riesci a fare in
VB.NET
 e non in C# ?
....
Beh, lasciamo stare VB, con quello non ho problemi...
Adesso non ricordo cosa stavo facendo in C# per provare, ma davvero un "ciao
mondo"... e non funzionava.
Sai, quei progettini che apri, metti su una classetta e poco altro.
Non entro nello specifico, anche perche', appunto, non mi ricordo; pero'
credo che un aiutino per iniziare a conoscere l'IDE C# mi serve.


title: iniziare con C#

author: Massimo

text:
"vbMizio" <
vbm...@io.it
> ha scritto nel messaggio
news:4d0a1604$0$6556$4faf...@reader4.news.tin.it...

Se ti puo' essere utile, per imparare  .....lo  Sharpdevelop
aveva un utility di conversione Vb.net  --- >  C#.
L'ho provato con alcuni piccoli progetti  è funzionava
abbastanza bene......
Ti fai il progettino
vb.net
   (tipo   label1.text=" ciao mondo")  lo
converti e vedi come funge


title: iniziare con C#

text:
Ciao Massimo e grazie per la risposta,
...
>Se ti puo' essere utile, per imparare  .....lo  Sharpdevelop
<aveva un utility di conversione Vb.net  --- >  C#.
...
Si si, lo conosco.
L'ho usato diverse volte per fare il contrario. In molti casi si trovano gli
esempi di codice scritti solo in C#, ed usavo questo tool per converitre gli
esempi da C# a VB.Net cosi' da averli in un modo per me piu' comprensibile.
Grazie ancora... Maurizio


title: Mocking di IQueryable

author: Giulio Petrucci

text:
Ciao a tutti,
prendendo spunto dall'idioma LET (Diritti riservati di Andrea :-p), ho
una interfaccia per un repository fatta così:
class Foo { ... } //entità;
interface IRepository<Foo>
{
	Add(Foo f);
	IQueryable<Foo> Query();
}
Ho un servizio di business in cui viene iniettato un mock del
repository. Questo servizio ha un metodo "Select()" che riceve in
ingresso un oggetto che rappresenta una query, questo viene interpretato
e tradotto in una serie di statement LINQ sull'istanza di
IQueryable<Foo> ritornata da IRepository<Foo>.Query(). Ora, mi chiedo,
come faccio a mockare l'istanza di IQueryable per intercettare tutti
quei begli extension methods?
Ciao e grazie,
Giulio
--


title: Come abortire un backgroundworker

author: marcosabba

text:
Ciao a tutti.
Sviluppando un editor/debugger javascript, mi sono trovato nella
necessità di lanciare un interprete javascript (Jint) durante l'editing
del codice. Siccome avevo avuto un'esperienza precedente con i
BackgroundWorker, ne ho sottoclassato uno per le mie esigenze,
sfruttando anche il fatto che le eccezioni del thread in background
(l'interprete) me le ritrovavo comodamente in
RunWorkerCompletedEventArgs dentro ad Error.
Però provando uno script con un loop infinito mi sono reso conto che
dovevo interrompere il thread dell'interprete ad ogni nuova pressione di
tasto, così ho cercato un modo per farlo.
Mamma google mi ha detto senza troppi giri di parole che un
backgroundworker va interrotto in modo "graceful" (CancelAsync) e non
con un Abort del thread, a causa del fatto che BackgroundWorker usa una
ThreadPool, e che comunque usare Abort non è mai una buona scelta.
Però nel mio caso non sono io a controllare l'esecuzione in background,
con cicli in qualche modo "controllabili" ad ogni passaggio, ma passo la
palla all'engine javascript che potrebbe avere un meccanismo di stop
oppure no (non ho controllato se Jint ce l'abbia, ma un giorno potrei
mettere v8 o spidermonkey, vorrei trattarlo come una blackbox), dunque
credo che l'abort abbia un senso.
Dunque mi sono buttato su una soluzione "ibrida" con BackgroundWorker +
Thread classico, scopiazzando un post su Stackoverflow ed aggiungendo il
rilancio delle eccezioni al BackgroundWorker che le cattura in Error:
var backgroundWorker = new BackgroundWorker(){WorkerSupportsCancellation
= true};
backgroundWorker.DoWork += (sender, args) =>
	{
		Exception workerException = null;
		var thisWorker = sender as BackgroundWorker;
		var _child = new Thread(() =>
                  	{
            			try
				{
					//..Do Some Code
				}
				catch (Exception ex)
				{
					workerException = ex;
				}
			});
		_child .Start();
		while (_child.IsAlive)
		{
			if (thisWorker.CancellationPending)
			{
				_child.Abort();
				args.Cancel = true;
			}
			Thread.SpinWait(1);
		}
                 if (workerException != null)
                     throw workerException;
	};
[...]
backgroundWorker.RunWorkerAsync(parameter);
  //..Do Something...
backgroundWorker.CancelAsync();
Vedete qualche controindicazione evidente alla cosa?
Sembra funzionare bene, ma con i thread non si sa mai...
Grazie e ciao


title: Come abortire un backgroundworker

author: Mauro Servienti [MVP]

text:
Ciao marcosabba,
You wrote on 09/03/2011 :
> Vedete qualche controindicazione evidente alla cosa?
non fare l'Abort del child thread, wrappa il child thread in una tua
classe che è quella che fa il lavoro "ricorsivo" e metti in piedi li un
meccanismo di "graceful exit"
.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: Come abortire un backgroundworker

text:
Il 10/03/2011 10:53, Mauro Servienti [MVP] ha scritto:
> non fare l'Abort del child thread, wrappa il child thread in una tua
> classe che è quella che fa il lavoro "ricorsivo" e metti in piedi li un
> meccanismo di "graceful exit"
capisco che sarebbe la cosa ideale, però il child thread in questione
non fa un lavoro ricorsivo o iterativo che controllo, in realtà fa una
cosa come questa:
result = _jEngine.Run(_script);
con _jEngine interprete javascript che non ha un metodo Abort o Stop
(nella fattispecie Jint, che può gestire un evento Break ma il punto di
break va impostato prima del Run).
Immagina che io stia scrivendo questo script nell'editor dimenticandomi
di scrivere "i++" (cosa comunque lecita):
function pippofun()
{
	var result = 0;
	var i = 0;

	for(i=0; i<1000;)
	{
		result++;
	}
	return result;
}
var pluto = pippofun()
ovviamente l'interprete va in loop infinito prima che possa aggiungere
"i++" nel for, perché viene lanciato ad ogni pressione di tasto, ed io
devo poterlo interrompere e far ripartire alla successiva pressione di
un tasto.
Ecco in sostanza la questione, sicuramente mi ero spiegato molto male (e
forse anche adesso, ma spero che tu mi abbia capito lo stesso).
Intanto grazie per la risposta.
Ciao


title: Come abortire un backgroundworker

text:
marcosabba wrote:
> ovviamente l'interprete va in loop infinito prima che possa aggiungere "i++"
> nel for, perché viene lanciato ad ogni pressione di tasto, ed io devo poterlo
> interrompere e far ripartire alla successiva pressione di un tasto.
> Ecco in sostanza la questione, sicuramente mi ero spiegato molto male (e
> forse anche adesso, ma spero che tu mi abbia capito lo stesso).
> Intanto grazie per la risposta.
> Ciao
La sostanza non cambia, l'importante è che dentro il loop ci sia il
controllo di una variabile booleana che provochi l'uscita dalla
funzione.
Abortire i thread implica la potenziale perdita di risorse ed è un
rimedio estremo a cui non bisognerebbe mai ricorrere.
--
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: Come abortire un backgroundworker

text:
Ciao Raf,
On 3/10/2011 12:17 PM, Raffaele Rialdi [MVP] wrote:
> La sostanza non cambia, l'importante è che dentro il loop ci sia il
> controllo di una variabile booleana che provochi l'uscita dalla funzione.
intervengo in quanto collega del buon sabba (e "visionatore" del codice).
La situazione è questa:
IComponenteEsterno ce = ...;
ce.Run();
il metodo 'ce.Run()' va richiamato internamente a un background worker.
Tale metodo può anche metterci svariati minuti e il componente esterno
non ha un altro metodo tipo 'Stop()' per fermare l'esecuzione di
'Run()'. Quindi niente loop, niente variabili di controllo, niente
gracefully exit (a meno che anche a me non sfugga qualcosa).  :-)
Ciao e grazie,
Giulio
--


title: Come abortire un backgroundworker

text:
Ciao Giulio,
You wrote on 10/03/2011 :
> il metodo 'ce.Run()' va richiamato internamente a un background worker. Tale
> metodo può anche metterci svariati minuti e il componente esterno non ha un
> altro metodo tipo 'Stop()' per fermare l'esecuzione di 'Run()'. Quindi niente
> loop, niente variabili di controllo, niente gracefully exit (a meno che anche
> a me non sfugga qualcosa).  :-)
credo di aver capito che l'unica è l'Abort.



title: Come abortire un backgroundworker

text:
Giulio Petrucci wrote:
> il metodo 'ce.Run()' va richiamato internamente a un background worker. Tale
> metodo può anche metterci svariati minuti e il componente esterno non ha un
> altro metodo tipo 'Stop()' per fermare l'esecuzione di 'Run()'. Quindi niente
> loop, niente variabili di controllo, niente gracefully exit (a meno che anche
> a me non sfugga qualcosa).  :-)
Beh è il componente esterno ad essere fatto male ... ;)
Di solito i componenti che impiegano molto tempo ad eseguire espongono
una callback/delegate che permette di interrompere l'operazione.
> Ciao e grazie,
> Giulio
Prego



title: Come abortire un backgroundworker

text:
Raffaele Rialdi [MVP] wrote:
> Beh è il componente esterno ad essere fatto male ... ;)
Giusto per chiarire, abortire il thread di quel componente può dare
grossi problemi.
Mettiamo ad esempio che faccia delle aperture di file o di oggetti
grafici o comunque qualsiasi altra cosa in cui viene aperto un handle.
Alla chiusura forzata del thread quelle risorse rimarranno "leaked" e a
lungo andare il processo dovrà necessariamente essere chiuso per
poterle chiudere e recuperarle.
