web-dev-qa-db-ja.com

サブクラスのフィールドまたはプロパティをオーバーライドする

抽象基本クラスがあり、この親クラスを継承する各クラスで異なる値を持つフィールドまたはプロパティを宣言したい。

ベースクラスで定義したいので、ベースクラスのメソッドで参照できます。たとえば、ToStringをオーバーライドして「このオブジェクトは プロパティ/フィールド「私はこれを行うための3つの方法を知っていますが、私は疑問に思っていました-これを行うための最良の方法または受け入れられている方法は何ですか？初心者の質問、ごめんなさい。

オプション1：
抽象プロパティを使用し、継承されたクラスでオーバーライドします。これは、強制されることでメリットがあり（オーバーライドする必要があります）、クリーンです。しかし、フィールドをカプセル化するのではなくハードコード値を返すのは少し間違っていると感じており、単なるコードではなく数行のコードです。また、「セット」のボディを宣言する必要がありますが、それはそれほど重要ではありません（おそらく、私が知らないことを避ける方法があります）。

abstract class Father
{
    abstract public int MyInt { get; set;}
}

class Son : Father
{
    public override int MyInt
    {
        get { return 1; }
        set { }
    }
}

オプション2
パブリックフィールド（または保護フィールド）を宣言し、継承クラスで明示的にオーバーライドできます。以下の例では、「新しい」を使用するように警告が表示され、おそらくそれを行うことができますが、間違っていると感じ、多態性を壊します。良い考えではないようです...

abstract class Mother
{
    public int MyInt = 0;
}

class Daughter : Mother
{
    public int MyInt = 1;
}

オプション
保護フィールドを使用して、コンストラクターで値を設定できます。これはかなりきれいに見えますが、コンストラクタが常にこれを設定し、オーバーロードされた複数のコンストラクタを使用すると、コードパスが値を設定しない可能性が常にあります。

abstract class Aunt
{
    protected int MyInt;
}

class Niece : Aunt
{
    public Niece()
    {
        MyInt = 1;
    }
}

それは少し理論的な質問であり、それは唯一の選択肢なので、答えはオプション1でなければなりません 安全 オプションですが、私はちょうどC＃を理解しているので、これをもっと経験のある人に聞いてみたいと思いました。

c#propertiesfield
134
Frans

3つのソリューションのうち、オプション1はポリモーフィックです。

フィールド自体はオーバーライドできません。 オプション2がnewキーワード警告を返す理由はまさにこれです。

警告の解決策は、「新しい」キーワードを追加するのではなく、オプション1を実装することです。

フィールドをポリモーフィックにする必要がある場合は、プロパティでラップする必要があります。

オプションは、ポリモーフィックな動作が必要ない場合は問題ありません。ただし、実行時にプロパティMyIntにアクセスすると、派生クラスは返される値を制御できないことに注意してください。基本クラス自体は、この値を返すことができます。

これは、プロパティの真にポリモーフィックな実装がどのように見えるかであり、派生クラスをcontrolに入れることができます。

abstract class Parent
{
    abstract public int MyInt { get; }
}

class Father : Parent
{
    public override int MyInt
    {
        get { /* Apply formula "X" and return a value */ }
    }
}

class Mother : Parent
{
    public override int MyInt
    {
        get { /* Apply formula "Y" and return a value */ }
    }
}
128
Preets

オプション2はスターターではありません-オーバーライドフィールドはできません。hideフィールドのみです。

個人的には、毎回オプション1に行きます。フィールドは常に非公開にしようとしています。もちろん、本当にプロパティをオーバーライドする必要がある場合です。もう1つのオプションは、コンストラクターパラメーターから設定される基本クラスに読み取り専用プロパティを設定することです。

abstract class Mother
{
    private readonly int myInt;
    public int MyInt { get { return myInt; } }

    protected Mother(int myInt)
    {
        this.myInt = myInt;
    }
}

class Daughter : Mother
{
    public Daughter() : base(1)
    {
    }
}

インスタンスの存続期間にわたって値が変化しない場合、これがおそらく最も適切なアプローチです。

18
Jon Skeet

オプション2は悪い考えです。その結果、シャドウイングと呼ばれるものが生じます。基本的に、2つの異なる「MyInt」メンバーがあります。1つは母親に、もう1つは娘にいます。これに関する問題は、母親に実装されているメソッドが母親の「MyInt」を参照し、娘に実装されているメソッドが娘の「MyInt」を参照することです。これは深刻な読みやすさの問題を引き起こし、後で混乱を招く可能性があります。

個人的には、最良の選択肢は3だと思います。明確な中央集中型の値を提供し、独自のフィールドを定義する手間をかけずに子によって内部的に参照できるためです。これはオプション1の問題です。

7
Charlie Lavers

次のようなものを定義できます。

abstract class Father
{
    //Do you need it public?
    protected readonly int MyInt;
}

class Son : Father
{
    public Son()
    {
        MyInt = 1;
    }
}

値を読み取り専用に設定することにより、オブジェクトの存続期間中、そのクラスの値が変更されないようにします。

次の質問は、なぜ必要なのでしょうか？

4
Ant

あなたはこれを行うことができます

