Vererbung mit mehrfach eingeschränktem TypParamater

[Der schöne Günther]

Noch ohne auf die PDF geschaut zu haben: Das where in C# ist bei den Typeinschränkungen doch auch nichts anderes als der Doppelpunkt in Delphi. Und statt new() heißt es constructor .

Code:

public void meineMethode<T>(T meinParameter) where T: ISomeBaseInterface, ISomeOtherInterface

bedeutet in C# doch genauso, dass T beide Interfaces implementieren muss.

PS: Punkte und Vekoren. Ich wusste es

PPS: Warum überhaupt der Unterschied zwischen Punkten und Vektoren? Transformation wie bspw. Translation wird ja sowieso eigentlich doch über einen Vektor in homogenisierter Form mit einer Transformationsmatrix erledigt. Darüber lassen sich alle möglichen Operationen abwickeln.
Aber das führt jetzt nur vom eigentlichen Thema weg... (oder?)

PPPS: Warum möchtest du an der Stelle wissen, ob es nun ein IPoint oder IVector ist? Die richtige Typeinschränkung an diesen Fall wäre übrigens, anders als auf der PDF, IBase und nicht IPoint UND IVector.
Wenn du jetzt zur Laufzeit unbedingt wissen willst ob es nun ein IPoint oder IVector ist kannst du das mit Supports(..) überprüfen.

Delphi-Quellcode:

program Project3;

{$APPTYPE CONSOLE}

{$R *.res}

uses
  System.SysUtils;

type
   IBaseInterface = interface
      //
   end;

   IChildInterface1 = interface(IBaseInterface)
   ['{65F8AA65-0EED-4D26-A396-26999CD9E316}']
      //
   end;

   IChildInterface2 = interface(IBaseInterface)
   ['{8F390B34-CCF6-4908-B205-D4CD9CF5D3BE}']
      //
   end;

   TIChildClass1 = class(TInterfacedObject, IBaseInterface, IChildInterface1)
      // Es müssen IBaseInterface UND IChildInterface1 angegeben werden.
      // Ja, IBaseInterface ist eigentlich obsolet, aber so ist Delphi halt
      // Stört mich ehrlich gesagt auch
   end;

   TIChildClass2 = class(TInterfacedObject, IBaseInterface, IChildInterface2)
      //
   end;

   TSomeRecord = record
      public class procedure someMethod<T: IBaseInterface>(const someInput: T); static;

   end;

{ TSomeRecord }

class procedure TSomeRecord.someMethod<T>(const someInput: T);
begin
   if Supports(someInput, IChildInterface1) then
      WriteLn('Es ist ein IChildInterface1')
   else if Supports(someInput, IChildInterface2) then
      WriteLn('Es ist ein IChildInterface2')
   ;

end;

begin
  try
   TSomeRecord.someMethod( TIChildClass2.Create() );
  except
    on E: Exception do
     Writeln(E.ClassName, ': ', E.Message);
  end;

  ReadLn;
end.

PPPPS: Generics und im Nachhinein wieder aufdröseln um im Detail nochmal zu schauen was drinsteckt führt Generics ad absurdum. So meine Meinung ohne gründlich drüber nachgedacht zu haben.