This document provides an overview comparison of key concepts between Java and C# programming languages. It covers differences in language syntax, frameworks, and platforms. Some key differences highlighted include C# using the .NET framework instead of Java's JVM, C# properties instead of getter/setter methods, and C# supporting structs as value types while Java only supports classes as reference types. The document also provides examples of implicit and explicit interface implementation in both languages.

1. C#
for Java Developers
dhaval.dalal@software-artisan.com
@softwareartisan

2. A Broad Overview
.NET Platform JVM Platform
IL
Intermediate
Language
Bytecode
C# F# VB.NET Java Groovy Scala
CLR
(Common Language Runtime)
Win Win Mac UnixLinux
csc javac
groovyc
fsc
vbc
scalac
JRE
(Java Runtime Environment)
Mono

3. Technology Stack
Java C#
Data Access
Client Side GUI
Web Side GUI
Web Scripting
Web Hosting
Remote Invocation
Messaging
Native
Directory Access
Componentization
JDBC ADO.NET
AWT/Swing WinForms, WPF
JSP, JavaFX, JSF ASP.NET, WebForms
Servlets, Filters
ISAPI, HttpHandler,
HttpModule
Tomcat, Jetty, Weblogic
etc...
IIS
RMI, Netty, AKKA Remoting, now part of WCF
JMS, AKKA MSMQ
JNI PInvoke
JNDI Active Directory (Ldap/ADSI)
EJB (Entity/Session), Spring
COM+, Managed Extensibility
Framework (MEF)

4. Language Comparison
Java C#
Program Entry Point
Namespace
Including Classes
Inheritance
Overriding
Accessing Parent Ctor
Accessing Parent Method
Visibility
main(String ...args)
Main() or
Main(string [] args)
package namespace
import using
class (extends),
interface (implements)
class and interface (:)
virtual by default
non-virtual by default
use virtual keyword
super(...) : base(...)
super.method(...) base.Method(...)
private, package,
protected, public
private, protected, internal,
internal protected, public

5. Language Comparison
Java C#
Abstract Class
Non-Extensible Class
Non-Writable Field
Non-Extensible Method
Constant
Checking Instance Type
Enums
for-each construct
Switch-Case
abstract class X { ... } abstract class X { ... }
final class X { ... } sealed class X { ... }
final readonly
final sealed
static final const
instanceof is
enum, can have fields, methods and
implement interfaces and are typesafe
enum, cannot have methods,
fields or implement
interfaces, not typesafe
for (item : collection)
{ ... }
foreach(item in collection)
{ ... }
numeric types (int,
float...) enums, and now
strings (in Java 7)
numeric types, enums and
strings

6. Language Comparison
Java C#
Method Parameters
Variable Arguments
Exceptions
ADT Meta Type
Meta Information
Static class
Properties
Non-Deterministic Object
Cleanup
Object References are
passed by Value only
Object reference are passed
by Value(default), ref & out
method(type... args) Method(params type[] args)
Checked and Unchecked
(enforced by javac, not by JIT
compiler)
All Unchecked Exceptions
Class
Class klass = X.class;
Type
Type type = typeof(X);
@Annotation [Attribute]
Simulated by private Ctor
and static methods
Static class and ctor with
static methods
getProperty(),
setProperty()
Property { get; set; }
compiler generated
get_Property() and
set_Property() methods
finalize() destructor ~X()

7. Language Comparison
Java C#
Deterministic Object Cleanup
Generics
Class Loading
synchronized block
synchronized method
Thread Local Storage
Smallest Deployment Unit
Signing
AutoCloseable or Closeable
try-with-resources (Java 7)
try ( ... ) { ... }
IDisposable
using ( ... ) { ... }
<T>, <T extends Type>, <?>
Type Erasure
<T>, where T : type, new()
Preserves Type Info
Class.forName(“fqn”)
ClassLoader.getResources()
Activator.CreateInstance<T>()
Assembly.Load()
synchronized (this) { ... } lock (this) { ... }
synchronized method()
{ ... }
[MethodImpl(MethodImplOptions.Synchronized)]
void Method() { ... }
Thread relative static fields
Thread relative static fields
[ThreadStatic] and Data Slots
Jar
EXE/DLL
Private Assembly, Shared Assembly
Jar Signing Assembly Signing

