コード例 #1
0
        public MethodMetadata MapToDeserialize(MethodMetadataBase metadata)
        {
            MethodMetadata methodMetadata = new MethodMetadata
            {
                Name      = metadata.Name,
                Extension = metadata.Extension
            };
            Type         type = metadata.GetType();
            PropertyInfo genericArgumentsProperty = type.GetProperty("GenericArguments", BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);

            if (genericArgumentsProperty?.GetValue(metadata) != null)
            {
                List <TypeMetadataBase> genericArguments = (List <TypeMetadataBase>)ConvertionUtilities.ConvertList(typeof(TypeMetadataBase), (IList)genericArgumentsProperty?.GetValue(metadata));
                methodMetadata.GenericArguments = genericArguments.Select(g => TypeMetadataMapper.EmitTypeForDeserialization(g)).ToList();
            }
            methodMetadata.Modifiers = metadata.Modifiers;
            PropertyInfo parametersProperty = type.GetProperty("Parameters", BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);

            if (parametersProperty?.GetValue(metadata) != null)
            {
                List <ParameterMetadataBase> parameters = (List <ParameterMetadataBase>)ConvertionUtilities.ConvertList(typeof(ParameterMetadataBase), (IList)parametersProperty?.GetValue(metadata));
                methodMetadata.Parameters = parameters.Select(p => new ParameterMetadataMapper().MapToDeserialize(p)).ToList();
            }
            PropertyInfo     returnTypeProperty = type.GetProperty("ReturnType", BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
            TypeMetadataBase returnType         = (TypeMetadataBase)returnTypeProperty?.GetValue(metadata);

            if (returnType != null)
            {
                methodMetadata.ReturnType = TypeMetadataMapper.EmitTypeForDeserialization(returnType);
            }
            return(methodMetadata);
        }
コード例 #2
0
        public NamespaceMetadata MapToDeserialize(NamespaceMetadataBase metadata)
        {
            NamespaceMetadata namespaceMetadata = new NamespaceMetadata
            {
                NamespaceName = metadata.NamespaceName
            };
            Type                    type          = metadata.GetType();
            PropertyInfo            typesProperty = type.GetProperty("Types", BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
            List <TypeMetadataBase> types         = (List <TypeMetadataBase>)ConvertionUtilities.ConvertList(typeof(TypeMetadataBase), (IList)typesProperty?.GetValue(metadata));

            if (types != null)
            {
                namespaceMetadata.Types = types.Select(n => TypeMetadataMapper.EmitTypeForDeserialization(n)).ToList();
            }
            return(namespaceMetadata);
        }
コード例 #3
0
        public ParameterMetadata MapToDeserialize(ParameterMetadataBase metadata)
        {
            ParameterMetadata parameterMetadata = new ParameterMetadata
            {
                Name = metadata.Name
            };
            Type             type         = metadata.GetType();
            PropertyInfo     typeProperty = type.GetProperty("TypeMetadata", BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly);
            TypeMetadataBase typeModel    = (TypeMetadataBase)typeProperty?.GetValue(metadata);

            if (typeModel != null)
            {
                parameterMetadata.TypeMetadata = TypeMetadataMapper.EmitTypeForDeserialization(typeModel);
            }
            return(parameterMetadata);
        }