We need you! We're working hard on the next version of Developer Fusion - Let us know what you think we should be up to!

The Labs \ Source Viewer \ SSCLI \ System.Reflection.Emit \ Format

SSCLI
  1. // ==++==
  2. //
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. //
  14. // ==--==
  15. using System;
  16. using System.Collections.Generic;
  17. using System.Runtime.CompilerServices;
  19. namespace System.Reflection.Emit
  20. {
  21.     // TypeNameBuilder is NOT thread safe NOR hardened for OOM NOR reliable
  22.     internal class TypeNameBuilder
  23.     {
  24.         internal enum Format
  25.         {
  26.             ToString,
  27.             FullName,
  28.             AssemblyQualifiedName
  29.         }
  30.        
  31.         #region FCalls
  32.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  33.         private static extern IntPtr _CreateTypeNameBuilder();
  34.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  35.         private static extern void _ReleaseTypeNameBuilder(IntPtr pAQN);
  36.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  37.         private static extern void _OpenGenericArguments(IntPtr tnb);
  38.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  39.         private static extern void _CloseGenericArguments(IntPtr tnb);
  40.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  41.         private static extern void _OpenGenericArgument(IntPtr tnb);
  42.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  43.         private static extern void _CloseGenericArgument(IntPtr tnb);
  44.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  45.         private static extern void _AddName(IntPtr tnb, string name);
  46.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  47.         private static extern void _AddPointer(IntPtr tnb);
  48.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  49.         private static extern void _AddByRef(IntPtr tnb);
  50.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  51.         private static extern void _AddSzArray(IntPtr tnb);
  52.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  53.         private static extern void _AddArray(IntPtr tnb, int rank);
  54.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  55.         private static extern void _AddAssemblySpec(IntPtr tnb, string assemblySpec);
  56.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  57.         private static extern string _ToString(IntPtr tnb);
  58.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  59.         private static extern void _Clear(IntPtr tnb);
  60.         #endregion
  61.        
  62.         #region Static Members
  63.        
  64.         // TypeNameBuilder is NOT thread safe NOR hardened for OOM NOR reliable
  65.         static internal string ToString(Type type, Format format)
  66.         {
  67.             if (format == Format.FullName || format == Format.AssemblyQualifiedName) {
  68.                 if (!type.IsGenericTypeDefinition && type.ContainsGenericParameters)
  69.                     return null;
  70.             }
  71.            
  72.             TypeNameBuilder tnb = new TypeNameBuilder(_CreateTypeNameBuilder());
  73.             tnb.Clear();
  74.             tnb.ConstructAssemblyQualifiedNameWorker(type, format);
  75.             string toString = tnb.ToString();
  76.             tnb.Dispose();
  77.             return toString;
  78.         }
  79.         #endregion
  80.        
  81.         #region Private Data Members
  82.         private IntPtr m_typeNameBuilder;
  83.         #endregion
  84.        
  85.         #region Constructor
  86.         private TypeNameBuilder(IntPtr typeNameBuilder)
  87.         {
  88.             m_typeNameBuilder = typeNameBuilder;
  89.         }
  90.         internal void Dispose()
  91.         {
  92.             _ReleaseTypeNameBuilder(m_typeNameBuilder);
  93.         }
  94.         #endregion
  95.        
  96.         #region private Members
  97.         private void AddElementType(Type elementType)
  98.         {
  99.             if (elementType.HasElementType)
  100.                 AddElementType(elementType.GetElementType());
  101.            
  102.             if (elementType.IsPointer)
  103.                 AddPointer();
  104.             else if (elementType.IsByRef)
  105.                 AddByRef();
  106.             else if (elementType.IsSzArray)
  107.                 AddSzArray();
  108.             else if (elementType.IsArray)
  109.                
  110.                
  111.                
  112.                 AddArray(elementType.GetArrayRank());
  113.         }
  114.        
  115.         private void ConstructAssemblyQualifiedNameWorker(Type type, Format format)
  116.         {
  117.             Type rootType = type;
  118.            
  119.             while (rootType.HasElementType)
  120.                 rootType = rootType.GetElementType();
  121.            
  122.             // Append namespace + nesting + name
  123.             List<Type> nestings = new List<Type>();
  124.             for (Type t = rootType; t != null; t = t.IsGenericParameter ? null : t.DeclaringType)
  125.                 nestings.Add(t);
  126.            
  127.             for (int i = nestings.Count - 1; i >= 0; i--) {
  128.                 Type enclosingType = nestings[i];
  129.                 string name = enclosingType.Name;
  130.                
  131.                 if (i == nestings.Count - 1 && enclosingType.Namespace != null && enclosingType.Namespace.Length != 0)
  132.                     name = enclosingType.Namespace + "." + name;
  133.                
  134.                 AddName(name);
  135.             }
  136.            
  137.             // Append generic arguments
  138.             if (rootType.IsGenericType && (!rootType.IsGenericTypeDefinition || format == Format.ToString)) {
  139.                 Type[] genericArguments = rootType.GetGenericArguments();
  140.                
  141.                 OpenGenericArguments();
  142.                 for (int i = 0; i < genericArguments.Length; i++) {
  143.                     Format genericArgumentsFormat = format == Format.FullName ? Format.AssemblyQualifiedName : format;
  144.                    
  145.                     OpenGenericArgument();
  146.                     ConstructAssemblyQualifiedNameWorker(genericArguments[i], genericArgumentsFormat);
  147.                     CloseGenericArgument();
  148.                 }
  149.                 CloseGenericArguments();
  150.             }
  151.            
  152.             // Append pointer, byRef and array qualifiers
  153.             AddElementType(type);
  154.            
  155.             if (format == Format.AssemblyQualifiedName)
  156.                 AddAssemblySpec(type.Module.Assembly.FullName);
  157.         }
  158.        
  159.         private void OpenGenericArguments()
  160.         {
  161.             _OpenGenericArguments(m_typeNameBuilder);
  162.         }
  163.         private void CloseGenericArguments()
  164.         {
  165.             _CloseGenericArguments(m_typeNameBuilder);
  166.         }
  167.         private void OpenGenericArgument()
  168.         {
  169.             _OpenGenericArgument(m_typeNameBuilder);
  170.         }
  171.         private void CloseGenericArgument()
  172.         {
  173.             _CloseGenericArgument(m_typeNameBuilder);
  174.         }
  175.         private void AddName(string name)
  176.         {
  177.             _AddName(m_typeNameBuilder, name);
  178.         }
  179.         private void AddPointer()
  180.         {
  181.             _AddPointer(m_typeNameBuilder);
  182.         }
  183.         private void AddByRef()
  184.         {
  185.             _AddByRef(m_typeNameBuilder);
  186.         }
  187.         private void AddSzArray()
  188.         {
  189.             _AddSzArray(m_typeNameBuilder);
  190.         }
  191.         private void AddArray(int rank)
  192.         {
  193.             _AddArray(m_typeNameBuilder, rank);
  194.         }
  195.         private void AddAssemblySpec(string assemblySpec)
  196.         {
  197.             _AddAssemblySpec(m_typeNameBuilder, assemblySpec);
  198.         }
  199.         public override string ToString()
  200.         {
  201.             return _ToString(m_typeNameBuilder);
  202.         }
  203.         private void Clear()
  204.         {
  205.             _Clear(m_typeNameBuilder);
  206.         }
  207.         #endregion
  208.     }
  209. }

Developer Fusion