ジェネリックなプロパティの実装を非ジェネリックなインターフェースで強制させることができるか

Question

質問に至るバックグラウンド

自身のUnityプロジェクトにおけるFSMで以下のImtStateMachineを採用しています．
https://github.com/Sinoa/ImtStateMachine/blob/develop/Packages/ImtStateMachine/Runtime/StateMachine.cs
実装を進める上で，

「ステートマシンを実装しているクラスをまとめて扱いたい」

という要件がでてきました．
単純に考えると，基底クラス/インターフェースを使えばいいとおもいましたがどうやっても実現できませんでした．

該当のソースコード

ImtStateMachineはジェネリックで以下のように定義されます．

using IceMilkTea.Core;

public class SampleClass
{
    public enum EventId
    {
        event1,
        event2,
        event3,
    }
    public ImtStateMachine<SampleClass, EventId> StateMachine { get; set; }
}

私としては，EventIdとStateMachineプロパティの実装を強制し，StateMachineを適切に外部に公開したいのですが，
ImtStateMachineは派生クラスをジェネリックに指定する必要があるので基底側で定義することができません．そこで次のようにしたんですが．．．

public interface IState<TContext, TEvent>
{
    public ImtStateMachine<TContext, TEvent> StateMachine { get; set; }
}
public class SampleClass : IState<SampleClass, SampleClass.EventId>
{
    public enum EventId
    {
        event1,
        event2,
        event3,
    }
    public ImtStateMachine<SampleClass, EventId> StateMachine { get; set; }
}

確かにこれで実装を強制できたのですが，

IState state = new SampleClass();
state.StateMachine.SendEvent......

的なことができないのでこのインターフェースは利用側にはほとんど価値がありません．
（例えば，IStateを全部取得して全てのStateMachineをIdle状態にするといったことができない）
なので実際はIStateは非ジェネリックでなければならないことにここで気が付きましたが，そうなるとImtStateMachineが定義できなくなってしまいます．

以上を踏まえての質問

C#でジェネリックなプロパティを非ジェネリックなインターフェースを通して実装の強制，外部への公開は可能でしょうか？

ご回答よろしくおねがいいたします．

Comments

[blanket]

実現しようとしているのは、enumで定義した変数をinterfaceでMonoBehaviourと同じく継承する感じですか？

[leaf21341]

>enumで定義した変数をinterfaceでMonoBehaviourと同じく継承する

部分的にはそうです．
とにかく私が実現を目指したのは
IStateインターフェースを通してStateMahicne（とそのジェネリックに必要なenumクラス）を公開することです．
ImtStateMachineはImtStateMachineを使うクラスそのものの型をジェネリックに使うので，IStateをジェネリックにしても抽象化のレベルが全く変わりません．

↓こんな感じにインスタンスを取得して，StateMachineを使いたいが
>if (SampleClassObj.TryGetComponent<IState>(out var state)) ....

↓ジェネリックだと結局派生クラスを知らなければならないので抽象化ができていない
>if (SampleClassObj.TryGetComponent<IState<SampleClass,SampleClass.EventId>>(out var state)) ....

Answer 1

dynamic型を使うことで解決しました．
ただし，派生クラスからのアクセスを制限できないので命名やらコメントアウトやらドキュメントやらで使用を制限する旨をプロジェクト内で周知しなければならないです．
やや無理筋感がありますが，これ以外の方法は思いつかないので仕方がないです．

改めて問題を咀嚼すると，

1. 派生クラスに依存するプロパティを基底クラスで公開したい
2. 基底クラスはインスタンス化されるまで派生クラスの実態がわからないのでコンパイルの段階で把握するのは不可能
3. 動的に型付けするしかないのでdynamicを使う

って感じですかね．
こう考えるとdynamicの真っ当な使い方のような気がしなくもないです．

実装

// 動的な型付けで公開することを強調するためにIStatefulDynamic等の命名も検討した方がいいかもしれません．
public interface IStateful
{
    /// <summary>
    /// Do not use from outside this interface.
    /// </summary>
    /// <returns> ImtStateMachine </returns>
    dynamic DynamicStateMachine{ get; }
}

public class SampleClass : IStateful
{
    public enum EventId
    {
        event1,
        event2,
        event3,
    }
    private ImtStateMachine<SampleClass, EventId> _stateMachine;
    public ImtStateMachine<SampleClass, EventId> StateMachine => _stateMachine;
    public dynamic DynamicStateMachine => _stateMachine;
}

