Database Answer

Database diagram for all modules available in this link 

http://databaseanswers.org/data_models/

--
With Regards-
Siddu 

Please consider the environment before printing this e-mail

Filter an ObservableCollection with a CollectionView in C#

Article regarding how to apply filter condition on Observable Collection

http://jacobmsaylor.com/?p=1270

How do you pass arguments to a Thread that you create

1. Pass data using Lambda Expressions:

1. static void Main()
2. {
3. String m = "yeahh!";
4. Thread thread = new Thread ( () => PrintToConsole (m) );
5. thread.Start();
6. }
8. static void PrintToConsole (string message)
9. {
10. Console.WriteLine (message);
11. }

In the above example we have effectively passed m into the thread function. Any number of parameters can be passed this way.

2. Another way is to use the overloaded Thread.Start function which accepts ParamterizedThreadStart.

1. string parameter = "xyz";
2. Thread thread = new Thread(new ParameterizedThreadStart(PrintToConsole));
3. thread.Start(parameter);
4. private void PrintToConsole(object o)
5. {
6. String m = (String) o;
7. Console.WriteLine(m);
8. }

3. This is the same as (1) but the example is for .Net 4.0 Tasks

Task.Factory.StartNew(() => SomeMethod(p1,p2,p3));

Thread Pool

Creating a Thread is expensive as it requires a few hundred milliseconds to create a new one. Additionally each thread requires atleast around 1MB of data. So instead of creating and destroying a thread each time we could just create a collection of preinstantiated threads and use them instead. Whenever we require a thread we ask thread pool for a thread which we can use and when we are done with it instead of destroying it we can send it back to the collection for recycling. This way we avoid the cost it incurs for creating and destroying threads. This collection of preinstantiated thread is called a Thread Pool.

Dependency Injection

This pattern we use to break the strongly dependency across the class level.

Say, you have Class which does Database operation inside this class you want some logger to perferm like logging the debug message into the flat file.

var log = new Logger();

It is fine up to the day later sometime we have bunch of loggers available like logging Server,console or TCP/IP etc.

Of course we do not want to change all code and replace all lines with

var logger = new Logger();
by
var logger = new TcpLogger();
It is quite good idea to introduce an Interface ILog that is implemented by all the various loggers.

ILog logger = new Logger();
or
ILog logger = new TCPLogger();
or
ILog logger = new ConsoleLogger();

Now the type interface doesn't change type any more, we always keep single interface across.

 

interface ILog       {         void Log(string msg);       }       class Logger : ILog       {         public void Log(string msg)         {           //write to file.         }       }       class TCPLogger : ILog       {         public void Log(string msg)         {           //write to Server - TCP/IP.         }       }       class ConsoleLogger : ILog       {         public void Log(string msg)         {           //write to Console.         }       }       class Database       {         ILog _ilog;         public Database(ILog ilog)         { // Dependency Injection.           _ilog = ilog;         }         public void ExecuteNonQuery(string sql)         {           //do database operaion           _ilog.Log("some Database operation happened");         }       }  

Marshaling

What is Marshaling?
Creating a bridge between the Managed code and unmanaged code . Which carries messages from the managed to the unmanaged environment and viseversa provided by CLR.

Why Marshaling?
You already know that there is no such compatibility between managed and unmanaged environments. In other words, .NET does not contain such the types HRESULT, DWORD, and HANDLE that exist in the realm of unmanaged code. Therefore, you need to find a .NET substitute or create your own if needed. That is what called marshaling.

An example is the unmanaged DWORD; it is an unsigned 32-bit integer, so we can marshal it in .NET as System.UInt32. Therefore, System.UInt32 is a substitute for the unmanaged DWORD. On the other hand, unmanaged compound types (structures, unions, etc.) do not have counterparts or substitutes in the managed environment. Thus, you'll need to create your own managed types (structures/classes) that will serve as the substitutes for the unmanaged types you use.

When I Need to Marshal?
Marshaling comes handy when you are working with unmanaged code, whether you are working with Windows API or COM components. It helps you interoperating (i.e. working) correctly with these environments by providing a way to share data between the two environments. Figure 1 shows the marshaling process, where it fall, and how it is required in the communication process between the two environments. 

Invoke() and BeginInvoke()

What's the difference between Invoke() and BeginInvoke()

Delegate.Invoke/BeginInvoke and Control.Invoke/BeginInvoke

Delegate.Invoke: Executes synchronously, on the same thread.
Delegate.BeginInvoke: Executes asynchronously, on a threadpool thread.

Control.Invoke: Executes on the UI thread, but calling thread waits for completion before continuing.
Control.BeginInvoke: Executes on the UI thread, and calling thread doesn't wait for completion.

A logical conclusion is that a delegate you pass to Invoke() can have out-parameters or a return-value, while a delegate you pass to BeginInvoke() cannot (you have to use EndInvoke to retrieve the results).

 new Thread(foo).Start();     private void foo()     {     this.Dispatcher.BeginInvoke(DispatcherPriority.Normal,     (ThreadStart)delegate()     {     myTextBox.Text = "bing";     Thread.Sleep(TimeSpan.FromSeconds(3));     });     MessageBox.Show("done");     } 

If use BeginInvoke, MessageBox pops simultaneous to the text update. If use Invoke, MessageBox pops after the 3 second sleep. Hence, showing the effect of an asynchronous (BeginInvoke) and a synchronous (Invoke) call.

Delegate.BeginInvoke() asynchronously queues the call of a delegate and returns control immediately. When using Delegate.BeginInvoke(), you should call Delegate.EndInvoke() in the callback method to get the results.

Delegate.Invoke() synchronously calls the delegate in the same thread.

why and when to use Invoke().

Both Invoke() and BeginInvoke() marshal the code you specify to the dispatcher thread.

But unlike BeginInvoke(), Invoke() stalls your thread until the dispatcher executes your code. You might want to use Invoke() if you need to pause an asynchronous operation until the user has supplied some sort of feedback.

For example, you could call Invoke() to run a snippet of code that shows an OK/Cancel dialog box. After the user clicks a button and your marshaled code completes, the invoke() method will return, and you can act upon the user's response.