.NET (Core and Framework)

JoeRip wrote:

So: how do I avoid this? Since the update mechanisms are private to the DataSource/Binding mechanism, there is no clear place where I can use Invoke to sync the datatable with the UI thread, so I can cross the thread boundary safely.

I do own the library object. I am currently exposing the DataTable as a public object. Is there another way to get the data in the table to the DGV, in a way that crosses the thread boundary safely?

Bastard Programmer from Hell
if you can't read my code, try converting it here[^]

JoeRip wrote:

I think it comes down to this: should I redesign the library object so that it takes a delegate to call after Rows.Add (seriously ugly)? Or should I not expose the DataTable directly, and look to find another method of making the DataTable's content available?

Bastard Programmer from Hell
if you can't read my code, try converting it here[^]

using System;
using System.Windows.Forms;

namespace dgv
{
    public partial class Form1 : Form
    {
        DataGridView dgvMain = new DataGridView();
        GrowingTable ra = new GrowingTable();
        
        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {

            Controls.Add(dgvMain);
            dgvMain.Dock = System.Windows.Forms.DockStyle.Fill;
            dgvMain.Location = new System.Drawing.Point(0, 45);
            dgvMain.DataSource = ra.itemTable;
            ra.Start();
        }

        // this class would normally appear in a separate assembly and namespace
        public class GrowingTable
        {
            public System.Data.DataTable itemTable; 
            private System.Threading.Timer myTimer = null;

            // constructor
            public GrowingTable()
            {
                itemTable = new System.Data.DataTable();
                myTimer = new System.Threading.Timer(this.AddRow, null, System.Threading.Timeout.Infinite, System.Threading.Timeout.Infinite); 
                for (int i = 0; i < 11; i++)
                {
                    itemTable.Columns.Add(new System.Data.DataColumn(i.ToString(), typeof(System.DateTime)));
                }
            }

            public void Start()
            {
                myTimer.Change(0, 500);
            }

            private void AddRow(object state)
            {
                if (itemTable.Rows.Count < 50)
                {
                    System.Data.DataRow dr = this.itemTable.NewRow();
                    for (int i = 0; i < 11; i++) { dr[i.ToString()] = DateTime.Now; }
                    this.itemTable.Rows.Add(dr);
                }
                else
                {
                    myTimer.Dispose();
                    myTimer = null;
                }
            }
        }
    }
}

public Action<Action> InvokeOnUI{get;set;}

this.itemTable.Rows.Add(dr);

if (InvokeOnUI!=null)
    InvokeOnUI(()=>this.itemTable.Rows.Add(dr));
else
    this.itemTable.Rows.Add(dr);

ra.InvokeOnUI = action => Invoke(action);

public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
    }
    Updater ud = new Updater();
    private void Form1_Load(object sender, EventArgs e)
    {
        this.dataGridView1.DataSource = ud.Data; 

        ud.InvokeOnIU = action => Invoke(action);
    }

    private void button1_Click(object sender, EventArgs e)
    {
        Thread run = new Thread(ud.AddInBackGround);
        run.Start();
    }
}

public class Updater
{
    public Updater()
    {
        Data = new DataTable();
        Data.Columns.Add("Column 1");
        Data.Columns.Add("Column 2");
        Data.Columns.Add("Column 3");
    }
    public Action<Action> InvokeOnIU { get; set; }

    public DataTable Data { get; set; }

    public void AddInBackGround()
    {
        if (InvokeOnIU!=null)
        {
            var toAdd = Data.NewRow();
            InvokeOnIU(()=>Data.Rows.Add(toAdd));
        }
    }

}

bool fCallerNeedsUpdateOnItsOwnContext

void UpdateGTDataSource(GTUpdates updates)

event UpdateDataAgainstYourOwnContext

using System;
using System.Windows.Forms;
using GrowingDataTable;

namespace dgv
{
    public partial class Form1 : Form
    {
        public DataGridView dgvMain;
        public delegate void delEventHandler(object sender,
               GrowingDataTable.UpdateDataTableOnYourThreadContextEventArgs e);
        public GrowingDataTable gt;
        