利用側

// 非ジェネリックなインターフェースでジェネリックなプロパティにアクセス
IStateful stateful = new SampleClass();
Console.WriteLine(stateful.DynamicStateMachine.CurrentStateName);
// Enum定義のイベントidなら一応型情報なしでSendEventもできる
stateful.DynamicStateMachine.SendEvent(0);

このようなインターフェースを提供することで，例えばデバッグにおいてプロジェクトのすべてのIStatefulを取得してそれぞれの現在のステートを表示するといった要求は当然出てくると思いますが，それを簡潔に記述できます．

【追記】
タイトルへの回答としては「dynamicで公開すれば可能」ということになりますが，
他回答者様のご指摘通り，「そもそもそんなことが必要なのか？」という点を十分に検討する必要があります．
また，実際に利用する際に派生クラスの情報を得ているわけではないので全ての操作が行えるわけではありません．

Comments

[退会済みユーザー]

CurrentStateじゃなくてCurrentStateNameでは？
あとIStateは誤解を招く気がします
全体的にUnity前提ではなくC#として書いて欲しかったかも

[leaf21341]

dameoさんコメントありがとうございます．

>CurrentStateじゃなくてCurrentStateNameでは？

これはそうでした．CurrentStateは私自身で拡張したプロパティなのでピュアなImtStateMachineには存在しないです．

>あとIStateは誤解を招く気がします

あまりしっくりくるものがなくて適当に決めました．今考えたらIStatefulとかの方がいいですかね．

>全体的にUnity前提ではなくC#として書いて欲しかったかも

タグがC#なのでそちらの方が適切ですね．諸々修正しておきました．

[退会済みユーザー]

あとプロパティを式で定義する場合に{get;}は指定できないみたいですよ。

[退会済みユーザー]

一応他の人のためにサンプル的なコードを付けておきます。
public class Program
{
public interface IStateful
{
/// <summary>
/// Do not use from outside this interface.
/// </summary>
/// <returns> ImtStateMachine </returns>
dynamic DynamicStateMachine{ get; }
}

public class SampleClass1 : IStateful
{
public enum EventId
{
event1,
event2,
event3,
}
private class State1: ImtStateMachine<SampleClass1, EventId>.State {}
private class State2: ImtStateMachine<SampleClass1, EventId>.State {}
private ImtStateMachine<SampleClass1, EventId> _stateMachine;
public ImtStateMachine<SampleClass1, EventId> StateMachine => _stateMachine;
public dynamic DynamicStateMachine => _stateMachine;
public SampleClass1() {
_stateMachine = new ImtStateMachine<SampleClass1, EventId>(this);
_stateMachine.AddTransition<State1, State2>(EventId.event1);
_stateMachine.AddTransition<State1, State2>(EventId.event2);
_stateMachine.AddTransition<State2, State1>(EventId.event3);
_stateMachine.SetStartState<State1>();
_stateMachine.Update();
}
}

public class SampleClass2 : IStateful
{
public enum EventId
{
event1,
event2,
event3,
}
private class State1: ImtStateMachine<SampleClass2, EventId>.State {}
private class State2: ImtStateMachine<SampleClass2, EventId>.State {}
private ImtStateMachine<SampleClass2, EventId> _stateMachine;
public ImtStateMachine<SampleClass2, EventId> StateMachine => _stateMachine;
public dynamic DynamicStateMachine => _stateMachine;
public SampleClass2() {
_stateMachine = new ImtStateMachine<SampleClass2, EventId>(this);
_stateMachine.AddTransition<State1, State2>(EventId.event1);
_stateMachine.AddTransition<State1, State2>(EventId.event2);
_stateMachine.AddTransition<State2, State1>(EventId.event3);
_stateMachine.SetStartState<State1>();
_stateMachine.Update();
}
}

public static void Main(string[] args)
{
var list = new List<IStateful>(){new SampleClass1(), new SampleClass2()};
list[1].DynamicStateMachine.SendEvent((int)SampleClass2.EventId.event1);
list[1].DynamicStateMachine.Update();
foreach(var e in list) Console.WriteLine(e.DynamicStateMachine.CurrentStateName);
}
}

[leaf21341]

指摘&補足ありがとうございます．
該当箇所は修正しておきました．

Answer 2

本当にジェネリックじゃないといけないのか？という所から考えた方がいいような気がします。
共通の処理させたいだけなら、その処理だけ非ジェネリックなインターフェースにしたらどうですか？

