Avro.Protocol.ToString C# (CSharp) Method

        public override string ToString()
        {
            using (StringWriter sw = new StringWriter())
            {
                using (Newtonsoft.Json.JsonTextWriter writer = new Newtonsoft.Json.JsonTextWriter(sw))
                {
                    #if(DEBUG)
                    writer.Formatting = Newtonsoft.Json.Formatting.Indented;
                    #endif

                    writeJson(writer);
                    writer.Flush();
                    return sw.ToString();
                }
            }
        }

        /// <summary>
        /// Generates code for an individual protocol.
        /// </summary>
        /// <param name="protocol">Protocol to generate code for.</param>
        /// <exception cref="CodeGenException">Namespace required for enum schema " + nspace.</exception>
        protected virtual void processInterface(Protocol protocol)
        {
            // Create abstract class
            string protocolNameMangled = CodeGenUtil.Instance.Mangle(protocol.Name);

            var ctd = new CodeTypeDeclaration(protocolNameMangled);

            ctd.TypeAttributes = TypeAttributes.Abstract | TypeAttributes.Public;
            ctd.IsClass        = true;
            ctd.BaseTypes.Add("Avro.Specific.ISpecificProtocol");

            AddProtocolDocumentation(protocol, ctd);

            // Add static protocol field.
            var protocolField = new CodeMemberField();

            protocolField.Attributes = MemberAttributes.Private | MemberAttributes.Static | MemberAttributes.Final;
            protocolField.Name       = "protocol";
            protocolField.Type       = new CodeTypeReference("readonly Avro.Protocol");

            var cpe  = new CodePrimitiveExpression(protocol.ToString());
            var cmie = new CodeMethodInvokeExpression(
                new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(typeof(Protocol)), "Parse"),
                new CodeExpression[] { cpe });

            protocolField.InitExpression = cmie;

            ctd.Members.Add(protocolField);

            // Add overridden Protocol method.
            var property = new CodeMemberProperty();

            property.Attributes = MemberAttributes.Public | MemberAttributes.Final;
            property.Name       = "Protocol";
            property.Type       = new CodeTypeReference("Avro.Protocol");
            property.HasGet     = true;

            property.GetStatements.Add(new CodeTypeReferenceExpression("return protocol"));
            ctd.Members.Add(property);

            // var requestMethod = CreateRequestMethod();
            // ctd.Members.Add(requestMethod);
            var requestMethod = CreateRequestMethod();

            // requestMethod.Attributes |= MemberAttributes.Override;
            var builder = new StringBuilder();

            if (protocol.Messages.Count > 0)
            {
                builder.AppendLine("switch(messageName)");
                builder.Append("\t\t\t{");

                foreach (var a in protocol.Messages)
                {
                    builder.AppendLine().Append("\t\t\t\tcase \"").Append(a.Key).AppendLine("\":");

                    bool   unused = false;
                    string type   = getType(a.Value.Response, false, ref unused);

                    builder.Append("\t\t\t\trequestor.Request<")
                    .Append(type)
                    .AppendLine(">(messageName, args, callback);");
                    builder.AppendLine("\t\t\t\tbreak;");
                }

                builder.Append("\t\t\t}");
            }

            var cseGet = new CodeSnippetExpression(builder.ToString());

            requestMethod.Statements.Add(cseGet);
            ctd.Members.Add(requestMethod);

            AddMethods(protocol, false, ctd);

            string nspace = protocol.Namespace;

            if (string.IsNullOrEmpty(nspace))
            {
                throw new CodeGenException("Namespace required for enum schema " + nspace);
            }

            CodeNamespace codens = AddNamespace(nspace);

            codens.Types.Add(ctd);

            // Create callback abstract class
            ctd = new CodeTypeDeclaration(protocolNameMangled + "Callback");
            ctd.TypeAttributes = TypeAttributes.Abstract | TypeAttributes.Public;
            ctd.IsClass        = true;
            ctd.BaseTypes.Add(protocolNameMangled);

            // Need to override
            AddProtocolDocumentation(protocol, ctd);

            AddMethods(protocol, true, ctd);

            codens.Types.Add(ctd);
        }