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

  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.Reflection;
  17. using System.Reflection.Emit;
  18. using System.Collections;
  19. using System.Globalization;
  20. namespace System.Reflection.Emit
  21. {
  22.     internal sealed class TypeBuilderInstantiation : Type
  23.     {
  24.         #region Private Data Mebers
  25.         private Type m_type;
  26.         private Type[] m_inst;
  27.         private string m_strFullQualName;
  28.         #endregion
  29.        
  30.         #region Constructor
  31.         internal TypeBuilderInstantiation(Type type, Type[] inst)
  32.         {
  33.             m_type = type;
  34.             m_inst = inst;
  35.         }
  36.         #endregion
  37.        
  38.         #region Object Overrides
  39.         public override string ToString()
  40.         {
  41.             return TypeNameBuilder.ToString(this, TypeNameBuilder.Format.ToString);
  42.         }
  43.         #endregion
  44.        
  45.         #region MemberInfo Overrides
  46.         public override Type DeclaringType {
  47.             get { return m_type.DeclaringType; }
  48.         }
  49.        
  50.         public override Type ReflectedType {
  51.             get { return m_type.ReflectedType; }
  52.         }
  53.        
  54.         public override string Name {
  55.             get { return m_type.Name; }
  56.         }
  57.        
  58.         public override Module Module {
  59.             get { return m_type.Module; }
  60.         }
  61.        
  62.         internal override int MetadataTokenInternal {
  63.             get {
  64.                 throw new NotSupportedException();
  65.             }
  66.         }
  67.         #endregion
  68.        
  69.         #region Type Overrides
  70.         public override Type MakePointerType()
  71.         {
  72.             return SymbolType.FormCompoundType("*".ToCharArray(), this, 0);
  73.         }
  74.         public override Type MakeByRefType()
  75.         {
  76.             return SymbolType.FormCompoundType("&".ToCharArray(), this, 0);
  77.         }
  78.         public override Type MakeArrayType()
  79.         {
  80.             return SymbolType.FormCompoundType("[]".ToCharArray(), this, 0);
  81.         }
  82.         public override Type MakeArrayType(int rank)
  83.         {
  84.             if (rank <= 0)
  85.                 throw new IndexOutOfRangeException();
  86.            
  87.             string comma = "";
  88.             for (int i = 1; i < rank; i++)
  89.                 comma += ",";
  90.            
  91.             string s = String.Format(CultureInfo.InvariantCulture, "[{0}]", comma);
  92.             return SymbolType.FormCompoundType(s.ToCharArray(), this, 0);
  93.         }
  94.         public override Guid GUID {
  95.             get {
  96.                 throw new NotSupportedException();
  97.             }
  98.         }
  99.         public override object InvokeMember(string name, BindingFlags invokeAttr, Binder binder, object target, object[] args, ParameterModifier[] modifiers, CultureInfo culture, string[] namedParameters)
  100.         {
  101.             throw new NotSupportedException();
  102.         }
  103.         public override Assembly Assembly {
  104.             get { return m_type.Assembly; }
  105.         }
  106.         public override RuntimeTypeHandle TypeHandle {
  107.             get {
  108.                 throw new NotSupportedException();
  109.             }
  110.         }
  111.         public override string FullName {
  112.             get {
  113.                 if (m_strFullQualName == null)
  114.                     m_strFullQualName = TypeNameBuilder.ToString(this, TypeNameBuilder.Format.FullName);
  115.                 return m_strFullQualName;
  116.             }
  117.         }
  118.         public override string Namespace {
  119.             get { return m_type.Namespace; }
  120.         }
  121.         public override string AssemblyQualifiedName {
  122.             get { return TypeNameBuilder.ToString(this, TypeNameBuilder.Format.AssemblyQualifiedName); }
  123.         }
  124.         internal Type Substitute(Type[] substitutes)
  125.         {
  126.             Type[] inst = GetGenericArguments();
  127.             Type[] instSubstituted = new Type[inst.Length];
  128.            
  129.             for (int i = 0; i < instSubstituted.Length; i++) {
  130.                 Type t = inst[i];
  131.                
  132.                 if (t is TypeBuilderInstantiation) {
  133.                     instSubstituted[i] = (t as TypeBuilderInstantiation).Substitute(substitutes);
  134.                 }
  135.                 else if (t is GenericTypeParameterBuilder) {
  136.                     // Substitute
  137.                     instSubstituted[i] = substitutes[t.GenericParameterPosition];
  138.                 }
  139.                 else {
  140.                     instSubstituted[i] = t;
  141.                 }
  142.             }
  143.            
  144.             return GetGenericTypeDefinition().MakeGenericType(instSubstituted);
  145.         }
  146.         public override Type BaseType {
  147.             // B<A,B,C>
  148.             // D<T,S> : B<S,List<T>,char>
  149.            
  150.             // D<string,int> : B<int,List<string>,char>
  151.             // D<S,T> : B<T,List<S>,char>
  152.             // D<S,string> : B<string,List<S>,char>
  153.             get {
  154.                 Type typeBldrBase = m_type.BaseType;
  155.                
  156.                 if (typeBldrBase == null)
  157.                     return null;
  158.                
  159.                 TypeBuilderInstantiation typeBldrBaseAs = typeBldrBase as TypeBuilderInstantiation;
  160.                
  161.                 if (typeBldrBaseAs == null)
  162.                     return typeBldrBase;
  163.                
  164.                 return typeBldrBaseAs.Substitute(GetGenericArguments());
  165.             }
  166.         }
  167.         protected override ConstructorInfo GetConstructorImpl(BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers)
  168.         {
  169.             throw new NotSupportedException();
  170.         }
  171.        
  172.         [System.Runtime.InteropServices.ComVisible(true)]
  173.         public override ConstructorInfo[] GetConstructors(BindingFlags bindingAttr)
  174.         {
  175.             throw new NotSupportedException();
  176.         }
  177.         protected override MethodInfo GetMethodImpl(string name, BindingFlags bindingAttr, Binder binder, CallingConventions callConvention, Type[] types, ParameterModifier[] modifiers)
  178.         {
  179.             throw new NotSupportedException();
  180.         }
  181.         public override MethodInfo[] GetMethods(BindingFlags bindingAttr)
  182.         {
  183.             throw new NotSupportedException();
  184.         }
  185.         public override FieldInfo GetField(string name, BindingFlags bindingAttr)
  186.         {
  187.             throw new NotSupportedException();
  188.         }
  189.         public override FieldInfo[] GetFields(BindingFlags bindingAttr)
  190.         {
  191.             throw new NotSupportedException();
  192.         }
  193.         public override Type GetInterface(string name, bool ignoreCase)
  194.         {
  195.             throw new NotSupportedException();
  196.         }
  197.         public override Type[] GetInterfaces()
  198.         {
  199.             throw new NotSupportedException();
  200.         }
  201.         public override EventInfo GetEvent(string name, BindingFlags bindingAttr)
  202.         {
  203.             throw new NotSupportedException();
  204.         }
  205.         public override EventInfo[] GetEvents()
  206.         {
  207.             throw new NotSupportedException();
  208.         }
  209.         protected override PropertyInfo GetPropertyImpl(string name, BindingFlags bindingAttr, Binder binder, Type returnType, Type[] types, ParameterModifier[] modifiers)
  210.         {
  211.             throw new NotSupportedException();
  212.         }
  213.         public override PropertyInfo[] GetProperties(BindingFlags bindingAttr)
  214.         {
  215.             throw new NotSupportedException();
  216.         }
  217.         public override Type[] GetNestedTypes(BindingFlags bindingAttr)
  218.         {
  219.             throw new NotSupportedException();
  220.         }
  221.         public override Type GetNestedType(string name, BindingFlags bindingAttr)
  222.         {
  223.             throw new NotSupportedException();
  224.         }
  225.         public override MemberInfo[] GetMember(string name, MemberTypes type, BindingFlags bindingAttr)
  226.         {
  227.             throw new NotSupportedException();
  228.         }
  229.        
  230.         [System.Runtime.InteropServices.ComVisible(true)]
  231.         public override InterfaceMapping GetInterfaceMap(Type interfaceType)
  232.         {
  233.             throw new NotSupportedException();
  234.         }
  235.         public override EventInfo[] GetEvents(BindingFlags bindingAttr)
  236.         {
  237.             throw new NotSupportedException();
  238.         }
  239.         public override MemberInfo[] GetMembers(BindingFlags bindingAttr)
  240.         {
  241.             throw new NotSupportedException();
  242.         }
  243.         protected override TypeAttributes GetAttributeFlagsImpl()
  244.         {
  245.             return m_type.Attributes;
  246.         }
  247.         protected override bool IsArrayImpl()
  248.         {
  249.             return false;
  250.         }
  251.         protected override bool IsByRefImpl()
  252.         {
  253.             return false;
  254.         }
  255.         protected override bool IsPointerImpl()
  256.         {
  257.             return false;
  258.         }
  259.         protected override bool IsPrimitiveImpl()
  260.         {
  261.             return false;
  262.         }
  263.         protected override bool IsCOMObjectImpl()
  264.         {
  265.             return false;
  266.         }
  267.         public override Type GetElementType()
  268.         {
  269.             throw new NotSupportedException();
  270.         }
  271.         protected override bool HasElementTypeImpl()
  272.         {
  273.             return false;
  274.         }
  275.         public override Type UnderlyingSystemType {
  276.             get { return this; }
  277.         }
  278.         public override Type[] GetGenericArguments()
  279.         {
  280.             return m_inst;
  281.         }
  282.         public override bool IsGenericTypeDefinition {
  283.             get { return false; }
  284.         }
  285.         public override bool IsGenericType {
  286.             get { return true; }
  287.         }
  288.         public override bool IsGenericParameter {
  289.             get { return false; }
  290.         }
  291.         public override int GenericParameterPosition {
  292.             get {
  293.                 throw new InvalidOperationException();
  294.             }
  295.         }
  296.         protected override bool IsValueTypeImpl()
  297.         {
  298.             return m_type.IsValueType;
  299.         }
  300.         public override bool ContainsGenericParameters {
  301.             get {
  302.                 for (int i = 0; i < m_inst.Length; i++) {
  303.                     if (m_inst[i].ContainsGenericParameters)
  304.                         return true;
  305.                 }
  306.                
  307.                 return false;
  308.             }
  309.         }
  310.         public override MethodBase DeclaringMethod {
  311.             get { return null; }
  312.         }
  313.         public override Type GetGenericTypeDefinition()
  314.         {
  315.             return m_type;
  316.         }
  317.         public override Type MakeGenericType(params Type[] inst)
  318.         {
  319.             throw new InvalidOperationException(Environment.GetResourceString("Arg_NotGenericTypeDefinition"));
  320.         }
  321.         public override bool IsAssignableFrom(Type c)
  322.         {
  323.             throw new NotSupportedException();
  324.         }
  325.        
  326.         [System.Runtime.InteropServices.ComVisible(true)]
  327.         public override bool IsSubclassOf(Type c)
  328.         {
  329.             throw new NotSupportedException();
  330.             /*       
  331.             if (!c.IsGenericType)
  332.                 return false;
  333.             if (c.IsGenericTypeDefinition)
  334.                 return false;
  335.             Type cgtd = c.GetGenericTypeDefinition();
  336.             Type gtd = GetGenericTypeDefinition();
  337.             while (gtd != cgtd)
  338.             {
  339.                 gtd = gtd.BaseType;
  340.                 if (gtd == null)
  341.                     return false;
  342.             }
  343.             for (int i = 0; i < gtd.GetGenericArguments().Length; i++)
  344.             {
  345.                 if (gtd.GetGenericArguments()[i] != c.GetGenericArguments()[i])
  346.                     return false;
  347.             }
  348.             return true;
  349. */           
  350.         }
  351.         #endregion
  352.        
  353.         #region ICustomAttributeProvider Implementation
  354.         public override object[] GetCustomAttributes(bool inherit)
  355.         {
  356.             throw new NotSupportedException();
  357.         }
  358.        
  359.         public override object[] GetCustomAttributes(Type attributeType, bool inherit)
  360.         {
  361.             throw new NotSupportedException();
  362.         }
  363.        
  364.         public override bool IsDefined(Type attributeType, bool inherit)
  365.         {
  366.             throw new NotSupportedException();
  367.         }
  368.         #endregion
  369.     }
  370. }

Developer Fusion