        public Form1()
        {
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            // add a datagridview to the form
            dgvMain = new DataGridView();
            Controls.Add(dgvMain);
            dgvMain.Dock = System.Windows.Forms.DockStyle.Fill;

            // create the GrowingTable object
            gt = new GrowingDataTable();

            // subscribe to the GrowingTable event
            gt.RaiseUpdateTableAgainstYourThreadContextEvent += new 
           EventHandler<GrowingDataTable.UpdateDataTableOnYourThreadContextEventArgs>
          (gt_RaiseUpdateTableAgainstYourThreadContextEvent);

            // tell gt that we want to be updated
            gt.UpdateDataTableOnCallerThreadContext = true;

            // assign the DataTable as DataSource for our datagridview
            dgvMain.DataSource = gt.itemTable;
            
            // tell the GrowingTable to start growing; 
            // delay start for 3 seconds, add row every 1 second
            gt.Start(3000, 1000);
        }

        void gt_RaiseUpdateTableAgainstYourThreadContextEvent(object sender,
                GrowingDataTable.UpdateDataTableOnYourThreadContextEventArgs e)
        {
            if (InvokeRequired) {
                Invoke(new
                delEventHandler(gt_RaiseUpdateTableAgainstYourThreadContextEvent),
                new object[] { sender, e}); }
            else
            {
                if ((e.Updates != null) || (e.Updates.Count > 0))
                {
                    gt.UpdateTableOnMyThreadContext(e.Updates);
                }
            }
        }
    }
}

using System;
using System.Collections.Concurrent;

namespace GrowingDataTable
{
    public class GrowingDataTable
    {
        public System.Data.DataTable itemTable;
        public System.Threading.Timer myTimer = null;
        private ConcurrentQueue<System.Data.DataRow> qUpdates = new
                ConcurrentQueue<System.Data.DataRow>();

        // constructor
        public GrowingDataTable()
        {
            // table and timer
            itemTable = new System.Data.DataTable();
            myTimer = new System.Threading.Timer(this.AddRows, null, 
                  System.Threading.Timeout.Infinite, System.Threading.Timeout.Infinite);

            // add some columns to table
            for (int i = 0; i < 10; i++) {
                itemTable.Columns.Add(new System.Data.DataColumn
                       (i.ToString(), typeof(System.DateTime))); }
        }

        // Property which specifies that the caller needs table updates
        // to occur on their own thread context.
        public bool UpdateDataTableOnCallerThreadContext { get; set; }

        // Class which describes the custom event arguments raised
        public class UpdateDataTableOnYourThreadContextEventArgs : EventArgs
        {
            private ConcurrentQueue<System.Data.DataRow> qu;

            public UpdateDataTableOnYourThreadContextEventArgs
                       (ConcurrentQueue<System.Data.DataRow> Qu)
            {
                qu = Qu;
            }

            public ConcurrentQueue<System.Data.DataRow> Updates
            {
                get { return qu; }
            }
        }

        // Event raised when we need to update our data, and customer has specified
        // they need the update to occur on their own thread context (eg, UX thread).
        public event EventHandler<UpdateDataTableOnYourThreadContextEventArgs>
                                      RaiseUpdateTableAgainstYourThreadContextEvent;

        public void UpdateTableOnMyThreadContext(
                         ConcurrentQueue<System.Data.DataRow> Q)
        {
            System.Data.DataRow dr = null;
            while (Q.TryDequeue(out dr))
            {
                if (dr != null)
                {
                    itemTable.Rows.Add(dr);
                }
            }
        }

        public void Start(int delay, int interval)
        {
            myTimer.Change(delay, interval);
        }

        private void AddRows(object state)
        {
            if (itemTable.Rows.Count < 10)
            {
                System.Data.DataRow dr = this.itemTable.NewRow();

                // fill row with pseudo data
                for (int i = 0; i < 11; i++) { dr[i.ToString()] = DateTime.Now; }

                // If caller has specified, notify them so they can update the
                // data on their own thread context.
                if (UpdateDataTableOnCallerThreadContext)
                {
                    // add row to qUpdates, raise the event
                    qUpdates.Enqueue(dr);
                    OnRaiseUpdateDataTableAgainstYourThreadContextEvent(new
                             UpdateDataTableOnYourThreadContextEventArgs(qUpdates));
                }
                else
                {
                    this.itemTable.Rows.Add(dr);
                }
            }
            else
            {
                myTimer.Dispose();
                myTimer = null;
            }
        }

