title: SQL Server 2012 Client App in VBNET

author: Attilio Tarabusi

text:
Ciao a tutti
ho realizzato una piccola applicazione Client Side che si occupa di
collegarsi ad un database remodo SQL Server 2012 alloggiato su un
server.

Ora dopo aver risolto tutti i problemi legati alla configurazione del
SQL server 2012, ho scritto la mia app che si collega e dialoga con il
server ricevendo, inserendo e modificando i dati.
Il mio problema ora è effettuare il deployment dell'applicativo. Sembra
funzionare solo sulla macchina di sviluppo.
Ho provato a installare nel pc client di destinazione diversi
compomenti come l'SQLCLI 2012 (che in teoria dovrebbe essere il driver
del client Sql server 2012) ma nulla da fare.
L'unica cosa che lo fa funzionare da un pc qualsiasi è installare
insieme alla app il pacchetto (assai grosso) di sql server management
studio 2012. Mi domando, ma è necessario? Esiste solo questo metodo?

Grazie per un suggerimento (in passato mi è capitato di fare la stessa
cosa con oracle ma non ricordo di aver dovuto installare tutto oracle
sul pc client).

Ciao!
Attilio

--
I'm trying a new usenet client for Mac, Nemo OS X, since 0 days.

You can download it at
http://www.malcom-mac.com/nemo


title: SQL Server 2012 Client App in VBNET

author: Mauro Servienti [MVP]

text:
Ciao Attilio,

You wrote on 13/01/2013 :
> Mi domando, ma è necessario?

no

> Esiste solo questo metodo?

Non direi proprio, è assai strano.
Una volta installato l'RDBMS comincia a provare a connetterti dalla tua
macchina con il management studio presente sulla tua macchina, che
errori hai?

.m

--
blog @ //
milestone.topics.it


title: SQL Server 2012 Client App in VBNET

author: Stefano Paparesta

text:
Ciao,
ma ricevi una eccezione, la puoi postare ?

Io di solito gli unici problemi che incontro, se non ho impostato bene sql server\sql server express sono legati alla configurazione delle porte e del firewall che mi bloccano la connessione, diversamente solitamente non ho problemi. Per cui se ottieni qualche errore e lo posti magari riusciamo a capire dove sta l'inghippo.

Stefano


title: Repository, specification, visitor e un abuso di Generics

author: Giulio Petrucci

text:
Ciao a tutti,

sto seguendo l'ispirazione (tutta teorica) di implementare una
interfaccia che possa definire il comportamento di un repository. La
situazione è questa:

1. definizione di entità e specification
public interface IEntity<TKey>
{
   TKey Key { get; }
}
public abstract class Entity<TKey> : IEntity<TKey>
{
   public TKey Key { get; private set; }
}
public interface ISpecification<T>
{
   bool IsSatisfiedBy(T item);
}

2. per ogni entità definisco una gerarchia di specification e un visitor
public class Foo : Entity<Int32>
{
   public Int32 Seed { get; set; }
}
public interface IFooSpecification : ISpecification<Foo>
{
   T Accept<T>(IFooSpecificationVisitor<T> visitor);
}
public class SeedNonZeroFooSpecification : IFooSpecification {
   public bool IsSatisfiedBy(Foo item) {
     return item.Seed != 0;
   }
   public T Accept<T>(IFooSpecificationVisitor<T> visitor)
   {
     return visitor.Visit(this);
   }
}
public interface IFooSpecificationVisitor<T> {
   T Visit(SeedNonZeroFooSpecification spec);
}

Ora, vorrei creare una interfaccia che implementata permetta di
generalizzare (tramite type arguments) quanto segue:

public interface IFooRepository
{
   Foo Get(Int32 key);
   void Add(Foo foo);
   IEnumerable<Foo> Select(IFooSpecification spec);
}

Per fare tutto ciò dovrei avere una cosa del genere:

public interface IRepository<TEntity, TKey, TSpecification>
   where TEntity : IEntity<TKey>
   where TSpecification : ISpecification<TEntity>
{
   TEntity Get(TKey key);
   void Add(TEntity entity);
   IEnumerable<TEntity> Select(TSpecification specification);
}
public class FooRepository : IRepository<Foo, Int32, IFooSpecification>
{
   public Foo Get(Int32 key) { ... }
   public void Add(Foo entity) { ...  }
   public IEnumerable<Foo> Select(IFooSpecification specification) { ... }
}

Domande. :-)
1. è possibile far capire al compilatore che visto che il primo type
argument è Foo, il secondo dovrà necessariamente essere Int32?
(risposta: No, ma tanto valeva chiedere)
2. tutto questo, onestamente, ha senso? :-)

Ciao e grazie,
Giulio

--


title: WPF e blendability: ma è possibile che si debba necessariamente "sporcare" il codice?

text:
Ciao a tutti,

sotto la supervisione dell'amico e collega marcosabba sto muovendo i
primi passi nel magico mondo di WPF. Sto sbattendo il muso con il
concetto di "blendability". Sia con MVVM Light [1] che con soluzioni
alternative [2] (ma che comunque sono una variazione sul tema), la
musica è sempre la stessa: bisogna "sporcare" il codice. La mia domanda
è la seguente: è possibile impostare il design data context con una
specie di IoC a design time?

Ciao e grazie,
Giulio
________________________________________
[1]
http://blog.galasoft.ch/archive/2011/09/25/detecting-design-mode-in-windows-8winrt.aspx

[2]
http://blog.roboblob.com/2010/01/17/wiring-up-view-and-viewmodel-in-mvvm-and-silverlight-4-blendability-included/


text:
Ciao Giulio,

You wrote on 28/10/2011 :
> Ciao a tutti,
>
> sotto la supervisione dell'amico e collega marcosabba sto muovendo i primi
> passi nel magico mondo di WPF. Sto sbattendo il muso con il concetto di
> "blendability". Sia con MVVM Light [1] che con soluzioni alternative [2] (ma
> che comunque sono una variazione sul tema), la musica è sempre la stessa:
> bisogna "sporcare" il codice. La mia domanda è la seguente: è possibile
> impostare il design data context con una specie di IoC a design time?

io non faccio nulla di tutto ciò, sono il solito bastian contrario e
proprio perchè sono un po' "talebano" su certe cose, prima di
"sporcare" il codice cerco di capire se una soluzione più bella (non
necessariamente più semplice) c'è, negli anni sono giunto a questo:

http://milestone.topics.it/blog/post/design-time-data-reloaded

(ad oggi è un po' diverso ed è disponibile su Radical)

Purtroppo funziona solo con wpf perchè ha il supporto per
ICustomPropertyDescriptor, sarà adattabile sicuramente a Silverlight 5
perché introduce un supporto simile.

il mio "workflow" ad oggi è una cosa del tipo:

diciamo che hai un view model del tipo:

class PersonViewModel : BaseBlaBlaBla..
{
    String FirstName;
    String LastName;

    ObservableCollection<AddressViewModel> Addresses;
}

class AddressViewModel : BaseBlaBlaBla..
{
   String Country;
}

la prima cosa da notare, a differenza del post di cui sopra, è che sono
classi concrete e non vi è traccia di "interfaccia", mentre al tempo
del post ero obbligato a definire anche i contratti dei view model
perchè il meccanismo funzionasse.

Dato quel modello posso definire una cose del tipo:

class dt_AddressVM : DesignTimeHost<AddressViewModel>
{
   public dt_AddressVM()
   {
       this.Expose( v => v.Country )
           .WithStaticValue( "Italia" );
   }
}

class dt_PersonVM : DesignTimeHost<PersonViewModel>
{
   public dt_PersonVM()
   {
       this.Expose( v => v.FirstName )
           .WithStaticValue( "Mauro" );

       this.Expose( v => v.Addresses )
           .WithDynamicValue( new ObservableCollection<dt_AddressVM>()
           {
               new DesignTimeAddressViewModel(),
               new DesignTimeAddressViewModel()
           } );
   }
}

a questo punto nello xaml lo puoi usare così, in un ipotetico elemento
grid:

<grid d:DataContext="{markup:DesignTimeDataHost Type=dt_PersonVM}" />

dove DesignTimeDataHost è una mia markup extension che altro non fa che
creare un'istanza del tipo "Type", e "d" fa parte del modello di
namespace(s) usato per i design time data:

xmlns:mc="
http://schemas.openxmlformats.org/markup-compatibility/2006
"
xmlns:d="
http://schemas.microsoft.com/expression/blend/2008
"
mc:Ignorable="d"

cosa c'è di interessante da notare?

- DesignTimeHost<T> non è che faccia poi cose turche, si limita a
sfruttare il fatto che il motore di data binding è un credulone e se
gli dici che una proprietà c'è lui si fida di te :-), quindi implementa
ICustomPropertyDescriptor e ti espone nel costruttore un sistema per
creare proprietà, l'uso dei generics ti consente di sfruttare
l'intellisense, ma si potrebbe anche giocare facendo comparire cose che
proprio non esistono.

- ci sono svariati metodi With****Value per esporre i valori a design
time, lo static value è type safe quindi se esponi Country che è di
tipo string il valore deve essere string, mentre avrai notato
WithDynamicValue che viola palesemente la type-safaty perchè
ObservableCollection<dt_AddressVM> non è
ObservableCollection<AddressViewModel>...eppure funziona...e luce sia
:-)

il tutto, proprio perchè usa ICustomPropertyDescriptor funziona sia con
il fx 3.5 che con il 4.x, sto pensando di farne una versione ad hoc per
il 4.x che sfrutti ExpandoObject (e quindi la possibilità di fare
binding con "dynamic") perchè semplificherebbe le cose internamente e
aprirebbe interessanti scenari :-)

Io lo uso da molto tempo, se lo volete testare:
http://nuget.org/List/Packages/Radical.Design

Mi piacerebbe avere feedback, okkio che è una v0.9.0 quindi l'API
pubblica non è stabile, ci sono alunce cose che non mi piacciono molto
ma si potrebbe fare qualche test insieme per giungere rapidamente ad
una v1.0

Suggerimenti sono sempre ben accetti :-)

Domani in giro per Lucca vedrò di identificarti :-P

.m

--
Mauro Servienti
{C67C0157-5D98-4733-A75E-93CAEE4BADC8}
Microsoft MVP - Visual C# / MCTS
http://mvp.support.microsoft.com/profile/mauro

blog @
http://milestone.topics.it

whynot [ at ] topics [ dot ] it


text:
Ciao Mauro,

On 29/10/2011 09:32, Mauro Servienti [MVP] wrote:
> cosa c'è di interessante da notare?
[cut]

Ho fatto il checkout del codice (revisione 69993) e sto dando uno
sguardo. Grazie anche alla tua descrizione tutto è chiarissimo (e sai
bene che per me è davvero un evento :-)). Ora però, c'è un problema: il
metodo .Expose() usato in DesignTimeHost non lo trovo da nessuna parte
(ho anche fatto un grep su tutto il codice di radical, ma niente). Anche
se dal nome è *STRACHIARO* come funzioni e a cosa serva, puoi darmi
qualche riferimento?

> il tutto, proprio perchè usa ICustomPropertyDescriptor funziona sia con
> il fx 3.5 che con il 4.x, sto pensando di farne una versione ad hoc per
> il 4.x che sfrutti ExpandoObject (e quindi la possibilità di fare
> binding con "dynamic") perchè semplificherebbe le cose internamente e
> aprirebbe interessanti scenari :-)

Sì, questa sarebbe una prospettiva decisamente interessante. :-)

> Mi piacerebbe avere feedback, okkio che è una v0.9.0 quindi l'API
> pubblica non è stabile, ci sono alunce cose che non mi piacciono molto
> ma si potrebbe fare qualche test insieme per giungere rapidamente ad una
> v1.0
> Suggerimenti sono sempre ben accetti :-)

Ok, ci gioco un po' e ti dico.
Il problema più immediato è che Radical è una soluzione decisamente
complessa per il tipo di problemi che affrontiamo e soprattutto è al di
sopra delle nostre skill da programmatori. Niente però ci vieta di
poterne ricavare qualcosa di buono. :-)

> Domani in giro per Lucca vedrò di identificarti :-P

Non ci siamo beccati. :-(
Va be', vediamo di organizzarci per il prossimo anno.
Per me era la prima volta a Lucca Comics: è una cosa incredibile!!! Io
sono andato principalmente per l'aspetto musicale (ossìa per il concerto
di Vince Tempera sulla Goldrake Generation) ma anche tutto il resto è
davvero spettacolare!!!

Ciao,
Giulio


text:
Ciao Mauro,

On 31/10/2011 10:06, Giulio Petrucci wrote:
>  Ora però, c'è un problema: il
> metodo .Expose() usato in DesignTimeHost non lo trovo da nessuna parte

rettifico: era proprio lì!
(Mia nonna direbbe: "ah, Santa Lucia...")

Ciao,
Giulio

--


text:
Ciao Mauro,

dopo due giorni di scorribande sulla code base di Radical.Design credo
di potermi esprimere con un minimo di cognizione di causa. :-)

On 29/10/2011 09:32, Mauro Servienti [MVP] wrote:
> - ci sono svariati metodi With****Value per esporre i valori a design
> time, lo static value è type safe quindi se esponi Country che è di tipo
> string il valore deve essere string, mentre avrai notato
> WithDynamicValue che viola palesemente la type-safaty perchè
> ObservableCollection<dt_AddressVM> non è
> ObservableCollection<AddressViewModel>...eppure funziona...e luce sia :-)

