class FLinkerTables
{
public:
    /** The list of FObjectImports found in the package */
    TArray<FObjectImport> ImportMap;
    /** The list of FObjectExports found in the package */
    TArray<FObjectExport> ExportMap;
}

class FLinkerLoad 
#if !WITH_EDITOR
	final 
#endif
	: public FLinker, public FArchiveUObject
{
private:
    /** The archive that actually reads the raw data from disk.*/
    FArchive* Loader;
}

UObject* StaticLoadObjectInternal(UClass* ObjectClass, UObject* InOuter, const TCHAR* InName, const TCHAR* Filename, uint32 LoadFlags, UPackageMap* Sandbox, bool bAllowObjectReconciliation, const FLinkerInstancingContext* InstancingContext)
{
//......
    // break up the name into packages, returning the innermost name and its outer
    ResolveName(InOuter, StrName, true, true, LoadFlags & (LOAD_EditorOnly | LOAD_NoVerify | LOAD_Quiet | LOAD_NoWarn | LOAD_DeferDependencyLoads), InstancingContext);
}

// Try to find the package in memory first, should be faster than attempting to load or create
InPackage = InPackage ? nullptr : StaticFindObjectFast(UPackage::StaticClass(), InPackage, *PartialName);
if (!bIsScriptPackage && !InPackage)
{
    InPackage = LoadPackage(Cast<UPackage>(InPackage), *PartialName, LoadFlags, nullptr, InstancingContext);
}

// Create loader, aka FArchive used for serialization and also precache the package file summary.创建加载器，又名 FArchive，用于序列化并预缓存包文件摘要。
// false is returned until any precaching is complete.创建加载器，又名 FArchive，用于序列化并预缓存包文件摘要。
Status = CreateLoader(TFunction<void()>([]() {}));

	bCanSerializePackageFileSummary = (Status == LINKER_Loaded);
}

// Serialize the package file summary and presize the various arrays (name, import & export map)
if (bCanSerializePackageFileSummary)
{
    Status = ProcessPackageSummary(ObjectNameWithOuterToExportMap);
}

// Validate all imports and map them to their remote linkers.
for (int32 ImportIndex = 0; ImportIndex < Summary.ImportCount; ImportIndex++)
{
    FObjectImport& Import = ImportMap[ImportIndex];

#if WITH_EDITOR
    if (SlowTask)
    {
        UE_SERIALIZE_ACCCESS_SCOPE_SUSPEND();
        static const FText LoadingImportText = NSLOCTEXT("Core", "LinkerLoad_LoadingImportName", "Loading Import '{0}'");
        SlowTask->EnterProgressFrame(1, FText::Format(LoadingImportText, FText::FromString(Import.ObjectName.ToString())));
    }
#endif
    VerifyImport( ImportIndex );
}

UObject* FLinkerLoad::CreateExport( int32 Index )
{
    //...
	// Find the Archetype object for the one we are loading.找到我们正在加载的原型对象。
	UObject* Template = UObject::GetArchetypeFromRequiredInfo(LoadClass, ThisParent, Export.ObjectName, Export.ObjectFlags);//line: 5300
    //...
}

UObject* GetArchetypeFromRequiredInfoImpl(const UClass* Class, const UObject* Outer, FName Name, EObjectFlags ObjectFlags, bool bUseUpToDateClass)
{
	UObject* Result = NULL;
	const bool bIsCDO = !!(ObjectFlags & RF_ClassDefaultObject);
	if (bIsCDO)
	{
		Result = bUseUpToDateClass ? Class->GetAuthoritativeClass()->GetArchetypeForCDO() : Class->GetArchetypeForCDO();
	}
	else
	{
		if (Outer
			&& Outer->GetClass() != UPackage::StaticClass()) // packages cannot have subobjects
		{
			// Get a lock on the UObject hash tables for the duration of the GetArchetype operation
			FScopedUObjectHashTablesLock HashTablesLock;

			UObject* ArchetypeToSearch = nullptr;
#if UE_CACHE_ARCHETYPE
			ArchetypeToSearch = Outer->GetArchetype();
#else
			ArchetypeToSearch = GetArchetypeFromRequiredInfoImpl(Outer->GetClass(), Outer->GetOuter(), Outer->GetFName(), Outer->GetFlags(), bUseUpToDateClass);//递归，这样必有一个CDO返回
#endif // UE_CACHE_ARCHETYPE
			UObject* MyArchetype = static_cast<UObject*>(FindObjectWithOuter(ArchetypeToSearch, Class, Name));
			if (MyArchetype)
			{
				Result = MyArchetype; // found that my outers archetype had a matching component, that must be my archetype
			}
			else if (!!(ObjectFlags & RF_InheritableComponentTemplate) && Outer->IsA<UClass>()){}
			else{}
		}

		if (!Result)
		{
			// nothing found, I am not a CDO, so this is just the class CDO
			Result = bUseUpToDateClass ? Class->GetAuthoritativeClass()->GetDefaultObject() : Class->GetDefaultObject();
		}
	}

	return Result;
}

