예제 #1
0
 static Accessibility GetAccessibility(Type type)
 {
     if (type.IsPublic)
     {
         return(Accessibility.Public);
     }
     else if (type.IsNotPublic)
     {
         return(Accessibility.Private);
     }
     return(MissingMember.GetAccessibility(type));
 }
예제 #2
0
        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());
            }
        }
예제 #3
0
        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);
        }