Uhm... la domanda opportuna sarebbe: "perché?" :-)
In generale, hai qualche link su cui poter studiare come funziona
"dietro le quinte" il motore di binding di WPF (che dovrebbe essere lo
stesso a design-time e run-time)?

> Mi piacerebbe avere feedback, okkio che è una v0.9.0 quindi l'API
> pubblica non è stabile, ci sono alunce cose che non mi piacciono molto
> ma si potrebbe fare qualche test insieme per giungere rapidamente ad una
> v1.0
> Suggerimenti sono sempre ben accetti :-)

Sto elaborando qualche suggerimento.
Posto qui o mando in PVT?

Ciao,
Giulio

--


text:
Ri-ciao,

On 29/10/2011 09:32, Mauro Servienti [MVP] wrote:
> - ci sono svariati metodi With****Value per esporre i valori a design
> time, lo static value è type safe quindi se esponi Country che è di tipo
> string il valore deve essere string, mentre avrai notato
> WithDynamicValue che viola palesemente la type-safaty perchè
> ObservableCollection<dt_AddressVM> non è
> ObservableCollection<AddressViewModel>...eppure funziona...e luce sia :-)

OK, credo di esserci arrivato: quando la collection viene bindata, il
motore di binding ripete la trafila, pertanto trovando dei
DesignTimeHost<AddressViewModel> succede quello che è successo con
l'oggetto "padre". Giusto?

Ciao,
Giulio

--


text:
Ciao Giulio,

You wrote on 02/11/2011 :
> OK, credo di esserci arrivato: quando la collection viene bindata, il motore
> di binding ripete la trafila, pertanto trovando dei
> DesignTimeHost<AddressViewModel> succede quello che è successo con l'oggetto
> "padre". Giusto?

yes :-)



text:
Ciao Giulio,

You wrote on 02/11/2011 :
> Uhm... la domanda opportuna sarebbe: "perché?" :-)

perchè se implementi ICustomTypeDescriptor il motore di databinding
viene sempre a chiedere a te come è la struttura del tipo e non prova a
scoprirlo da solo.

>> Mi piacerebbe avere feedback, okkio che è una v0.9.0 quindi l'API
>> pubblica non è stabile, ci sono alunce cose che non mi piacciono molto
>> ma si potrebbe fare qualche test insieme per giungere rapidamente ad una
>> v1.0
>> Suggerimenti sono sempre ben accetti :-)
>
> Sto elaborando qualche suggerimento.
> Posto qui o mando in PVT?

come preferisci, o qui oppure mauro [ at ] topics [ dot ] it

> Ciao,
> Giulio



text:
Ciao Giulio,

You wrote on 31/10/2011 :
> Ho fatto il checkout del codice (revisione 69993) e sto dando uno sguardo.

i sorgenti di Radical sono decisamente outdated, perchè per ora ho
tutto sulla preview di tfs di Azure, per i binari usa il package su
nuget. I sorgenti della parte di design invece sono solo un po'
outdated perchè ho fatto solo un po' di "polishing"

> Ok, ci gioco un po' e ti dico.
> Il problema più immediato è che Radical è una soluzione decisamente complessa
> per il tipo di problemi che affrontiamo e soprattutto è al di sopra delle
> nostre skill da programmatori. Niente però ci vieta di poterne ricavare
> qualcosa di buono. :-)

di Radical in Radical.Design viene utilizzata solo la classe "Entity"
come classe base per il DesignTimeHost, il resto lo puoi
tranquillamente ignorare.

> Va be', vediamo di organizzarci per il prossimo anno.
> Per me era la prima volta a Lucca Comics: è una cosa incredibile!!! Io sono
> andato principalmente per l'aspetto musicale (ossìa per il concerto di Vince
> Tempera sulla Goldrake Generation) ma anche tutto il resto è davvero
> spettacolare!!!

:-)



text:
Ciao Mauro,

On 02/11/2011 13:35, Mauro Servienti [MVP] wrote:
> come preferisci, o qui oppure mauro [ at ] topics [ dot ] it

Preferisco qui.
Sarà OT?

Ciao,
Giulio

--


text:
Ciao Giulio,

You wrote on 02/11/2011 :
> Ciao Mauro,
>
> On 02/11/2011 13:35, Mauro Servienti [MVP] wrote:
>> come preferisci, o qui oppure mauro [ at ] topics [ dot ] it
>
> Preferisco qui.
> Sarà OT?

proseguiemo sul thread, la blendability è argomento in topic, magari
l'implementazione specifica no, ma può far comodo a tutti. C'è sempre
l'ignore-thread :-)



text:
Ciao Mauro,

On 29/10/2011 09:32, Mauro Servienti [MVP] wrote:
> - ci sono svariati metodi With****Value per esporre i valori a design
> time, lo static value è type safe quindi se esponi Country che è di tipo
> string il valore deve essere string, mentre avrai notato
> WithDynamicValue che viola palesemente la type-safaty perchè
> ObservableCollection<dt_AddressVM> non è
> ObservableCollection<AddressViewModel>...eppure funziona...e luce sia :-)

Come ti dicevo in precedenza, sto leggendo molto il codice (lo trovo un
esercizio molto utile per migliorare lo stile, e inoltre mi viene più
facile che leggere la doc delle API... :-)) per darti qualche feedback.

Intanto comincio con questo: ho qualche problema a capire come funziona
e a cosa serva il metodo ITropertyBuilder<T>.WithLiveValue(...), e
adesso cerco anche di spiegare perché.

1. (osservazione dovuta solo alla lettura del codice) se al momento
dell'invocazione del metodo in questione il membro this.property è NULL,
questo viene passato al .ctor() di LiveDesignTimeProperty, che lo passa
a quello di DesignTimeProperty<T, TValue> che lo passa a quello di
DesignTimeTimeProperty che passa sourceProperty.Name... ma se la
property iniziale è NULL, questo solleva una NullRefException, giusto?
E' voluto?

2. (sempre leggendo il codice) nel costruttore di una
LiveDesignTimeProperty viene creato un PropetyChangedMonitor<T> (dove T
nel nostro caso è DesignTimeHost<TViewModel>), in cui si imposta di
osservare la property espressa nell'argomento "liveValueProperty" e si
imposta la callback con una  lambda (su facebook avrei messo un <3 :-))
che altro non fa che sollevare il metodo RaisePropertyChanged(...) di
DesignTimeHost<T>. Il "cosa" è abbastanza chiaro, ma mi restano dei
punti oscuri sul "come" e sul "perché". :-)

2.1. perché imporre come signature alla callback Action<T, String> e non
semplicemente Action() visto che nel costruttore di
LiveDesignTimeProperty realizzi già una closure sugli oggetti che ti
servono e i parametri attuali della callback non vengono usati?

2.2 non mi è chiaro come si sposano il discorso del monitor e quello del
property descriptor. In poche parole, nel .ctor() di
LiveDesignTimePropetry() succede questo:
- creo un observer per l'host
- impongo di osservare una property
- nella callback dico di richiamare il metodo RaisePropertyChanged() di
host (che a sua volta richiamerà quello di Entity, ecc ecc...)
Quando viene scatenato tutto l'ambaradam? In che punto del codice? In
che scenario? E' possibile avere una cosa del genere a design-time o è
qualcosa che serve solo se si usa DesignTimeHost<T> come datacontext di
runtime (cosa che magari può essere assai utile per fare le prove...)?

Grazie,
Giulio

p.s. ...e che non si dica che non ho studiato! :-P
--


text:
Ciao Giulio,

You wrote on 04/11/2011 :
> Ciao Mauro,
>
> On 29/10/2011 09:32, Mauro Servienti [MVP] wrote:
>> - ci sono svariati metodi With****Value per esporre i valori a design
>> time, lo static value è type safe quindi se esponi Country che è di tipo
>> string il valore deve essere string, mentre avrai notato
>> WithDynamicValue che viola palesemente la type-safaty perchè
>> ObservableCollection<dt_AddressVM> non è
>> ObservableCollection<AddressViewModel>...eppure funziona...e luce sia :-)
>
> Come ti dicevo in precedenza, sto leggendo molto il codice (lo trovo un
> esercizio molto utile per migliorare lo stile, e inoltre mi viene più facile
> che leggere la doc delle API... :-)) per darti qualche feedback.
>
> Intanto comincio con questo: ho qualche problema a capire come funziona e a
> cosa serva il metodo ITropertyBuilder<T>.WithLiveValue(...), e adesso cerco
> anche di spiegare perché.

"Live-Value" serve per permettere all'omino che usa il designer di
cambiare i valori delle proprietà direttamente dal designer, immagina
un view model che espone una proprietà bool in sola lettura sulla base
della quale la view cambia comportamente, magari con un trigger o con
il visual state manager, è abbastanza ovvio che il designer voglia
poter visualizzare a design time la view in tutti gli stati possibili.
Ergo gli viene prodotto un DesignTimeHost che espone una proprietà che
trigghera live direttamente a design time il valore della proprietà
bool in sola lettura e visual studio ti viene dietro che è un piacere
:-)

In realtà se spulci a fondo il codice scopri che tutto alla fine
funziona allo stesso modo sotto sotto, sono solo i builder che ad alto
livello espongono dei comportamenti diversi, e l'unico scopo è quello
di esplicitare visivamente nel codice quello che vuoi ottenere. Nulla
di più si potrebbe ottenere lo stesso risualtato con un solo metodo ma
sarebbe tutto tranne che auto-esplicativo.

> 1. (osservazione dovuta solo alla lettura del codice) se al momento
> dell'invocazione del metodo in questione il membro this.property è NULL,
> questo viene passato al .ctor() di LiveDesignTimeProperty, che lo passa a
> quello di DesignTimeProperty<T, TValue> che lo passa a quello di
> DesignTimeTimeProperty che passa sourceProperty.Name... ma se la property
> iniziale è NULL, questo solleva una NullRefException, giusto? E' voluto?

quasi certamente è un bug, ma la domanda è perché dovrebbe essere null?
Comunque ci guardo.

> 2. (sempre leggendo il codice) nel costruttore di una LiveDesignTimeProperty
> viene creato un PropetyChangedMonitor<T> (dove T nel nostro caso è
> DesignTimeHost<TViewModel>), in cui si imposta di osservare la property
> espressa nell'argomento "liveValueProperty" e si imposta la callback con una
> lambda (su facebook avrei messo un <3 :-)) che altro non fa che sollevare il
> metodo RaisePropertyChanged(...) di DesignTimeHost<T>. Il "cosa" è abbastanza
> chiaro, ma mi restano dei punti oscuri sul "come" e sul "perché". :-)

dunque.
il giochetto è questo, hai un view model che è in binding a disgn time
dentro visual studio (o blend poco importa) il funzionamento è molto
simile a quello che avresti a runtime quindi siccome il tuo view model
è INotifyPropertyChanged il buon visual studio reagisce alle notifiche.
Quindi, scenario di prima, view model InvoiceViewModel che espone una
proprietà bool IsPayed, la view deve visualizzare cose diverse se
IsPayed è true o false.
Ottimo, se non avessi le LiveDesignTimeProperty sei obbligato a
definire nelle risorse 2 diversi "DesignTimeViewMode" che puntano a due
classi diverse ognuna che espone un diverso valore di IsPayed.
Usando le LiveDesignTimeProperty puoi fare questo

class DesignInvoiceViewModel : DesignTimeHost<InvoiceViewModel>
{
   public DesignInvoiceViewModel()
   {
      this.Expose( v => v.IsPayed )
	      .WithLiveValue( () => this.dt_IsPayed );
   }

   public bool dt_IsPayed
   {
       get { return this.GetPropertyValue( () => this.dt_IsPayed ); }
	   set { this.SetPropertyValue( () => this.dt_IsPayed, value ); }
   }
}

e nalle view fai una cosa del tipo:

<UserControl.Resources>
	<local:DesignInvoiceViewModel x:Key="dtd" dt_IsPayed="True" />
</UserControl.Resources>
	<Grid d:DataContext="{StaticResource ResourceKey=dtd}">
<...

se adesso con il designer aperto cambi nelle risorse il valore di
dt_IsPayed quello che succede è che la LiveDesignTimeProperty se ne
accorde, dice al DesignTimeHost che la proprietà IsPayed è cambiata,
anche se in realtà è cambiata dt_IsPayed, visyal studio torna a
chiederti il valore di IsPayed e la LiveDesignTimeProperty invoca il
delegato compilato della lambda ritornando il nuovo valore di
dt_IsPayed...cervellotico? si :-) ma alla fine con una semplicità
disarmente ti permette di fare a design time cose turche...perchè prova
a immaginare se nel costruttore del tuo DesignInvoiceViewModel metti un
DispatcherTime che ogni x secondi cambia alcuni volori? immaginati
adesso che quello che stai disegndo è un robo che visualizza uno stream
di informazioni tipo quelle che arrivano dai servizi di adn kronos? :-)
ecco che a design time hai un coso vivo che simula perfettamente quello
che succede a runtime ;-P

> 2.1. perché imporre come signature alla callback Action<T, String> e non
> semplicemente Action() visto che nel costruttore di LiveDesignTimeProperty
> realizzi già una closure sugli oggetti che ti servono e i parametri attuali
> della callback non vengono usati?

