Hello friends I have a messaging system that uses p2p. Each peer has a incoming message list and a outgoing message list. What I need to do is whenever a new peer will join the mesh he will get the all the incoming messages from other peers and add those into it's own incoming message list. Now I know when I get the other peer info from I can ask them to give their own list to me. But I'm not finding the way how..? Any suggestion on this or help would be highly appreciated. I'm giving my code below.

Thanking in Advance Johnny

   #region Instance Fields

    private string strOrigin = "";
    //the chat member name
    private string m_Member;
    //the channel instance where we execute our service methods against
    private IServerChannel m_participant;
    //the instance context which in this case is our window since it is the service host
    private InstanceContext m_site;
    //our binding transport for the p2p mesh
    private NetPeerTcpBinding m_binding;
    //the factory to create our chat channel
    private ChannelFactory<IServerChannel> m_channelFactory;
    //an interface provided by the channel exposing events to indicate
    //when we have connected or disconnected from the mesh
    private IOnlineStatus o_statusHandler;
    //a generic delegate to execute a thread against that accepts no args
    private delegate void NoArgDelegate();
    //an object to hold user details
    private IUserService userService;        
    //an Observable Collection of object to get all the Application Instance Details in databas
    ObservableCollection<AppLoginInstance> appLoginInstances;
    // an Observable Collection of object to get all Incoming Messages types
    ObservableCollection<MessageType> inComingMessageTypes;
    // an Observable Collection of object to get all Outgoing Messages
    ObservableCollection<PDCL.ERP.DataModels.Message> outGoingMessages;
    // an Observable Collection of object to get all Incoming Messages
    ObservableCollection<PDCL.ERP.DataModels.Message> inComingMessages;
    //an Event Aggregator to publish event for other modules to subscribe
    private readonly IEventAggregator eventAggregator;   

    /// <summary>
    /// an IUnityCOntainer to get the container
    /// </summary>
    private IUnityContainer container;
    private RefreshConnectionStatus refreshConnectionStatus;
    private RefreshConnectionStatusEventArgs args;
    private ReplyRequestMessage replyMessageRequest;
    private ReplyRequestMessageEventArgs eventsArgs;

    #endregion

    public P2pMessageService(IUserService UserService, IEventAggregator EventAggregator, IUnityContainer container)
    {
        userService = UserService;
        this.container = container;
        appLoginInstances = new ObservableCollection<AppLoginInstance>();
        inComingMessageTypes = new ObservableCollection<MessageType>();
        inComingMessages = new ObservableCollection<PDCL.ERP.DataModels.Message>();
        outGoingMessages = new ObservableCollection<PDCL.ERP.DataModels.Message>();
        this.args = new RefreshConnectionStatusEventArgs();
        this.eventsArgs = new ReplyRequestMessageEventArgs();
        this.eventAggregator = EventAggregator;            
        this.refreshConnectionStatus = this.eventAggregator.GetEvent<RefreshConnectionStatus>();
        this.replyMessageRequest = this.eventAggregator.GetEvent<ReplyRequestMessage>();
    }    


    #region IOnlineStatus Event Handlers
    void ostat_Offline(object sender, EventArgs e)
    {
        // we could update a status bar or animate an icon to 
        //indicate to the user they have disconnected from the mesh

        //currently i don't have a "disconnect" button but adding it
        //should be trivial if you understand the rest of this code
    }

    void ostat_Online(object sender, EventArgs e)
    {
        try
        {                
            m_participant.Join(userService.AppInstance);
        }
        catch (Exception Ex)
        {
            Logger.Exception(Ex, Ex.TargetSite.Name + ": " + Ex.TargetSite + ": " + Ex.Message);
        }
    }

    #endregion        

    #region IServer Members

    //this method gets called from a background thread to 
    //connect the service client to the p2p mesh specified
    //by the binding info in the app.config
    public void ConnectToMesh()
    {
        try
        {               

            m_site = new InstanceContext(this);

            //use the binding from the app.config with default settings
            m_binding = new NetPeerTcpBinding("P2PMessageBinding");

            m_channelFactory = new DuplexChannelFactory<IServerChannel>(m_site, "P2PMessageEndPoint");
            m_participant = m_channelFactory.CreateChannel();
            o_statusHandler = m_participant.GetProperty<IOnlineStatus>();
            o_statusHandler.Online += new EventHandler(ostat_Online);
            o_statusHandler.Offline += new EventHandler(ostat_Offline);
            //m_participant.InitializeMesh();
            //this.appLoginInstances.Add(this.userService.AppInstance);

            BackgroundWorkerHelper.DoWork<object>(() =>
            {
                //this is an empty unhandled method on the service interface.
                //why? because for some reason p2p clients don't try to connect to the mesh
                //until the first service method call.  so to facilitate connecting i call this method
                //to get the ball rolling.
                m_participant.InitializeMesh();
                //SynchronizeMessage(this.inComingMessages);    
                return new object();
            }, arg =>
            {

            });

            this.appLoginInstances.Add(this.userService.AppInstance);

        }
        catch (Exception Ex)
        {
            Logger.Exception(Ex, Ex.TargetSite.Name + ": " + Ex.TargetSite + ": " + Ex.Message);
        }
    }


    public void Join(AppLoginInstance obj)
    {
        try
        {
            // Adding Instance to the PeerList

            if (appLoginInstances.SingleOrDefault(a => a.InstanceId == obj.InstanceId)==null)
            {
                appLoginInstances.Add(obj);                    
                this.refreshConnectionStatus.Publish(new RefreshConnectionStatusEventArgs() { Status = m_channelFactory.State });                                        
            }                    

            //this will retrieve any new members that have joined before the current user
            m_participant.SynchronizeMemberList(userService.AppInstance);

        }
        catch(Exception Ex)
        {
            Logger.Exception(Ex,Ex.TargetSite.Name + ": " + Ex.TargetSite + ": " + Ex.Message);
        }
    }

    /// <summary>
    /// Synchronizes member list
    /// </summary>
    /// <param name="obj">The AppLoginInstance Param</param>
    public void SynchronizeMemberList(AppLoginInstance obj)
    {

        //as member names come in we simply disregard duplicates and 
        //add them to the member list, this way we can retrieve a list
        //of members already in the chatroom when we enter at any time.

        //again, since this is just an example this is the simplified
        //way to do things.  the correct way would be to retrieve a list
        //of peernames and retrieve the metadata from each one which would
        //tell us what the member name is and add it.  we would want to check
        //this list when we join the mesh to make sure our member name doesn't 
        //conflict with someone else
        try
        {
            if (appLoginInstances.SingleOrDefault(a => a.InstanceId == obj.InstanceId) == null)
            {
                appLoginInstances.Add(obj);                    
            }
        }
        catch (Exception Ex)
        {
            Logger.Exception(Ex, Ex.TargetSite.Name + ": " + Ex.TargetSite + ": " + Ex.Message);
        }
    }      

    /// <summary>
    /// This methos broadcasts the mesasge to all peers.
    /// </summary>
    /// <param name="msg">The whole message which is to be broadcasted</param>
    /// <param name="securityLevels"> Level of security</param>
    public void BroadCastMsg(PDCL.ERP.DataModels.Message msg, List<string> securityLevels)
    {
        try
        {
            foreach (string s in securityLevels)
            {
                if (this.userService.IsInRole(s))
                {
                    if (this.inComingMessages.Count == 0 && msg.CreatedByApp != this.userService.AppInstanceId)
                    {
                        this.inComingMessages.Add(msg);                            
                    }
                    else if (this.inComingMessages.SingleOrDefault(a => a.MessageId == msg.MessageId) == null && msg.CreatedByApp != this.userService.AppInstanceId)
                    {
                        this.inComingMessages.Add(msg);
                    }
                }
            }
        }
        catch (Exception Ex)
        {
            Logger.Exception(Ex, Ex.TargetSite.Name + ": " + Ex.TargetSite + ": " + Ex.Message);
        }

    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="msg">The Message to denyed</param>
    public void BroadCastReplyMsg(PDCL.ERP.DataModels.Message msg)
    {
        try
        {
            //if (this.inComingMessages.SingleOrDefault(a => a.MessageId == msg.MessageId) != null)
            //{
                this.replyMessageRequest.Publish(new ReplyRequestMessageEventArgs() { Message = msg });
                this.inComingMessages.Remove(this.inComingMessages.SingleOrDefault(o => o.MessageId == msg.MessageId));
            //}

        }
        catch (Exception ex)
        {
            Logger.Exception(ex, ex.TargetSite.Name + ": " + ex.TargetSite + ": " + ex.Message);
        }
    }

    //again we need to sync the worker thread with the UI thread via Dispatcher
    public void Whisper(string Member, string MemberTo, string Message)
    {          


    }

    public void InitializeMesh()
    {
        //do nothing
    }

    public void Leave(AppLoginInstance obj)
    {
        if (this.appLoginInstances.SingleOrDefault(a => a.InstanceId == obj.InstanceId) != null)
        {
            this.appLoginInstances.Remove(this.appLoginInstances.Single(a => a.InstanceId == obj.InstanceId));
        }            
    }        

    //public void SynchronizeRemoveMemberList(AppLoginInstance obj)
    //{
    //    if (appLoginInstances.SingleOrDefault(a => a.InstanceId == obj.InstanceId) != null)
    //    {
    //        appLoginInstances.Remove(obj);
    //    }
    //}       

    #endregion