using System;
using System.Runtime.CompilerServices;

public interface IMachine
{
    string CurrentStateName { get; }
    void SendEvent(int evt);
}

public interface IStateful
{
    IMachine StateMachine { get; }
}

public class ImtStateMachine<TEvent> : IMachine where TEvent : Enum
{
    public void SendEvent(TEvent evt) => Console.WriteLine($"SendEvent:{evt}");
    public void SendEvent(int evt) => SendEvent(Unsafe.As<int, TEvent>(ref evt)); //Enumのベースがintである前提
    public string CurrentStateName => "hogeStatus";
}

public class SampleClass : IStateful
{
    public enum EventId
    {
        event1,
        event2,
        event3,
    }
    private ImtStateMachine<EventId> _stateMachine = new ImtStateMachine<EventId>();
    public IMachine StateMachine => _stateMachine;
}

public class Program
{
    public static void Main(string[] args)
    {
        var stateful = new SampleClass();
        var machine = stateful.StateMachine;
        Console.WriteLine(machine.CurrentStateName);
        machine.SendEvent(0);
    }
}

Comments

[leaf21341]

回答ありがとうございます．

>本当にジェネリックじゃないといけないのか？という所から考えた方がいいような気がします。
共通の処理させたいだけなら、その処理だけ非ジェネリックなインターフェースにしたらどうですか？

これはその通りだと思いました．
そこで色々要件を調査したところ，結果としてdynamicなステートマシンも型に依存しない処理も両方ともインターフェースに定義しました．
（ちなみに，dynamicなステートマシンは主にデバッグ機能の実装に必要でした．
デバッガーに公開するだけの目的でIStatefulにあれこれと定義するとIStatefulを実装するクラスが本番環境では無関係なコードで溢れかえってしまうため，ステートマシン自体を公開するのが一番スッキリします．）

public interface IStateful
{
/// <summary>
/// Do not use from outside this interface
/// </summary>
/// <returns> ImtStateMachine </returns>
dynamic StateMachineDynamic { get; }
public void SendIdle();
public void SendExit();
public bool IsExit { get; }
public bool IsIdle { get; }
}

Answer 3

素人なので話自体が良くわかっていない気もするのですが…

ImtStateMachine<TContext, TEvent> というのを利用側で直接（そのままこの型で）扱わねばならないのでしょうか？
なんとなく，

• 利用側は各ステートマシンの TContext が具体的に何なのかを知りたくないし，知りようもない．というか，TContext とかいう何かが存在すること自体を意識したくないのでは．
• 複数のステートマシンで共通の TEvent を用いるのであれば，それらは個々のステートマシンが定義するものではなく，もっと広範な範囲で共用する存在なのでは．

とか思うのですが．

要は，ImtStateMachine<TContext, TEvent> なるものを使っているのは個々の型の内部実装の話なのであって，それを外側にダイレクトに公開しなければ良いのではないか？　と．
各型を まとめて/同じように 操作するための全く別のインタフェースを定義するのではダメなのでしょうか？

//全てのステートマシンが共通で用いる（必ずサポートする）イベント
enum CommonEventID{ ... };

//インタフェース
//ここには TContext は出てこないし，
//CommonEventID を扱う処理だけがあればよいハズ．（どのみち個々のステートマシン固有のイベントに関する処理を共通インタフェースを介して扱うのは無理なのだろうし）
interface ICommonStateMachine
{
  bool SendCommonEvent( CommonEventID Event );
}

Comments

[leaf21341]

回答ありがとうございます

>ImtStateMachine<TContext, TEvent> というのを利用側で直接（そのままこの型で）扱わねばならないのでしょうか？
>要は，ImtStateMachine<TContext, TEvent> なるものを使っているのは個々の型の内部実装の話なのであって，それを外側にダイレクトに公開しなければ良いのではないか？

上の回答者様とおよそ似た話だと思いますが，やはりdynamicなステートマシンも主にデバッグ機能を実装する上で必要でした．なのでdynamicなステーマシンも定義しつつ，型情報が必要ない汎用的な処理も提供するようにしました．
↓
public interface IStateful
{
/// <summary>
/// Do not use from outside this interface
/// </summary>
/// <returns> ImtStateMachine </returns>
dynamic StateMachineDynamic { get; }
public void SendIdle();
public void SendExit();
public bool IsExit { get; }
public bool IsIdle { get; }
}