sempre e solo per avere il supporto dell'intellisense e un check a
compile time.

> 2.2 non mi è chiaro come si sposano il discorso del monitor e quello del
> property descriptor. In poche parole, nel .ctor() di LiveDesignTimePropetry()
> succede questo:
> - creo un observer per l'host
> - impongo di osservare una property
> - nella callback dico di richiamare il metodo RaisePropertyChanged() di host
> (che a sua volta richiamerà quello di Entity, ecc ecc...)
> Quando viene scatenato tutto l'ambaradam? In che punto del codice? In che
> scenario? E' possibile avere una cosa del genere a design-time o è qualcosa
> che serve solo se si usa DesignTimeHost<T> come datacontext di runtime (cosa
> che magari può essere assai utile per fare le prove...)?

vedi sopra :-) il tutto funziona solo a DesignTime ma il property
observer, così come tutto ciò che in Radical implementa IMonitor è
fatto principalmente per essere usato a runtime. Lo scenario in cui lo
uso di più sono i delegate command.

> Grazie,
> Giulio
>
> p.s. ...e che non si dica che non ho studiato! :-P

:-)



text:
> quasi certamente è un bug, ma la domanda è perché dovrebbe essere null?
> Comunque ci guardo.

ho dato una rapida occhiata, non può essere null, mai, riesci a farmi
un esempio in cui secondo te può essere null?

Tieni inoltre presente che l'obiettivo di DesignTimeHost non è quello
di proteggere lo sviluppatore, quindi pochi fronzoli e pochi controlli,
è qualcosa che non finirà mai in produzione deve solo semplificare la
vita del designer.



text:
Ciao Mauro,

On 05/11/2011 10:20, Mauro Servienti [MVP] wrote:
> "Live-Value" serve per permettere all'omino che usa il designer di
> cambiare i valori delle proprietà direttamente dal designer,
[cut]

Ok, avevo intuito. :-) Ora vedo di fare qualche prova per capire meglio
come funziona.

> quasi certamente è un bug, ma la domanda è perché dovrebbe essere null?

Perché non viene inizializzato (mi pare).

> il giochetto è questo,
[cut]
> ecco che a design time hai un coso vivo che simula perfettamente quello
> che succede a runtime ;-P

Ok, strabello. :-)

> sempre e solo per avere il supporto dell'intellisense e un check a
> compile time.

Questa non l'ho capita.
:-)

Grazie e buona giornata/settimana,
Giulio

--


text:
Ciao Giulio,

You wrote on 07/11/2011 :
>> quasi certamente è un bug, ma la domanda è perché dovrebbe essere null?
>
> Perché non viene inizializzato (mi pare).

sono tutte lambda expression, a meno che non gli passi espliticamente
null non possono essere null.

>> sempre e solo per avere il supporto dell'intellisense e un check a
>> compile time.
>
> Questa non l'ho capita.
> :-)

mi sono perso, posso goicare il jolly di quello con l'influenza e mi
rifai la domanda? :-)

> Grazie e buona giornata/settimana,

altrettanto, non tio dico che delirio è Milano oggi con sciopero dei
mezzi e pioggia battente... :-S

> Giulio



title: Cross-thread operation

text:
Ciao a tutti,
ho acuistato un componente per gestire connessioni via FTP. Prezzo interessante, avevo fatto qualche prova prima di acuistarlo e tutto ciò che avevo provato fuzìnzionava. Oggi stavo tendando di utilizzare un evento generato dal componente che in pratica viene scatenato durante l'upload o il download del file.
Ho creato una semplice solution winforms e ho gestito l'evento.
Ovviamente se dall'interno del metodo dell'evento gli faccio scrivere qualcosa sulla UI, genera la Cross-thread operation exception.
Niente di strano, provo a gestirla con diversi metodi, ma tutti non sortiscono l'effetto desiderato.
La cosa che ho notato è che se scrivo una cosa del genere

void client_Progress(object sender, ProgressEventArgs e)
            {

            Console.WriteLine(e.TotalBytesTransferred.ToString());
            //ThreadSafeFunction(e.TotalBytesTransferred);
            this.BeginInvoke((MethodInvoker)(() =>
            {
                lblInfo.Text = e.TotalBytesTransferred.ToString();
            }));
            }
Lui cosa fa, effettua l'upload e con il prim writeline mi scrive nella console i dati, quando termina l'upload mi scrive nella label uno dietro l'altro i dati dentro BeginInvoke.
Se sostituisco la begininvoke con invoke il programma si blocca e non fa nenanche l'upload.
Avete qualche suggerimento da darmi ?
Stefano


title: Cross-thread operation

author: LudovicoVan

text:
"Stefano Paparesta" <
paparest...@gmail.com
> wrote in message
news:e126ac13-0782-44eb...@googlegroups.com...
<snip>

> Ovviamente se dall'interno del metodo dell'evento gli faccio scrivere
> qualcosa sulla UI, genera la Cross-thread operation exception.
> Niente di strano, provo a gestirla con diversi metodi, ma tutti non
> sortiscono l'effetto desiderato.

Io ho usato qualcosa del genere senza problemi:

Private Sub MyObj_Changed(ByVal sender As Object, ByVal e As EventArgs)
Handles MyObj.Changed
    If Me.InvokeRequired Then
        Me.Invoke(Sub() MyObj_Changed(sender, e))
        Return
    End If

    ... do something ...
End Sub

Praticamente, quando l'InvokeRequired e' true, l'handler fa l'Invoke di
stesso, altrimenti procede come normale...

HTH,

-LV


title: Cross-thread operation

text:
Grazie Ludovico,
avevo provato anche quello ma non ottenevo il risultato sperato. Adesso il produttore del componente mi ha mandato un pezzo di codice che non fa altro che far partire un thread nuovo in cui fa l'upload e con il codice che ho postato all'inizio funziona. Ahimè mi sa che questo componente non gestisce molto bene ithread
Stefano


title: Click mouse via programma

author: roby

text:
Salve a tutti.
Io ho questo problema:
divrei mandare un click in una posizione voluta di una qualunque finestra,
anche di terze parti, posta ad icona o comunque che non ha il focus.
Quindi senza spostare il mouse e cliccare (come un automouse).

Qualcuno puņ aiutarmi?
Una postmessage č la soluzione?

Saluti e grazie


title: Click mouse via programma

author: Mirco Manta

text:
via api di windows funziona con postmessage, via
dot.net
 non so se cè qlc.
del genere al max importi il postmessage delle api e lo usi

"roby"  ha scritto nel messaggio
news:4fb4ef71$0$1393$4faf...@reader1.news.tin.it...

Salve a tutti.
Io ho questo problema:
divrei mandare un click in una posizione voluta di una qualunque finestra,
anche di terze parti, posta ad icona o comunque che non ha il focus.
Quindi senza spostare il mouse e cliccare (come un automouse).

Qualcuno può aiutarmi?
Una postmessage è la soluzione?

Saluti e grazie


title: Click mouse via programma

author: ermes

text:
Grazie!
"Mirco Manta" <
mirco...@alice.it
> ha scritto nel messaggio
news:4fb530a8$0$1391$4faf...@reader1.news.tin.it...



title: Creare form (e controlli) a runtime

text:
Dunque ... ho le vertigini per quanto è dinamico
VB.NET

