[nelson2391]

[code]
For Each f1 In diar1
f1.Delete()
'lblnumber.Text = "C:\WINDOWS\Temp\" + dra.Name.ToString()
Next
[code\]

but i got this error message,
"The process cannot access the file 'kls3FBE.tmp' because it is being used by another process."

How can i check the file is currently using or not?

Thanks in advance..

[Jeff H]

One method is to use a try catch block but to be more specific use A IOException

        Try

        Catch ex As IOException


        End Try

[nelson2391]

okay, but, if any error occur, it just skip. But i need to know is it currently using or not, without a skip.

[Jeff H]

If Catch block is empty then it just skips it and if the try catch is inside or contains the for each loop it will change its behavior.


You might want to post your code that fills diar1 and are you sure you are closing all resources?

I like to use a using block because it close it, call dispose if needed, and the compiler will generate a try catch finally block for you and call dispose etc.. for you in finally block.


A simple console app to show try catch

Imports System.IO

Module Module1

    Sub Main()
        Dim fStream As New FileStream("C:\Hpad\Test\TestOpen.txt", FileMode.Open)

        For Each fileName In Directory.GetFiles("C:\Hpad\Test")
            Try
                File.Delete(fileName)
            Catch ex As IOException
                Console.WriteLine(String.Format("{0} {1} created error {1} {2}", fileName, Environment.NewLine, ex.Message))
            End Try

        Next

        Console.ReadLine()

    End Sub

End Module

Same one updated that will not cause an error because of 'using' block

Imports System.IO

Module Module1

    Sub Main()
        Using fStream As New FileStream("C:\Hpad\Test\TestOpen.txt", FileMode.Open)

        End Using

        Try
            For Each fileName In Directory.GetFiles("C:\Hpad\Test")
                File.Delete(fileName)
            Next

        Catch ex As IOException
            Console.WriteLine(ex.Message)
        End Try





        Console.ReadLine()

    End Sub

End Module

This post has been edited by Jeff H: 07 June 2011 - 03:10 AM

[nelson2391]

Thank you. Its working

[Psyguy]

I have never used a "Using" block. Can anyone provide a short explanation of what it does?

[CodingSup3rnatur@l-360]

Basically, a using block ensures that an object's Dispose() method is called once you have finished using it.

In the example in this thread (slightly modified to write "Test" to the .txt file):

Using fStream As New FileStream("C:\Hpad\Test\TestOpen.txt", FileMode.Append)
          Dim b As Byte() = Encoding.ASCII.GetBytes("Test")
          fStream.Write(Encoding.ASCII.GetBytes("Test"), 0, b.Length)
End Using

we are 'using' the FileStream object in the using block. The FileStream object is only available inside the using block.

Once all the code in the using block has executed OR the code in the using block throws an exception, the Dispose() method of the FileStream object is called automatically in order to clean up the resources used by the object. You don't have to call Dispose(), it is done automatically for you by the using block.


Behind the scenes, this is essentially what that using block code gets translated to:

Dim fStream As New FileStream("TestOpen.txt", FileMode.Append)

Try
       Dim b As Byte() = Encoding.ASCII.GetBytes("Test")
       fStream.Write(Encoding.ASCII.GetBytes("Test"), 0, b.Length)
Finally
       If Not fStream Is Nothing Then
          fStream.Dispose()
       End If
End Try

That is all the using block is really... Syntax sugar for a try-finally block. Essentially, no matter what happens*** (see below for a few small exceptions to this) in the using block, Dispose() is always called automatically on the object your 'using' for you when the block has finished executing.

The object your using in the block (FileStream in this case) must implement the IDisposable interface, as this guarantees that the object has a Dispose() method for the using block to call

It is advised that for any object that implements IDisposable (and can therefore be 'disposed'), you try and wrap it in a using block so you don't forget to call Dispose() on it when your done with it.

Anyhow, just know that you should always call Dispose() (via a using block, or by calling it directly) on objects that implement IDisposable in order to free the resources used by them.


For anyone interested, here is the IL code that the using block above gets translated to (if you put the using block in the Main method of Module1). You can clearly see the try and the finally blocks:

Spoiler

.method public static void  Main() cil managed
{
  .entrypoint
  .custom instance void [mscorlib]System.STAThreadAttribute::.ctor() = ( 01 00 00 00 ) 
  // Code size       89 (0x59)
  .maxstack  4
  .locals init ([0] class [mscorlib]System.IO.FileStream fStream,
           [1] uint8[] b,
           [2] bool VB$CG$t_bool$S0)
  IL_0000:  nop
  IL_0001:  nop
  IL_0002:  ldstr      "TestOpen.txt"
  IL_0007:  ldc.i4.1
  IL_0008:  newobj     instance void [mscorlib]System.IO.FileStream::.ctor(string,
                                                                           valuetype [mscorlib]System.IO.FileMode)
  IL_000d:  stloc.0
  IL_000e:  nop
  .try
  {
    IL_000f:  call       class [mscorlib]System.Text.Encoding [mscorlib]System.Text.Encoding::get_ASCII()
    IL_0014:  ldstr      "Test"
    IL_0019:  callvirt   instance uint8[] [mscorlib]System.Text.Encoding::GetBytes(string)
    IL_001e:  stloc.1
    IL_001f:  ldloc.0
    IL_0020:  call       class [mscorlib]System.Text.Encoding [mscorlib]System.Text.Encoding::get_ASCII()
    IL_0025:  ldstr      "Test"
    IL_002a:  callvirt   instance uint8[] [mscorlib]System.Text.Encoding::GetBytes(string)
    IL_002f:  ldc.i4.0
    IL_0030:  ldloc.1
    IL_0031:  ldlen
    IL_0032:  conv.ovf.i4
    IL_0033:  callvirt   instance void [mscorlib]System.IO.FileStream::Write(uint8[],
                                                                             int32,
                                                                             int32)
    IL_0038:  nop
    IL_0039:  ldloc.0
    IL_003a:  callvirt   instance void [mscorlib]System.IO.Stream::Dispose()
    IL_003f:  nop
    IL_0040:  nop
    IL_0041:  leave.s    IL_0057
  }  // end .try
  finally
  {
    IL_0043:  ldloc.0
    IL_0044:  ldnull
    IL_0045:  ceq
    IL_0047:  ldc.i4.0
    IL_0048:  ceq
    IL_004a:  stloc.2
    IL_004b:  ldloc.2
    IL_004c:  brfalse.s  IL_0055
    IL_004e:  ldloc.0
    IL_004f:  callvirt   instance void [mscorlib]System.IDisposable::Dispose()
    IL_0054:  nop
    IL_0055:  nop
    IL_0056:  endfinally
  }  // end handler
  IL_0057:  nop
  IL_0058:  ret
} // end of method Module1::Main

***Well, finally blocks are NOT always guarenteed to be executed. For example, if the executing thread is killed using the Win32 TerminateThread function, or the process is killed using the Win32 TerminateProcess function or the System.Environment.FailFast() method, whilst in a try block (or a using block, as remember that a using block is just a try-finally block behind the scenes), then the finally block will not be executed, meaning that Dispose() will not be called. It will then be down to the operating system to clean up the resources

This post has been edited by CodingSup3rnatur@l-360: 08 June 2011 - 01:44 AM

[trevster344]

I've always enjoyed using blocks, as they provide for cleaner code.

[Psyguy]

Thanks, that was a very good explaination!

[nelson2391]

yeah really good explanation.