InfoQ

News

Friend Assemblies and Unit Testing

Posted by Jonathan Allen on Jun 04, 2007 06:05 AM

Community
.NET
Topics
Unit Testing
Tags
C# ,
Visual Basic.NET
One of the major problems with unit testing is the need to access non-public classes and methods. There are numerous ways to work around this such as using proxy classes and reflection, but wouldn't it be nicer if an assembly could just treat non-public fields as if they were public?

C# 2.0 has this ability via friend assemblies. Normally types marked as internal as only accessible from within the assembly that defines it. However, when an assembly says that another assembly is a friend via the InternalsVisibleTo attribute, that second assembly can access any type in the first one that is marked internal.

According to Tim Ng, the ability to define friend assemblies will be added to the next version of Visual Basic.

2 comments

Reply

strongly signed assemblies only? by andrew mcveigh Posted Jun 4, 2007 6:35 AM
Re: strongly signed assemblies only? - No, that is a documentation error. by Jonathan Allen Posted Jun 4, 2007 10:58 AM
  1. Back to top

    strongly signed assemblies only?

    Jun 4, 2007 6:35 AM by andrew mcveigh

    I may be wrong, but I think this only works for strongly signed assemblies, which takes away some of the usefulness. at least it used to be that way in C#2.0 ...

    Andrew

  2. The MSDN documentation is highly inaccurate for this feature. The first error is the implication that the assemblies must be signed. Via testing I just conducted, I found that you do not need signed assemblies to use this feature.

    According to Tim Ng in the linked article, if friend assembly only has to be strongly signed if the assembly being shared is signed.

    One of the rules regarding friend assemblies is that if the declaring assembly is a strong name assembly (that is, that it specifies a key file/container), then you can only declare friends that are also strong name assemblies. This means that you must specify the entire 128 bit public key in the InternalsVisibleTo attribute: InternalsVisibleTo("A, PublicKey=<128-bit Key>").


    The second error I found in the documentation is that it implies your friend assembly has access to "all non-public types". In reality, it only has access to types marked as "internal". Private types and methods remain so.

Exclusive Content

Dan Farino About MySpace’s Architecture

Dan Farino talks about the system architecture and the challenges faced when building a very large online community. Dan explains how a .NET product scales on hundreds of servers.

The Maxine VM

Bernd Mathiske discusses Maxine VM, Java compatibility, swapping major VM components, research areas, Object handling, code examples, optimizing compiler, snippets, bytecode generation, JNI and JIT.

Joe Armstrong About Erlang

Joe Armstrong speaks on various aspects of the Erlang language, presenting its roots, how it compares with other languages and why it has become popular these days.

The Limits of Code Optimization: a new Singleton Pattern Implementation

The java double-check singleton pattern is not thread safe and can’t be fixed. In this article, Dr. Alexey Yakubovich provides an implementation of the Singleton pattern that he claims is thread-safe.

Pressure and Performance – The CTO's Dilemma

Diana and Jim talk about patterns observed in CTOs' activity. CTOs emerge as real people caring for other people in their organization, and are put under a lot of pressure and constraints.

Biztalk Services in the Cloud

Cloud computing feels like a tomorrow technology. Simon Thurman shows how developers can use Biztalk to create an Internet Service Bus which can be deployed locally or in the cloud.

Java FX Technology Preview

InfoQ takes a look at the JavaFX preview build and talks to Sun Staff Engineer Joshua Marinacci about the upcoming version 1 release expected this autumn.

Jeff Sutherland: Reaching Hyper-Productivity with Outsourced Development Teams

Jeff Sutherland, co-creator of Scrum, and Guido Schoonheim, CTO of Xebia, present an actual case of reaching hyper-productivity with a large distributed team using XP and Scrum.