C#

Dave Kreskowiak wrote:

leave the data collection code running and not worry about killing the thread

Jacob Dixon wrote:

Users don't like to wait

Jacob Dixon wrote:

cancel a form close then abort the threads

Jacob Dixon wrote:

check if a thread is alive on FormClosing

using ( WMI wmi = new WMI() )
{
    Application.Run ( new MyForm ( WMI ) ) ;
}

Jacob Dixon wrote:

Well even if I called a abort on a thread will it abort during the call to WMI or wait for it to finish?

Jacob Dixon wrote:

I'm a little new to using threads like this, but creating a new thread (not as background) will run even if the application is closed correct?

public delegate void UserRetrievalDelegate();
public event UserRetrievalDelegate UserRetrievalFinished;

private void frmMain_Load(object sender, EventArgs e)
{
    UserRetrievalFinished += new UserRetrievalDelegate(frmMain_UserRetrievalFinished);
}

void frmMain_UserRetrievalFinished()
{
    PopulateUsers();
}

// Gets users from active directory
private void FillUsers()
{
    users = new List<User>();

    LDAP ldap = Login();

    if (ldap != null)
    {
        PrincipalSearchResult<Principal> usrs = ldap.AllADUsers();
        foreach (Principal principal in usrs)
        {
            // Create a new User object (gets more information about the user and stores it)
            User temp = ldap.GetUserInfo(principal.Name, "name");

            // Add the User object to our private list
            users.Add(temp);
            temp = null;
        }

        UserRetrievalFinished();
    }
}

private void GetServices()
        {
            WMI_Commands wmi = new WMI_Commands(Username, Password,
                System.Management.ImpersonationLevel.Impersonate, System.Management.AuthenticationLevel.Default);

            List<Services> services = wmi.GetServices(NetBios);
            if (!this.IsDisposed)
            {
                foreach (Services s in services)
                {
                    AddServices(s);
                }

                SetPBVisible("pbservices", false);
            }

            services = null;
        }

//The event that will be fired upon completion
private delegate void ApplicationsLoadedDel(List<Product> apps);
private event ApplicationsLoadedDel ApplicationsLoaded;

private void frmMain_Load(object sender, EventArgs e)
{
   //Create the new thread
   appThread = new Thread(new ThreadStart(GetApplications));
   appThread.IsBackground = true;

   //add the event handler
   this.ApplicationsLoaded += AddApplications;
   
   //Start the thread
   appThread.Start();
}

private void LoadApplications()
{
     //Just run the WMI_Commands and return the apps
     WMI_Commands wmi = new WMI_Commands(Username, Password,
                            System.Management.ImpersonationLevel.Impersonate, 
                            System.Management.AuthenticationLevel.Default);

     //Get the list of apps
     List<Product> products = wmi.InstalledApplications(NetBios);

     //Raise the event
     ApplicationsLoaded(products);
}

Delegate void AddApplicationsDel(List<Product> products)

private void AddApplications(List<Product> products)
{
   if (this.InvokeRequired)
      this.Invoke(new AddApplciationsDel(Address of AddApplications),
                  new Object() {products});

   foreach (Product p in products)
   {
       AddApplication(p);
   }

   products = null;

   SetPBVisible("pbapplications", false);
}

public void form_close(Object sender, FormClosingEventArgs e)
{
   this.Hide();
   this.ApplicationsLoaded -= AddApplications;
   this.ApplicationsLoaded =+ CloseFormOnCompletion;
}

public void CloseFormOnCompletion(List<Product> products)
{
   this.Close();
}

private delegate void ApplicationsLoadedDelegate(List<Product> products);
private event ApplicationsLoadedDelegate ApplicationsLoaded;

        private void frmCompInfo_Load(object sender, EventArgs e)
        {
            // Create our methods for handling data once its finished
            ApplicationsLoaded += new ApplicationsLoadedDelegate(frmCompInfo_ApplicationsLoaded);
            ServicesLoaded += new ServicesLoadedDelegate(frmCompInfo_ServicesLoaded);
            InfoLoaded += new InfoLoadedDelegate(frmCompInfo_InfoLoaded);


            // Start our threads for getting information
            appThread = new Thread(new ThreadStart(GetApplications));
            appThread.Start();

            driveThread = new Thread(new ThreadStart(GetInfo));
            driveThread.Start();

            serviceThread = new Thread(new ThreadStart(GetServices));
            serviceThread.Start();
        }

        private void GetApplications()
        {
            WMI_Commands wmi = new WMI_Commands(Username, Password,
                System.Management.ImpersonationLevel.Impersonate, System.Management.AuthenticationLevel.Default);

            List<Product> products = wmi.InstalledApplications(NetBios);
            if (ApplicationsLoaded != null)
                ApplicationsLoaded(products);

            products = null;
        }