rispetto al VB6.
Ma, si sa, più uno lo nutri, più appetito je viene.
Allora avevo la necessità di invocare una specie di
miniwizard (MODAL non MODELESS) associato alla pressione di
un bottone da parte di un form chiamante.
Ho creato via codice (ragazzi che potenza !) un form, l'ho
riempito di text box e bottoni (con nome stringa), collegati
a variabili shared withevents, e poi ho scritto a mano il
gestore di eventi.
Ma mi sono accorto che poi il mio form creato da zero, al
pari delle variabili di tipo classe e structure che di norma
possono essere dichiarate nelle istanze a compile-time, con
Dim etc, aveva la necessità di ospitare dentro almeno un
oggetto contenitore di tipo non nativo.
Mi son reso conto di non saperlo dichiarare (non esiste
alcun ambito nell'editor associato a quel generico form, che
non ha nome, ma è As windows.forms.
Per adesso ho messo una pezza poco elegante, agganciando
alla proprietà TAG (che ha tipo oggetto generico) la mia
variabile di classe tipizzata. (con ciò mi son giocato
l'associazione anticipata e il controllo at compile time
ovviamente).
Sempre a mano, nel gestore di eventi del bottone creato del
form creato, faccio un altrettanto bruttino CType della
property generica TAG (l'unico gancio che ho escogitato) al
tipo classe agganciato altrove.
E' chiaro che è fragilina sta roba. Se ci agganciassi altro
per errore, sarebbe un crash.
Allora domanda : si possono associare, con tanto della loro
tipizzazione anticipata, variabili arbitrarie (locali o
globali, fate voi) alla variabile di istanza di un form
creato dinamicamente ?
Non ho veramente idea se chiedo una cosa strana, ovvia, o
demenziale.
Grazie in anticipo ai gurus :)
ciao
Soviet


title: Creare form (e controlli) a runtime

text:
On Mar 15, 5:42 pm, Soviet_Mario <Soviet.Ma...@CCCP.MIR> wrote:
> Allora domanda : si possono associare, con tanto della loro
> tipizzazione anticipata, variabili arbitrarie (locali o
> globali, fate voi) alla variabile di istanza di un form
> creato dinamicamente ?
> Non ho veramente idea se chiedo una cosa strana, ovvia, o
> demenziale.
Ti confesso che non mi e' facile capire di cosa stai parlando... fra
l'altro assumo che la tecnologia e' WinForms, ma sarebbe bene che tu
fossi esplicito nei tuoi quesiti sia sulla tecnollgia a cui ti
riferisci sia qual e' la versione del framework. Cio' premesso:
Se intendi che il form e' creato completamente via codice, la prima
cosa che mi verrebbe da suggerirti e' di avere invece un form a design-
time a cui solo i controlli sono aggiunti a run-time. In questo modo
hai il contesto in cui scrivere tutto il codice che vuoi...
-LV


title: Creare form (e controlli) a runtime

text:
Il 16/03/2011 17:15, LudovicoVan ha scritto:
> On Mar 15, 5:42 pm, Soviet_Mario<Soviet.Ma...@CCCP.MIR>  wrote:
>
>> Allora domanda : si possono associare, con tanto della loro
>> tipizzazione anticipata, variabili arbitrarie (locali o
>> globali, fate voi) alla variabile di istanza di un form
>> creato dinamicamente ?
>> Non ho veramente idea se chiedo una cosa strana, ovvia, o
>> demenziale.
>
> Ti confesso che non mi e' facile capire di cosa stai parlando...
:-( Lo so ... accidenti a me. Non so come riesco a far
girare il codice, senza manco essere consapevole di nulla
del dietro le quinte. Non lo so che tecnologia è ... L'IDE
le chiama SOLUZIONI (.SLN, .SUO), e contengono
"windows.forms" (nel namespace windows), che sono classi.
I programmi non sono per il web, ma standalone. Basta ? boh ...
> fra
> l'altro assumo che la tecnologia e' WinForms, ma sarebbe bene che tu
per assonanza direi di si ... non so dove dovrei leggerlo e
manco come scegliere se si o se no.
> fossi esplicito nei tuoi quesiti sia sulla tecnollgia a cui ti
> riferisci sia qual e' la versione del framework. Cio' premesso:
la versione posso dirla, è la 3.5 (uso il 2008). Il 2010
l'ho scaricato, ma per oscure ragioni non mi lascia usare il
titanico MSDN OFFLINE che ho scaricato, e mi apre firefox !
(minuti di attesa) per consultare una voce di help,
nonostante ho tentato a settare ricerca solo offline (e
questa cosa non la ingoio proprio)
>
> Se intendi che il form e' creato completamente via codice, la prima
> cosa che mi verrebbe da suggerirti e' di avere invece un form a design-
> time a cui solo i controlli sono aggiunti a run-time. In questo modo
> hai il contesto in cui scrivere tutto il codice che vuoi...
Per giove ... sarà ovvio, ma non ci avevo mica pensato. E'
estremamente ragionevole. Credo che farò proprio come dici.
Cmq, integrando la domanda : c'è qualche modo per aggiungere
proprietà a un form a RUN TIME ?
Intendo essenzialmente variabili (dati) e non tanto metodi.
Agganciare dei gestori credo si possa (non ricordo bene ...
forse addhandler ? o qualcosa di simile). Ma nell'aggiungere
membri dati a runtime (a prescindere se il form esista a
compile time o meno) non l'ho saputo fare. Ecco ora forse ho
un po' circoscritto il nocciolo.
Un titolo migliore era : aggiungere properties a runtime ai
forms
ciao e grazie del consiglio, che cmq mi risolve a priori il
problema specifico
Soviet
>
> -LV


title: Creare form (e controlli) a runtime

text:
On Mar 17, 6:13 pm, Soviet_Mario <Soviet.Ma...@CCCP.MIR> wrote:
> Non so come riesco a far
> girare il codice, senza manco essere consapevole di nulla
> del dietro le quinte.
Non ti preoccupare: il mondo .Net e' davvero ampio, quindi ti
consiglierei di portare un po' di pazienza e soprattutto di fare
riferimento alla documentazione ogni volta che qualcosa non ti e'
completamente chiaro (ovviamente nei limiti del ragionevole e dei
vincoli sui tempi). Vedrai che con un approccio attento in breve
comincerai ad orientarti e perlomeno a padroneggiare quegli ambiti che
ti sono immediatamente di interesse. Dopodiche' la parte davvero
difficile sara' passata...
Intanto un link a Wikipedia che puo' darti una rapida panoramica
generale:
http://en.wikipedia.org/wiki/.NET_Framework
> Non lo so che tecnologia è ... L'IDE le chiama SOLUZIONI (.SLN, .SUO)
Tutti i file delle solution .Net hanno estensione .sln (e relativo
file .suo, che contiene le impostazioni specifiche relative al tuo
ide... se non sbaglio), non e' li la differenza.
> , e contengono
> "windows.forms" (nel namespace windows), che sono classi.
> I programmi non sono per il web, ma standalone. Basta ? boh ...
OK, direi che senza dubbio e' Windows Forms, o WinForms in breve.
> la versione posso dirla, è la 3.5 (uso il 2008). Il 2010
> l'ho scaricato, ma per oscure ragioni non mi lascia usare il
> titanico MSDN OFFLINE che ho scaricato
Perche' se usi la versione express il sistema di help e' completamente
cambiato e se non sbaglio avere l'help in locale non e' proprio piu'
possibile (o forse e' possibile avere solo alcune porzioni dell'help,
da scaricare via via: d'acchitto non ricordo i dettagli).
> , e mi apre firefox !
> (minuti di attesa) per consultare una voce di help,
Colpa della connessione direi, perche' il sito MSDN di suo non e'
lento, non di solito.
> Cmq, integrando la domanda : c'è qualche modo per aggiungere
> proprietà a un form a RUN TIME ?
> Intendo essenzialmente variabili (dati) e non tanto metodi.
Direi proprio di no (a meno di non impelagarti in cose molto piu'
complesse tipo la generazione dinamica di assembly...). D'altra parte,
per esempio, nello stesso contesto in cui crei il form in questione
puoi avere proprieta' o comunque membri che siano pubblici e quindi
accessibili dal form appena creato. Nota che questi non devono essere
necessariamente statici: puoi usare uno degli overload di Show o
ShowModal che ti consentono di passare un riferimento all'owner...
Comunque non uso WinForms da parecchio e da ancora meno mi e' capitato
di creare form e controlli dinamicamente: ci potrebbero essere
approcci migliori, o piu' snelli, o semplicemente meglio tagliati
sulle tue specifiche esigenza... La regola generale pero' e' sempre la
stessa: keep it simple (as simple as possible).
In bocca al lupo,
-LV


title: Creare form (e controlli) a runtime

text:
Il 17/03/2011 20:12, LudovicoVan ha scritto:
> On Mar 17, 6:13 pm, Soviet_Mario<Soviet.Ma...@CCCP.MIR>  wrote:
CUT
> Direi proprio di no (a meno di non impelagarti in cose molto piu'
> complesse tipo la generazione dinamica di assembly...).
no no, non fa per me.
> D'altra parte,
> per esempio, nello stesso contesto in cui crei il form in questione
> puoi avere proprieta' o comunque membri che siano pubblici e quindi
> accessibili dal form appena creato. Nota che questi non devono essere
> necessariamente statici: puoi usare uno degli overload di Show o
> ShowModal che ti consentono di passare un riferimento all'owner...
Ecco : mi hai dato un altro spunto grandioso.
PErché possedere dati, se fosse possibile INTERROGARE dati
presenti nel form chiamante ?
Dopotutto questi diamine di dati, mi servono solo da
caricare dal chiamante e scaricarli (optavo per delle
reference confidando, blandamente, che non facesse una copia
fisica, ma se potesse attingere all'istanza genuina del
chiamante, che ha tutti i dati da copiare, sarebbe tanto
meglio ancora). Indagherò !
ciao e grassie
Soviet



title: Creare form (e controlli) a runtime

text:
Il 17/03/2011 23:10, Soviet_Mario ha scritto:
> Il 17/03/2011 20:12, LudovicoVan ha scritto:
Riciao ... uhm
Sono inciampato in un'altro problema (ho seguito il tuo
consiglio di mettere le variabili dentro un form creato a
design time).
Ora il mio problema nasce dal fatto che devo invocarlo MODAL
(e non modeless) e non si ritorna da ShowDialog sin quando
non chiudo il form stesso.
Per quanto riguarda passare gli oggetti AL form dinamico, no
problem
La routine in cui lo CREO, nascosto, prima di usare
showdialog, copia le variabili nel chiamante nelle reference
del dato form dinamico (riempito a runtime).
Quando però ritorno da ShowDialog, chiudendo il form
malefico, non riesco in nessun modo a ricopiare i dati
elaborati nelle reference del form padre. Tutti i
riferimenti si resettano a NOTHING quando il modal cessa di
esistere.
Nell'evento form_closing ho tentato di settare e.cancel=true
e barare, scrivendo me.hide (insomma volevo che il modal si
nascondesse ma non morisse ... ma non ritorna. Tenta di
nuovo da solo di fare closing, e dopo avere rifatto
e.cancel=true, da solo, muore ugualmente e si scarica ... e
annulla tutte le sue reference create con NEW e assegnate
alla variabile creata dentro il form padre, variabile che si
vanifica al ritorno)
Non ci sto a capire più una mazza. Ma come cavolo faccio a
controllare il life time, se non con new ?
Io voglio riuscire a copiare le variabili del figlio dentro
il padre ... copiare, non solo agganciare un riferimento.
Pensavo che con new funzionasse, che istanziasse veri dati
... ma sembra di no, muoiono col morire dello scope.
boh
scusa se tedio con questi problemucci :(
ciao
Soviet


title: Creare form (e controlli) a runtime

text:
On Mar 18, 11:42 pm, Soviet_Mario <Soviet.Ma...@CCCP.MIR> wrote:
> Il 17/03/2011 23:10, Soviet_Mario ha scritto:> Il 17/03/2011 20:12, LudovicoVan ha scritto:
>
> Sono inciampato in un'altro problema (ho seguito il tuo
> consiglio di mettere le variabili dentro un form creato a
> design time).
Non dare la colpa a me! ;) (scherzo.)
> Ora il mio problema nasce dal fatto che devo invocarlo MODAL
> (e non modeless) e non si ritorna da ShowDialog sin quando
> non chiudo il form stesso.
>
> Per quanto riguarda passare gli oggetti AL form dinamico, no
> problem
>
> La routine in cui lo CREO, nascosto, prima di usare
> showdialog, copia le variabili nel chiamante nelle reference
> del dato form dinamico (riempito a runtime).
>
> Quando però ritorno da ShowDialog, chiudendo il form
> malefico, non riesco in nessun modo a ricopiare i dati
> elaborati nelle reference del form padre. Tutti i
> riferimenti si resettano a NOTHING quando il modal cessa di
> esistere.
Potresti mostrare qualche riga di codice? Mi aspetteri che proprio
nello handler del close "copi" quello che eventualmente c'e' da
"copiare", ma e' difficile aiutarti se continui a non dare nessun
elemento concreto: di *cosa* e' che stai parlando e che dovresti
copiare (per lo meno, quali *tipi* di dati, ecc.) e cosa e' che hai
provato che non ti rida'?
Intanto ti consiglierei di leggere qualcosa su value types vs
reference types, ma piu' che altro perche' e' da sapere e perche' mi
costringi ad andare totalmente a naso...
-LV


title: Creare form (e controlli) a runtime

text:
Il 19/03/2011 04:01, LudovicoVan ha scritto:
> On Mar 18, 11:42 pm, Soviet_Mario<Soviet.Ma...@CCCP.MIR>  wrote:
>> Il 17/03/2011 23:10, Soviet_Mario ha scritto:>  Il 17/03/2011 20:12, LudovicoVan ha scritto:
>>
>> Sono inciampato in un'altro problema (ho seguito il tuo
>> consiglio di mettere le variabili dentro un form creato a
>> design time).
>
> Non dare la colpa a me! ;) (scherzo.)
AH eh eh he. Certo che no. Dopotutto alla fine (l'altra
notte) la pezza ha funto, ed è molto più agile di prima. Mi
evito il late-binding a runtime che onestamente non posso
soffrire (e non solo per le performance, mi blocca
l'intellisense, mi costringe a mettere gestori di eccezioni
sul possibile trycast fallito etc, con il binding statico, o
compila, e va, o non compila).
>
CUT
>
> Potresti mostrare qualche riga di codice? Mi aspetteri che proprio
> nello handler del close "copi" quello che eventualmente c'e' da
> "copiare", ma e' difficile aiutarti se continui a non dare nessun
> elemento concreto: di *cosa* e' che stai parlando e che dovresti
> copiare (per lo meno, quali *tipi* di dati, ecc.) e cosa e' che hai
> provato che non ti rida'?
>
> Intanto ti consiglierei di leggere qualcosa su value types vs
> reference types, ma piu' che altro perche' e' da sapere e perche' mi
> costringi ad andare totalmente a naso...
dunque ... troppo lungo e non so stralciare (e casualmente,
a spanne, ho trovato cosa funge, senza ben capire la ragione).
Per inciso gli oggetti che passo per riferimento sono
REFERENCE TYPES (classi, abbastanza annidate, ma tutti ref
type).
Io facevo una NEW di troppo nel form chiamato, dove riempivo
alcuni sottocampi vuoti della variabile globale del
chiamante passata come argomento in un metodo del chiamato
(per agganciarli).
Il vero problema è che non capisco il lifetime di new del basic.
In C quando scrivo new, so esattamente che l'oggetto vive
sin quando non lo ammazzo io.
Qui mi aspettavo almeno di poter contare che vivesse sin
quando non usciva di scope (e siccome lo scope era del
chiamante e non del form chiamato, avrei giurato che lo
scope fosse quello di nascita). Invece una new effettuata
nel figlio (seppure di inizializzazione di una reference del
padre) moriva col figlio.
Ora ho allocato tutto nel padre e funge. Mah. Piccola pecca
: devo preallocare tutto, anche quello che non servirà,
perché a priori non so cosa servirà (si decide nel form
figlio). Pazienza, non è un grosso problema sprecare 200-400
byte.
Ammetto di non capire bene la new del basic.
Scusa se sono stato vago, non è né pigrizia né gelosia del
codice : quando sarà pronto sarà pure liberamente leggibile
perché è un programma didattico (di stechiometria chimica).
Ma non riuscivo a stralciare senza mettermici d'impegno. O
meglio, siccome non capisco delle cose e non so esattamente
che aspettarmi o dove e perché fallasse, non sarei stato
sicuro di avere stralciato dettagli critici al problema o
no. Cmq ora funge. Magari pian piano provo piccole
variazioni per vedere quando e come introduco la debolezza,
e imparo per induzione.
Già sono soddisfatto di avere usato bene delle veriabili
withevents per agganciarle a bottoni creati dinamicamente.
Qualche tempo fa avevo imparato a usare i delegates per fare
una tavola di puntatori a funzione. COmodissimi. Ma li ho
scordati. Devo ristudiarmi pure quelli
Cmq grazie dei consigli vari
ciao
Soviet
>
> -LV


title: Creare form (e controlli) a runtime

text:
Ciao Soviet_Mario,
You wrote on 19/03/2011 :
> Invece una new effettuata nel figlio (seppure di inizializzazione di una
> reference del padre) moriva col figlio.
> Ora ho allocato tutto nel padre e funge
spiegati meglio perchè questa cosa è sbagliata upfront :-)
.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: Creare form (e controlli) a runtime

text:
On Mar 19, 2:57 pm, Soviet_Mario <Soviet.Ma...@CCCP.MIR> wrote:
> Il 19/03/2011 04:01, LudovicoVan ha scritto:
>
> > Potresti mostrare qualche riga di codice? Mi aspetteri che proprio
> > nello handler del close "copi" quello che eventualmente c'e' da
> > "copiare", ma e' difficile aiutarti se continui a non dare nessun
> > elemento concreto: di *cosa* e' che stai parlando e che dovresti
> > copiare (per lo meno, quali *tipi* di dati, ecc.) e cosa e' che hai
> > provato che non ti rida'?
>
> > Intanto ti consiglierei di leggere qualcosa su value types vs
> > reference types, ma piu' che altro perche' e' da sapere e perche' mi
> > costringi ad andare totalmente a naso...
>
> dunque ... troppo lungo e non so stralciare (e casualmente,
> a spanne, ho trovato cosa funge, senza ben capire la ragione).
Non posso credere che non riesci a isolare e copiare le poche righe di
codice rilevante. E andare avanti cosi' e' quasi solo una perdita di
tempo.
> Per inciso gli oggetti che passo per riferimento sono
> REFERENCE TYPES (classi, abbastanza annidate, ma tutti ref
> type).
> Io facevo una NEW di troppo nel form chiamato, dove riempivo
> alcuni sottocampi vuoti della variabile globale del
> chiamante passata come argomento in un metodo del chiamato
> (per agganciarli).
L'unica cosa che mi viene in mente e' che passi il reference type by
value, per cui alla fine sarebbe corretto che la reference original
nell'owner e' nulla: in realta' non e' mai stata valorizzata!
> Il vero problema è che non capisco il lifetime di new del basic.
> In C quando scrivo new, so esattamente che l'oggetto vive
> sin quando non lo ammazzo io.
In generale, i reference type vanno nel cosiddetto heap (vs. stack) e
vengono eliminati via garbage collection, indeterministicamente,
quando il reference count (il numero di referenze esistenti) va a
zero.  Di nuovo, ti tocca guardare un po' di documentazione, in questo
caso sul memory management in .Net: il "metodo induttivo" e' garanzia
certa che fra 10 dieci anni stai ancora a fare scommesse...
-LV


