C# vs. Java-Enums: Was sind die Hauptunterschiede und wie kann ich effektiv von Java auf C# migrieren?

C# vs. Java Enums: Erläuterung der Unterschiede für C#-Neulinge

Bei der Migration von Java zu C# stellen Sie möglicherweise Unterschiede in der Aufzählungsimplementierung fest. Auch wenn C#-Aufzählungen auf den ersten Blick einfacher erscheinen mögen, ist es für die effektive Nutzung ihrer Funktionen wichtig, ihre Unterschiede zu verstehen.

Unterschiede zwischen C#- und Java-Enumerationen

• Typsicherheit: Java-Enumerationen bieten eine strengere Typsicherheit, indem sie automatisch Unterklassen erstellen und Exklusivität erzwingen. C#-Enums hingegen sind Werttypen und erlauben implizite Konvertierungen, die zu Laufzeitfehlern führen können.
• Funktionseinschränkungen: Java-Aufzählungen bieten integrierte Methoden wie valueOf, name und ordinal. In C#-Aufzählungen fehlen diese Methoden, sie ermöglichen jedoch benutzerdefinierte Erweiterungsmethoden zur Erweiterung ihrer Funktionalität.
• Speicherung: Java-Aufzählungen speichern Aufzählungswerte als Objekte auf dem Heap. C#-Aufzählungen speichern Werte als Ganzzahlen auf dem Stapel und ermöglichen so einen schnelleren Zugriff und einen geringeren Speicherbedarf.
• Eigenschaften: Java-Aufzählungen können zugehörige Daten in EnumConstants gespeichert haben, aber sie sind statisch und unveränderlich. C#-Enumerationen unterstützen benutzerdefinierte Eigenschaften, sodass Sie zusätzliche Informationen dynamisch hinzufügen können.

Unterschiede überwinden

Um die Lücke zwischen Java- und C#-Aufzählungen zu schließen, beachten Sie Folgendes:

• Verwendung von Erweiterungsmethoden: Mit C#-Enumerationen können Sie Erweiterungsmethoden definieren, die die Funktionalität von Java-Enumerationsmethoden replizieren. Dies bietet eine bequeme Möglichkeit, auf allgemeine Vorgänge zuzugreifen, ohne die Kernaufzählungsdefinition zu ändern.
• Benutzerdefinierte Eigenschaften nutzen: C# ermöglicht Ihnen die Definition benutzerdefinierter Eigenschaften, die verwendet werden können, um zusätzliche Daten mit Aufzählungswerten zu verknüpfen. Dieser Ansatz bietet eine flexible Möglichkeit, erweiterte Eigenschaften in Aufzählungen zu speichern und darauf zuzugreifen.

Äquivalente Implementierung des Planetenbeispiels in C#

Um die Funktionalität der Planet-Enumeration in Java zu emulieren, können Sie benutzerdefinierte Eigenschaften und Erweiterungsmethoden wie folgt in C# implementieren:

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

Dieses aktualisierte Beispiel zeigt, wie benutzerdefinierte Eigenschaften zum Speichern von Planetendaten verwendet werden und wie Erweiterungsmethoden zum Implementieren der Funktionen SurfaceGravity() und SurfaceWeight() verwendet werden, wodurch das C#-Äquivalent der Java Planet-Enumeration bereitgestellt wird.

Das obige ist der detaillierte Inhalt vonC# vs. Java-Enums: Was sind die Hauptunterschiede und wie kann ich effektiv von Java auf C# migrieren?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!