/// <inheritdocs /> public override string ToString() { var result = Type.Name.Split('`').First() + ": " + Nullability + "\n " + string.Join("\n", GenericArguments.Select(a => a.ToString())).Replace("\n", "\n "); return(result.Trim()); }
public MethodModel ToModel() { MethodModel methodModel = new MethodModel { Name = Name, GenericArguments = GenericArguments?.Select(typeModel => typeModel.ToModel()), Modifiers = new Tuple<AccessLevelEnum, AbstractEnum, StaticEnum, VirtualEnum, OverrideEnum>( EnumMapper.ConvertEnum<AccessLevelEnum, AccessLevelEnumMetadata>(Modifiers.Item1), EnumMapper.ConvertEnum<AbstractEnum, AbstractEnumMetadata>(Modifiers.Item2), EnumMapper.ConvertEnum<StaticEnum, StaticEnumMetadata>(Modifiers.Item3), EnumMapper.ConvertEnum<VirtualEnum, VirtualEnumMetadata>(Modifiers.Item4), EnumMapper.ConvertEnum<OverrideEnum, OverrideEnumMetadata>(Modifiers.Item5) ), ReturnType = ReturnType, Extension = Extension, Parameters = Parameters?.Select(parameterModel => parameterModel.ToModel()) }; return methodModel; }
public TypeModel ToModel() { TypeModel model = new TypeModel(); model.TypeEnum = EnumMapper.ConvertEnum <TypeTypesEnum, TypeTypesSerializationModelEnum>(TypeEnum); model.TypeName = TypeName; model.NamespaceName = NamespaceName; model.GenericArguments = GenericArguments?.Select(EmitTypeModel); model.Modifiers = new Tuple <AccessLevelEnum, SealedEnum, AbstractEnum>( EnumMapper.ConvertEnum <AccessLevelEnum, AccessLevelSerializationModelEnum>(Modifiers.Item1), EnumMapper.ConvertEnum <SealedEnum, SealedSerializationModelEnum>(Modifiers.Item2), EnumMapper.ConvertEnum <AbstractEnum, AbstractSerializationModelEnum>(Modifiers.Item3)); model.Attributes = Attributes?.Select(attributeMetadata => attributeMetadata.ToModel()); model.FullTypeName = FullTypeName; model.DeclaringType = DeclaringType == null ? null : EmitTypeModel(DeclaringType); model.BaseType = DeclaringType == null ? null : EmitTypeModel(BaseType); model.ImplementedInterfaces = ImplementedInterfaces?.Select(EmitTypeModel); model.Fields = Fields?.Select(typeModel => typeModel.ToModel()); model.Methods = Methods?.Select(typeModel => typeModel.ToModel()); model.Properties = Properties?.Select(typeModel => typeModel.ToModel()); model.Indexers = Indexers?.Select(typeModel => typeModel.ToModel()); model.Events = Events?.Select(typeModel => typeModel.ToModel()); model.Constructors = Constructors?.Select(typeModel => typeModel.ToModel()); model.NestedTypes = NestedTypes?.Select(EmitTypeModel); return(model); }
public MethodModel ToModel() { MethodModel methodModel = new MethodModel(); methodModel.Name = Name; methodModel.GenericArguments = GenericArguments?.Select(typeModel => typeModel.ToModel()); methodModel.Modifiers = new Tuple <AccessLevelEnum, AbstractEnum, StaticEnum, VirtualEnum, OverrideEnum> ( EnumMapper.ConvertEnum <AccessLevelEnum, AccessLevelDbModelEnum>(Item1), EnumMapper.ConvertEnum <AbstractEnum, AbstractDbModelEnum>(Item2), EnumMapper.ConvertEnum <StaticEnum, StaticDbModelEnum>(Item3), EnumMapper.ConvertEnum <VirtualEnum, VirtualDbModelEnum>(Item4), EnumMapper.ConvertEnum <OverrideEnum, OverrideDbModelEnum>(Item5) ); methodModel.ReturnType = ReturnType; methodModel.Extension = Extension; methodModel.Parameters = Parameters?.Select(parameterModel => parameterModel.ToModel()); return(methodModel); }
string FormatForDisplay(Func <TypeIdentifier, string> displayNameSelector) { string languageName; if (LanguageNames.TryGetValue(FullName, out languageName)) { return(languageName); } if (IsAnonymous) { return("Anonymous"); } var result = displayNameSelector(this); if (GenericArguments.Length > 0) { result += "<"; result += string.Join(", ", GenericArguments.Select(a => a.FormatForDisplay(displayNameSelector))); result += ">"; } result += Modifiers; return(result); }
public override ObjectFragment Build() { var result = new ObjectFragment() { Name = Name, ModuleName = ModuleName, GenericArguments = GenericArguments.Select(a => new GenericArgumentDefinition(a)).ToArray(), }; foreach (var constant in Constants) { result.Constants.Add(constant.Build()); } foreach (var field in Fields) { result.Fields.Add(field.Build()); } foreach (var hint in Hints) { result.Hints.Add(hint); } return(result); }
/// <summary> /// Returns the CLR <see cref="MemberInfo"/>. /// </summary> /// <returns>Returns the CLR <see cref="MemberInfo"/>.</returns> public override MemberInfo GetClrVersion() { InterLinqTypeSystem tsInstance = InterLinqTypeSystem.Instance; lock (tsInstance) { if (tsInstance.IsInterLinqMemberInfoRegistered(this)) { return(tsInstance.GetClrVersion <MethodInfo>(this)); } Type declaringType = (Type)DeclaringType.GetClrVersion(); Type[] genericArgumentTypes = GenericArguments.Select(p => (Type)p.GetClrVersion()).ToArray(); MethodInfo foundMethod = null; foreach (MethodInfo method in declaringType.GetMethods().Where(m => m.Name == Name)) { MethodInfo currentMethod = method; if (currentMethod.IsGenericMethod) { if (currentMethod.GetGenericArguments().Length == genericArgumentTypes.Length) { currentMethod = currentMethod.MakeGenericMethod(genericArgumentTypes); } else { continue; } } ParameterInfo[] currentParameters = currentMethod.GetParameters(); if (ParameterTypes.Count == currentParameters.Length) { bool allArumentsFit = true; for (int i = 0; i < ParameterTypes.Count && i < currentParameters.Length; i++) { Type currentArg = (Type)ParameterTypes[i].GetClrVersion(); Type currentParamType = currentParameters[i].ParameterType; if (!currentParamType.IsAssignableFrom(currentArg)) { allArumentsFit = false; break; } } if (allArumentsFit) { foundMethod = currentMethod; } } } if (foundMethod == null) { throw new Exception(string.Format("Method \"{0}.{1}\" not found.", declaringType, Name)); } tsInstance.SetClrVersion(this, foundMethod); return(foundMethod); } }
private string CreateFullName() { if (!GenericArguments.Any()) { return(Mapping.Name); } var genericArguments = string.Join(", ", GenericArguments.Select(a => a.Name)); return($"{Mapping.Name}<{genericArguments}>"); }
private MethodInfo GetMethodInfo() { MethodInfo mi; if (GenericArguments != null && GenericArguments.Length > 0) { mi = FindGenericMethod(MethodType, MethodName, GenericArguments.Select(p => p.GetSystemType()).ToArray(), ParameterTypes.Select(p => p.GetSystemType()).ToArray()); } else { mi = MethodType.GetMethod(MethodName, ParameterTypes.Select(p => p.GetSystemType()).ToArray()); } if (mi == null) { throw new MissingMethodException(MethodType.FullName, MethodName); } return(mi); }
public string MakeGenericName(string openBracket, string closeBracket, string commaSeparator) { if (!IsGenericType) { return(this.Name.ToString()); } if (IsGenericDefinition) { return( this.Name + openBracket + string.Join(commaSeparator, GenericParameters.Select(t => t.Name)) + closeBracket); } else { return( this.Name + openBracket + string.Join(commaSeparator, GenericArguments.Select(t => t.MakeGenericName(openBracket, closeBracket, commaSeparator))) + closeBracket); } }
public TypeDefinition(Type type) { Type = type; Name = type.Name; var typeInfo = type.GetTypeInfo(); if (typeInfo.IsGenericType) { Type[] types = type.GetGenericArguments(); if (type.GetGenericTypeDefinition() == typeof(Nullable <>)) { Type = type.GetGenericArguments()[0]; } Name = Name.Replace("`" + types.Length, "Of" + string.Join("", types.Select(p => p.Name))); } FullName = type.FullName; GetPrimitiveInfo(Type); IsArray = typeInfo.IsArray; if (!IsPrimitive && typeof(IEnumerable).IsAssignableFrom(type)) { IsEnumerable = true; } if (IsEnumerable) { if (typeof(IDictionary).IsAssignableFrom(type)) { IsDictionary = true; } var elementType = type.GetElementType(); if (elementType != null) { Name = "ArrayOf" + elementType.Name; } if (typeInfo.IsGenericType) { GenericArguments = type.GetGenericArguments(); if (elementType == null) { Name = "ArrayOf" + string.Join("", GenericArguments.Select(p => p.Name)); } if (IsDictionary) { MethodAddToDictionary = ObjectAccessors.CreateMethodAddToDictionary(type); } else { MethodAddToCollection = ObjectAccessors.CreateMethodAddCollection(type); } } } IsObjectToSerialize = // !typeInfo.IsPrimitive && !typeInfo.IsValueType && !IsPrimitive && !typeInfo.IsEnum && type != typeof(string) && //not generic or generic but not List<> and Set<> (!typeInfo.IsGenericType || (typeInfo.IsGenericType && !typeof(IEnumerable).IsAssignableFrom(type))); if (IsObjectToSerialize) { Properties = GetPropertieToSerialze(type); } ObjectActivator = ObjectAccessors.CreateObjectActivator(type, IsPrimitive); }
public string ToGenericArgumentsString() { return(IsGeneric ? $"<{string.Join(", ", GenericArguments.Select(a => a.ToString()))}>" : ""); }
public TypeName GetGenericTypeDefinition() { return(Create(rawName, AssemblyName, GenericArguments.Select(t => Maybe <TypeName> .Empty), OrderOfArray)); }
public TypeDefinition(Type type) { Type = type; Name = type.Name; var typeInfo = type.GetTypeInfo(); var isGenericType = typeInfo.IsGenericType; if (isGenericType) { var types = type.GetGenericArguments(); if (type.GetGenericTypeDefinition() == typeof(Nullable <>)) { Type = type.GetGenericArguments()[0]; } Name = Name.Replace("`" + types.Length, "Of" + string.Join("", types.Select(p => p.Name))); } FullName = type.FullName; GetPrimitiveInfo(Type); IsArray = typeInfo.IsArray; IsEnumerable = !IsPrimitive && typeof(IEnumerable).IsAssignableFrom(type); if (IsEnumerable) { IsDictionary = typeof(IDictionary).IsAssignableFrom(type); var elementType = ElementTypeLocator.Default.Locate(type); if (isGenericType) { GenericArguments = type.GetGenericArguments(); } else if (elementType != null) { GenericArguments = new[] { elementType }; } Name = IsArray || isGenericType ? $"ArrayOf{string.Join(string.Empty, GenericArguments.Select(p => p.Name))}" : type.Name; if (IsDictionary) { MethodAddToDictionary = ObjectAccessors.CreateMethodAddToDictionary(type); } else if (elementType != null && !IsArray) { MethodAddToCollection = ObjectAccessors.CreateMethodAddCollection(type, elementType); } } var attribute = typeInfo.GetCustomAttribute <XmlRootAttribute>(); if (attribute != null) { Name = attribute.ElementName; } IsObjectToSerialize = // !typeInfo.IsPrimitive && !typeInfo.IsValueType && !IsPrimitive && !typeInfo.IsEnum && type != typeof(string) && //not generic or generic but not List<> and Set<> (!isGenericType || !IsEnumerable); _properties = new Lazy <IEnumerable <PropertieDefinition> >(GetPropertieToSerialze); ObjectActivator = ObjectAccessors.CreateObjectActivator(type, IsPrimitive); }