Threading: does c# have an equivalent of the Java Runnable interface?

Does c# have an equivalent of the Java Runnable interface?

Yes, it's ThreadStart

class Runner{    void SomeMethod()     {        Thread newThread = new Thread(new ThreadStart(Run));        newThread.Start();     }     public void Run()      {          Console.WriteLine("Running in a different thread.")     }}

Would be equivalent to the following Java code

 class Runner implements Runnable {     void someMethod() {        Thread newThread = new Thread( this );        newThread.start();       }      public void run() {          out.println("Running in a different thread.");      }  }

Nope. C# handles threads differently to Java. Rather than subclassing the Thread class, you simply create a new System.Threading.Thread object and pass it a ThreadStart delegate (this is the function where you do the work)..

The ThreadStart delegate is essentially the same as the Runnable interface. A delegate is like an interface for a single method rather than an entire class, so it's actually easier to implement than the Runnable interface in Java.

MSDN explains about delegates:

Delegates and interfaces are similar in that they enable the separation of specification and implementation. Multiple independent authors can produce implementations that are compatible with an interface specification. Similarly, a delegate specifies the signature of a method, and authors can write methods that are compatible with the delegate specification. When should you use interfaces, and when should you use delegates?

Delegates are useful when:

• A single method is being called.
• A class may want to have multiple implementations of the method specification.
• It is desirable to allow using a static method to implement the specification.
• An event-like design pattern is desired (for more information, see the Events Tutorial).
• The caller has no need to know or obtain the object that the method is defined on.
• The provider of the implementation wants to "hand out" the implementation of the specification to only a few select components.
• Easy composition is desired.

Interfaces are useful when:

• The specification defines a set of related methods that will be called.
• A class typically implements the specification only once.
• The caller of the interface wants to cast to or from the interface type to obtain other interfaces or classes.