コンストラクタによるメソッドの有効化について

Question

前提・実現したいこと

一つのクラスでいくつかのそれぞれ違う引数をとるコンストラクタを作成し、
それに対応するメソッドを呼び出せるようにしたいのですがどのようにすればよいかわかりません。
それ以前に、これが実現可能かどうかもわかりませんので回答のほどよろしくお願いいたします。

具体的な内容

__//　修正__
public class A
{
   private int ListSize = 5;
   private List<string> StrList;
   private List<float> FloatList;
   public A(){
　　　初期化内容;
   }

   public A(string str){
　　　// リストの中身をListSize分作成する
　　　for(var i=0;i<ListSize;i++) StrList.add("");
   }

   public A(float value){
　　　// リストの中身をListSize分作成する
　　　for(var i=0;i<ListSize;i++) FloatList.add(0);
   }

   public Method(){
    A()の初期化内容を使った処理;
   }

   public Method(string str){
   　// 実行毎に、最新から5つのstrを保持するStrListを作成する
　　　
   }

   public Method(float value){
    // 実行毎に、最新から5つのvalueを保持するFloatListを作成する
   }
}

具体的な内容としては、現在同じ処理をそれぞれ型の違う(Vector3/Quaternion/float)数値へかけています。
そこで処理を共通化したいのですが、処理を掛ける型分クラスを作成するのはどうかと思い上記のようなクラスを考えました。
しかし、上記の例だとA(string str)でインスタンス化し、Method(string str)のメソッドが使えれば問題はないのですが引数を間違ってMethod(float value)を実行してしまうことがあると思います。
自分だけでやっている場合にはこれでもいいかもしれませんが、多人数でこのクラスを使用する場合は問題になります。
そこで使用したコンストラクタによりメソッドが有効化されるようなことはできないのか、そもそもクラスを分けるべきなのかと思い質問させていただきました。
よろしくお願いいたします。

※追記
使用想定としては、unityでupdate()が呼ばれる毎に最新の値をListSize分常に持ちたいと考えています。

Comments

[BluOxy]

Aクラスのコンストラクタがどのように初期化していて、Methodがどのように処理しているかがもし書けるのであれば、より正確な回答ができます。
例えば、Automatic9045さんが回答したようにジェネリッククラスを使うことも可能かもしれないし、不可能かもしれません。

Answer 1

ジェネリッククラス（ClassName<T>）を使ってみてはいかがでしょう？
インスタンス化する際に型を指定出来ます。

public class MyClass<T>
{
    public MyClass(T arg)
    {
        ...
    }
    
    public void MyMethod(T arg)
    {
        ...
    }
}

class MainClass
{
    static void Main(string[] args)
    {
        MyClass<string> a = new MyClass<string>("hoge");
        a.MyMethod("aaa");
    }
}

##追記を受けて
ジェネリッククラスを用いれば、コンストラクタの引数は不要になります。
型パラメータTの型はtypeof(T)で取得出来るので、初期化処理は以下のように書けます。

// Linqを用いると、繰り返し系の処理をfor無しで可読性高く書けます。
// また、C#では変数名はローワーキャメルが原則なのでご注意を。

public A()
{
    switch (typeof(T))
    {
        case typeof(string):
            strList = new List<string>(Enumerable.Repeat(string.Empty, listSize));
            break;
        ...
    }
}

Comments

[suzuki0707]

回答ありがとうございます
ジェネリッククラス自体を知らなかった為、大変参考になりました。

[Automatic9045]

ジェネリッククラスは、標準で提供されているものだとList<T>やCollection<T>、Dictionary<T>などに使われているので、良ければ調べてみて下さいね。

Answer 2

A(string str)でインスタンス化し、Method(string str)のメソッドが使えれば問題はないのですが引数を間違ってMethod(float value)を実行してしまうことがあると思います。

このクラスの設計者はXMLコメントを追加してください。
このクラスの利用者はそれを読んで意図した引数をインスタンス作成時に渡してください。

VisualStudioを使っていれば、コンストラクタ呼び出しの記述にカーソルを合わせる事でXMLコメントの内容や渡している引数を見る事が出来ます。

利用者に、ドキュメントを読んで使うという意識があれば間違うことはありません。
その意識がなければ、そもそもプログラマとしてどうかを疑います。

Convertクラスを見てください。ToByteメソッド、ToBooleanメソッドなどはオーバーロードを多く行っていますが、ドキュメントを読めば引数を渡し間違うことはありません。

よって、余程疲れていない限りプログラマなら間違って使うことは無いはずなので、問題にはなりません。

suzuki0707さんがドキュメントを書き、利用者がそれを読んでも誤解をするような複雑な作りである場合はクラスを分けるなどの手段を検討すれば良いと思います。

使用したコンストラクタによりメソッドが有効化されるようなことはできないのか

