Avro.Message.Parse C# (CSharp) Method

        internal static Message Parse(Newtonsoft.Json.Linq.JProperty jmessage, Names names)
        {
            string name = jmessage.Name;
            string doc = JsonHelper.GetOptionalString(jmessage.Value, "doc");
            JToken jrequest = jmessage.Value["request"];
            JToken jresponse = jmessage.Value["response"];
            JToken jerrors = jmessage.Value["errors"];

            List<Parameter> request = new List<Parameter>();

            foreach (JToken jtype in jrequest)
            {
                Parameter parameter = new Parameter();
                parameter.Name = JsonHelper.GetRequiredString(jtype, "name");
                parameter.Schema = Schema.ParseJson(jtype, names);

                if (null == parameter.Schema)
                    throw new SchemaParseException(jtype.ToString());

                request.Add(parameter);
            }

            Schema response = Schema.ParseJson(jresponse, names);


            
            UnionSchema uerrorSchema = null;
            if (null != jerrors)
            {
                Schema errorSchema = Schema.ParseJson(jerrors, names);


                if (!(errorSchema is UnionSchema))
                {
                    throw new AvroException("");
                }

                uerrorSchema = errorSchema as UnionSchema;
            }



            return new Message(name, doc, request, response, uerrorSchema);


            //Message message = new Message(name, 



            //throw new NotImplementedException();
        }

        /// <summary>
        /// Parses the given JSON object to create a Protocol object
        /// </summary>
        /// <param name="jtok">JSON object</param>
        /// <returns>Protocol object</returns>
        private static Protocol Parse(JToken jtok)
        {
            string name  = JsonHelper.GetRequiredString(jtok, "protocol");
            string space = JsonHelper.GetOptionalString(jtok, "namespace");
            string doc   = JsonHelper.GetOptionalString(jtok, "doc");

            var names = new SchemaNames();

            JToken jtypes = jtok["types"];
            var    types  = new List <Schema>();

            if (jtypes is JArray)
            {
                foreach (JToken jtype in jtypes)
                {
                    var schema = Schema.ParseJson(jtype, names, space);
                    types.Add(schema);
                }
            }

            var    messages  = new Dictionary <string, Message>();
            JToken jmessages = jtok["messages"];

            if (null != jmessages)
            {
                foreach (JProperty jmessage in jmessages)
                {
                    var message = Message.Parse(jmessage, names, space);
                    messages.Add(message.Name, message);
                }
            }

            return(new Protocol(name, space, doc, types, messages));
        }