private static string TypeName(Type type) { if (type.IsGenericType && type.GetGenericTypeDefinition().FullName.StartsWith("System.Nullable")) { return(provider.GetTypeOutput(new System.CodeDom.CodeTypeReference(type.GetGenericArguments()[0])) + "?"); } return(provider.GetTypeOutput(new System.CodeDom.CodeTypeReference(type))); }
/// <summary> /// Gets the CSharp type indicated by the specified value. /// </summary> /// <param name="typeName">Name of the type.</param> /// <param name="isNullableType">if set to <c>true</c> [is nullable type].</param> /// <returns></returns> public static string GetCSharpTypeOutput(string typeName, bool isNullableType) { Guard.ArgumentNotNullOrEmptyString(typeName, "typeName"); if (isNullableType && CanBeNullable(typeName)) { typeName = string.Format(CultureInfo.InvariantCulture, "System.Nullable`1[{0}]", typeName); } string output = csProvider.GetTypeOutput(new CodeTypeReference(typeName)); return(FormatAlreadyConverted(typeName, output)); }
/// <summary> /// Detemines whether the specific type name represents a given .NET type within the context of a given /// language (only C# and VB are supported). For example, List(Of System.Int32) and List(Of Integer) /// within VB both represent the .NET type List``1[System.Int32] /// </summary> private static bool IsType(string languageSpecificLongTypeName, Type type, string languageGuid) { // Normalise both type names into language-specific ones with short type names (e.g, System.Collections.Generic.List<int>) // since that's the only direction we can go without manually parsing language-specific type names into CLR-style ones CodeDomProvider codeDomProvider = string.Equals(languageGuid, VsConstants.VbCodeModelLanguageGuid, StringComparison.OrdinalIgnoreCase) ? (CodeDomProvider) new VBCodeProvider() : new CSharpCodeProvider(); var languageSpecificType = codeDomProvider.GetTypeOutput(new CodeTypeReference(type)); var codeTypeRefLanguageSpecificType = ShortenLanguageSpecificTypeName(languageSpecificLongTypeName, languageGuid); return(string.Equals(codeTypeRefLanguageSpecificType, languageSpecificType, StringComparison.Ordinal)); }
private ViewLocationResult CreateViewLocationWithModel(Type expectedType, CodeDomProvider provider, string modelDirective) { var codeTypeRef = new CodeTypeReference(expectedType); var modelType = provider.GetTypeOutput(codeTypeRef); var modelTypeCode = BuildCodeExtractingModelType(provider); var view = string.Format("@{0} {1}\n\n@{2}", modelDirective, modelType, modelTypeCode); return(new ViewLocationResult( string.Empty, string.Empty, string.Concat(provider.FileExtension, "html"), () => new StringReader(view) )); }
private static string [] GetStaticEventDefinitionPath(CodeDomProvider codeDomProvider, CodeMemberEvent @event) { var isStatic = @event.Attributes.HasBitMask(MemberAttributes.Static) && @event.PrivateImplementationType == null; if (!isStatic) { return(null); } var path = new List <string> ( ); switch (@event.Attributes & MemberAttributes.AccessMask) { case MemberAttributes.Assembly: path.Add("internal "); break; case MemberAttributes.FamilyAndAssembly: path.Add("internal "); break; case MemberAttributes.Family: path.Add("protected "); break; case MemberAttributes.FamilyOrAssembly: path.Add("protected internal "); break; case MemberAttributes.Private: path.Add("private "); break; case MemberAttributes.Public: path.Add("public "); break; } path.Add("event "); path.Add(codeDomProvider.GetTypeOutput(@event.Type)); path.Add(" "); path.Add(codeDomProvider.CreateEscapedIdentifier(@event.Name)); return(path.ToArray( )); }
public static string GetFriendlyName(Type type) { return(_codeDomProvider.GetTypeOutput(ResolveTypeReference(type))); }
static string ToCSharp(Type type) { string r = cs.GetTypeOutput(new CodeTypeReference(type)); return(r != type.FullName ? r : type.Name); }
public static string GetCSharpName(this Type type) { var reference = new System.CodeDom.CodeTypeReference(type); return(s_csharpCodeDomProvider.GetTypeOutput(reference)); }
internal static string GetTypeName(CodeDomProvider codeProvider, string string1, string string2) { string str2 = codeProvider.GetTypeOutput(Type(typeof(Activator))).Replace("System", "").Replace("Activator", ""); return(string1 + str2 + string2); }
/// <summary> /// Gets a compilable, readability-optimized string representation of the specified type. /// </summary> /// <remarks> /// Adapted from: <a href="https://stackoverflow.com/a/6402967/356790" />. /// Adapted from: <a href="https://stackoverflow.com/questions/1362884/is-there-a-way-to-get-a-types-alias-through-reflection" />. /// </remarks> /// <param name="type">The type.</param> /// <param name="throwIfNoCompilableStringExists">Optional value indicating whether to throw a <see cref="NotSupportedException"/> if there's no compilable representation of the specified type.</param> /// <returns> /// A compilable, readability-optimized string representation of the specified type /// OR /// null if there is no compilable representation and <paramref name="throwIfNoCompilableStringExists"/> is true. /// </returns> /// <exception cref="ArgumentNullException"><paramref name="type"/> is null.</exception> /// <exception cref="NotSupportedException"><paramref name="throwIfNoCompilableStringExists"/> is true and <paramref name="type"/> is a generic open constructed type, which is not supported.</exception> /// <exception cref="NotSupportedException"><paramref name="throwIfNoCompilableStringExists"/> is true and <paramref name="type"/> is a generic parameter.</exception> public static string ToStringCompilable( this Type type, bool throwIfNoCompilableStringExists = false) { if (type == null) { throw new ArgumentNullException(nameof(type)); } string result; if (type.IsClosedAnonymousType()) { if (throwIfNoCompilableStringExists) { throw new NotSupportedException("Anonymous types are not supported."); } else { result = null; } } else if (type.IsGenericParameter) { if (throwIfNoCompilableStringExists) { // note that IsGenericParameter and ContainsGenericParameters will return true for generic parameters, // hence we order the IsGenericParameter check first. throw new NotSupportedException("Generic parameters not supported."); } else { result = null; } } else { if (ValueTypeToAliasMap.ContainsKey(type)) { result = ValueTypeToAliasMap[type]; } else if (type.IsClosedNullableType()) { result = Nullable.GetUnderlyingType(type).ToStringCompilable() + "?"; } else if (type.IsArray) { result = type.GetElementType().ToStringCompilable() + "[]"; } else { result = CodeDomProvider.GetTypeOutput(new CodeTypeReference(type.FullName?.Replace(type.Namespace + ".", string.Empty))); if (type.IsGenericType) { if (type.IsGenericTypeDefinition) { result = result.Replace(" ", string.Empty); } else if (type.ContainsGenericParameters) { if (throwIfNoCompilableStringExists) { throw new NotSupportedException("Generic open constructed types are not supported."); } else { result = null; } } else { var genericParameters = type.GenericTypeArguments.Select(_ => _.ToStringCompilable()).ToArray(); result = GenericBracketsRegex.Replace(result, "<" + string.Join(", ", genericParameters) + ">"); } } } } return(result); }
public string GetTypeOutput(CodeTypeReference type) { return(provider.GetTypeOutput(type)); }