Как проверить, реализует ли один тип.NET определенный интерфейс.NET абстрактно?
Отмечание параметров, передаваемых по значению 'константа' является определенно субъективной вещью.
Однако я на самом деле предпочитаю отмечать константу параметров, передаваемых по значению, точно так же, как в Вашем примере.
void func(const int n, const long l) { /* ... */ }
значение мне находится в четком указании, что значения параметра функции никогда не изменяются функцией. У них будет то же значение вначале как в конце. Для меня это - часть придерживания вида очень функционального программирования стиля.
Для короткой функции, это - возможно пустая трата времени/пространства для имения 'константы' там, так как обычно довольно очевидно, что аргументы не изменяются функцией.
Однако для большей функции, это - форма документации реализации, и это осуществляется компилятором.
я могу быть уверен, делаю ли я некоторое вычисление с 'n' и 'l', я могу осуществить рефакторинг/переместить то вычисление без страха перед получением различного результата, потому что я пропустил место, где один или оба изменяются.
, Так как это - деталь реализации, Вы не должны объявлять константу параметров, передаваемых по значению в заголовке, точно так же, как Вы не должны объявлять параметры функции с теми же именами как использование реализации.
4 ответа
You can determine if a type implements a particular interface by using Type.IsAssignableFrom:
typeof(MyInterface).IsAssignableFrom(abstractType);
Edit: after clarification was added to the answer - to determine if all of an interface's implementations are abstract for a given class, you can do so much more easily by getting an InterfaceMap for the type in question:
bool IsAbstractOfInterface(Type classType, Type interfaceType)
{
var map = classType.GetInterfaceMap(interfaceType);
foreach (var info in map.TargetMethods)
{
if (!info.IsAbstract)
{
return false;
}
}
return true;
}
Or maybe a generic extension method...
public static bool IsAbstractOf<TInterface>(this Type type)
{
var map = type.GetInterfaceMap(typeof(TInterface));
foreach (var info in map.TargetMethods)
{
if (!info.IsAbstract)
{
return false;
}
}
return true;
}
Rex M's answer is correct in general, but if your type is a type parameter, you can also do:
class Foo<T> where T : IWhatever {
// Do your thing, secure in the knowledge that T implements IWhatever
}
public static bool IsAbstractInterfaceImplementation(Type someType, Type someInterface)
{
return someType.IsAbstract && someInterface.IsAssignableFrom(someType);
}
Вы не можете использовать имена членов. BE потому что нет причин предполагать, что имя члена говорит вам что-либо о члене интерфейса, который он реализует. Отражение дает вам возможность увидеть, какой метод какой из них реализует из интерфейса.
Вот фрагмент, который вернет все методы данного типа, которые реализованы только абстрактно.
static IEnumerable<MethodInfo> GetAbstractImplementations(this Type implementingType, Type interfaceType)
{
if(!interfaceType.IsInterface)
throw new ArgumentException(interfaceType.FullName + " is not an interface.");
if(implementingType.IsInterface)
throw new ArgumentException(interfaceType.FullName + " is an interface.");
if(!interfaceType.IsAssignableFrom(implementingType))
throw new ArgumentException(implementingType.FullName + " does not implement " + interfaceType.FullName + ".");
var mapping = implementingType.GetInterfaceMap(interfaceType);
return from m in mapping.TargetMethods
where m.IsAbstract
select m;
}
public static bool IsAbstractInterfaceImplementationOf(this Type implementingType, Type interfaceType)
{
return implementingType.GetAbstractImplementations(interfaceType).Any();
}