title: Single Inheritance

text:
Mi sapreste gentilmente dire a che può servire
l'ereditarietà singola in una struttura di classi realistica ?
Ammettendo che una certa struttura dati (che rappresenta
bene un certo modello reale) possa venire naturalmente
mappata in una certa struttura di classi basata su
ereditarietà multiple, secondo un grafo comunque ramificato
o con "anelli", come si può trasporre in una struttura
basata su Single Inheritance ?
Esiste qualche modello matematico-topologico generico per
effettuare una simile conversione ?
Che accade del numero totale di classi, in una conversione ?
grazie delle vostre considerazioni
ciao
Soviet


title: Single Inheritance

author: Raffaele Rialdi [MVP]

text:

Non capisco dove vuoi arrivare.
La limitazione della single-inheritance implica solo che dotnet non ti
permette di avere più di una classe base ma ti permette di avere più
interfacce base, trucco usato spesso per cercare di aggirare la
mancanza di multiple-inheritance.
Partendo dal fatto che il grafo di derivazione è sempre un albero (la
cui root è 'object') se usi il 'trucco' delle interfacce ottieni invece
un grafo un po' particolare che direi sia di tipo aciclico e orientato.
Ovviamente interfacce e classi sono differenti e quindi l'analisi di
questo grafo a mio avviso lascia un po' il tempo che trova e non mi
viene in mente alcuna teoria dei grafi applicabili a questo tipo di
problema.
Per quanto riguarda l'inheritance il dato più interessante è che la
relazione dovrebbe sempre rappresentare il concetto di 'a kind of' tra
due oggetti. Questo è sempre un ottimo modo per partire a disegnare una
gerarchia.
Potrei capire il discorso di analisi matematica del grafo se prendiamo
invece in considerazione un object model. Il grafo di un object model
può essere (lo è spesso) ciclico e non orientato e la teoria dei grafi
potrebbe aiutare nell'analisi delle performance assegnando un peso per
ciascuna proprietà/metodo che restituisce un nodo (reference) di un
altro oggetto. O ancora nel determinare la sua usabilità in base
all'analisi dei costi del cammino minimo.
Ma mi sa che sono andato fuori strada ...
--
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: Single Inheritance

text:
Il 15/01/2011 01:13, Raffaele Rialdi [MVP] ha scritto:
> Soviet_Mario wrote:
>> Mi sapreste gentilmente dire a che può servire l'ereditarietà singola
>> in una struttura di classi realistica ?
>>
>> Ammettendo che una certa struttura dati (che rappresenta bene un certo
>> modello reale) possa venire naturalmente mappata in una certa
>> struttura di classi basata su ereditarietà multiple, secondo un grafo
>> comunque ramificato o con "anelli", come si può trasporre in una
>> struttura basata su Single Inheritance ?
>> Esiste qualche modello matematico-topologico generico per effettuare
>> una simile conversione ?
>>
>> Che accade del numero totale di classi, in una conversione ?
>>
>> grazie delle vostre considerazioni
>
> Non capisco dove vuoi arrivare.
uhm, non è un segreto, sto solo cercando di capire se c'è un
modo di tradurre del codice scritto per ereditarietà
multipla in uno a singola (e il grafo delle relazioni non è
banalmente 1:molti, ma c'è anche una "sibling")
>
> La limitazione della single-inheritance implica solo che dotnet non ti
> permette di avere più di una classe base
eggià, e appunto per questo mi chiedevo se ci fosse un modo
generale di cambiare struttura in modo da tradurne una che
non soffrisse di tale limitazione.
Qualche algoritmo, non so.
> ma ti permette di avere più
> interfacce base, trucco usato spesso per cercare di aggirare la mancanza
> di multiple-inheritance.
>
> Partendo dal fatto che il grafo di derivazione è sempre un albero (la
> cui root è 'object') se usi il 'trucco' delle interfacce ottieni invece
> un grafo un po' particolare che direi sia di tipo aciclico e orientato.
no in effetti ci sono maglie, ossia divaricazioni del grafo
che però poi riconfluiscono. E' una traduzione fatta per
esercizio, quindi non piango se non riesco a tradurre
>
> Ovviamente interfacce e classi sono differenti e quindi l'analisi di
> questo grafo a mio avviso lascia un po' il tempo che trova e non mi
> viene in mente alcuna teoria dei grafi applicabili a questo tipo di
> problema.
mmm. Avevo tentato di ragionare in modo un po' facilone,
intuitivo diciamo, pensando alla creazione di classi
intermedie, boh. Ma non mi ci ero applicato
> Per quanto riguarda l'inheritance il dato più interessante è che la
> relazione dovrebbe sempre rappresentare il concetto di 'a kind of' tra
> due oggetti. Questo è sempre un ottimo modo per partire a disegnare una
> gerarchia.
Si, la domanda "is a.." o "has a ..".
Quasi sempre ci metto una pezza con la "has a", nel senso
che ficco dentro una classe grossa oggetti di altre classi,
di cui chiamo i metodi attraverso le variabili accessorie.
Sarà inelegante, ma non sapendo come far convergere metodi
da più radici, facevo questo.
Il fatto è appunto che le classi più derivate delle
gerarchie, sono spesso di molti tipi contemporaneamente.
> Potrei capire il discorso di analisi matematica del grafo se prendiamo
> invece in considerazione un object model. Il grafo di un object model
> può essere (lo è spesso) ciclico e non orientato e la teoria dei grafi
> potrebbe aiutare nell'analisi delle performance assegnando un peso per
> ciascuna proprietà/metodo che restituisce un nodo (reference) di un
> altro oggetto. O ancora nel determinare la sua usabilità in base
> all'analisi dei costi del cammino minimo.
>
> Ma mi sa che sono andato fuori strada ...
No, non saprei anzi, proprio per il fatto di avere scarsa
base matematica sulla teoria chiedevo se esistesse già
prefabbricata qualche strategia, o persino tool di analisi
di codice che magari traducono un grafo compatto (pochi
nodi) ma con relazioni abb. intricate, in uno "snodato"
magari con un gran numero di nodi accessori.
Purtroppo non ho capito bene queste ultime considerazioni,
ma suonavano interessanti. Ad es. non so cosa si intenda
precisamente per object model.
Quanto ai grafi che vorrei tradurre, contengono "maglie", ma
non sono interamente ciclici nel senso di anelli (credo però
di avere equivocato le considerazioni che facevi).
Ma cmq diciamo che provo a rifletterci un po' meglio e senza
pigrizia :)
ciao e grazie
Soviet


title: Single Inheritance

text:
> uhm, non è un segreto, sto solo cercando di capire se c'è un modo di tradurre
> del codice scritto per ereditarietà multipla in uno a singola (e il grafo
> delle relazioni non è banalmente 1:molti, ma c'è anche una "sibling")
Non credo e credo personalmente non ne vedo l'utilità ...
> Quasi sempre ci metto una pezza con la "has a", nel senso che ficco dentro
> una classe grossa oggetti di altre classi, di cui chiamo i metodi attraverso
> le variabili accessorie.
> Sarà inelegante, ma non sapendo come far convergere metodi da più radici,
> facevo questo.
> Il fatto è appunto che le classi più derivate delle gerarchie, sono spesso di
> molti tipi contemporaneamente.
... quello che voglio dire è che non vedo l'utilità di fare questo
processo in modo automatico, algoritmico.
Tutto dovrebbe partire dal modo migliore per disegnare un object model,
cioè il modello che vuoi realizzare per descrivere il problema reale
che stai cercando di risolvere.
Se mai fosse automatizzabile il processo creare il modello, alla fine
il problema dell'inheritance sarebbe solo una 'regola' da applicare per
evitare di creare una gerarchia a multiple-inheritance.
Il processo di passare da multiple a single, sinceramente non lo vedo
utile.
> No, non saprei anzi, proprio per il fatto di avere scarsa base matematica
> sulla teoria chiedevo se esistesse già prefabbricata qualche strategia, o
> persino tool di analisi di codice che magari traducono un grafo compatto
> (pochi nodi) ma con relazioni abb. intricate, in uno "snodato" magari con un
> gran numero di nodi accessori.
> Purtroppo non ho capito bene queste ultime considerazioni, ma suonavano
> interessanti. Ad es. non so cosa si intenda precisamente per object model.
(vedi sopra)
> Quanto ai grafi che vorrei tradurre, contengono "maglie", ma non sono
> interamente ciclici nel senso di anelli (credo però di avere equivocato le
> considerazioni che facevi).
Se ti leggi un po' di teoria dei grafi, troverai i concetti base
interessanti, ma dubito che siano applicabili al problema che hai
sollevato.
> Ma cmq diciamo che provo a rifletterci un po' meglio e senza pigrizia :)
> ciao e grazie
prego, ciao



title: Policy di persistenza dati

author: marcosabba

text:
Salve, non so se la domanda che sto per fare è stata fatta esattamente
nei termini in cui ve la sto ponendo, però ho dei dubbi "architetturali"
sulle modalità di salvataggio di alcune classi di dominio: attualmente,
dopo aver provato la serializzazione col binary formatter, sto usando il
DataContractSerializer, dunque l'"impatto" sulle mie classi di dominio è
limitato all'uso di attributi [DataContract] e [DataMember], e la
serializzazione viene invocata da un PersistenceService che chiamo da un
progetto che racchiude i servizi di Runtime. Dunque non c'è (a parte gli
attributi) niente che "sporchi" le classi di modello, non so se mi
spiego bene. So che la serializzazione non è pensata specificamente per
il salvataggio, ma è la prima cosa che mi è venuta in mente...
Ora però avrei necessità di salvare i miei dati in un formato
proprietario, sempre xml, ma devo pilotare io la scrittura: in che
direzione è meglio muoversi?

- Inserire nelle classi di modello dei metodi per il salvataggio e il
caricamento? A prima vista non mi pare corretto, si inserirebbe una
conoscenza implementativa di servizio in un oggetto di dominio...
- Centralizzare nel PersistenceService tutta la policy di esplorazione e
salvataggio dei dati?
- Altre policy a cui non ho pensato

Credo che siano cose per molti di voi già assodate, se avete dunque
qualche riferimento per studiare la questione o qualche consiglio, vi
sarei molto grato.

Grazie e ciao!


title: Policy di persistenza dati

text:
Ciao Marco,

You wrote on 09/04/2013 :
> - Inserire nelle classi di modello dei metodi per il salvataggio e il
> caricamento? A prima vista non mi pare corretto, si inserirebbe una
> conoscenza implementativa di servizio in un oggetto di dominio...
> - Centralizzare nel PersistenceService tutta la policy di esplorazione e
> salvataggio dei dati?
> - Altre policy a cui non ho pensato

un "mix" fatto da un sistema centralizzato con cui tu dialoghi
dall'esterno e lui internamente usata un pattern come il Visitor per
delegare a classi specifiche la serielizzazione custom di elementi
specifici che ovviamente lui non può conoscere.

.m

--
blog @ //
milestone.topics.it


title: Policy di persistenza dati

text:

Grazie Mauro, manco a dirlo ecco un commento scritto ieri pomeriggio
durante la stesura di un metodo chilometrico per la scrittura su xml:

//TODO: Visitor pattern???
foreach (var blockNScope in blocksNScopes.SelectMany(s => s).ToList())
[...]

;)

Mi hai confermato l'ipotesi, grazie e buona giornata!!


title: Soluzione - Progetto - Assembly - File - Modulo classe etc

