private void ConnectGenericMethodParameters(NetMethod method)
{
foreach (var param in method.GenericParameters)
{
_tx.CreateRelationship(method, param, Relationship.DEFINES_GENERIC_METHOD_ARG);
}
}
private void ConnectGenericMethodParameters(NetMethod method, IGraphDatabaseTransaction tx)
{
foreach (var param in method.GenericParameters)
{
tx.CreateRelationship(method, param, Relationship.DEFINES_GENERIC_METHOD_ARG);
}
}
private IReadOnlyList <NetMethodParameter> CreateParameters(
MethodDefinition method,
NetMethod methodModel)
{
return(method.Parameters
.Select(param => CreateParameter(method, param, methodModel))
.ToList());
}
private void ConnectMethod(NetType type, NetMethod method)
{
_tx.CreateRelationship(type, method, Relationship.DEFINES_METHOD);
_tx.CreateRelationship(method, method.ReturnType, Relationship.RETURNS);
ConnectMethodParameters(method);
ConnectGenericMethodParameters(method);
}
public ClientMethod(ClientComponent parent, NetMethod method)
{
this.parent = parent;
this.name = method.name;
this.returnTypeRaw = method.returnTypeRaw;
this.returnType = method.returnType;
this.argumentTypes = method.argumentTypes;
this.argumentNames = method.argumentNames;
}
private void PrepareMethodForCallCount(NetMethod method)
{
MethodDefinition CecilType = (MethodDefinition)method.Tag;
BodyWorker worker = new BodyWorker(CecilType.Body);
Instruction beforeIns = CecilType.Body.Instructions[0];
Instruction afterIns = worker.InsertBefore(beforeIns, worker.Create(OpCodes.Ldc_I4, method.Handle));
Instruction instruction4 = worker.AppendAfter(afterIns, worker.Create(OpCodes.Ldc_I4, Project.Settings.BuildKey));
worker.AppendAfter(instruction4, worker.Create(OpCodes.Call, _Context.StartEndMethodRef));
worker.Done();
}
private void ConnectMethod(NetType type, NetMethod method, IGraphDatabaseTransaction tx)
{
tx.CreateRelationship(type, method, Relationship.DEFINES_METHOD);
tx.CreateRelationship(method, method.ReturnType, Relationship.RETURNS);
ConnectMethodParameters(method, tx);
ConnectGenericMethodParameters(method, tx);
ConnectAnalyzerExtensionValues(method, method.Exports, Relationship.EXPORTS, tx);
ConnectAnalyzerExtensionValues(method, method.Imports, Relationship.IMPORTS, tx);
ConnectAnalyzerExtensionValues(method, method.TypesUsedInBody, Relationship.HAS_TYPE, tx);
}
public virtual TsFunction GetTsFunction(NetMethod netMethod)
{
return(new TsFunction
{
IsConstructor = netMethod.IsConstructor,
IsPublic = netMethod.IsPublic,
IsStatic = netMethod.IsStatic,
Name = GetTsName(netMethod.Name),
Parameters = netMethod.Parameters.Select(GetTsParameter).ToList(),
ReturnType = GetTsType(netMethod.ReturnType)
});
}
private NetMethodParameter CreateParameter(
MethodDefinition method,
ParameterDefinition param,
NetMethod methodModel)
{
var model = Factory.CreateMethodParameter(method, param);
model.Order = param.Sequence;
model.Type = GetTypeFromTypeReference(param.ParameterType);
model.DeclaringMethod = methodModel;
return(model);
}
private NetMethodParameter CreateParameter(
MethodDefinition method,
ParameterDefinition param,
NetMethod methodModel)
{
var model = Factory.CreateMethodParameter(method, param);
model.Order = param.Sequence;
model.Type = GetTypeFromTypeReference(param.ParameterType);
model.DeclaringMethod = methodModel;
model.Imports = GetMefUsedInterfacesFromMethodParameter(param, nameof(AttributeType.Import));
model.Exports = GetMefUsedInterfacesFromMethodParameter(param, nameof(AttributeType.Export));
return(model);
}
private void ConnectMethodParameters(NetMethod method)
{
foreach (var param in method.Parameters)
{
_tx.CreateRelationship(
method,
param,
Relationship.DEFINES_PARAMETER);
_tx.CreateRelationship(
param,
param.Type,
Relationship.HAS_TYPE);
}
}
private void ConnectMethod(NetType type, NetMethod method)
{
_db.CreateRelationship(type, method, Relationship.DEFINES_METHOD);
_db.CreateRelationship(method, method.ReturnType, Relationship.RETURNS);
var order = 0;
foreach (var param in method.ParameterTypes)
{
var rel = new HasParameterRelationship {
Order = order++
};
_db.CreateRelationship(method, param, Relationship.HAS_PARAMETER, rel);
}
}
public static NetMethod GetNetMethod(MethodDeclarationSyntax methodDeclaration)
{
var item = new NetMethod
{
Name = methodDeclaration.Identifier.ToString(),
Attributes = GetAttributeList(methodDeclaration.AttributeLists),
IsConstructor = false, //constructor declarations are separate type of syntax
IsStatic = IsStatic(methodDeclaration.Modifiers),
IsPublic = IsPublic(methodDeclaration.Modifiers),
Parameters = methodDeclaration.ParameterList.Parameters.Select(GetParameter).ToList(),
ReturnType = GetType(methodDeclaration.ReturnType)
};
return(item);
}
private void ConnectMethodParameters(NetMethod method, IGraphDatabaseTransaction tx)
{
foreach (var param in method.Parameters)
{
tx.CreateRelationship(
method,
param,
Relationship.DEFINES_PARAMETER);
tx.CreateRelationship(
param,
param.Type,
Relationship.HAS_TYPE);
}
}
private NetFieldDeclaration GetUrlNavigateConstFieldDeclaration(NetMethod netMethod, NetClass controllerNetClass)
{
var route = GetRouteInfo(controllerNetClass, netMethod);
var a = new NetFieldDeclaration
{
DefaultValue = "\"" + route.Url + "\"",
FieldDeclarationType = NetFieldDeclarationType.Const,
FieldType = new NetType {
Name = "string"
},
IsPublic = true,
Name = netMethod.Name + "Url"
};
return(a);
}
public virtual string WriteMethod(NetMethod netMethod)
{
var funParams = string.Join(", ", netMethod.Parameters.Select(p => WriteField(p)));
var returnTypeStr = WriteTypeName(netMethod.ReturnType);
var returnType = string.IsNullOrWhiteSpace(returnTypeStr) ? "void" : returnTypeStr;
var exportStr = !netMethod.IsPublic ? "private " : "public ";
var staticStr = netMethod.IsStatic ? "static " : "";
string accessModifier = $"{exportStr}{staticStr}";
var body = netMethod.MethodBody;
return($"{accessModifier}{returnType} {netMethod.Name}({funParams})" + _config.NewLine +
@"{" + _config.NewLine +
$@"{body.Indent(_indent)}" + _config.NewLine +
@"}");
//TODO: if body is null then we should only render a method signature?
}
//TODO: no route info classes for now
// public NetFieldDeclaration GetRouteDataFieldDeclaration(NetMethod netMethod, NetClass controllerNetClass)
// {
// var route = GetRouteInfo(controllerNetClass, netMethod);
// var a = new NetFieldDeclaration
// {
// DefaultValue =
//$@"{{
// baseUrl: '/',
// controller: '{route.Controller}',
// action: '{route.Action}'
//}}",
// FieldDeclarationType = NetFieldDeclarationType.Const,
// FieldType = new NetType { Name = "IRouteData" },
// IsStatic = true,
// Name = netMethod.Name + "Route"
// };
// return a;
// }
private RouteInfo GetRouteInfo(NetClass controllerNetClass, NetMethod netMethod)
{
var controllerName = GetControllerName(controllerNetClass.Name);
var actionName = netMethod.Name;
var routeInfo = controllerNetClass.Attributes.FirstOrDefault(attr => attr.StartsWith("Route"));
if (string.IsNullOrWhiteSpace(routeInfo))
{
routeInfo = "[controller]/[action]";
}
else
{
var m = Regex.Match(routeInfo, "\"(.*?)\"");
if (m.Success && m.Groups.Count > 1 && m.Groups[1].Success)
{
routeInfo = m.Groups[1].Value;
}
}
var route = routeInfo
.Replace("[controller]", controllerName)
.Replace("[action]", actionName);
if (!route.StartsWith("/"))
{
route = "/" + route;
}
return(new RouteInfo
{
Url = route,
Controller = controllerName,
Action = actionName
});
}
/// <summary>
///
/// </summary>
/// <param name="assembly"></param>
/// <param name="method"></param>
/// <param name="rtmodule"></param>
private void PrepareMethod(AssemblyDefinition assembly, NetMethod method)
{
Tracer.Verbose("InjectionProfiler.PrepareMethod START ", method.Name);
// no profiling on this method
if (MustSkipMethod((MethodDefinition)method.Tag))
{
return;
}
//trace the number of call in methods
if (Project.Settings.Action == ProfilMode.CallCount)
{
PrepareMethodForCallCount(method);
}
//trace for performance
if (Project.Settings.Action == ProfilMode.TimeSpent)
{
PrepareMethodForTiming(assembly, method);
}
Tracer.Verbose("InjectionProfiler.PrepareMethod END ", method.Name);
}
/// <summary>
/// IValueConverter.Convert
/// </summary>
/// <param name="value"></param>
/// <param name="targetType"></param>
/// <param name="parameter"></param>
/// <param name="culture"></param>
/// <returns></returns>
public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
if (value == null)
{
return(null);
}
if (value.ToString() == "FolderGroup")
{
return(new BitmapImage(new Uri("pack://application:,,,/Resources/Images/16x16/assembly/references.png")));
}
if (value.GetType() == typeof(NetAssembly))
{
return(new BitmapImage(new Uri("pack://application:,,,/Resources/Images/16x16/assembly/assembly.png")));
}
if (value.GetType() == typeof(NetReference))
{
return(new BitmapImage(new Uri("pack://application:,,,/Resources/Images/16x16/assembly/assembly.png")));
}
if (value.GetType() == typeof(NetNamespace))
{
return(new BitmapImage(new Uri("pack://application:,,,/Resources/Images/16x16/assembly/namespace.png")));
}
if (value.GetType() == typeof(NetClass))
{
return(new BitmapImage(new Uri("pack://application:,,,/Resources/Images/16x16/assembly/class.png")));
}
if (value.GetType() == typeof(NetInterface))
{
return(new BitmapImage(new Uri("pack://application:,,,/Resources/Images/16x16/assembly/interfaces.png")));
}
if (value.GetType() == typeof(NetEnum))
{
return(new BitmapImage(new Uri("pack://application:,,,/Resources/Images/16x16/assembly/enum.png")));
}
if (value.GetType() == typeof(NetMethod))
{
NetMethod method = value as NetMethod;
if (method.Tag.GetType().ToString() == "System.Reflection.RuntimeConstructorInfo")
{
return(new BitmapImage(new Uri("pack://application:,,,/Resources/Images/16x16/assembly/constructor.png")));
}
if (method.Tag.GetType().ToString() == "System.Reflection.RuntimeMethodInfo")
{
return(new BitmapImage(new Uri("pack://application:,,,/Resources/Images/16x16/assembly/method.png")));
}
if (method.Tag.GetType().ToString() == "System.Reflection.RuntimePropertyInfo")
{
return(new BitmapImage(new Uri("pack://application:,,,/Resources/Images/16x16/assembly/properties.png")));
}
if (method.Tag.GetType().ToString() == "System.Reflection.RtFieldInfo")
{
return(new BitmapImage(new Uri("pack://application:,,,/Resources/Images/16x16/assembly/member.png")));
}
if (method.Tag.GetType().ToString() == "System.Reflection.MdFieldInfo")
{
return(new BitmapImage(new Uri("pack://application:,,,/Resources/Images/16x16/assembly/member.png")));
}
if (method.Tag.GetType().ToString() == "System.Reflection.RuntimeEventInfo")
{
return(new BitmapImage(new Uri("pack://application:,,,/Resources/Images/16x16/assembly/event.png")));
}
}
return(null);
}
private void PrepareMethodForTiming(AssemblyDefinition assembly, NetMethod method)
{
MethodDefinition CecilType = (MethodDefinition)method.Tag;
MethodBody body = CecilType.Body;
BodyWorker bw = new BodyWorker(body);
VariableDefinition definition = null;
if (CecilType.ReturnType.ReturnType != assembly.MainModule.TypeReferences["System.Void"])
{
definition = new VariableDefinition(CecilType.ReturnType.ReturnType);
body.Variables.Add(definition);
}
Instruction instruction6 = null;
Instruction instruction7 = body.Instructions[0];
Instruction instruction8 = bw.InsertBefore(instruction7, bw.Create(OpCodes.Ldc_I4, method.Handle));
Instruction instruction9 = bw.AppendAfter(instruction8, bw.Create(OpCodes.Ldc_I4, Project.Settings.BuildKey));
bw.AppendAfter(instruction9, bw.Create(OpCodes.Call, _Context.StartMethodRef));
Instruction instruction10 = bw.OriginalInstructions[bw.OriginalInstructions.Count - 1];
Instruction instruction11 = bw.AppendAfter(instruction10, bw.Create(OpCodes.Call, _Context.EndMethodRef));
Instruction instruction12 = bw.AppendAfter(instruction11, bw.Create(OpCodes.Endfinally));
Instruction outside = body.Instructions.Outside;
//gestion des methodes de debut/fin ?
// TODO
foreach (Instruction original in bw.OriginalInstructions)
{
Instruction instruction15;
if (!(original.OpCode == OpCodes.Ret) || (original == instruction6))
{
continue;
}
//return type exist
if (definition != null)
{
//return the value
instruction15 = bw.AppendAfter(instruction12, bw.Create(OpCodes.Ldloc, definition));
bw.AppendAfter(instruction15, bw.Create(OpCodes.Ret));
}
else
{
//else quit
instruction15 = bw.AppendAfter(instruction12, bw.Create(OpCodes.Ret));
}
foreach (Instruction instruction16 in bw.OriginalInstructions)
{
if ((instruction16.OpCode == OpCodes.Ret) && (instruction16 != instruction6))
{
if (definition != null)
{
Instruction instruction17 = bw.Replace(instruction16, bw.Create(OpCodes.Stloc, definition));
bw.AppendAfter(instruction17, bw.Create(OpCodes.Leave, instruction15));
}
else
{
bw.Replace(instruction16, bw.Create(OpCodes.Leave, instruction15));
}
}
}
outside = instruction15;
break;
}
bw.RemapBodyOutside(instruction11);
bw.Done();
//define the exception handling arround the existing code
ExceptionHandler handler = new ExceptionHandler(ExceptionHandlerType.Finally)
{
TryStart = instruction7,
TryEnd = instruction11,
HandlerStart = instruction11,
HandlerEnd = outside
};
body.ExceptionHandlers.Add(handler);
//if return type, be sure that variables are initialized
if (definition != null)
{
body.InitLocals = true;
}
}
private NetMethod GetCsProxy(NetMethod controllerMethod, string controllerName)
{
var csProxy = new NetMethod
{
ReturnType = new NetType
{
Name = "RestRequestAsyncHandle"
},
Name = controllerMethod.Name,
IsPublic = true
};
//get HTTP verb from controller attributes if present. Default to Post
var actionType = controllerMethod.Attributes.Any(attr => attr.Contains("HttpGet")) ? "GET" : "POST";
actionType = controllerMethod.Attributes.Any(attr => attr.Contains("HttpPost")) ? "POST" : actionType;
//gets the param names from controller
var dataParametersString = string.Join(",\r\n", controllerMethod.Parameters.Select(p => $"{p.Name}"));
//these are value params
csProxy.Parameters = controllerMethod.Parameters.Select(p => new NetParameter
{
Name = p.Name,
FieldType = new NetType
{
Name = p.FieldType.Name
}
}).ToList();
csProxy.Parameters.Add(new NetParameter
{
//Action<IRestResponse<{functionReturnType}>>
FieldType = new NetType
{
Name = "Action",
GenericParameters = new[] {
new NetGenericParameter
{
Name = "IRestResponse",
NetGenericParameters = controllerMethod.ReturnType.Name == "void" ? null : new[]
{
new NetGenericParameter(controllerMethod.ReturnType)
}
}
}
//Name = $"Action<IRestResponse<{functionReturnType}>>"
},
Name = "callback"
});
csProxy.MethodBody =
@"return ServiceFramework.FrameworkExec(
baseUrl: _baseUrl,
url: " + $"{csProxy.Name}Url" + @",
data: new {
" + dataParametersString.Indent("\t\t") + @"
},
method: Method." + actionType + @",
callback: callback
);";
return(csProxy);
}
