private void OnLoadReadWriteVersionListSuccess(string fileUri, byte[] bytes, float duration, object userData)
            {
                if (m_ReadWriteVersionListReady)
                {
                    throw new GXException("Read write version list has been parsed.");
                }

                MemoryStream memoryStream = null;

                try
                {
                    memoryStream = new MemoryStream(bytes, false);
                    LocalVersionList versionList = m_ResourceManager.m_ReadWriteVersionListSerializer.Deserialize(memoryStream);
                    if (!versionList.IsValid)
                    {
                        throw new GXException("Deserialize read write version list failure.");
                    }

                    LocalVersionList.Resource[] resources = versionList.GetResources();
                    foreach (LocalVersionList.Resource resource in resources)
                    {
                        ResourceName resourceName = new ResourceName(resource.Name, resource.Variant, resource.Extension);
                        SetReadWriteInfo(resourceName, (LoadType)resource.LoadType, resource.Length, resource.HashCode);
                        m_ResourceManager.m_ReadWriteResourceInfos.Add(resourceName, new ReadWriteResourceInfo((LoadType)resource.LoadType, resource.Length, resource.HashCode));
                    }

                    m_ReadWriteVersionListReady = true;
                    RefreshCheckInfoStatus();
                }
                catch (Exception exception)
                {
                    if (exception is GXException)
                    {
                        throw;
                    }

                    throw new GXException(Utility.Text.Format("Parse read write version list exception '{0}'.", exception.ToString()), exception);
                }
                finally
                {
                    if (memoryStream != null)
                    {
                        memoryStream.Dispose();
                        memoryStream = null;
                    }
                }
            }
            private void GenerateReadWriteVersionList()
            {
                if (File.Exists(m_ReadWriteVersionListFileName))
                {
                    if (File.Exists(m_ReadWriteVersionListBackupFileName))
                    {
                        File.Delete(m_ReadWriteVersionListBackupFileName);
                    }

                    File.Move(m_ReadWriteVersionListFileName, m_ReadWriteVersionListBackupFileName);
                }

                FileStream fileStream = null;

                try
                {
                    fileStream = new FileStream(m_ReadWriteVersionListFileName, FileMode.CreateNew, FileAccess.Write);
                    LocalVersionList.Resource[] resources = m_ResourceManager.m_ReadWriteResourceInfos.Count > 0 ? new LocalVersionList.Resource[m_ResourceManager.m_ReadWriteResourceInfos.Count] : null;
                    if (resources != null)
                    {
                        int index = 0;
                        foreach (KeyValuePair <ResourceName, ReadWriteResourceInfo> i in m_ResourceManager.m_ReadWriteResourceInfos)
                        {
                            resources[index++] = new LocalVersionList.Resource(i.Key.Name, i.Key.Variant, i.Key.Extension, (byte)i.Value.LoadType, i.Value.Length, i.Value.HashCode);
                        }
                    }

                    LocalVersionList versionList = new LocalVersionList(resources);
                    if (!m_ResourceManager.m_ReadWriteVersionListSerializer.Serialize(fileStream, versionList))
                    {
                        throw new GXException("Serialize read write version list failure.");
                    }

                    if (fileStream != null)
                    {
                        fileStream.Dispose();
                        fileStream = null;
                    }

                    if (!string.IsNullOrEmpty(m_ReadWriteVersionListBackupFileName))
                    {
                        File.Delete(m_ReadWriteVersionListBackupFileName);
                    }
                }
                catch (Exception exception)
                {
                    if (fileStream != null)
                    {
                        fileStream.Dispose();
                        fileStream = null;
                    }

                    if (File.Exists(m_ReadWriteVersionListFileName))
                    {
                        File.Delete(m_ReadWriteVersionListFileName);
                    }

                    if (!string.IsNullOrEmpty(m_ReadWriteVersionListBackupFileName))
                    {
                        File.Move(m_ReadWriteVersionListBackupFileName, m_ReadWriteVersionListFileName);
                    }

                    throw new GXException(Utility.Text.Format("Generate read write version list exception '{0}'.", exception.ToString()), exception);
                }
            }