Tip of the day: Friend assemblies

The internal keyword (C#) is defined as the way to restrict access to members only to types in same assembly.

But, since the .net framework 2.0, there is a way to to define an assembly as a friend assembly. This can be done by specifying

[assembly:InternalsVisibleTo("friend assembly")]

in the AssemblyInfo.cs file (or in any other file).

After specifying this, the friend assembly can access the internals of the assembly marked with this attribute.

I can see two useful thing that can be achieved:

1) Better encapsulation of course.

2) Enable access for unit testing by using this strategy.

The msdn documentation is here.

Tip of the day #2: ref/out key words for reference types

This tip is the courtesy of Gal.

It surprised and embarrassed me to realize that I didn't know it.

When a reference type is passed to a method without using the ref or out keywords, a new reference is created inside the method and it points to the same location in the memory as the reference that was passed so we have two "pointers" to the same location in memory.

In case the the reference inside the method is set to a different location, the reference that was passed does not change.

When the ref/out keywords are used, we have only one reference inside and outside the method so if the reference is changed to point to another location and it happens inside the method, the outer reference is changed too.

Basic stuff...

Tip of the day: ThreadStatic attribute

According to the msdn documentation, the ThreadStatic attribute "Indicates that the value of a static field is unique for each thread."

A practical use for it can be a registrar implementation. A registrar can be used as a static entry point to store context data for say, a request that is being processed by several classes that need to share data.

Implementation example:

public static class Registrar
{
   [ThreadStatic]
   private static Dictionary<string, object>
      m_registrar = null;

   private static Dictionary<string, object> 
      LocalDictionary
   {
      get
      {
         if (m_registrar == null)
         {
            m_registrar =
               new Dictionary<string, object>();
         }
         return m_registrar;
      }
   }

   public static object Get(string key)
   {
      return LocalDictionary[key];
   }

   public static void Set(string key, object value)
   {
      LocalDictionary[key] = value;
   }
}

Now since the m_registrar is marked with ThreadStatic attribute, is static per thread, which means that no locking is required and no data corruption can occur.

A real world example for using such strategy is HttpContext.Items

Gilad pointed out two important points:

- ASP.NET is changing threads under the hood so don't use it there since u will most probably get your data corrupted. The HttpContext knows how to handle that so use it.

- When using a thread pool, the threads are not killed and so when a thread completes execution and returned to the pool, the static data is still kept. In this case u should use an execution wrapper than clears the per thread static data after the thread complete execution.

Tip of the day: Data Type aliasing

There is a feature in .net that is not commonly remembered and it is Data Type aliasing.

What it means is that u give a data type a different name.

I can see two uses for it:
1) Enhance code readability:

Instead of having very long type declarations such as when using generic types inside generic types, u can assign an alias to that declaration. Here is an example:

    
    // Aliasing
    using HashOfHashes = 
	Dictionary<string, Dictionary<string, List<string>>>;
 
    public class AliasExample
    {
        HashOfHashes m_hash;
 
        public AliasExample()
        {
            m_hash = new HashOfHashes();
        }
 
        public HashOfHashes MyHash
        {
            get
            {
                return m_hash;
            }
        }
    }

2) Alias data types that are prone to change:

An example is an identifier property of class. It can save a lot find&replace when changing code like changing the identifier of a member from int to Guid and it better shows intent. For example:

    // Aliasing
    using MemberIdentidfier = Guid;
 
    public class MemberWithAlias
    {
        private MemberIdentidfier m_id;
        private string m_name;
 
        public MemberWithAlias
		(MemberIdentidfier id)
        {
            m_id = id;
        }
 
        public MemberIdentidfier Id
        {
            get { return m_id; }
        }
 
        public string Name
        {
            get { return m_name; }
            set { m_name = value; }
        }
    }

Tip of the day: Primitive but efficient way for profiling (on development machine)

Small thing I read about. It is so simple and obvious but I never thought about it...

In the lack of a decent profiler,

if u observe that a certain process takes a large amount of time (such as system startup),

start the debugger and while the time consuming task is running, click the pause button in VS.

Now take a look at the call stack to see which method take the time to execute.