Newsgroup: it.comp.lang.visual-basic
Titolo: Liberare forzatamente un file in uso da altra applicazione.

Esiste un modo (magari brutale...) di liberare un file bloccato da un'altro
processo?
tramite magari API o simili??
(mi sembra di aver capito che il Sistema operativo memorizza da qualche
parte lo stato dei file bloccati...
pensavo si potresse andare a liberarne uno...)
Grazie
Cristina

Io non ho mai provato ma cercando su google ho trovato un po' di roba
interessante...
Private Declare Function TerminateProcess Lib "kernel32" (ByVal hProcess
As Long, ByVal uExitCode As Long) As Long
http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dllproc/base/process_and_thread_functions.asp
(Da un post di hal)
Il codice sotto la firma va copiato in un modulo .bas e per provarlo va
lanciata
la TerminateApp.
Ho aggiunto un po' di commenti che illustrano anche dove reperire le
informazioni
necessarie.
---------------------------- inizio codice -----------------
Option Explicit
'// costanti tratte da : HOWTO: Constants in OpenProcess API dsDesiredAccess
Parameter
'// 
http://support.microsoft.com/support/kb/articles/q172/2/73.asp?FR=0
Private Const PROCESS_TERMINATE = &H1 'Enables using the process handle in
the
            'TerminateProcess function to terminate the process.
Private Const SYNCHRONIZE = &H100000   'Enables using the process handle in
any of the
            'wait functions to wait for the process to terminate.
'// costanti recuperate con Google
Private Const WAIT_OBJECT_0 = 0&
'// costante di comodo per mappatura con il codice c++
Private Const pNULL = 0&
'// dichiarazioni tratte dall' API viewer di vb
'      --- kernel32
Private Declare Function CloseHandle Lib "kernel32" ( _
                        ByVal hObject As Long _
                        ) As Long
Private Declare Function OpenProcess Lib "kernel32" ( _
                        ByVal dwDesiredAccess As Long, _
                        ByVal bInheritHandle As Long, _
                        ByVal dwProcessId As Long _
                        ) As Long
Private Declare Function TerminateProcess Lib "kernel32" ( _
                        ByVal hProcess As Long, _
                        ByVal uExitCode As Long _
                        ) As Long
Private Declare Function WaitForSingleObject Lib "kernel32" ( _
                        ByVal hHandle As Long, _
                        ByVal dwMilliseconds As Long _
                        ) As Long
'       --- user32
Private Declare Function EnumWindows Lib "user32" ( _
                        ByVal lpEnumFunc As Long, _
                        ByVal lParam As Long _
                        ) As Long
Private Declare Function GetWindowThreadProcessId Lib "user32" ( _
                        ByVal hwnd As Long, _
                        ByRef lpdwProcessId As Long _
                        ) As Long
Private Declare Function PostMessage Lib "user32" Alias "PostMessageA" ( _
                        ByVal hwnd As Long, ByVal wMsg As Long, _
                        ByVal wParam As Long, ByVal lParam As Long _
                        ) As Long
Private Const WM_CLOSE = &H10
''''''''''''''''''''''''''''''''''''''''''''''''''''
'// codice liberamente portato dall' esempio in c++ su msdn:
'// HOWTO: Terminate an Application "Cleanly" in Win32
'// Q178893
'//
'// Per ottenere il PID del processo vedere l' articolo su msdn:
'// HOWTO: List Running Processes
'// Q187913
'//
Public Function TerminateApp(ByVal dwPID As Long, ByVal dwTimeout As Long)
As Boolean
    Dim hProc As Long
    '// If we can't open the process with PROCESS_TERMINATE rights,
    '// then we give up immediately.
    hProc = OpenProcess(SYNCHRONIZE Or PROCESS_TERMINATE, 0&, dwPID)
    If (hProc = pNULL) Then Exit Function
    '// TerminateAppEnum() posts WM_CLOSE to all windows whose PID
    ' // matches your process's.
    EnumWindows AddressOf TerminateAppEnum, dwPID
    '// Wait on the handle. If it signals, great. If it times out,
    '// then you kill it.
    If (WaitForSingleObject(hProc, dwTimeout) <> WAIT_OBJECT_0) Then
         If (TerminateProcess(hProc, 0)) Then
            '// dirty termination
            TerminateApp = True
         End If
    Else
        '// clean termination :-)
         TerminateApp = True
    End If
    CloseHandle (hProc)
End Function    '// TerminateApp
Private Function TerminateAppEnum(ByVal hwnd As Long, ByVal lParam As Long)
As Long
    Dim dwID As Long
    Call GetWindowThreadProcessId(hwnd, dwID)
    If (dwID = lParam) Then
        Call PostMessage(hwnd, WM_CLOSE, 0, 0)
    End If
    TerminateAppEnum = 1
End Function    '// TerminateAppEnum
---------------------------- fine codice --------------------------------
-- 
Le persone non sono il proprio comportamento: devi sempre andare oltre,
essere flessibile, capire il punto di vista degli altri, interpretarne i
comportamenti ed intuirne le esigenze.
Per rispondere in privato elimina
dall'indirizzo "togliquesto"
MasterDavidex
David Ruscelli
"Cristina" <Pi...@Pika.it> ha scritto nel messaggio
news:Um8bc.7101$rM4.2...@news4.tin.it...


 ha scritto nel
messaggio news:c4j4u5$2hrg7j$1...@ID-110499.news.uni-berlin.de...


 Comunque grazie per l'impegno.
Sì fa quel che si può...

 (o forse non ho capito nulla è nel tuo esempio c'è proprio la soluzione,



 soluzione, i file loccati sono visti come Thread?? strano...)
no, lui dice che l'unico modo per togliere il lock dal file è
terminare 
l'applicazione che lo locka... anche se non ne sono troppo convinto, 
specie se per terminarla usi la TerminateProcess.
Ciao,
Moreno
Inviato da 
www.mynewsgate.net

 specie se per terminarla usi la TerminateProcess.
Io per primo ho dei dubbi sull'effettivo funzionamento...


tramite magari API o simili??
Non e' per niente banale: credo che l'unico modo sia iniettare del
proprio codice nel processo remoto.
In teoria si tratterebbe di creare nel processo remoto un thread
aggiuntivo, all'interno del quale chiamare la CloseHandle()
sull'handle al file.
In pratica io cercherei un'altra soluzione, cioe' eviterei di 
far bloccare il file o di non aver bisogno di usarlo mentre e'
bloccato ;-)
-- 
ciao, un hal di passaggio