class x
{
    private int _myInt;
    public virtual int myInt { get { return _myInt; } set { _myInt = value; } }
}

class y : x
{
    private int _myYInt;
    public override int myInt { get { return _myYInt; } set { _myYInt = value; } }
}

virtualを使用すると、何かを行う本体のプロパティを取得でき、サブクラスでそれをオーバーライドできます。

4
Joshua G

クラスを構築していて、プロパティのベース値が必要な場合は、ベースクラスでvirtualキーワードを使用します。これにより、オプションでプロパティをオーバーライドできます。

上記の例を使用します。

//you may want to also use interfaces.
interface IFather
{
    int MyInt { get; set; }
}


public class Father : IFather
{
    //defaulting the value of this property to 1
    private int myInt = 1;

    public virtual int MyInt
    {
        get { return myInt; }
        set { myInt = value; }
    }
}

public class Son : Father
{
    public override int MyInt
    {
        get {

            //demonstrating that you can access base.properties
            //this will return 1 from the base class
            int baseInt = base.MyInt;

            //add 1 and return new value
            return baseInt + 1;
        }
        set
        {
            //sets the value of the property
            base.MyInt = value;
        }
    }
}

プログラム内：

Son son = new Son();
//son.MyInt will equal 2
1
Keith Aymar

オプション3を使用しますが、サブクラスに強制的に実装される抽象setMyIntメソッドがあります。このように、派生クラスがコンストラクターで設定するのを忘れるという問題はありません。

abstract class Base 
{
 protected int myInt;
 protected abstract void setMyInt();
}

class Derived : Base 
{
 override protected void setMyInt()
 {
   myInt = 3;
 }
}

ところで、オプション1では、setを指定しない場合、抽象基本クラスプロパティでは、派生クラスで実装する必要はありません。

abstract class Father
{
    abstract public int MyInt { get; }
}

class Son : Father
{
    public override int MyInt
    {
        get { return 1; }
    }
}
0
Winston Smith

コンストラクターでプロパティ値を要求するように抽象基本クラスを変更する場合、オプション3を使用できます。パスを見逃すことはありません。私は本当にこのオプションを検討したいと思います。

abstract class Aunt
{
    protected int MyInt;
    protected Aunt(int myInt)
    {
        MyInt = myInt;
    }

}

もちろん、フィールドをプライベートにし、必要に応じて、保護されたプロパティゲッターまたはパブリックプロパティゲッターを公開するオプションもあります。

0
Blair Conrad

これは私がしました...

namespace Core.Text.Menus
{
    public abstract class AbstractBaseClass
    {
        public string SELECT_MODEL;
        public string BROWSE_RECORDS;
        public string SETUP;
    }
}

namespace Core.Text.Menus
{
    public class English : AbstractBaseClass
    {
        public English()
        {
            base.SELECT_MODEL = "Select Model";
            base.BROWSE_RECORDS = "Browse Measurements";
            base.SETUP = "Setup Instrument";
        }
    }
}

このようにして、フィールドを引き続き使用できます。

0
8r13n

実装で抽象クラスを使用する場合の実装例。サブクラスは：

  1. 抽象クラスの実装をパラメーター化します。
  2. 抽象クラスの実装を完全に継承します。
  3. 独自の実装が必要です。

この場合、実装に必要なプロパティは、抽象クラスと独自のサブクラスを除き、使用できないようにする必要があります。

    internal abstract class AbstractClass
    {
        //Properties for parameterization from concrete class
        protected abstract string Param1 { get; }
        protected abstract string Param2 { get; }

        //Internal fields need for manage state of object
        private string var1;
        private string var2;

        internal AbstractClass(string _var1, string _var2)
        {
            this.var1 = _var1;
            this.var2 = _var2;
        }

        internal void CalcResult()
        {
            //The result calculation uses Param1, Param2, var1, var2;
        }
    }

    internal class ConcreteClassFirst : AbstractClass
    {
        private string param1;
        private string param2;
        protected override string Param1 { get { return param1; } }
        protected override string Param2 { get { return param2; } }

        public ConcreteClassFirst(string _var1, string _var2) : base(_var1, _var2) { }

        internal void CalcParams()
        {
            //The calculation param1 and param2
        }
    }

    internal class ConcreteClassSecond : AbstractClass
    {
        private string param1;
        private string param2;

        protected override string Param1 { get { return param1; } }

        protected override string Param2 { get { return param2; } }

        public ConcreteClassSecond(string _var1, string _var2) : base(_var1, _var2) { }

        internal void CalcParams()
        {
            //The calculation param1 and param2
        }
    }

    static void Main(string[] args)
    {
        string var1_1 = "val1_1";
        string var1_2 = "val1_2";

        ConcreteClassFirst concreteClassFirst = new ConcreteClassFirst(var1_1, var1_2);
        concreteClassFirst.CalcParams();
        concreteClassFirst.CalcResult();

        string var2_1 = "val2_1";
        string var2_2 = "val2_2";

        ConcreteClassSecond concreteClassSecond = new ConcreteClassSecond(var2_1, var2_2);
        concreteClassSecond.CalcParams();
        concreteClassSecond.CalcResult();

        //Param1 and Param2 are not visible in main method
    }
0
Belomestnykh Sergey