1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:

    public interface Auto<T> 
    {
        void fahren(T l);
    }

    public class Benz : Auto<Diesel>
    {
        public void fahren(Diesel l)
        {
            
        }
    }

    public class Ferarri : Auto<Benzin>
    {
        public void fahren(Benzin l)
        {

        }
    }					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:

class Program
{
  public Auto<Diesel> auto;
  
  public Program(bool test)
  {
    if (test)
    {
      auto = new Benz();   //Funktioniert
    }
    else
    {
      auto = new Ferarri(); //Funktioniert nicht, da ja Diesel als Datentyp angegeben wurde
    }
  }
  
}					

1:
2:
3:
4:
5:
6:
7:
8:

public interface IAuto
{
}

public interface IAuto<T> : IAuto // Interfaces sollten immer mit I anfangen, d.h. IAuto<T>
{
    void fahren(T l);
}					

1:

public IAuto auto;					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:

    interface IInput<T>
    {
        void UpdateState();
        void UpdatelastState();

        bool IsUp();
        bool IsDown();
        T getState();
        ..... usw.
     }					

1:
2:
3:
4:
5:
6:
7:
8:
9:

    class Input_PC : IInput<KeyboardState>
    {
      
    }

    class Input_Xbox : IInput<GamePadState>
    {

    }					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:

public class Player
{
public IInpunt<GamepadState> input {get; set;} 

        public Player(ContentManager content, SpriteBatch spriteBatch, Vector2 pos, bool pc)
        {  
            if (!pc)
            {
                 this.input = new Input_Xbox();
            }
            else
            {
                this.input = new Input_PC();
            }
        }

  //BeispielMethode
  public void Update()
  {  
      input.UpdateState();
  }
}					

1:
2:
3:
4:

interface IInput<T> where T : StateBase
{
  // ...
}					

1:
2:
3:
4:
5:

public IInput<StateBase> input {get; set;}

// in einer Methode
StateBase state = input.GetState();
state.DoSomething(); // virtuelle Methode (bzw. abstrakt in der Basisklasse)					

1:
2:
3:
4:
5:
6:

    public interface IInput1
    {
        void UpdateState();
        bool IsUp();
        //... usw.
    }					

1:
2:
3:
4:
5:

    public interface IInput2<T> where T : StateBase
    {
        T getState();
  // ... usw.
    }					

1:
2:
3:
4:

public interface Auto<TTyp> where TTyp : IBrennstoff;
{
    void fahren<T>(T l) where T : IBrennstoff;
}