C# vs. Java Enums: What are the Key Differences and How Can I Effectively Migrate from Java to C#?

C# vs. Java Enums: Clarifying the Differences for C# Newcomers

When migrating from Java to C#, you may notice differences in enumeration implementation. While C# enums may appear simpler at first glance, understanding their differences is critical to effectively utilizing their capabilities.

Differences between C# and Java enumerations

• Type safety: Java enumerations provide stricter type safety by automatically creating subclasses and enforcing exclusivity. C# enums, on the other hand, are value types and allow implicit conversions, which can lead to runtime errors.
• Function limitations: Java enumerations provide built-in methods such as valueOf, name, and ordinal. C# enumerations lack these methods but allow custom extension methods to enhance their functionality.
• Storage: Java enumerations store enumeration values ​​as objects on the heap. C# enumerations store values ​​as integers on the stack, providing faster access and a smaller memory footprint.
• Properties: Java enumerations can have associated data stored in EnumConstants, but they are static and immutable. C# enumerations support custom properties, allowing you to add additional information dynamically.

Overcoming Differences

To bridge the gap between Java and C# enums, consider the following:

• Using extension methods: C# enumerations allow you to define extension methods that replicate the functionality of Java enumeration methods. This provides a convenient way to access common operations without modifying the core enumeration definition.
• Leverage Custom Properties: C# allows you to define custom properties that can be used to associate additional data with enumeration values. This approach provides a flexible way to store and access extended properties on enumerations.

Equivalent implementation of the planet example in C#

To emulate the functionality of the Planet enumeration in Java, you can implement custom properties and extension methods in C# as follows:

<code class="language-csharp">using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;

namespace Planets
{
    [AttributeUsage(AttributeTargets.Field)]
    public class PlanetAttribute : Attribute
    {
        public double Mass { get; set; }
        public double Radius { get; set; }
    }

    public enum Planet
    {
        [PlanetAttribute(3.303e+23, 2.4397e6)]
        Mercury,
        [PlanetAttribute(4.869e+24, 6.0518e6)]
        Venus,
        [PlanetAttribute(5.976e+24, 6.37814e6)]
        Earth,
        [PlanetAttribute(6.421e+23, 3.3972e6)]
        Mars,
        [PlanetAttribute(1.9e+27, 7.1492e7)]
        Jupiter,
        [PlanetAttribute(5.688e+26, 6.0268e7)]
        Saturn,
        [PlanetAttribute(8.686e+25, 2.5559e7)]
        Uranus,
        [PlanetAttribute(1.024e+26, 2.4746e7)]
        Neptune,
        [PlanetAttribute(1.27e+22, 1.137e6)]
        Pluto
    }

    public static class PlanetExtensions
    {
        public static double SurfaceGravity(this Planet planet)
        {
            PlanetAttribute attribute = GetAttribute<PlanetAttribute>(planet);
            return GetG() * attribute.Mass / (attribute.Radius * attribute.Radius);
        }

        public static double SurfaceWeight(this Planet planet, double mass)
        {
            return mass * planet.SurfaceGravity();
        }

        private static double GetG() => 6.67300E-11;

        private static T GetAttribute<T>(Planet planet) where T : Attribute
        {
            FieldInfo fieldInfo = typeof(Planet).GetField(planet.ToString());
            return fieldInfo.GetCustomAttribute<T>();
        }
    }

    public class Program
    {
        public static void Main(string[] args)
        {
            double earthWeight = 175;
            double mass = earthWeight / Planet.Earth.SurfaceGravity();
            Console.WriteLine($"Weight on each planet (mass = {mass}):");
            foreach (Planet planet in Enum.GetValues<Planet>())
            {
                Console.WriteLine($"{planet}: {planet.SurfaceWeight(mass)}");
            }
        }
    }
}</code>

This updated example demonstrates how to use custom properties to store planet data, and how to use extension methods to implement the SurfaceGravity() and SurfaceWeight() functions, providing the C# equivalent of the Java Planet enumeration.

The above is the detailed content of C# vs. Java Enums: What are the Key Differences and How Can I Effectively Migrate from Java to C#?. For more information, please follow other related articles on the PHP Chinese website!