internal MethodDefinition AddNewCall(string typeName, MethodDefinition mDef, object callDef, string startMethod)
{
Logger.Current.Debug("AssemblyData :: AddNewCall");
// check whether the call and the current type is valid
if (Rules.IsValidCall(callDef, typeName, new CallRules()))
{
if (mDef != null)
{
var mInfo = new MethodCallInfo
{
StartMethod = startMethod,
TypeName = typeName,
MethodName = CecilAssemblyHelper.CreateNormalizeMethodDefinition(mDef).ToString()
};
mDef = callDef as MethodDefinition;
NormalizeMethodDefinition norm;
if (mDef == null)
{
var callRef = callDef as MethodReference;
// method reference, just add the callee, we'll search for the referenced assembly later
norm = CecilAssemblyHelper.CreateNormalizeMethodDefinition(callRef);
}
else
{
norm = CecilAssemblyHelper.CreateNormalizeMethodDefinition(mDef);
}
mInfo.MethodCallType = norm.DeclaringTypeFullName;
mInfo.MethodCallNamespace = norm.DeclaringTypeNamespace;
mInfo.MethodCallName = norm.ToString();
mInfo.TargetMethodAssembly = norm.AssemblyName;
// check whether the calling type is in the ignored list
if (Rules.IsValidType(mInfo.MethodCallType))
{
MethodCallList.Add(mInfo);
Logger.Current.Debug(">> Adding Method:" + mInfo);
}
else
{
Logger.Current.Debug(">> MethodCallType: " + mInfo.MethodCallType + " in ignored list");
}
}
}
else
{
mDef = null;
}
return mDef;
}
public void AddMessage(string sourceKey, string targetKey, string methodCallName, MethodCallInfo methodCallInfo)
{
if (string.IsNullOrEmpty(sourceKey) || string.IsNullOrEmpty(targetKey) || string.IsNullOrEmpty(methodCallName))
{
throw new ArgumentNullException(string.IsNullOrEmpty(sourceKey) ? "sourceKey" : string.IsNullOrEmpty(targetKey) ? "targetKey" : "typeName");
}
ObjectInfo sourceInfo = DiagramContext.DiagramObjects.Find(sourceKey);
ObjectInfo targetInfo = DiagramContext.DiagramObjects.Find(targetKey);
if (sourceInfo == null || targetInfo == null)
{
throw new ArgumentException(string.Format(CultureInfo.InvariantCulture, Properties.Resources.SourceOrTargetObjectInfoNotFound, sourceInfo == null ? sourceKey : targetKey), sourceInfo == null ? "sourceKey" : "targetKey");
}
MessageInfo message = new MessageInfo(sourceInfo, targetInfo, methodCallName, methodCallInfo);
DiagramContext.Messages.Add(message);
}
/// <summary>
/// Adds the new call.
/// </summary>
/// <param name="typeName">Name of the type.</param>
/// <param name="methodDefinition">The method definition.</param>
/// <param name="callDefinition">The call definition.</param>
/// <param name="startMethod">The start method.</param>
/// <returns>The IMethodDeclaration based on the given call definition. This provides a means of working through the method's call stack.</returns>
internal IMethodDeclaration AddNewCall(string typeName, IMethodDeclaration methodDefinition, object callDefinition, string startMethod)
{
Logger.Current.Info(typeName);
Logger.Current.Info(methodDefinition.Name);
Logger.Current.Info(startMethod);
if (!Rules.IsValidCall(callDefinition, new CallRules()))
{
return null;
}
MethodCallInfo methodInfo = new MethodCallInfo();
methodInfo.StartMethod = startMethod;
methodInfo.TypeName = typeName;
methodInfo.MethodName = ReflectorHelper.CreateNormalizeMethodDefinition(methodDefinition).ToString();
methodDefinition = callDefinition as IMethodDeclaration;
IMethodReference methodReference = callDefinition as IMethodReference;
if (methodDefinition != null || methodReference != null)
{
NormalizeMethodDefinition norm = null;
if (methodDefinition == null)
{
norm = ReflectorHelper.CreateNormalizeMethodDefinition(methodReference);
}
else
{
norm = ReflectorHelper.CreateNormalizeMethodDefinition(methodDefinition);
}
methodInfo.MethodCallType = norm.DeclaringTypeFullName;
methodInfo.MethodCallNamespace = norm.DeclaringTypeNamespace;
methodInfo.MethodCallName = norm.ToString();
this.MethodCallList.Add(methodInfo);
}
return methodDefinition;
}
public void AddMessage(MethodCallInfo methodCall)
{
methodList.Add(methodCall);
}
private void WriteMessage(StreamWriter sw, MethodCallInfo mInfo)
{
// get the key
string sourceKey = objectList.Find(
oInfo => oInfo.TypeName.Equals(mInfo.TypeName)
).Key;
string targetKey = objectList.Find(
oInfo => oInfo.TypeName.Equals(mInfo.MethodCallType)
).Key;
Write(sw, string.Format("message({0},{1}, \"{2}\");",sourceKey, targetKey, mInfo.MethodCallName));
}
