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.