[Legacy]

Hallo Forum!

Mit meiner .NET Applikation möchte ich auf eine private Funktion einer anderen, bereits kompilierten .NET Komponente zugreifen. Ist das möglich?

Dieser Beitrag wurde von Legacy bearbeitet: 22. Mai 2005 - 17:08

[Rika]

Nur über Managed C++ bei der .NET CLR 2.0 oder geeignete Spielereien mit Native Code. Mir scheint aber, daß du das Konzept der privaten Funktionen nicht verstehen willst.

[Legacy]

@Rika Danke!
Die Komponente wurde noch mit .NET 1.1 erstellt. Müsste wegen 'nem Workaround darauf zugreifen.

[constructor]

Och ... über Reflection funktioniert das ganz easy

Hier mal ein Code Beispiel:

//Der Namespace System.Reflection wurde eingebunden!

//Assembly laden
        Assembly l_Assembly 
  = Assembly.LoadFrom(@"..\..\..\ClassLibrary6\bin\Debug\ClassLibrary6.dll");
        
        //Die Klasse, auf die zugegriffen werden soll, ermitteln
        Type l_Type = l_Assembly.GetType("ClassLibrary6.Class1");
        
        //Instanz der Klasse erstellen
        object l_Instance = Activator.CreateInstance(l_Type);
        
        //MethodInfo-Objekt für die gewünschte Funktion erstellen 
        //und Funktion in der KlassenInstanz über Invoke aufrufen
        MethodInfo l_MethodInfo = l_Type.GetMethod("ShowMessage", BindingFlags.Instance | BindingFlags.NonPublic);
        l_MethodInfo.Invoke(l_Instance, new object[]{"Hello Reflection World!"});

Beim Erstellen des MethodInfo-Objekts musst du darauf achten, dass BindingFlags.NonPublic übergeben wird!

Habe dir mal ein Beispielprojekt mitgeschickt.

RIP OOP

Viel Spaß!

Angehängte Datei(en)

•  Reflection.zip (33,06K)
  Anzahl der Downloads: 105

[Rika]

Mit /safe kompilierte private Functions reagieren auf Reflections?
Wat'n dat für 'n Murks?

[constructor]

Jep, ist schon interessant, was mit .NET so alles möglich ist

Um den obrigen Code auszuhebeln könnte man in der Komponente, in der sich die private Funktion befindet, einen private/internal Constructor einführen.
Das würde das Erstellen des Types über Reflection verhindern.

Aaaaaber:
In diesem Fall holt man sich über Reflection einfach den privaten (!!!) Constructor und erstellt mit dem die Klasseninstanz!

//Privaten Constructor ermitteln
ConstructorInfo l_ConstructorInfo = l_Type.GetConstructor(BindingFlags.Instance | BindingFlags.NonPublic, null, new Type[0], null);
object l_Instance = l_ConstructorInfo.Invoke(new object[0]);

//Methode aufrufen
MethodInfo l_MethodInfo = l_Type.GetMethod("ShowMessage2", BindingFlags.Instance | BindingFlags.NonPublic);
l_MethodInfo.Invoke(l_Instance, new object[]{"Hello Reflection World 2!"});

Schützen kann man sich dagegen imho nur mit declarative security und dem Attribut ReflectionPermissionAttribute. Im Betriebsystem läßt sich das ganze dann konfigurieren.

Diese Möglichkeiten hat sicherlich schon den ein oder anderen Script Kiddie oder echten Hacker/Cracker auf den Plan gebracht Mit dem .NET-Framework 2.0 soll das aber wohl nicht mehr so einfach möglich sein.

Anbei noch das erweiterte Beispielprojekt.

Angehängte Datei(en)

•  Reflection2.zip (36,11K)
  Anzahl der Downloads: 93

Dieser Beitrag wurde von constructor bearbeitet: 20. Mai 2005 - 18:04

[Legacy]

Danke, werde es gleich mal ausprobieren!

[Legacy]

Sehr gut - es funktioniert!

Nun verzweifle ich an einem anderen Problem!

Die private Funktion befindet sich in einer Klasse, die von einem bestimmten Interface erbt. Leider ist nich klar, welche Klasse das ist. Es können auch mehrere Klassen von dem Interface geerbt haben.

Die Funktion "type.GetInterfaces()" gibt mir anscheinend nur die Interface-Implementierungen zurück.
Wie kann ich über Reflection feststellen, ob eine Komponente eine Klasse enthält, die von einem bestimmten Interface ERBT?

Dieser Beitrag wurde von Legacy bearbeitet: 22. Mai 2005 - 17:40

[Legacy]

push

Kann mir denn keiner helfen?

[constructor]

Zitat (Legacy: 22.05.2005, 18:07)

Wie kann ich über Reflection feststellen, ob eine Komponente eine Klasse enthält, die von einem bestimmten Interface ERBT?
<{POST_SNAPBACK}>

Das ist imho etwas komplizierter:

Du benötigst einen System.Reflection.TypeFilter und eine zusätzliche Filterfunktion. Über eine Schleife gehst du dann alle Types der Komponente durch und überprüfst, ob der jeweilige Type von dem Interface erbt.

private static Type FindType()
{
    Assembly l_Assembly = Assembly.LoadFrom(@"c:\MeineKomponente.dll");
    Type l_AddInInfoType = null;
    foreach(Type type in l_Assembly.GetTypes())
    {
        //Überprüfen, ob der Type das Interface implementiert
        TypeFilter myFilter = new TypeFilter(InterfaceFilter);
        String[] myInterfaceList = new String[1] {"Namespace.IMeinInterface"};
        Type[] myInterfaces = type.FindInterfaces(myFilter, myInterfaceList[0]);
        if (myInterfaces.Length == 1)
        {
            l_AddInInfoType = type;
            break;
        }
    }
    
    return l_AddInInfoType;
}


private static bool InterfaceFilter(Type typeObj, Object criteriaObj)
{
    if(typeObj.ToString() == criteriaObj.ToString())
    {
        return true;
    }
    else
    {
        return false;
    }
}

[Legacy]

Super - Danke!