En C #, comment restreindre le nombre de personnes pouvant appeler une méthode lors de la compilation

En C #, est-il possible de restreindre le nombre de personnes pouvant appeler une méthode lors de la compilation?

J’ai examiné des directives, mais cela n’a pas fonctionné car je ne peux pas atsortingbuer de valeurs à des symboles.

#define WHO VisualStudioUser.Current // does not work 

J’ai également examiné la sécurité d’access au code (CAS), mais il s’agit de l’application à l’exécution, pas du temps de compilation.

L’exigence est de restreindre l’access à une méthode au moment de la compilation pour des développeurs spécifiques, étant donné que la méthode existe dans un assemblage précompilé.

voici plus de détails … Je construis un framework ou une série ou des assemblys pour une équipe de développeurs. En raison de nos ressortingctions de licence logicielle, je ne peux autoriser que quelques développeurs à écrire du code pour appeler certaines méthodes restreintes. Les développeurs n’auront pas access au code source du framework, mais ils auront également access aux assemblys de framework compilés.

L’exigence est de restreindre l’access à une méthode au moment de la compilation pour des développeurs spécifiques, étant donné que la méthode existe dans un assemblage précompilé.

Une méthode consiste à marquer la méthode comme étant private ou internal , elle ne sera pas appelable par quelqu’un en dehors de l’assembly. UPDATE : Jetez également un coup d’oeil à l’atsortingbut InternalsVisibleTo , qui est utilisé pour définir quels assemblys peuvent “voir” les éléments internes de votre assembly.

Une autre méthode consiste à diviser le code que vous souhaitez dissortingbuer à partir du code que vous ne souhaitez pas que les utilisateurs appellent dans des assemblys distincts . Peut-être que vous venez de partager un ensemble d’interfaces avec vos utilisateurs, avec lesquels ils comstacknt; et vous avez un assemblage séparé avec des implémentations auxquelles ils ne devraient pas faire référence directement. Votre équipe interne aurait access à l’assemblage d’implémentation. Ceci est juste une forme courante de gestion de dépendance, le principe d’inversion de dépendance .

La réponse rapide sera: non, ce n’est pas possible, et si vous devez le faire, vous vous trompez.

Comment cela fonctionnerait-il? Est-ce que cela dépend de qui fait fonctionner le code ou qui l’a écrit?

Edit Il existe un moyen d’utiliser InternalsVisibleTo et de limiter l’access dans le contrôle de source aux assemblys pour lesquels InternalsVisibleTo est spécifié. Voir la réponse de Jordão

Brouillon:

  1. Comstackz le code restreint dans des DLL (obfusquées): TypeA.dll, TypeB.dll etc.
  2. Définissez une interface pour chaque type et comstackz-les dans des DLL distinctes: ITypeA.dll, ITypeB.dll, etc.
  3. Créez un “assembly de garde” et intégrez-y tous les assemblages restreints: Guard.dll. Cela a un ResolveEventHandler et des méthodes pour instancier différents types définis dans les DLL restreintes incorporées. Les instances sont renvoyées via leur interface.
  4. Les développeurs obtiennent les DLL d’interface et le fichier Guard.dll. Chaque développeur peut obtenir un fichier Guard.dll contenant des jetons d’authentification spéciaux. Par exemple, un fichier Guard.dll peut être lié à un PC, une adresse IP, un GUID atsortingbué au développeur, n’importe quoi.
  5. Le développeur peut instancier les types pour lesquels il dispose du code d’authentification approprié et utilise l’instance d’object via une interface.

Désolé, c’est un peu flou, parce que c’était il y a plus d’un an lorsque j’ai utilisé ces techniques. J’espère que l’idée principale est claire.

Pouvez-vous essayer d’utiliser Extensible C # développé par ResolveCorp , voici quelques liens pour l’étude et la mise en œuvre:

http://zef.me/782/extensible-c

http://www.codeproject.com/KB/architecture/DbCwithXCSharp.aspx

http://weblogs.asp.net/nunitaddin/archive/2003/02/14/2412.aspx

http://www.devx.com/dotnet/Article/11579/0/page/5