public override void Close()
{
if (!disableClose)
{
BaseStream.Close();
}
}
} // end of function - StartReader
/*======================= PROTECTED =====================================*/
/************************ Events *****************************************/
/************************ Properties *************************************/
/************************ Construction ***********************************/
/************************ Methods ****************************************/
/// <summary>
/// Explicit dispose method
/// </summary>
/// <param name="disposing">
/// Are we explicitly disposing, or called from the destructor
/// </param>
protected virtual void Dispose(bool disposing)
{
if (!CancelTokenSource.IsCancellationRequested)
{
CancelTokenSource.Cancel();
} // end of if - cancel has not already be requested
try
{
#warning Should revisit this wait on the data reader
DataReader.Wait(4000);
}
catch (Exception)
{
// Nothing to do with this exception at this point
}
if (disposing)
{
if (CloseStream && null != BaseStream)
{
BaseStream.Close();
BaseStream.Dispose();
} // end of if - we should close the base stream
CancelTokenSource.Dispose();
} // end of if - explicitly disposing
BaseStream = null;
CancelTokenSource = null;
} // end of function - Dispose
public void LoadData()
{
BaseStream.Seek(Header.HeaderSize, SeekOrigin.Begin);
using (AssetsReader reader = new AssetsReader(BaseStream, false))
{
Metadata = new AssetsMetadata(this);
Metadata.Parse(reader);
}
BaseStream.Seek(Header.ObjectDataOffset, SeekOrigin.Begin);
if (Manager.ForceLoadAllFiles)
{
foreach (var ext in Metadata.ExternalFiles)
{
Manager.GetAssetsFile(ext.FileName);
}
}
if (!Manager.LazyLoad)
{
foreach (var oi in Metadata.ObjectInfos)
{
var o = oi.Object;
}
BaseStream.Close();
BaseStream.Dispose();
BaseStream = null;
}
}
public void Close()
{
if (OwnsStream)
{
BaseStream.Close();
}
}
protected override void Dispose(bool disposing)
{
if (disposing)
{
if (BaseStream != null)
{
BaseStream.Close();
BaseStream = null;
}
}
if (BaseStream != null)
{
BaseStream = null;
CurrentEncoding = null;
_decoder = null;
_byteBuffer = null;
_charBuffer = null;
}
if (_eofEvent != null)
{
_eofEvent.Close();
_eofEvent = null;
}
}
public void Dispose()
{
if (BaseStream != null)
{
BaseStream.Close();
}
}
public void Close()
{
IsOpen = false;
log.Info("Closing port " + PortName);
BaseStream.Close();
safeFileHandle.Close();
}
protected override void Dispose(bool disposing)
{
if (disposing)
{
try
{
/* The .Net SerialStream class has a bug that causes its finalizer to crash when working
* with virtual COM ports (e.g. FTDI, Prolific, etc.) See the following page for details:
* http://social.msdn.microsoft.com/Forums/en-US/netfxbcl/thread/8a1825d2-c84b-4620-91e7-3934a4d47330
* To work around this bug, we suppress the finalizer for the BaseStream and close it ourselves instead.
* See the Open method for the other half of this workaround.
*/
if (IsOpen)
{
BaseStream.Close();
}
}
// ReSharper disable EmptyGeneralCatchClause
catch (Exception)
// ReSharper restore EmptyGeneralCatchClause
{
// The BaseStream is already closed, disposed, or in an invalid state. Ignore and continue disposing.
}
}
base.Dispose(disposing);
}
/// <summary>Gets the content written to the stream as a block of bytes.</summary>
/// <returns>The block of bytes.</returns>
public virtual byte[] GetResult()
{
byte[] r = ((MemoryStream)BaseStream).ToArray();
BaseStream.Close();
BaseStream.Dispose();
return(r);
}
public void Dispose()
{
if (BaseStream.IsOpen)
{
BaseStream.Close();
}
BaseStream = null;
}
public override void Close()
{
base.Close();
if (BaseStream != null)
{
BaseStream.Close();
}
}
public void Dispose()
{
if (!leaveOpen)
{
BaseStream.Close();
}
BaseStream = null;
}
protected override void Dispose(bool disposing)
{
if (disposing)
{
BaseStream.Close();
_response.Close();
}
base.Dispose(disposing);
}
/// <summary>Gets the content written to the stream as a block of bytes.</summary>
/// <returns>The block of bytes.</returns>
public virtual byte[] GetResult()
{
byte[] r = ((MemoryStream)BaseStream).ToArray();
#if !NETFX_CORE
BaseStream.Close();
#endif
BaseStream.Dispose();
return(r);
}
public void DisposeInternal()
{
foreach (var pushOnWrite in multiReadActions)
{
pushOnWrite.Dispose();
}
Flush();
BaseStream.Close();
}
/// <summary>
/// Closes the current stream and releases any resources (such as sockets and file handles) associated with the current stream.
/// </summary>
public override void Close()
{
base.Close();
if (_closeParent)
{
BaseStream.Close();
}
_closed = true;
}
public new void Close()
{
if (IsOpen)
{
BaseStream.Flush();
DiscardInBuffer();
BaseStream.Close();
base.Close();
}
}
public override void Close()
{
#if MONO
BaseStream.Close();
#else
decryptStream.Close();
encryptStream.Close();
BaseStream.Close();
#endif
}
public override void Close()
{
if (IsDisposed)
{
return;
}
Compile(true);
BaseStream.Close();
}
public void Close()
{
try
{
if (BaseStream.IsOpen)
{
BaseStream.Close();
}
}
catch { }
}
/// <inheritdoc cref="SerialPort.Close"/>
public new void Close()
{
if (!IsOpen)
{
return;
}
Thread.Sleep(250);
BaseStream.Flush();
DiscardInBuffer();
BaseStream.Close();
base.Close();
}
public void Close()
{
try
{
if (logfile != null)
{
logfile.Close();
}
}
catch
{
}
try
{
if (rawlogfile != null)
{
rawlogfile.Close();
}
}
catch
{
}
try
{
if (logplaybackfile != null)
{
logplaybackfile.Close();
}
}
catch
{
}
try
{
if (BaseStream.IsOpen)
{
BaseStream.Close();
}
}
catch
{
}
try
{
connection.Close();
}
catch
{
}
}
public void ClosePacket()
{
if (Writer != null)
{
Writer.Close();
}
// ReSharper disable ConditionIsAlwaysTrueOrFalse (/slap R#)
if (BaseStream != null)
{
// ReSharper restore ConditionIsAlwaysTrueOrFalse
BaseStream.Close();
}
Dispose(true);
}
public void ClosePacket()
{
if (Writer != null)
{
Writer.Clear();
Writer = null;
}
if (BaseStream != null)
{
BaseStream.Close();
}
Dispose(true);
}
public Task Close(CloseOpt closeOpt)
{
if (closeOpt.CloseType == CloseType.Close)
{
return(BaseStream.Close());
}
else if (closeOpt.CloseType == CloseType.Shutdown)
{
return(BaseStream.Shutdown(closeOpt.ShutdownType));
}
else
{
throw new ArgumentOutOfRangeException(nameof(closeOpt));
}
}
public void ClosePacket(bool clearWriter = true)
{
if (clearWriter && Writer != null)
{
if (Settings.DumpFormatWithText())
{
Writer.Clear();
}
Writer = null;
}
BaseStream.Close();
Dispose(true);
}
public virtual void Close()
{
if (IsOpen)
{
OnClose();
}
IsOpen = false;
FilePath = "";
if (BaseStream != null)
{
BaseStream.Close();
BaseStream = null;
}
}
protected override void Dispose(bool disposing)
{
try
{
if (BaseStream != null && disposing)
{
Flush();
}
}
finally
{
if (_closeAction == StreamActionOnDispose.Close && BaseStream != null && disposing)
{
BaseStream.Close();
}
}
}
private void Dispose(bool disposing)
{
if (!disposed)
{
if (disposing)
{
if (BaseStream != null)
{
BaseStream.Close();
}
}
buffer = null;
disposed = true;
}
}
public override void Close()
{
byte[] buffer = _stream.ToArray();
if (_threshold <= 0 || _stream.Length > _threshold)
{
BaseStream.Write(buffer, 0, buffer.Length);
BaseStream.Flush();
BaseStream.Close();
}
else
{
_baseStream.Write(buffer, 0, buffer.Length);
_baseStream.Flush();
_baseStream.Close();
}
_stream.Close();
}