text:
Ordunque, codesto è un post da linciaggio e pubblica gogna,
perché certi dubbi bisognerebbe esserseli chiariti molto
prima di avere scritto paginate di codice che (pare) funziona.
Ma tant'è, il dubbio mi rimane e tento di rigirarlo a
qualche buon anima (anche non sempre gli stessi eh, se no ci
devo offrire una cena come minimo). Cmq
Io non ho chiaro, anzi una percezione indistinta, della
gerarchia, e dello scopo della gerarchia.
Ad es. mi son fatto l'idea (empirica) che tra soluzione e
progetto ci sia, insiemisticamente, una relazione di
inclusione (la prima include uno o più dei secondi).
MA a cosa serva questo non lo intuisco. Cosa si può fare con
una soluzione che non si può fare con un progetto ?
Poi non capisco cosa possa rappresentare l'entità FILE. Qui,
nebulosamente, mi pare di intuire niente del tutto. Ci si
possono ficcare tante classi, moduli, moduli e classi, e
namespace. Ma cmq ad es. un namespace può essere inteso su
più files. Ergo ho pensato che l'entità FILE, significativa
per la memorizzazione nel file system, funzionalmente non
abbia alcun significato con la struttura di oggetti che
portano ad un programma compilato completo (con magari
l'eccezione del file di risorse, se ancora esiste come nel
vecchio VB 6). Se mi sbaglio, mi dareste qualche dritta
astratta a come unire o dividere le unità funzionali del
codice su uno o più files ? A naso ora sto mettendo da un
lato forms e tutto quanto riguarda la gui, e in un altro
file tutte le funzioni non gui ma usate dalla gui e di una
qualche utilità generale. Ma così, a naso appunto, e non è
il massimo.
Poi per me il concetto di assembly è invece rimasto ancora
del tutto misterioso. Su ciò non ho fatto alcuna scelta
cosciente, non ne so nulla, e evidentemente tutti i default
funzionano e un programmuccio compila ed esegue malgrado ciò.
Cosa sono in realtà ? A che servono, e in che posizione
della gerarchia degli oggetti si collocano ? Sono parte di
un progetto, o un progetto è parte di un assembly ? O sono
parte di una soluzione ? Boh :-(
Grazie di ogni suggerimento anche molto generalistico e non
approfondito, devo proprio cominciare da zero (e pure ho dei
ricordi di altri linguaggi che mi condizionano
negativamente, tipo il senso che *file* aveva in C come
unità di compilazione e di scope di nomi static)
ciao
Soviet


text:
Soviet_Mario wrote:
[...]
>
> Ad es. mi son fatto l'idea (empirica) che tra soluzione e progetto ci sia,
> insiemisticamente, una relazione di inclusione (la prima include uno o piï¿œ
> dei secondi).
> MA a cosa serva questo non lo intuisco. Cosa si puï¿œ fare con una soluzione
> che non si puï¿œ fare con un progetto ?
I progetti possono essere di vario tipo (librerie, UI, web services,
etc.).
Mi pare ovvio che mettere tutto in uno sarebbe un errore anche quando
tutto dovesse far parte dello stesso processo. Se poi sono su diversi
processi o addirittura diversi tier, allora diventa persino
impossibile.
Di conseguenza se hai una applicazione che ha un client e un web
service che accede ai dati avrai almeno due progetti.
Considerato che riguardano lo stesso argomento e che vorrai
probabilmente svilupparli in parallelo, la solution risulta
fondamentale.
>
> Poi non capisco cosa possa rappresentare l'entitï¿œ FILE. Qui, nebulosamente,
> mi pare di intuire niente del tutto. Ci si possono ficcare tante classi,
> moduli, moduli e classi, e namespace. Ma cmq ad es. un namespace puï¿œ essere
> inteso su piï¿œ files. Ergo ho pensato che l'entitï¿œ FILE, significativa per la
> memorizzazione nel file system, funzionalmente non abbia alcun significato
> con la struttura di oggetti che portano ad un programma compilato completo
> (con magari l'eccezione del file di risorse, se ancora esiste come nel
> vecchio VB 6). Se mi sbaglio, mi dareste qualche dritta astratta a come unire
> o dividere le unitï¿œ funzionali del codice su uno o piï¿œ files ?
Esatto, il file ï¿œ insignificante perchï¿œ anche una sola classe, grazie a
"partial" puï¿œ essere splittata su piï¿œ file.
Il grosso, enorme vantaggio ï¿œ che puoi avere un generatore di codice
(di visual studio o tuo se usi i template T4) che genera un file con
una partial class. Questa viene rigenerata tutte le volte e di
conseguenza non vorrai mai editarla, altrimenti perderesti il codice
editato. Per esempio i proxy dei web service generati da
vs.net
 sono in
una partial class su un file.
Il resto di quella classe lo puoi scrivere tu su un altro file senza
rischiare che venga sovrascritto dal generatore.
> A naso ora sto
> mettendo da un lato forms e tutto quanto riguarda la gui, e in un altro file
> tutte le funzioni non gui ma usate dalla gui e di una qualche utilitï¿œ
> generale. Ma cosï¿œ, a naso appunto, e non ï¿œ il massimo.
La separazione in "layer" ï¿œ un 'must' (direi un obbligo morale :D)
dello sviluppatore, altrimenti scrive garbugli.
I layer possono essere in classi differenti o anche in dll (ergo
progetti) diverse.
>
> Poi per me il concetto di assembly ï¿œ invece rimasto ancora del tutto
> misterioso. Su ciï¿œ non ho fatto alcuna scelta cosciente, non ne so nulla, e
> evidentemente tutti i default funzionano e un programmuccio compila ed esegue
> malgrado ciï¿œ.
> Cosa sono in realtï¿œ ? A che servono, e in che posizione della gerarchia degli
> oggetti si collocano ? Sono parte di un progetto, o un progetto ï¿œ parte di un
> assembly ? O sono parte di una soluzione ? Boh :-(
Per capirlo a fondo leggiti il libro di Richter (CLR via C#) che ï¿œ un
libro a mio avviso indispensabile.
Evito di reinventarmi una definizione. Vedi qui:
http://en.wikipedia.org/wiki/.NET_assembly
Una cosa importante ï¿œ che Visual Studio semplifica la gestione degli
assembly generandone uno per progetto.
In realtï¿œ un assembly puï¿œ avere piï¿œ file e ci sono ottimi motivi per
volerlo fare. Per esempio uno contiene il manifest, uno le funzioni piï¿œ
usate e un altro ancora quelle meno utilizzate. In questo modo fai un
uso migliore della memoria.
Per adesso accontentati del mapping 1:1 di
vs.net
 ;)
> Grazie di ogni suggerimento anche molto generalistico e non approfondito,
> devo proprio cominciare da zero (e pure ho dei ricordi di altri linguaggi che
> mi condizionano negativamente, tipo il senso che *file* aveva in C come unitï¿œ
> di compilazione e di scope di nomi static)
Prego, ciao
--
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/


text:
Il 26/01/2011 12:26, Raffaele Rialdi [MVP] ha scritto:
> Soviet_Mario wrote:
> [...]
ahia, la cena da offrire si avvicina :)
>>
>> Ad es. mi son fatto l'idea (empirica) che tra soluzione e progetto ci
>> sia, insiemisticamente, una relazione di inclusione (la prima include
>> uno o più dei secondi).
>> MA a cosa serva questo non lo intuisco. Cosa si può fare con una
>> soluzione che non si può fare con un progetto ?
>
> I progetti possono essere di vario tipo (librerie, UI, web services, etc.).
> Mi pare ovvio che mettere tutto in uno sarebbe un errore anche quando
> tutto dovesse far parte dello stesso processo. Se poi sono su diversi
> processi o addirittura diversi tier, allora diventa persino impossibile.
si ... capisco che io sto pensando molto in piccolo e tu in
grande (o normale, ma pare in grande a me), e una parte di
quello che mi sembra inutile è distorto dalla prospettiva di
necessità limitate. MA cmq grazie di avermi chiarito il punto
>
> Di conseguenza se hai una applicazione che ha un client e un web service
> che accede ai dati avrai almeno due progetti.
Si ! Bene. PErché in effetti le due applicazioni a cui sto
lavorando, cascano proprio a fagiolo in questa categoria.
C'è una sorta di Ebook reader , dove accanto al reader io
dovrò usare il "writer" come autore, ed è chiaro che parlano
la lingua dello stesso formato file (era quel file astruso
di cui parlavo tempo fa e delle mie grane con la
serializzazione). In effetti, sempre a naso e a istinto, un
progetto l'ho chiamato MyBookEditor e l'altro MyBookReader,
ma la soluzione boh, l'ho chiamata come il secondo, non
sapevo che nome darci.
E ora come ora ne sto facendo uno per correggere problemi
numerici (compiti in classe) valutando il procedimento, ma
anche lì mi serve un modulo master per crearli questi
benedetti template giusti, e di nuovo la scissione in
effetti è naturale. Invece per qualche ragione astrusa (è
molto più semplice dell'EBook) stavolta sto cacciando tutto
nello stesso progetto. Spero di riuscire ancora a dividere i
destini (ho lavorato solo al master editor per ora, mentre
il solutore non ha ancora gui ed è a livello di classi e
gestione interna, ergo non dispero).
Cmq mi sforzerò di essere ordinato su questo punto, già che
me l'hai fatto capire
> Considerato che riguardano lo stesso argomento e che vorrai
> probabilmente svilupparli in parallelo, la solution risulta fondamentale.
>
vero. Cmq stavo riflettendo se valesse la pena di dividere
in tre. Due parti completamente disgiunte, ossia il codice
esclusivo o del Client o del Server (che per me sono il
modulo valutazione e il modulo master-editing ma la sostanza
è quella), e poi un terzo "progetto" per la sola parte
comune, cioè le routine da cui dipendono entrambi.
Ma non so se sia un'idea decente. 1) come la intitolo ? 2)
come la "includo" in entrambi (uso un verbo forse inesatto
mutuato dal C, ma intendo che devo legare delle dipendenze
dei due progetti disgiunti da questa parte comune). E poi è
giusto chiamarla progetto ? O sarebbe meglio una DLL ? Qui
ho della confusione
>>
>> Poi non capisco cosa possa rappresentare l'entità FILE. Qui,
>> nebulosamente, mi pare di intuire niente del tutto. Ci si possono
>> ficcare tante classi, moduli, moduli e classi, e namespace. Ma cmq ad
>> es. un namespace può essere inteso su più files. Ergo ho pensato che
>> l'entità FILE, significativa per la memorizzazione nel file system,
>> funzionalmente non abbia alcun significato con la struttura di oggetti
>> che portano ad un programma compilato completo (con magari l'eccezione
>> del file di risorse, se ancora esiste come nel vecchio VB 6). Se mi
>> sbaglio, mi dareste qualche dritta astratta a come unire o dividere le
>> unità funzionali del codice su uno o più files ?
>
> Esatto, il file è insignificante perché anche una sola classe, grazie a
> "partial" può essere splittata su più file.
Ok, e siccome un file può avere più classi, non esiste
nessuna corrispondenza univoca. Meglio cmq
> Il grosso, enorme vantaggio è che puoi avere un generatore di codice (di
> visual studio o tuo se usi i template T4)
qui devo studiare. Mai sentiti i template T4, li cercherò.
So che esistono i generics, che si hanno qualche vantaggio
come le restrizioni, ma ogni volta che mi azzardo a pensare
a qualcosa di minimamente intricato coi template mi viene
d'istinto a pensare in termini di C++, e poi a tradurre in
VB mi vien mal di cuore per la stratosferica sproporzione di
flessibilità di questo aspetto. Ergo i tipi generici ora
praticamente mi limito a usare i contenitori prefabbricati.
Non ho ancora provato il VS2010, magari è maturato sui
template, boh ... cmq non mi sono essenziali per ora
> che genera un file con una
> partial class. Questa viene rigenerata tutte le volte e di conseguenza
> non vorrai mai editarla, altrimenti perderesti il codice editato. Per
> esempio i proxy dei web service generati da
vs.net
 sono in una partial
> class su un file.
> Il resto di quella classe lo puoi scrivere tu su un altro file senza
> rischiare che venga sovrascritto dal generatore.
molto interessante, e cercherò informazioni su questi
template T4
>
>
>> A naso ora sto mettendo da un lato forms e tutto quanto riguarda la
>> gui, e in un altro file tutte le funzioni non gui ma usate dalla gui e
>> di una qualche utilità generale. Ma così, a naso appunto, e non è il
>> massimo.
>
> La separazione in "layer" è un 'must' (direi un obbligo morale :D) dello
> sviluppatore, altrimenti scrive garbugli.
> I layer possono essere in classi differenti o anche in dll (ergo
> progetti) diverse.
>
>>
>> Poi per me il concetto di assembly è invece rimasto ancora del tutto
>> misterioso. Su ciò non ho fatto alcuna scelta cosciente, non ne so
>> nulla, e evidentemente tutti i default funzionano e un programmuccio
>> compila ed esegue malgrado ciò.
>> Cosa sono in realtà ? A che servono, e in che posizione della
>> gerarchia degli oggetti si collocano ? Sono parte di un progetto, o un
>> progetto è parte di un assembly ? O sono parte di una soluzione ? Boh :-(
>
> Per capirlo a fondo leggiti il libro di Richter (CLR via C#) che è un
> libro a mio avviso indispensabile.
Eh, non lo possiedo. E non sono un vero programmatore, ergo
non ho manco quel grandissimo tempo da dedicarci in studio
puro (lo so che serve eh, non dico di no). Mi sforzo di
imparare quanto basta. Purtroppo mi pare che capire questo
concetto sia importante. Ne ho letto qualcosa sull'help, ma
non capendo molto
>
> Evito di reinventarmi una definizione. Vedi qui:
>
http://en.wikipedia.org/wiki/.NET_assembly
proverò a vedere anche questo. Dovrei trovare uno scheletro
di codice minimale che faccia capire a cosa possa servire
>
> Una cosa importante è che Visual Studio semplifica la gestione degli
> assembly generandone uno per progetto.
ah, ecco perché il default mi funzionava. Lo suppo
> In realtà un assembly può avere più file e ci sono ottimi motivi per
> volerlo fare.
domanda forse oziosa. E un solo file può avere più assembly
o parti di essi ? Tanto per saperlo
> Per esempio uno contiene il manifest, uno le funzioni più
> usate e un altro ancora quelle meno utilizzate. In questo modo fai un
> uso migliore della memoria.
> Per adesso accontentati del mapping 1:1 di
vs.net
 ;)
si.
Ma tornando al problema di due eseguibili della stessa
famiglia, l'idea di avere tre assembly, invece dei tre
progetti, due con le parti specifiche, uno con la sola
"intersezione" calzerebbe ?
O dovrei avere due progetti più un assembly comune
(assumendo che un assembly possa essere al di fuori di un
progetto, ossia un "pezzo" di codice a sé stante e che non
viene compilato da solo a applicazione) ma solo inglobato
... Lo so, ho infiniti dubbi
Rigrazie
ciao
Soviet
>


text:
Soviet_Mario wrote:
> si ... capisco che io sto pensando molto in piccolo e tu in grande (o
> normale, ma pare in grande a me), e una parte di quello che mi sembra inutile
> è distorto dalla prospettiva di necessità limitate. MA cmq grazie di avermi
> chiarito il punto
In questo caso a te non fa differenza perché hai un'icona di più nel
tree della solution.
Se penso a solution su cui ho lavorato che hanno *diverse* decine di
progetti, la ritengo una feature indispensabile.
> Cmq mi sforzerò di essere ordinato su questo punto, già che me l'hai fatto
> capire
:)
> vero. Cmq stavo riflettendo se valesse la pena di dividere in tre. Due parti
> completamente disgiunte, ossia il codice esclusivo o del Client o del Server
> (che per me sono il modulo valutazione e il modulo master-editing ma la
> sostanza è quella), e poi un terzo "progetto" per la sola parte comune, cioè
> le routine da cui dipendono entrambi.
> Ma non so se sia un'idea decente. 1) come la intitolo ? 2) come la "includo"
> in entrambi (uso un verbo forse inesatto mutuato dal C, ma intendo che devo
> legare delle dipendenze dei due progetti disgiunti da questa parte comune). E
> poi è giusto chiamarla progetto ? O sarebbe meglio una DLL ? Qui ho della
> confusione
1. il titolo è una tua scelta. Sarà il nome della dll che ne risulta.
Adesso che sei all'inizio non farti troppi problemi.... in seguito ti
sperimenterai le best-practice per i nomi di namespace e progetti.
2. pulsante destro sul progetto, menu "add reference" ...
nella dialog che si apre scegli il tab dei tuoi progetti e referenzi
quella comune.
Se hai vs2010 e installi i powertools tramite extension manager, c'è
una nuova versione di questa dialog che è super-potente (in quella
extension ci sono molte altre cose belle).
> Ok, e siccome un file può avere più classi, non esiste nessuna corrispondenza
> univoca. Meglio cmq
esatto
> qui devo studiare. Mai sentiti i template T4, li cercherò.
Servono per generare sorgenti quando è possibile costruirli in modo
programmatico partendo da metainformazioni. Diciamo come fanno i wizard
di
vs.net
[...]
>> In realtà un assembly può avere più file e ci sono ottimi motivi per
>> volerlo fare.
>
> domanda forse oziosa. E un solo file può avere più assembly o parti di essi ?
> Tanto per saperlo
No, un file può essere <= un assembly
> si.
> Ma tornando al problema di due eseguibili della stessa famiglia, l'idea di
> avere tre assembly, invece dei tre progetti, due con le parti specifiche, uno
> con la sola "intersezione" calzerebbe ?
In
vs.net
 tre assembly implica tre progetti.
Nel caso dei tuoi tre progetti di cui uno comune, sono comunque tre
assembly.
Le dipendenze tra assembly sono ovviamente una cosa molto comune, abbi
solo l'attenzione di non avere referenze rircolari tra assembly.
> O dovrei avere due progetti più un assembly comune (assumendo che un assembly
> possa essere al di fuori di un progetto, ossia un "pezzo" di codice a sé
> stante e che non viene compilato da solo a applicazione) ma solo inglobato
> ... Lo so, ho infiniti dubbi
vedi quanto ho scritto sopra ...
>
>
> Rigrazie
Prego



text:
Il 26/01/2011 14:43, Raffaele Rialdi [MVP] ha scritto:
> Soviet_Mario wrote:
CUT
>
> 1. il titolo è una tua scelta. Sarà il nome della dll che ne risulta.
> Adesso che sei all'inizio non farti troppi problemi.... in seguito ti
> sperimenterai le best-practice per i nomi di namespace e progetti.
>
> 2. pulsante destro sul progetto, menu "add reference" ...
> nella dialog che si apre scegli il tab dei tuoi progetti e referenzi
> quella comune.
ok
> Se hai vs2010 e installi i powertools tramite extension manager, c'è una
> nuova versione di questa dialog che è super-potente (in quella extension
> ci sono molte altre cose belle).
>
>> Ok, e siccome un file può avere più classi, non esiste nessuna
>> corrispondenza univoca. Meglio cmq
>
> esatto
>
>> qui devo studiare. Mai sentiti i template T4, li cercherò.
>
> Servono per generare sorgenti quando è possibile costruirli in modo
> programmatico partendo da metainformazioni. Diciamo come fanno i wizard
> di
vs.net
>
>
> [...]
>
>>> In realtà un assembly può avere più file e ci sono ottimi motivi per
>>> volerlo fare.
>>
>> domanda forse oziosa. E un solo file può avere più assembly o parti di
>> essi ? Tanto per saperlo
>
> No, un file può essere <= un assembly
okappa
>
>> si.
>> Ma tornando al problema di due eseguibili della stessa famiglia,
>> l'idea di avere tre assembly, invece dei tre progetti, due con le
>> parti specifiche, uno con la sola "intersezione" calzerebbe ?
>
> In
vs.net
 tre assembly implica tre progetti.
> Nel caso dei tuoi tre progetti di cui uno comune, sono comunque tre
> assembly.
> Le dipendenze tra assembly sono ovviamente una cosa molto comune, abbi
> solo l'attenzione di non avere referenze rircolari tra assembly.
si, un rischio del genere si ha anche implementando classi
con mutua dipendenza, non dovrei cascarci
>
>> O dovrei avere due progetti più un assembly comune (assumendo che un
>> assembly possa essere al di fuori di un progetto, ossia un "pezzo" di
>> codice a sé stante e che non viene compilato da solo a applicazione)
>> ma solo inglobato ... Lo so, ho infiniti dubbi
>
> vedi quanto ho scritto sopra ...
>
>>
>>
>> Rigrazie
>
> Prego
>
ciao
CCCP


title: Gestire metodi di ricerca in funzione delle impostazioni dell'operatore

author: Romano

text:
Ciao a tutti,
programmo in visual c# 2005 e volevo porre quesito per una corretta
impostazione di programmazione:
Vi spiego il mio problema:
Su un'applicazione desktop gestita con logica 3 Tier che attinge i dati
da un db Sql Server,
ho una maschera di ricerca il cui risultato è un list di miei oggetti
che vengono elencati su una datagridview.
Vengo al punto:
Supponiamo che l'operatore possa ricercare per :
Anno
Denominazione
Citta
Al comando 'TROVA', dell'operatore sulla mascherina deve essere eseguita
una funzione Find dove passo i parametri di ricerca impostati
dall'operatore.
C'è un modello da seguire per la gestione di ricerca ?
Mi spiego:
Nella classe gestione quante Find devo implementare ?
Find(anno)
FInd(anno, Denominazione)
Find(anno, Citta)
Find(Denominazione, Citta)
Ovviamente per ciascuna Find poi devo creare il suo omonimo nella parte
Dal per poi ricostruire la query da dare in pasto a Sql Server.
Non so se ho reso l'idea.
Ricerco documentazione in tal senso.
Thanks.


text:
Ciao Romano,
You wrote on 27/05/2011 :
> Non so se ho reso l'idea.
no :-)
> Ricerco documentazione in tal senso.
interface ISearchEngine
{
   IEnumerable<Results> Search( Criteria criteria );
}
dove Criteria è una cosa del tipo:
class Criteria
{
   public Int32 Year { get; set; }
   public String Naming { get; set; }
   public String City { get; set; }
}
> Thanks.
.m
--
Mauro Servienti
{C67C0157-5D98-4733-A75E-93CAEE4BADC8}
Microsoft MVP - Visual C# / MCTS
http://mvp.support.microsoft.com/profile/mauro
blog @
http://milestone.topics.it
whynot [ at ] topics [ dot ] it


text:
Il 27/05/2011 1:19 PM, Mauro Servienti [MVP] ha scritto:
>
> interface ISearchEngine
> {
> IEnumerable<Results> Search( Criteria criteria );
> }
>
> dove Criteria è una cosa del tipo:
>
> class Criteria
> {
> public Int32 Year { get; set; }
> public String Naming { get; set; }
> public String City { get; set; }
> }
Ti ringrazio di avere risposto al mio problema: Hai ragione
non sono stato molto chiaro nello spiegare il tutto.
Ho un paio di domande sulla tua risposta:
Intanto ti chiedo dove devo dichiarare l'interfaccia ?
Lato business object ?
Io non sono abituato ad utilizzare le interfacce e questo codice mi
spiazza un pò.
Cmq. voglio capire meglio.
Mi spieghi meglio dall'interfaccia utente fino alla Dal ?
Diciamo in modo schematico, dove si infila questa interfaccia nello
schema sotto ?
View----------------------> Business Logic ------------------> Dal
es.nel caso lineare: L'operatore ricerca per Anno.
View --> Gestione gest= new Gestione();
          List<mio_oggetto> elenco = gest.Find(Anno);
Business Logic-->   Class Gestione
                     Dal db= new Dal();
                     List<mio_oggetto> dati= db.Find(_anno);
Dal            -->  Class Dal
                     metodo TrovaDb(int anno);
                     metodo TrovaDb(int anno, Azienda az);
                     ...
                     ...
Thanks


text:
Ciao Romano,
On 5/27/2011 3:47 PM, Romano wrote:
> Intanto ti chiedo dove devo dichiarare l'interfaccia ?
> Lato business object ?
Io opterei per una cosa del genere:
http://martinfowler.com/eaaCatalog/queryObject.html
In sostanza dichiari un oggetto che rappresenta una query, come ha
suggerito Mauro con l'oggetto Criteria. Nella tua view, fai editare
l'oggetto all'utente e poi lo passi al servizio di business che
orchestra le chiamate al data layer "interpretando" l'oggetto Criteria.
HTH,
Giulio
--


text:

Ho capito questi punti e vi ringrazio.
Approfitto della vostra bontà per chiedervi perchè è utile l'utilizzo di
interface ISearchEngine
{
IEnumerable<Result> Search( Criteri criteri );
}
e poi chi deve ereditare questa interfaccia ?
Il Dal o la business logic ?
E' corretto scrivere cosi ?
  public class Dal:ISearchEngine
     {
         public List<Result> Search(Criteri criteri)
         {
             List<Result> elenco = null;
             return elenco;
         }
     }
Grazie e buon lavoro.


text:
Ciao Romano,
You wrote on 31/05/2011 :
> Ho capito questi punti e vi ringrazio.
> Approfitto della vostra bontà per chiedervi perchè è utile l'utilizzo di
>
> interface ISearchEngine
> {
> IEnumerable<Result> Search( Criteri criteri );
> }
la risposta non è esauribile in un post, purtroppo. Diciamo che entrano
in gioco parecchi concetti tra cui quelli di Separation of Concern, di
design by contract, di dependency injection e inversion of control.
> E' corretto scrivere cosi ?
>
>   public class Dal:ISearchEngine
>      {
>          public List<Result> Search(Criteri criteri)
>          {
>              List<Result> elenco = null;
>
>              return elenco;
>          }
>      }
>
si è corretto, ma non è detto che ti serva l'interfaccia, non c'è
scritto da nessuna parte che devi averla :-)
>
> Grazie e buon lavoro.



