public MethodBuilder GenerateInstanceMethodWithClassWrapper(ILCode code)
{
MethodBuilder mBuilder = GetMethod(code);
//este es el nombre de la clase que contiene a este funcion
string parentWrapper = string.Format("Tg_{0}", FunctionParentCodeName());
//obtengo el tipo de la clase que contiene a esta funcion
var container = (TypeBuilder)code.DefinedType[parentWrapper];
//generar la clase wrapper a mis variables
string currentWrapper = string.Format("Tg_{0}", FunctionCodeName());
TypeBuilder typeNested = container.DefineNestedType(currentWrapper,
TypeAttributes.NestedPublic);
//annadir a la clase code el tipo.
code.DefinedType.Add(typeNested.Name, typeNested);
//asociar el wrapper con la funcion que lo creo
code.AsociatteMethodToWrapper(mBuilder.Name, currentWrapper);
//tengo que asociar este tipo con su padre.
TypeCodeInfo typeCodeInfo = code.GetWrapperAsociatteTo(FunctionCodeName());
typeCodeInfo.Parent = code.GetWrapperAsociatteTo(FunctionParentCodeName());
//annadir esta funcion al padre.
//Tener en cuenta cuando se llame la funcion antes de ser declarada
if (!typeCodeInfo.Parent.ContainMethodInLevel1(mBuilder.Name))
{
typeCodeInfo.Parent.AddMethod(mBuilder.Name, mBuilder);
}
PopulateNestedTypeWithVar(code, typeNested, typeCodeInfo, container);
//crear la instancia de esta clase dentro de mi codigo.
ILGenerator il = mBuilder.GetILGenerator();
il.DeclareLocal(typeNested);
//No annado la variable local al ILCode porque siempre sera la primera de todas.
return(mBuilder);
}
private static TypeBuilder AddFunctionMainToCode(ILCode code, MethodBuilder main)
{
code.DefinedMethod.Add(MainFunction, main);
//crear lo que sera el wrapper a esta funcion
string currentWrapper = string.Format("Tg_{0}", MainFunction);
TypeBuilder typeNested = code.Type.DefineNestedType(currentWrapper,
TypeAttributes.NestedPublic);
//crear en la variable de instancia de la clase contenedora,pues el Let asume que la tiene creada.
ILGenerator il = main.GetILGenerator();
il.DeclareLocal(typeNested);
//annadir a la clase code el tipo.
code.DefinedType.Add(typeNested.Name, typeNested);
//asociar el tipo wrapper al metodo
code.AsociatteMethodToWrapper(MainFunction, currentWrapper);
code.GetWrapperAsociatteTo(MainFunction);
//PopulateNestedTypeWithVar(code, typeNested, typeCodeInfo);
return(typeNested);
}