AssetBundleGraph.TypeUtility.FindTypeOfAsset C# (CSharp) Method

        public static Type FindTypeOfAsset(string assetPath)
        {
            // check by asset importer type.
            var importer = AssetImporter.GetAtPath(assetPath);
            if (importer == null) {
                Debug.LogWarning("Failed to assume assetType of asset. The asset will be ignored: " + assetPath);
                return typeof(object);
            }

            var assumedImporterType = importer.GetType();
            var importerTypeStr = assumedImporterType.ToString();

            switch (importerTypeStr) {
                case "UnityEditor.TextureImporter":
                case "UnityEditor.ModelImporter":
                case "UnityEditor.AudioImporter": {
                    return assumedImporterType;
                }
            }

            // not specific type importer. should determine their type by extension.
            var extension = Path.GetExtension(assetPath);
            if (AssumeTypeBindingByExtension.ContainsKey(extension)) {
                return AssumeTypeBindingByExtension[extension];
            }

            if (IgnoredExtension.Contains(extension)) {
                return null;
            }

            // unhandled.
            Debug.LogWarning("Unknown file type found:" + extension + "\n. Asset:" + assetPath + "\n Assume 'object'.");
            return typeof(object);
        }

        private void Filter(List <Asset> assets, Action <string, List <string> > FilterResultReceiver)
        {
            var exhaustiveAssets = new List <ExhaustiveAssetPathData>();

            foreach (var asset in assets)
            {
                exhaustiveAssets.Add(new ExhaustiveAssetPathData(asset.absoluteAssetPath, asset.importFrom));
            }

            for (var i = 0; i < connectionIdsFromThisNodeToChildNodesOrFakeIds.Length; i++)
            {
                // these 3 parameters depends on their contents order.
                var connectionId = connectionIdsFromThisNodeToChildNodesOrFakeIds[i];
                var keyword      = containsKeywords[i];
                var keytype      = containsKeytypes[i];

                // filter by keyword first
                List <ExhaustiveAssetPathData> keywordContainsAssets = exhaustiveAssets.Where(
                    assetData =>
                    !assetData.isFilterExhausted &&
                    Regex.IsMatch(assetData.importFrom, keyword, RegexOptions.IgnoreCase | RegexOptions.IgnorePatternWhitespace)
                    ).ToList();

                var typeMatchedAssetsAbsolutePaths = new List <string>();

                // then, filter by type
                foreach (var containedAssetData in keywordContainsAssets)
                {
                    if (keytype != AssetBundleGraphSettings.DEFAULT_FILTER_KEYTYPE)
                    {
                        var assumedType = TypeUtility.FindTypeOfAsset(containedAssetData.importFrom);
                        if (assumedType == null || keytype != assumedType.ToString())
                        {
                            continue;
                        }
                    }
                    typeMatchedAssetsAbsolutePaths.Add(containedAssetData.absoluteAssetPath);
                }

                // mark assets as exhausted.
                foreach (var exhaustiveAsset in exhaustiveAssets)
                {
                    if (typeMatchedAssetsAbsolutePaths.Contains(exhaustiveAsset.absoluteAssetPath))
                    {
                        exhaustiveAsset.isFilterExhausted = true;
                    }
                }

                if (connectionId != AssetBundleGraphSettings.FILTER_FAKE_CONNECTION_ID)
                {
                    FilterResultReceiver(connectionId, typeMatchedAssetsAbsolutePaths);
                }
            }
        }