C#

public void ShowProgress(string msg, int percentDone)
{
    if (InvokeRequired)
    {
        // Wrap the parameters in some EventArgs-derived custom class:
        System.EventArgs e = new MyProgressEvents(msg, percentDone);
        object[] pList = { this, e };

        // Invoke the method. Call BeginInvoke to get to the UI thread.
        BeginInvoke(new MyProgressEventsHandler(UpdateProgressBar), pList);
    }
    else
    {
        // We're already on the UI thread just call straight through.
        UpdateProgressBar(this, new MyProgressEvents(msg, percentDone));
    }
}

private delegate void MyProgressEventsHandler(object sender, MyProgressEvents e);

private void UpdateProgressBar(object sender, MyProgressEvents e)
{
    //Show progress bar, and a message.
    FrmSentPrtPgres.label_MsgContext.Text = e.msg;
    FrmSentPrtPgres.progressBar.Value = e.percentDone;
}

Bruce Coward wrote:

an unused buffer address

Bruce Coward wrote:

how do I change this to store real individual values

Gideon Engelberth wrote:

I would suggest using the Queue class instead of making your own circular array.

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

  private const int CANArraySize = 20;
  // MODIFIED initial value
  static private int CANFront = 0;
  static private int CANRear = 0;
  // NEW control variable
  static private int currentCount = 0;

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

  // 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

    // MODIFIED
    if (currentCount < arCANTx.Length) {
      // Modulus Increment rear pointer
      CANRear = (CANRear + 1) % arCANTx.Length;

      // Store data in array
      // ...

      // NEW update contents counter
      currentCount++;
    } else {
      // you screwed up!
    }
  }

  static public void RemoveMsg() {
    if (currentCount > 0) {
      // Remove data here
      // ...

      // Modulus increment front pointer
      CANFront = (CANFront + 1) % arCANTx.Length;
      // update current contents counter
      currentCount--;
    } else {
      // you screwed up!
    }
  }
}

DaveyM69 wrote:

a string is a reference type that behaves like a value type

PIEBALDconsult wrote:

Should the type be immutable? -- Value types generally tend toward immutability, but maybe that's due to operators

void CallExceptionASync()
{
     Thread thrd;
     ThreadStart ts = (ThreadStart)delegate
     {
          try
          {
               t.DoSomething();
          }
          catch(MyCustomException ex)
          {
               this.lblMessage.Invoke((MethodInvokder)delegate()
               {
                    this.lblMessage.Text = ex.Message;
               });
          }
     }
}