◆ LoadAssetWithPotentialAsync< T >()

async Task ReLogic.Content.AssetRepository.LoadAssetWithPotentialAsync< T >	(	Asset< T >	asset,
		AssetRequestMode	mode )
inlineprivate
Type Constraints
T
:
class
Definition at line 242 of file AssetRepository.cs.
                                                                                                     : class
    {
        _ = 3;
        try
        {
            if (!Monitor.IsEntered(_requestLock))
            {
                throw new Exception("Asset load started without holding _requestLock");
            }
            TotalAssets++;
            asset.SetToLoadingState();
            Interlocked.Increment(ref _Remaining);
            new List<string>();
            MainThreadCreationContext mainThreadCtx = new MainThreadCreationContext(new ContinuationScheduler(asset, this));
            IContentSource[] sources = _sources;
            foreach (IContentSource source in sources)
            {
                if (source.Rejections.IsRejected(asset.Name))
                {
                    continue;
                }
                string extension = source.GetExtension(asset.Name);
                if (extension == null)
                {
                    continue;
                }
                if (!_readers.TryGetReader(extension, out var reader))
                {
                    source.Rejections.Reject(asset.Name, new ContentRejectionNoCompatibleReader(extension, _readers.GetSupportedExtensions()));
                    continue;
                }
                if (mode == AssetRequestMode.AsyncLoad)
                {
                    await Task.Yield();
                }
                if (Monitor.IsEntered(_requestLock) && !IsMainThread)
                {
                    await Task.Yield();
                }
                T resultAsset;
                using (Stream stream = source.OpenStream(asset.Name + extension))
                {
                    _ = 2;
                    try
                    {
                        resultAsset = await reader.FromStream<T>(stream, mainThreadCtx);
                    }
                    catch (Exception e2)
                    {
                        source.Rejections.Reject(asset.Name, new ContentRejectionAssetReaderException(e2));
                        continue;
                    }
                }
                if (source.ContentValidator != null && !source.ContentValidator.AssetIsValid(resultAsset, asset.Name, out var rejectionReason))
                {
                    source.Rejections.Reject(asset.Name, rejectionReason);
                    continue;
                }
                await mainThreadCtx;
                if (!Monitor.IsEntered(_requestLock))
                {
                    throw new Exception("Asset transfer started without holding _requestLock");
                }
                asset.SubmitLoadedContent(resultAsset, source);
                LoadedAssets++;
                return;
            }
            throw AssetLoadException.FromMissingAsset(asset.Name);
        }
        catch (Exception e)
        {
            AssetLoadFailHandler?.Invoke(asset.Name, e);
            if (mode == AssetRequestMode.ImmediateLoad)
            {
                throw;
            }
        }
        finally
        {
            Interlocked.Decrement(ref _Remaining);
        }
    }