Énumérations C# et Java : quelles sont les principales différences et comment puis-je migrer efficacement de Java vers C# ?

Énumérations C# vs Java : clarifier les différences pour les nouveaux arrivants en C#

Lors de la migration de Java vers C#, vous remarquerez peut-être des différences dans l'implémentation de l'énumération. Même si les énumérations C# peuvent paraître plus simples à première vue, il est essentiel de comprendre leurs différences pour utiliser efficacement leurs capacités.

Différences entre les énumérations C# et Java

• Sécurité des types : Les énumérations Java offrent une sécurité de type plus stricte en créant automatiquement des sous-classes et en appliquant l'exclusivité. Les énumérations C#, en revanche, sont des types valeur et permettent des conversions implicites, ce qui peut entraîner des erreurs d'exécution.
• Limitations des fonctions : Les énumérations Java fournissent des méthodes intégrées telles que valueOf, name et ordinal. Les énumérations C# ne disposent pas de ces méthodes mais permettent aux méthodes d'extension personnalisées d'améliorer leurs fonctionnalités.
• Stockage : Les énumérations Java stockent les valeurs d'énumération sous forme d'objets sur le tas. Les énumérations C# stockent les valeurs sous forme d'entiers sur la pile, offrant un accès plus rapide et une empreinte mémoire réduite.
• Propriétés : Les énumérations Java peuvent avoir des données associées stockées dans EnumConstants, mais elles sont statiques et immuables. Les énumérations C# prennent en charge les propriétés personnalisées, vous permettant d'ajouter des informations supplémentaires de manière dynamique.

Surmonter les différences

Pour combler le fossé entre les énumérations Java et C#, considérez ce qui suit :

• Utilisation des méthodes d'extension : Les énumérations C# vous permettent de définir des méthodes d'extension qui reproduisent les fonctionnalités des méthodes d'énumération Java. Cela constitue un moyen pratique d’accéder aux opérations courantes sans modifier la définition de l’énumération principale.
• Exploiter les propriétés personnalisées : C# vous permet de définir des propriétés personnalisées qui peuvent être utilisées pour associer des données supplémentaires à des valeurs d'énumération. Cette approche offre un moyen flexible de stocker et d’accéder aux propriétés étendues des énumérations.

Implémentation équivalente de l'exemple de planète en C#

Pour émuler la fonctionnalité de l'énumération Planet en Java, vous pouvez implémenter des propriétés personnalisées et des méthodes d'extension en C# comme suit :

<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>

Cet exemple mis à jour montre comment utiliser des propriétés personnalisées pour stocker des données planétaires et comment utiliser des méthodes d'extension pour implémenter les fonctions SurfaceGravity() et SurfaceWeight(), fournissant l'équivalent C# de l'énumération Java Planet.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!