CODEWITHSUNDEEP
wpf
wildbisu
wildbisu

Reputation: 172

performing database operations in the background in WPF application?

In my WPF application I need to perform database operattions in the background to make the UI more responsive. I'm making use of the BackgroungWorker class, but since it operates on different thread than that of UI, i can't pass the parameters to the database queries.These values comes from the UI controls.

Could anyone please help me with this problem or suggest some other way to do database operations,at the same time making UI responsive.

Thank You

Upvotes: 0

Views: 794

Answers (2)

Dan Busha
Dan Busha

Reputation: 3803

I think the BackgroundWorker is the correct tool for the job. When you create a BackgroundWorker you specify an event handler for the DoWork event. The DoWorkEventArgs object has a property on it called Arguments which is the object passed in when you start the BackgroundWorker by calling RunWorkerAsync. You may need to create a helper class to handle the parameters you need to pass, but that should be quite easy. Something like

Helper Class:

public class WorkerArgs
{
     public string Arg1 {get;set;}
     public object Arg2 {get;set;}
     public int Arg3 {get;set;}
}

Background Worker:

BackgroundWorker worker = new BackgroundWorker();

// Hook up DoWork event handler
worker.DoWork += (sender, e) => {
     WorkerArgs args = e.Arguments as WorkerArgs;
     // ... Do the rest of your background work
};

// Create arguments to pass to BackgroundWorker
WorkerArgs myWorkerArgs = new WorkerArgs {Arg1 = "Foo", Arg2 = new Object(), Arg3 = 123 };

// Start BackgroundWorker with arguments
worker.RunWorkerAsync(myWorkerArgs);

In your case, you would populate the helper class object with values from your UI controls.

Upvotes: 0

gliderkite
gliderkite

Reputation: 8928

Instead of using BackgroungWorker class you could work with Dispatcher.BeginInvoke method. In fact as specified by MSDN:

BeginInvoke is asynchronous; therefore, control returns immediately to the calling object after it is called. In WPF, only the thread that created a DispatcherObject may access that object. For example, a background thread that is spun off from the main UI thread cannot update the contents of a Button that was created on the UI thread. In order for the background thread to access the Content property of the Button, the background thread must delegate the work to the Dispatcher associated with the UI thread. This is accomplished by using either Invoke or BeginInvoke. Invoke is synchronous and BeginInvoke is asynchronous. The operation is added to the event queue of the Dispatcher at the specified DispatcherPriority.

Here a good article that explains how to work with Dispatcher class.

Upvotes: 1

Related Questions