diff --git a/ECSMemoryPool/ECSMemoryPool.vcxproj b/ECSMemoryPool/ECSMemoryPool.vcxproj
index 4c64a7c..cc4e118 100644
--- a/ECSMemoryPool/ECSMemoryPool.vcxproj
+++ b/ECSMemoryPool/ECSMemoryPool.vcxproj
@@ -16,6 +16,7 @@
     <WindowsTargetPlatformVersion Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">10.0</WindowsTargetPlatformVersion>
     <WindowsTargetPlatformVersion Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">10.0</WindowsTargetPlatformVersion>
     <QtMsBuild Condition="'$(QtMsBuild)'=='' OR !Exists('$(QtMsBuild)\qt.targets')">$(MSBuildProjectDirectory)\QtMsBuild</QtMsBuild>
+    <ProjectName>ECSChunkPool</ProjectName>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'" Label="Configuration">
diff --git a/ECSMemoryPool/ecs_memorypool.cpp b/ECSMemoryPool/ecs_memorypool.cpp
index 04ca6f2..4a17856 100644
--- a/ECSMemoryPool/ecs_memorypool.cpp
+++ b/ECSMemoryPool/ecs_memorypool.cpp
@@ -5,7 +5,7 @@ ECSMemoryPool::ECSMemoryPool()
 }
 
 ChunkAccessIndex::ChunkAccessIndex(ElementControlBlock* ecb, uint64_t chunk_type_code)
-:_element_bind(MemoryElement(ecb)), _chunk_type_code(chunk_type_code)
+:_element_bind(MemoryChunk(ecb)), _chunk_type_code(chunk_type_code)
 {
 
 }
