public void WriteTo(MessageStore store)
        {
            using (MemoryStream mS = new MemoryStream(128))
            {
                BincodingEncoder encoder = new BincodingEncoder(mS, "MI", 1);

                encoder.Encode((byte)_type);
                encoder.Encode(_messageDate);

                switch (_type)
                {
                case MessageType.Info:
                    encoder.Encode(_message);
                    break;

                case MessageType.TextMessage:
                case MessageType.InvitationMessage:
                    encoder.Encode(_sender);
                    encoder.Encode(_message);
                    encoder.Encode(_recipients);
                    break;

                case MessageType.SharedFileMetaData:
                    encoder.Encode(_sender);
                    encoder.Encode(_sharedFileMetaData);
                    break;

                default:
                    throw new NotSupportedException("MessageType not supported: " + _type);
                }

                byte[] messageData = mS.ToArray();

                if (_messageNumber == -1)
                {
                    _messageNumber = store.WriteMessage(messageData, 0, messageData.Length);
                }
                else
                {
                    store.UpdateMessage(_messageNumber, messageData, 0, messageData.Length);
                }
            }
        }
        public MessageItem(MessageStore store, int messageNumber)
        {
            _messageNumber = messageNumber;
            byte[] messageData = store.ReadMessage(messageNumber);

            using (MemoryStream mS = new MemoryStream(messageData))
            {
                if (Encoding.ASCII.GetString(messageData, 0, 2) == "MI")
                {
                    //new format
                    BincodingDecoder decoder = new BincodingDecoder(mS, "MI");

                    switch (decoder.Version)
                    {
                    case 1:
                        _type        = (MessageType)decoder.DecodeNext().GetByteValue();
                        _messageDate = decoder.DecodeNext().GetDateTimeValue();

                        switch (_type)
                        {
                        case MessageType.Info:
                            _message = decoder.DecodeNext().GetStringValue();
                            break;

                        case MessageType.TextMessage:
                        case MessageType.InvitationMessage:
                            _sender  = decoder.DecodeNext().GetStringValue();
                            _message = decoder.DecodeNext().GetStringValue();

                            {
                                List <Bincoding> rcptDataList = decoder.DecodeNext().GetList();

                                _recipients = new MessageRecipient[rcptDataList.Count];
                                int i = 0;

                                foreach (Bincoding data in rcptDataList)
                                {
                                    _recipients[i++] = new MessageRecipient(data.GetValueStream());
                                }
                            }
                            break;

                        case MessageType.SharedFileMetaData:
                            _sender             = decoder.DecodeNext().GetStringValue();
                            _sharedFileMetaData = new SharedFileMetaData(decoder.DecodeNext().GetValueStream());
                            break;
                        }

                        break;

                    default:
                        throw new InvalidDataException("Cannot decode data format: version not supported.");
                    }
                }
                else
                {
                    //old format support
                    BincodingDecoder decoder = new BincodingDecoder(mS);

                    _type        = (MessageType)decoder.DecodeNext().GetByteValue();
                    _messageDate = _epoch.AddSeconds(decoder.DecodeNext().GetLongValue());

                    switch (_type)
                    {
                    case MessageType.Info:
                        _message = decoder.DecodeNext().GetStringValue();
                        break;

                    case MessageType.TextMessage:
                        _sender     = decoder.DecodeNext().GetStringValue();
                        _message    = decoder.DecodeNext().GetStringValue();
                        _recipients = new MessageRecipient[] { };
                        break;
                    }
                }
            }
        }