4 Key Differences Moving From Java to .NET Core. Part 1

From Java to .NET Core. Part 1

This post was originally published on the Red Hat Developers blog.

There was a time when the word “.NET” was virtually synonymous with bloat, vendor lock-in, and Windows. .NET Core is the exact opposite. It’s blazingly fast. It’s open source under a permissive license (Mostly MIT, some parts Apache-2.0). Unlike some other open-source platforms, .NET Core’s Contributor License Agreement does not grant exclusive privileges to a single corporation. .NET Core is cross-platform, allowing you to target Windows, Mac, Docker, and many flavors of Linux. My favorite resource for getting started with .NET Core is Don Schenck’s free book. This post, I hope, can serve as an addendum specifically for Java developers exploring .NET’s flagship language, C#. While C# borrows much from Java, there are important differences to be aware of. Fortunately, some of them are for the better. In this series of posts, I’ll go over a few of the most prominent differences.

1. Naming Conventions

The naming and coding conventions are the surest way for experienced .NET developers to spot Java developers trying to cross over. In .NET, public methods are PascalCased, as in myObject.DoSomething();. Interface names always start with I, as in IComparable<T> (unless they were written by a Java developer). These are just the two most obvious differences. Before checking your code into a public repository, you may wish to check the full Coding Conventions and Naming Conventions.

2. Properties instead of Getters and Setters

In .NET, properties provide the same kind of encapsulation as get and set methods in Java classes, except properties are sweetened with a generous helping of syntactic sugar. Like this:

public class Person
   public string Name { get; set; }

public class MainClass
    public static void Main(string[] args)
        Person joe = new Person();
        joe.Name = "Joe";
        Console.WriteLine($"Why, hello, {joe.Name}!");
        Person joanna = new Person() { Name = "Joanna" };

Want to make a property immutable? Easy!

public class Person
    public string Name{get; private set;}

Want to implement your own get and set logic?

public class Person
    private string name;
    public string Name
        get { return name; }
            if ("Donald".Equals(value))
                Console.WriteLine("I'm moving to Canada!");
            this.name = value;


Explore projects in OpenHub

3. Var instead of <> and carpal tunnel syndrome

Remember the DRY rule (“don’t repeat yourself”)? Nothing is more repetitive than typing out a type name twice: once to declare and once to initialize:

Dictionary<string, IList<string>> listMap = new Dictionary<strin
g, IList<string>>();

With Java’s <> operator, the duplication would be reduced to just Dictionary, but in C#, we can do better:

var listMap = new Dictionary<string, IList<string>>();

The statement above is equivalent to the one immediately prior. The type of listMap becomes fixed. It cannot be assigned an object of any type other than Dictionary.

Oh, and while we’re on the subject, Dictionary is what we call maps in .NET (except they don’t allow nulls).

4. Linq instead of streams

When streams were introduced in Java 8, many of the tasks previously requiring writing for loops became declarative and elegant. Here’s how one might get an alphabetically sorted list of names:

List<String> sortedNames = people.stream().map(Person::getName).s

C# developers have had similar functionality since 2008 in a feature called “Language Integrated Query” (LINQ). To use LINQ, first you’ll need to add its namespace to your using declarations:

using System.Linq;

So here’s the LINQ equivalent of that Java stream example above:

IList<string> sortedNames = people.Select(person => person.Name).
OrderBy(x => x.ToLower()).ToList();

Ok, that’s not much prettier. And, this approach does not look much like a query or very language-integrated. Fortunately, C# provides some nifty syntactic sugar to make the same functionality much easier to read and write:

IEnumerable<string> names = from p in people
                            orderby p.Name.ToLower()
                            select p.Name;

The same kind of query syntax can be applied to databases, XML, JSON, and just about anything else. It’s completely extensible.

To be continued…

Obviously, there are many more differences than I have described here. In subsequent posts, we’ll take up Assembly loading vs. class loading, true generics vs. type erasure, value types vs. primitives, and much more. While Java has been languishing in a design-by-committee quagmire, C# and .NET have been steadily advancing. Now that .NET Core, with its requisite compilers and language tooling are open source, you may be surprised by how productive and liberated you can become in this new and exciting ecosystem.

Read more posts by Yev. 

Sorry we missed you! We close comments for older posts, but we still want to hear from you. Tweet @black_duck_sw to continue the discussion.


#Nugate and the Reality of (Commercial) Open Source

| Aug 8, 2017

Note: this post is the opinion of its author and may not represent the views of Black Duck Software, its shareholders, and other employees. There was a small scandal in a small corner of the open source world last week (#nugate). A pull request was submitted to the Nuget Gallery project to add

| MORE >

Why People and Businesses Get Blindsided by Threats

| Jul 24, 2017

When Black Duck released the results of its 2017 Open Source Security and Risk Analysis, the results were deeply concerning. Among the audited applications, 96% utilized open source, of which 67% contained known vulnerabilities. On average, the identified vulnerabilities had been known for four

| MORE >

From Java to .NET Core, Part 2: Types

| Jun 22, 2017

This post was originally published on the Red Hat Developers blog. In my previous post in the series, I discussed some fairly surface-level differences between C#/.NET and Java. These can be important for Java developers transitioning to .NET Core, to create code that looks and feels “native” to

| MORE >