Skip to main content
AI
  • Get started with AI

    • Red Hat AI

      Accelerate the development and deployment of enterprise AI solutions.

    • AI learning hub

      Explore learning materials and tools, organized by task.

    • AI interactive demos

      Click through scenarios with Red Hat AI, including training LLMs and more.

    • AI/ML learning paths

      Expand your Red Hat OpenShift AI knowledge using these learning resources.

    • AI quickstarts

      Focused AI use cases designed for fast deployment on Red Hat AI platforms.

    • No-cost AI training

      Foundational Red Hat AI training.

  • Featured resources

    • Red Hat OpenShift AI
    • Open source AI for developers
    • AI product application development
    • Open source-powered AI/ML for hybrid cloud
    • AI and Node.js cheat sheet

Red Hat AI Factory with NVIDIA

Red Hat AI Factory with NVIDIA is a co-engineered, enterprise-grade AI solution for building, deploying, and managing AI at scale across hybrid cloud environments.

Learn
  • Self-guided

    • Documentation

      Find answers, get step-by-step guidance, and learn how to use Red Hat products.

    • Learning paths

      Explore curated walkthroughs for common development tasks.

    • Guided learning

      Receive custom learning paths powered by our AI assistant.

    • See all learning
  • Hands-on

    • Developer Sandbox

      Spin up Red Hat's products and technologies without setup or configuration.

    • Interactive labs

      Learn by doing in these hands-on, browser-based experiences.

    • Interactive demos

      Click through product features in these guided tours.

  • Browse by topic

    • AI/ML
    • Automation
    • Java
    • Kubernetes
    • Linux
    • See all topics
  • Training & certifications

    • Courses and exams
    • Certifications
    • Skills assessments
    • Red Hat Academy
    • Learning subscription
    • Explore training
Build
  • Get started

    • Red Hat build of Podman Desktop

      A downloadable, local development hub to experiment with our products and builds.

    • Developer Sandbox

      Spin up Red Hat's products and technologies without setup or configuration.

  • Download products

    • Red Hat Enterprise Linux
    • Red Hat AI
    • Red Hat OpenShift
    • Red Hat Ansible Automation Platform
    • See all products
  • Featured

    • Red Hat build of OpenJDK
    • Red Hat JBoss Enterprise Application Platform
    • Red Hat OpenShift Dev Spaces
    • Red Hat Developer Toolset
  • References

    • E-books
    • Documentation
    • Cheat sheets
    • Architecture center
Community
  • Get involved

    • Events
    • Live AI events
    • Red Hat Summit
    • Red Hat Accelerators
    • Community discussions
  • Follow along

    • Articles & blogs
    • Developer newsletter
    • Videos
    • Github
  • Get help

    • Customer service
    • Customer support
    • Regional contacts
    • Find a partner

Join the Red Hat Developer program

Download Red Hat products and project builds, access support documentation, learning content, and more.

ConsoleDocsSupport Search
New For you

Recommended

We'll recommend resources you may like as you browse. Try these suggestions for now.

  • Product downloads
  • Cheat sheets
  • Red Hat Developer learning portal
  • Developer blog
  • E-books
  • Developer Sandbox
Log in

Get more with a Red Hat Developer account

  • Product downloads
  • Console access
  • Event registration
  • Training & trials
Explore more account benefitsLog in or register

A subscription may be required for some services.

Contact us

From Java to .NET Core. Part 1

May 17, 2017
Yev Bronshteyn
Related topics:
.NETJava
Related products:
Red Hat OpenShift

    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: February 22, 2024

    Recent Posts

    • A day in the life of an NVIDIA H100 on Red Hat OpenShift 5

    • Migrate BuildConfigs to builds for Red Hat OpenShift with one plug-in install

    • Run Red Hat Enterprise Linux CoreOS on NVIDIA BlueField DPUs

    • Agent harness engineering: Separating model capabilities from enforcement

    • What's new for developers in Red Hat Enterprise Linux 10.3 and 9.9

    Red Hat Developers logo

    Platforms

    • Red Hat AI
    • Red Hat Enterprise Linux
    • Red Hat OpenShift
    • Red Hat Ansible Automation Platform
    • See all products

    Build

    • Developer Sandbox
    • Developer tools
    • Interactive tutorials
    • API catalog

    Quicklinks

    • Learning resources
    • E-books
    • Cheat sheets
    • Blog
    • Events
    • Newsletter

    Communicate

    • About us
    • Contact sales
    • Find a partner
    • Report a website issue
    • Site status dashboard
    • Report a security problem

    Red Hat Developer

    Build here. Go anywhere.

    We serve the builders. The problem solvers who create careers with code.

    Join us if you’re a developer, software engineer, web designer, front-end designer, UX designer, computer scientist, architect, tester, product manager, project manager or team lead.

    Sign me up

    Red Hat legal and privacy links

    • About Red Hat
    • Jobs
    • Events
    • Locations
    • Contact Red Hat
    • Red Hat Blog
    • Inclusion at Red Hat
    • Cool Stuff Store
    • Red Hat Summit
    © 2026 Red Hat

    Red Hat legal and privacy links

    • Privacy statement
    • Terms of use
    • All policies and guidelines
    • Digital accessibility
    Ask AI