C# Compilation.ClassifyConversion方法代码示例

        /// <summary>
        /// Takes a set of types and returns the most "constrained" type that all of them can be converted to.
        /// 
        /// Worst case, it returns a TypeSyntax for `object`.
        /// 
        /// If the appropriate type is an anonymous one, `replaceType` contains a Tuple of that anonymous type and the 
        /// name of a new one that should be created to take its place.
        /// </summary>
        private static TypeSyntax FindCommonType(IEnumerable<TypeInfo> info, Compilation comp, out Tuple<NamedTypeSymbol, string> replaceType)
        {
            if (info.Any(a => a.Equals(TypeInfo.None)))
            {
                replaceType = null;
                return null;
            }

            var allPossibilities = info.SelectMany(i => i.Type.AllInterfaces).OfType<NamedTypeSymbol>().ToList();

            allPossibilities.AddRange(info.Select(s => s.Type).OfType<NamedTypeSymbol>());

            foreach (var i in info)
            {
                var @base = i.Type.BaseType;
                while (@base != null)
                {
                    allPossibilities.Add(@base);
                    @base = @base.BaseType;
                }
            }

            // Order so that subclasses are before superclasses, classes are before interfaces,
            //   special interfaces first, and generic types are before non-generic ones
            //   with the special case that System.Object is always the *last* option
            //   uses type name as a tie-breaker for ordering
            //
            // Special interfaces are anything that gets special treatment in the language, which for now is IEnumerable<T> and IEnumerable
            allPossibilities.Sort(
                (a, b) =>
                {
                    var aIsNotObject = a.TypeKind != TypeKind.Class || a.BaseType != null;
                    var bIsNotObject = b.TypeKind != TypeKind.Class || b.BaseType != null;

                    var aIsNotInterface = a.TypeKind != TypeKind.Interface;
                    var bIsNotInferface = b.TypeKind != TypeKind.Interface;

                    // Get both IEnumerable && IEnumerable<T>
                    var aIsSpecial = a.Name == "IEnumerable";
                    var bIsSpecial = b.Name == "IEnumerable";

                    var aIsSubclassOfB = IsSubclass(a, b);
                    var bIsSubclassOfA = IsSubclass(b, a);

                    if (aIsNotObject && !bIsNotObject) return -1;
                    if (bIsNotObject && !aIsNotObject) return 1;

                    if (aIsSubclassOfB) return -1;
                    if (bIsSubclassOfA) return 1;

                    if (aIsNotInterface && !bIsNotInferface) return -1;
                    if (bIsNotInferface && !aIsNotInterface) return 1;

                    if (!aIsNotInterface && !bIsNotInferface)
                    {
                        if (aIsSpecial && !bIsSpecial) return -1;
                        if (bIsSpecial && !aIsSpecial) return 1;
                    }

                    if (a.IsGenericType && !b.IsGenericType) return -1;
                    if (b.IsGenericType && !a.IsGenericType) return 1;

                    return a.MetadataName.CompareTo(b.MetadataName);
                }
            );

            var commonType =
                allPossibilities.First(
                    t =>
                    {
                        var conversions = info.Select(a => comp.ClassifyConversion(a.Type, t)).ToList();

                        return conversions.All(a => a.Exists && a.IsImplicit);
                    }
                );

            string fullName;

            // we actually need to *replace* this type so we can put it in the returns
            if (commonType.IsAnonymousType)
            {
                fullName = "__FTI" + Guid.NewGuid().ToString().Replace("-", "");
                replaceType = Tuple.Create(commonType, fullName);
            }
            else
            {
                fullName = commonType.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
                replaceType = null;
            }

            return Syntax.ParseTypeName(fullName);
        }

 protected override bool DoesConversionExist(Compilation compilation, ITypeSymbol source, ITypeSymbol destination)
 {
     return compilation.ClassifyConversion(source, destination).Exists;
 }

        internal static bool AreEquivalent(TypeSymbol a, TypeSymbol b, Compilation comp)
        {
            var aMembers = a.GetMembers().OfType<PropertySymbol>().ToList();
            var bMembers = b.GetMembers().OfType<PropertySymbol>().ToList();

            if (aMembers.Count != bMembers.Count) return false;

            for (var i = 0; i < aMembers.Count; i++)
            {
                var aMember = aMembers[i];
                var bMember = bMembers[i];

                if (aMember.Name != bMember.Name) return false;
                if (aMember.DeclaredAccessibility != bMember.DeclaredAccessibility) return false;

                var aType = aMember.Type;
                var bType = bMember.Type;

                var aName = aType.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
                var bName = bType.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);

                if (aName == bName) continue;

                var conv = comp.ClassifyConversion(aType, bType);

                if (!conv.IsIdentity) return false;
            }

            return true;
        }