SAlve a tutti....
ho un gridview, faccio selezionare l'intera riga e quello che vorrei fare è questo, quando con il mouse mi viene visualizzato sulla form l'anteprima di una immagine il cui path è salvato nel datagrid...e se faccio invece il doubleclick mi si apre una nuova form con tutti i dettagli relativi a tale riga seleziona.....

facile no??....

il problema che quando faccio il doubleclick parte anche l'evento click!!!.....è possibile?

Sì, anzi per l'esattezza viene scatenato prima l'evento _Click e poi il _DoubleClick.

Potresti sfruttare l'evento _SelectionChanged invece che il _MouseClick per visualizzare l'anteprima dell'immagine e poi sfruttare il _DoubleClick per aprire la form.

Altrimenti cambia strategia utilizzando un menù a pop-up (ContextMenuStrip) da richiamare col tasto dx del mouse.

Andrea

Anche se fa schifo una soluzione c'è. Potresti far si che l'evento OnClick parta con ritardo e se in tale intervallo si scatena il DoubleClick inibisci il Click..... Dovrebbe essere una roba del genere (verifica perche lo scrivo cosi senza provarlo in vs)


volatile bool doubleClick = false;


private void DataGridView1_OnClick(Object sender, EventArgs e)
{
for (int i = 0; i < 200; i++)
{
Thread.Sleep(1);
if (doubleClick)
return;
}

/* codice dell OnClick */
}

private void DataGridView_DoubleClick(Object sender, EventArgs e)
{
doubleClick = true;

try
{
/* codice del DoubleClick */
}
finally
{
doubleClick = false;
}
}



In questo caso si attendono 200 ms approssimativamente....

Non credo che questa soluzione funzioni per due motivi: uno logico e l'altro architetturale:
Gli eventi OnClick e DoubleClick vengono scatenati in sequenza, quindi se tu interrompi il Thread principale su OnClick non è detto che l'evento double click si verifichi esattamente nell'intervallo di tempo impostato, quindi alla fine se è scaduto lo sleep ti perdi anche l'evento DoubleClick ed il cliente ti maledice perchè gli hai "rotto il mouse" dato che non lo vede reagire come lui si aspetta.
Il secondo motivo è puramente architetturale, ovvero le Winform reagiscono a eventi standard del sistema operativo generati in una certa sequenza, quindi non ha il minimo senso invertire l'ordine degli eventi. Esistono altri sistemi per ottenere il risultato che giobaxx vuole ottenere come Andreaz ha illustrato perfettamente e che tra l'altro segue il "corso naturale degli eventi" che le Winforms generano. L'evento Click è un evento troppo generico per essere usato come evento di visualizzazione dei dati della GridView perchè l'utente potrebbe aver cliccato la gridview in qualsiasi punto oppure potrebbe aver usato le freccette della tastiera per navigare tra i records e quindi l'evento Click non verrebbe gerato. Fortunatamente i progettisti della GridView hanno pensato di introdurre appositi eventi proprio per fare questo, come Andreaz ha spiegato molto bene.
HTH
Alberto

....ehm, volevo fare il magnifico ed ho scritto delle gran cazz.... eccoti il codice giusto, verificato su vs2008:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Threading;

namespace WindowsFormsApplication1
{
public partial class Form1 : Form
{
volatile bool dataGridDoubleClick = false;

public Form1()
{
InitializeComponent();
}

private void Form1_Load(object sender, EventArgs e)
{
List cellsList = new List();
cellsList.Add(new DataGridInfo());
dataGridView1.DataSource = cellsList;
}

private void dataGridView1_CellMouseClick(object sender, DataGridViewCellMouseEventArgs e)
{
Thread waitThread = new Thread(delegate()
{
for (int i = 0; i < 20; i++)
{
Thread.Sleep(1);
if (dataGridDoubleClick)
return;
}
/* codice tuo */
MessageBox.Show("Click");
/* fine codice tuo */
});
waitThread.Start();
}

private void dataGridView1_CellMouseDoubleClick(object sender, DataGridViewCellMouseEventArgs e)
{
dataGridDoubleClick = true;

/* codice tuo */
MessageBox.Show("DoubleClick");
/* fine codice tuo */

dataGridDoubleClick = false;
}
}

class DataGridInfo
{
String name = "enzo";

public String Name
{
get { return name; }
set { name = value; }
}
int age = 34;

public int Age
{
get { return age; }
set { age = value; }
}
}
}