private void frmCompInfo_ApplicationsLoaded(List<Product> products)
        {
            if (lstApplications.InvokeRequired)
                lstApplications.Invoke(new ApplicationsLoadedDelegate(ApplicationsLoaded), new object[] { products });
            else
            {
                lstApplications.BeginUpdate();

                foreach (Product p in products)
                {
                    ListViewItem item = new ListViewItem();
                    item.Text = p.Name;
                    item.SubItems.Add(p.Version);
                    item.SubItems.Add(p.Vendor);
                    item.SubItems.Add(p.InstallLocation);

                    lstApplications.Items.Add(item);
                }

                lstApplications.EndUpdate();
                SetPBVisible(pbApplications, false);
            }
        }

private void frmCompInfo_FormClosing(object sender, FormClosingEventArgs e)
{
    ApplicationsLoaded -= frmCompInfo_ApplicationsLoaded;
    ServicesLoaded -= frmCompInfo_ServicesLoaded;
    InfoLoaded -= frmCompInfo_InfoLoaded;
}

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Threading;
using System.Windows.Forms;

namespace ThreadingDemo
{
    public partial class FormMain : Form
    {
        MyThreadedClass myThreadedClass;

        public FormMain()
        {
            InitializeComponent();
            myThreadedClass = new MyThreadedClass();
            myThreadedClass.GotDataCompleted += myThreadedClass_GotDataCompleted;
            FormClosing += FormMain_FormClosing;
            Shown += new EventHandler(FormMain_Shown);
        }

        void FormMain_Shown(object sender, EventArgs e)
        {
            // Call one of these depending on your requirements for thread termination

            //RunThread();
            //RunThreadAsBackground();
        }

        private void FormMain_FormClosing(object sender, FormClosingEventArgs e)
        {
            // Unsubscribing from event ensures UI will not be updated once form is closed!
            myThreadedClass.GotDataCompleted -= myThreadedClass_GotDataCompleted;
        }
        private void myThreadedClass_GotDataCompleted(object sender, GotDataCompletedEventArgs e)
        {
            if (InvokeRequired)
                Invoke(new MethodInvoker(delegate { myThreadedClass_GotDataCompleted(sender, e); }));
            else
            {
                foreach (string item in e.Data)
                    Text = item;
            }
        }
        // Application will close but thread will continue to run until completed.
        private void RunThread()
        {
            myThreadedClass.Begin();
        }
        // Thread will terminate when application closes.
        private void RunThreadAsBackground()
        {
            myThreadedClass.SetAsBackground();
            myThreadedClass.Begin();
        }
    }

    public class MyThreadedClass
    {
        public event EventHandler<GotDataCompletedEventArgs> GotDataCompleted;

        private Thread thread;

        public MyThreadedClass()
        {
            thread = new Thread(new ThreadStart(Start));
        }

        public void Begin()
        {
            thread.Start();
        }
        protected virtual void OnGotDataCompleted(GotDataCompletedEventArgs e)
        {
            EventHandler<GotDataCompletedEventArgs> eh = GotDataCompleted;
            if (eh != null)
                eh(this, e);
        }
        private void Start()
        {
            GotDataCompletedEventArgs e = new GotDataCompletedEventArgs();
            e.AddData("Data 1");
            // Simulate long operation
            Thread.Sleep(10000);
            e.AddData("Data 2");
            OnGotDataCompleted(e);
        }
        public void SetAsBackground()
        {
            thread.IsBackground = true;
        }
    }

    public class GotDataCompletedEventArgs : EventArgs
    {
        private List<string> data;

        public GotDataCompletedEventArgs()
        {
            data = new List<string>();
        }

        public ReadOnlyCollection<string> Data
        {
            get { return data.AsReadOnly(); }
        }

        internal void AddData(string item)
        {
            data.Add(item);
        }
    }
}