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

  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 MethodOnTypeBuilderInstantiation : MethodInfo
  23.     {
  24.         #region Private Static Members
  25.         static internal MethodInfo GetMethod(MethodInfo method, TypeBuilderInstantiation type)
  26.         {
  27.             return new MethodOnTypeBuilderInstantiation(method, type);
  28.         }
  29.         #endregion
  30.        
  31.         #region Private Data Mebers
  32.         internal MethodInfo m_method;
  33.         private TypeBuilderInstantiation m_type;
  34.         #endregion
  35.        
  36.         #region Constructor
  37.         internal MethodOnTypeBuilderInstantiation(MethodInfo method, TypeBuilderInstantiation type)
  38.         {
  39.             m_method = method;
  40.             m_type = type;
  41.         }
  42.         #endregion
  43.        
  44.         internal override Type[] GetParameterTypes()
  45.         {
  46.             return m_method.GetParameterTypes();
  47.         }
  48.        
  49.         #region MemberInfo Overrides
  50.         public override MemberTypes MemberType {
  51.             get { return m_method.MemberType; }
  52.         }
  53.         public override string Name {
  54.             get { return m_method.Name; }
  55.         }
  56.         public override Type DeclaringType {
  57.             get { return m_type; }
  58.         }
  59.         public override Type ReflectedType {
  60.             get { return m_type; }
  61.         }
  62.         public override object[] GetCustomAttributes(bool inherit)
  63.         {
  64.             return m_method.GetCustomAttributes(inherit);
  65.         }
  66.         public override object[] GetCustomAttributes(Type attributeType, bool inherit)
  67.         {
  68.             return m_method.GetCustomAttributes(attributeType, inherit);
  69.         }
  70.         public override bool IsDefined(Type attributeType, bool inherit)
  71.         {
  72.             return m_method.IsDefined(attributeType, inherit);
  73.         }
  74.         internal override int MetadataTokenInternal {
  75.             get { return m_method.MetadataTokenInternal; }
  76.         }
  77.         public override Module Module {
  78.             get { return m_method.Module; }
  79.         }
  80.         public new Type GetType()
  81.         {
  82.             return base.GetType();
  83.         }
  84.         #endregion
  85.        
  86.         #region MethodBase Members
  87.         public override ParameterInfo[] GetParameters()
  88.         {
  89.             return m_method.GetParameters();
  90.         }
  91.         public override MethodImplAttributes GetMethodImplementationFlags()
  92.         {
  93.             return m_method.GetMethodImplementationFlags();
  94.         }
  95.         public override RuntimeMethodHandle MethodHandle {
  96.             get { return m_method.MethodHandle; }
  97.         }
  98.         public override MethodAttributes Attributes {
  99.             get { return m_method.Attributes; }
  100.         }
  101.         public override object Invoke(object obj, BindingFlags invokeAttr, Binder binder, object[] parameters, CultureInfo culture)
  102.         {
  103.             throw new NotSupportedException();
  104.         }
  105.         public override CallingConventions CallingConvention {
  106.             get { return m_method.CallingConvention; }
  107.         }
  108.         public override Type[] GetGenericArguments()
  109.         {
  110.             return m_method.GetGenericArguments();
  111.         }
  112.         public override MethodInfo GetGenericMethodDefinition()
  113.         {
  114.             return m_method;
  115.         }
  116.         public override bool IsGenericMethodDefinition {
  117.             get { return m_method.IsGenericMethodDefinition; }
  118.         }
  119.         public override bool ContainsGenericParameters {
  120.             get { return m_method.ContainsGenericParameters; }
  121.         }
  122.         public override MethodInfo MakeGenericMethod(params Type[] typeArgs)
  123.         {
  124.             if (!IsGenericMethodDefinition)
  125.                 throw new InvalidOperationException(Environment.GetResourceString("Arg_NotGenericMethodDefinition"));
  126.            
  127.             return MethodBuilderInstantiation.MakeGenericMethod(this, typeArgs);
  128.         }
  129.        
  130.         public override bool IsGenericMethod {
  131.             get { return m_method.IsGenericMethod; }
  132.         }
  133.        
  134.         #endregion
  135.        
  136.         #region Public Abstract\Virtual Members
  137.         internal override Type GetReturnType()
  138.         {
  139.             return m_method.GetReturnType();
  140.         }
  141.         public override ParameterInfo ReturnParameter {
  142.             get {
  143.                 throw new NotSupportedException();
  144.             }
  145.         }
  146.         public override ICustomAttributeProvider ReturnTypeCustomAttributes {
  147.             get {
  148.                 throw new NotSupportedException();
  149.             }
  150.         }
  151.         public override MethodInfo GetBaseDefinition()
  152.         {
  153.             throw new NotSupportedException();
  154.         }
  155.         #endregion
  156.     }
  157.    
  158.     internal sealed class ConstructorOnTypeBuilderInstantiation : ConstructorInfo
  159.     {
  160.         #region Private Static Members
  161.         static internal ConstructorInfo GetConstructor(ConstructorInfo Constructor, TypeBuilderInstantiation type)
  162.         {
  163.             return new ConstructorOnTypeBuilderInstantiation(Constructor, type);
  164.         }
  165.         #endregion
  166.        
  167.         #region Private Data Mebers
  168.         internal ConstructorInfo m_ctor;
  169.         private TypeBuilderInstantiation m_type;
  170.         #endregion
  171.        
  172.         #region Constructor
  173.         internal ConstructorOnTypeBuilderInstantiation(ConstructorInfo constructor, TypeBuilderInstantiation type)
  174.         {
  175.             m_ctor = constructor;
  176.             m_type = type;
  177.         }
  178.         #endregion
  179.        
  180.         internal override Type[] GetParameterTypes()
  181.         {
  182.             return m_ctor.GetParameterTypes();
  183.         }
  184.        
  185.         #region MemberInfo Overrides
  186.         public override MemberTypes MemberType {
  187.             get { return m_ctor.MemberType; }
  188.         }
  189.         public override string Name {
  190.             get { return m_ctor.Name; }
  191.         }
  192.         public override Type DeclaringType {
  193.             get { return m_type; }
  194.         }
  195.         public override Type ReflectedType {
  196.             get { return m_type; }
  197.         }
  198.         public override object[] GetCustomAttributes(bool inherit)
  199.         {
  200.             return m_ctor.GetCustomAttributes(inherit);
  201.         }
  202.         public override object[] GetCustomAttributes(Type attributeType, bool inherit)
  203.         {
  204.             return m_ctor.GetCustomAttributes(attributeType, inherit);
  205.         }
  206.         public override bool IsDefined(Type attributeType, bool inherit)
  207.         {
  208.             return m_ctor.IsDefined(attributeType, inherit);
  209.         }
  210.         internal override int MetadataTokenInternal {
  211.             get {
  212.                 throw new NotSupportedException();
  213.             }
  214.         }
  215.         public override Module Module {
  216.             get { return m_ctor.Module; }
  217.         }
  218.         public new Type GetType()
  219.         {
  220.             return base.GetType();
  221.         }
  222.         #endregion
  223.        
  224.         #region MethodBase Members
  225.         public override ParameterInfo[] GetParameters()
  226.         {
  227.             return m_ctor.GetParameters();
  228.         }
  229.         public override MethodImplAttributes GetMethodImplementationFlags()
  230.         {
  231.             return m_ctor.GetMethodImplementationFlags();
  232.         }
  233.         public override RuntimeMethodHandle MethodHandle {
  234.             get { return m_ctor.MethodHandle; }
  235.         }
  236.         public override MethodAttributes Attributes {
  237.             get { return m_ctor.Attributes; }
  238.         }
  239.         public override object Invoke(object obj, BindingFlags invokeAttr, Binder binder, object[] parameters, CultureInfo culture)
  240.         {
  241.             throw new NotSupportedException();
  242.         }
  243.         public override CallingConventions CallingConvention {
  244.             get { return m_ctor.CallingConvention; }
  245.         }
  246.         public override Type[] GetGenericArguments()
  247.         {
  248.             return m_ctor.GetGenericArguments();
  249.         }
  250.         public override bool IsGenericMethodDefinition {
  251.             get { return false; }
  252.         }
  253.         public override bool ContainsGenericParameters {
  254.             get { return false; }
  255.         }
  256.        
  257.         public override bool IsGenericMethod {
  258.             get { return false; }
  259.         }
  260.         #endregion
  261.        
  262.         #region ConstructorInfo Members
  263.         public override object Invoke(BindingFlags invokeAttr, Binder binder, object[] parameters, CultureInfo culture)
  264.         {
  265.             throw new InvalidOperationException();
  266.         }
  267.         #endregion
  268.     }
  269.    
  270.     internal sealed class FieldOnTypeBuilderInstantiation : FieldInfo
  271.     {
  272.         #region Private Static Members
  273.         private static Hashtable m_hashtable = new Hashtable();
  274.         private struct Entry
  275.         {
  276.             public Entry(FieldInfo Field, TypeBuilderInstantiation type)
  277.             {
  278.                 m_field = Field;
  279.                 m_type = type;
  280.             }
  281.            
  282.             public FieldInfo m_field;
  283.             public TypeBuilderInstantiation m_type;
  284.            
  285.             public override int GetHashCode()
  286.             {
  287.                 return m_field.GetHashCode();
  288.             }
  289.            
  290.             public override bool Equals(object o)
  291.             {
  292.                 if (o is Entry)
  293.                     return Equals((Entry)o);
  294.                 else
  295.                     return false;
  296.             }
  297.            
  298.             public bool Equals(Entry obj)
  299.             {
  300.                 return obj.m_field == m_field && obj.m_type == m_type;
  301.             }
  302.         }
  303.         static internal FieldInfo GetField(FieldInfo Field, TypeBuilderInstantiation type)
  304.         {
  305.             Entry entry = new Entry(Field, type);
  306.            
  307.             if (m_hashtable.Contains(entry))
  308.                 return m_hashtable[entry] as FieldInfo;
  309.            
  310.             FieldInfo m = new FieldOnTypeBuilderInstantiation(Field, type);
  311.            
  312.             m_hashtable[entry] = m;
  313.             return m;
  314.         }
  315.         #endregion
  316.        
  317.         #region Private Data Members
  318.         private FieldInfo m_field;
  319.         private TypeBuilderInstantiation m_type;
  320.         #endregion
  321.        
  322.         #region Constructor
  323.         internal FieldOnTypeBuilderInstantiation(FieldInfo field, TypeBuilderInstantiation type)
  324.         {
  325.             m_field = field;
  326.             m_type = type;
  327.         }
  328.         #endregion
  329.        
  330.         internal FieldInfo FieldInfo {
  331.             get { return m_field; }
  332.         }
  333.        
  334.         #region MemberInfo Overrides
  335.         public override MemberTypes MemberType {
  336.             get { return System.Reflection.MemberTypes.Field; }
  337.         }
  338.         public override string Name {
  339.             get { return m_field.Name; }
  340.         }
  341.         public override Type DeclaringType {
  342.             get { return m_type; }
  343.         }
  344.         public override Type ReflectedType {
  345.             get { return m_type; }
  346.         }
  347.         public override object[] GetCustomAttributes(bool inherit)
  348.         {
  349.             return m_field.GetCustomAttributes(inherit);
  350.         }
  351.         public override object[] GetCustomAttributes(Type attributeType, bool inherit)
  352.         {
  353.             return m_field.GetCustomAttributes(attributeType, inherit);
  354.         }
  355.         public override bool IsDefined(Type attributeType, bool inherit)
  356.         {
  357.             return m_field.IsDefined(attributeType, inherit);
  358.         }
  359.         internal override int MetadataTokenInternal {
  360.             get {
  361.                 throw new NotImplementedException();
  362.             }
  363.         }
  364.         public override Module Module {
  365.             get { return m_field.Module; }
  366.         }
  367.         public new Type GetType()
  368.         {
  369.             return base.GetType();
  370.         }
  371.         #endregion
  372.        
  373.         #region Public Abstract\Virtual Members
  374.         public override Type[] GetRequiredCustomModifiers()
  375.         {
  376.             return m_field.GetRequiredCustomModifiers();
  377.         }
  378.         public override Type[] GetOptionalCustomModifiers()
  379.         {
  380.             return m_field.GetOptionalCustomModifiers();
  381.         }
  382.         public override void SetValueDirect(TypedReference obj, object value)
  383.         {
  384.             throw new NotImplementedException();
  385.         }
  386.         public override object GetValueDirect(TypedReference obj)
  387.         {
  388.             throw new NotImplementedException();
  389.         }
  390.         public override RuntimeFieldHandle FieldHandle {
  391.             get {
  392.                 throw new NotImplementedException();
  393.             }
  394.         }
  395.         public override Type FieldType {
  396.             get {
  397.                 throw new NotImplementedException();
  398.             }
  399.         }
  400.         public override object GetValue(object obj)
  401.         {
  402.             throw new InvalidOperationException();
  403.         }
  404.         public override void SetValue(object obj, object value, BindingFlags invokeAttr, Binder binder, CultureInfo culture)
  405.         {
  406.             throw new InvalidOperationException();
  407.         }
  408.         public override FieldAttributes Attributes {
  409.             get { return m_field.Attributes; }
  410.         }
  411.         #endregion
  412.     }
  413. }

Developer Fusion