Nur direkte Schnittstelle statt alle?

Habe ich eine Klasse wie die unten. GetInterfaces() sagt

Wenn der aktuelle Type stellt eine Art
parameter in der definition einer
generischen Typ oder die generische Methode, diese
Methode sucht in der Schnittstelle
Einschränkungen und Schnittstellen
geerbt von Klasse oder Schnittstelle
- Einschränkungen.

Ist es möglich für mich, um nicht alle geerbten Schnittstelle? Wenn ich GetInterfaces auf ABC habe ich nur wollen, um zu sehen, DEF, keine DEF und GHI.

interface DEF : GHI {...}
class ABC : DEF {...}

Da ichm only on my iPad I cant-test-code oder schauen alle Methoden, aber hiers a thought. Could you find all the interfaces your type implements (including inherites ones), then move on to the base type of your type, find all the interfaces *that* type implements, and subtract those from the first set? I would think you would be left with what ABC itself added of interfaces. If anyone wants to "steal" this comment and type up a real answer of it, please do, it wont werden bis morgen, bis ich wieder an meinem computer.
die GetInterfaces() ist eine Methode der Typ-Klasse.
Ah, ich entschuldige mich, Ihre "Basis-Typ" ist eine Schnittstelle, dann weiß ich nicht.
Ich habe verstanden, das problem anders; ich denke, die OP ist nur daran interessiert, interface-Hierarchien.

InformationsquelleAutor | 2011-03-15

c#reflection

29

Erstens, die MSDN-snippet, das du gepostet hast hat nichts zu tun mit Ihrer wirklichen Frage. Es befasst sich mit, wenn man zum Beispiel ein generischer Typ wie class Foo<T> where T : IEnumerable, und Sie versuchen, den Aufruf GetInterfaces auf den Typ-parameter T werden, zum Beispiel durch typeof(Foo<>).GetGenericArguments().Single().GetInterfaces().

Zweitens, das problem ist etwas schlecht angegeben. Beachten Sie, dass, wenn eine Klasse eine Schnittstelle implementiert, muss es implementieren alle des interfaces 'geerbt' von der Schnittstelle. Es ist einfach eine C# - Komfort-feature, das können Sie auslassen, die geerbten Schnittstellen in der class-Deklaration. In deinem Beispiel, es ist völlig legal (und nicht anders) zu explizit sind die 'geerbt' GHI Schnittstelle:
```
class ABC : DEF, GHI {...}
```
Ich bin davon ausgegangen, dass das, was Sie wirklich wollen, zu tun ist, suchen Sie eine " minimal-set von Schnittstellen, die 'Deckel', die alle vom Typ implementierten Schnittstellen. Dies führt zu einer leicht vereinfachten version der Set cover problem.

Hier ist ein Weg, um es zu lösen, ohne den Versuch überhaupt zu werden algorithmisch effizient. Die Idee zu produzieren, die das minimal-interface-set, die durch das herausfiltern dieser Schnittstellen, die bereits umgesetzt anderen Schnittstellen implementiert, die für den Typ.
```
Type type = ...

var allInterfaces = type.GetInterfaces();    
var minimalInterfaces = from iType in allInterfaces 
                        where !allInterfaces.Any(t => t.GetInterfaces()
                                                       .Contains(iType))
                        select iType;
```
(
BEARBEITEN - Hier ist ein besserer Weg, dies zu erreichen:
```
var minimalInterfaces = allInterfaces.Except
                        (allInterfaces.SelectMany(t => t.GetInterfaces()));
```
)

Beispielsweise für List<int>:
```
allInterfaces: 

System.Collections.Generic.IList`1[System.Int32]
System.Collections.Generic.ICollection`1[System.Int32]
System.Collections.Generic.IEnumerable`1[System.Int32]
System.Collections.IEnumerable
System.Collections.IList
System.Collections.ICollection

minimalInterfaces:

System.Collections.Generic.IList`1[System.Int32]
System.Collections.IList
```
Tun, beachten Sie, dass diese Lösung deckt Schnittstelle 'Hierarchien' nur (das ist, was Sie scheinen zu wollen), nicht, wie Sie beziehen sich auf die Klasse Klasse Hierarchie. Insbesondere, es zahlt keine Aufmerksamkeit auf wo in eine Klasse in der Hierarchie eine Schnittstelle erstmals umgesetzt.