UObject* FLinkerLoad::CreateExport( int32 Index )
{
    //...
	// Try to find existing object first in case we're a forced export to be able to reconcile. Also do it for the
	// case of async loading as we cannot in-place replace objects.
	//首先尝试找到现有对象，以防我们强制导出以便能够协调。对于异步加载的情况也这样做，因为我们无法就地替换对象。
		UObject* ActualObjectWithTheName = StaticFindObjectFastInternal(nullptr, ThisParent, Export.ObjectName, true);//line: 5311

		check(Export.Object == nullptr);
		if (ActualObjectWithTheName && (ActualObjectWithTheName->GetClass() == LoadClass))
		{
			Export.Object = ActualObjectWithTheName;
		}

		// Object is found in memory.
		if (Export.Object)
		{
			//...
			return Export.Object;
		}
    //...
}

UObject* FLinkerLoad::CreateExport( int32 Index )
{
    //...
	Export.Object = StaticConstructObject_Internal(Params);//line: 5479
    //...
}

struct FStaticConstructObjectParameters
{
	/** The class of the object to create */
	const UClass* Class;

	/** The object to create this object within (the Outer property for the new object will be set to the value specified here). */
	UObject* Outer;

	/** The name to give the new object.If no value(NAME_None) is specified, the object will be given a unique name in the form of ClassName_#. */
	FName Name;

	/** The ObjectFlags to assign to the new object. some flags can affect the behavior of constructing the object. */
	EObjectFlags SetFlags = RF_NoFlags;

	/** The InternalObjectFlags to assign to the new object. some flags can affect the behavior of constructing the object. */
	EInternalObjectFlags InternalSetFlags = EInternalObjectFlags::None;

	/**
	 * If specified, the property values from this object will be copied to the new object, and the new object's ObjectArchetype value will be set to this object.
	 * If nullptr, the class default object is used instead.
	 */
	UObject* Template = nullptr;
    
    //...
};

UObject* FLinkerLoad::CreateExport( int32 Index )
{
    //...
	// Check to see if LoadClass is a blueprint, which potentialLy needs 
    // to be refreshed and regenerated.  If so, regenerate and patch it 
    // back into the export table
    //检查LoadClass是否是一个蓝图，它可能需要刷新和重新生成。如果是这样，重新生成后将其修补回导出表中

      if (bIsBlueprintCDO && (LoadClass->GetOutermost() != GetTransientPackage()))//line: 5537
      {
         {
            // For classes that are about to be regenerated, make sure we register them with the linker, so future references to this linker index will be valid
             //对于即将重新生成的类，请确保我们使用链接器注册它们，以便将来对此链接器索引的引用将有效
            const EObjectFlags OldFlags = Export.Object->GetFlags();
            Export.Object->ClearFlags(RF_NeedLoad|RF_NeedPostLoad|RF_NeedPostLoadSubobjects);
            Export.Object->SetLinker( this, Index, false );
            Export.Object->SetFlags(OldFlags);
         }

         if ( RegenerateBlueprintClass(LoadClass, Export.Object) )
         {
            return Export.Object;
         }
      }
      else
      {
         // we created the object, but the data stored on disk for this object has not yet been loaded,
         // so add the object to the list of objects that need to be loaded, which will be processed
         // in EndLoad()
          //我们创建了该对象，但该对象存储在磁盘上的数据尚未加载，因此将该对象添加到需要加载的对象列表中，该列表将在 EndLoad() 中处理
         Export.Object->SetLinker( this, Index );
         check(CurrentLoadContext);
         CurrentLoadContext->AddLoadedObject(Export.Object);
      }
    //...
}