        protected virtual void OnRaiseUpdateDataTableAgainstYourThreadContextEvent(
                                     UpdateDataTableOnYourThreadContextEventArgs q)
        {
            // protect against race conditions:
            EventHandler<UpdateDataTableOnYourThreadContextEventArgs> handler =
                                     RaiseUpdateTableAgainstYourThreadContextEvent;

            // Event will be null if there are no subscribers
            if (handler != null)
            {
                handler(this, q);
            }
        }
    }

}

<DllImport("user32.dll")> _
Public Shared Function GetForegroundWindow() As IntPtr
End Function
<DllImport("user32.dll")> _
Private Shared Function GetWindowRect(hWnd As IntPtr, ByRef lpRect As RECT) As <MarshalAs(UnmanagedType.Bool)> Boolean
End Function
<DllImport("user32.dll", ExactSpelling := True, CharSet := CharSet.Auto)> _
Private Shared Function SetForegroundWindow(hWnd As IntPtr) As <MarshalAs(UnmanagedType.Bool)> Boolean
End Function
<StructLayout(LayoutKind.Sequential)> _
Public Structure RECT
	Public Left As Integer
	Public Top As Integer
	Public Right As Integer
	Public Bottom As Integer
End Structure

Public Shared Sub CaptureWindow(fileName As String, format As ImageFormat)
	Dim hWnd As IntPtr = GetForegroundWindow()
	If hWnd = IntPtr.Zero Then
		Return
	End If
	Dim srcRect As RECT
	If Not GetWindowRect(hWnd, srcRect) Then
		Return
	End If
	Dim width As Integer = srcRect.Right - srcRect.Left
	Dim height As Integer = srcRect.Bottom - srcRect.Top
	Using bmp As New Bitmap(width, height)
		Using g As Graphics = Graphics.FromImage(bmp)
			g.CopyFromScreen(srcRect.Left, srcRect.Top, 0, 0, New Size(width, height), CopyPixelOperation.SourceCopy)
			bmp.Save(fileName, format)
		End Using
	End Using
End Sub

[DllImport("user32.dll")]
public static extern IntPtr GetForegroundWindow();
[DllImport("user32.dll")]
[return: MarshalAs(UnmanagedType.Bool)]
private static extern bool GetWindowRect(IntPtr hWnd, out RECT lpRect);
[DllImport("user32.dll", ExactSpelling = true, CharSet = CharSet.Auto)]
[return: MarshalAs(UnmanagedType.Bool)]
private static extern bool SetForegroundWindow(IntPtr hWnd);
[StructLayout(LayoutKind.Sequential)]
public struct RECT
{
  public int Left;
  public int Top;
  public int Right;
  public int Bottom;
}
public static void CaptureWindow(string fileName, ImageFormat format)
{
  IntPtr hWnd = GetForegroundWindow();
  if (hWnd == IntPtr.Zero) return;
  RECT srcRect;
  if (!GetWindowRect(hWnd, out srcRect)) return;
  int width = srcRect.Right - srcRect.Left;
  int height = srcRect.Bottom - srcRect.Top;
  using (Bitmap bmp = new Bitmap(width, height))
  {
    using (Graphics g = Graphics.FromImage(bmp))
    {
      g.CopyFromScreen(srcRect.Left, srcRect.Top, 0, 0,
        new Size(width, height), CopyPixelOperation.SourceCopy);
      bmp.Save(fileName, format);
    }
  }
}

public int Compare(object a, object b)
{
  if (a == b)
  {
    return 0;
  }
  if (a == null)
  {
    return -1;
  }
  if (b == null)
  {
    return 1;
  }
  if (this.m_compareInfo != null)
  {
    string str = a as string;
    string str2 = b as string;
    if ((str != null) && (str2 != null))
    {
      return this.m_compareInfo.Compare(str, str2);
    }
  }
  IComparable comparable = a as IComparable;
  if (comparable == null)
  {
    throw new ArgumentException(Environment.GetResourceString("Argument_ImplementIComparable"));
  }
  return comparable.CompareTo(b);
}