8

質問のタイトルが紛らわしくて申し訳ありませんが、質問の仕方がわかりません。本当に必要なのは、決して変更されない読み取り専用データを持つことです。

現在、私は2つの列挙型MeterTypeを持っていますSubMeterType

public enum MeterType
{
  Water = 1001,
  Electricity = 1004,
  Gas = 1007
}

と

public enum SubMeterType
{
  DrinkingWater = 1002,
  UsageWater = 1003,
  SubsidiseGas = 1008,
  NonSusbsidisedGas = 1009
}

今、私はこれらを次のように使用したいと思います

MeterType を取得するには

string meterType = MeterType.Water.ToString("d");

SubMeterTypeを取得するには、次のようなものを使用できますか

string subMeterType = MeterType.Water.DrinkingWater("d");

読み取り専用プロパティを持つクラスを使用する別のアプローチに行きますか? または、要件に合わせてこれらの列挙型を変更します。

4

3 に答える 3

9

列挙型を使用する代わりに、ネストされたクラスで定数整数を使用できます。

public static class MeterType
{
    public const int Water = 1001;
    public const int Electricity = 1004;
    public const int Gas = 1007;

    public static class Waters
    {
        public const int DrinkingWater = 1002;
        public const int UsageWater = 1003;
    }

    public static class Gases
    {
        public const int SubsidiseGas = 1008;
        public const int NonSusbsidisedGas = 1009;
    }
}
于 2013-09-20T07:23:03.443 に答える
3

sをネストすることはできませんenumが、すでにそれはわかっています。できることは、必要なさまざまなタイプにマップするプロパティ/フィールドを持つconstことreadonlyです。次に、各タイプで、サブタイプのフィールド/プロパティを定義します。

public static class MeterTypes
{
    public static readonly Electricity electricity;
    public static readonly Gas gas;
    public static readonly Water water;

    static MeterTypes()
    {
        // initialize the meter types to their default
        MeterTypes.Water = Water.GenericWater;
        MeterTypes.Gas = Gas.GenericGas;
        MeterTypes.Electricity = Electricity.GenericElectricity;
    }

    private MeterTypes()
    {
        // private initialization prevents others from creating the class            
    }

    public class Electricity
    {
        public enum Type
        {
            Generic = 1007,
            SubsidisedElectricity = 1008,
            NonSubsidisedElectricity = 1009
        }

        public static readonly Electricity GenericElectricity;
        public static readonly Electricity SubsidisedElectricity;
        public static readonly Electricity NonSubsidisedElectricity;
        private Type ElectricityType;

        static Electricity()
        {
            SubsidisedElectricity = new Electricity(Type.SubsidisedElectricity);
            NonSubsidisedElectricity = new Electricity(Type.NonSubsidisedElectricity);
            GenericElectricity = new Electricity(Type.Generic);
        }

        // private constructor prevents creation from outside the class
        private Electricity(Type ElectricityType)
        {
            this.ElectricityType = ElectricityType;
        }

        public override string ToString()
        {
            return ElectricityType.ToString();
        }

        public string ToString(string format)
        {
            return ElectricityType.ToString(format);
        }
    }

    public class Gas
    {
        public enum Type
        {
            Generic = 1007,
            SubsidisedGas = 1008,
            NonSubsidisedGas = 1009
        }

        public static readonly Gas GenericGas;
        public static readonly Gas SubsidisedGas;
        public static readonly Gas NonSubsidisedGas;
        private Type gasType;

        static Gas()
        {
            SubsidisedGas = new Gas(Type.SubsidisedGas);
            NonSubsidisedGas = new Gas(Type.NonSubsidisedGas);
            GenericGas = new Gas(Type.Generic);
        }

        // private constructor prevents creation from outside the class
        private Gas(Type gasType)
        {
            this.gasType = gasType;
        }

        public override string ToString()
        {
            return gasType.ToString();
        }

        public string ToString(string format)
        {
            return gasType.ToString(format);
        }
    }

    public class Water
    {
        public enum Type
        {
            Generic = 1001,
            DrinkingWater = 1002,
            UsageWater = 1003
        }

        public static readonly Water GenericWater;
        public static readonly Water DrinkingWater;
        public static readonly Water UsageWater;
        private Type waterType;

        static Water()
        {
            DrinkingWater = new Water(Type.DrinkingWater);
            UsageWater = new Water(Type.UsageWater);
            GenericWater = new Water(Type.Generic);
        }

        // private constructor prevents creation from outside the class
        private Water(Type waterType)
        {
            this.waterType = waterType;
        }

        public override string ToString()
        {
            return waterType.ToString();
        }

        public string ToString(string format)
        {
            return waterType.ToString(format);
        }
    }
}

これはそのまま使えます

var w = MeterTypes.water; // will give generic water
var uw = MeterTypes.Water.UsageWater // will give usage water

また、メソッドをさらに使用することEnum.ToString()もできます。

この実装は、C# の大文字と小文字の区別に依存していることに注意する必要があります。これにより、フィールドとクラスがそれぞれ作成MeterTypes.electricityおよび参照されます。MeterTypes.Electricityこのコードは、大文字と小文字が区別されない言語 (VB.NET など) で使用されると、失敗する可能性が非常に高くなります。クラスの静的フィールドに別の名前を使用することで、これを回避できますMeterTypes(たとえば、 の_Electricity代わりにelectricity)。

于 2013-09-20T08:43:33.560 に答える
3

ネストされた列挙型を使用するだけです：

public class MeterType
{
    public enum Water { }
}

ただし、この場合MeterType.Water、直接使用することはできません。これはデフォルトでは不可能です。次に、ネストされたオブジェクトを使用するか、MeterType.

public enum MeterType { }
public enum MeterTypeWater { }

この場合、列挙ごとに異なる名前のプロパティが必要です。最善の解決策は、ネストされたクラスを使用しないことです。

public class MeterType
{
    public static WaterType Water { get; }
}

public class WaterType
{
    public readonly SubWaterType DrinkingWater = SubWaterType.DrinkingWater;
}
于 2013-09-20T07:08:10.980 に答える