text:
> la risposta non è esauribile in un post, purtroppo. Diciamo che entrano
> in gioco parecchi concetti tra cui quelli di Separation of Concern, di
> design by contract, di dependency injection e inversion of control.
>
Mi che sei ermetico: Speravo in qualcosa di + concreto.
Comunque grazie e buona continuazione.


text:
Ciao Romano,

potrei farci un corso di 3 giorni su un argomento del genere :-P
Cerca "dependency injection" e "inversion of control".



text:
Ciao Mauro,
Ciao Romano,
On 6/2/2011 11:29 AM, Mauro Servienti [MVP] wrote:
> potrei farci un corso di 3 giorni su un argomento del genere :-P
Ok, se lo fai fammi un fischio. :-)
Scherzi a parte, per come l'ho messa io, l'interfaccia andrebbe fatta
ereditare dal business layer per una questione pratica. La definizione
della classe che implementa il criterio deve essere visibile nel
presentation layer che "vede" il bsuiness layer. Implementare il tutto
nel DAL significherebbe dover inserire questa dipendenza (DAL -> BL) che
dovrebbe essere risolta con una cosa tipo separated interface (i.e.
estraendo la definizione dei criteri in un ulteriore assembly/componente
visibile da tutti). Ora, 'sta cosa mi darebbe non poca noia... :) quindi
io impementerei l'interfaccia per la ricerca come servizio di business.
Detto questo, va comunque detto che Mauro ha ragione e che l'argomento
non è facilmente risolvibile con un "fai così". Quella che ho proposto
io è *una* soluzione, non è detto che sia la migliore né tantomeno
quella più adatta al tuo caso. Può comunque essere un punto di partenza.
buon lavoro e facci sapere come va a finire,
Giulio
--


