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 \ CustomAttributeBuilder

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. /*============================================================
  16. **
  17. ** Class:  CustomAttrbuteBuilder
  18. **
  19. **
  20. ** CustomAttributeBuilder is a helper class to help building custom attribute.
  21. **
  22. **
  23. ===========================================================*/
  24. namespace System.Reflection.Emit
  25. {
  26.    
  27.    
  28.     using System;
  29.     using System.Reflection;
  30.     using System.Reflection.Emit;
  31.     using System.IO;
  32.     using System.Text;
  33.     using System.Security.Permissions;
  34.     using System.Runtime.InteropServices;
  35.     using System.Globalization;
  36.    
  37.     [HostProtection(MayLeakOnAbort = true)]
  38.     [ClassInterface(ClassInterfaceType.None)]
  39.     [ComDefaultInterface(typeof(_CustomAttributeBuilder))]
  40.     [System.Runtime.InteropServices.ComVisible(true)]
  41.     public class CustomAttributeBuilder : _CustomAttributeBuilder
  42.     {
  43.         // public constructor to form the custom attribute with constructor and constructor
  44.         // parameters.
  45.         public CustomAttributeBuilder(ConstructorInfo con, object[] constructorArgs)
  46.         {
  47.             InitCustomAttributeBuilder(con, constructorArgs, new PropertyInfo[] {}, new object[] {}, new FieldInfo[] {}, new object[] {});
  48.         }
  49.        
  50.         // public constructor to form the custom attribute with constructor, constructor
  51.         // parameters and named properties.
  52.         public CustomAttributeBuilder(ConstructorInfo con, object[] constructorArgs, PropertyInfo[] namedProperties, object[] propertyValues)
  53.         {
  54.             InitCustomAttributeBuilder(con, constructorArgs, namedProperties, propertyValues, new FieldInfo[] {}, new object[] {});
  55.         }
  56.        
  57.         // public constructor to form the custom attribute with constructor and constructor
  58.         // parameters.
  59.         public CustomAttributeBuilder(ConstructorInfo con, object[] constructorArgs, FieldInfo[] namedFields, object[] fieldValues)
  60.         {
  61.             InitCustomAttributeBuilder(con, constructorArgs, new PropertyInfo[] {}, new object[] {}, namedFields, fieldValues);
  62.         }
  63.        
  64.         // public constructor to form the custom attribute with constructor and constructor
  65.         // parameters.
  66.         public CustomAttributeBuilder(ConstructorInfo con, object[] constructorArgs, PropertyInfo[] namedProperties, object[] propertyValues, FieldInfo[] namedFields, object[] fieldValues)
  67.         {
  68.             InitCustomAttributeBuilder(con, constructorArgs, namedProperties, propertyValues, namedFields, fieldValues);
  69.         }
  70.        
  71.         private const byte SERIALIZATION_TYPE_BOOLEAN = SignatureHelper.ELEMENT_TYPE_BOOLEAN;
  72.         private const byte SERIALIZATION_TYPE_CHAR = SignatureHelper.ELEMENT_TYPE_CHAR;
  73.         private const byte SERIALIZATION_TYPE_I1 = SignatureHelper.ELEMENT_TYPE_I1;
  74.         private const byte SERIALIZATION_TYPE_U1 = SignatureHelper.ELEMENT_TYPE_U1;
  75.         private const byte SERIALIZATION_TYPE_I2 = SignatureHelper.ELEMENT_TYPE_I2;
  76.         private const byte SERIALIZATION_TYPE_U2 = SignatureHelper.ELEMENT_TYPE_U2;
  77.         private const byte SERIALIZATION_TYPE_I4 = SignatureHelper.ELEMENT_TYPE_I4;
  78.         private const byte SERIALIZATION_TYPE_U4 = SignatureHelper.ELEMENT_TYPE_U4;
  79.         private const byte SERIALIZATION_TYPE_I8 = SignatureHelper.ELEMENT_TYPE_I8;
  80.         private const byte SERIALIZATION_TYPE_U8 = SignatureHelper.ELEMENT_TYPE_U8;
  81.         private const byte SERIALIZATION_TYPE_R4 = SignatureHelper.ELEMENT_TYPE_R4;
  82.         private const byte SERIALIZATION_TYPE_R8 = SignatureHelper.ELEMENT_TYPE_R8;
  83.         private const byte SERIALIZATION_TYPE_STRING = SignatureHelper.ELEMENT_TYPE_STRING;
  84.         private const byte SERIALIZATION_TYPE_SZARRAY = SignatureHelper.ELEMENT_TYPE_SZARRAY;
  85.         private const byte SERIALIZATION_TYPE_TYPE = 80;
  86.         private const byte SERIALIZATION_TYPE_TAGGED_OBJECT = 81;
  87.         private const byte SERIALIZATION_TYPE_FIELD = 83;
  88.         private const byte SERIALIZATION_TYPE_PROPERTY = 84;
  89.         private const byte SERIALIZATION_TYPE_ENUM = 85;
  90.        
  91.         // Check that a type is suitable for use in a custom attribute.
  92.         private bool ValidateType(Type t)
  93.         {
  94.             if (t.IsPrimitive || t == typeof(string) || t == typeof(Type))
  95.                 return true;
  96.             if (t.IsEnum) {
  97.                 switch (Type.GetTypeCode(Enum.GetUnderlyingType(t))) {
  98.                     case TypeCode.SByte:
  99.                     case TypeCode.Byte:
  100.                     case TypeCode.Int16:
  101.                     case TypeCode.UInt16:
  102.                     case TypeCode.Int32:
  103.                     case TypeCode.UInt32:
  104.                     case TypeCode.Int64:
  105.                     case TypeCode.UInt64:
  106.                         return true;
  107.                     default:
  108.                         return false;
  109.                 }
  110.             }
  111.             if (t.IsArray) {
  112.                 if (t.GetArrayRank() != 1)
  113.                     return false;
  114.                 return ValidateType(t.GetElementType());
  115.             }
  116.             return t == typeof(object);
  117.         }
  118.        
  119.         internal void InitCustomAttributeBuilder(ConstructorInfo con, object[] constructorArgs, PropertyInfo[] namedProperties, object[] propertyValues, FieldInfo[] namedFields, object[] fieldValues)
  120.         {
  121.             if (con == null)
  122.                 throw new ArgumentNullException("con");
  123.             if (constructorArgs == null)
  124.                 throw new ArgumentNullException("constructorArgs");
  125.             if (namedProperties == null)
  126.                 throw new ArgumentNullException("constructorArgs");
  127.             if (propertyValues == null)
  128.                 throw new ArgumentNullException("propertyValues");
  129.             if (namedFields == null)
  130.                 throw new ArgumentNullException("namedFields");
  131.             if (fieldValues == null)
  132.                 throw new ArgumentNullException("fieldValues");
  133.             if (namedProperties.Length != propertyValues.Length)
  134.                 throw new ArgumentException(Environment.GetResourceString("Arg_ArrayLengthsDiffer"), "namedProperties, propertyValues");
  135.             if (namedFields.Length != fieldValues.Length)
  136.                 throw new ArgumentException(Environment.GetResourceString("Arg_ArrayLengthsDiffer"), "namedFields, fieldValues");
  137.            
  138.             if ((con.Attributes & MethodAttributes.Static) == MethodAttributes.Static || (con.Attributes & MethodAttributes.MemberAccessMask) == MethodAttributes.Private)
  139.                 throw new ArgumentException(Environment.GetResourceString("Argument_BadConstructor"));
  140.            
  141.             if ((con.CallingConvention & CallingConventions.Standard) != CallingConventions.Standard)
  142.                 throw new ArgumentException(Environment.GetResourceString("Argument_BadConstructorCallConv"));
  143.            
  144.             // Cache information used elsewhere.
  145.             m_con = con;
  146.             m_constructorArgs = new object[constructorArgs.Length];
  147.             Array.Copy(constructorArgs, m_constructorArgs, constructorArgs.Length);
  148.            
  149.             Type[] paramTypes;
  150.             int i;
  151.            
  152.             // Get the types of the constructor's formal parameters.
  153.             if (con is ConstructorBuilder) {
  154.                 paramTypes = ((ConstructorBuilder)con).GetParameterTypes();
  155.             }
  156.             else {
  157.                 ParameterInfo[] paramInfos = con.GetParametersNoCopy();
  158.                 paramTypes = new Type[paramInfos.Length];
  159.                 for (i = 0; i < paramInfos.Length; i++)
  160.                     paramTypes[i] = paramInfos[i].ParameterType;
  161.             }
  162.            
  163.             // Since we're guaranteed a non-var calling convention, the number of arguments must equal the number of parameters.
  164.             if (paramTypes.Length != constructorArgs.Length)
  165.                 throw new ArgumentException(Environment.GetResourceString("Argument_BadParameterCountsForConstructor"));
  166.            
  167.             // Verify that the constructor has a valid signature (custom attributes only support a subset of our type system).
  168.             for (i = 0; i < paramTypes.Length; i++)
  169.                 if (!ValidateType(paramTypes[i]))
  170.                     throw new ArgumentException(Environment.GetResourceString("Argument_BadTypeInCustomAttribute"));
  172.            
  173.             // Now verify that the types of the actual parameters are compatible with the types of the formal parameters.
  174.             for (i = 0; i < paramTypes.Length; i++) {
  175.                 if (constructorArgs[i] == null)
  176.                     continue;
  177.                 TypeCode paramTC = Type.GetTypeCode(paramTypes[i]);
  178.                 if (paramTC != Type.GetTypeCode(constructorArgs[i].GetType()))
  179.                     if (paramTC != TypeCode.Object || !ValidateType(constructorArgs[i].GetType()))
  180.                         throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_BadParameterTypeForConstructor"), i));
  182.             }
  183.            
  184.             // Allocate a memory stream to represent the CA blob in the metadata and a binary writer to help format it.
  185.             MemoryStream stream = new MemoryStream();
  186.             BinaryWriter writer = new BinaryWriter(stream);
  187.            
  188.             // Write the blob protocol version (currently 1).
  189.             writer.Write((ushort)1);
  190.            
  191.             // Now emit the constructor argument values (no need for types, they're inferred from the constructor signature).
  192.             for (i = 0; i < constructorArgs.Length; i++)
  193.                 EmitValue(writer, paramTypes[i], constructorArgs[i]);
  194.            
  195.             // Next a short with the count of properties and fields.
  196.             writer.Write((ushort)(namedProperties.Length + namedFields.Length));
  197.            
  198.             // Emit all the property sets.
  199.             for (i = 0; i < namedProperties.Length; i++) {
  200.                 // Validate the property.
  201.                 if (namedProperties[i] == null)
  202.                     throw new ArgumentNullException("namedProperties[" + i + "]");
  203.                
  204.                 // Allow null for non-primitive types only.
  205.                 Type propType = namedProperties[i].PropertyType;
  206.                 if (propertyValues[i] == null && propType.IsPrimitive)
  207.                     throw new ArgumentNullException("propertyValues[" + i + "]");
  208.                
  209.                 // Validate property type.
  210.                 if (!ValidateType(propType))
  211.                     throw new ArgumentException(Environment.GetResourceString("Argument_BadTypeInCustomAttribute"));
  212.                
  213.                 // Property has to be writable.
  214.                 if (!namedProperties[i].CanWrite)
  215.                     throw new ArgumentException(Environment.GetResourceString("Argument_NotAWritableProperty"));
  216.                
  217.                 // Property has to be from the same class or base class as ConstructorInfo.
  218.                 if (namedProperties[i].DeclaringType != con.DeclaringType && (!(con.DeclaringType is TypeBuilderInstantiation)) && !con.DeclaringType.IsSubclassOf(namedProperties[i].DeclaringType)) {
  219.                     // Might have failed check because one type is a XXXBuilder
  220.                     // and the other is not. Deal with these special cases
  221.                     // separately.
  222.                     if (!TypeBuilder.IsTypeEqual(namedProperties[i].DeclaringType, con.DeclaringType)) {
  223.                         // IsSubclassOf is overloaded to do the right thing if
  224.                         // the constructor is a TypeBuilder, but we still need
  225.                         // to deal with the case where the property's declaring
  226.                         // type is one.
  227.                         if (!(namedProperties[i].DeclaringType is TypeBuilder) || !con.DeclaringType.IsSubclassOf(((TypeBuilder)namedProperties[i].DeclaringType).m_runtimeType))
  228.                             throw new ArgumentException(Environment.GetResourceString("Argument_BadPropertyForConstructorBuilder"));
  229.                     }
  230.                 }
  231.                
  232.                 // Make sure the property's type can take the given value.
  233.                 // Note that there will be no coersion.
  234.                 if (propertyValues[i] != null && propType != typeof(object) && Type.GetTypeCode(propertyValues[i].GetType()) != Type.GetTypeCode(propType))
  235.                     throw new ArgumentException(Environment.GetResourceString("Argument_ConstantDoesntMatch"));
  236.                
  237.                 // First a byte indicating that this is a property.
  238.                 writer.Write(SERIALIZATION_TYPE_PROPERTY);
  239.                
  240.                 // Emit the property type, name and value.
  241.                 EmitType(writer, propType);
  242.                 EmitString(writer, namedProperties[i].Name);
  243.                 EmitValue(writer, propType, propertyValues[i]);
  244.             }
  245.            
  246.             // Emit all the field sets.
  247.             for (i = 0; i < namedFields.Length; i++) {
  248.                 // Validate the field.
  249.                 if (namedFields[i] == null)
  250.                     throw new ArgumentNullException("namedFields[" + i + "]");
  251.                
  252.                 // Allow null for non-primitive types only.
  253.                 Type fldType = namedFields[i].FieldType;
  254.                 if (fieldValues[i] == null && fldType.IsPrimitive)
  255.                     throw new ArgumentNullException("fieldValues[" + i + "]");
  256.                
  257.                 // Validate field type.
  258.                 if (!ValidateType(fldType))
  259.                     throw new ArgumentException(Environment.GetResourceString("Argument_BadTypeInCustomAttribute"));
  260.                
  261.                 // Field has to be from the same class or base class as ConstructorInfo.
  262.                 if (namedFields[i].DeclaringType != con.DeclaringType && (!(con.DeclaringType is TypeBuilderInstantiation)) && !con.DeclaringType.IsSubclassOf(namedFields[i].DeclaringType)) {
  263.                     // Might have failed check because one type is a XXXBuilder
  264.                     // and the other is not. Deal with these special cases
  265.                     // separately.
  266.                     if (!TypeBuilder.IsTypeEqual(namedFields[i].DeclaringType, con.DeclaringType)) {
  267.                         // IsSubclassOf is overloaded to do the right thing if
  268.                         // the constructor is a TypeBuilder, but we still need
  269.                         // to deal with the case where the field's declaring
  270.                         // type is one.
  271.                         if (!(namedFields[i].DeclaringType is TypeBuilder) || !con.DeclaringType.IsSubclassOf(((TypeBuilder)namedFields[i].DeclaringType).m_runtimeType))
  272.                             throw new ArgumentException(Environment.GetResourceString("Argument_BadFieldForConstructorBuilder"));
  273.                     }
  274.                 }
  275.                
  276.                 // Make sure the field's type can take the given value.
  277.                 // Note that there will be no coersion.
  278.                 if (fieldValues[i] != null && fldType != typeof(object) && Type.GetTypeCode(fieldValues[i].GetType()) != Type.GetTypeCode(fldType))
  279.                     throw new ArgumentException(Environment.GetResourceString("Argument_ConstantDoesntMatch"));
  280.                
  281.                 // First a byte indicating that this is a field.
  282.                 writer.Write(SERIALIZATION_TYPE_FIELD);
  283.                
  284.                 // Emit the field type, name and value.
  285.                 EmitType(writer, fldType);
  286.                 EmitString(writer, namedFields[i].Name);
  287.                 EmitValue(writer, fldType, fieldValues[i]);
  288.             }
  289.            
  290.             // Create the blob array.
  291.             m_blob = ((MemoryStream)writer.BaseStream).ToArray();
  292.         }
  293.        
  294.         private void EmitType(BinaryWriter writer, Type type)
  295.         {
  296.             if (type.IsPrimitive) {
  297.                 switch (Type.GetTypeCode(type)) {
  298.                     case TypeCode.SByte:
  299.                         writer.Write(SERIALIZATION_TYPE_I1);
  300.                         break;
  301.                     case TypeCode.Byte:
  302.                         writer.Write(SERIALIZATION_TYPE_U1);
  303.                         break;
  304.                     case TypeCode.Char:
  305.                         writer.Write(SERIALIZATION_TYPE_CHAR);
  306.                         break;
  307.                     case TypeCode.Boolean:
  308.                         writer.Write(SERIALIZATION_TYPE_BOOLEAN);
  309.                         break;
  310.                     case TypeCode.Int16:
  311.                         writer.Write(SERIALIZATION_TYPE_I2);
  312.                         break;
  313.                     case TypeCode.UInt16:
  314.                         writer.Write(SERIALIZATION_TYPE_U2);
  315.                         break;
  316.                     case TypeCode.Int32:
  317.                         writer.Write(SERIALIZATION_TYPE_I4);
  318.                         break;
  319.                     case TypeCode.UInt32:
  320.                         writer.Write(SERIALIZATION_TYPE_U4);
  321.                         break;
  322.                     case TypeCode.Int64:
  323.                         writer.Write(SERIALIZATION_TYPE_I8);
  324.                         break;
  325.                     case TypeCode.UInt64:
  326.                         writer.Write(SERIALIZATION_TYPE_U8);
  327.                         break;
  328.                     case TypeCode.Single:
  329.                         writer.Write(SERIALIZATION_TYPE_R4);
  330.                         break;
  331.                     case TypeCode.Double:
  332.                         writer.Write(SERIALIZATION_TYPE_R8);
  333.                         break;
  334.                     default:
  335.                         BCLDebug.Assert(false, "Invalid primitive type");
  336.                         break;
  337.                 }
  338.             }
  339.             else if (type.IsEnum) {
  340.                 writer.Write(SERIALIZATION_TYPE_ENUM);
  341.                 EmitString(writer, type.AssemblyQualifiedName);
  342.             }
  343.             else if (type == typeof(string)) {
  344.                 writer.Write(SERIALIZATION_TYPE_STRING);
  345.             }
  346.             else if (type == typeof(Type)) {
  347.                 writer.Write(SERIALIZATION_TYPE_TYPE);
  348.             }
  349.             else if (type.IsArray) {
  350.                 writer.Write(SERIALIZATION_TYPE_SZARRAY);
  351.                 EmitType(writer, type.GetElementType());
  352.             }
  353.             else {
  354.                 // Tagged object case.
  355.                 writer.Write(SERIALIZATION_TYPE_TAGGED_OBJECT);
  356.             }
  357.         }
  358.        
  359.         private void EmitString(BinaryWriter writer, string str)
  360.         {
  361.             // Strings are emitted with a length prefix in a compressed format (1, 2 or 4 bytes) as used internally by metadata.
  362.             byte[] utf8Str = Encoding.UTF8.GetBytes(str);
  363.             uint length = (uint)utf8Str.Length;
  364.             if (length <= 127) {
  365.                 writer.Write((byte)length);
  366.             }
  367.             else if (length <= 16383) {
  368.                 writer.Write((byte)((length >> 8) | 128));
  369.                 writer.Write((byte)(length & 255));
  370.             }
  371.             else {
  372.                 writer.Write((byte)((length >> 24) | 192));
  373.                 writer.Write((byte)((length >> 16) & 255));
  374.                 writer.Write((byte)((length >> 8) & 255));
  375.                 writer.Write((byte)(length & 255));
  376.             }
  377.             writer.Write(utf8Str);
  378.         }
  379.        
  380.         private void EmitValue(BinaryWriter writer, Type type, object value)
  381.         {
  382.             if (type.IsEnum) {
  383.                 switch (Type.GetTypeCode(Enum.GetUnderlyingType(type))) {
  384.                     case TypeCode.SByte:
  385.                         writer.Write((sbyte)value);
  386.                         break;
  387.                     case TypeCode.Byte:
  388.                         writer.Write((byte)value);
  389.                         break;
  390.                     case TypeCode.Int16:
  391.                         writer.Write((short)value);
  392.                         break;
  393.                     case TypeCode.UInt16:
  394.                         writer.Write((ushort)value);
  395.                         break;
  396.                     case TypeCode.Int32:
  397.                         writer.Write((int)value);
  398.                         break;
  399.                     case TypeCode.UInt32:
  400.                         writer.Write((uint)value);
  401.                         break;
  402.                     case TypeCode.Int64:
  403.                         writer.Write((long)value);
  404.                         break;
  405.                     case TypeCode.UInt64:
  406.                         writer.Write((ulong)value);
  407.                         break;
  408.                     default:
  409.                         BCLDebug.Assert(false, "Invalid enum base type");
  410.                         break;
  411.                 }
  412.             }
  413.             else if (type == typeof(string)) {
  414.                 if (value == null)
  415.                     writer.Write((byte)255);
  416.                 else
  417.                     EmitString(writer, (string)value);
  418.             }
  419.             else if (type == typeof(Type)) {
  420.                 if (value == null)
  421.                     writer.Write((byte)255);
  422.                 else {
  423.                     string typeName = TypeNameBuilder.ToString((Type)value, TypeNameBuilder.Format.AssemblyQualifiedName);
  424.                     if (typeName == null)
  425.                         throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_InvalidTypeForCA"), value.GetType()));
  426.                     EmitString(writer, typeName);
  427.                 }
  428.             }
  429.             else if (type.IsArray) {
  430.                 if (value == null)
  431.                     writer.Write((uint)4294967295u);
  432.                 else {
  433.                     Array a = (Array)value;
  434.                     Type et = type.GetElementType();
  435.                     writer.Write(a.Length);
  436.                     for (int i = 0; i < a.Length; i++)
  437.                         EmitValue(writer, et, a.GetValue(i));
  438.                 }
  439.             }
  440.             else if (type.IsPrimitive) {
  441.                 switch (Type.GetTypeCode(type)) {
  442.                     case TypeCode.SByte:
  443.                         writer.Write((sbyte)value);
  444.                         break;
  445.                     case TypeCode.Byte:
  446.                         writer.Write((byte)value);
  447.                         break;
  448.                     case TypeCode.Char:
  449.                         writer.Write(Convert.ToInt16((char)value));
  450.                         break;
  451.                     case TypeCode.Boolean:
  452.                         writer.Write((byte)((bool)value ? 1 : 0));
  453.                         break;
  454.                     case TypeCode.Int16:
  455.                         writer.Write((short)value);
  456.                         break;
  457.                     case TypeCode.UInt16:
  458.                         writer.Write((ushort)value);
  459.                         break;
  460.                     case TypeCode.Int32:
  461.                         writer.Write((int)value);
  462.                         break;
  463.                     case TypeCode.UInt32:
  464.                         writer.Write((uint)value);
  465.                         break;
  466.                     case TypeCode.Int64:
  467.                         writer.Write((long)value);
  468.                         break;
  469.                     case TypeCode.UInt64:
  470.                         writer.Write((ulong)value);
  471.                         break;
  472.                     case TypeCode.Single:
  473.                         writer.Write((float)value);
  474.                         break;
  475.                     case TypeCode.Double:
  476.                         writer.Write((double)value);
  477.                         break;
  478.                     default:
  479.                         BCLDebug.Assert(false, "Invalid primitive type");
  480.                         break;
  481.                 }
  482.             }
  483.             else if (type == typeof(object)) {
  484.                 // Tagged object case. Type instances aren't actually Type, they're some subclass (such as RuntimeType or
  485.                 // TypeBuilder), so we need to canonicalize this case back to Type. If we have a null value we follow the convention
  486.                 // used by C# and emit a null typed as a string (it doesn't really matter what type we pick as long as it's a
  487.                 // reference type).
  488.                 Type ot = value == null ? typeof(string) : value is Type ? typeof(Type) : value.GetType();
  489.                 EmitType(writer, ot);
  490.                 EmitValue(writer, ot, value);
  491.             }
  492.             else {
  493.                 string typename = "null";
  494.                
  495.                 if (value != null)
  496.                     typename = value.GetType().ToString();
  497.                
  498.                 throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Argument_BadParameterTypeForCAB"), typename));
  499.             }
  500.         }
  501.        
  502.        
  503.        
  504.        
  505.         // return the byte interpretation of the custom attribute
  506.         internal void CreateCustomAttribute(ModuleBuilder mod, int tkOwner)
  507.         {
  508.             CreateCustomAttribute(mod, tkOwner, mod.GetConstructorToken(m_con).Token, false);
  509.         }
  510.        
  511.         //*************************************************
  512.         // Upon saving to disk, we need to create the memberRef token for the custom attribute's type
  513.         // first of all. So when we snap the in-memory module for on disk, this token will be there.
  514.         // We also need to enforce the use of MemberRef. Because MemberDef token might move.
  515.         // This function has to be called before we snap the in-memory module for on disk (i.e. Presave on
  516.         // ModuleBuilder.
  517.         //*************************************************
  518.         internal int PrepareCreateCustomAttributeToDisk(ModuleBuilder mod)
  519.         {
  520.             return mod.InternalGetConstructorToken(m_con, true).Token;
  521.         }
  522.        
  523.         //*************************************************
  524.         // Call this function with toDisk=1, after on disk module has been snapped.
  525.         //*************************************************
  526.         internal void CreateCustomAttribute(ModuleBuilder mod, int tkOwner, int tkAttrib, bool toDisk)
  527.         {
  528.             TypeBuilder.InternalCreateCustomAttribute(tkOwner, tkAttrib, m_blob, mod, toDisk, typeof(System.Diagnostics.DebuggableAttribute) == m_con.DeclaringType);
  529.         }
  530.        
  531.         void _CustomAttributeBuilder.GetTypeInfoCount(out uint pcTInfo)
  532.         {
  533.             throw new NotImplementedException();
  534.         }
  535.        
  536.         void _CustomAttributeBuilder.GetTypeInfo(uint iTInfo, uint lcid, IntPtr ppTInfo)
  537.         {
  538.             throw new NotImplementedException();
  539.         }
  540.        
  541.         void _CustomAttributeBuilder.GetIDsOfNames(        [In()]
  542. ref Guid riid, IntPtr rgszNames, uint cNames, uint lcid, IntPtr rgDispId)
  543.         {
  544.             throw new NotImplementedException();
  545.         }
  546.        
  547.         void _CustomAttributeBuilder.Invoke(uint dispIdMember,         [In()]
  548. ref Guid riid, uint lcid, short wFlags, IntPtr pDispParams, IntPtr pVarResult, IntPtr pExcepInfo, IntPtr puArgErr)
  549.         {
  550.             throw new NotImplementedException();
  551.         }
  552.        
  553.         internal ConstructorInfo m_con;
  554.         internal object[] m_constructorArgs;
  555.         internal byte[] m_blob;
  556.     }
  557. }

Developer Fusion