Méthode d'accès privé dans un autre assemblage c #

Question

Cela peut être une question stupide que je peux voir la raison de la sécurité pour que cela arrive comme il le fait ...

J'ai un projet de licence de c #, il a une classe qui a une méthode qui génère mes clés de licence. J'ai fait cette méthode privée que je ne veux pas que quelqu'un d'autre pour être en mesure d'appeler ma méthode pour des raisons évidentes

La prochaine chose que je veux faire est d'avoir mon interface utilisateur, qui est dans un autre c # projet qui fait référence à la dll de licence pour être la seule autre « chose » qui peut accéder à cette méthode en dehors d'elle-même, est-ce possible ou Ai-je besoin de le déplacer dans le même projet afin que tout compile au même dll et je peux accéder à ses membres?

  

LicensingProject
  -LicensingClass
  --Private MethodX (GeneratesLicenseKeys)

     

LicensingProject.UI
  -LicensingUiClass
  -I veulent être en mesure d'être la seule classe pour pouvoir accéder MethodX

Il y a une raison pour laquelle la licence Key Generator est non seulement dans l'interface utilisateur, c'est parce que les travaux de licence en générant un hachage sur lui-même et il se compare à celui généré par le générateur de licence.

Je préférerais ne pas compiler tous à la dll que mes utilisateurs finaux ne ont pas besoin du code de l'interface utilisateur.

Je sais que par le bon sens une méthode privée, est juste que. Je suis perplexe.

Answer 1

Vous pouvez faire une méthode interne, et utiliser pour donner InternalsVisibleToAttribute LicensingProject.UI un accès supplémentaire à LicensingProject.

Du point de Merhdad au sujet de l'application est bien et mal en même temps. Si vous ne disposez pas ReflectionPermission , la CLR vous arrêter d'appeler les choses que vous ne devriez pas - mais si vous utilisez la réflexion à partir d'un assemblage entièrement confiance, vous pouvez appeler quoi que ce soit. Vous devez supposer qu'un pirate potentiel est en mesure d'exécuter un assemblage entièrement confiance sur sa propre machine:)

Rien de tout cela arrêtera quelqu'un d'utiliser décompiler votre code réflecteur . En d'autres termes, ce qui en fait privé est pas vraiment en ajoutant une quantité importante de sécurité à votre régime d'autorisation. Si quelqu'un met en fait aucun effort en rupture, ils vont probablement pouvoir.

Answer 2

Ceci est vraiment un commentaire , en réponse à point de Mehrdad sur l'exécution ne pas effectuer des contrôles d'accès; Ici, vous pouvez voir le JIT (il apparaît) effectuer le contrôle d'accès -. pas la réflexion, et non le compilateur C #

Pour corriger le code, faire du public Foo.Bar. Fait intéressant, il vérifie également que est accessible Foo - donc faire interne pour voir <=> plus de feux d'artifice:

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 ... choses sont juste appliquées par le compilateur. Vous pouvez utiliser la réflexion pour y accéder assez facilement (en supposant que le code a les autorisations nécessaires, ce qui est une hypothèse raisonnable qu'il a un contrôle complet sur la machine). Ne vous fiez pas à cette hypothèse que personne ne peut l'appeler.

Answer 4

Foo.Bar peut rester privé ... Pour corriger le code ci-dessus, ajoutez un paramètre à la fin du constructeur DynamicMethod:

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

Ajouter vrai pour sauter les contrôles de visibilité JIT sur les types et les membres accessibles par le MSIL de la méthode dynamique.