Stai attento che nel thread asincrono eventuali chiamate ad oggetti del form devono essere gestite correttamente... this.Invoke( ecc.

Si vero, infatti bisogna creare un thread a parte... se provi il codice che ho scritto dopo vedrai che funziona... anche se ammetto che è una soluzione penosa.

allego la soluzione completa se serve.

Comunque è una soluzione che non mi piace per niente, anche se funziona. Però ci sei molto vicino perchè una soluzione meno penosa esiste sempre usando gli stessi eventi, ovvero lanci in un thread separato attraverso un backgroundworker l'operazione di caricamento dell'immagine (che è anche + logico) e caso mai ne interrompi l'azione (oppure no) se viene scatenato l'evento DoubleClick. In questo modo rendi asincrono ciò che deve essere reso asincrono, ovvero il caricamento dell'immagine e non l'evento OnClick.
HTH
Alberto.

Non per fare discussione... ma mi sembra brutto abortire a metà il caricamento di un immagine (ma anche di altri compiti). Come dici te ogni volta che uno fa il doppio click vedrebbe subito un immagine che comincia a caricarsi e si interrompe subito. Dato che, come hai detto, la sequenza degli eventi è 1) click 2) doppioclick, e dato che quando si comincia a fare il doppio click il pc non può prevedere il futuro, la soluzione più logica è aspettare un intervallo di tempo entro il quale potrebbe essere triggerato un doppio click, e se davvero avviene, far partire il codice del doppio click, altrimenti se non avviene quello del click.

E dov'è scritto? Se in quel momento non serve caricarla è brutto farlo non è brutto interrompere il caricamento.Come ti ho già spiegato la soluzione più logica è lasciare che le operazioni da eseguire vengano gestite negli eventi corretti, il caricamento di un'immagine memorizzata in un record di una DataGridView non deve essere gestita attraverso l'evento click perchè ciò che ci interessa in quel momento è sapere quale record della DataGridView è il record corrente al fine di individuare il path corretto del file (questa era la richiesta di giobaxx) e non sapere se l'utente ha fatto click sulla DataGridView. Quindi ciò che è sbagliato è l'approccio al gestore eventi, giobaxx sta usando l'evento sbagliato per caricare l'immagine e la prima risposta di Andreaz è la + corretta di questo thread e ti spiego perchè:
1) Il click viene scatenato quando l'utente preme su qualsiasi punto della datagridview non necessariamente c'è una modifica della posizione del record corrente, quindi l'immagine non deve essere caricata
2) L'utente può modificare la posizione della riga corrente anche agendo sulle freccette da tastiera e quindi NON scatenando l'evento click con la conseguenza che l'immagine non viene caricata
3) L'utente può costantemente cliccare la stessa riga anche n volte di seguito con conseguente caricamento dell'immagine per n volte
4) Il caricamento di un'immagine può richiedere molto tempo e va gestita come fosse un'operazione asincrona poichè non si sa bene la dimensione della stessa.
5) Non è detto che l'operazione di caricamento dell'immagine debba essere portata a completamento e per questo devo avere la possibilità di verificare le condizioni e di interromperla usando un'operazione asincrona attraverso un backgroundworker oppure attraverso un delegate su thread separato.
6) Non ha alcun senso gestire un evento sincrono come il click o il double click attraverso una procedura asincrona perchè potrebbe dar luogo a comportamenti imprevisti nei confronti dell'utente, sopratutto nel caso in cui si accavallino gli eventi. Prova a gestire le cose come tu hai detto e a cliccare ripetutamente sulla datagridview e vedi cosa succede... in alcuni casi ti sposti su un altro record e non ti carica l'immagine oppure credi di aver fatto doppio click e non succede niente perchè il pc non recepisce le istruzioni corrette.
7) Prova a modificare l'intervallo del doppio click sul sistema operativo e poi mi dici cosa succede mantenendo gli intervalli come hai impostato sulla procedura.

Spero di aver sufficientemente chiarito la cosa e che giobaxx abbia sufficienti elementi in mano per valutare la soluzione migliore per lui e se necessiti di ulteriori spiegazioni sulle tecniche proposte basta fare un fischio.
HTH
Alberto.

Ma che l'approccio sia sbagliato son d'accordissimo.... altrimenti non avrei detto che è una soluzione penosa. Dico solo che se uno vuole , per qualche motivo sbagliato o giusto che sia, far si che l'evento click attenda un eventuale evento doppio click allora quello mi sembra un buon 'raggiro'.
Anche io avrei fatto qualcosa di simile alla soluzione da te citata.

Mi fa piacere che siamo d'accordo e che un bravo sviluppatore C# si sia fatto avanti nelle risposte oltre alla Sabrina e pochi altri... Grazie per il tuo prezioso intervento.

Alberto.

Figurati! Grazie del bravo!