diff --git a/ECSMemoryPool/ecs_memorypool.h b/ECSMemoryPool/ecs_memorypool.h
index 017a793..3f13cc4 100644
--- a/ECSMemoryPool/ecs_memorypool.h
+++ b/ECSMemoryPool/ecs_memorypool.h
@@ -19,17 +19,17 @@ concept CompenentType = requires(T t, T other, const QJsonObject & in, QJsonObje
 /// 组件引用符号
 /// </summary>
 /// <typeparam name="T"></typeparam>
-template<typename T> class ComponentRefer : protected MemoryElement {
+template<typename T> class ChunkRefer : protected MemoryChunk {
 public:
-	ComponentRefer(ElementControlBlock* data) : MemoryElement(data) { referAdd(); }
-	ComponentRefer(const ComponentRefer<T>& other) :MemoryElement(other.data_ptr) { referAdd(); }
-	virtual ~ComponentRefer() { referSub(); }
+	ChunkRefer(ElementControlBlock* data) : MemoryChunk(data) { referAdd(); }
+	ChunkRefer(const ChunkRefer<T> &other) :MemoryChunk(other.data_ptr) { referAdd(); }
+	virtual ~ChunkRefer() { referSub(); }
 
 	T* dataLock() {
-		return (T*)(MemoryElement::dataLock());
+		return (T*)(MemoryChunk::dataLock());
 	}
 	void unlock() {
-		MemoryElement::release();
+		MemoryChunk::release();
 	}
 
 };
@@ -37,7 +37,7 @@ public:
 
 class ECSMEMORYPOOL_EXPORT ChunkAccessIndex {
 private:
-	MemoryElement _element_bind;
+	MemoryChunk _element_bind;
 	uint64_t _chunk_type_code;
 	std::map<uint64_t, std::pair<uint16_t, uint16_t>> _member_offset;
 
@@ -93,7 +93,7 @@ public:
 	/// </summary>
 	/// <typeparam name="T"></typeparam>
 	/// <returns></returns>
-	template<CompenentType T> ComponentRefer<T> generate() {
+	template<CompenentType T> ChunkRefer<T> generate() {
 		std::lock_guard<std::mutex> lockx(_pool_protected_);
 
 		auto type_code = T::typeCode();
@@ -103,13 +103,13 @@ public:
 
 		// 迭代内存页集合
 		for (auto page_ptr : page_list) {
-			auto max_element_cnt = page_ptr->maxSliceCount();
+			auto max_element_cnt = page_ptr->maxCapacity();
 			auto active_cnt = page_ptr->getActiveCount();
 			// 初级校核可用数量
 			if (active_cnt < max_element_cnt) {
 				// 逐个查找数据元素
 				for (auto eidx = 0; eidx < max_element_cnt; eidx++) {
-					auto slice_ptr = page_ptr->getSlicePtr(eidx);
+					auto slice_ptr = page_ptr->getChunkPtr(eidx);
 					// 访问排他
 					slice_ptr->page_refer->lock();
 					// 裁决元素可用性
@@ -130,15 +130,15 @@ public:
 		}
 		{
 			// 生成新的内存页
-			auto new_page = new MemoryPage(MemoryElement::rawSize(T::typeSize()), type_code);
+			auto new_page = new MemoryPage(MemoryChunk::rawSize(T::typeSize()), type_code);
 			_storage_pages.insert(type_code, new_page);
-			refer_ptr = new_page->getSlicePtr(0);
+			refer_ptr = new_page->getChunkPtr(0);
 			refer_ptr->page_refer->getActiveCount(1);
 			refer_ptr->refer_count++;
 		}
 
 	exists_reuse:
-		ComponentRefer<T> temp_inst(refer_ptr);
+		ChunkRefer<T> temp_inst(refer_ptr);
 		auto data_pointer = temp_inst.dataLock();
 		refer_ptr->refer_count--;
 		auto dpair = _basic_component_memory_example[T::typeCode()];
diff --git a/ECSMemoryPool/memory_pages.cpp b/ECSMemoryPool/memory_pages.cpp
index 4a31212..4089810 100644
--- a/ECSMemoryPool/memory_pages.cpp
+++ b/ECSMemoryPool/memory_pages.cpp
@@ -7,9 +7,9 @@ MemoryPage::MemoryPage(uint16_t element_size, uint64_t typecode)
 	pcb.typecode_of_element = typecode;
 }
 
-uint16_t MemoryPage::dataSliceSize() const
+uint16_t MemoryPage::chunkSize() const
 {
-	return pcb.byte_count_per_element - MemoryElement::data_buffer_offset;
+	return pcb.byte_count_per_element - MemoryChunk::data_buffer_offset;
 }
 
 uint16_t MemoryPage::getActiveCount(uint16_t inc) const
@@ -39,9 +39,9 @@ std::pair<uint64_t, uint32_t> MemoryPage::getRecords() const {
 	return std::make_pair(pcb.curr_access_usec, pcb.acc_count_per_cycle);
 }
 
-ElementControlBlock* MemoryPage::getSlicePtr(int index) {
-	auto member_cnt = maxSliceCount();
-	auto element_size = sliceRawSize();
+ElementControlBlock* MemoryPage::getChunkPtr(int index) {
+	auto member_cnt = maxCapacity();
+	auto element_size = chunkRawSize();
 
 	ElementControlBlock* element_ptr = nullptr;
 	if (index >= 0 && index < member_cnt) {
@@ -79,28 +79,28 @@ uint64_t MemoryPage::elementTypeCode() const
 	return pcb.typecode_of_element;
 }
 
-uint16_t MemoryPage::sliceRawSize() const {
+uint16_t MemoryPage::chunkRawSize() const {
 	auto data_ptr = const_cast<MemoryPage*>(this);
 	std::lock_guard<std::mutex> g(data_ptr->pcb.access_protected);
 	return pcb.byte_count_per_element;
 }
 
-uint16_t MemoryPage::maxSliceCount() const {
+uint16_t MemoryPage::maxCapacity() const {
 	uint16_t cnt = sizeof(data_buffer);
-	return cnt / this->sliceRawSize();
+	return cnt / this->chunkRawSize();
 }
 
 // element =================================================================
-const uint32_t MemoryElement::data_buffer_offset = MemoryElement::validOffset();
+const uint32_t MemoryChunk::data_buffer_offset = MemoryChunk::validOffset();
 
-uint32_t MemoryElement::validOffset()
+uint32_t MemoryChunk::validOffset()
 {
 	uint32_t remains = sizeof(ElementControlBlock) % 16;
 	uint32_t times = sizeof(ElementControlBlock) / 16;
 	return (remains ? times + 1 : times) * 16;
 }
 
-uint32_t MemoryElement::rawSize(uint32_t data_type_size)
+uint32_t MemoryChunk::rawSize(uint32_t data_type_size)
 {
 	uint32_t minimal_size = validOffset() + data_type_size;
 	auto remains = minimal_size % 16;
@@ -108,21 +108,21 @@ uint32_t MemoryElement::rawSize(uint32_t data_type_size)
 	return (remains ? times + 1 : times) * 16;
 }
 
-MemoryElement::MemoryElement(ElementControlBlock* access_bind)
+MemoryChunk::MemoryChunk(ElementControlBlock* access_bind)
 	: data_ptr((ElementControlBlock*)access_bind) {}
 
-uint16_t MemoryElement::typeSize() const
+uint16_t MemoryChunk::typeSize() const
 {
 	auto page_ptr = data_ptr->page_refer;
-	return page_ptr->sliceRawSize();
+	return page_ptr->chunkRawSize();
 }
 
-void MemoryElement::accessUpdate(uint64_t time_usec)
+void MemoryChunk::accessUpdate(uint64_t time_usec)
 {
 	data_ptr->page_refer->accessRecord(time_usec);
 }
 
-bool MemoryElement::isActived(ElementControlBlock* refer)
+bool MemoryChunk::isActived(ElementControlBlock* refer)
 {
 	refer->page_refer->lock();
 	auto mark = refer->refer_count;
@@ -130,27 +130,27 @@ bool MemoryElement::isActived(ElementControlBlock* refer)
 	return mark;
 }
 
-void MemoryElement::referAdd()
+void MemoryChunk::referAdd()
 {
 	data_ptr->page_refer->lock();
 	data_ptr->refer_count++;
 	data_ptr->page_refer->release();
 }
 
-void MemoryElement::referSub()
+void MemoryChunk::referSub()
 {
 	data_ptr->page_refer->lock();
 	data_ptr->refer_count--;
 	data_ptr->page_refer->release();
 }
 
-unsigned char* MemoryElement::dataLock()
+unsigned char* MemoryChunk::dataLock()
 {
 	data_ptr->page_refer->lock();
 	return ((unsigned char*)data_ptr) + data_buffer_offset;
 }
 
-void MemoryElement::release()
+void MemoryChunk::release()
 {
 	data_ptr->page_refer->release();
 }
diff --git a/ECSMemoryPool/memory_pages.h b/ECSMemoryPool/memory_pages.h
index 83d5960..9061ec4 100644
--- a/ECSMemoryPool/memory_pages.h
+++ b/ECSMemoryPool/memory_pages.h
@@ -55,7 +55,7 @@ public:
 	/// 内存存储的数据元素的尺寸
 	/// </summary>
 	/// <returns></returns>
-	uint16_t dataSliceSize() const;
+	uint16_t chunkSize() const;
 
 	/// <summary>
 	/// 获取当前活跃元素数量
@@ -95,7 +95,7 @@ public:
 	/// <param name="index">元素索引</param>
 	/// <param name="active_set">是否设置</param>
 	/// <returns>数据指针</returns>
-	ElementControlBlock* getSlicePtr(int index);
+	ElementControlBlock* getChunkPtr(int index);
 	/// <summary>
 	/// 元素类型码
 	/// </summary>
@@ -105,18 +105,18 @@ public:
 	/// 获取单个元素尺寸
 	/// </summary>
 	/// <returns>字节数量</returns>
-	uint16_t sliceRawSize() const;
+	uint16_t chunkRawSize() const;
 	/// <summary>
 	/// 获取元素数量
 	/// </summary>
 	/// <returns></returns>
-	uint16_t maxSliceCount() const;
+	uint16_t maxCapacity() const;
 };
 
 /// <summary>
 /// 内存元素访问接口
 /// </summary>
-class ECSMEMORYPOOL_EXPORT MemoryElement {
+class ECSMEMORYPOOL_EXPORT MemoryChunk {
 protected:
 	ElementControlBlock* const data_ptr;
 
@@ -134,7 +134,7 @@ public:
 	/// 构建内存元素访问接口
 	/// </summary>
 	/// <param name="access_bind"></param>
-	MemoryElement(ElementControlBlock* access_bind);
+	MemoryChunk(ElementControlBlock* access_bind);
 
 	/// <summary>
 	/// 提取关联元素尺寸
@@ -147,16 +147,13 @@ public:
 	/// </summary>
 	/// <param name="time_usec"></param>
 	void accessUpdate(uint64_t time_usec);
-
 	/// <summary>
 	/// 设置数据活跃状态
 	/// </summary>
-	/// <param name="ste"></param>
 	void referAdd();
 	/// <summary>
 	/// 设置数据活跃状态
 	/// </summary>
-	/// <param name="ste"></param>
 	void referSub();
 
 	/// <summary>
diff --git a/QtConsoleApplication1/QtConsoleApplication1.vcxproj b/QtConsoleApplication1/QtConsoleApplication1.vcxproj
index a2e13ef..c74f05e 100644
--- a/QtConsoleApplication1/QtConsoleApplication1.vcxproj
+++ b/QtConsoleApplication1/QtConsoleApplication1.vcxproj
@@ -70,7 +70,7 @@
       <LanguageStandard>stdcpp20</LanguageStandard>
     </ClCompile>
     <Link>
-      <AdditionalDependencies>ECSMemoryPool.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>ECSChunkPool.lib;%(AdditionalDependencies)</AdditionalDependencies>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'" Label="Configuration">