[C#] File lock/unlock

[MonsterMash]

Salve a tutti.
A quanto ho capito googlando un po' in c# non esiste il file locking. Da qualche parte ho letto addirittura che l'unico modo per gestire un accesso conteso allo stesso file è di aspettare che venga generata l'eccezione, e quindi nel catch mettere un cosa del tipo: "aspetta qualche millisecondo e poi riprova ad accedere al file"...
Onestamente mi sembra una soluzione abbastanza brutta, e neanche sempre attuabile. Mi sapete dare un metodo alternativo?

Grazie a tutti.

Ciao

[Stoicenko]

Bè dipende da cosa vuoi fare col file.. Se devi accedere in sola lettura puoi accedere anche in multiutenza tramite l'api di windows CreateFile..

Se devi modificare il file allora devi rimanere in ascolto dell'eccezione generata in caso il file sia già aperto in scrittura..

[MonsterMash]

Originariamente inviato da Stoicenko
Bè dipende da cosa vuoi fare col file.. Se devi accedere in sola lettura puoi accedere anche in multiutenza tramite l'api di windows CreateFile..

Se devi modificare il file allora devi rimanere in ascolto dell'eccezione generata in caso il file sia già aperto in scrittura..

Devo scrivere un file di log ogni volta che viene chiamato un oggetto. Il problema è che questo oggetto viene chiamato da più thread, e quindi lo stesso file di log viene scritto da più thread.
A me sembra una cosa scomodissima dover continuare a tentare la scrittura fino a quando l'eccezione non viene più generata. In c era molto più semplice...

[Stoicenko]

Ma se ti fai una classe che scrive il log non è meglio?

Gestisci la classe come classe statica (così non hai bisogno di mille riferimenti) con all'interno una variabile object che ti serve come semaforo per la concorrenza..

Ti scivi un metodo statica Scrivi(string log) con:

public static void Scrivi(String log)
{
      lock(objLock)
      {
           //qui scrivi il log
      }
}

con il lock sei sicuro che i thread scrivano uno alla volta

[MonsterMash]

Originariamente inviato da Stoicenko
Ma se ti fai una classe che scrive il log non è meglio?

Gestisci la classe come classe statica (così non hai bisogno di mille riferimenti) con all'interno una variabile object che ti serve come semaforo per la concorrenza..

Ti scivi un metodo statica Scrivi(string log) con:

public static void Scrivi(String log)
{
      lock(objLock)
      {
           //qui scrivi il log
      }
}

con il lock sei sicuro che i thread scrivano uno alla volta

A dire il vero non sono sicuro di aver capito bene cosa fa l'istruzione lock.
A quanto ho capito blocca l'accesso ad un oggetto finchè non è stato eseguita una porzione di codice tra parentesi graffe. Cioè se scrivo:

lock(myObject)
{
      //codice da eseguire
}

esege il codice impedendo che nel mentre l'oggetto myObject venga usato da qualche altro thread. E' giusto?

[Stoicenko]

Giusto.. in questo modo usi una specie di semaforo per impedire che 2 thread accedano al fine in contemporanea.. in java si usa il blocco syncronized in c++ si usano i semafori..

[MonsterMash]

Ah, ma quindi se più thread arrivano all'istruzione lock(myObject), solo una alla volta eseguirà il codice seguente? Ovviamente a patto che l'oggetto myObject sia lo stesso per entrambi i thread.

Cmq, dato che il metodo che esegue il log è un metodo statico e quindi non ho un oggetto che possa essere lo stesso per tutte le chiamate a quel metodo, questo sistema non posso usarlo.
Al momento ho risolto (ma forse è meglio dire "ho tamponato") usando un goto. Quando viene sollevata l'eccezione perchè il file è già aperto da un altro thread riprovo ad accedervi con un goto.

[Stoicenko]

Mamma mia un goto??? Assolutamente te lo sconsiglio..

Cmq, dato che il metodo che esegue il log è un metodo statico e quindi non ho un oggetto che possa essere lo stesso per tutte le chiamate a quel metodo, questo sistema non posso usarlo.

forse non ti è chiaro cosa voglia dire statico.. è assolutamente il contrario di quello che affermi.. l'essere statico ti da la certezza che ci sia sempre una e solo "un'istanza" (parola non corretta) di quell'oggetto (da chiamare staticamente) per tutta l'applicazione.. quindi una chiamata a:

classeStaticaLog.scriviLog("test");

chiamata da più thread si riferirà sempre allo stesso metodo dello stesso oggetto statico..
quindi il lock serve eccome..

[MonsterMash]

Originariamente inviato da Stoicenko
Mamma mia un goto??? Assolutamente te lo sconsiglio..



forse non ti è chiaro cosa voglia dire statico.. è assolutamente il contrario di quello che affermi.. l'essere statico ti da la certezza che ci sia sempre una e solo "un'istanza" (parola non corretta) di quell'oggetto (da chiamare staticamente) per tutta l'applicazione.. quindi una chiamata a:

classeStaticaLog.scriviLog("test");

chiamata da più thread si riferirà sempre allo stesso metodo dello stesso oggetto statico..
quindi il lock serve eccome..

Innanzitutto, anche se ormai è da un po' che programmo, non conosco tutti gli strumenti, le tecniche e la terminologia, e di solito mi affido solo alla mia fantasia per risolvere i problemi, per cui se quello che dico è sbagliato o impreciso chiedo scusa.
Ora vediamo se ho capito quello che mi hai detto di fare. Attualmente quando si verifica un dato evento viene lanciato un metodo statico che mi serve a registrare su un file di log informazioni su quell'evento. Lo stesso metodo statico viene chiamato da più thread, per cui può capitare che più thread tentino di scrivere lo stesso file generando un conflitto. A questo punto tu mi suggerisci di usare all'interno del metodo statico che registra i log il costrutto:

lock(myObject)
{
     // Scrittura del log sul file
}

In modo che se un secondo thread chiama il metodo statico per la scrittura del log mentre questo è ancora in uso da parte di un altro thread, si troverà a voler fare un lock sull'oggetto myObject, già lockato dall'altro thread, e quindi aspetterà che l'oggetto venga liberato prima di eseguire la scrittura del file.
Ora il problema è: cosa è myObject? E dove lo devo dichiarare? Se il metodo (e la classe in cui esso è) è statico non può usare oggetti o in generale variabili dichiarate nella parte iniziale della classe (quella prima della scrittura dei suoi metodi, per intenderci), o almeno io ci ho provato ma il metodo statico non riconosce quelle variabili, anche se dichiarate public.

Cosa c'è dunque che mi sfugge di quello che mi hai detto di fare? In definitiva, da dove lo prendo l'oggetto su cui eseguire il lock?

Grazie.

Ciao

[Stoicenko]

l'oggetto su cui fai il lock può benissimo essere di tipo object e statico dichiarato dentro la classe statica che fa il log