8. Specific to C#
• Aliases
• Verbatim Strings
• var
• Partial Class/Method
• Object Initializer
• Named Args
• Optional Args
• Value Types(struct)
• Nullable Types
• Safe Cast
• Tuples
• Extension Methods
• Operator Overloading
• Indexer

9. Value Type
or
Ref Type?
Value Type
use ==
Reference Type use
ReferenceEquals
Specific to C#: Equality
• ForValue Types, default Equals implementation uses
reflection on fields.
• Override Equals for Reference Types
• Use the same strategy forValue Types, it is more
performant and consistent as well.

10. Equality Similarities
• Define Equals(object other) and hashCode as a
part of the contract
• Define both in terms of immutable fields
• It should be
• Reflexive: x.Equals(x) => True
• Symmetric: if x.Equals(y) then y.Equals(x) => True
• Transitive: x.Equals(y) and y.Equals(z), then x.Equals(z) =>
True

11. Specific to C#: Equality
• Use Exact object argument - Equals for use in
Collections and for performance.
• IEquatable<T>
• PreserveValue Semantics forValue Types
• Overload == operator

12. Implicit & Explicit
Interfaces
01. interface Greet1 {
02. public String greet();
03. }
04.
05. interface Greet2 {
06. public String greet();
07. }
08.
09. public class Greeter implements Greet1, Greet2 {
10. //Implicit Implementation
11. public String greet() {
12. {
13. return “Hello”;
14. }
15.
16. public static void main(String ...args) {
17. Greet1 greeter1 = new Greeter();
18. greeter1.greet(); // Hello
19.
20. Greet2 greeter2 = new Greeter();
21. greeter2.greet(); // Hello
22.
23. Greeter greeter = new Greeter();
24. greeter.greet(); // Hello
25. }
26. }

13. Implicit & Explicit
Interfaces
01. interface Greet1 {
02. public String greet();
03. }
04.
05. interface Greet2 {
06. public String greet();
07. }
08.
09. public class Greeter implements Greet1, Greet2 {
10. //Implicit Implementation
11. public String greet() {
12. {
13. return “Hello”;
14. }
15.
16. public static void main(String ...args) {
17. Greet1 greeter1 = new Greeter();
18. greeter1.greet(); // Hello
19.
20. Greet2 greeter2 = new Greeter();
21. greeter2.greet(); // Hello
22.
23. Greeter greeter = new Greeter();
24. greeter.greet(); // Hello
25. }
26. }
Java: Implicit means whether you use Greet1 or
Greet2, it invokes the same implementation.

14. Implicit & Explicit
Interfaces
01. interface Greet1 {
02. public String greet();
03. }
04.
05. interface Greet2 {
06. public String greet();
07. }
08.
09. public class Greeter implements Greet1, Greet2 {
10. //Implicit Implementation
11. public String greet() {
12. {
13. return “Hello”;
14. }
15.
16. public static void main(String ...args) {
17. Greet1 greeter1 = new Greeter();
18. greeter1.greet(); // Hello
19.
20. Greet2 greeter2 = new Greeter();
21. greeter2.greet(); // Hello
22.
23. Greeter greeter = new Greeter();
24. greeter.greet(); // Hello
25. }
26. }
Java: Implicit means whether you use Greet1 or
Greet2, it invokes the same implementation.
01. interface Greet1
02. {
03. string Greet();
04. }
05. interface Greet2
06. {
07. string Greet();
08. }
09. public class Greeter : Greet1, Greet2
10. {
11. //Implicit Implementation
12. public string Greet() //Note the Visibility here
13. {
14. return “Hello”;
15. }
16.
17. public static void Main()
18. {
19. Greet1 greeter1 = new Greeter();
20. greeter1.Greet(); // Hello
21. Greet2 greeter2 = new Greeter();
22. greeter2.Greet(); // Hello
23. Greeter greeter = new Greeter();
24. greeter.Greet(); // Hello
25. }
26. }

15. Implicit & Explicit
Interfaces
01. interface Greet1 {
02. public String greet();
03. }
04.
05. interface Greet2 {
06. public String greet();
07. }
08.
09. public class Greeter implements Greet1, Greet2 {
10. //Implicit Implementation
11. public String greet() {
12. {
13. return “Hello”;
14. }
15.
16. public static void main(String ...args) {
17. Greet1 greeter1 = new Greeter();
18. greeter1.greet(); // Hello
19.
20. Greet2 greeter2 = new Greeter();
21. greeter2.greet(); // Hello
22.
23. Greeter greeter = new Greeter();
24. greeter.greet(); // Hello
25. }
26. }
Java: Implicit means whether you use Greet1 or
Greet2, it invokes the same implementation.
01. interface Greet1
02. {
03. string Greet();
04. }
05. interface Greet2
06. {
07. string Greet();
08. }
09. public class Greeter : Greet1, Greet2
10. {
11. //Implicit Implementation
12. public string Greet() //Note the Visibility here
13. {
14. return “Hello”;
15. }
16.
17. public static void Main()
18. {
19. Greet1 greeter1 = new Greeter();
20. greeter1.Greet(); // Hello
21. Greet2 greeter2 = new Greeter();
22. greeter2.Greet(); // Hello
23. Greeter greeter = new Greeter();
24. greeter.Greet(); // Hello
25. }
26. }
C#: Implicit interface implementation

16. Specific to C#: Explicit
Interfaces

17. Specific to C#: Explicit
Interfaces01. interface Greet1 // v1.0
02. {
03. string Greet();
04. }
05. interface Greet2 //v2.0
06. {
07. string Greet();
08. }
09. public class Greeter : Greet1, Greet2
10. {
11. //Explicit Implementations
12. string Greet1.Greet() //Note the Visibility here
13. {
14. return “Hello from 1”;
15. }
16. string Greet2.Greet() //public not allowed for explicit
17. {
18. return “Hello from 2”;
19. }
20. public static void Main()
21. {
22. Greet1 greeter1 = new Greeter();
23. greeter1.Greet(); // Hello from 1
24. Greet2 greeter2 = new Greeter();
25. greeter2.Greet(); // Hello from 2
26. Greeter greeter = new Greeter();
27. greeter. // No Greeters to Greet unless I cast
28. }
29. }

18. Specific to C#: Explicit
Interfaces01. interface Greet1 // v1.0
02. {
03. string Greet();
04. }
05. interface Greet2 : Greet1 // v2.0
06. {
07. new string Greet();
08. }
09. public class Greeter : Greet2
10. {
11. //Explicit Implementations
12. string Greet1.Greet() //Note the Visibility here
13. {
14. return “Hello from 1”;
15. }
16. string Greet2.Greet() //public not allowed for explicit
17. {
18. return “Hello from 2”;
19. }
20. public static void Main()
21. {
22. Greet1 greeter1 = new Greeter();
23. greeter1.Greet(); // Hello from 1
24. Greet2 greeter2 = new Greeter();
25. greeter2.Greet(); // Hello from 2
26. Greeter greeter = new Greeter();
27. greeter. // No Greeters to Greet unless I cast
28. }
29. }
01. interface Greet1 // v1.0
02. {
03. string Greet();
04. }
05. interface Greet2 //v2.0
06. {
07. string Greet();
08. }
09. public class Greeter : Greet1, Greet2
10. {
11. //Explicit Implementations
12. string Greet1.Greet() //Note the Visibility here
13. {
14. return “Hello from 1”;
15. }
16. string Greet2.Greet() //public not allowed for explicit
17. {
18. return “Hello from 2”;
19. }
20. public static void Main()
21. {
22. Greet1 greeter1 = new Greeter();
23. greeter1.Greet(); // Hello from 1
24. Greet2 greeter2 = new Greeter();
25. greeter2.Greet(); // Hello from 2
26. Greeter greeter = new Greeter();
27. greeter. // No Greeters to Greet unless I cast
28. }
29. }

19. Specific to C#: Explicit
Interfaces01. interface Greet1 // v1.0
02. {
03. string Greet();
04. }
05. interface Greet2 : Greet1 // v2.0
06. {
07. new string Greet();
08. }
09. public class Greeter : Greet2
10. {
11. //Explicit Implementations
12. string Greet1.Greet() //Note the Visibility here
13. {
14. return “Hello from 1”;
15. }
16. string Greet2.Greet() //public not allowed for explicit
17. {
18. return “Hello from 2”;
19. }
20. public static void Main()
21. {
22. Greet1 greeter1 = new Greeter();
23. greeter1.Greet(); // Hello from 1
24. Greet2 greeter2 = new Greeter();
25. greeter2.Greet(); // Hello from 2
26. Greeter greeter = new Greeter();
27. greeter. // No Greeters to Greet unless I cast
28. }
29. }
01. interface Greet1 // v1.0
02. {
03. string Greet();
04. }
05. interface Greet2 //v2.0
06. {
07. string Greet();
08. }
09. public class Greeter : Greet1, Greet2
10. {
11. //Explicit Implementations
12. string Greet1.Greet() //Note the Visibility here
13. {
14. return “Hello from 1”;
15. }
16. string Greet2.Greet() //public not allowed for explicit
17. {
18. return “Hello from 2”;
19. }
20. public static void Main()
21. {
22. Greet1 greeter1 = new Greeter();
23. greeter1.Greet(); // Hello from 1
24. Greet2 greeter2 = new Greeter();
25. greeter2.Greet(); // Hello from 2
26. Greeter greeter = new Greeter();
27. greeter. // No Greeters to Greet unless I cast
28. }
29. }
Explicitly State the interface for which the
implementation is

20. Similarities
• Immutable Strings
• Serialization
• Boxing
• ConvertValue Type to a Reference Type
• Unboxing
• Convert Reference Type to aValue Type

21. Similarities
• Collections
• C# - IList, IDictionary, Queue, Stack
• Java - List, Map, Queue, Stack
• for-each Collection Iterators

22. Specific to C#
• Collection Initializer
• Coroutines (more precisely Generators)
• yield break
• yield return
01. public static void Main() {
02. foreach(int fiboSeq in new Fibonacci(5)) {
03. Console.Out.WriteLine("{0}", fiboSeq);
04. }
05. }
Output:
0
1
1
2
3
5

23. Specific to C#
• Collection Initializer
• Coroutines (more precisely Generators)
• yield break
• yield return
01. class Fibonacci : IEnumerable<int> {
02. private readonly int howMany;
03. private int firstSeed, secondSeed = 1;
04.
05. public Fibonacci(int howMany)
06. {
07. this.howMany = howMany;
08. }
09.
10. public IEnumerator<int> GetEnumerator()
11. {
12. if (howMany < 0)
13. {
14. yield break;
15. }
16. for (var i = 0; i <= howMany; i++)
17. {
18. yield return firstSeed;
19. var sum = firstSeed + secondSeed;
20. firstSeed = secondSeed;
21. secondSeed = sum;
22. }
23. }
24.
25. IEnumerator IEnumerable.GetEnumerator()
26. {
27. return GetEnumerator();
28. }
29. }
01. public static void Main() {
02. foreach(int fiboSeq in new Fibonacci(5)) {
03. Console.Out.WriteLine("{0}", fiboSeq);
04. }
05. }
Output:
0
1
1
2
3
5

24. Covariance &
Contravariance
• Covariance
• Pass collection of sub-class to a collection of base class
• Contravariance
• Pass collection of base class to a collection of sub-class
• Invariance
• Neither of the above applies

25. Arrays and Generic
Collections
• Arrays are Covariant in C# and Java
• There is a hole in the type system and a runtime patch is
applied.
• Generics are Invariant in Java.
• In C#, use leniency offered by IEnumerable if you
need Covariance.
• Only interfaces and delegates can be covariant (out) or
contravariant (in)

26. C# Example

27. C# Example
01. abstract class Animal {
02. public abstract string Speak();
03. }
04.
05. class Cat : Animal {
06. public string Speak() {
07. return “Meow!”;
08. }
09. }
10.
11. class Dog : Animal {
12. public string Speak() {
13. return “Bark!”;
14. }
15. }
16.
17. class Printer {
18. public static Print(Animal [] animals) {
19. animals[0] = new Dog();
20. for (var i = 0; i < animals.Length; i++) {
21. System.out.println(animals[i].speak();
22. }
23. }
24.
25. public static Print(IList<Animal> animals) {
26. for (var animal in animals) {
27. System.out.println(animal.Speak());
28. }
29. }
30.

28. C# Example
01. abstract class Animal {
02. public abstract string Speak();
03. }
04.
05. class Cat : Animal {
06. public string Speak() {
07. return “Meow!”;
08. }
09. }
10.
11. class Dog : Animal {
12. public string Speak() {
13. return “Bark!”;
14. }
15. }
16.
17. class Printer {
18. public static Print(Animal [] animals) {
19. animals[0] = new Dog();
20. for (var i = 0; i < animals.Length; i++) {
21. System.out.println(animals[i].speak();
22. }
23. }
24.
25. public static Print(IList<Animal> animals) {
26. for (var animal in animals) {
27. System.out.println(animal.Speak());
28. }
29. }
30.
01. public static Print(IEnumerable<Animal> animals)
02. {
03. for (var animal in animals) {
04. Console.Out.WriteLine(animal.Speak());
05. }
06. }
07. }
08. class TestCollections {
09. public static void main(String []args) {
10. Cat cat = new Cat();
11. Animal animal = cat;
12. animal.speak();
13.
14. animal = new Dog();
15. animal.speak();
16.
17. Animal [] animals = new Animal [] { cat, dog };
18. Cat [] cats = new Cat[] { cat };
19. animals = cats;
20. Print(animals); //Exposes Hole in Type System
21.
22. // In absence of above Print method, the code
23. // does not compile as Generic Collections in
24. // C# are Invariant.
25. List<Animal> animals = new ArrayList<Dog>();
26
27. //We need Co-variance to allow this to compile
28. Printer.Print(dogs);
29.
30. }
31. }

29. Java Example

30. Java Example
01. abstract class Animal {
02. public abstract String speak();
03. }
04.
05. class Cat extends Animal {
06. public String speak() {
07. return “Meow!”;
08. }
09. }
10.
11. class Dog extends Animal {
12. public String speak() {
13. return “Bark!”;
14. }
15. }
16.
17. class Printer {
18. public static print(Animal [] animals) {
19. animals[0] = new Dog();
20. for (int i = 0; i < animals.length; i++) {
21. System.out.println(animals[i].speak();
22. }
23. }
24.
25. public static print(List<Animal> animals) {
26. for(Animal animal : animals) {
27. System.out.println(animal.speak());
28. }
29. }
30. }

31. Java Example
01. class TestCollections {
02. public static void main(String []args) {
03. Cat cat = new Cat();
04. Animal animal = cat;
05. animal.speak();
06.
07. animal = new Dog();
08. animal.speak();
09.
10. Animal [] animals = new Animal [] { cat, dog };
11. Cat [] cats = new Cat[] { cat };
12. animals = cats;
13. print(animals); //Exposes Hole in Type System
14.
15. // Fails to compile as Generic Collections in
16. // Java are Invariant
17. List<Animal> animals = new ArrayList<Dog>();
18.
19. List<Dog> dogs = new ArrayList<Dog>();
20. dogs.add(dog);
21. dogs.add(dog);
22. print(dogs);
23. }
24. }
01. abstract class Animal {
02. public abstract String speak();
03. }
04.
05. class Cat extends Animal {
06. public String speak() {
07. return “Meow!”;
08. }
09. }
10.
11. class Dog extends Animal {
12. public String speak() {
13. return “Bark!”;
14. }
15. }
16.
17. class Printer {
18. public static print(Animal [] animals) {
19. animals[0] = new Dog();
20. for (int i = 0; i < animals.length; i++) {
21. System.out.println(animals[i].speak();
22. }
23. }
24.
25. public static print(List<Animal> animals) {
26. for(Animal animal : animals) {
27. System.out.println(animal.speak());
28. }
29. }
30. }

32. Specific to C#
• Anonymous Types
• Anonymous Methods/Delegates
• Pass Methods as Data
• Action: No return values
• Func: Non-void return values
• Predicate: A Func that always returns a bool
• Generally above suffice, but if not,then use Custom Delegates
• Delegate Chaining
• Compiler Eye Candy: +=, -= for Combine(), Remove()
• Lambdas

33. Specific to C#
• Events
• Syntactic sugar over delegates, but with visibility
• Events can only be invoked from within the class that declared it, whereas a
delegate field can be invoked by whoever has access to it.
• Events can be included in interfaces, delegates cannot be.
• Built-in EventHandler and EventArgs
• Compiler generated add_ and remove_ methods for
the event.
• dynamic
• ExpandoObject

34. Dynamic Runtime Library
CLR
(Common Language Runtime)
DLR
(Dynamic Language Runtime)
C#
VB.NET
Python
Ruby
• Allows you to talk with
implementations in other
languages
• C#/VB.NET with Python, Ruby
• Also with Silverlight etc..
Dynamically Typed
Statically Typed
01. using IronPython.Hosting;
02. using Microsoft.Scripting.Hosting;
03.
04. var python = Python.CreateRuntime();
05. dynamic script = python.UseFile(“Calculator.py”);
06.
07. // Get PythonType
08. dynamic Calculator = script.GetVariable(“Calculator”);
09. dynamic calc = Calculator(); // Instantiate Object
10.
11. //Invoke method
12. dynamic result = calc.add(2, 3); // 5

35. Specific to C#
• Avoid Configuration hell
• Single Configuration File (App.config)
• Asynchronous Programming
• BeginInvoke and EndInvoke
• Wait with EndInvoke
• Wait with WaitHandle
• Poll for Async call completion
• Execute a callback upon completion
• Task Parallel Library (TPL)

36. Specific to Java
• Static Imports
• Instance and Static Initializers
• Interfaces Containing Fields
• Anonymous Classes
• Proxy Support through Interceptor

37. Specific to Java
• Asynchronous Programming
• Future Task
• Poll Completion with isDone().
• Execute callback upon completion
• Using ListenableFuture and FutureCallback - Google Guava Library
• Or roll your own result completion callback.
• Akka Actors

38. Frameworks and Tools
Java C#
Dependency Injection
Frameworks
ORM Frameworks
Proxying/AOP Frameworks
TDD Frameworks
Mocking Frameworks
BDD Frameworks
Build Tools
Coverage Tools
Profiler
Code Analysis Tools
Spring, Guice, Pico
Container etc...
Spring.NET, Unity Container
Hibernate, iBatis etc...
NHibernate, Entity
Framework
JDK Proxy, Spring AOP, CGLib
AspectJ, AspectWerkz
Castle Proxy, Rhino Proxy,
Unity Interceptor
JUnit, TestNG NUnit, MSTest
JMock2, Mockito, EasyMock Rhino Mocks, Moq, TypeMock
Cucumber, JBehave, Spock,
Easyb
NBehave, SpecFlow, NSpec
Ant, Maven, Gradle, Ivy NAnt, MSBuild, NMaven
Cobertura, Emma, Clover NCover, OpenCover
JProfiler, YourKit dotTrace, YourKit.NET
FindBugs, PMD, Checkstyle,
JDepend
FxCop, NDepend, ReSharper,
Simian

39. References
• MSDN Site
• Venkat Subramaniam
• http://agiledeveloper.com/presentations/CSharpForJavaProgrammers.zip
• Wikipedia
• http://en.wikipedia.org/wiki/Comparison_of_C_Sharp_and_Java
• Dare Obasanjo
• http://www.25hoursaday.com/CsharpVsJava.html
• Scott Hanselman
• http://www.hanselman.com/blog/
C4AndTheDynamicKeywordWhirlwindTourAroundNET4AndVisualStudio2010Beta1.aspx