accedere metodo privato in un diverso montaggio c #

Question

Questa può essere una domanda sciocca come posso vedere la ragione di sicurezza che accada il modo in cui lo fa ...

Ho un progetto di licensing # c, questo ha una classe che ha un metodo che genera le chiavi di licenza. Ho fatto questo metodo privato come io non voglio che nessun altro sia in grado di chiamare il mio metodo per ovvi motivi

La prossima cosa che voglio fare è quello di avere la mia interfaccia utente, che è in un altro progetto C #, che fa riferimento al dll di licenza di essere l'unica altra 'cosa' che può accedere a questo metodo al di fuori di se stesso, è questo possibile o non ho bisogno di spostarlo nello stesso progetto in modo che tutto compila allo stesso dll e posso accedere ai suoi membri?

  

LicensingProject
  -LicensingClass
  --Private MethodX (GeneratesLicenseKeys)

     

LicensingProject.UI
  -LicensingUiClass
  --I vogliono essere in grado di essere l'unica classe per essere in grado di accedere MethodX

C'è una ragione per cui il generatore di codice di licenza non è solo nell'interfaccia utente, è perché le opere di licenza per la generazione di un hash su se stesso e si confronta con quello generato dal generatore di licenza.

preferirei non a tutti di compilare la dll come i miei utenti finali non hanno bisogno del codice di interfaccia utente.

So che dal buon senso un metodo privato, è proprio questo. Stumped.

Answer 1

Si potrebbe rendere un metodo interno, e utilizzare InternalsVisibleToAttribute per dare LicensingProject.UI l'accesso in più per LicensingProject.

punto di Merhdad circa l'applicazione è giusto e sbagliato allo stesso tempo. Se non si dispone di ReflectionPermission , il CLR vi vieta di chiamare le cose non si dovrebbe - ma se si sta utilizzando la riflessione da un assembly completamente attendibile, è possibile chiamare qualsiasi cosa. Si dovrebbe presumere che un potenziale hacker è in grado di eseguire un montaggio completamente di fiducia sulla propria macchina:)

Tutto ciò non impedire a qualcuno di utilizzare Reflector per decompilare il codice. In altre parole, il che rende privata non è davvero l'aggiunta di una quantità significativa di protezione al sistema di licenze. Se qualcuno in realtà mette ogni sforzo in rottura, che probabilmente saranno in grado di.

Answer 2

Questo è veramente un commento , in risposta al punto di Mehrdad circa il runtime non esegue controlli di accesso; Qui, si può vedere il JIT (risulti) eseguendo il controllo di accesso -. Non riflessione, e non il compilatore C #

Per risolvere il codice, fare Foo.Bar pubblica. È interessante notare, si verifica inoltre che Foo accessibile - in modo da fare <=> interno per vedere più fuochi d'artificio:

using System;
using System.Reflection;
using System.Reflection.Emit;
static class Program {
    static void Main() {
        MethodInfo bar = typeof(Foo).GetMethod("Bar",
            BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
        var method = new DynamicMethod("FooBar", null, new[] {typeof(Foo)});
        var il = method.GetILGenerator();
        il.Emit(OpCodes.Ldarg_0);
        il.EmitCall(OpCodes.Callvirt, bar, null);
        il.Emit(OpCodes.Ret);

        Action<Foo> action = (Action<Foo>) method.CreateDelegate(typeof(Action<Foo>));
        Foo foo = new Foo();
        Console.WriteLine("Created method etc");
        action(foo); // MethodAccessException
    }
}

public class Foo {
    private void Bar() {
        Console.WriteLine("hi");
    }
}

Answer 3

public, private, ... roba sono solo applicate dal compilatore. È possibile utilizzare la reflection per accedervi abbastanza facilmente (supponendo che il codice ha richiesto i permessi, che è un'ipotesi ragionevole come lui ha il controllo completo sulla macchina). Non fare affidamento su quel assumendo nessuno può chiamare.

Answer 4

Foo.Bar può rimanere private ... Per risolvere il codice precedente, aggiungere un parametro alla fine del costruttore DynamicMethod:

var method = new DynamicMethod("FooBar", null, new[] {typeof(Foo)}, true);

Aggiungi vero per saltare i controlli JIT visibilità sui tipi e membri a cui si accede dalla MSIL del metodo dinamico.