言語仕様にないので出来ません。その必要がないと判断されているからです。

---

ジェネリックで型を指定できる最新の要素のみを保持する固定長のコレクションを用意すれば実現できませんか？

試しに作りました。

public class FixedLengthList<T> : IList<T>
{
    private readonly List<T> _list;
    private readonly int _size;
    public FixedLengthList(int size)
    {
        _list = new T[size].ToList();
        this._size = size;
    }

    public T this[int index]
    {
        get => _list[index];
        set => _list[index] = value;
    }

    public int Count => _list.Count;

    public bool IsReadOnly => ((IList<T>)_list).IsReadOnly;

    public void Add(T element)
    {
        if (_list.Count() >= _size)
        {
            _list.RemoveAt(0);
        }
        _list.Add(element);
    }

    public void Clear()
    {
        _list.Clear();
    }

    public bool Contains(T item)
    {
        return _list.Contains(item);
    }

    public void CopyTo(T[] array, int arrayIndex)
    {
        _list.CopyTo(array, arrayIndex);
    }

    public IEnumerator<T> GetEnumerator()
    {
        return ((IList<T>)_list).GetEnumerator();
    }

    public int IndexOf(T item)
    {
        return _list.IndexOf(item);
    }

    public void Insert(int index, T item)
    {
        _list.Insert(index, item);
    }

    public bool Remove(T item)
    {
        return _list.Remove(item);
    }

    public void RemoveAt(int index)
    {
        _list.RemoveAt(index);
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return ((IList<T>)_list).GetEnumerator();
    }
}

現在同じ処理をそれぞれ型の違う(Vector3/Quaternion/float)数値へかけています。

そこで処理を共通化したい

public class A
{
   private const int ListSize = 5;
   private FixedLengthList<Vetctor3> _vectors = new FixedLengthList<Vetctor3>(ListSize);
   private FixedLengthList<Quaternion> _quaternions = new FixedLengthList<Quaternion>(ListSize);
   private FixedLengthList<float> _floatValues = new FixedLengthList<float>(ListSize);

   public void Method(){
       //TODO: _vectors,_quaternions,_floatValues を参照して何かを処理する;
   }

   public AddVector3(Vector3 v){
       _vectors.Add(v);
   }

   public AddQuaternion(Quaternion q){
       _quaternions.Add(q);
   }
}

Comments

[suzuki0707]

回答ありがとうございました

[BluOxy]

> unityでupdate()が呼ばれる毎に最新の値をListSize分常に持ちたい
やりたいのは（最新の要素を保持する）固定長のリストのように思います。
であれば1つのクラスに複数の型を持つのはやめ、型毎にその固定長のリストを用意すれば良いと思います。

[suzuki0707]

再度、回答ありがとうございました。
作成例も初学者の自分自分としては知らないものもあり大変勉強になりました。

Answer 3

間違った引数のMethod()を呼ばれたら例外でも投げておけばどうでしょう．

容赦なくNullReferenceExceptionが飛ぶ：

class A
{
    public A(){ m_method = this.Method_;    }
    public A( string str ){ m_method_s = this.Method_s; }
    public A( float value ){    m_method_f = this.Method_f; }

    public void Method(){   m_method(); }
    public void Method( string str ){   m_method_s(str);    }
    public void Method( float value ){  m_method_f(value);  }

    private readonly Action m_method = null;
    private readonly Action<string> m_method_s = null;
    private readonly Action<float> m_method_f = null;

    private void Method_(){ Console.WriteLine( "Method()" );    }
    private void Method_s( string str ){    Console.WriteLine( str );   }
    private void Method_f( float value ){   Console.WriteLine( value ); }
}

Answer 4

ジェネリッククラスで解決できるのであればそちらを使うべきでしょうし、「間違って○○してしまう」と考えだすと何も出来なくなってしまいます。
もしどうしてもというのであれば下記のように自分でフラグを設けるなどすればいいのではないですか？

class A
{
    private int mytype;

    public A()
    {
        mytype = 0;
        // 初期化A
    }
    public A(string value)
    {
        mytype = 1;
        // 初期化B
    }
    public A(float value)
    {
        mytype = 2;
        // 初期化C
    }

    public void Method()
    {
        if(mytype != 0)
        {
            throw new ArgumentException("型が違います");
        }
        // 処理A
    }

    public void Method(string value)
    {
        if (mytype != 1)
        {
            throw new ArgumentException("型が違います");
        }
        // 処理B
    }

    public void Method(float value)
    {
        if (mytype != 2)
        {
            throw new ArgumentException("型が違います");
        }
        // 処理C
    }
}

Comments

[suzuki0707]

回答ありがとうございます。
フラグ管理を考えさせていただきたと思います

[YAmaGNZ]

追記された内容を見るとジェネリッククラスで大丈夫のように思えます。