Zum Beispiel, sagen wir, wir haben:
```
interface IFoo { }
interface IBar : IFoo { }
interface IBaz { } 

class Base : IBar {  }
class Derived : Base, IBaz {  }
```
Nun, wenn Sie versucht, mit der Lösung die ich beschrieben habe, um die minimal-interface-set für Derived, würden Sie bekommen IBaz sowie IBar. Wenn Sie nicht möchten, dass IBar würden Sie haben zu gehen, um mehr Aufwand: Beseitigung von Schnittstellen implementiert, durch den Basis-Klassen. Der einfachste Weg, dies zu tun wäre, um von der minimal-Schnittstelle-legen Sie diese Schnittstellen implementiert, indem die Klasse der unmittelbaren Basis-Klasse, wie bereits in @MikeEast Antwort.
- +1 schöner, und arbeitet für Schnittstellen
- Ausgezeichnete Antwort.
InformationsquelleAutor Ani

Dies ist ein schönes Stück von einem doppelte Frage:

public static class TypeExtensions {
   public static IEnumerable<Type> GetInterfaces(this Type type, bool includeInherited)
   {
      if (includeInherited || type.BaseType == null)
         return type.GetInterfaces();
      else
         return type.GetInterfaces().Except(type.BaseType.GetInterfaces());
   }
}

Und Verwendung:

foreach(Type ifc in typeof(Some).GetInterfaces(false)) {
   Console.WriteLine(ifc);
}

problem mit diesem ist, dass es nicht für die Arbeit, d.h. IList<string> hatte ich eine ähnliche Lösung auf Basis @lasses Kommentar
Ah, für die BaseType Sache. Nicht sehen, dass ein.

InformationsquelleAutor Mikael Östberg

0

Den gleichen MSDN-Seite sagt

Den GetInterfaces-Methode nicht
return-Schnittstellen, die in einer bestimmten
um, wie alphabetische oder
in der Reihenfolge der Deklaration. Ihr code muss nicht
hängt von der Reihenfolge, in der die
Schnittstellen zurückgegeben, weil das
Reihenfolge variiert.

Nicht So, Sie können nicht überspringen Schnittstellen.
- Die OP ist nicht versuchen Sie zu überspringen-Schnittstellen, aber nur abrufen, die direkt implementierten interfaces.
- Ich denke, das Hauptproblem hier ist, dass einmal ein Typ eine Schnittstelle implementiert, gibt ess no concept of "directly implemented" any more. Youll zu analysieren, die Grafik-Schnittstelle "Vererbung" und finden Sie das plausibelste Ergebnis.
InformationsquelleAutor Roman Royter

Wie über dieses für interface-Vererbung heirachy?

    public static Map GetTypeInheritance(Type type)
    {
        //get all the interfaces for this type
        var interfaces = type.GetInterfaces();

        //get all the interfaces for the ancestor interfaces
        var baseInterfaces = interfaces.SelectMany(i => i.GetInterfaces());

        //filter based on only the direct interfaces
        var directInterfaces = interfaces.Where(i => baseInterfaces.All(b => b != i));

        Map map = new Map
            {
                Node = type,
                Ancestors = directInterfaces.Select(GetTypeInheritance).ToList()
            };

        return map;
    }

    public class Map
    {
       public Type Node { get; set; }
       public List<Map> Ancestors { get; set; }
    }

InformationsquelleAutor Mina

Diese Frage wird dupliziert, beide hier und hier. In jedem Fall, hier ist meine prägnante code der Auffassung, dass die angesprochenen Punkte auf diesen thread von @Ani und @Mikael:

var actualInterfaces = type.GetInterfaces();
foreach ( var result in actualInterfaces
    .Except( type.BaseType?.GetInterfaces() ?? Enumerable.Empty<Type>() ) //See https://stackoverflow.com/a/1613936
    .Except( actualInterfaces.SelectMany( i => i.GetInterfaces() ) ) //See https://stackoverflow.com/a/5318781
) yield return result;

InformationsquelleAutor HappyNomad

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.