while (LoadContext->DecrementBeginLoadCount() == 0 && (LoadContext->HasLoadedObjects() || LoadContext->HasPendingImportsOrForcedExports()))
{
   // Temporary list of loaded objects as GObjLoaded might expand during iteration.
   TArray<UObject*> ObjLoaded;
   TSet<FLinkerLoad*> LoadedLinkers;
   while (LoadContext->HasLoadedObjects())
   {
      // Accumulate till GObjLoaded no longer increases.
      LoadContext->AppendLoadedObjectsAndEmpty(ObjLoaded);

      // Finish loading everything.
      {
         for (int32 i = 0; i < ObjLoaded.Num(); i++)
         {
            // Preload.
            UObject* Obj = ObjLoaded[i];//在这拿到之前添加进去的需要加载的所有Export等
            if (Obj->HasAnyFlags(RF_NeedLoad))
            {
               FLinkerLoad* Linker = Obj->GetLinker();
               check(Linker);

               UPackage* Package = Linker->LinkerRoot;
               check(Package);

               Linker->Preload(Obj);
            }
         }
      }
//再之后做一些操作后开始进行PostLoad等之类逻辑并刷新Linker删除对给定包的链接器的引用等

void FLinkerLoad::Preload( UObject* Object )
{
    //...
    FAsyncArchive* AsyncLoader = GetAsyncLoader();
    {
        SCOPE_CYCLE_COUNTER(STAT_LinkerPrecache);
        // tell the file reader to read the raw data from disk
        if (AsyncLoader)
        {
           bool bReady = AsyncLoader->PrecacheWithTimeLimit(Export.SerialOffset, Export.SerialSize, bUseTimeLimit, bUseFullTimeLimit, TickStartTime, TimeLimit);
           UE_CLOG(!(bReady || !bUseTimeLimit || !FPlatformProperties::RequiresCookedData()), LogLinker, Warning, TEXT("Hitch on async loading of %s; this export was not properly precached."), *Object->GetFullName());
        }
        else
        {
           Loader->Precache(Export.SerialOffset, Export.SerialSize);
        }
    }
    //...//Object->SerializeScriptProperties(Adapter.GetArchive());等
}

// 搜索 /Game/ 路径下所有 Triangles 小于 300 的StaticMesh

int32 MaxTriangles = 300;

IAssetRegistry& AssetRegistry = FAssetRegistryModule::GetRegistry();

FARFilter ARFilter;
ARFilter.ClassNames.Add(UStaticMesh::StaticClass()->GetFName());
ARFilter.PackagePaths.Add(TEXT("/Game/"));
ARFilter.bRecursivePaths = true;

TArray<FSoftObjectPath> AssetList;
TArray<FAssetData> Assets;

AssetRegistry.GetAssets(ARFilter, Assets);
//AssetList.Reserve(Assets.Num());

for(int32 i = 0; i < Assets.Num(); i++)
{
	const FAssetData& AssetData = Assets[i];
	
	int32 TriangleCount;
	if(AssetData.GetTagValue<int32>("Triangles", TriangleCount)
		&& TriangleCount < MaxTriangles)
	{
		AssetList.Add(AssetData.ToSoftObjectPath());
	}
}

AssetList.Shrink();

for(const FSoftObjectPath& Asset : AssetList)
{
	FString Message = Asset.ToString();
	GEngine->AddOnScreenDebugMessage(-1, 10.f, FColor::Red, Message);
}

/**
* Marks/Unmarks the package's bDirty flag, save the package to the transaction buffer if a transaction is ongoing
*/
COREUOBJECT_API void SetDirtyFlag( bool bIsDirty );
//D:\UE_5.4\Engine\Source\Runtime\CoreUObject\Private\UObject\Package.cpp
/**
 * Marks/Unmarks the package's bDirty flag
 */
void UPackage::SetDirtyFlag( bool bInIsDirty ){
    //...
    // Package is changing dirty state, let the editor know so we may prompt for source control checkout
    PackageDirtyStateChangedEvent.Broadcast(this);
    //...
}

/** D:\UE_5.4\Engine\Source\Runtime\CoreUObject\Public\UObject\UObjectBaseUtility.h
 * Finds the outermost package and marks it dirty. 
 * The editor suppresses this behavior during load as it is against policy to dirty packages simply by loading them.
 *
 * @return false if the request to mark the package dirty was suppressed by the editor and true otherwise.
 */
COREUOBJECT_API bool MarkPackageDirty() const;
/** D:\UE_5.4\Engine\Source\Runtime\CoreUObject\Private\UObject\UObjectBaseUtility.cpp
 * Finds the outermost package and marks it dirty
 */
bool UObjectBaseUtility::MarkPackageDirty() const{
    //...
    // We prevent needless re-dirtying as this can be an expensive operation.
    if( !bIsDirty )
    {
        Package->SetDirtyFlag(true);
    }

    // Always call PackageMarkedDirtyEvent, even when the package is already dirty
    Package->PackageMarkedDirtyEvent.Broadcast(Package, bIsDirty);
    //...
}

/** Delegate to notify subscribers when the dirty state of a package is changed.
 *  Allows the editor to register the modified package as one that should be prompted for source control checkout. 
 *  Use Package->IsDirty() to get the updated dirty state of the package */
UPackage::FOnPackageDirtyStateChanged UPackage::PackageDirtyStateChangedEvent;//这个是SetDirtyFlag会调用的
/** 
 * Delegate to notify subscribers when a package is marked as dirty via UObjectBaseUtilty::MarkPackageDirty 
 * Note: Unlike FOnPackageDirtyStateChanged, this is always called, even when the package is already dirty
 * Use bWasDirty to check the previous dirty state of the package
 * Use Package->IsDirty() to get the updated dirty state of the package
 */
UPackage::FOnPackageMarkedDirty UPackage::PackageMarkedDirtyEvent;//这个是MarkPackageDirty调用的
//用法
UPackage::PackageMarkedDirtyEvent.AddRaw(this, &FAssetManagerEditorModule::OnMarkPackageDirty);//例子