C#

glitteringsound wrote:

I need to parse plain Win32 DLL/Exe and need to get all imports and exports from it and to show it on console or GUI(say Win Forms). Is it possible to parse Win32 DLL/Exe in C#.NET, read its export table,import table and get managed types from it. As its unmanaged PE(.NET doesn't allows you to convert unmanaged PE files to managed .NET assemblies, only it generates COM managed assemblies).

Chesnokov Yuriy wrote:

Only if the function is non-blocking it would be possible that a second timer event arrives before previous RunWorkerAsync completed.

using System;
using System.ComponentModel;
using System.Threading;

namespace DaveyM69.ComponentModel
{
    [DefaultEvent("DoWork")]
    [DefaultProperty("WorkerReportsProgress")]
    public class SaferBackgroundWorker : Component
    {
        public event DoWorkEventHandler DoWork;
        public event ProgressChangedEventHandler ProgressChanged;
        public event RunWorkerCompletedEventHandler RunWorkerCompleted;

        private bool cancellationPending;
        private bool isBusy;
        private AsyncOperation operation;
        private SendOrPostCallback operationCompleted;
        private SendOrPostCallback progressReporter;
        private object syncLock = new object();
        private bool workerReportsProgress;
        private bool workerSupportsCancellation;
        private ParameterizedThreadStart workerThreadStart;

        public SaferBackgroundWorker()
        {
            cancellationPending = false;
            isBusy = false;
            operation = null;
            operationCompleted = new SendOrPostCallback(OperationCompleted);
            progressReporter = new SendOrPostCallback(ProgressReporter);
            workerReportsProgress = false;
            workerSupportsCancellation = false;
            workerThreadStart = new ParameterizedThreadStart(WorkerThreadStart);
        }

        [Browsable(false)]
        public bool CancellationPending
        {
            get { lock (syncLock) { return cancellationPending; } }
        }
        [Browsable(false)]
        public bool IsBusy
        {
            get { lock (syncLock) { return isBusy; } }
        }
        [DefaultValue(false)]
        public bool WorkerReportsProgress
        {
            get { lock (syncLock) { return workerReportsProgress; } }
            set { lock (syncLock) { workerReportsProgress = value; } }
        }
        [DefaultValue(false)]
        public bool WorkerSupportsCancellation
        {
            get { lock (syncLock) { return workerSupportsCancellation; } }
            set { lock (syncLock) { workerSupportsCancellation = value; } }
        }

        public void CancelAsync()
        {
            if (!WorkerSupportsCancellation)
                throw new InvalidOperationException("Worker doesn't support cancellation");
            SetCancellationPending(true);
        }
        protected virtual void OnDoWork(DoWorkEventArgs e)
        {
            DoWorkEventHandler eh = DoWork;
            if (eh != null)
                eh(this, e);
        }
        protected virtual void OnProgressChanged(ProgressChangedEventArgs e)
        {
            ProgressChangedEventHandler eh = ProgressChanged;
            if (eh != null)
                eh(this, e);
        }
        protected virtual void OnRunWorkerCompleted(RunWorkerCompletedEventArgs e)
        {
            RunWorkerCompletedEventHandler eh = RunWorkerCompleted;
            if (eh != null)
                eh(this, e);
        }
        private void OperationCompleted(object state)
        {
            SetIsBusy(false);
            SetCancellationPending(false);
            OnRunWorkerCompleted((RunWorkerCompletedEventArgs)state);
        }
        private void ProgressReporter(object state)
        {
            OnProgressChanged((ProgressChangedEventArgs)state);
        }
        public void ReportProgress(int percentProgress)
        {
            ReportProgress(percentProgress, null);
        }
        public void ReportProgress(int percentProgress, object userState)
        {
            if (!WorkerReportsProgress)
                throw new InvalidOperationException("Worker doesn't report progress");
            ProgressChangedEventArgs arg = new ProgressChangedEventArgs(percentProgress, userState);
            if (operation == null)
                progressReporter(arg);
            else
                operation.Post(progressReporter, arg);
        }
        public void RunWorkerAsync()
        {
            RunWorkerAsync(null);
        }
        public void RunWorkerAsync(object argument)
        {
            if (IsBusy)
                throw new InvalidOperationException("Worker is busy");
            SetIsBusy(true);
            SetCancellationPending(false);
            operation = AsyncOperationManager.CreateOperation(null);
            workerThreadStart.BeginInvoke(argument, null, null);
        }
        private void SetCancellationPending(bool value)
        {
            lock (syncLock) { cancellationPending = value; }
        }
        private void SetIsBusy(bool value)
        {
            lock (syncLock) { isBusy = value; }
        }
        private void WorkerThreadStart(object obj)
        {
            object result = null;
            Exception error = null;
            bool cancelled = false;
            try
            {
                DoWorkEventArgs doWorkArgs = new DoWorkEventArgs(obj);
                OnDoWork(doWorkArgs);
                if (doWorkArgs.Cancel)
                    cancelled = true;
                else
                    result = doWorkArgs.Result;
            }
            catch (Exception exception)
            {
                error = exception;
            }
            RunWorkerCompletedEventArgs e = new RunWorkerCompletedEventArgs(result, error, cancelled);
            operation.PostOperationCompleted(operationCompleted, e);
        }
    }
}

for (int i = 0; i < this.drives.Count; i++)
{
    if (this.drvBackgroundWorkers[i].IsBusy == false)
    {
         BackgroundWorkerArgument argument = new BackgroundWorkerArgument()
         {
             threadId = i,
             drive = this.drives[i]
         };
         this.drvBackgroundWorkers[i].RunWorkerAsync(argument);
    }                                
}

System.Threading.Timer timer;
int count;

public override void Test(int arg) {
    timer=new System.Threading.Timer(new TimerCallback(ticker), null, 30, 30);
}

protected void output(string s) {
    Console.WriteLine(DateTime.Now.ToString("HH:mm:ss.fff ")+s);
}

public void ticker(object dummy) {
    output("ticker("+count+") start");
    for (int i=0; i<10000000; i++) { } // waste time, simulate loaded system
    output("ticker("+count+") stop");
    count++;
    if (count>10) {
        timer.Change(Timeout.Infinite, Timeout.Infinite);
        output("done");
    }
}