static Accessibility GetAccessibility(Type type)
{
if (type.IsPublic)
{
return(Accessibility.Public);
}
else if (type.IsNotPublic)
{
return(Accessibility.Private);
}
return(MissingMember.GetAccessibility(type));
}
public void AddMember(MissingMember mm)
{
switch (mm.Info.MemberType)
{
case MemberTypes.Method:
nsMethods.AddChildren(mm.Status);
rgMethods.Add(mm);
break;
case MemberTypes.Property:
nsProperties.AddChildren(mm.Status);
rgProperties.Add(mm);
break;
case MemberTypes.Event:
nsEvents.AddChildren(mm.Status);
rgEvents.Add(mm);
break;
case MemberTypes.Field:
nsFields.AddChildren(mm.Status);
rgFields.Add(mm);
break;
case MemberTypes.Constructor:
nsConstructors.AddChildren(mm.Status);
rgConstructors.Add(mm);
break;
case MemberTypes.NestedType:
nsNestedTypes.AddChildren(mm.Status);
rgNestedTypes.Add(mm);
break;
default:
throw new Exception("Unexpected MemberType: " + mm.Info.ToString());
}
}
public override NodeStatus Analyze()
{
Hashtable htMono = new Hashtable();
if (typeMono != null)
{
ArrayList rgIgnoreMono = new ArrayList();
foreach (MemberInfo miMono in typeMono.GetMembers(BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic))
{
if (typeMono == miMono.DeclaringType)
{
string strName = MissingMember.GetUniqueName(miMono);
htMono.Add(strName, miMono);
// ignore any property/event accessors
if (miMono.MemberType == MemberTypes.Property)
{
PropertyInfo pi = (PropertyInfo)miMono;
MemberInfo miGet = pi.GetGetMethod();
if (miGet != null)
{
rgIgnoreMono.Add(miGet);
}
MemberInfo miSet = pi.GetSetMethod();
if (miSet != null)
{
rgIgnoreMono.Add(miSet);
}
}
else if (miMono.MemberType == MemberTypes.Event)
{
EventInfo ei = (EventInfo)miMono;
MemberInfo miAdd = ei.GetAddMethod();
if (miAdd != null)
{
rgIgnoreMono.Add(miAdd);
}
MemberInfo miRemove = ei.GetRemoveMethod();
if (miRemove != null)
{
rgIgnoreMono.Add(miRemove);
}
MemberInfo miRaise = ei.GetRaiseMethod();
if (miRaise != null)
{
rgIgnoreMono.Add(miRaise);
}
}
}
}
foreach (MemberInfo miIgnore in rgIgnoreMono)
{
htMono.Remove(MissingMember.GetUniqueName(miIgnore));
}
}
Hashtable htMethodsMS = new Hashtable();
if (typeMS != null)
{
ICollection colMembersMS = typeMS.GetMembers(BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
Hashtable htIgnoreMS = new Hashtable();
foreach (MemberInfo miMS in colMembersMS)
{
// ignore any property/event accessors
if (miMS.MemberType == MemberTypes.Property)
{
PropertyInfo pi = (PropertyInfo)miMS;
MemberInfo miGet = pi.GetGetMethod();
if (miGet != null)
{
htIgnoreMS.Add(miGet, miMS);
}
MemberInfo miSet = pi.GetSetMethod();
if (miSet != null)
{
htIgnoreMS.Add(miSet, miMS);
}
}
else if (miMS.MemberType == MemberTypes.Event)
{
EventInfo ei = (EventInfo)miMS;
MemberInfo miAdd = ei.GetAddMethod();
if (miAdd != null)
{
htIgnoreMS.Add(miAdd, miMS);
}
MemberInfo miRemove = ei.GetRemoveMethod();
if (miRemove != null)
{
htIgnoreMS.Add(miRemove, miMS);
}
MemberInfo miRaise = ei.GetRaiseMethod();
if (miRaise != null)
{
htIgnoreMS.Add(miRaise, miMS);
}
}
}
foreach (MemberInfo miMS in colMembersMS)
{
if (miMS != null && miMS.DeclaringType == typeMS && !htIgnoreMS.Contains(miMS))
{
string strNameUnique = MissingMember.GetUniqueName(miMS);
MemberInfo miMono = (MemberInfo)htMono [strNameUnique];
MissingMember mm = CreateMember(miMono, miMS);
bool fVisibleMS = IsVisible(miMS);
if (miMono == null)
{
if (fVisibleMS)
{
AddMember(mm);
}
}
else
{
if (miMono.MemberType != miMS.MemberType)
{
//AddMember (null, miMS);
//MissingMember mm2 = CreateMember (miMono, null);
//mm2.Status.AddWarning ("MemberType mismatch, is: '" + miMono.MemberType.ToString () + "' [should be: '" + miMS.MemberType.ToString ()+"']");
//AddMember (mm2);
mm.Status.AddWarning("MemberType mismatch, is: '" + miMono.MemberType.ToString() + "' [should be: '" + miMS.MemberType.ToString() + "']");
AddMember(mm);
}
else if (fVisibleMS || IsVisible(miMono))
{
AddMember(mm);
}
htMono.Remove(strNameUnique);
}
switch (miMS.MemberType)
{
case MemberTypes.Method:
{
string strNameMSFull = miMS.ToString();
int ichMS = strNameMSFull.IndexOf(' ');
string strNameMS = strNameMSFull.Substring(ichMS + 1);
if (!htMethodsMS.Contains(strNameMS))
{
htMethodsMS.Add(strNameMSFull.Substring(ichMS + 1), miMS);
}
break;
}
}
}
}
}
foreach (MemberInfo miMono in htMono.Values)
{
if (IsVisible(miMono))
{
MissingMember mm = CreateMember(miMono, null);
switch (miMono.MemberType)
{
case MemberTypes.Method:
{
string strNameMonoFull = miMono.ToString();
int ichMono = strNameMonoFull.IndexOf(' ');
string strNameMono = strNameMonoFull.Substring(ichMono + 1);
MemberInfo miMS = (MemberInfo)htMethodsMS [strNameMono];
if (miMS != null)
{
string strNameMSFull = miMS.ToString();
int ichMS = strNameMSFull.IndexOf(' ');
string strReturnTypeMS = strNameMSFull.Substring(0, ichMS);
string strReturnTypeMono = strNameMonoFull.Substring(0, ichMono);
mm.Status.AddWarning("Return type mismatch, is: '" + strReturnTypeMono + "' [should be: '" + strReturnTypeMS + "']");
//Console.WriteLine ("WARNING: Return type mismatch on "+miMS.DeclaringType.FullName+"."+strNameMono+", is: '"+strReturnTypeMono+"' [should be: '"+strReturnTypeMS+"']");
}
break;
}
}
AddMember(mm);
}
}
// compare the attributes
rgAttributes = new ArrayList();
nsAttributes = MissingAttribute.AnalyzeAttributes(
(typeMono == null) ? null : typeMono.GetCustomAttributes(false),
(typeMS == null) ? null : typeMS.GetCustomAttributes(false),
rgAttributes);
rgInterfaces = new ArrayList();
if (typeMono != null && typeMS != null)
{
// compare base types
string strBaseMono = (typeMono.BaseType == null) ? null : typeMono.BaseType.FullName;
string strBaseMS = (typeMS.BaseType == null) ? null : typeMS.BaseType.FullName;
if (strBaseMono != strBaseMS)
{
m_nodeStatus.AddWarning("Base class mismatch, is '" + strBaseMono + "' [should be: '" + strBaseMS + "']");
//Console.WriteLine ("WARNING: Base class mismatch on "+typeMono.FullName+", is: '"+strBaseMono+"' [should be: '"+strBaseMS+"']");
}
// compare the interfaces
Hashtable htInterfacesMono = new Hashtable();
Type [] rgInterfacesMono = typeMono.GetInterfaces();
foreach (Type ifaceMono in rgInterfacesMono)
{
if (ifaceMono != null)
{
string strName = ifaceMono.FullName;
htInterfacesMono.Add(strName, ifaceMono);
}
}
Type [] rgInterfacesMS = typeMS.GetInterfaces();
foreach (Type ifaceMS in rgInterfacesMS)
{
if (ifaceMS != null)
{
string strName = ifaceMS.FullName;
Type ifaceMono = (Type)htInterfacesMono [strName];
MissingInterface mi = new MissingInterface(ifaceMono, ifaceMS);
mi.Analyze();
rgInterfaces.Add(mi);
if (ifaceMono != null)
{
htInterfacesMono.Remove(strName);
}
nsInterfaces.AddChildren(mi.Status);
}
}
foreach (Type ifaceMono in htInterfacesMono.Values)
{
MissingInterface mi = new MissingInterface(ifaceMono, null);
mi.Analyze();
rgInterfaces.Add(mi);
//Console.WriteLine ("WARNING: additional interface on "+typeMono.FullName+": '"+ifaceMono.FullName+"'");
nsInterfaces.AddChildren(mi.Status);
}
// serializable attribute
// AddFakeAttribute (typeMono.IsSerializable, typeMS.IsSerializable, "System.SerializableAttribute");
AddFakeAttribute(typeMono.IsAutoLayout, typeMS.IsAutoLayout, "System.AutoLayoutAttribute");
AddFakeAttribute(typeMono.IsExplicitLayout, typeMS.IsExplicitLayout, "System.ExplicitLayoutAttribute");
AddFakeAttribute(typeMono.IsLayoutSequential, typeMS.IsLayoutSequential, "System.SequentialLayoutAttribute");
Accessibility accessibilityMono = GetAccessibility(typeMono);
Accessibility accessibilityMS = GetAccessibility(typeMS);
if (accessibilityMono != accessibilityMS)
{
m_nodeStatus.AddWarning("Should be " + AccessibilityToString(accessibilityMono));
}
AddFlagWarning(typeMono.IsSealed, typeMS.IsSealed, "sealed");
AddFlagWarning(typeMono.IsAbstract, typeMS.IsAbstract, "abstract");
}
// sum up the sub-sections
m_nodeStatus.Add(nsAttributes);
m_nodeStatus.Add(nsMethods);
m_nodeStatus.Add(nsProperties);
m_nodeStatus.Add(nsEvents);
m_nodeStatus.Add(nsFields);
m_nodeStatus.Add(nsConstructors);
m_nodeStatus.Add(nsNestedTypes);
m_nodeStatus.Add(nsInterfaces);
return(m_nodeStatus);
}
