public static string CreateMultipleComplexTypesClassInstance(MethodDeclarationSyntax wcfClientMethod, string serviceComplexTypeParamName, IEnumerable <MethodDeclarationSyntax> wcfServiceMethods) { // handle if method has two or more (i.e. "multiple") complex types parameters var wcfServiceMethod = MethodsGenerator.FindWcfServiceMethod(wcfClientMethod, wcfServiceMethods); var wcfServiceParameters = wcfServiceMethod .ParameterList .Parameters; var multipleComplexParameters = MultipleComplexTypesGenerator.FindMultipleComplexTypesOrOutKeyword(wcfServiceParameters); // get the param names and use as anonymous class property names var properties = multipleComplexParameters.Any() ? multipleComplexParameters .Select(parameter => { var name = parameter.Identifier.ToFullString(); return(name); }) .Aggregate((name1, name2) => $"{name1},{name2}") : ""; // create anonymous class instance with complex type properties var hasComplexTypeProperties = !string.IsNullOrEmpty(properties); var classInstance = hasComplexTypeProperties ? $@"var {serviceComplexTypeParamName} = new {{{properties}}};" : ""; return(classInstance); }
public static async Task <string> CreateComplexTypeClass(MethodDeclarationSyntax wcfMethod, string methodName, bool isActiveWcfMethod) { if (!isActiveWcfMethod) { return(""); } var parameters = wcfMethod.ParameterList.Parameters; // add return type as class property if has 'out' keyword if (!OutKeywordGenerator.AnyHaveOutKeyword(parameters)) { return(""); } // create complex class var className = ComplexTypeNamesMapper.MapToClientComplexClassName(methodName); var complexClassDeclaration = await MultipleComplexTypesGenerator.CreateClassFromComplexTypes(parameters, className); // create return type property var wcfReturnType = wcfMethod.ReturnType.NormalizeWhitespace().ToFullString(); var returnTypePropertyCode = $"public {wcfReturnType} Result {{ get; set;}}"; var returnTypeProperty = (await CodeParser.ConvertToMemberDeclarations(returnTypePropertyCode)).Single(); // add return type property to complex class var members = complexClassDeclaration.Members.Add(returnTypeProperty); complexClassDeclaration = complexClassDeclaration.WithMembers(members); var complexTypeClass = complexClassDeclaration?.NormalizeWhitespace().ToFullString(); return(complexTypeClass); }
private static async Task <IEnumerable <MemberDeclarationSyntax> > CreateMethods(string controllerName, MethodDeclarationSyntax wcfMethod, string wcfClassName, IDictionary <string, string> duplicateMethodNamesMap, bool isAsmx) { var members = new List <MemberDeclarationSyntax>(); var wcfMethodName = wcfMethod.Identifier.ValueText; var wcfParameters = wcfMethod.ParameterList.Parameters; // create method & parameter names var methodName = DuplicateMethodNamesGenerator.TransformMethodNameIfDuplicate(duplicateMethodNamesMap, wcfMethodName, wcfParameters); var parameters = ServiceCodeParametersGenerator.CreateParameters(wcfParameters); parameters = ServiceCodeMultipleComplexTypesGenerator.TransformMultipleComplexTypeParameters(parameters, methodName); // create service type for method comment var serviceType = ServiceNamesMapper.GetServiceTypeName(isAsmx); // create http verb var httpVerb = CreateHttpVerb(wcfMethodName, parameters); // create route name var routeUriTemplate = ServiceNamesMapper.MapToRouteUriTemplate(controllerName, methodName); // create return type var wcfReturnType = wcfMethod .ReturnType .NormalizeWhitespace() .ToFullString(); var returnType = ServiceCodeOutKeywordGenerator.TransformOutKeywordReturnType(wcfReturnType, wcfParameters, methodName); // create method block arguments var arguments = CreateWcfArguments(wcfParameters); arguments = ServiceCodeMultipleComplexTypesGenerator.TransformMultipleComplexTypeArguments(arguments, wcfParameters, methodName); // create method block var block = CreateMethodBlock(wcfClassName, wcfMethodName, arguments, returnType); block = ServiceCodeOutKeywordGenerator.TransformBlockWithOutKeyword(block, wcfParameters, arguments, methodName); // create new method var method = await CreateMethodDeclaration(methodName, httpVerb, routeUriTemplate, parameters, block, returnType, serviceType); // add nested class model if have multiple complex params var className = ComplexTypeNamesMapper.MapToServiceComplexClassType(methodName); var complexClass = await MultipleComplexTypesGenerator.CreateClassFromComplexTypes(wcfParameters, className); if (complexClass != null) { complexClass = ServiceCodeOutKeywordGenerator.TransformComplexClassWithOutKeyword(complexClass, wcfParameters, wcfReturnType); members.Add(complexClass); } // add new method members.Add(method); return(members); }
public static List <SyntaxNodeOrToken> TransformMultipleComplexTypeArguments(List <SyntaxNodeOrToken> arguments, SeparatedSyntaxList <ParameterSyntax> wcfParameters, string wcfMethodName) { var complexParameters = MultipleComplexTypesGenerator.FindMultipleComplexTypesOrOutKeyword(wcfParameters); if (!complexParameters.Any()) { return(arguments); } // replace all complex type arguments with complex type class properties // if any arguments already have 'out' keyword then will be ignored var newArguments = arguments .Select(nodeOrToken => { var argument = (ArgumentSyntax)nodeOrToken; var isArgument = argument != null; if (!isArgument) { return(nodeOrToken); } var argumentName = argument .NormalizeWhitespace() .ToFullString(); var isComplexArgument = complexParameters .Select(parameter => parameter.Identifier.ValueText) .Contains(argumentName); if (!isComplexArgument) { return(argument); } var complexTypeArgumentName = ComplexTypeNamesMapper.MapToComplexTypeArgument(wcfMethodName, argumentName); var complexTypeArgument = SyntaxFactory.Argument(SyntaxFactory.IdentifierName(complexTypeArgumentName)); return(complexTypeArgument); }) .ToList(); return(newArguments); }
public static SeparatedSyntaxList <ParameterSyntax> TransformMultipleComplexTypeParameters(SeparatedSyntaxList <ParameterSyntax> originalParameters, string methodName) { // handle if parameters have more two or more (i.e. multiple) complex types var complexParameters = MultipleComplexTypesGenerator.FindMultipleComplexTypesOrOutKeyword(originalParameters); if (!complexParameters.Any()) { return(originalParameters); } var parameters = new SeparatedSyntaxList <ParameterSyntax>(); // remove all complex types from parameters var complexNames = complexParameters .Select(complex => complex.Identifier.ToFullString()); var filteredParameters = originalParameters .Where(parameter => { var name = parameter.Identifier.ToFullString(); return(complexNames.All(complexName => complexName != name)); }); parameters = parameters.AddRange(filteredParameters); // add single complex class type parameter var complexType = ComplexTypeNamesMapper.MapToServiceComplexClassType(methodName); var complexParameterName = ComplexTypeNamesMapper.MapToComplexClassParameterName(methodName); var complexTypeClass = SyntaxFactory.Parameter(SyntaxFactory.Identifier(complexParameterName)) .WithType(SyntaxFactory.IdentifierName(complexType)); // insert complex type before any optional parameters with default values // otherwise insert at the end var insertIndex = ParametersGenerator.FindIndexBeforeFirstOptionalParam(parameters); parameters = parameters.Insert(insertIndex, complexTypeClass); return(parameters); }