text:
Ciao Giulio,
You wrote on 03/06/2011 :
> Ok, se lo fai fammi un fischio. :-)
sarà fatto :-)
> Scherzi a parte, per come l'ho messa io, l'interfaccia andrebbe fatta
> ereditare dal business layer per una questione pratica. La definizione della
> classe che implementa il criterio deve essere visibile nel presentation layer
> che "vede" il bsuiness layer. Implementare il tutto nel DAL significherebbe
> dover inserire questa dipendenza (DAL -> BL) che dovrebbe essere risolta con
> una cosa tipo separated interface (i.e. estraendo la definizione dei criteri
> in un ulteriore assembly/componente visibile da tutti). Ora, 'sta cosa mi
> darebbe non poca noia... :) quindi io impementerei l'interfaccia per la
> ricerca come servizio di business.
condivido.



title: Lavorare con bitmap

author: vbMizio

text:
Ciao,
Sto lavorando da un po' con DirectShow, DirectX e roba simile.
Quello che sto facendo adesso e', dato un filmato, recuperare uno screenshot
ad un dato frame. Tutto ok, funziona, ma....
per fare questo utilizzo una mia funzione (DirectShow) che restituisce una
bitmap (se volete vi mostro come faccio), la cui proprieta' RawFormat e'
MemoryBMP *non so se questo particolare puo' servire*

Devo poi visualizzare questa bitmap in un controllo PictureBox, e purtroppo
per fare questo devo prendere la bitmap originale, salvarla in un file
temporaneo, disporre (si dice cosi' in italiano?) la bitmap originale,
creare una nuova Image, caricare il file temporaneo creato, ed andare avanti
cosi'.

Purtroppo non ho trovato un modo per ottenere la seconda image senza passare
per il salvataggio e il caricamento del file temporaneo.
Dati SourceBmp come la bitmap presa da DirectShow, e DestBitmap come la
Image che dovro' usare, ho provato anche:

DestBitmap  = new Bitmap (SourceBitmap)
oppure
DestBitmap = SourceBitmap.GetThumbnail (bla bla )
ma ottengo sempre una immagine nera.
Come posso fare per evitare di passare per il salvataggio?
Mi sarebbe anche utile poter avere la destinazione in un formato diverso da
bmp. E' probabile che dovro' poi rendere persistenti questi dati in un file
XML, ed ho notato che salvando (e poi caricando) la prima immagine in jpg,
risparmio un bel po' di spazio rispetto al bmp; naturalmente non mi
riferisco alla dimensione del file temporaneo creato, ma al file xml creato.
Spero di essere stato abbastanza comprensibile.


title: Lavorare con bitmap

text:
P.s.
Naturalmente per velocita', anziche' usare un file per salvare e caricare
l'immagine, sto usando un memorystream, ma il succo della situazione non
cambia.


title: Wpf quanti tasti sto tenendo premuti?

text:
Ciao a tutti,
ho una domandina da porre.
Ho un controllo wpf, hostato su una form; quando premo un tasto (diciamo lo
0) deve partire una certa routine. Per far cio' vado a vedere, nell'evento
KeyDown, se la proprieta' Key dell'argomento di tipo
System.Windows.Input.KeyEventArgs e' Key.D0 oppure Key.NumPad0, e fin qui
tutto ok.
Mi e' venuto in mente che questa routine viene chiamata anche se,
contemporaneamente al tasto "0", sto tenendo premuto un qualunque altro
tasto, e questo non e' il comportamento che mi piacerebbe ottenere.
Ho modo di sapere se, oltre al mio "0", sto tenendo premuto anche altri
tasti? Naturalmente non mi basta andare a controllare i vari Control, Shift
ecc.. ma dovrei sapere se un qualunque altro tasto e' stato premuto.
Spero di essermi spiegato :-)
Uso VB2008
Grazie e ciao... Maurizio


title: Wpf quanti tasti sto tenendo premuti?

author: dmaxime

text:

Ciao,
se non hai bisogno di sapere anche quali sono i tasti premuti dovrebbe
esserti sufficiente aggiungere un contatore che incrementi ad ogni
KeyDown e decrementi ad ogni KeyUp. Quando ricevi il tasto che ti
interessa non dovrai far altro che verificare che il contatore valga 1.


title: Wpf quanti tasti sto tenendo premuti?

text:
ciao dmaxime, grazie della risposta
...
>se non hai bisogno di sapere anche quali sono i tasti premuti dovrebbe
esserti sufficiente aggiungere un contatore che incrementi ad ogni
KeyDown e decrementi ad ogni KeyUp.
...
Si si, a questo avevo gia' pensato. Speravo pero' in una soluzione un po'
piu' elegante.
Grazie e ciao... Maurizio


title: Wpf quanti tasti sto tenendo premuti?

text:
Elegante? Non so cosa tu intenda per 'elegante'; invece definirei poco
elegante un qualsiasi accrocchio  differisca da questa soluzione.

Un saluto.


title: Wpf quanti tasti sto tenendo premuti?

text:
Ciao vbMizio,

You wrote on 27/09/2011 :
> Mi e' venuto in mente che questa routine viene chiamata anche se,
> contemporaneamente al tasto "0", sto tenendo premuto un qualunque altro
> tasto, e questo non e' il comportamento che mi piacerebbe ottenere.

ti è venuto in mente o hai verificato che è così? perchè a me un po'
puzza che non sia possibile, mi sa che i "modifier key" sono gli unici
che possono essere premuti insieme ad un altro key. Per tutti gli altri
dovresti avere eventi separati.

.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: Wpf quanti tasti sto tenendo premuti?

text:
Ciao,
...
>Elegante? Non so cosa tu intenda per 'elegante'; invece definirei poco
elegante un qualsiasi accrocchio  differisca da questa soluzione.
...
Tanto per dire, se potessi controllare lo statade esempio, della tastiera, e
vedere quanti tasti sono premuti, sarebbe un modo "piu' elegante" :-)
Cmq, il metodo che hai suggerito, e che avevo pensato anche io, non dovrebbe
essere malaccio :)
Grazie ancora


title: Wpf quanti tasti sto tenendo premuti?

text:
Ciao Mauro, grazie per la risposta,
...
>ti è venuto in mente o hai verificato che è così? perchè a me un po'
puzza che non sia possibile, mi sa che i "modifier key" sono gli unici
che possono essere premuti insieme ad un altro key.
...
Ho verificato perche' mi e' venuto in mente :-)
Mi spiego meglio, forse non sono stato troppo chiaro...
Diciamo che, come da primo esempio, voglio "reagire" alla pressione del
tasto "0", ma solo se e' premuto esclusivamente lui.

Come prima cosa premo (e tengo premuto) il tasto "x", parte l'evento
KeyDown, vedo che non e' il tasto che mi interessa, e passo oltre.

Mentre sto ancora tenendo giu' il tasto "x", premo il tasto "0", che e'
proprio quello che serve a me, parte, come dici tu, un suo evento KeyDown, e
nella gestione dello stesso dovrei fare tutte quelle cose che ho
previsto.... pero' solo se non ci sono altri tasti premuti.


title: Wpf quanti tasti sto tenendo premuti?

text:
Ciao vbMizio,

You wrote on 29/09/2011 :
> Mentre sto ancora tenendo giu' il tasto "x", premo il tasto "0", che e'
> proprio quello che serve a me, parte, come dici tu, un suo evento KeyDown, e
> nella gestione dello stesso dovrei fare tutte quelle cose che ho previsto....
> pero' solo se non ci sono altri tasti premuti.

questo perchè la combinazione x+0 ha un significato diverso?



title: Wpf quanti tasti sto tenendo premuti?

text:
...
>questo perchè la combinazione x+0 ha un significato diverso?
...
No no, x+0 non ha nessun significato


title: Wpf quanti tasti sto tenendo premuti?

text:
Ciao vbMizio,

You wrote on 29/09/2011 :

rieccomi, quindi dove sta il problema? tu avrai sempre e solo l'evento
per 0 e mai per X, se l'utente nel frattempo preme anche altro perchè
dovrebbe essere un problema?



title: Modellazione Quiz

author: Riddler ?

text:
Salve a tutti,
Ho visto che ormai è defunto microsoft.public.it.dotnet.asp quindi
riposto quì ... era un pò che non venivo a chiederVi aiuto ;-)
Vorrei creare una struttura tipo List<string> in cui caricare i vari
quiz 1,2,3,4
ogni quiz avra le sue n domande visualizzate a gruppi di 4-5.
Le domande potranno essere "classiche" tipo
Qual'è la capitale d'Italia? risp.Roma
o matematiche:
Quanto fa 3x4? risp.12
Fin quì niente di particlare se non che vorrei che in caricamenti
differenti i quiz proposti e le domande dei relativi quiz vorrei che
NON fossero sempre nello stesso ordine, ma se non erro non è possibile
fare uno shuffle dell'oggetto List ... è corretto?
Attualmente le domande dei quiz le metterà ò a mano ma mi piacerebbe
fare un metodo Load, magari un domani rimpiazzato con un caricamento
da file ex XML.
Vorrei includere anche nel gruppo di domande qual'è quella corretta in
modo da sapere subito se l'utente ha o meno selezionato quella
corretta.
Come dite si possa modellare una cosa del genere?
Grazie in anticipo
--
Riddler ?


title: Modellazione Quiz

text:
Avrei pensato ad una modellazione del genere:
Quiz
---> Type ---> Math, Logic, ...
---> Questions ---> domanda1, domanda2 ... domandaN
In cui domanda ha le seguenti risposte:
domandaN ---> risp1, risp2, risp3, risp4
in cui a loro volta le varie risposte sono così formate:
ripN ---> text, isCorrect
cosa ne dite?
Una volta caricato il Quiz, le risposte dovranno poi essere piazzate
casualmente su dei bottoni e vorrei tenere traccia se la risposta
fatta è o meno corretta.
saluti
--
Riddler ?


title: Modellazione Quiz

text:
Modellazione ... cosa ne dite?
Per randomizzare l'ordine dei quiz ho intenzione di utilizzare una
funzione che randomizzi n numeri a seconda delle domande, per esempio
10 Quiz a 10 domande (io avrei una raccolta superiore)
ne pesco a caso 5 ... e visualizzo a caso le risposte ..
Per il quin in sè invece lo modelerei così
public class Answer{
	public string answer;
	public bool isCorrect;
	public Answer(){
		answer = "";
		isCorrect = false;
	}
}
/// <summary>
/// Quiz class
/// <param name="type"> quiz type
/// <param name="nQuest"> questions number
/// <param name="question"/> Quiz's questions
/// </summary>
///
public class Quiz
{
	private static int nAnswer = 4; // max number of answer...
	public IEnumerable<string> type =
{"Funny","Logic","Math","General"};
	public int nQuest;
	public List<Question> questions;
	public Quiz ()
	{
		type = "";
		nQuest = 0;
		questions = new List<string>();
	}
}
che dite?
--
Riddler ?


title: Set di colori rilassanti per visual studio 2008 es. Backgroud verde

text:
Ciao a tutti,
esiste un set di colori rilassanti per visual studio 2008 in modo che lo
lancio e cambia tutto senza ogni volta cambiare le singole voci ?
Thanks


text:
Qui trovi tutti i temi che vuoi, comprese le istruzioni per
installarli.
http://studiostyl.es/
Ecco, lo sfondo verde non so quanto sia rilassante, personalmente ti
consiglio qualcosa di scuro, io uso Selenitic e mi trovo molto bene
http://studiostyl.es/schemes/selenitic
HTH,
mt



author: nibble

text:
esiste qualcosa di simile per la versione EXPRESS?
ciao


title: OT- Considerando che questo è un NG...

author: AleTV

text:
domando, ma non esiste proprio nessuna piattaforma web-based che permetta di
gestire le discussioni con la stessa interfaccia che offrono i vari client
NG?
Quindi non forum dove la discussione è piatta, ma qualcosa che permetta di
avere sott'occhio la gerarchia che può sviluppare a fronte di un thread.
Deve esistere, per forza...


title: OT- Considerando che questo è un NG...

author: Midnightmare

text:
"AleTV" <
sti...@libbero.it
> ha scritto:
> Deve esistere, per forza...
Prova
http://www.mynewsgate.net


title: OT- Considerando che questo è un NG...

text:
On Dec 21, 7:30 pm, "AleTV" <
sti...@libbero.it
> wrote:
> domando, ma non esiste proprio nessuna piattaforma web-based che permetta di
> gestire le discussioni con la stessa interfaccia che offrono i vari client
> NG?
> Quindi non forum dove la discussione piatta, ma qualcosa che permetta di
> avere sott'occhio la gerarchia che pu sviluppare a fronte di un thread.
> Deve esistere, per forza...
Google... anche se trovo la nuova interfaccia inutilizzabile, per cui
sono rimasto alla vecchia. Ci trovi opzioni per la tree view, e per
vedere i post in fixed font.
-LV


title: OT- Considerando che questo è un NG...

text:
"Midnightmare" <
midnightm...@live.it
> ha scritto nel messaggio
news:4d11046b$0$10579$4faf...@reader1.news.tin.it...
> "AleTV" <
sti...@libbero.it
> ha scritto:
>
>> Deve esistere, per forza...
>
> Prova
http://www.mynewsgate.net
>
Proprio, ecco, una cosa così, ma da integrare in un sito.
Cioè dei vari cms in giro ce n'è qualcuno che offre una sezione forum con
interfaccia di quel genere?