C#

public partial class ModalForm : Form
{
  Button theButton; ...etc.
  
  public ModalForm
  {
    theButton.Click+= new EventHandler(ClickHandler)
  }

  public void ClickHandler(object sender, Eventargs e)
  {    
    objParenForm.myProperty = 1;
    Dispose();
  }    
}

public partial class ParentForm : Form
{
  ModalForm mForm
  public int myProperty;

  public void ParentForm_Load(object sender, Eventargs e)
  {
    mForm = new ModalForm();
    mForm.Show(this);
  }
}

namespace ThreadTestandForms
{
    public partial class FormGUI : UserControl
    {

        private void button2_Click(object sender, EventArgs e)
        {
            Thread ThreadSendParts;
            ThreadSendParts = new Thread(new ThreadStart(RunsOnThread));
            ThreadSendParts.SetApartmentState(ApartmentState.STA);

            //I want to use a good priority.
            ThreadSendParts.Priority = ThreadPriority.Highest;
            ThreadSendParts.Start();    //TO KEEP A RESPONSIVE UI

            FrmSentPrtPgres.ShowDialog();  //I need to show a modal dialog after running the thread.
        }


        private void RunsOnThread()
        {
            for (int i = 0; i <= 100; i += 10) //SIMULATE HEAVY PROCESS
            {
                Thread.Sleep(200);  //SIMULATE HEAVY PROCESS

                //This method uses BeginInvoke and InvokeRequired
                ShowProgress("My Progress Status", i);

                //Example of doing some custom form with some custom conditions.
                FrmMyMessage MyForm = new FrmMyMessage("Do you want do this or that?");

                //show message stop exectuting until user takes a decision.
                DialogResult DLRes = MyForm.ShowDialog();

                if (DLRes == DialogResult.OK)
                {
                    //do something this
                }
                else
                {
                    //do something that
                }
            }

            //Execute some extra things when finishing the thread.
            //This method uses BeginInvoke and InvokeRequired
            ThreadCompleted();
        }
    }  
}

class CAN
{
    // Members
    public struct CANTXSTRUCT
    {
        public int    PGN;
        public byte   DLC;
        public byte[] TxData;
    }

    private const int CANArraySize = 20;
    static private int CANFront = 1;
    static private int CANRear = 0;

    // Create static private circular array of CAN Tx messages
    static private CANTXSTRUCT[] arCANTx = new CANTXSTRUCT[CANArraySize + 1];

    // Methods
    //*********************************************************************
    // static public void QueueCANTxMsg()
    // This method is called to place a CAN Tx message on the rear of the
    // arCANTx circular array.
    //*********************************************************************
    static public void QueueCANTxMsg(int PGN, byte DLC, byte[]TxData)
    {
        // Just warn and return if arCANTx message array is full
        if ((CANRear + 2) % CANArraySize == CANFront)
        {
            MessageBox.Show("CAN Tx Array Overflow, Press OK to continue",
                                    "Error Warning", MessageBoxButtons.OK);
            return;
        }
        // Modulus Increment rear pointer
        CANRear = (CANRear + 1) % CANArraySize;

        // Store data in array
        CAN.arCANTx[CANRear].PGN = PGN;
        CAN.arCANTx[CANRear].DLC = DLC;
        CAN.arCANTx[CANRear].TxData = TxData;

        // Test Code
        TxData[0] = 0xFF;
        CANRear = (CANRear + 1) % CANArraySize;
        // Store test data in array
        CAN.arCANTx[CANRear].PGN = PGN;
        CAN.arCANTx[CANRear].DLC = DLC;
        CAN.arCANTx[CANRear].TxData = TxData;  // <---- Failing line

    } // End of QueueCANTxMsg()