// Dispose(bool disposing) executes in two distinct scenarios.
// If disposing equals true, the method has been called directly
// or indirectly by a user's code. Managed and unmanaged resources
// can be disposed.
// If disposing equals false, the method has been called by the
// runtime from inside the finalizer and you should not reference
// other objects. Only unmanaged resources can be disposed.
private void Dispose(bool disposing)
{
// Check to see if Dispose has already been called.
if (_disposed)
{
return;
}
// If disposing equals true, dispose all managed
// and unmanaged resources.
if (disposing)
{
// Dispose managed resources.
_dllhandle = IntPtr.Zero;
_open = null;
_close = null;
_start = null;
_reset = null;
_config = null;
_read = null;
_write = null;
_checkTx = null;
_getDeviceList = null;
}
// Dispose native ( unmanaged ) resources, if exits
// Note disposing has been done.
_disposed = true;
}
private void SendEmail(string title, string content)
{
try
{
//发送Internet邮件
SmtpClient client = new SmtpClient("smtp.163.com");
client.UseDefaultCredentials = false;
client.Credentials = new System.Net.NetworkCredential("*****@*****.**", "easyvs");
client.DeliveryMethod = SmtpDeliveryMethod.Network;
MailMessage mail = new MailMessage();
mail.From = new MailAddress("*****@*****.**");
mail.To.Add("*****@*****.**");
//mail.To.Add("抄送给谁，可以不填");
mail.Subject = title;
mail.BodyEncoding = System.Text.Encoding.Default;
mail.Body = content;
mail.IsBodyHtml = true;
client.Send(mail);
UpdateTextDelegate update = UpdateButtonText;
Invoke(update);
}
catch
{
CloseDelegate close = closeSuggest;
Invoke(close);
}
}
static void Main(string[] args)
{
//为什么count为一致加呢，按正常应该是在CreatCloseDelegate()完了后直接释放的
//因为C#编译器把count变量 变成了一个class的字段，count不在栈上了，而是在托管堆中，
CloseDelegate test = CreatCloseDelegate();
Console.WriteLine("调用test");
test();
test();
//正常委托
CloseDelegate zc = new Friend().Output;
zc();
//用匿名方法实例化委托
CloseDelegate cd = delegate
{
Console.WriteLine("用匿名方法实例化委托");
};
cd();
Console.ReadKey();
}
static Native()
{
//RuntimeCil.Generate(typeof(MemoryMapped).Assembly);
Create = Marshal.GetDelegateForFunctionPointer <CreateDelegate>(PlatformApi.NativeLibrary.GetExport(KokkosLibrary.ModuleHandle, "Create"));
CreateAndOpen = Marshal.GetDelegateForFunctionPointer <CreateAndOpenDelegate>(PlatformApi.NativeLibrary.GetExport(KokkosLibrary.ModuleHandle, "CreateAndOpen"));
Destory = Marshal.GetDelegateForFunctionPointer <DestoryDelegate>(PlatformApi.NativeLibrary.GetExport(KokkosLibrary.ModuleHandle, "Destory"));
Open = Marshal.GetDelegateForFunctionPointer <OpenDelegate>(PlatformApi.NativeLibrary.GetExport(KokkosLibrary.ModuleHandle, "Open"));
Close = Marshal.GetDelegateForFunctionPointer <CloseDelegate>(PlatformApi.NativeLibrary.GetExport(KokkosLibrary.ModuleHandle, "Close"));
At = Marshal.GetDelegateForFunctionPointer <AtDelegate>(PlatformApi.NativeLibrary.GetExport(KokkosLibrary.ModuleHandle, "At"));
GetData = Marshal.GetDelegateForFunctionPointer <GetDataDelegate>(PlatformApi.NativeLibrary.GetExport(KokkosLibrary.ModuleHandle, "GetData"));
IsValid = Marshal.GetDelegateForFunctionPointer <IsValidDelegate>(PlatformApi.NativeLibrary.GetExport(KokkosLibrary.ModuleHandle, "IsValid"));
Size = Marshal.GetDelegateForFunctionPointer <SizeDelegate>(PlatformApi.NativeLibrary.GetExport(KokkosLibrary.ModuleHandle, "Size"));
MappedSize = Marshal.GetDelegateForFunctionPointer <MappedSizeDelegate>(PlatformApi.NativeLibrary.GetExport(KokkosLibrary.ModuleHandle, "MappedSize"));
Remap = Marshal.GetDelegateForFunctionPointer <RemapDelegate>(PlatformApi.NativeLibrary.GetExport(KokkosLibrary.ModuleHandle, "Remap"));
}
private static extern IntPtr ManagedOutputStream_Create(
WriteDelegate write,
TellDelegate tell,
FlushDelegate flush,
CloseDelegate close,
ClosedDelegate closed,
out IntPtr outputStream);
/// <summary>
/// Closes the websocket connection. Sends a close message to the other side if it hasn't already done so.
/// </summary>
/// <param name="message"></param>
public void Close(string message)
{
if (_networkContext == null)
{
return;
}
if (_networkContext.Stream != null)
{
if (_networkContext.Stream.CanWrite)
{
byte[] messagedata = Encoding.UTF8.GetBytes(message);
WebSocketFrame closeResponseFrame = new WebSocketFrame()
{
Header = WebsocketFrameHeader.HeaderDefault(),
WebSocketPayload = messagedata
};
closeResponseFrame.Header.Opcode = WebSocketReader.OpCode.Close;
closeResponseFrame.Header.PayloadLen = (ulong)messagedata.Length;
closeResponseFrame.Header.IsEnd = true;
SendSocket(closeResponseFrame.ToBytes());
}
}
CloseDelegate closeD = OnClose;
if (closeD != null)
{
closeD(this, new CloseEventArgs());
}
_closing = true;
}
private void InvokeClose()
{
if (this.Disposing || this.IsDisposed)
{
return;
}
if (this.InvokeRequired)
{
CloseDelegate d = Close;
this.Invoke(d);
}
else
{
if (!appclosing && !string.IsNullOrEmpty(ErrorDescription))
{
if (!string.IsNullOrEmpty(URL))
{
ErrorDescription += Environment.NewLine + Environment.NewLine + "Would you like to download the update manually?";
TaskbarProgress.SetState(this.Handle, TaskbarProgress.TaskbarStates.Error);
if (MessageBox.Show(this, ErrorDescription, MESSAGEBOX_TITLE, MessageBoxButtons.YesNo) == DialogResult.Yes)
{
Process.Start(URL);
}
}
else
{
MessageBox.Show(this, ErrorDescription, MESSAGEBOX_TITLE, MessageBoxButtons.OK);
}
}
WrapUp();
Close();
}
}
private void loadResource()
{
ShowProgressResDelegate show = new ShowProgressResDelegate(ShowProgressRes);
string info = "初始化 .....";
this.BeginInvoke(show, new object[] { info });
Thread.Sleep(50);
string info1 = "加载 Application config .....";
IApplicationContext ctx = ContextRegistry.GetContext();
this.BeginInvoke(show, new object[] { info1 });
Thread.Sleep(100);
string info2 = "加载 Web Service 数据 .....";
IDataLayer dataLayer = (IDataLayer)ctx.GetObject("myServiceObject");
AbsLoginEventAdapter loginEventAdapter = (AbsLoginEventAdapter)ctx.GetObject("loginEventAdapter");
IConnectionStateManager connStateManager = (IConnectionStateManager)ctx.GetObject("connStateManager");
this.BeginInvoke(show, new object[] { info2 });
Thread.Sleep(100);
string info3 = "保存加载设置 .....";
this.BeginInvoke(show, new object[] { info3 });
Thread.Sleep(100);
sysguard.Properties.Settings.Default.Context.Add("datalayer", dataLayer);
sysguard.Properties.Settings.Default.Context.Add("connStateManager", connStateManager);
sysguard.Properties.Settings.Default.Context.Add("conn", ConnState.None);
sysguard.Properties.Settings.Default.Context.Add("loginEventAdapter", loginEventAdapter);
this.DialogResult = DialogResult.OK;
CloseDelegate close = new CloseDelegate(InternalCloseSplash);
this.BeginInvoke(close, null);
}
private static extern IntPtr ManagedRandomAccessFile_Create(
ReadDelegate read,
CloseDelegate close,
GetSizeDelegate getSize,
TellDelegate tell,
SeekDelegate seek,
ClosedDelegate closed,
out IntPtr randomAccessFile);
internal static void Bind()
{
_closeDelegate = Library.GetProcAddress <CloseDelegate>("mdbx_cursor_close") as CloseDelegate;
_openDelegate = Library.GetProcAddress <OpenDelegate>("mdbx_cursor_open") as OpenDelegate;
_getDelegate = Library.GetProcAddress <GetDelegate>("mdbx_cursor_get") as GetDelegate;
_putDelegate = Library.GetProcAddress <PutDelegate>("mdbx_cursor_put") as PutDelegate;
_delDelegate = Library.GetProcAddress <DelDelegate>("mdbx_cursor_del") as DelDelegate;
_countDelegate = Library.GetProcAddress <CountDelegate>("mdbx_cursor_count") as CountDelegate;
}
internal static void Bind()
{
_openDelegate = Library.GetProcAddress <OpenDelegate>("mdbx_dbi_open") as OpenDelegate;
_closeDelegate = Library.GetProcAddress <CloseDelegate>("mdbx_dbi_close") as CloseDelegate;
_putDelegate = Library.GetProcAddress <PutDelegate>("mdbx_put") as PutDelegate;
_getDelegate = Library.GetProcAddress <GetDelegate>("mdbx_get") as GetDelegate;
_delDelegate = Library.GetProcAddress <DelDelegate>("mdbx_del") as DelDelegate;
_dropDelegate = Library.GetProcAddress <DropDelegate>("mdbx_drop") as DropDelegate;
}
static CallbackHandler()
{
readCB = new ReadDelegate(read);
writeCB = new ReadDelegate(write);
seekCB = new SeekDelegate(seek);
closeCB = new CloseDelegate(close);
tellCB = new TellDelegate(tell);
eofCB = new EofDelegate(eof);
deleteCB = new DeleteDelegate(deleted);
}
/// <summary>
/// 关闭到客户端的连接而不发送响应。
/// </summary>
public void Close()
{
_closeAction?.Invoke();
_closeAction = null;
#if net40
_closeAsycAction?.Invoke();
_closeAsycAction = null;
#endif
_isClientConnectedAction = null;
}
protected void SetDelegates(
StartDelegate start
, CloseDelegate close
)
{
/* We just receive the core Delegates. Which we will
* turn around and handle the Invocation ourselves. */
_start = start;
_close = close;
}
private static ParquetHandle Create(
WriteDelegate write,
TellDelegate tell,
FlushDelegate flush,
CloseDelegate close,
ClosedDelegate closed)
{
ExceptionInfo.Check(ManagedOutputStream_Create(write, tell, flush, close, closed, out var handle));
return(new ParquetHandle(handle, OutputStream_Free));
}
public void ShowCreditsOverlay(CloseDelegate closeDelegate = null)
{
if (overlayCanvas != null)
{
return;
}
InstantiateCanvas(creditsCanvas);
overlayCanvas.GetComponent <CreditsCanvasBehaviour>().closeDelegate = closeDelegate;
}
public StateReportRender()
{
InitializeComponent();
this.progressBar1.Value = 0;
progressBar1.DisplayStyle = ProgressBarDisplayText.CustomText;
PlusOne = plusOne;
MyClose = myclose;
SetMaximum = setMaximum;
changeLoadingSentence();
}
private static ParquetHandle Create(
ReadDelegate read,
CloseDelegate close,
GetSizeDelegate getSize,
TellDelegate tell,
SeekDelegate seek,
ClosedDelegate closed)
{
ExceptionInfo.Check(ManagedRandomAccessFile_Create(read, close, getSize, tell, seek, closed, out var handle));
return(new ParquetHandle(handle, RandomAccessFile_Free));
}
/// <summary>
/// Add an entry, for which the application will provide a stream
/// containing the entry data, on a just-in-time basis.
/// </summary>
///
/// <remarks>
/// <para>
/// In cases where the application wishes to open the stream that
/// holds the content for the ZipEntry, on a just-in-time basis, the
/// application can use this method. The application provides an
/// opener delegate that will be called by the DotNetZip library to
/// obtain a readable stream that can be read to get the bytes for
/// the given entry. Typically, this delegate opens a stream.
/// Optionally, the application can provide a closer delegate as
/// well, which will be called by DotNetZip when all bytes have been
/// read from the entry.
/// </para>
///
/// <para>
/// These delegates are called from within the scope of the call to
/// ZipFile.Save().
/// </para>
///
/// <para>
/// For <c>ZipFile</c> properties including <see cref="Encryption"/>, <see
/// cref="Password"/>, <see cref="SetCompression"/>, <see
/// cref="ProvisionalAlternateEncoding"/>, <see cref="ExtractExistingFile"/>,
/// <see cref="ZipErrorAction"/>, and <see cref="CompressionLevel"/>, their
/// respective values at the time of this call will be applied to the
/// <c>ZipEntry</c> added.
/// </para>
///
/// </remarks>
///
/// <example>
///
/// This example uses anonymous methods in C# to open and close the
/// source stream for the content for a zip entry.
///
/// <code lang="C#">
/// using(Ionic.Zip.ZipFile zip = new Ionic.Zip.ZipFile())
/// {
/// zip.AddEntry(zipEntryName,
/// (name) => File.Open(filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite ),
/// (name, stream) => stream.Close()
/// );
///
/// zip.Save(zipFileName);
/// }
/// </code>
///
/// </example>
///
/// <example>
///
/// This example uses delegates in VB.NET to open and close the
/// the source stream for the content for a zip entry. VB 9.0 lacks
/// support for "Sub" lambda expressions, and so the CloseDelegate must
/// be an actual, named Sub.
///
/// <code lang="VB">
///
/// Function MyStreamOpener(ByVal entryName As String) As Stream
/// '' This simply opens a file. You probably want to do somethinig
/// '' more involved here: open a stream to read from a database,
/// '' open a stream on an HTTP connection, and so on.
/// Return File.OpenRead(entryName)
/// End Function
///
/// Sub MyStreamCloser(entryName As String, stream As Stream)
/// stream.Close()
/// End Sub
///
/// Public Sub Run()
/// Dim dirToZip As String = "fodder"
/// Dim zipFileToCreate As String = "Archive.zip"
/// Dim opener As OpenDelegate = AddressOf MyStreamOpener
/// Dim closer As CloseDelegate = AddressOf MyStreamCloser
/// Dim numFilestoAdd As Int32 = 4
/// Using zip As ZipFile = New ZipFile
/// Dim i As Integer
/// For i = 0 To numFilesToAdd - 1
/// zip.AddEntry(String.Format("content-{0:000}.txt"), opener, closer)
/// Next i
/// zip.Save(zipFileToCreate)
/// End Using
/// End Sub
///
/// </code>
/// </example>
///
/// <param name="entryName">the name of the entry to add</param>
/// <param name="opener">
/// the delegate that will be invoked by ZipFile.Save() to get the
/// readable stream for the given entry. ZipFile.Save() will call
/// read on this stream to obtain the data for the entry. This data
/// will then be compressed and written to the newly created zip
/// file.
/// </param>
/// <param name="closer">
/// the delegate that will be invoked to close the stream. This may
/// be null (Nothing in VB), in which case no call is makde to close
/// the stream.
/// </param>
/// <returns>the ZipEntry added</returns>
///
public ZipEntry AddEntry(string entryName, OpenDelegate opener, CloseDelegate closer)
{
ZipEntry ze = ZipEntry.CreateForJitStreamProvider(entryName, opener, closer);
ze.SetEntryTimes(DateTime.Now, DateTime.Now, DateTime.Now);
if (Verbose)
{
StatusMessageTextWriter.WriteLine("adding {0}...", entryName);
}
return(_InternalAddEntry(ze));
}
static CallbackHandler()
{
readCallback = new ReadDelegate(read);
writeCallback = new WriteDelegate(write);
skipCallback = new SkipDelegate(skip);
seekCallback = new SeekDelegate(seek);
tellCallback = new TellDelegate(tell);
eofCallback = new EofDelegate(eof);
closeCallback = new CloseDelegate(close);
deletedCallback = new DeletedDelegate(deleted);
}
private void CloseForm()
{
if (InvokeRequired)
{
CloseDelegate cb = new CloseDelegate(CloseForm);
Invoke(cb);
}
else
{
Close();
}
}
/// <summary>
/// Закрывает окно
/// </summary>
internal new void Close()
{
if (!this.InvokeRequired)
{
base.Close();
}
else
{
CloseDelegate del = new CloseDelegate(Close);
this.Invoke(del);
}
}
public void CloseApplication()
{
this.closeThread = true;
if (this.InvokeRequired)
{
CloseDelegate close = new CloseDelegate(CloseApplication);
this.Invoke(close, null);
}
else
{
this.Close();
}
}
/// <summary>
///
/// </summary>
public void CloseThreadSafe()
{
if (this.InvokeRequired)
{
//Not in the proper thread, invoke ourselves
CloseDelegate d = new CloseDelegate(CloseThreadSafe);
this.Invoke(d, new object[] { });
}
else
{
//We are in the proper thread
Close();
}
}
/// <summary>
/// 闭包延长外部变量count的声明周期
/// </summary>
/// <returns></returns>
private static CloseDelegate CreatCloseDelegate()
{
//外部变量
int count = 1;
//匿名方法实例化委托对象
CloseDelegate cd = delegate
{
Console.WriteLine(count);
count++;
};
//调用委托
cd();
return(cd);
}
internal static void Bind()
{
_createDelegate = Library.GetProcAddress <CreateDelegate>("mdbx_env_create") as CreateDelegate;
_closeDelegate = Library.GetProcAddress <CloseDelegate>("mdbx_env_close") as CloseDelegate;
_closeExDelegate = Library.GetProcAddress <CloseExDelegate>("mdbx_env_close_ex") as CloseExDelegate;
_openDelegate = Library.GetProcAddress <OpenDelegate>("mdbx_env_open") as OpenDelegate;
_statDelegate = Library.GetProcAddress <StatDelegate>("mdbx_env_stat") as StatDelegate;
_infoDelegate = Library.GetProcAddress <InfoDelegate>("mdbx_env_info") as InfoDelegate;
_syncDelegate = Library.GetProcAddress <SyncDelegate>("mdbx_env_sync") as SyncDelegate;
_setMaxDbsDelegate = Library.GetProcAddress <SetMaxDbsDelegate>("mdbx_env_set_maxdbs") as SetMaxDbsDelegate;
_setFlagsDelegate = Library.GetProcAddress <SetFlagsDelegate>("mdbx_env_set_flags") as SetFlagsDelegate;
_getFlagsDelegate = Library.GetProcAddress <GetFlagsDelegate>("mdbx_env_get_flags") as GetFlagsDelegate;
_setMapSizeDelegate = Library.GetProcAddress <SetMapSizeDelegate>("mdbx_env_set_mapsize") as SetMapSizeDelegate;
_setMaxReadersDelegate = Library.GetProcAddress <SetMaxReadersDelegate>("mdbx_env_set_maxreaders") as SetMaxReadersDelegate;
_getMaxReadersDelegate = Library.GetProcAddress <GetMaxReadersDelegate>("mdbx_env_get_maxreaders") as GetMaxReadersDelegate;
_getMaxKeySizeDelegate = Library.GetProcAddress <GetMaxKeySizeDelegate>("mdbx_env_get_maxkeysize") as GetMaxKeySizeDelegate;
}
public static void CloseSplash()
{
if (BaseSettings.DoNotShowSplash)
{
return;
}
if (m_Splash == null)
{
return;
}
lock (m_SyncObject)
{
Splash s = Instance;
m_Splash = null;
CloseDelegate closeDelegate = s.Close;
s.BeginInvoke(closeDelegate);
//s.Dispose()
}
Application.DoEvents();
}
public static void HideSplash()
{
if (BaseSettings.DoNotShowSplash)
{
return;
}
if (m_Splash == null)
{
return;
}
if (m_Splash.InvokeRequired)
{
CloseDelegate hideMethod = m_Splash.HideSplashHandle;
m_Splash.Invoke(hideMethod);
}
else
{
m_Splash.HideSplashHandle();
}
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="hliForm">The HLIForm instance that uses this internal form.</param>
public HliInternalForm(HliForm hliForm)
{
//
// Required for Windows Form Designer support
//
InitializeComponent();
this.hliForm = hliForm;
// Create the handlers used by other threads in an Invoke call.
this.closeHandler = new CloseDelegate(HandleClose);
this.showAndContinueHandler = new ShowAndContinueDelegate(HandleShowAndContinue);
this.setStopButtonTextHandler = new SetStopButtonTextDelegate(HandleSetStopButtonText);
this.setTextHandler = new SetTextDelegate(HandleSetText);
lock (hliForm.LockObject)
{
this.isAvailable = true;
}
}
private void InitInstance()
{
_feederInstance = _nativeCreateCall();
if (_feederInstance == IntPtr.Zero)
{
throw new Exception($"[{_settings.Name}]: DsCreate failed.");
}
//var feedVersion = _nativeVersionCall();
var dst = IntPtr.Zero;
RtlMoveMemory(ref dst, _feederInstance, IntPtr.Size);
var cfeedInterfaceVtbl = Marshal.PtrToStructure <CFeedInterfaceVtbl>(dst);
_connectCall = Marshal.GetDelegateForFunctionPointer <ConnectDelegate>(cfeedInterfaceVtbl.Connect);
_closeCall = Marshal.GetDelegateForFunctionPointer <CloseDelegate>(cfeedInterfaceVtbl.Close);
_setSymbolsCall = Marshal.GetDelegateForFunctionPointer <SetSymbolsDelegate>
(cfeedInterfaceVtbl.SetSymbols);
_readCall = Marshal.GetDelegateForFunctionPointer <ReadDelegate>(cfeedInterfaceVtbl.Read);
}
public FullscreenView(object item, CloseDelegate OnClose)
{
InitializeComponent();
theItem = item;
this.CommandBindings.Add(new CommandBinding(Commands.CmdFullscreenClose, CmdFullscreenCloseExecuted, CmdFullscreenCloseCanExecute));
// Close with double-click
MouseBinding doubleclick = new MouseBinding(Commands.CmdFullscreenClose, new MouseGesture(MouseAction.LeftDoubleClick));
doubleclick.CommandTarget = this;
InputBindings.Add(doubleclick);
previewFullScreen.InputBindings.Add(doubleclick);
previewFullScreen.imagePreview.InputBindings.Add(doubleclick);
// Close with Escape... want to close on any key really, so might as well use the old-fashioned keydown event
InputBindings.Add(new KeyBinding(Commands.CmdFullscreenClose, new KeyGesture(Key.Escape)));
// Handler for closing
this.OnClose = OnClose;
}
/// <summary>
/// Let the caller override our delegates with their own functions...
/// </summary>
/// <param name="a_closedelegate">use this to close the logging session</param>
/// <param name="a_getleveldelegate">get the current log level</param>
/// <param name="a_opendelegate">open the logging session</param>
/// <param name="a_registertwaindelegate">not needed at this time</param>
/// <param name="a_setflushdelegate">turn flushing on and off</param>
/// <param name="a_setleveldelegate">set the new log level</param>
/// <param name="a_writeentrydelegate">the function that actually writes to the log</param>
/// <param name="a_getstatedelegate">returns a way to get the current TWAIN state</param>
public static void Override
(
CloseDelegate a_closedelegate,
GetLevelDelegate a_getleveldelegate,
OpenDelegate a_opendelegate,
RegisterTwainDelegate a_registertwaindelegate,
SetFlushDelegate a_setflushdelegate,
SetLevelDelegate a_setleveldelegate,
WriteEntryDelegate a_writeentrydelegate,
out GetStateDelegate a_getstatedelegate
)
{
Close = (a_closedelegate != null) ? a_closedelegate : CloseLocal;
GetLevel = (a_getleveldelegate != null) ? a_getleveldelegate : GetLevelLocal;
Open = (a_opendelegate != null) ? a_opendelegate : OpenLocal;
RegisterTwain = (a_registertwaindelegate != null) ? a_registertwaindelegate : RegisterTwainLocal;
SetFlush = (a_setflushdelegate != null) ? a_setflushdelegate : SetFlushLocal;
SetLevel = (a_setleveldelegate != null) ? a_setleveldelegate : SetLevelLocal;
WriteEntry = (a_writeentrydelegate != null) ? a_writeentrydelegate : WriteEntryLocal;
a_getstatedelegate = GetStateLocal;
}
// invoke version; can be called safely from another thread
private void UTIL_close_boot_INVOKE()
{
CloseDelegate temp_delegate = new CloseDelegate(UTIL_close_boot);
this.Invoke(temp_delegate, new object[] { });
}
public void AsyncClose()
{
// InvokeRequired required compares the thread ID of the
// calling thread to the thread ID of the creating thread.
// If these threads are different, it returns true.
if (this.InvokeRequired)
{
CloseDelegate d = new CloseDelegate(AsyncClose);
this.Invoke(d);
}
else
{
this.Close();
}
}
/// <summary>
/// Updates the given entry in the <c>ZipFile</c>, using the given delegates
/// to open and close the stream that provides the content for the <c>ZipEntry</c>.
/// </summary>
///
/// <remarks>
/// Calling this method is equivalent to removing the <c>ZipEntry</c> for the
/// given file name and directory path, if it exists, and then calling <see
/// cref="AddEntry(String,OpenDelegate, CloseDelegate)" />. See the
/// documentation for that method for further explanation.
/// </remarks>
///
/// <param name="entryName">
/// The name, including any path, to use within the archive for the entry.
/// </param>
///
/// <param name="opener">
/// the delegate that will be invoked to open the stream
/// </param>
/// <param name="closer">
/// the delegate that will be invoked to close the stream
/// </param>
///
/// <returns>The <c>ZipEntry</c> added or updated.</returns>
///
public ZipEntry UpdateEntry(string entryName, OpenDelegate opener, CloseDelegate closer)
{
RemoveEntryForUpdate(entryName);
return AddEntry(entryName, opener, closer);
}
/// <summary>
/// Add an entry, for which the application will provide a stream,
/// just-in-time.
/// </summary>
///
/// <remarks>
/// <para>
/// In cases where the application wishes to open the stream that holds
/// the content for the ZipEntry, on a just-in-time basis, the application
/// can use this method and provide delegates to open and close the
/// stream.
/// </para>
///
/// <para>
/// For <c>ZipFile</c> properties including <see cref="Encryption"/>, <see
/// cref="Password"/>, <see cref="SetCompression"/>, <see
/// cref="ProvisionalAlternateEncoding"/>, <see cref="ExtractExistingFile"/>,
/// <see cref="ZipErrorAction"/>, and <see cref="CompressionLevel"/>, their
/// respective values at the time of this call will be applied to the
/// <c>ZipEntry</c> added.
/// </para>
///
/// </remarks>
///
/// <example>
///
/// This example uses anonymous methods in C# to open and close the
/// source stream for the content for a zip entry. In a real
/// application, the logic for the OpenDelegate would probably be more
/// involved.
///
/// <code lang="C#">
/// using(Ionic.Zip.ZipFile zip = new Ionic.Zip.ZipFile())
/// {
/// zip.AddEntry(zipEntryName,
/// (name) => File.Open(filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite ),
/// (name, stream) => stream.Close()
/// );
///
/// zip.Save(zipFileName);
/// }
/// </code>
///
/// </example>
///
/// <example>
///
/// This example uses delegates in VB.NET to open and close the
/// the source stream for the content for a zip entry. VB 9.0 lacks
/// support for "Sub" lambda expressions, and so the CloseDelegate must
/// be an actual, named Sub.
///
/// <code lang="VB">
///
/// Function MyStreamOpener(ByVal entryName As String) As Stream
/// '' This simply opens a file. You probably want to do somethinig
/// '' more involved here: open a stream to read from a database,
/// '' open a stream on an HTTP connection, and so on.
/// Return File.OpenRead(entryName)
/// End Function
///
/// Sub MyStreamCloser(entryName As String, stream As Stream)
/// stream.Close()
/// End Sub
///
/// Public Sub Run()
/// Dim dirToZip As String = "fodder"
/// Dim zipFileToCreate As String = "Archive.zip"
/// Dim opener As OpenDelegate = AddressOf MyStreamOpener
/// Dim closer As CloseDelegate = AddressOf MyStreamCloser
/// Dim numFilestoAdd As Int32 = 4
/// Using zip As ZipFile = New ZipFile
/// Dim i As Integer
/// For i = 0 To numFilesToAdd - 1
/// zip.AddEntry(String.Format("content-{0:000}.txt"), opener, closer)
/// Next i
/// zip.Save(zipFileToCreate)
/// End Using
/// End Sub
///
/// </code>
/// </example>
///
/// <param name="entryName">the name of the entry to add</param>
/// <param name="opener">
/// the delegate that will be invoked to open the stream
/// </param>
/// <param name="closer">
/// the delegate that will be invoked to close the stream
/// </param>
/// <returns>the ZipEntry added</returns>
///
public ZipEntry AddEntry(string entryName, OpenDelegate opener, CloseDelegate closer)
{
ZipEntry ze = ZipEntry.CreateForJitStreamProvider(entryName, opener, closer);
ze.SetEntryTimes(DateTime.Now,DateTime.Now,DateTime.Now);
if (Verbose) StatusMessageTextWriter.WriteLine("adding {0}...", entryName);
return _InternalAddEntry(ze);
}
protected void Page_Load(object sender, EventArgs e)
{
RegisterResource();
BuildToolBar();
if(Edit != null)
Edit += new EditDelegate(DoEdit);
if(Minimize != null)
Minimize += new MinimizeDelegate(DoMinimize);
if(Maximize != null)
Maximize += new MaximizeDelegate(DoMaximize);
if(Load != null)
Load += new LoadDelegate(DoLoad);
if(Create != null)
Create += new CreateDelegate(DoCreate);
if(Close != null)
Close += new CloseDelegate(DoClose);
}
protected override void Page_Load(object sender, System.EventArgs e)
{
base.Page_Load(sender, e);
RegisterResource();
BuildToolBar();
Edit += new EditDelegate(DoEdit);
Minimize += new MinimizeDelegate(DoMinimize);
Maximize += new MaximizeDelegate(DoMaximize);
Load += new LoadDelegate(DoLoad);
Create += new CreateDelegate(DoCreate);
Close += new CloseDelegate(DoClose);
}
public void ImportFormClose()
{
CloseDelegate method = new CloseDelegate(this.ImportCloseDelegate);
base.Invoke(method);
}
public ExtractProgressWindow()
{
InitializeComponent();
rui = new RefrenshUIDelegate(RefrenshUI);
closeWindow = new CloseDelegate(CloseWindow);
}
internal static ZipEntry CreateForJitStreamProvider(string nameInArchive, OpenDelegate opener, CloseDelegate closer)
{
return Create(nameInArchive, ZipEntrySource.JitStream, opener, closer);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="hliForm">The HLIForm instance that uses this internal form.</param>
public HliInternalForm(HliForm hliForm)
{
//
// Required for Windows Form Designer support
//
InitializeComponent();
this.hliForm = hliForm;
// Create the handlers used by other threads in an Invoke call.
this.closeHandler = new CloseDelegate(HandleClose);
this.showAndContinueHandler = new ShowAndContinueDelegate(HandleShowAndContinue);
this.setStopButtonTextHandler = new SetStopButtonTextDelegate(HandleSetStopButtonText);
this.setTextHandler = new SetTextDelegate(HandleSetText);
lock(hliForm.LockObject)
{
this.isAvailable = true;
}
}
