Esempio n. 1
0
        internal static void WriteFriendlyName(
            this TranslationBuffer buffer,
            Type type,
            TranslationSettings settings)
        {
            if (type.FullName == null)
            {
                // An open generic parameter Type:
                return;
            }

            if (type.IsArray)
            {
                buffer.WriteFriendlyName(type.GetElementType(), settings);
                buffer.WriteToTranslation("[]");
                return;
            }

            if (!type.IsGenericType())
            {
                var substitutedTypeName = type.GetSubstitutionOrNull();

                if (type.IsNested)
                {
                    buffer.WriteFriendlyName(type.DeclaringType, settings);
                    buffer.WriteToTranslation('.');
                    buffer.WriteToTranslation(substitutedTypeName ?? type.Name);
                    return;
                }

                if (substitutedTypeName != null)
                {
                    buffer.WriteToTranslation(substitutedTypeName);
                    return;
                }

                buffer.WriteTypeNamespaceIfRequired(type, settings);
                buffer.WriteToTranslation(type.Name);
                return;
            }

            Type underlyingNullableType;

            if ((underlyingNullableType = Nullable.GetUnderlyingType(type)) == null)
            {
                buffer.WriteGenericTypeName(type, settings);
                return;
            }

            buffer.WriteFriendlyName(underlyingNullableType, settings);
            buffer.WriteToTranslation('?');
        }
Esempio n. 2
0
        private static void WriteClosedGenericTypeName(
            this TranslationBuffer buffer,
            Type genericType,
            ref Type[] typeGenericTypeArguments,
            TranslationSettings settings)
        {
            var typeName = genericType.Name;

            var backtickIndex = typeName.IndexOf("`", StringComparison.Ordinal);

            if (backtickIndex == -1)
            {
                buffer.WriteToTranslation(typeName);
                return;
            }

            var numberOfParameters = int.Parse(typeName.Substring(backtickIndex + 1));

            Type[] typeArguments;

            if (numberOfParameters == typeGenericTypeArguments.Length)
            {
                typeArguments = typeGenericTypeArguments;
                goto WriteName;
            }

            switch (numberOfParameters)
            {
            case 1:
                typeArguments = new[] { typeGenericTypeArguments[0] };
                break;

            case 2:
                typeArguments = new[] { typeGenericTypeArguments[0], typeGenericTypeArguments[1] };
                break;

            default:
                typeArguments = new Type[numberOfParameters];

                Array.Copy(
                    typeGenericTypeArguments,
                    typeArguments,
                    numberOfParameters);

                break;
            }

            var numberOfRemainingTypeArguments = typeGenericTypeArguments.Length - numberOfParameters;
            var typeGenericTypeArgumentsSubset = new Type[numberOfRemainingTypeArguments];

            Array.Copy(
                typeGenericTypeArguments,
                numberOfParameters,
                typeGenericTypeArgumentsSubset,
                0,
                numberOfRemainingTypeArguments);

            typeGenericTypeArguments = typeGenericTypeArgumentsSubset;

WriteName:
            buffer.WriteGenericTypeName(genericType, numberOfParameters, typeArguments, settings);
        }