インターフェイスをC＃ジェネリック型制約として使用するにはどうすればよいですか？
次の関数宣言を取得する方法はありますか？
public bool Foo<T>() where T : interface;
すなわち。ここで、Tはインターフェイスタイプです（where T : classおよびstructと同様）。
現在、私は以下のために解決しました：
public bool Foo<T>() where T : IBase;
IBaseは、すべてのカスタムインターフェイスに継承される空のインターフェイスとして定義されています...理想的ではありませんが、機能するはずです...
価値があるのは、Fooがインターフェイスタイプを必要とする場所でリフレクションを実行しているためです。通常のパラメータとして渡し、関数自体で必要なチェックを行うことができますが、これは非常に思えましたよりタイプセーフになります（すべてのチェックがコンパイル時に行われるため、パフォーマンスが少し向上すると思います）。
できる限り近い方法（ベースインターフェイスアプローチを除く）は "where T : class"で、参照型を意味します。 「任意のインターフェイス」を意味する構文はありません。
これ（ "where T : class"）は、たとえばWCFでクライアントをサービスコントラクト（インターフェイス）に制限するために使用されます。
私はこれが少し遅いことを知っていますが、興味がある人のためにランタイムチェックを使用できます。
typeof(T).IsInterface
いいえ、実際には、classとstructがclassesとstructsを意味していると考えている場合、あなたは間違っています。 classは任意の参照タイプ（たとえばインターフェースも含む）を意味し、structは任意の値タイプを意味します（たとえばstruct、enum）。
ロバートの答えをフォローアップするために、これはさらに後のことですが、静的ヘルパークラスを使用して、タイプごとに1回だけランタイムチェックを行うことができます。
public bool Foo<T>() where T : class
{
FooHelper<T>.Foo();
}
private static class FooHelper<TInterface> where TInterface : class
{
static FooHelper()
{
if (!typeof(TInterface).IsInterface)
throw // ... some exception
}
public static void Foo() { /*...*/ }
}
また、「正常に機能する」ソリューションが実際には機能しないことにも注意してください。考慮してください：
public bool Foo<T>() where T : IBase;
public interface IBase { }
public interface IActual : IBase { string S { get; } }
public class Actual : IActual { public string S { get; set; } }
これで、Fooの呼び出しを止めることはできません。
Foo<Actual>();
Actualクラスは、結局、IBase制約を満たします。
しばらくの間、私はほぼコンパイル時の制約について考えてきたので、これはコンセプトを開始する絶好の機会です。
基本的な考え方は、コンパイル時のチェックを実行できない場合、可能な限り早い時点で実行する必要があるということです。これは、基本的にはアプリケーションの起動時です。すべてのチェックに問題がなければ、アプリケーションが実行されます。チェックが失敗すると、アプリケーションはすぐに失敗します。
動作
可能な限り最良の結果は、制約が満たされない場合、プログラムがコンパイルされないことです。残念ながら、これは現在のC＃実装では不可能です。
次に最適なのは、プログラムが開始された瞬間にクラッシュすることです。
最後のオプションは、コードがヒットした瞬間にプログラムがクラッシュすることです。これは、.NETのデフォルトの動作です。 私にとって、これはまったく受け入れられません。
前提条件
制約メカニズムが必要なので、より良いものがないため...属性を使用しましょう。属性は、一般的な制約の上に存在し、条件に一致するかどうかを確認します。そうでない場合、いエラーが発生します。
これにより、コードで次のようなことができます。
public class Clas<[IsInterface] T> where T : class
（ここではwhere T:classを保持しました。実行時チェックよりもコンパイル時チェックを常に好むためです）
そのため、使用するすべてのタイプが制約に一致するかどうかをチェックするという問題が1つだけ残ります。それはどれくらい難しいのでしょうか？
分割しましょう
ジェネリック型は常にクラス（/ struct/interface）またはメソッドにあります。
制約をトリガーするには、次のいずれかを実行する必要があります。
- 型（継承、汎用制約、クラスメンバー）で型を使用する場合のコンパイル時
- メソッド本体で型を使用する場合のコンパイル時
- ランタイム。リフレクションを使用して、汎用基本クラスに基づいて何かを構築する場合。
- RTTIに基づいて何かを構築するためにリフレクションを使用する場合のランタイム。
この時点で、プログラムIMOで（4）を実行することは常に避けてください。とにかく、これらのチェックはそれをサポートしません。それは事実上停止する問題を解決することを意味するからです。
ケース1：タイプを使用する
例：
public class TestClass : SomeClass<IMyInterface> { ... }
例2：
public class TestClass
{
SomeClass<IMyInterface> myMember; // or a property, method, etc.
}
基本的に、これはすべてのタイプ、継承、メンバー、パラメータなどをスキャンすることなどを含みます。タイプがジェネリックタイプで制約がある場合、制約をチェックします。配列の場合、要素タイプを確認します。
この時点で、デフォルトで.NETがタイプ「遅延」をロードするという事実を壊すことを追加する必要があります。すべてのタイプをスキャンすることにより、.NETランタイムにすべてのタイプを強制的にロードさせます。ほとんどのプログラムでは、これは問題になりません。それでも、コードで静的イニシャライザを使用すると、このアプローチで問題が発生する可能性があります...とはいえ、とにかくこれを行うようにアドバイスすることはありません（このようなことを除いて:-)、それは与えるべきではありません多くの問題。
ケース2：メソッドで型を使用する
例：
void Test() {
new SomeClass<ISomeInterface>();
}
これを確認するには、1つのオプションしかありません。クラスを逆コンパイルし、使用されているすべてのメンバートークンを確認し、そのうちの1つがジェネリック型である場合-引数を確認します。
ケース3：リフレクション、ランタイムジェネリック構築
例：
typeof(CtorTest<>).MakeGenericType(typeof(IMyInterface))
ケース（2）と同様のトリックでこれをチェックすることは理論的には可能であると思いますが、その実装ははるかに困難です（コードパスでMakeGenericTypeが呼び出されるかどうかをチェックする必要があります）。ここでは詳しく説明しません...
ケース4：リフレクション、ランタイムRTTI
例：
Type t = Type.GetType("CtorTest`1[IMyInterface]");
これは最悪のシナリオであり、前に説明したように、一般的には悪い考えです。いずれにしても、チェックを使用してこれを把握する実用的な方法はありません。
ロットのテスト
ケース（1）および（2）をテストするプログラムを作成すると、次のような結果になります。
[AttributeUsage(AttributeTargets.GenericParameter)]
public class IsInterface : ConstraintAttribute
{
public override bool Check(Type genericType)
{
return genericType.IsInterface;
}
public override string ToString()
{
return "Generic type is not an interface";
}
}
public abstract class ConstraintAttribute : Attribute
{
public ConstraintAttribute() {}
public abstract bool Check(Type generic);
}
internal class BigEndianByteReader
{
public BigEndianByteReader(byte[] data)
{
this.data = data;
this.position = 0;
}
private byte[] data;
private int position;
public int Position
{
get { return position; }
}
public bool Eof
{
get { return position >= data.Length; }
}
public sbyte ReadSByte()
{
return (sbyte)data[position++];
}
public byte ReadByte()
{
return (byte)data[position++];
}
public int ReadInt16()
{
return ((data[position++] | (data[position++] << 8)));
}
public ushort ReadUInt16()
{
return (ushort)((data[position++] | (data[position++] << 8)));
}
public int ReadInt32()
{
return (((data[position++] | (data[position++] << 8)) | (data[position++] << 0x10)) | (data[position++] << 0x18));
}
public ulong ReadInt64()
{
return (ulong)(((data[position++] | (data[position++] << 8)) | (data[position++] << 0x10)) | (data[position++] << 0x18) |
(data[position++] << 0x20) | (data[position++] << 0x28) | (data[position++] << 0x30) | (data[position++] << 0x38));
}
public double ReadDouble()
{
var result = BitConverter.ToDouble(data, position);
position += 8;
return result;
}
public float ReadSingle()
{
var result = BitConverter.ToSingle(data, position);
position += 4;
return result;
}
}
internal class ILDecompiler
{
static ILDecompiler()
{
// Initialize our cheat tables
singleByteOpcodes = new OpCode[0x100];
multiByteOpcodes = new OpCode[0x100];
FieldInfo[] infoArray1 = typeof(OpCodes).GetFields();
for (int num1 = 0; num1 < infoArray1.Length; num1++)
{
FieldInfo info1 = infoArray1[num1];
if (info1.FieldType == typeof(OpCode))
{
OpCode code1 = (OpCode)info1.GetValue(null);
ushort num2 = (ushort)code1.Value;
if (num2 < 0x100)
{
singleByteOpcodes[(int)num2] = code1;
}
else
{
if ((num2 & 0xff00) != 0xfe00)
{
throw new Exception("Invalid opcode: " + num2.ToString());
}
multiByteOpcodes[num2 & 0xff] = code1;
}
}
}
}
private ILDecompiler() { }
private static OpCode[] singleByteOpcodes;
private static OpCode[] multiByteOpcodes;
public static IEnumerable<ILInstruction> Decompile(MethodBase mi, byte[] ildata)
{
Module module = mi.Module;
BigEndianByteReader reader = new BigEndianByteReader(ildata);
while (!reader.Eof)
{
OpCode code = OpCodes.Nop;
int offset = reader.Position;
ushort b = reader.ReadByte();
if (b != 0xfe)
{
code = singleByteOpcodes[b];
}
else
{
b = reader.ReadByte();
code = multiByteOpcodes[b];
b |= (ushort)(0xfe00);
}
object operand = null;
switch (code.OperandType)
{
case OperandType.InlineBrTarget:
operand = reader.ReadInt32() + reader.Position;
break;
case OperandType.InlineField:
if (mi is ConstructorInfo)
{
operand = module.ResolveField(reader.ReadInt32(), mi.DeclaringType.GetGenericArguments(), Type.EmptyTypes);
}
else
{
operand = module.ResolveField(reader.ReadInt32(), mi.DeclaringType.GetGenericArguments(), mi.GetGenericArguments());
}
break;
case OperandType.InlineI:
operand = reader.ReadInt32();
break;
case OperandType.InlineI8:
operand = reader.ReadInt64();
break;
case OperandType.InlineMethod:
try
{
if (mi is ConstructorInfo)
{
operand = module.ResolveMember(reader.ReadInt32(), mi.DeclaringType.GetGenericArguments(), Type.EmptyTypes);
}
else
{
operand = module.ResolveMember(reader.ReadInt32(), mi.DeclaringType.GetGenericArguments(), mi.GetGenericArguments());
}
}
catch
{
operand = null;
}
break;
case OperandType.InlineNone:
break;
case OperandType.InlineR:
operand = reader.ReadDouble();
break;
case OperandType.InlineSig:
operand = module.ResolveSignature(reader.ReadInt32());
break;
case OperandType.InlineString:
operand = module.ResolveString(reader.ReadInt32());
break;
case OperandType.InlineSwitch:
int count = reader.ReadInt32();
int[] targetOffsets = new int[count];
for (int i = 0; i < count; ++i)
{
targetOffsets[i] = reader.ReadInt32();
}
int pos = reader.Position;
for (int i = 0; i < count; ++i)
{
targetOffsets[i] += pos;
}
operand = targetOffsets;
break;
case OperandType.InlineTok:
case OperandType.InlineType:
try
{
if (mi is ConstructorInfo)
{
operand = module.ResolveMember(reader.ReadInt32(), mi.DeclaringType.GetGenericArguments(), Type.EmptyTypes);
}
else
{
operand = module.ResolveMember(reader.ReadInt32(), mi.DeclaringType.GetGenericArguments(), mi.GetGenericArguments());
}
}
catch
{
operand = null;
}
break;
case OperandType.InlineVar:
operand = reader.ReadUInt16();
break;
case OperandType.ShortInlineBrTarget:
operand = reader.ReadSByte() + reader.Position;
break;
case OperandType.ShortInlineI:
operand = reader.ReadSByte();
break;
case OperandType.ShortInlineR:
operand = reader.ReadSingle();
break;
case OperandType.ShortInlineVar:
operand = reader.ReadByte();
break;
default:
throw new Exception("Unknown instruction operand; cannot continue. Operand type: " + code.OperandType);
}
yield return new ILInstruction(offset, code, operand);
}
}
}
public class ILInstruction
{
public ILInstruction(int offset, OpCode code, object operand)
{
this.Offset = offset;
this.Code = code;
this.Operand = operand;
}
public int Offset { get; private set; }
public OpCode Code { get; private set; }
public object Operand { get; private set; }
}
public class IncorrectConstraintException : Exception
{
public IncorrectConstraintException(string msg, params object[] arg) : base(string.Format(msg, arg)) { }
}
public class ConstraintFailedException : Exception
{
public ConstraintFailedException(string msg) : base(msg) { }
public ConstraintFailedException(string msg, params object[] arg) : base(string.Format(msg, arg)) { }
}
public class NCTChecks
{
public NCTChecks(Type startpoint)
: this(startpoint.Assembly)
{ }
public NCTChecks(params Assembly[] ass)
{
foreach (var Assembly in ass)
{
assemblies.Add(Assembly);
foreach (var type in Assembly.GetTypes())
{
EnsureType(type);
}
}
while (typesToCheck.Count > 0)
{
var t = typesToCheck.Pop();
GatherTypesFrom(t);
PerformRuntimeCheck(t);
}
}
private HashSet<Assembly> assemblies = new HashSet<Assembly>();
private Stack<Type> typesToCheck = new Stack<Type>();
private HashSet<Type> typesKnown = new HashSet<Type>();
private void EnsureType(Type t)
{
// Don't check for Assembly here; we can pass f.ex. System.Lazy<Our.T<MyClass>>
if (t != null && !t.IsGenericTypeDefinition && typesKnown.Add(t))
{
typesToCheck.Push(t);
if (t.IsGenericType)
{
foreach (var par in t.GetGenericArguments())
{
EnsureType(par);
}
}
if (t.IsArray)
{
EnsureType(t.GetElementType());
}
}
}
private void PerformRuntimeCheck(Type t)
{
if (t.IsGenericType && !t.IsGenericTypeDefinition)
{
// Only check the assemblies we explicitly asked for:
if (this.assemblies.Contains(t.Assembly))
{
// Gather the generics data:
var def = t.GetGenericTypeDefinition();
var par = def.GetGenericArguments();
var args = t.GetGenericArguments();
// Perform checks:
for (int i = 0; i < args.Length; ++i)
{
foreach (var check in par[i].GetCustomAttributes(typeof(ConstraintAttribute), true).Cast<ConstraintAttribute>())
{
if (!check.Check(args[i]))
{
string error = "Runtime type check failed for type " + t.ToString() + ": " + check.ToString();
Debugger.Break();
throw new ConstraintFailedException(error);
}
}
}
}
}
}
// Phase 1: all types that are referenced in some way
private void GatherTypesFrom(Type t)
{
EnsureType(t.BaseType);
foreach (var intf in t.GetInterfaces())
{
EnsureType(intf);
}
foreach (var nested in t.GetNestedTypes())
{
EnsureType(nested);
}
var all = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance;
foreach (var field in t.GetFields(all))
{
EnsureType(field.FieldType);
}
foreach (var property in t.GetProperties(all))
{
EnsureType(property.PropertyType);
}
foreach (var evt in t.GetEvents(all))
{
EnsureType(evt.EventHandlerType);
}
foreach (var ctor in t.GetConstructors(all))
{
foreach (var par in ctor.GetParameters())
{
EnsureType(par.ParameterType);
}
// Phase 2: all types that are used in a body
GatherTypesFrom(ctor);
}
foreach (var method in t.GetMethods(all))
{
if (method.ReturnType != typeof(void))
{
EnsureType(method.ReturnType);
}
foreach (var par in method.GetParameters())
{
EnsureType(par.ParameterType);
}
// Phase 2: all types that are used in a body
GatherTypesFrom(method);
}
}
private void GatherTypesFrom(MethodBase method)
{
if (this.assemblies.Contains(method.DeclaringType.Assembly)) // only consider methods we've build ourselves
{
MethodBody methodBody = method.GetMethodBody();
if (methodBody != null)
{
// Handle local variables
foreach (var local in methodBody.LocalVariables)
{
EnsureType(local.LocalType);
}
// Handle method body
var il = methodBody.GetILAsByteArray();
if (il != null)
{
foreach (var oper in ILDecompiler.Decompile(method, il))
{
if (oper.Operand is MemberInfo)
{
foreach (var type in HandleMember((MemberInfo)oper.Operand))
{
EnsureType(type);
}
}
}
}
}
}
}
private static IEnumerable<Type> HandleMember(MemberInfo info)
{
// Event, Field, Method, Constructor or Property.
yield return info.DeclaringType;
if (info is EventInfo)
{
yield return ((EventInfo)info).EventHandlerType;
}
else if (info is FieldInfo)
{
yield return ((FieldInfo)info).FieldType;
}
else if (info is PropertyInfo)
{
yield return ((PropertyInfo)info).PropertyType;
}
else if (info is ConstructorInfo)
{
foreach (var par in ((ConstructorInfo)info).GetParameters())
{
yield return par.ParameterType;
}
}
else if (info is MethodInfo)
{
foreach (var par in ((MethodInfo)info).GetParameters())
{
yield return par.ParameterType;
}
}
else if (info is Type)
{
yield return (Type)info;
}
else
{
throw new NotSupportedException("Incorrect unsupported member type: " + info.GetType().Name);
}
}
}
コードを使用
まあ、それは簡単な部分です:-)
// Create something illegal
public class Bar2 : IMyInterface
{
public void Execute()
{
throw new NotImplementedException();
}
}
// Our fancy check
public class Foo<[IsInterface] T>
{
}
class Program
{
static Program()
{
// Perform all runtime checks
new NCTChecks(typeof(Program));
}
static void Main(string[] args)
{
// Normal operation
Console.WriteLine("Foo");
Console.ReadLine();
}
}
これは、C＃のリリースされたバージョンでも、今後のC＃4.0でも実行できません。 C＃の制限でもありません。CLR自体には「インターフェイス」の制約はありません。
可能であれば、私はこのようなソリューションに行きました。いくつかの特定のインターフェース（ソースへのアクセス権があるインターフェースなど）を汎用パラメーターとして渡したい場合にのみ機能します。
- 問題になったインターフェイスに、空のインターフェイス
IInterfaceを継承させます。 - 汎用Tパラメーターを
IInterfaceに制限しました
ソースでは、次のようになります。
ジェネリックパラメーターとして渡す任意のインターフェイス：
public interface IWhatever : IInterface { // IWhatever specific declarations }IInterface：
public interface IInterface { // Nothing in here, keep moving }型制約を設定するクラス：
public class WorldPeaceGenerator<T> where T : IInterface { // Actual world peace generating code }
あなたが解決したのはあなたができる最善のことです：
public bool Foo<T>() where T : IBase;
私は同様のことをしようとし、回避策を使用しました：構造の暗黙的および明示的な演算子について考えました：アイデアは、暗黙的にTypeに変換できる構造でTypeをラップすることです。
そのような構造は次のとおりです。
public struct InterfaceType {private Type _type;
public InterfaceType(Type type)
{
CheckType(type);
_type = type;
}
public static explicit operator Type(InterfaceType value)
{
return value._type;
}
public static implicit operator InterfaceType(Type type)
{
return new InterfaceType(type);
}
private static void CheckType(Type type)
{
if (type == null) throw new NullReferenceException("The type cannot be null");
if (!type.IsInterface) throw new NotSupportedException(string.Format("The given type {0} is not an interface, thus is not supported", type.Name));
}
}
基本的な使用法：
// OK
InterfaceType type1 = typeof(System.ComponentModel.INotifyPropertyChanged);
// Throws an exception
InterfaceType type2 = typeof(WeakReference);
これについては独自のメカニズムを想像する必要がありますが、例としては、タイプではなくパラメーターでInterfaceTypeを取得するメソッドがあります。
this.MyMethod(typeof(IMyType)) // works
this.MyMethod(typeof(MyType)) // throws exception
インターフェイスタイプを返すオーバーライドするメソッド：
public virtual IEnumerable<InterfaceType> GetInterfaces()
ジェネリック医薬品にも関係があるかもしれませんが、私は試しませんでした
これが助けになるか、アイデアを与えることを願っています:-)