static bool checkParticipant(DDS.DomainParticipant participant)
    {
        DDS.DomainParticipantQos participantQos = new DDS.DomainParticipantQos();
        participant.get_qos(participantQos);

        DDS.PropertySeq properties = participantQos.property_qos.value;

        for (int i = 0; i < properties.length; i++)
        {
            if (String.Compare(properties.get_at(i).name,
                "dds.transport.UDPv4.builtin.send_socket_buffer_size") == 0)
            {
                if (String.Compare(properties.get_at(i).value, NEW_SOCKET_BUFFER_SIZE_STRING)
                     != 0)
                {
                    Console.WriteLine("Error, send_socket_buffer_size...not modified");
                    return false;
                }
            }
            if (String.Compare(properties.get_at(i).name,
                "dds.transport.UDPv4.builtin.recv_socket_buffer_size") == 0)
            {
                string value = properties.get_at(i).value;
                if (String.Compare(properties.get_at(i).value, NEW_SOCKET_BUFFER_SIZE_STRING)
                     != 0)
                {
                    Console.WriteLine("Error, recv_socket_buffer_size...not modified");
                    return false;
                }
            }
        }
        return true;
    }

 public static bool RequestedDeadlineMissedValid(DDS.IDataReader reader, int totalCount
     , int totalCountChange)
 {
     bool result = false;
     DDS.RequestedDeadlineMissedStatus holder = new DDS.RequestedDeadlineMissedStatus();
     DDS.ReturnCode rc = reader.GetRequestedDeadlineMissedStatus(ref holder);
     if (rc == DDS.ReturnCode.Ok)
     {
         DDS.RequestedDeadlineMissedStatus status = holder;
         if (status.TotalCount == totalCount)
         {
             if (status.TotalCountChange == totalCountChange)
             {
                 result = true;
             }
             else
             {
                 System.Console.Error.WriteLine("requested_deadline_missed.TotalCountChange != '"
                      + totalCountChange + "', but '" + status.TotalCountChange + "'.");
             }
         }
         else
         {
             System.Console.Error.WriteLine("requested_deadline_missed.TotalCount != '" + totalCount
                  + "', but '" + status.TotalCount + "'.");
         }
     }
     else
     {
         System.Console.Error.WriteLine("get_requested_deadline_missed_status returned " +
              rc);
     }
     return result;
 }

 public virtual void OnLivelinessChanged(DDS.IDataReader reader, DDS.LivelinessChangedStatus
      status)
 {
     
     onLivelinessChangedCalled = true;
     lcStatus = status;
 }

 public static extern void Report(
         ReportType type,
         string reportContext,
         string fileName,
         int lineNo,
         DDS.ErrorCode reportCode,
         string description);

 public static bool StatussesValid(DDS.IDataReader reader, int rdmTotalCount, int rdmTotalCountChange
     , int riqsTotalCount, int riqsTotalCountChange, int srTotalCount, int srTotalCountChange
     , int lcActiveCount, int lcActiveCountChange, int lcInactiveCount, int lcInactiveCountChange
     , int smTotalCount, int smTotalCountChange, int slTotalCount, int slTotalCountChange
     )
 {
     bool result = false;
     if (RequestedDeadlineMissedValid(reader, rdmTotalCount, rdmTotalCountChange))
     {
         if (RequestedIncompatibleQosValid(reader, riqsTotalCount, riqsTotalCountChange))
         {
             if (SampleRejectedValid(reader, srTotalCount, srTotalCountChange))
             {
                 if (LivelinessChangedValid(reader, lcActiveCount, lcActiveCountChange, lcInactiveCount
                     , lcInactiveCountChange))
                 {
                     if (SubscriptionMatchValid(reader, smTotalCount, smTotalCountChange))
                     {
                         if (SampleLostValid(reader, slTotalCount, slTotalCountChange))
                         {
                             result = true;
                         }
                     }
                 }
             }
         }
     }
     return result;
 }

    private static DDS.TypeCode create_type_code(DDS.TypeCodeFactory tcf)
    {
        DDS.UnionMemberSeq members = new DDS.UnionMemberSeq();

        /* First, we create the typeCode for a union */
        /* Default-member index refers to which member of the union
         * will be the default one. In this example index = 1 refers
         * to the the member 'aLong'. Take into account that index
         * starts in 0 */
        try {
            DDS.TypeCode unionTC = tcf.create_union_tc("Foo",
                DDS.ExtensibilityKind.MUTABLE_EXTENSIBILITY,
                DDS.TypeCode.TC_LONG,
                1, /* default-member index */
                members); /* For now, it does not have any member */

            /* Case 1 will be a short named aShort */
            unionTC.add_member("aShort", DDS.DynamicData.MEMBER_ID_UNSPECIFIED,
                    DDS.TypeCode.TC_SHORT, DDS.TypeCode.NONKEY_MEMBER);

            /* Case 2, the default, will be a long named aLong */
            unionTC.add_member("aLong", 2, DDS.TypeCode.TC_LONG,
                    DDS.TypeCode.NONKEY_MEMBER);

            /* Case 3 will be a double named aDouble */
            unionTC.add_member("aDouble", 3, DDS.TypeCode.TC_DOUBLE,
                    DDS.TypeCode.NONKEY_MEMBER);

            return unionTC;
        } catch (Exception e) {
            Console.WriteLine("register_type error {0}", e);
            return null;
        }
    }

    static void shutdown(
        DDS.DomainParticipant participant)
    {
        /* Delete all entities */

        if (participant != null) {
            participant.delete_contained_entities();
            DDS.DomainParticipantFactory.get_instance().delete_participant(
                ref participant);
        }

        /* RTI Connext provides finalize_instance() method on
           domain participant factory for users who want to release memory
           used by the participant factory. Uncomment the following block of
           code for clean destruction of the singleton. */
        /*
        try {
            DDS.DomainParticipantFactory.finalize_instance();
        }
        catch(DDS.Exception e) {
            Console.WriteLine("finalize_instance error {0}", e);
            throw e;
        }
        */
    }

    public override void on_data_available( DDS.DataReader reader )
    {
        DDS.PublicationBuiltinTopicDataDataReader builtin_reader =
                (DDS.PublicationBuiltinTopicDataDataReader)reader;

        try {
            builtin_reader.take(
                data_seq,
                info_seq,
                DDS.ResourceLimitsQosPolicy.LENGTH_UNLIMITED,
                DDS.SampleStateKind.ANY_SAMPLE_STATE,
                DDS.ViewStateKind.ANY_VIEW_STATE,
                DDS.InstanceStateKind.ANY_INSTANCE_STATE);
        } catch (DDS.Retcode_NoData) {
            return;
        } catch (DDS.Exception e) {
            Console.WriteLine("take error {0}", e);
            return;
        }

        System.Int32 data_length = data_seq.length;
        for (int i = 0; i < data_length; ++i) {

            if (!info_seq.get_at(i).valid_data) {
                continue;
            }
            Console.WriteLine("-----");
            Console.WriteLine("Found topic \"{0}\"",
                data_seq.get_at(i).topic_name);
            Console.WriteLine("participant: {0:x8}{1:x8}{2:x8}",
                data_seq.get_at(i).participant_key.value1,
                data_seq.get_at(i).participant_key.value2,
                data_seq.get_at(i).participant_key.value3);
            Console.WriteLine("datawriter: {0:x8}{1:x8}{2:x8}",
                data_seq.get_at(i).key.value1,
                data_seq.get_at(i).key.value2,
                data_seq.get_at(i).key.value3);
            Console.WriteLine("type:");

            if (data_seq.get_at(i).type_code == null) {
                Console.WriteLine("No type code received, perhaps increase " +
                    "type_code_max_serialized_length?");
                continue;
            }
            /* Using the type_code propagated we print the data type
             * with print_IDL(). */
            try {
                data_seq.get_at(i).type_code.print_IDL(2);
            } catch (DDS.Exception) {
                Console.WriteLine("error printing IDL");
            }
        }

        try {
            builtin_reader.return_loan(data_seq, info_seq);
        } catch (DDS.Exception e) {
            Console.WriteLine("return loan error {0}", e);
        }
    }

    /* Start changes for Ordered_Presentation*/
    /* No listener is needed; we poll readers in this function */
    private static void poll_data(DDS.DataReader[] reader, int numreaders)
    {
        DDS.SampleInfoSeq info_seq = new DDS.SampleInfoSeq();
        orderedSeq data_seq = new orderedSeq();

        for (int r = 0; r < numreaders; ++r) {
            try {
                ((orderedDataReader)(reader[r])).take(
                    data_seq,
                    info_seq,
                    DDS.ResourceLimitsQosPolicy.LENGTH_UNLIMITED,
                    DDS.SampleStateKind.ANY_SAMPLE_STATE,
                    DDS.ViewStateKind.ANY_VIEW_STATE,
                    DDS.InstanceStateKind.ANY_INSTANCE_STATE);
            } catch (DDS.Retcode_NoData) {
                // Not an error
                return;
            } catch (DDS.Exception e) {
                // Is an error
                Console.WriteLine("take error {0}", e);
                return;
            }

            System.Int32 data_length = data_seq.length;
            for (int i = 0; i < data_length; ++i) {
                if (!info_seq.get_at(i).valid_data) {
                    continue;
                }
                // Make things a bit easier to read.
                int ident = r;
                while (ident-- != 0) {
                    Console.Write("\t");
                }
                Console.WriteLine("Reader {0}: Instance{1}->value = {2}", r,
                    data_seq.get_at(i).id, data_seq.get_at(i).value);
            }

            try {
                ((orderedDataReader)(reader[r])).return_loan(data_seq,
                        info_seq);
            } catch (DDS.Exception e) {
                Console.WriteLine("return loan error {0}", e);
            }

            info_seq.ensure_length(0, 0);
            data_seq.ensure_length(0, 0);
        }
    }

 internal static DDS.ReturnCode CopyIn(
         DDS.OfferedIncompatibleQosStatus from, 
         IntPtr to, 
         int offset)
 {
     DDS.ReturnCode result = DDS.ReturnCode.Ok;
     if (from != null) {
         Write(to, offset_total_count, from.TotalCount);
         Write(to, offset_total_count_change, from.TotalCountChange);
         Write(to, offset_last_policy_id, (int) from.LastPolicyId);
         result = QosPolicyCountSequenceMarshaler.CopyIn(from.Policies, to, offset_policies);
     } else {
         result = DDS.ReturnCode.BadParameter;
         DDS.OpenSplice.OS.Report(
                 DDS.OpenSplice.ReportType.OS_ERROR,
                 "DDS.OpenSplice.CustomMarshalers.OfferedIncompatibleQosStatusMarshaler.CopyIn",
                 "DDS/OpenSplice/CustomMarshalers/StatusMarshalers.cs",
                 DDS.ErrorCode.InvalidValue,
                 "OfferedIncompatibleQosStatus attribute may not be a null pointer.");
     }
     return result; 
 }

        public override void on_data_available(DDS.DataReader reader)
        {
            /* We need to create a DynamicDataReader to receive the DynamicData
             */
            DDS.DynamicDataReader DynamicData_reader =
                (DDS.DynamicDataReader)reader;

            try {
                DynamicData_reader.take(
                    data_seq,
                    info_seq,
                    DDS.ResourceLimitsQosPolicy.LENGTH_UNLIMITED,
                    DDS.SampleStateKind.ANY_SAMPLE_STATE,
                    DDS.ViewStateKind.ANY_VIEW_STATE,
                    DDS.InstanceStateKind.ANY_INSTANCE_STATE);
            }
            catch(DDS.Retcode_NoData) {
                return;
            }
            catch(DDS.Exception e) {
                Console.WriteLine("take error {0}", e);
                return;
            }

            System.Int32 data_length = data_seq.length;
            for (int i = 0; i < data_length; ++i) {
                if (info_seq.get_at(i).valid_data) {
                    data_seq.get_at(i).print(1);
                }
            }

            try {
                DynamicData_reader.return_loan(data_seq, info_seq);
            }
            catch(DDS.Exception e) {
                Console.WriteLine("return loan error {0}", e);
            }
        }

 public ReturnCode GetDiscoveredTopicData(
     ref DDS.TopicBuiltinTopicData[] topic_data,
     long topic_handle)
 {
     throw new System.NotImplementedException();
     //return realParticipant.get_discovered_topic_data(
     //        topic_data, topic_handle);
 }

        public override void on_data_available( DDS.DataReader reader )
        {
            sequencesDataReader sequences_reader =
                (sequencesDataReader)reader;

            try {
                sequences_reader.take(
                    data_seq,
                    info_seq,
                    DDS.ResourceLimitsQosPolicy.LENGTH_UNLIMITED,
                    DDS.SampleStateKind.ANY_SAMPLE_STATE,
                    DDS.ViewStateKind.ANY_VIEW_STATE,
                    DDS.InstanceStateKind.ANY_INSTANCE_STATE);
            } catch (DDS.Retcode_NoData) {
                return;
            } catch (DDS.Exception e) {
                Console.WriteLine("take error {0}", e);
                return;
            }

            System.Int32 data_length = data_seq.length;
            for (int i = 0; i < data_length; ++i) {
                if (info_seq.get_at(i).valid_data) {
                    sequencesTypeSupport.print_data(data_seq.get_at(i));
                }
            }

            try {
                sequences_reader.return_loan(data_seq, info_seq);
            } catch (DDS.Exception e) {
                Console.WriteLine("return loan error {0}", e);
            }
        }

        /**** Start changes for Advanced_Keys ****/
        public override void on_data_available(DDS.DataReader reader)
        {
            keysDataReader keys_reader =
                (keysDataReader)reader;

            //// Start changes for Advanced_Keys

            while (true)
            {
                /* Given DDS_HANDLE_NIL as a parameter, take_next_instance returns
                a sequence containing samples from only the next (in a well-determined
                but unspecified order) un-taken instance.
                */

                try
                {
                    keys_reader.take_next_instance(
                        data_seq,
                        info_seq,
                        DDS.ResourceLimitsQosPolicy.LENGTH_UNLIMITED,
                        ref DDS.InstanceHandle_t.HANDLE_NIL,
                        DDS.SampleStateKind.ANY_SAMPLE_STATE,
                        DDS.ViewStateKind.ANY_VIEW_STATE,
                        DDS.InstanceStateKind.ANY_INSTANCE_STATE);
                }
                catch (DDS.Retcode_NoData)
                {
                    break;
                }
                catch (DDS.Exception e)
                {
                    Console.WriteLine("take error {0}", e);
                    return;
                }

                System.Int32 data_length = data_seq.length;
                /* We process all the obtained samples for a particular instance */
                for (int i = 0; i < data_length; ++i)
                {
                    /* We first check if the sample includes valid data */
                    if (info_seq.get_at(i).valid_data)
                    {
                        if (info_seq.get_at(i).view_state == DDS.ViewStateKind.NEW_VIEW_STATE)
                        {
                            new_instance_found(keys_reader, info_seq.get_at(i), data_seq.get_at(i));
                        }

                        /* We check if the obtained samples are associated to one
                        of the instances of interest.
                        Since take_next_instance gives sequences of the same instance,
                        we only need to test this for the first sample obtained.
                        */
                        if (i == 0 && !key_is_relevant(data_seq.get_at(i)))
                        {
                            break;
                        }

                        handle_data(keys_reader, info_seq.get_at(i), data_seq.get_at(i));
                    }
                    else
                    {
                        /* Since there is not valid data, it may include metadata */
                        keys dummy = null; ;

                        dummy = keysTypeSupport.create_data();
                        if (dummy == null)
                        {
                            throw new ApplicationException(
                            "keysTypeSupport.create_data error");
                        }

                        DDS.InstanceHandle_t handle = info_seq.get_at(i).instance_handle;

                        try
                        {
                            keys_reader.get_key_value(dummy, ref handle);
                        }
                        catch (DDS.Exception e)
                        {
                            Console.WriteLine(" get_key_value error {0}", e);
                        }

                        /* Here we print a message and change the instance state
                        if the instance state is ALIVE_NO_WRITERS or ALIVE_DISPOSED */
                        if (info_seq.get_at(i).instance_state == DDS.InstanceStateKind.NOT_ALIVE_NO_WRITERS_INSTANCE_STATE)
                        {
                            instance_lost_writers(keys_reader, info_seq.get_at(i), dummy);
                        }
                        else if (info_seq.get_at(i).instance_state == DDS.InstanceStateKind.NOT_ALIVE_DISPOSED_INSTANCE_STATE)
                        {
                            instance_disposed(keys_reader, info_seq.get_at(i), dummy);
                        }
                    }
                }

                try
                {
                    keys_reader.return_loan(data_seq, info_seq);
                }
//.........这里部分代码省略.........

        public override void on_data_available(DDS.DataReader reader)
        {
            keysDataReader keys_reader =
                (keysDataReader)reader;

            try {
                keys_reader.take(
                    data_seq,
                    info_seq,
                    DDS.ResourceLimitsQosPolicy.LENGTH_UNLIMITED,
                    DDS.SampleStateKind.ANY_SAMPLE_STATE,
                    DDS.ViewStateKind.ANY_VIEW_STATE,
                    DDS.InstanceStateKind.ANY_INSTANCE_STATE);
            }
            catch(DDS.Retcode_NoData) {
                return;
            }
            catch(DDS.Exception e) {
                Console.WriteLine("take error {0}", e);
                return;
            }

            System.Int32 data_length = data_seq.length;
            for (int i = 0; i < data_length; ++i)
            {
                /* Start changes for Keyed_Data */
                /* We first check if the sample includes valid data */
                if (info_seq.get_at(i).valid_data)
                {
                    if (info_seq.get_at(i).view_state ==
                        DDS.ViewStateKind.NEW_VIEW_STATE)
                    {
                        Console.WriteLine("Found new instance; code = {0}",
                            data_seq.get_at(i).code);
                    }

                    Console.WriteLine("Instance {0}: x: {1}, y: {2}",
                        data_seq.get_at(i).code, data_seq.get_at(i).x,
                        data_seq.get_at(i).y);
                }
                else
                {
                    /* Since there is not valid data, it may include metadata */
                    keys dummy = new keys();
                    try
                    {
                        DDS.InstanceHandle_t temp =
                            info_seq.get_at(i).instance_handle;
                        keys_reader.get_key_value(dummy, ref temp);
                    }
                    catch (DDS.Exception e)
                    {
                        Console.WriteLine("get_key_value error {0}", e);
                    }

                    /* Here we print a message if the instance state is ALIVE_NO_WRITERS or ALIVE_DISPOSED */
                    if (info_seq.get_at(i).instance_state ==
                        DDS.InstanceStateKind.NOT_ALIVE_NO_WRITERS_INSTANCE_STATE)
                    {
                        Console.WriteLine("Instance {0} has no writers",
                            dummy.code);
                    }
                    else if (info_seq.get_at(i).instance_state ==
                        DDS.InstanceStateKind.NOT_ALIVE_DISPOSED_INSTANCE_STATE)
                    {
                        Console.WriteLine("Instance {0} disposed",
                            dummy.code);
                    }
                }
                /* End changes for Keyed_Data */
            }

            try {
                keys_reader.return_loan(data_seq, info_seq);
            }
            catch(DDS.Exception e) {
                Console.WriteLine("return loan error {0}", e);
            }
        }

 public override void on_liveliness_changed(
     DDS.DataReader reader,
     ref DDS.LivelinessChangedStatus status)
 {
 }

 public override void on_sample_rejected(
     DDS.DataReader reader,
     ref DDS.SampleRejectedStatus status)
 {
 }

 public override void on_requested_incompatible_qos(
     DDS.DataReader reader,
     DDS.RequestedIncompatibleQosStatus status)
 {
 }

        public override void on_data_available(DDS.DataReader reader)
        {
            tbfDataReader tbf_reader =
                (tbfDataReader)reader;

            try {
                tbf_reader.take(
                    data_seq,
                    info_seq,
                    DDS.ResourceLimitsQosPolicy.LENGTH_UNLIMITED,
                    DDS.SampleStateKind.ANY_SAMPLE_STATE,
                    DDS.ViewStateKind.ANY_VIEW_STATE,
                    DDS.InstanceStateKind.ANY_INSTANCE_STATE);
            }
            catch(DDS.Retcode_NoData) {
                return;
            }
            catch(DDS.Exception e) {
                Console.WriteLine("take error {0}", e);
                return;
            }

            System.Int32 data_length = data_seq.length;
            for (int i = 0; i < data_length; ++i) {
                if (info_seq.get_at(i).valid_data) {
                    /* Here we get source timestamp of the sample using the
                     * sample info.
                     *
                     * info_seq[i].source_timestamp returns DDS_Time_t
                     * ({seconds,nanoseconds}). We convert nanoseconds to
                     * seconds to get the decimal part of the timestamp.
                     */
                    System.Double source_timestamp =
                        info_seq.get_at(i).source_timestamp.sec +
                        (info_seq.get_at(i).source_timestamp.nanosec /
                         Constant.NANOSECOND);

                    Console.WriteLine(source_timestamp.ToString("0.00000") +
                        "\t" + data_seq.get_at(i).code + "\t\t" +
                        data_seq.get_at(i).x);
                }
            }

            try {
                tbf_reader.return_loan(data_seq, info_seq);
            }
            catch(DDS.Exception e) {
                Console.WriteLine("return loan error {0}", e);
            }
        }

        public override void on_data_on_readers(
                DDS.Subscriber sub)
        {
            /* IMPORTANT for GROUP access scope: Invoking begin_access() */
            sub.begin_access();

            /* Obtain DataReaders. We obtain a sequence of DataReaders that specifies
            the order in which each sample should be read */
            try {
                sub.get_datareaders(my_datareaders,
                    DDS.SampleStateKind.ANY_SAMPLE_STATE,
                    DDS.ViewStateKind.ANY_VIEW_STATE,
                    DDS.InstanceStateKind.ANY_INSTANCE_STATE);
            } catch (DDS.Exception e) {
                Console.WriteLine("get_datareaders error {0}", e);
                my_datareaders.ensure_length(0, 0);
                sub.end_access();
                return;
            }

            /* Read the samples received, following the DataReaders sequence */
            try {
                for (int i = 0; i < my_datareaders.length; ++i) {
                    try {
                        ordered_group_reader = (ordered_groupDataReader)
                            my_datareaders.get_at(i);
                    } catch (DDS.Exception e) {
                        Console.WriteLine("my_datareaders.get_at error {0}", e);
                        sub.end_access();
                        return;
                    }

                    /* IMPORTANT. Use take_next_sample(). We need to take only
                     * one sample each time, as we want to follow the sequence
                     * of DataReaders. This way the samples will be returned in
                     * the order in which they were modified
                     */
                    ordered_group_reader.take_next_sample(data, info);

                    if (info.valid_data) {
                        ordered_groupTypeSupport.print_data(data);
                    }

                    my_datareaders.ensure_length(0, 0);

                    /* IMPORTANT for GROUP access scope: Invoking end_access() */
                    sub.end_access();
                }
            } catch (DDS.Retcode_NoData noData) {
                //No data to process
            }
        }