In case FileStream fails, the GC throws an exception in another thread that cannot be caught

Have you tried wrapping the use of your FileStreamer in a "using" block?
Something like:

using(FileStrea m fs =
new FileStream(args[0], FileMode.Create )) {
Console.WriteLi ne("starting to write...");
while (true)
fs.WriteByte(0x ff);
}

You can always wrap the using block inside your try/catch block, but using
the implicit Dispose pattern you should be able to force the finalization to
occur in your thread (if I am not wrong).

using(
"Muki Rapp" <ra**@notalvisi on.com> wrote in message
news:uI******** ******@TK2MSFTN GP11.phx.gbl...

Hi!
In the example below, once the media is full, the FileSteam.Write Byte throws an exception and the code
is designed to handle it. However, when the GC is invoked, it calls the
Finalize of FileSteam, who is trying
to flush and close the stream, but the disk is full, so the flush fails and another exception is thrown from another
(GC) thread. An ugly solution would be to use GC.SuppressFina lize(fs).
Is there a better solution or good practice? (closing withot flushing
perhaps)?

many thanks,
M. Rapp

--------------------------------

Example:

static void Main(string[] args)
{
try
{
FileStream fs =
new FileStream(args[0], FileMode.Create );
Console.WriteLi ne("starting to write...");
while (true)
fs.WriteByte(0x ff);
}
catch (Exception e)
{
Console.WriteLi ne("Exception: {0}",
e.Message);
}
Console.WriteLi ne("press any key to continue");
Console.Read();
}

Hi!
I am afraid this is not the solution to the problem.
'using' will force the dispose method to be called and
exception to be thrown in the same thread, but still
at the end of the process the GC will also try to dispose
the filestream and an exception will be thrown in a DIFFERENT thread (run
example below for demonstration,
when filename path is a small floppy disk)

Any other ideas?

try
{
using(FileStrea m fs =
new FileStream(args[0], FileMode.Create ))
{

while (true)
fs.WriteByte(0x ff);

}
}
catch (Exception e)
{
Console.WriteLi ne("Exception: " + e.Message);
}

"Stefano "WildHeart" Lanzavecchia" <st********@apl .it> wrote in message
news:u4******** *****@tk2msftng p13.phx.gbl...

Have you tried wrapping the use of your FileStreamer in a "using" block?
Something like:

using(FileStrea m fs =
new FileStream(args[0], FileMode.Create )) {
Console.WriteLi ne("starting to write...");
while (true)
fs.WriteByte(0x ff);
}

You can always wrap the using block inside your try/catch block, but using
the implicit Dispose pattern you should be able to force the finalization to occur in your thread (if I am not wrong).

using(
"Muki Rapp" <ra**@notalvisi on.com> wrote in message
news:uI******** ******@TK2MSFTN GP11.phx.gbl...

Hi!
In the example below, once the media is full, the FileSteam.Write Byte

throws

an exception and the code
is designed to handle it. However, when the GC is invoked, it calls the
Finalize of FileSteam, who is trying
to flush and close the stream, but the disk is full, so the flush fails

and

another exception is thrown from another
(GC) thread. An ugly solution would be to use GC.SuppressFina lize(fs).
Is there a better solution or good practice? (closing withot flushing
perhaps)?

many thanks,
M. Rapp

--------------------------------

Example:

static void Main(string[] args)
{
try
{
FileStream fs =
new FileStream(args[0], FileMode.Create );
Console.WriteLi ne("starting to write...");
while (true)
fs.WriteByte(0x ff);
}
catch (Exception e)
{
Console.WriteLi ne("Exception: {0}",
e.Message);
}
Console.WriteLi ne("press any key to continue");
Console.Read();
}

> > > An ugly solution would be to use GC.SuppressFina lize(fs).

Is there a better solution or good practice? (closing withot flushing perhaps)?

I think you will have to use GC.SuppressFina lize(fs) after trying a
call to Dispose() or close() or using statement.
The FileStream's dispose (and IMO most "good" dispose methods) call
GC.SuppressFina lize at the end of the method call. However, because
of the exception, it is not getting called. So I wouldn't feel too
bad about manually supressing finalization.

I can't think of any other way to prevent an exception from being
raised on the Finalizer thread or catching that exception once thrown.

// a sample dispose function
void Dispose()
{
Dispose(true); // exception firing within this event...
GC.SuppressFina lize(this);
}

Although I do wonder if the file will continue to be locked since
Dispose was never called successfully. In the below program, it does
look like the file will be locked. Argh!

public static void Main ()
{
FileStream fs = new FileStream(@"A: \new.txt",
FileMode.Create );
bool diskfull = false;
try
{
while (true)
fs.WriteByte(0x ff);
}
catch (IOException e)
{
Console.WriteLi ne("Exception: " + e.Message);
diskfull = true; // technically should only be set for
IOException when disk really is full.
}
finally
{
if (diskfull)
{
GC.SuppressFina lize(fs);
}
else
{
fs.Close();
}
}

// let's check to see if the file is locked.
try
{
using (FileStream fs1 = new FileStream(@"A: \new.txt",
FileMode.Open))
{
fs.ReadByte();
}
}
catch (Exception ex)
{
Console.WriteLi ne ("Exception: " + ex.Message);
}

Console.ReadLin e();
}