Ejemplo n.º 1
0
        }  // end AvroEncode

        /// <summary>
        /// Make a copy of an object as an Avro GenericRecord
        /// </summary>
        /// <param name="obj">Original object</param>
        /// <param name="ktype">An associated KineticaType object that
        /// describes the original object.</param>
        /// <returns>GenericRecord object which is a copy of the specified object</returns>
        private Avro.Generic.GenericRecord MakeGenericRecord(object obj, KineticaType ktype)
        {
            // Get the schema
            var schema = KineticaData.SchemaFromType(obj.GetType(), ktype);

            // Create a new GenericRecord for this schema
            var recordToSend = new Avro.Generic.GenericRecord(schema);

            // Copy each field from obj to recordToSend
            foreach (var field in schema.Fields)
            {
                var property = obj.GetType()
                               .GetProperties()
                               .FirstOrDefault(prop => prop.Name.ToLowerInvariant() == field.Name.ToLowerInvariant());

                if (property == null)
                {
                    continue;
                }

                recordToSend.Add(field.Name, property.GetValue(obj, null));
            }

            // Return the newly created object
            return(recordToSend);
        }
Ejemplo n.º 2
0
        }  // lookupKineticaType()

        /// <summary>
        /// Encode specified object using Avro
        /// </summary>
        /// <param name="obj">Object to encode</param>
        /// <returns>Byte array of binary Avro-encoded data</returns>
        internal byte[] AvroEncode(object obj)
        {
            // Create a stream that will allow us to view the underlying memory
            using (var ms = new MemoryStream())
            {
                // Write the object to the memory stream
                // If obj is an ISpecificRecord, this is more efficient
                if (obj is Avro.Specific.ISpecificRecord)
                {
                    var schema = (obj as Avro.Specific.ISpecificRecord).Schema;
                    Avro.Specific.SpecificDefaultWriter writer = new Avro.Specific.SpecificDefaultWriter(schema);
                    writer.Write(schema, obj, new BinaryEncoder(ms));
                }
                else // Not an ISpecificRecord - this way is less efficient
                {
                    // Get the KineticaType associated with the object to be encoded
                    Type         obj_type = obj.GetType();
                    KineticaType ktype    = lookupKineticaType(obj_type);
                    if (ktype == null)
                    {
                        throw new KineticaException("No known KineticaType associated with the given object.  " +
                                                    "Need a known KineticaType to encode the object.");
                    }

                    // Make a copy of the object to send as a GenericRecord, then write that to the memory stream
                    var schema       = KineticaData.SchemaFromType(obj.GetType(), ktype);
                    var recordToSend = MakeGenericRecord(obj, ktype);
                    var writer       = new Avro.Generic.DefaultWriter(schema);
                    writer.Write(schema, recordToSend, new BinaryEncoder(ms));
                }

                // Get the memory from the stream
                return(ms.ToArray());
            }
        }  // end AvroEncode
Ejemplo n.º 3
0
        }     // end AvroDecode<T>

        /// <summary>
        /// Decode binary Avro data from a stream into an object
        /// </summary>
        /// <typeparam name="T">Type of expected object</typeparam>
        /// <param name="stream">Stream to read for object data</param>
        /// <returns>New object</returns>
        private T AvroDecode <T>(Stream stream) where T : Avro.Specific.ISpecificRecord, new()
        {
            // T obj = new T(); // Activator.CreateInstance<T>();
            var schema = KineticaData.SchemaFromType(typeof(T), null);
            var reader = new Avro.Specific.SpecificReader <T>(schema, schema);

            return(reader.Read(default(T), new BinaryDecoder(stream)));
        }
Ejemplo n.º 4
0
        /// <summary>
        /// Decode binary Avro data into an object.
        /// </summary>
        /// <typeparam name="T">Type of expected object</typeparam>
        /// <param name="bytes">Binary Avro data</param>
        /// <param name="ktype">An optional KineticaType object to help in decoding the object.</param>
        /// <returns>New object</returns>
        private T AvroDecode <T>(byte[] bytes, KineticaType ktype = null) where T : new()
        {
            // Get the schema
            var schema = KineticaData.SchemaFromType(typeof(T), ktype);

            // Create a stream to read the binary data
            using (var ms = new MemoryStream(bytes))
            {
                // Create a new object to return
                T obj = new T();
                if (obj is Avro.Specific.ISpecificRecord)
                {
                    var reader = new Avro.Specific.SpecificDefaultReader(schema, schema);
                    reader.Read(obj, new BinaryDecoder(ms));
                }
                else
                {
                    // Not ISpecificRecord, so first read into a new GenericRecord
                    var reader = new Avro.Generic.DefaultReader(schema, schema);
                    Avro.Generic.GenericRecord recordToReceive = new Avro.Generic.GenericRecord(schema);
                    reader.Read(recordToReceive, new BinaryDecoder(ms));

                    // Now, copy all the fields from the GenericRecord to obj
                    foreach (var field in schema.Fields)
                    {
                        var property = obj.GetType()
                                       .GetProperties()
                                       .FirstOrDefault(prop => prop.Name.ToLowerInvariant() == field.Name.ToLowerInvariant());

                        if (property == null)
                        {
                            continue;
                        }

                        object val;
                        // Try to get the property
                        if (recordToReceive.TryGetValue(field.Name, out val))
                        {
                            // If successful, write the property to obj
                            property.SetValue(obj, val);
                        }
                    } // end foreach
                }     // end if-else

                // Return the new object
                return(obj);
            } // end using
        }     // end AvroDecode<T>