void CreateCompareMethod(List <PropertySerializationInfo> properties)
        {
            const string        endFalseLabel = "compareFailedLabel";
            DynamicMethodHelper il            = new DynamicMethodHelper(
                "Compare_" + type.Name,
                typeof(bool),
                new Type[] { typeof(object), typeof(object) },
                this.type
                );

            //  Create calls to compare each member
            foreach (PropertySerializationInfo propInfo in properties)
            {
                il.BeginScope();
                propInfo.GenerateCompareIL(il, 0, 1);
                il.EndScope();

                il.GotoIfFalse(endFalseLabel);
            }

            //  Return true if all properties passed (didn't goto endFalseLabel)
            il.PushInt(Convert.ToInt32(true));
            il.Return();

            //  Return false if any properties failed (did goto endFalseLabel)
            il.MarkLabel(endFalseLabel);
            il.PushInt(Convert.ToInt32(false));
            il.Return();

            this.compareMethod = (CompareMethod)il.Compile(typeof(CompareMethod));
        }
		/// <summary>
		/// Generates IL for serializing the property
		/// </summary>
		/// <param name="args">
		///	<para>The arguments used to generate the il.</para>
		/// </param>
		public void GenerateWriteIL(GenerateArgs args)
		{
			#region Names
			const string loopConditionLabel = "loopStart";
			const string loopEndLabel = "loopEnd";
			const string propVar = "propValue";
			const string elemVar = "elemValue";
			const string instanceVar = "instance";
			const string collectionNotNullLabel = "collectionNotNullLabel";
			const string countVar = "collectionCount";
			const string enumVar = "enumerator";
			const string dictEnumVar = "dictEnumerator";
			const string dictKeyVar = "dictKey";
			const string dictValueVar = "dictValue";
			const string enumerableVar = "enumerable";
			#endregion

			DynamicMethodHelper il = args.il;

			if (this.attribute.WriteMethod != null)
			{
				//  Call custom handler
				MethodInfo method = this.OwnerType.GetMethod(
													 this.attribute.WriteMethod,
													 BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy,
													 null,
													 new [] { typeof(IPrimitiveWriter) },
													 null
													 );

				if (method == null)
				{
					throw new ApplicationException(string.Format(
									"Failed to locate method {0}.{1} to write property {2}",
									this.OwnerType.Name,
									this.attribute.ReadMethod,
									this.Name
									));
				}

				il.PushArg(args.instanceArg);
				il.PushLocal(args.streamVar);
				il.CallMethod(method);
				return;
			}

			il.DeclareLocal(instanceVar, this.OwnerType);
			il.DeclareLocal(propVar, this.Type);

			il.PushArg(args.instanceArg);
			il.PopLocal(instanceVar);

			//  Get property value and store in local
			if (this.classType != null)
			{
				//  For indexer load the instance itself
				il.PushLocal(instanceVar);
			}
			else if (this.property is PropertyInfo)
			{
				il.PushLocal(instanceVar);
				il.CallMethod(((PropertyInfo)this.property).GetGetMethod(true));
			}
			else // FieldInfo
			{
				//  push instance
				//  load_field
				il.GetField(instanceVar, (FieldInfo)this.property);
			}

			//  store propValue
			il.PopLocal(propVar);

			//  If this is a collection and null then store -1 length
			//  If this is a non-null collection then emit loop code            
			if (IsCollection)
			{
				il.DeclareLocal(countVar, typeof(int));
				il.DeclareLocal(enumVar, typeof(IEnumerator));
				il.DeclareLocal(enumerableVar, typeof(IEnumerable));
				il.DeclareLocal(elemVar, this.elementType);

				//  push propValue
				//  push null
				//  branch_if_equal collectionNullLabel
				//  branch collectionNotNullLabel
				il.PushLocal(propVar);
				il.GotoIfTrue(collectionNotNullLabel);

				//  ; collection is null so write -1
				//  push writer
				//  push -1
				//  call IPrimitiveWriter.Write(int)
				//  goto loopEnd
				il.PushLocal(args.streamVar);
				il.PushInt(-1);
				il.CallMethod(GetTypeMethod(typeof(int), TypeMethodType.Serialize));
				il.Goto(loopEndLabel);

				//  :collectionNotNullLabel
				il.MarkLabel(collectionNotNullLabel);

				//  countVar = collection.Length/Count
				if (IsArray)
				{
					il.CallMethod(propVar, "get_Length");
				}
				else
				{
					il.PushLocal(propVar);
					il.Cast(this.collectionInterfaceType);
					il.CallMethod(this.collectionCountMethod);
				}
				il.PopLocal(countVar);

				//  writer.Write(countVar)
				il.PushLocal(args.streamVar);
				il.PushLocal(countVar);
				il.CallMethod(GetTypeMethod(typeof(int), TypeMethodType.Serialize));

				//  enumerable = propVar
				//  enumVar = enumerable.GetEnumerator()
				il.CopyLocal(propVar, enumerableVar);
				il.CallMethod(enumerableVar, "GetEnumerator");
				il.PopLocal(enumVar);

				if (IsDictionary)
				{
					il.DeclareLocal(dictEnumVar, typeof(IDictionaryEnumerator));
					il.DeclareLocal(dictKeyVar, this.dictionaryKeyType);
					il.DeclareLocal(dictValueVar, this.dictionaryValueType);
					il.CopyLocal(enumVar, dictEnumVar);
				}

				//  :loopConditionLable
				//  if (enumVar.MoveNext == false) goto loopEndLabel
				il.MarkLabel(loopConditionLabel);
				il.CallMethod(enumVar, "MoveNext");
				il.GotoIfFalse(loopEndLabel);

				//  if (!dictionary) elemVar = enumVar.Current
				if (IsDictionary == false)
				{
					il.CallMethod(enumVar, "get_Current");
					il.PopLocalFromObject(elemVar);
				}
			}

			//  For dictionary properties serialize the key and value
			//  For everything else serialize the element as-is
			if (IsDictionary)
			{
				//  push elemValue
				//  call get_Key
				//  serialize key
				il.CallMethod(dictEnumVar, "get_Key");
				this.GenerateWriteTypeIL(this.dictionaryKeyType, args);

				//  push elemValue
				//  call get_Value
				//  serialize value
				il.CallMethod(dictEnumVar, "get_Value");
				GenerateWriteTypeIL(this.dictionaryValueType, args);
			}
			else if (IsCollection)
			{
				//  push elemValue
				//  serialize elemValue
				il.PushLocalAsObject(elemVar);
				GenerateWriteTypeIL(this.elementType, args);
			}
			else
			{
				il.PushLocalAsObject(propVar);
				GenerateWriteTypeIL(this.elementType, args);
			}

			//  Complete loop instructions for collection
			if (IsCollection)
			{
				//  branch loopConditionLabel
				//  :loopEnd
				il.Goto(loopConditionLabel);
				il.MarkLabel(loopEndLabel);
			}
		}
		static void GenerateCompareTypeIL(DynamicMethodHelper il, Type t)
		{
			MethodInfo method = GetTypeMethod(t, TypeMethodType.Compare);

			if ((method == null) && (t.IsPrimitive == false))
			{
				il.Pop();
				il.Pop();
				il.PushInt(1);
				return;
			}

			il.BeginScope();
			{
				const string valX = "x";
				const string valY = "y";
				const string valThis = "_thisX";
				const string trueLabel = "endTrue";
				const string falseLabel = "endFalse";
				const string endLabel = "endCheck";

				il.DeclareLocal(valX, typeof(object));
				il.PopLocal(valX);
				il.DeclareLocal(valY, typeof(object));
				il.PopLocal(valY);

				//  If both null or the same object then return true
				il.PushLocal(valX);
				il.PushLocal(valY);
				il.GotoIfEqual(trueLabel);

				//  Exit false if either value is null
				il.PushLocal(valX);
				il.GotoIfFalse(falseLabel);

				il.PushLocal(valY);
				il.GotoIfFalse(falseLabel);

				//  Both operands are non-null so call the type-specific comparison method
				if (t.IsPrimitive)
				{
					il.PushLocal(valX);
					il.UnboxValueType(t);
					il.PushLocal(valX);
					il.UnboxValueType(t);
					il.CompareEqual();
				}
				else
				{
					Type paramType = method.GetParameters()[0].ParameterType;

					il.DebugWriteLine("Calling " + method);
					if (method.IsStatic)
					{
						il.PushLocal(valX);
						if (paramType.IsValueType) il.UnboxValueType(paramType);
					}
					else
					{
						il.DeclareLocal(valThis, t);
						il.PushLocal(valX);
						il.PopLocalFromObject(valThis);
						il.PushThis(valThis, method);
					}
					il.PushLocal(valY);
					if (paramType.IsValueType) il.UnboxValueType(paramType);
					il.CallMethod(method);
				}
				il.GotoIfFalse(falseLabel);

				il.MarkLabel(trueLabel);
				il.PushInt(1);
				il.Goto(endLabel);

				il.MarkLabel(falseLabel);
				il.DebugWriteLine("The following values are not equal:");
				il.DebugWriteLocal(valX);
				il.DebugWriteLocal(valY);
				il.PushInt(0);

				il.MarkLabel(endLabel);
			}
			il.EndScope();
		}
		public void GenerateCompareIL(DynamicMethodHelper il, int xIndex, int yIndex)
		{
			#region Names
			const string instanceX = "instanceX";
			const string propVarX = "propValueX";
			const string enumerableX = "enumerableX";
			const string enumVarX = "enumX";
			const string dictEnumVarX = "dictEnumX";

			const string instanceY = "instanceY";
			const string propVarY = "propValueY";
			const string enumerableY = "enumerableY";
			const string enumVarY = "enumY";
			const string dictEnumVarY = "dictEnumY";

			const string endFalseLabel = "logBadPropertyLabel";
			const string endTrueLabel = "endTrue";
			const string endLabel = "endLabel";
			const string loopStart = "loopStart";
			const string loopEnd = "loopEnd";
			#endregion

			il.DebugWriteLine("Comparing property " + this.Name);

			il.DeclareLocal(instanceX, this.OwnerType);
			il.PushArg(xIndex);
			il.PopLocal(instanceX);

			il.DeclareLocal(instanceY, this.OwnerType);
			il.PushArg(yIndex);
			il.PopLocal(instanceY);

			il.DeclareLocal(propVarX, this.Type);
			il.DeclareLocal(propVarY, this.Type);

			if (this.classType != null)
			{
				il.CopyLocal(instanceX, propVarX);
				il.CopyLocal(instanceY, propVarY);
			}
			else if (this.property is PropertyInfo)
			{
				PropertyInfo pi = (PropertyInfo)this.property;
				MethodInfo getMethod = pi.GetGetMethod(true);

				il.CallMethod(instanceX, getMethod);
				il.PopLocal(propVarX);
				il.CallMethod(instanceY, getMethod);
				il.PopLocal(propVarY);
			}
			else
			{
				il.GetField(instanceX, this.property as FieldInfo);
				il.PopLocal(propVarX);
				il.GetField(instanceY, this.property as FieldInfo);
				il.PopLocal(propVarY);
			}

			//  For ref types, if both null or the same object then return true
			//  For value types, this is a value comparison
			Type t = IsCollection ? (IsDictionary ? null : this.elementType) : this.Type;
			bool doDefault = true;
			if (t != null && t.IsValueType)
			{
				MethodInfo mi = t.GetMethod("op_Equality", new [] { t, t });
				if (mi != null)
				{
					il.PushLocal(propVarX);
					il.PushLocal(propVarY);
					il.CallMethod(mi);
					il.GotoIfFalse(endTrueLabel);
					doDefault = false;
				}
				else if (t.IsGenericType && t.GetGenericTypeDefinition().Equals(typeof(Nullable<>)))
				{
					Type it = t.GetGenericArguments()[0];
					mi = typeof(Nullable).GetMethod("Equals", BindingFlags.Public | BindingFlags.Static | BindingFlags.DeclaredOnly);
					mi = mi.MakeGenericMethod(it);

					il.PushLocal(propVarX);
					il.PushLocal(propVarY);
					il.CallMethod(mi);
					il.GotoIfFalse(endTrueLabel);
					doDefault = false;
				}
			}

			if (doDefault)
			{
				il.PushLocal(propVarX);
				il.PushLocal(propVarY);
				il.GotoIfEqual(endTrueLabel);
			}

			if (IsCollection)
			{
				il.DeclareLocal(enumerableX, typeof(IEnumerable));
				il.DeclareLocal(enumVarX, typeof(IEnumerator));
				il.DeclareLocal(enumerableY, typeof(IEnumerable));
				il.DeclareLocal(enumVarY, typeof(IEnumerator));

				il.CopyLocal(propVarX, enumerableX);
				il.CallMethod(enumerableX, "GetEnumerator");
				il.PopLocal(enumVarX);

				il.CopyLocal(propVarY, enumerableX);
				il.CallMethod(enumerableX, "GetEnumerator");
				il.PopLocal(enumVarY);

				if (IsDictionary)
				{
					il.DeclareLocal(dictEnumVarX, typeof(IDictionaryEnumerator));
					il.CopyLocal(enumVarX, dictEnumVarX);
					il.DeclareLocal(dictEnumVarY, typeof(IDictionaryEnumerator));
					il.CopyLocal(enumVarY, dictEnumVarY);
				}

				il.MarkLabel(loopStart);
				il.CallMethod(enumVarX, "MoveNext");
				il.GotoIfFalse(loopEnd);

				il.CallMethod(enumVarY, "MoveNext");
				il.GotoIfFalse(endFalseLabel); // y has less elements than x

				if (IsDictionary)
				{
					il.CallMethod(dictEnumVarX, "get_Key");
					il.CallMethod(dictEnumVarY, "get_Key");
					GenerateCompareTypeIL(il, this.dictionaryKeyType);
					il.GotoIfFalse(endFalseLabel);

					il.CallMethod(dictEnumVarX, "get_Value");
					il.CallMethod(dictEnumVarY, "get_Value");
					GenerateCompareTypeIL(il, this.dictionaryValueType);
					il.GotoIfFalse(endFalseLabel);
				}
				else // if (not dictionary)
				{
					il.CallMethod(enumVarX, "get_Current");
					il.CallMethod(enumVarY, "get_Current");
					GenerateCompareTypeIL(il, this.elementType);
					il.GotoIfFalse(endFalseLabel);
				}

				il.Goto(loopStart);
				il.MarkLabel(loopEnd);

				//  enumVarX has no more elements so enumVarY shouldn't
				//  have any more either
				il.CallMethod(enumVarY, "MoveNext");
				il.GotoIfTrue(endFalseLabel); // count mismatch
			}
			else // if (not collection)
			{
				il.PushLocalAsObject(propVarX);
				il.PushLocalAsObject(propVarY);
				GenerateCompareTypeIL(il, this.Type);
				il.GotoIfFalse(endFalseLabel);
			}

			il.MarkLabel(endTrueLabel);
			//il.DebugWriteLine(string.Format("Property {0} is equal", this.Name));
			il.PushInt(1);
			il.Goto(endLabel);

			//  Log out name of property if not equal
			il.MarkLabel(endFalseLabel);
			il.DebugWriteLine(string.Format("Property {0} is not equal", this.Name));
			il.PushInt(0);  // set success to false

			il.MarkLabel(endLabel);
		}