We bring you a much needed Rosetta Stone — an explanatory bridge between these two technologies
Java and C# are incredibly similar. Both languages are somewhat derived from C++ and from similar first principles.
Java was developed in 1995 to create a language with a simpler programming model than C++ while still preserving some of the same syntax of the language to facilitate developers transitioning to it.
C# was developed in 2000 by Microsoft as part of its .NET drive in order to develop a language and set of technologies that could address some of the perceived weaknesses of the C++ language. It was also developed with quite heavy “inspiration” from the Java language.
Despite the similarities between the languages and sharing some common ground, transitioning from one technology to the other for a developer well-practised in one technology can be quite tricky.
Innovation happens best when there is collaboration between people of different mindsets — yet users of C# and Java can be somewhat tribalistic.
To that end, I thought it would be useful to put together a sort of guide to help people thinking about or starting to transition between these two technologies. It would also be nice in some way to facilitate a bit more collaboration between these two worlds — hopefully to do my bit to reduce the needless gulf that exists between them.
Some of the similarities right off the bat:
Java is a language that runs in a virtual machine environment (JVM) and runs bytecode that the Java compiler generates.
For C#, the situation is similar. It is a language that runs on the .NET framework and the CLR runtime. It uses a similar intermediary language to Java bytecode called MSIL which gets run via CLR.
Naming and Conventions
Some of the key and most immediately obvious differences in nomenclature, syntax, and conventions are:
- “Projects” (Java) — “Solutions” (C#)
- In Java, methods use lowerCamelCase (
bar.doAThing()), whilst in C# public methods use PascalCase (bar.DoAThing()) - In C#, interfaces are always prefixed with an I, as in
IUserService<T>, instead ofUserService<T>in Java - In Java, a string is a
String— in C# a string is astring - “POJO” (Java) — “POCO” (C#)
- Packages (Java) — Namespaces (C#)
Package (Java)
package dev.andymacdonald;// Code goes here
Namespace (C#)
namespace Dev.AndyMacdonald
{
// Code goes here
}
Syntax
Java has final variables — C# has readonly
A key difference here is that Java final variables can be assigned once anywhere in the class, whereas C#’s readonly variables can only be assigned in the constructor.
C# has out and ref parameters to allow passing arguments by reference — Java doesn’t
Java doesn’t actually pass by reference in method arguments.
It can manipulate objects and variables by reference, but in a method, these arguments are passed by a value. With C#, we can override this behaviour with the out and ref keywords.
Annotations (Java) — attributes (C#)
These are basically equivalent concepts and just differ in actual syntax. Both annotations and attributes can be accessed via each language’s respective Reflection API implementation.
Java annotation:
@PersonallyIdentifiable
private String fullName;
C# attribute:
[PersonallyIdentifiable]
private string fullName;
Getters and setters or Project Lombok (Java) — C# properties
C# really overtakes Java here with its built-in propertiesfeature. In the standard JDK, there isn’t an equivalent to this, and instead, in Java, getters and setters must be written for each field requiring an accessor.
These are often just generated by the developer with their IDE as a cheat … still a bit tedious, though.
Java getters and setters:
public class Element
{
private String symbol;
private String name;
private int atomicNumber; public int getAtomicNumber()
{
return this.atomicNumber;
} public String getSymbol()
{
return this.symbol;
} public String getName()
{
return this.name;
} public void setAtomicNumber(int atomicNumber)
{
this.atomicNumber = atomicNumber;
} public void setName(String name)
{
this.name = name;
} public void setSymbol(String symbol)
{
this.symbol = symbol;
}}
Many Java projects incorporate Project Lombok, which adds getters, setters, equals, and hash code (plus other useful boilerplates) at compile time.
Project Lombok — not part of the standard library:
@Getter @Setter
public class Element
{
private String symbol;
private String name;
private int atomicNumber;}
C# built-in properties feature:
public class Element
{ public string Symbol { get; set; }
public string Name { get; set; }
public int AtomicNumber { get; set; }}
Loops
Java for each loop:
List<Integer> fibNumbers = Arrays.asList(0, 1, 1, 2, 3, 5, 8, 13);
int count = 0;
for (int element: fibNumbers)
{
count++;
System.out.println(String.format("Element #%s: %s", count, element));
}
System.out.println(String.format("Number of elements: %s", count));
C# for each loop:
var fibNumbers = new List<int> { 0, 1, 1, 2, 3, 5, 8, 13 };
int count = 0;
foreach (int element in fibNumbers)
{
count++;
Console.WriteLine($"Element #{count}: {element}");
}
Console.WriteLine($"Number of elements: {count}");
Implementing interfaces/inheritance
Inheritance and implementing interfaces isn’t drastically different between the two languages. Java uses the extends or implements keywords; C# uses C++ syntax (derivation declaration) B : A for defining inheritance.
Defining and implementing an interface with methods in Java:
package dev.andymacdonald;
import java.util.ArrayList;
import java.util.List;
interface Fish
{
void swim();
}
class Salmon implements Fish
{
public void swim()
{
System.out.println("Salmon.Fish");
}
}
class Cod implements Fish
{
public void swim()
{
System.out.println("Cod.Swim");
}
}
public class Program
{
public static void main()
{
List<Fish> fishes = new ArrayList<>();
fishes.add(new Salmon());
fishes.add(new Cod());
for (Fish fish : fishes)
{
fish.swim();
}
}
}
Defining and implementing an interface with methods in C#:
using System;
using System.Collections.Generic;namespace Dev.AndyMacdonald
{
interface Fish
{
void Swim();
} class Salmon : Fish
{
public void Swim()
{
Console.WriteLine("Salmon.Fish");
}
} class Cod : Fish
{
public void Swim()
{
Console.WriteLine("Cod.Swim");
}
} class Program
{
static void Main()
{
List<Fish> fishes = new List<Fish>();
fishes.Add(new Salmon());
fishes.Add(new Cod());
foreach (Fish fish in fishes)
{
fish.Swim();
}
}
}
}
Pointers
Quite simply, Java just doesn’t do pointers, whereas in C# it is possible to do pointer arithmetic and manipulation.
unsafe {
int a = 25;
int * ptr = &a;
Console.WriteLine($"Value of pointer is {*ptr}");
}
IDE
Visual Studio
C# developers traditionally and typically use the Visual Studio IDE. This is a situation borne out of the origins of .NET being a closed-source technology. Microsoft developed Visual Studioto be a one-stop shop for all things .NET.
Java went down a different route, offering much more developer choice in tooling from the outset. That’s why there’s a much greater range of IDEs for Java development (e.g., IntelliJ, Eclipse, NetBeans). Gradually the landscape for .NET developers has shifted, and more IDEs and developer choice has been offered over the years.
IntelliJ (Java) — Rider (C#)
Users of JetBrains IDEs will find the transition from one IDE to another very smooth if they choose to make a switch to the respective JetBrains IDE in the technology they are targeting. Keyboard shortcuts, IDE layout, and even some plugins are equivalent or comparable — virtually the same IDE.
Dependency Management
Maven (Java) — NuGet and dotnet CLI (C#)
Maven is a tool responsible for dependency management and the life cycle of the building of typically Java and JVM applications. That said, it is pretty flexible, has 1000s of plugins, and can be used to build applications of other languages, such as PHP and JavaScript.
The configurable unit of maven is a pom.xml file that every maven project has. For a project’s submodules, it is possible to have a pom file per submodule which inherits from a parent. Maven uses a remote server or repository of some kind to host and retrieve packages.
Maven pom.xml file (Java):
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion> <groupId>dev.andymacdonald</groupId>
<artifactId>fish-app</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>
<dependencies>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
At the simplest level, you can test and build a Maven project with the following command:
mvn clean install
And create a package with this:
mvn clean package
And finally, deploy a package like this:
mvn clean deploy
NuGet fulfills a similar, though not identical role in .NET to Maven. NuGet can use a few different configuration files but commonly uses .csproj. As with Maven, NuGet uses a server/repository that can host packages.
NuGet .csproj file:
<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<AssemblyName>MSBuildSample</AssemblyName>
<OutputPath>Bin\</OutputPath>
</PropertyGroup>
<ItemGroup>
<Compile Include="helloworld.cs" />
</ItemGroup>
<ItemGroup>
<PackageReference Include="MyDependency" version="1.0.0" />
</ItemGroup>
<Target Name="Build">
<MakeDir Directories="$(OutputPath)" Condition="!Exists('$(OutputPath)')" />
<Csc Sources="@(Compile)" OutputAssembly="$(OutputPath)$(AssemblyName).exe" />
</Target>
</Project>
NuGet’s primary role is package management, construction, and deployment. Java developers will notice that it doesn’t really have the same concept of build phases as Maven does. Additionally, .NET developers don’t tend to edit their build files manually as Java developers do with pom.xml files, preferring to manipulate them in their IDE instead.
Packages can be built, packaged, and deployed to NuGet with the following nuget commands:
nuget spec
nuget pack {nuspec file}
nuget push {package file} {apikey} -Source {host url}
If you want to run the tests for your .NET application, you can run the following dotnet CLI command:
dotnet test
The dotnet CLI can also be used as a wrapper around nuget commands.
Application Servers
Apache Tomcat (Java) — IIS (ASP.NET)
Tomcat is an open-source web server and servlet container from the Apache Foundation. Though there are many other application servers used widely in Java, it is a pretty common choice for most enterprise-software companies. It works across pretty much every operating system (e.g., Windows, Unix, Linux, and Mac OS).
.NET projects are typically deployed on IIS, a web server that only runs on Windows. While its portability is limited, it’s a pretty popular choice for Windows developers because of its ease of use and simplicity while still offering some advanced configuration options.
… But Wait!
There is also .NET Core, which allows you to develop cross platform applications not just restricted to Windows.
For .NET Core web applications, you can package them to run as standalone web applications — allowing you to run them like this:
dotnet <app_assembly>.dll
In the same way you can run a Java Spring Boot webapplication (which has a self-contained Tomcat server):
java -jar <my-application>.jar
And visit your shiny new web app like this:
http://<serveraddress>:<port>
Libraries and Frameworks
Spring Framework (Java) — ASP.NET (C#)
The Spring Framework is a framework and IoC container for Java. In short, the Spring framework is responsible for instantiating objects (beans) and managing the life cycle of these beans in memory.
Create an ApplicationContext(similar to the concept of a Startup in ASP.NET). This example uses Spring Boot:
@SpringBootApplication
public class HumanApplication
{
public static void main(String[] args)
{
SpringApplication.run(HumanApplication.class, args);
}
}
Create an interface:
public interface Organ<T>
{
void function();
}
Implement the Organ<T> interface:
@Component
public class Heart implements Organ<Heart>
{
public Heart() {} public void function()
{
System.out.println("Buh-dump");
}
}
Constructor injection of Organ dependencies list into a Human service:
@Service
public class Human
{
private static final int MAX_SECONDS_OF_LIFE = 3000; private List<Organ> organs; public Human(List<Organ> organs)
{
this.organs = organs;
} @PostConstruct
public void live()
{
for (int i = 0; i < MAX_SECONDS_OF_LIFE; i++)
{
organs.forEach(organ -> organ.function());
}
}
}
Run the application …
It’s aliiiiiiive:
Buh-dump
Buh-dump
Buh-dump
Buh-dump
...
Spring also ships with a handy suite of modules and packages.
In the core Spring packages, and in the convention-over-configuration extension to the framework, Spring Boot, useful combinations of existing and bespoke technologies are provided for developers wanting access to common libraries to kickstart a project with all that they may need, rather than having to write or track down these utilities themselves:
RestTemplate(spring-web — for constructing REST and HTTP requests)JdbcTemplate(spring-data — for constructing JDBC queries and statements)- Spring Security (for creating and managing application security models)
ObjectMapper(spring-core — useful utility for mapping POJOs from Jackson)- etc.
ASP.NET fulfills a similar role in the world of C#, providing IoC functionality, commonly used technologies, and utilities in a single framework. However, ASP.NET generally only provides IoC functionality for web applications, whereas the Spring Framework provides this for any application type.
In terms of dependency inversion, it is possible to do very similar things in ASP.NET as in Spring.
As before, define the needed interface and concrete implementation:
public interface Organ<T>
{
void Function();
}public class Heart : Organ<Heart>
{
public Heart() {} public void Function()
{
Console.WriteLine("Buh-dump");
}
}
Invoke functions of injected dependencies:
public class Human
{ private List<IOrgan> _organs;
public Human(List<IOrgan> organs)
{
_organs = organs;
this.Live();
} public void Live()
{
organs.ForEach(organ =>
{
organ.Function();
});
}
}
Define a Startup and register services:
public class Startup
{
public void ConfigureServices(IServiceCollection services)
{
services.AddTransient<IList<IOrgan>>(p => p.GetServices<IOrgan>().ToList());
}
}
ASP.NET also fulfills the role of providing many useful libraries and utilities to accelerate development of your project.
Streams (Java) — LINQ (C#)
Both Java and C# have mechanisms to simplify the reduction of data sets — Streams and LINQ.
There are some differences and gaps between the two technologies but if you have familiarity with one, you’ll be able to get up and running fairly quickly with the other.
Java Streams:
List<Student> studentList = Arrays.asList(
new Student(1, "John", 18, 1),
new Student(2, "Steve", 21, 1),
);List<String> studentNames = studentList.stream()
.filter(s -> s.getAge() > 18)
.filter(s -> s.getStandardID() > 0)
.map(s -> s.getName()).collect(Collectors.toList());studentNames.forEach(name -> System.out.println(name));
LINQ Query (C#):
IList<Student> studentList = new List<Student>() {
new Student() { StudentID = 1, StudentName = "John", Age = 18, StandardID = 1 } ,
new Student() { StudentID = 2, StudentName = "Steve", Age = 21, StandardID = 1 }
};var studentNames = studentList.Where(s => s.Age > 18)
.Where(st => st.StandardID > 0)
.Select(s => s.StudentName);foreach(var name in studentNames) {
Console.WriteLine(name);
}
Apache Commons (Java) — CommonLibrary.NET (C#)
Apache Commonsprovides Java developers with a collection of several independently released, useful components and utilities for the purposes of accelerating development.
If you’re in need of a utility to work with ZIP files or a set of utilities for working with mathematical expressions and formulae, then Apache Commons has you covered.
In a similar way, CommonLibrary.NET covers these bases too — there are some key differences in naming of some components and modules, but for the most part, they are pretty much equivalent in their purpose.
That said, unlike Apache Commons, CommonLibrary.NET is quite old and isn’t very commonly used in projects anymore. If you’re after a continuously updated, curated list of libraries for each respective technology, I highly recommend these two lists:akullpp/awesome-javaA curated list of awesome frameworks, libraries and software for the Java programming language. – akullpp/awesome-javagithub.comquozd/awesome-dotnetA collection of awesome .NET libraries, tools, frameworks and software – quozd/awesome-dotnetgithub.com
Testing Libraries
JUnit (Java) — NUnit (C#)
Java’s ever-dependable JUnit library has a direct equivalent in C#.
NUnit has almost equivalent functionality to JUnit and is a popular choice for C# developers.
JUnit:
@Test
public void complexNumberTest()
{
ComplexNumber result = someCalculation(); Assert.assertEquals("Real", 5.2, result.getRealPart());
Assert.assertEquals("Imaginary" 3.9, result.getImaginaryPart());
}
NUnit:
[Test]
public void ComplexNumberTest()
{
ComplexNumber result = SomeCalculation(); Assert.Multiple(() =>
{
Assert.AreEqual(5.2, result.RealPart, "Real");
Assert.AreEqual(3.9, result.ImaginaryPart, "Imaginary");
});
}
(Rumour has it NUnit started life as the JUnit source code modified to run in C#.)
Mockito (Java) — Moq (C#)
As with JUnit and NUnit, comparable functionality exists between Java’s Mockito and C#’s Moq library.
Mockito:
Foo mockFoo = mock(Foo.class);
when(mockFoo.doSomething("ping")).thenReturn(true);
Moq:
var mock = new Mock<IFoo>();
mock.Setup(foo => foo.DoSomething("ping")).Returns(true);
That’s It
Thanks for Reading!
I obviously couldn’t fit every difference, similarity, and detail in this article —it’s already far too long.
I hope at least I’ve covered enough ground to make you feel confident to make a switch and see how the other half lives.
