.NET (Core and Framework)

S'boh wrote:

hi guys im new to programming in C# asp.net,how to write to a textfile automatically ?

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

ulasoc wrote:

How can i get list of subfolders?

ulasoc wrote:

Is there a simple way to delete non-empty folder?

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

fsOutPut = New FileStream(jitfOutputFile, FileMode.OpenOrCreate, FileAccess.Read)

fsOutPut = New FileStream(jitfOutputFile, FileMode.OpenOrCreate, FileAccess.Write)

public bool MyBool { get; set; }

Private _myBool As Boolean

Property MyBool() As Boolean
    Get
       Return _myBool
    End Get
    Set(ByVal Value As Boolean)
        _myBool = Value
    End Set
End Property

ankita.rose9 wrote:

please reply fast.....for this question

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

dgv.Invoke(new Action(() =>
    {
      var toAdd = dt.NewRow();
      dt.Rows.Add(toAdd);
    }));

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);
            }
        }
    }

}