Article

From Java to .NET Core. Part 1

May 17, 2017
.NET C# Java
Yev Bronshteyn
Guest Author

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; }
        set
        {
            if ("Donald".Equals(value))
            {
                Console.WriteLine("I'm moving to Canada!");
            }
            this.name = value;
        }
    }
}

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<string, 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).sorted(String::compareToIgnoreCase).collect(Collectors.toList());

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.

For additional information and articles on .NET Core visit our .NET Core web page for more on this topic.

 

Click here to install .NET Runtime for Red Hat Enterprise Linux and run a simple "Hello, World" application.

Last updated: March 22, 2023

Comments