public static extern ReturnCode read_next_instance_w_condition(
     IntPtr _this,
     IntPtr data_values,
     IntPtr info_seq,
     int max_samples,
     InstanceHandle a_handle,
     IntPtr a_condition);

        internal CacheChange NewChange(ChangeKind kind, Data data, InstanceHandle instance)
        {
            var change = new CacheChange()
            {
                WriterGuid = Id,
                SequenceNumber = SequenceNumber.Increment(),

                Kind = kind,
                InstanceHandle = instance,

                Data = data
            };

            var message = new Message()
            {
                Header = new Header()
                {
                    Protocol = ProtocolId.ProtocolRTPS,
                    Version = ProtocolVersion.v22,
                    Vendor = VendorId.Unknown,
                    GuidPrefix = new GuidPrefix()
                }
            };

            message.AddSubMessage(new DataSubMessage(data));
            message.AddSubMessage(new HeartbeatSubMessage());

            Channel.Send(message);

            return change;
        }

 public static extern ReturnCode read_next_instance(
     IntPtr _this,
     IntPtr data_values,
     IntPtr info_seq,
     int max_samples,
     InstanceHandle a_handle,
     SampleStateKind sample_states,
     ViewStateKind view_states,
     InstanceStateKind instance_states);

 public static ReturnCode GetKeyValue(
         DataReader reader, 
         ref object key, 
         InstanceHandle instanceHandle)
 {
     GCHandle tmpGCHandleData = GCHandle.Alloc(key, GCHandleType.Normal);
     ReturnCode result =  Gapi.FooDataReader.get_key_value(
             reader.GapiPeer,
             GCHandle.ToIntPtr(tmpGCHandleData),
             instanceHandle);
     tmpGCHandleData.Free();
     return result;
 }

        public static ReturnCode Dispose(
                DataWriter writer, 
                object instanceData, 
                InstanceHandle instanceHandle)
        {
            GCHandle tmpGCHandle = GCHandle.Alloc(instanceData, GCHandleType.Normal);
            ReturnCode result = Gapi.FooDataWriter.dispose(
                    writer.GapiPeer,
                    GCHandle.ToIntPtr(tmpGCHandle),
                    instanceHandle);
            tmpGCHandle.Free();

            return result;
        }

        public static ReturnCode DisposeWithTimestamp(
                DataWriter writer, 
                object instanceData,
                InstanceHandle instanceHandle, 
                Time sourceTimestamp)
        {
            GCHandle tmpGCHandle = GCHandle.Alloc(instanceData, GCHandleType.Normal);
            ReturnCode result = Gapi.FooDataWriter.dispose_w_timestamp(
                    writer.GapiPeer,
                    GCHandle.ToIntPtr(tmpGCHandle),
                    instanceHandle,
                    ref sourceTimestamp);
            tmpGCHandle.Free();

            return result;
        }

 public void AddReference(InstanceHandle handle)
 {
     if (referenceList.ContainsKey(handle.Instance))
         return;
     referenceList.Add(handle.Instance, handle);
     handle.MarkReferredBy(this);
 }

 public void RemoveReference(InstanceHandle handle)
 {
     if (referenceList.ContainsKey(handle.Instance))
     {
         referenceList.Remove(handle.Instance);
         handle.UnmarkReferredBy(this);
     }
 }

 internal void Cancel()
 {
     Fx.Assert(InstanceHandle != null, "InstanceHandleReference already cancelled.");
     InstanceHandle = null;
 }

 private void RemoveHandle(InstanceHandle handle)
 {
     Items.Remove(handle);
     foreach (var item in handle.referredList.Values.ToArray())
         item.RemoveReference(handle);
     foreach (var item in handle.referenceList.Values.ToArray())
         item.UnmarkReferredBy(handle);
 }

 public static extern byte contains_entity(
     IntPtr _this,
     InstanceHandle a_handle);

 internal InstanceHandleReference(InstanceHandle instanceHandle)
 {
     Fx.Assert(instanceHandle != null, "Null instanceHandle provided to InstanceHandleReference.");
     InstanceHandle = instanceHandle;
 }

        public static ReturnCode TakeNextInstanceWithCondition(
                DataReader reader, 
                ref object[] data, 
                ref SampleInfo[] sampleInfos,
                int maxSamples, 
                InstanceHandle instanceHandle, 
                IReadCondition condition)
        {
            ReturnCode result = ReturnCode.Ok;
            using (DataReaderMarshaler marshaler = 
                    new DataReaderMarshaler(data, sampleInfos, ref maxSamples, ref result))
            {
                if (result == ReturnCode.Ok)
                {
                    result = Gapi.FooDataReader.take_next_instance_w_condition(
                        reader.GapiPeer,
                        marshaler.dataValuesPtr,
                        marshaler.sampleInfosPtr,
                        maxSamples,
                        instanceHandle,
                        ((ReadCondition)condition).GapiPeer);

                    marshaler.CopyOut(ref data, ref sampleInfos);
                }
            }
            return result;
        }

 public static extern ReturnCode get_discovered_participant_data(
     IntPtr _this,
     IntPtr participant_data,
     InstanceHandle handle);

 public static extern ReturnCode get_matched_publication_data(
     IntPtr _this,
     IntPtr publication_data,
     InstanceHandle publication_handle);

 public void MarkReferredBy(InstanceHandle handle)
 {
     referredList.Add(handle.Instance, handle);
 }

 public static extern ReturnCode get_discovered_topic_data(
     IntPtr _this,
     IntPtr topic_data,
     InstanceHandle handle);

 public static void Write(IntPtr to, int offset, InstanceHandle from)
 {
     Marshal.WriteInt64(to, offset, from);
 }

 public static extern ReturnCode get_matched_subscription_data(
     IntPtr _this,
     IntPtr subscription_data,
     InstanceHandle subscription_handle);

 public void UnmarkReferredBy(InstanceHandle handle)
 {
     referredList.Remove(handle.Instance);
 }