private static string CheckILambdaSerializerType()

in Libraries/src/Amazon.Lambda.RuntimeSupport/Bootstrap/UserCodeValidator.cs [137:226]
70 lines of code
15 McCabe index (conditional complexity)

        private static string CheckILambdaSerializerType(TypeInfo typeInfo)
        {
            if (!typeInfo.IsInterface)
            {
                return LambdaExceptions.FormatMessage(Errors.UserCodeLoader.ILambdaSerializerMismatch_TypeNotInterface, typeInfo.FullName);
            }

            // check that the Deserialize method exists and is generic
            var deserializeMethodInfo = typeInfo.GetMethod("Deserialize");
            if (deserializeMethodInfo == null)
            {
                return Errors.UserCodeLoader.ILambdaSerializerMismatch_DeserializeMethodNotFound;
            }

            if (!deserializeMethodInfo.IsGenericMethod)
            {
                return Errors.UserCodeLoader.ILambdaSerializerMismatch_DeserializeMethodNotGeneric;
            }

            // verify that Stream is the only input
            var deserializeInputs = deserializeMethodInfo.GetParameters();
            if (deserializeInputs.Length != 1)
            {
                return LambdaExceptions.FormatMessage(Errors.UserCodeLoader.ILambdaSerializerMismatch_DeserializeMethodHasTooManyParams, deserializeInputs.Length);
            }

            if (deserializeInputs[0].ParameterType != Types.StreamType)
            {
                return LambdaExceptions.FormatMessage(Errors.UserCodeLoader.ILambdaSerializerMismatch_DeserializeMethodHasWrongParam, deserializeInputs[0].ParameterType.FullName,
                    Types.StreamType.FullName);
            }

            // verify that T is the return type
            var deserializeOutputType = deserializeMethodInfo.ReturnType;
            var deserializeGenericArguments = deserializeMethodInfo.GetGenericArguments();
            if (deserializeGenericArguments.Length != 1)
            {
                return LambdaExceptions.FormatMessage(Errors.UserCodeLoader.ILambdaSerializerMismatch_DeserializeMethodHasWrongNumberGenericArgs,
                    deserializeGenericArguments.Length);
            }

            if (deserializeGenericArguments[0] != deserializeOutputType)
            {
                return LambdaExceptions.FormatMessage(Errors.UserCodeLoader.ILambdaSerializerMismatch_DeserializeMethodHasWrongReturn, deserializeOutputType.FullName);
            }

            // check that the Serialize method exists, is generic, and returns void
            var serializeMethodInfo = typeInfo.GetMethod("Serialize");
            if (serializeMethodInfo == null)
            {
                return Errors.UserCodeLoader.ILambdaSerializerMismatch_SerializeMethodNotFound;
            }

            if (!serializeMethodInfo.IsGenericMethod)
            {
                return Errors.UserCodeLoader.ILambdaSerializerMismatch_SerializeMethodNotGeneric;
            }

            if (serializeMethodInfo.ReturnType != Types.VoidType)
            {
                return LambdaExceptions.FormatMessage(Errors.UserCodeLoader.ILambdaSerializerMismatch_SerializeMethodHasWrongReturn, serializeMethodInfo.ReturnType.FullName);
            }

            // verify that T is the first input and Stream is the second input
            var serializeInputs = serializeMethodInfo.GetParameters();
            var serializeGenericArguments = serializeMethodInfo.GetGenericArguments();
            if (serializeInputs.Length != 2)
            {
                return LambdaExceptions.FormatMessage(Errors.UserCodeLoader.ILambdaSerializerMismatch_SerializeMethodHasWrongNumberOfParameters, serializeInputs.Length);
            }

            if (serializeGenericArguments.Length != 1)
            {
                return LambdaExceptions.FormatMessage(Errors.UserCodeLoader.ILambdaSerializerMismatch_SerializeMethodHasWrongNumberGenericArgs, serializeGenericArguments.Length);
            }

            if (serializeInputs[0].ParameterType != serializeGenericArguments[0])
            {
                return LambdaExceptions.FormatMessage(Errors.UserCodeLoader.ILambdaSerializerMismatch_SerializeMethodHasWrongFirstParam, serializeInputs[0].ParameterType.FullName);
            }

            if (serializeInputs[1].ParameterType != Types.StreamType)
            {
                return LambdaExceptions.FormatMessage(Errors.UserCodeLoader.ILambdaSerializerMismatch_SerializeMethodHasWrongSecondParam, serializeInputs[1].ParameterType.FullName,
                    Types.StreamType.FullName);
            }

            // all good!
            return null;
        }