using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Threading;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using EntityStates;
using HG.Reflection;
using HarmonyLib;
using HarmonyLib.Public.Patching;
using Microsoft.CodeAnalysis;
using Mono.Cecil;
using Mono.Cecil.Cil;
using Mono.Collections.Generic;
using MonoDetour;
using MonoMod.Cil;
using MonoMod.RuntimeDetour;
using MonoMod.RuntimeDetour.HookGen;
using MonoMod.Utils;
using RoR2;
using RoR2.Achievements;
using RoR2.ConVar;
using RoR2.ContentManagement;
using RoR2.EntitlementManagement;
using RoR2.Items;
using RoR2.Networking;
using RoR2.UI;
using RoR2.UI.MainMenu;
using RoR2BepInExPack.GameAssetPaths.Version_1_39_0;
using RoR2BepInExPack.LegacyAssetSystem;
using RoR2BepInExPack.ModCompatibility;
using RoR2BepInExPack.ReflectionHooks;
using RoR2BepInExPack.UnityEngineHooks;
using RoR2BepInExPack.VanillaFixes;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.Networking;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("0Harmony")]
[assembly: IgnoresAccessChecksTo("HGUnityUtils")]
[assembly: AssemblyCompany("RoR2BepInExPack")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.43.0")]
[assembly: AssemblyInformationalVersion("1.43.0+6757a9cd683ac03d499276599cef90b52c9aa39f")]
[assembly: AssemblyProduct("RoR2BepInExPack")]
[assembly: AssemblyTitle("RoR2BepInExPack")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.43.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class NullableContextAttribute : Attribute
{
public readonly byte Flag;
public NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class NativeIntegerAttribute : Attribute
{
public readonly bool[] TransformFlags;
public NativeIntegerAttribute()
{
TransformFlags = new bool[1] { true };
}
public NativeIntegerAttribute(bool[] P_0)
{
TransformFlags = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace RoR2BepInExPack
{
internal static class HookWatcher
{
internal class HookInfo
{
internal enum HookKind
{
On,
IL,
Native
}
internal HookKind Kind;
internal Assembly? Owner;
internal MethodBase? OriginalManaged;
internal IntPtr OriginalNative;
internal Delegate? HookDelegate;
internal IntPtr HookIntPtr;
internal MethodBase? HookMethodBase;
}
private static Hook _harmonyWatcher;
private static bool _isMonoDetourPresent;
internal static bool RedirectFixFrameRateDependantLogicHooks;
private static DetourModManager ModManager { get; set; }
internal static void Init()
{
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_0039: Expected O, but got Unknown
//IL_015f: Unknown result type (might be due to invalid IL or missing references)
//IL_016d: Unknown result type (might be due to invalid IL or missing references)
//IL_016e: Unknown result type (might be due to invalid IL or missing references)
//IL_0178: Expected O, but got Unknown
try
{
_isMonoDetourPresent = (object)Type.GetType("MonoDetour.MonoDetourHook, com.github.MonoDetour")?.GetMethod("TryGetFrom") != null;
}
catch (Exception data)
{
Log.Error(data);
}
ModManager = new DetourModManager();
ModManager.OnHook += LogOnHook;
ModManager.OnILHook += LogILHook;
ModManager.OnDetour += LogDetour;
ModManager.OnNativeDetour += LogNativeDetour;
HookEndpointManager.OnAdd += LogHookAdd;
HookEndpointManager.OnModify += LogHookModify;
HookEndpointManager.OnRemove += LogHookRemove;
_harmonyWatcher = new Hook((MethodBase)typeof(Job<MethodInfo>).GetMethod("AddPatch", (BindingFlags)(-1)), (Delegate)new Action<Action<Job<MethodInfo>, AttributePatch>, Job<MethodInfo>, AttributePatch>(HarmonyAddPatchWatcher), new HookConfig
{
ManualApply = true
});
_harmonyWatcher.Apply();
}
private static void HarmonyAddPatchWatcher(Action<Job<MethodInfo>, AttributePatch> orig, Job<MethodInfo> self, AttributePatch patch)
{
orig(self, patch);
try
{
Assembly assembly = patch.info.method.DeclaringType.Assembly;
string text = (string.IsNullOrEmpty(assembly.Location) ? assembly.GetName().Name : Path.GetFileName(assembly.Location));
Log.Debug($"Harmony {patch.type} {GeneralExtensions.FullDescription((MethodBase)patch.info.method)} added by {text} for: {GeneralExtensions.FullDescription(self.original)}");
}
catch (Exception data)
{
Log.Debug(data);
}
}
internal static void Destroy()
{
_harmonyWatcher.Undo();
_harmonyWatcher.Free();
HookEndpointManager.OnRemove -= LogHookRemove;
HookEndpointManager.OnModify -= LogHookModify;
HookEndpointManager.OnAdd -= LogHookAdd;
ModManager.OnNativeDetour -= LogNativeDetour;
ModManager.OnDetour -= LogDetour;
ModManager.OnILHook -= LogILHook;
ModManager.OnHook -= LogOnHook;
ModManager.Dispose();
ModManager = null;
}
private static void LogOnHook(Assembly hookOwner, MethodBase from, MethodBase to, object target)
{
LogHook(new HookInfo
{
Kind = HookInfo.HookKind.On,
Owner = hookOwner,
OriginalManaged = from,
HookMethodBase = to
});
}
private static void LogILHook(Assembly hookOwner, MethodBase from, Manipulator manipulator)
{
if (!_isMonoDetourPresent || !IfMonoDetourHookDoSpecializedLog(manipulator, from))
{
LogHook(new HookInfo
{
Kind = HookInfo.HookKind.IL,
Owner = hookOwner,
OriginalManaged = from,
HookDelegate = (Delegate?)(object)manipulator
});
}
}
[MethodImpl(MethodImplOptions.NoInlining)]
private static bool IfMonoDetourHookDoSpecializedLog(Manipulator manipulator, MethodBase from)
{
MonoDetourHook val = default(MonoDetourHook);
if (!MonoDetourHook.TryGetFrom(manipulator, ref val))
{
return false;
}
string text;
if (val.ApplierType.Name.EndsWith("Detour", StringComparison.InvariantCulture))
{
string name = val.ApplierType.Name;
text = name.Substring(0, name.Length - 6);
}
else
{
text = val.ApplierType.Name;
}
LogHook(new HookInfo
{
Kind = HookInfo.HookKind.IL,
Owner = val.Manipulator.Module.Assembly,
OriginalManaged = from,
HookMethodBase = val.Manipulator
}, "added", " MonoDetour<" + text + ">");
return true;
}
private static void LogDetour(Assembly hookOwner, MethodBase from, MethodBase to)
{
LogHook(new HookInfo
{
Kind = HookInfo.HookKind.On,
Owner = hookOwner,
OriginalManaged = from,
HookMethodBase = to
});
}
private static void LogNativeDetour(Assembly hookOwner, MethodBase originalMethod, IntPtr from, IntPtr to)
{
LogHook(new HookInfo
{
Kind = HookInfo.HookKind.Native,
Owner = hookOwner,
OriginalNative = from,
HookIntPtr = to
});
}
private static bool LogHookAdd(MethodBase from, Delegate to)
{
return LogHook(GetHookInfo(from, to));
}
private static bool LogHookModify(MethodBase from, Delegate to)
{
return LogHook(GetHookInfo(from, to), "modifier");
}
private static bool LogHookRemove(MethodBase from, Delegate to)
{
return LogHook(GetHookInfo(from, to), "removed");
}
private static HookInfo GetHookInfo(MethodBase from, Delegate to)
{
HookInfo hookInfo = new HookInfo
{
Owner = to.Method.Module.Assembly,
OriginalManaged = from
};
Manipulator val = (Manipulator)(object)((to is Manipulator) ? to : null);
if (val != null)
{
hookInfo.Kind = HookInfo.HookKind.IL;
hookInfo.HookDelegate = (Delegate?)(object)val;
}
else
{
hookInfo.Kind = HookInfo.HookKind.On;
hookInfo.HookDelegate = to;
}
return hookInfo;
}
private static bool LogHook(HookInfo hookInfo, string context = "added", string? specifier = null)
{
HookInfo hookInfo2 = hookInfo;
if (hookInfo2.OriginalManaged == null)
{
return true;
}
string text = "Not Found";
if (hookInfo2.Owner != null)
{
text = Path.GetFileName(hookInfo2.Owner.Location);
}
Type declaringType = hookInfo2.OriginalManaged.DeclaringType;
string name = hookInfo2.OriginalManaged.Name;
string text2 = ((declaringType != null) ? (declaringType.FullName + "." + name) : name);
Log.Debug($"{hookInfo2.Kind}Hook{specifier} {GetToIdentifier()} {context} by assembly: {text} for: {text2}");
return true;
string? GetToIdentifier()
{
if ((object)hookInfo2.HookDelegate != null)
{
Type type = hookInfo2.HookDelegate.Method?.DeclaringType;
string text3 = hookInfo2.HookDelegate.Method?.Name;
if (!(type != null))
{
return text3;
}
return type.FullName + "." + text3;
}
if (hookInfo2.HookMethodBase != null)
{
Type declaringType2 = hookInfo2.HookMethodBase.DeclaringType;
string name2 = hookInfo2.HookMethodBase.Name;
if (!(declaringType2 != null))
{
return name2;
}
return declaringType2.FullName + "." + name2;
}
return "";
}
}
}
internal static class Log
{
internal static ManualLogSource _logSource;
internal static void Init(ManualLogSource logSource)
{
_logSource = logSource;
}
internal static void Debug(object data)
{
_logSource.LogDebug(data);
}
internal static void Error(object data)
{
_logSource.LogError(data);
}
internal static void Fatal(object data)
{
_logSource.LogFatal(data);
}
internal static void Info(object data)
{
_logSource.LogInfo(data);
}
internal static void Message(object data)
{
_logSource.LogMessage(data);
}
internal static void Warning(object data)
{
_logSource.LogWarning(data);
}
}
[BepInPlugin("___riskofthunder.RoR2BepInExPack", "RoR2BepInExPack", "1.43.0")]
public class RoR2BepInExPack : BaseUnityPlugin
{
public const string PluginGUID = "___riskofthunder.RoR2BepInExPack";
public const string PluginName = "RoR2BepInExPack";
public const string PluginVersion = "1.43.0";
private void Awake()
{
Log.Init(((BaseUnityPlugin)this).Logger);
RoR2Application.isModded = true;
HookWatcher.Init();
FrankenMonoPrintStackOverflowException.Init();
FixLRAPIReturns.Init(((BaseUnityPlugin)this).Info);
InitHooks();
Application.quitting += OnApplicationQuitting;
}
private void OnEnable()
{
EnableHooks();
}
private void OnDisable()
{
DisableHooks();
}
private void OnDestroy()
{
DestroyHooks();
HookWatcher.Destroy();
}
private void InitHooks()
{
ILLine.Init();
AutoCatchReflectionTypeLoadException.Init();
SaferAchievementManager.Init();
SaferResourceAvailability.Init();
SaferSearchableAttribute.Init();
FixConsoleLog.Init();
FixConVar.Init();
FixDeathAnimLog.Init();
FixExtraGameModesMenu.Init();
SaferWWise.Init();
FixNullEntitlement.Init();
FixNonLethalOneHP.Init();
FixRunScaling.Init();
FixDedicatedServerMaxPlayerCount.Init();
FixHasEffectiveAuthority.Init();
FixSystemInitializer.Init();
FixRuleBookViewerStrip.Init();
LogNetworkInvokeException.Init();
FixDuplicateItemTiers.Init();
LegacyResourcesDetours.Init();
LegacyShaderDetours.Init();
FixMultiCorrupt.Init(((BaseUnityPlugin)this).Config);
HarmonyMatchException.Init();
}
private static void EnableHooks()
{
ILLine.Enable();
AutoCatchReflectionTypeLoadException.Enable();
SaferAchievementManager.Enable();
SaferResourceAvailability.Enable();
SaferSearchableAttribute.Enable();
FixConsoleLog.Enable();
FixConVar.Enable();
FixDeathAnimLog.Enable();
FixExtraGameModesMenu.Enable();
SaferWWise.Enable();
FixNullEntitlement.Enable();
FixNonLethalOneHP.Enable();
FixRunScaling.Enable();
FixDedicatedServerMaxPlayerCount.Enable();
FixHasEffectiveAuthority.Enable();
FixRuleBookViewerStrip.Enable();
LogNetworkInvokeException.Enable();
FixDuplicateItemTiers.Enable();
LegacyResourcesDetours.Enable();
LegacyShaderDetours.Enable();
FixMultiCorrupt.Enable();
HarmonyMatchException.Enable();
}
private static void DisableHooks()
{
HarmonyMatchException.Disable();
FixMultiCorrupt.Disable();
LegacyShaderDetours.Disable();
LegacyResourcesDetours.Disable();
FixDuplicateItemTiers.Disable();
LogNetworkInvokeException.Disable();
FixHasEffectiveAuthority.Disable();
FixDedicatedServerMaxPlayerCount.Disable();
FixRunScaling.Disable();
FixNonLethalOneHP.Disable();
FixNullEntitlement.Disable();
SaferWWise.Disable();
FixExtraGameModesMenu.Disable();
FixDeathAnimLog.Disable();
FixConsoleLog.Disable();
FixConVar.Disable();
FixRuleBookViewerStrip.Disable();
SaferSearchableAttribute.Disable();
SaferResourceAvailability.Disable();
SaferAchievementManager.Disable();
AutoCatchReflectionTypeLoadException.Disable();
ILLine.Disable();
}
private static void DestroyHooks()
{
HarmonyMatchException.Destroy();
FixMultiCorrupt.Destroy();
LegacyShaderDetours.Destroy();
LegacyResourcesDetours.Destroy();
FixDuplicateItemTiers.Destroy();
LogNetworkInvokeException.Destroy();
FixHasEffectiveAuthority.Destroy();
FixDedicatedServerMaxPlayerCount.Destroy();
FixRunScaling.Destroy();
FixNonLethalOneHP.Destroy();
FixNullEntitlement.Destroy();
SaferWWise.Destroy();
FixExtraGameModesMenu.Destroy();
FixDeathAnimLog.Destroy();
FixConsoleLog.Destroy();
FixConVar.Destroy();
FixRuleBookViewerStrip.Destroy();
SaferSearchableAttribute.Destroy();
SaferResourceAvailability.Destroy();
SaferAchievementManager.Destroy();
AutoCatchReflectionTypeLoadException.Destroy();
ILLine.Destroy();
}
private void OnApplicationQuitting()
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_000b: Expected O, but got Unknown
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
GameObject val = new GameObject();
Object.DontDestroyOnLoad((Object)val);
Scene scene = val.scene;
GameObject[] rootGameObjects = ((Scene)(ref scene)).GetRootGameObjects();
foreach (GameObject val2 in rootGameObjects)
{
try
{
Object.DestroyImmediate((Object)(object)val2);
}
catch (Exception data)
{
Log.Error(data);
}
}
}
}
}
namespace RoR2BepInExPack.Utilities
{
public class FixedConditionalWeakTable<TKey, TValue> : IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable, IReadOnlyDictionary<TKey, TValue>, IReadOnlyCollection<KeyValuePair<TKey, TValue>>, FixedConditionalWeakTableManager.IShrinkable where TKey : class where TValue : class
{
private readonly struct WeakReferenceWrapper<T> where T : class
{
public readonly int targetHashCode;
public readonly WeakReference<T> weakReference;
public readonly T target;
public WeakReferenceWrapper(T target, bool strongReference)
{
targetHashCode = target.GetHashCode();
if (strongReference)
{
this.target = target;
weakReference = null;
}
else
{
this.target = null;
weakReference = new WeakReference<T>(target);
}
}
public WeakReferenceWrapper(int targetHashCode)
{
this.targetHashCode = targetHashCode;
target = null;
weakReference = null;
}
}
[StructLayout(LayoutKind.Sequential, Size = 1)]
private readonly struct WeakReferenceWrapperComparer<T> : IEqualityComparer<WeakReferenceWrapper<T>> where T : class
{
public bool Equals(WeakReferenceWrapper<T> first, WeakReferenceWrapper<T> second)
{
T target = first.target;
T target2 = second.target;
T target3;
if (target == null && first.weakReference == null)
{
return !second.weakReference.TryGetTarget(out target3);
}
if (target2 == null && second.weakReference == null)
{
return !first.weakReference.TryGetTarget(out target3);
}
if (target == null && !first.weakReference.TryGetTarget(out target))
{
return false;
}
if (target2 == null && !second.weakReference.TryGetTarget(out target2))
{
return false;
}
return target == target2;
}
public int GetHashCode(WeakReferenceWrapper<T> obj)
{
return obj.targetHashCode;
}
}
[CompilerGenerated]
private sealed class <GetEnumerator>d__32 : IEnumerator<KeyValuePair<TKey, TValue>>, IEnumerator, IDisposable
{
private int <>1__state;
private KeyValuePair<TKey, TValue> <>2__current;
public FixedConditionalWeakTable<TKey, TValue> <>4__this;
private IEnumerator<KeyValuePair<WeakReferenceWrapper<TKey>, TValue>> <>7__wrap1;
KeyValuePair<TKey, TValue> IEnumerator<KeyValuePair<TKey, TValue>>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <GetEnumerator>d__32(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
int num = <>1__state;
if (num == -3 || num == 1)
{
try
{
}
finally
{
<>m__Finally1();
}
}
<>7__wrap1 = null;
<>1__state = -2;
}
private bool MoveNext()
{
try
{
int num = <>1__state;
FixedConditionalWeakTable<TKey, TValue> fixedConditionalWeakTable = <>4__this;
switch (num)
{
default:
return false;
case 0:
<>1__state = -1;
<>7__wrap1 = fixedConditionalWeakTable.valueByKey.GetEnumerator();
<>1__state = -3;
break;
case 1:
<>1__state = -3;
break;
}
while (<>7__wrap1.MoveNext())
{
<>7__wrap1.Current.Deconstruct(out var key, out var value);
WeakReferenceWrapper<TKey> weakReferenceWrapper = key;
TValue value2 = value;
if (weakReferenceWrapper.weakReference.TryGetTarget(out var target))
{
<>2__current = new KeyValuePair<TKey, TValue>(target, value2);
<>1__state = 1;
return true;
}
}
<>m__Finally1();
<>7__wrap1 = null;
return false;
}
catch
{
//try-fault
((IDisposable)this).Dispose();
throw;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
private void <>m__Finally1()
{
<>1__state = -1;
if (<>7__wrap1 != null)
{
<>7__wrap1.Dispose();
}
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
private ConstructorInfo cachedConstructor;
private readonly ConcurrentDictionary<WeakReferenceWrapper<TKey>, TValue> valueByKey = new ConcurrentDictionary<WeakReferenceWrapper<TKey>, TValue>(default(WeakReferenceWrapperComparer<TKey>));
public TValue this[TKey key]
{
get
{
return valueByKey[new WeakReferenceWrapper<TKey>(key, strongReference: true)];
}
set
{
valueByKey[new WeakReferenceWrapper<TKey>(key, strongReference: false)] = value;
}
}
public ICollection<TKey> Keys
{
get
{
List<TKey> list = new List<TKey>(valueByKey.Count);
foreach (WeakReferenceWrapper<TKey> key in valueByKey.Keys)
{
if (key.weakReference.TryGetTarget(out var target))
{
list.Add(target);
}
}
return list.AsReadOnly();
}
}
public ICollection<TValue> Values
{
get
{
List<TValue> list = new List<TValue>(valueByKey.Count);
foreach (KeyValuePair<WeakReferenceWrapper<TKey>, TValue> item2 in valueByKey)
{
item2.Deconstruct(out var key, out var value);
WeakReferenceWrapper<TKey> weakReferenceWrapper = key;
TValue item = value;
if (weakReferenceWrapper.weakReference.TryGetTarget(out var _))
{
list.Add(item);
}
}
return list.AsReadOnly();
}
}
public int Count
{
get
{
int num = 0;
foreach (WeakReferenceWrapper<TKey> key in valueByKey.Keys)
{
if (key.weakReference.TryGetTarget(out var _))
{
num++;
}
}
return num;
}
}
public int SpeculativeCount => valueByKey.Count;
bool ICollection<KeyValuePair<TKey, TValue>>.IsReadOnly => false;
IEnumerable<TKey> IReadOnlyDictionary<TKey, TValue>.Keys => Keys;
IEnumerable<TValue> IReadOnlyDictionary<TKey, TValue>.Values => Values;
public FixedConditionalWeakTable()
{
FixedConditionalWeakTableManager.Add(this);
}
public void Add(TKey key, TValue value)
{
if (key == null)
{
throw new ArgumentNullException("key");
}
if (!valueByKey.TryAdd(new WeakReferenceWrapper<TKey>(key, strongReference: false), value))
{
throw new ArgumentException("The key already exists");
}
}
public bool Remove(TKey key)
{
TValue value;
return valueByKey.TryRemove(new WeakReferenceWrapper<TKey>(key, strongReference: true), out value);
}
public bool TryGetValue(TKey key, out TValue value)
{
return valueByKey.TryGetValue(new WeakReferenceWrapper<TKey>(key, strongReference: true), out value);
}
public TValue GetValue(TKey key, Func<TKey, TValue> defaultFunc)
{
if (TryGetValue(key, out var value))
{
return value;
}
value = defaultFunc(key);
Add(key, value);
return value;
}
public TValue GetOrCreateValue(TKey key)
{
if (TryGetValue(key, out var value))
{
return value;
}
if ((object)cachedConstructor == null)
{
Type typeFromHandle = typeof(TValue);
cachedConstructor = typeFromHandle.GetConstructor(Array.Empty<Type>());
if ((object)cachedConstructor == null)
{
throw new MissingMethodException(typeFromHandle.FullName + " doesn't have public parameterless constructor");
}
}
value = (TValue)cachedConstructor.Invoke(Array.Empty<object>());
Add(key, value);
return value;
}
void FixedConditionalWeakTableManager.IShrinkable.Shrink()
{
foreach (KeyValuePair<WeakReferenceWrapper<TKey>, TValue> item in valueByKey)
{
if (!item.Key.weakReference.TryGetTarget(out var _))
{
valueByKey.TryRemove(new WeakReferenceWrapper<TKey>(item.Key.targetHashCode), out var _);
}
}
}
public bool ContainsKey(TKey key)
{
return valueByKey.ContainsKey(new WeakReferenceWrapper<TKey>(key, strongReference: true));
}
public void Clear()
{
valueByKey.Clear();
}
void ICollection<KeyValuePair<TKey, TValue>>.Add(KeyValuePair<TKey, TValue> kvp)
{
Add(kvp.Key, kvp.Value);
}
bool ICollection<KeyValuePair<TKey, TValue>>.Contains(KeyValuePair<TKey, TValue> kvp)
{
if (TryGetValue(kvp.Key, out var value))
{
return EqualityComparer<TValue>.Default.Equals(value, kvp.Value);
}
return false;
}
void ICollection<KeyValuePair<TKey, TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
{
if (array == null)
{
throw new ArgumentNullException("array");
}
if (arrayIndex < 0 || arrayIndex >= array.Length)
{
throw new ArgumentOutOfRangeException("arrayIndex", "arrayIndex is not a valid index in array");
}
int count = Count;
if (arrayIndex + count > array.Length)
{
throw new ArgumentOutOfRangeException("array", "Destination array is not long enough to copy all the items in the collection.");
}
foreach (KeyValuePair<WeakReferenceWrapper<TKey>, TValue> item in valueByKey)
{
item.Deconstruct(out var key, out var value);
WeakReferenceWrapper<TKey> weakReferenceWrapper = key;
TValue value2 = value;
if (weakReferenceWrapper.weakReference.TryGetTarget(out var target))
{
array[arrayIndex++] = new KeyValuePair<TKey, TValue>(target, value2);
}
}
}
bool ICollection<KeyValuePair<TKey, TValue>>.Remove(KeyValuePair<TKey, TValue> kvp)
{
if (TryGetValue(kvp.Key, out var value) && EqualityComparer<TValue>.Default.Equals(value, kvp.Value))
{
return Remove(kvp.Key);
}
return false;
}
[IteratorStateMachine(typeof(FixedConditionalWeakTable<, >.<GetEnumerator>d__32))]
public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <GetEnumerator>d__32(0)
{
<>4__this = this
};
}
IEnumerator IEnumerable.GetEnumerator()
{
return GetEnumerator();
}
}
internal static class FixedConditionalWeakTableManager
{
internal interface IShrinkable
{
void Shrink();
}
private const int shrinkAttemptDelay = 2000;
private static readonly object lockObject = new object();
private static readonly List<WeakReference<IShrinkable>> instances = new List<WeakReference<IShrinkable>>();
private static int lastCollectionCount = 0;
public static void Add(IShrinkable weakTable)
{
lock (lockObject)
{
if (instances.Count == 0)
{
new Thread(ShrinkThreadLoop).Start();
}
instances.Add(new WeakReference<IShrinkable>(weakTable));
}
}
private static void ShrinkThreadLoop()
{
while (true)
{
Thread.Sleep(2000);
int num = GC.CollectionCount(2);
if (lastCollectionCount == num)
{
continue;
}
lastCollectionCount = num;
lock (lockObject)
{
for (int num2 = instances.Count - 1; num2 >= 0; num2--)
{
if (!instances[num2].TryGetTarget(out var target))
{
instances.RemoveAt(num2);
}
else
{
target.Shrink();
}
}
if (instances.Count == 0)
{
break;
}
}
}
}
}
public static class NativeDetourExtensions
{
private static readonly FieldInfo backupNativeField = typeof(NativeDetour).GetField("_BackupNative", (BindingFlags)(-1));
public static T GenerateTrampolineWithRecursionSupport<T>(this NativeDetour detour, uint bytesCount) where T : Delegate
{
if (!typeof(Delegate).IsAssignableFrom(typeof(T)))
{
throw new InvalidOperationException($"Type {typeof(T)} not a delegate type.");
}
return detour.GenerateNativeProxy(typeof(T).GetMethod("Invoke"), bytesCount).CreateDelegate(typeof(T)) as T;
}
public static MethodInfo GenerateNativeProxy(this NativeDetour detour, MethodBase signature, uint bytesCount)
{
//IL_0056: Unknown result type (might be due to invalid IL or missing references)
//IL_0084: Unknown result type (might be due to invalid IL or missing references)
//IL_008b: Expected O, but got Unknown
//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
//IL_00db: Unknown result type (might be due to invalid IL or missing references)
//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
//IL_0103: Unknown result type (might be due to invalid IL or missing references)
//IL_0105: Unknown result type (might be due to invalid IL or missing references)
//IL_010c: Unknown result type (might be due to invalid IL or missing references)
//IL_0125: Unknown result type (might be due to invalid IL or missing references)
//IL_0135: Unknown result type (might be due to invalid IL or missing references)
//IL_0182: Unknown result type (might be due to invalid IL or missing references)
//IL_018e: Unknown result type (might be due to invalid IL or missing references)
//IL_019a: Unknown result type (might be due to invalid IL or missing references)
//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
//IL_014a: Unknown result type (might be due to invalid IL or missing references)
//IL_0155: Unknown result type (might be due to invalid IL or missing references)
//IL_0167: Unknown result type (might be due to invalid IL or missing references)
Type type = (signature as MethodInfo)?.ReturnType ?? typeof(void);
ParameterInfo[] parameters = signature.GetParameters();
Type[] array = new Type[parameters.Length];
for (int i = 0; i < parameters.Length; i++)
{
array[i] = parameters[i].ParameterType;
}
DynamicMethodDefinition val = new DynamicMethodDefinition("Native<" + ((long)detour.Data.Method).ToString("X16", CultureInfo.InvariantCulture) + ">", type, array);
MethodInfo methodInfo;
try
{
methodInfo = DetourHelper.Pin<MethodInfo>(DetourHelper.StubCriticalDetour(val).Generate());
}
finally
{
((IDisposable)val)?.Dispose();
}
IntPtr nativeStart = DetourHelper.GetNativeStart((MethodBase)methodInfo);
NativeDetourData val2 = DetourHelper.Native.Create(nativeStart.Add(bytesCount), detour.Data.Method.Add(bytesCount), (byte?)null);
NativeDetourData val3 = default(NativeDetourData);
val3.Method = nativeStart;
val3.Size = bytesCount + val2.Size;
NativeDetourData val4 = val3;
DetourHelper.MakeWritable(DetourHelper.Native, val4);
IntPtr from = (IntPtr)backupNativeField.GetValue(detour);
uint num = bytesCount - detour.Data.Size;
Write(from, nativeStart, detour.Data.Size);
if (num != 0)
{
Write(detour.Data.Method.Add(detour.Data.Size), nativeStart.Add(detour.Data.Size), num);
}
DetourHelper.Native.Apply(val2);
DetourHelper.MakeExecutable(DetourHelper.Native, val4);
DetourHelper.FlushICache(DetourHelper.Native, val4);
DetourHelper.Native.Free(val4);
return methodInfo;
}
private unsafe static void Write(IntPtr from, IntPtr to, uint size)
{
byte* ptr = (byte*)from.ToPointer();
int num = 0;
for (int i = 0; i < size; i++)
{
DetourHelper.Write(to, ref num, ptr[i]);
}
}
public static IntPtr Add(this IntPtr ptr, long offset)
{
return new IntPtr(ptr.ToInt64() + offset);
}
public static IntPtr Add(this IntPtr ptr, uint offset)
{
return new IntPtr(ptr.ToInt64() + offset);
}
}
}
namespace RoR2BepInExPack.VanillaFixes
{
internal class HarmonyMatchException
{
[CompilerGenerated]
private static class <>O
{
public static Manipulator <0>__FixHarmonyMatchException;
public static Action<ILContext> <1>__ApplyILLabels;
public static Action<ILContext> <2>__UnApplyILLabels;
}
private static ILHook _hook;
internal static void Init()
{
//IL_005d: Unknown result type (might be due to invalid IL or missing references)
//IL_006b: Unknown result type (might be due to invalid IL or missing references)
//IL_006c: Unknown result type (might be due to invalid IL or missing references)
//IL_0076: Expected O, but got Unknown
//IL_0050: Unknown result type (might be due to invalid IL or missing references)
//IL_0055: Unknown result type (might be due to invalid IL or missing references)
//IL_005b: Expected O, but got Unknown
MethodInfo methodInfo = AccessTools.DeclaredMethod(typeof(HarmonyManipulator), "ApplyManipulators", (Type[])null, (Type[])null) ?? AccessTools.DeclaredMethod(typeof(HarmonyManipulator), "ApplyILManipulators", (Type[])null, (Type[])null);
if ((object)methodInfo == null)
{
Log.Error("Could not apply fix for HarmonyMatchException, target method is invalid");
return;
}
object obj = <>O.<0>__FixHarmonyMatchException;
if (obj == null)
{
Manipulator val = FixHarmonyMatchException;
<>O.<0>__FixHarmonyMatchException = val;
obj = (object)val;
}
_hook = new ILHook((MethodBase)methodInfo, (Manipulator)obj, new ILHookConfig
{
ManualApply = true
});
}
internal static void Enable()
{
ILHook hook = _hook;
if (hook != null)
{
hook.Apply();
}
}
internal static void Disable()
{
ILHook hook = _hook;
if (hook != null)
{
hook.Undo();
}
}
internal static void Destroy()
{
ILHook hook = _hook;
if (hook != null)
{
hook.Free();
}
}
internal static void FixHarmonyMatchException(ILContext il)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Expected O, but got Unknown
//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
//IL_012a: Unknown result type (might be due to invalid IL or missing references)
ILCursor val = new ILCursor(il);
int num = default(int);
MethodReference val2 = default(MethodReference);
if (!val.TryGotoNext((MoveType)1, new Func<Instruction, bool>[5]
{
(Instruction x) => ILPatternMatchingExt.MatchLdnull(x),
(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, ref num),
(Instruction x) => ILPatternMatchingExt.MatchCallvirt(x, ref val2),
(Instruction x) => ILPatternMatchingExt.MatchCallvirt(x, (MethodBase)AccessTools.Method(typeof(MethodBase), "Invoke", new Type[2]
{
typeof(object),
typeof(object[])
}, (Type[])null)),
(Instruction x) => ILPatternMatchingExt.MatchPop(x)
}))
{
Log.Error("Could not apply fix for FixHarmonyMatchException");
return;
}
val.Emit(OpCodes.Ldarg_0);
val.EmitDelegate<Action<ILContext>>((Action<ILContext>)ApplyILLabels);
val.GotoNext((MoveType)2, new Func<Instruction, bool>[1]
{
(Instruction x) => ILPatternMatchingExt.MatchPop(x)
});
val.Emit(OpCodes.Ldarg_0);
val.EmitDelegate<Action<ILContext>>((Action<ILContext>)UnApplyILLabels);
}
internal static void ApplyILLabels(ILContext il)
{
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
ILContext obj = il;
if (((obj != null) ? obj.Instrs : null) == null)
{
return;
}
Enumerator<Instruction> enumerator = il.Instrs.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
Instruction current = enumerator.Current;
if (((current != null) ? current.Operand : null) == null)
{
continue;
}
object operand = current.Operand;
Instruction val = (Instruction)((operand is Instruction) ? operand : null);
if (val != null)
{
current.Operand = il.DefineLabel(val);
}
else if (current.Operand is Instruction[] source)
{
current.Operand = source.Select((Instruction t) => il.DefineLabel(t)).ToArray();
}
}
}
finally
{
((IDisposable)enumerator).Dispose();
}
}
internal static void UnApplyILLabels(ILContext il)
{
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
if (((il != null) ? il.Instrs : null) == null || il.IsReadOnly)
{
return;
}
Enumerator<Instruction> enumerator = il.Instrs.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
Instruction current = enumerator.Current;
if (((current != null) ? current.Operand : null) == null)
{
continue;
}
object operand = current.Operand;
ILLabel val = (ILLabel)((operand is ILLabel) ? operand : null);
if (val != null)
{
current.Operand = val.Target;
}
else if (current.Operand is ILLabel[] source)
{
current.Operand = source.Select((ILLabel l) => l.Target).ToArray();
}
}
}
finally
{
((IDisposable)enumerator).Dispose();
}
}
}
internal class ILLine
{
private static ILHook _hook;
internal static void Init()
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Expected O, but got Unknown
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_003b: Expected O, but got Unknown
HookConfig val = default(HookConfig);
val.ManualApply = true;
_hook = new ILHook((MethodBase)typeof(StackTrace).GetMethod("AddFrames", (BindingFlags)(-1)), new Manipulator(ShowILLine));
}
internal static void Enable()
{
_hook.Apply();
}
internal static void Disable()
{
_hook.Undo();
}
internal static void Destroy()
{
_hook.Free();
}
private static void ShowILLine(ILContext il)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Expected O, but got Unknown
//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
ILCursor val = new ILCursor(il);
try
{
val.GotoNext(new Func<Instruction, bool>[1]
{
(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt(x, (MethodBase)typeof(StackFrame).GetMethod("GetFileLineNumber", (BindingFlags)(-1)))
});
val.RemoveRange(2);
val.EmitDelegate<Func<StackFrame, string>>((Func<StackFrame, string>)GetLineOrIL);
}
catch (Exception arg)
{
Log.Error(string.Format("{0} hook 1 failed.{1}{2}", "ShowILLine", Environment.NewLine, arg));
}
try
{
val.Index = 0;
int frameLocIndex = -1;
val.GotoNext((MoveType)2, new Func<Instruction, bool>[2]
{
(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, ref frameLocIndex),
(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt(x, (MethodBase)typeof(StackFrame).GetMethod("GetInternalMethodName", (BindingFlags)(-1)))
});
val.Emit(OpCodes.Ldloc, frameLocIndex);
val.EmitDelegate<Func<string, StackFrame, string>>((Func<string, StackFrame, string>)AppendLineOrIL);
}
catch (Exception arg2)
{
Log.Error(string.Format("{0} hook 2 failed.{1}{2}", "ShowILLine", Environment.NewLine, arg2));
}
}
private static string GetLineOrIL(StackFrame instance)
{
int fileLineNumber = instance.GetFileLineNumber();
if (fileLineNumber != -1 && fileLineNumber != 0)
{
return fileLineNumber.ToString();
}
return "IL_" + instance.GetILOffset().ToString("X4");
}
private static string AppendLineOrIL(string currentText, StackFrame instance)
{
return currentText + " (at " + GetLineOrIL(instance) + ")";
}
}
internal class FixConsoleLog
{
private static Hook _hook;
internal static void Init()
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_0047: Expected O, but got Unknown
HookConfig val = default(HookConfig);
val.ManualApply = true;
HookConfig val2 = val;
_hook = new Hook((MethodBase)typeof(UnitySystemConsoleRedirector).GetMethod("Redirect", (BindingFlags)(-1)), typeof(FixConsoleLog).GetMethod("DoNothing", (BindingFlags)(-1)), val2);
}
internal static void Enable()
{
_hook.Apply();
}
internal static void Disable()
{
_hook.Undo();
}
internal static void Destroy()
{
_hook.Free();
}
private static void DoNothing()
{
}
}
internal static class FixConVar
{
[CompilerGenerated]
private static class <>O
{
public static Manipulator <0>__ScanAllAssemblies;
public static Action <1>__LoadAllConVars;
}
private static ILHook _ilHook;
internal static void Init()
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_008d: Unknown result type (might be due to invalid IL or missing references)
//IL_0097: Expected O, but got Unknown
//IL_0080: Unknown result type (might be due to invalid IL or missing references)
//IL_0085: Unknown result type (might be due to invalid IL or missing references)
//IL_008b: Expected O, but got Unknown
try
{
ILHookConfig val = default(ILHookConfig);
val.ManualApply = true;
ILHookConfig val2 = val;
MethodInfo? methodInfo = typeof(Console).GetNestedTypes((BindingFlags)(-1)).FirstOrDefault((Type t) => t.Name.Contains("InitConVarsCoroutine")).GetMethods((BindingFlags)(-1))
.FirstOrDefault((MethodInfo m) => m.Name.Contains("MoveNext"));
object obj = <>O.<0>__ScanAllAssemblies;
if (obj == null)
{
Manipulator val3 = ScanAllAssemblies;
<>O.<0>__ScanAllAssemblies = val3;
obj = (object)val3;
}
_ilHook = new ILHook((MethodBase)methodInfo, (Manipulator)obj, ref val2);
}
catch (Exception data)
{
Log.Error(data);
}
}
internal static void Enable()
{
ILHook ilHook = _ilHook;
if (ilHook != null)
{
ilHook.Apply();
}
}
internal static void Disable()
{
ILHook ilHook = _ilHook;
if (ilHook != null)
{
ilHook.Undo();
}
}
internal static void Destroy()
{
ILHook ilHook = _ilHook;
if (ilHook != null)
{
ilHook.Free();
}
}
private static void ScanAllAssemblies(ILContext il)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
ILCursor val = new ILCursor(il);
val.EmitDelegate<Action>((Action)LoadAllConVars);
val.Emit(OpCodes.Ldc_I4_0);
val.Emit(OpCodes.Ret);
}
private static bool IsMonoFriendlyType(this Type type)
{
if (type.GetFields((BindingFlags)(-1)).Any((FieldInfo fi) => fi.FieldType.Name == "MonoFNPtrFakeClass"))
{
Log.Debug($"Not scanning {type} for ConVars due to it containing delegate pointer field(s)");
return false;
}
return true;
}
private static void LoadAllConVars()
{
//IL_0295: Unknown result type (might be due to invalid IL or missing references)
//IL_029c: Unknown result type (might be due to invalid IL or missing references)
//IL_00da: Unknown result type (might be due to invalid IL or missing references)
//IL_00e1: Expected O, but got Unknown
Console instance = Console.instance;
instance.allConVars = new Dictionary<string, BaseConVar>();
instance.archiveConVars = new List<BaseConVar>();
List<Type> list = new List<Type>();
Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
foreach (Assembly assembly in assemblies)
{
try
{
if (assembly.GetCustomAttribute<OptInAttribute>() != null)
{
list.AddRange(from t in assembly.GetTypes()
where t.IsMonoFriendlyType()
select t);
}
}
catch (Exception data)
{
Log.Debug(data);
}
}
foreach (Type item in list)
{
try
{
FieldInfo[] fields = item.GetFields(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
foreach (FieldInfo fieldInfo in fields)
{
try
{
if (fieldInfo.FieldType.IsSubclassOf(typeof(BaseConVar)))
{
if (fieldInfo.IsStatic)
{
BaseConVar val = (BaseConVar)fieldInfo.GetValue(null);
instance.RegisterConVarInternal(val);
}
else if (item.GetCustomAttribute<CompilerGeneratedAttribute>() == null)
{
Debug.LogError((object)("ConVar defined as " + item.Name + "." + fieldInfo.Name + " could not be registered. ConVars must be static fields."));
}
}
}
catch (Exception data2)
{
Log.Debug(data2);
}
}
MethodInfo[] methods = item.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
foreach (MethodInfo methodInfo in methods)
{
try
{
if (((MemberInfo)methodInfo).GetCustomAttribute<ConVarProviderAttribute>() == null)
{
continue;
}
if (methodInfo.ReturnType != typeof(IEnumerable<BaseConVar>) || methodInfo.GetParameters().Length != 0)
{
Debug.LogError((object)"ConVar provider {type.Name}.{methodInfo.Name} does not match the signature \"static IEnumerable<ConVar.BaseConVar>()\".");
continue;
}
if (!methodInfo.IsStatic)
{
Debug.LogError((object)("ConVar provider " + item.Name + "." + methodInfo.Name + " could not be invoked. Methods marked with the ConVarProvider attribute must be static."));
continue;
}
foreach (BaseConVar item2 in (IEnumerable<BaseConVar>)methodInfo.Invoke(null, Array.Empty<object>()))
{
instance.RegisterConVarInternal(item2);
}
}
catch (Exception data3)
{
Log.Debug(data3);
}
}
}
catch (Exception data4)
{
Log.Debug(data4);
}
}
AudioManager.cvVolumeMaster.fallbackString = ((BaseConVar)AudioManager.cvVolumeMaster).GetString();
foreach (BaseConVar value in instance.allConVars.Values)
{
try
{
if ((value.flags & 0x10) != 0)
{
value.defaultValue = value.GetString();
}
else if (value.defaultValue != null)
{
value.AttemptSetString(value.defaultValue);
}
}
catch (Exception data5)
{
Log.Error(data5);
}
}
}
}
internal class FixDeathAnimLog
{
[CompilerGenerated]
private static class <>O
{
public static Manipulator <0>__FixLackingAnim;
}
private static ILHook _ilHook;
internal static void Init()
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_0044: Unknown result type (might be due to invalid IL or missing references)
//IL_004e: Expected O, but got Unknown
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_0042: Expected O, but got Unknown
ILHookConfig val = default(ILHookConfig);
val.ManualApply = true;
ILHookConfig val2 = val;
MethodInfo? method = typeof(GenericCharacterDeath).GetMethod("PlayDeathAnimation", (BindingFlags)(-1));
object obj = <>O.<0>__FixLackingAnim;
if (obj == null)
{
Manipulator val3 = FixLackingAnim;
<>O.<0>__FixLackingAnim = val3;
obj = (object)val3;
}
_ilHook = new ILHook((MethodBase)method, (Manipulator)obj, ref val2);
}
internal static void Enable()
{
_ilHook.Apply();
}
internal static void Disable()
{
_ilHook.Undo();
}
internal static void Destroy()
{
_ilHook.Free();
}
private static void FixLackingAnim(ILContext il)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_000d: Expected O, but got Unknown
//IL_007c: Unknown result type (might be due to invalid IL or missing references)
//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
ILCursor val = new ILCursor(il);
ILLabel label = val.DefineLabel();
MethodReference val2 = default(MethodReference);
if (val.TryGotoNext((MoveType)2, new Func<Instruction, bool>[3]
{
(Instruction x) => ILPatternMatchingExt.MatchLdloc(x, 0),
(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt(x, ref val2),
(Instruction x) => ILPatternMatchingExt.MatchBrfalse(x, ref label)
}))
{
val.Emit(OpCodes.Ldloc_0);
val.EmitDelegate<Func<Animator, bool>>((Func<Animator, bool>)delegate(Animator anim)
{
for (int i = 0; i < anim.layerCount; i++)
{
if (anim.HasState(i, Animator.StringToHash("Death")))
{
return true;
}
}
return false;
});
val.Emit(OpCodes.Brfalse, (object)label);
}
else
{
Log.Error("FixDeathAnimLog TryGotoNext failed, not applying patch");
}
}
}
internal class FixDedicatedServerMaxPlayerCount
{
private static Hook _hook;
private static Hook _hook2;
internal static void Init()
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_0066: Unknown result type (might be due to invalid IL or missing references)
//IL_0070: Expected O, but got Unknown
//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
//IL_00ce: Expected O, but got Unknown
HookConfig val = default(HookConfig);
val.ManualApply = true;
HookConfig val2 = val;
_hook = new Hook((MethodBase)typeof(NetworkManager).GetMethod("StartHost", (BindingFlags)(-1), null, new Type[2]
{
typeof(ConnectionConfig),
typeof(int)
}, null), (Delegate)new Func<Func<NetworkManager, ConnectionConfig, int, NetworkClient>, NetworkManager, ConnectionConfig, int, NetworkClient>(FixUsageOfMaxPlayerCountVariable), ref val2);
_hook2 = new Hook((MethodBase)typeof(NetworkManager).GetMethod("StartServer", (BindingFlags)(-1), null, new Type[2]
{
typeof(ConnectionConfig),
typeof(int)
}, null), (Delegate)new Func<Func<NetworkManager, ConnectionConfig, int, bool>, NetworkManager, ConnectionConfig, int, bool>(FixUsageOfMaxPlayerCountVariable2), ref val2);
}
internal static void Enable()
{
_hook.Apply();
_hook2.Apply();
}
internal static void Disable()
{
_hook2.Undo();
_hook.Undo();
}
internal static void Destroy()
{
_hook2.Free();
_hook.Free();
}
private static NetworkClient FixUsageOfMaxPlayerCountVariable(Func<NetworkManager, ConnectionConfig, int, NetworkClient> orig, NetworkManager self, ConnectionConfig config, int maxConnections)
{
return orig(self, config, SvMaxPlayersConVar.instance.intValue);
}
private static bool FixUsageOfMaxPlayerCountVariable2(Func<NetworkManager, ConnectionConfig, int, bool> orig, NetworkManager self, ConnectionConfig config, int maxConnections)
{
return orig(self, config, SvMaxPlayersConVar.instance.intValue);
}
}
internal class FixDuplicateItemTiers
{
private static Hook _hook;
internal static void Init()
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_0047: Expected O, but got Unknown
HookConfig val = default(HookConfig);
val.ManualApply = true;
HookConfig val2 = val;
_hook = new Hook((MethodBase)typeof(ItemTierCatalog).GetMethod("Init", (BindingFlags)(-1)), typeof(FixDuplicateItemTiers).GetMethod("ReassignDuplicateTiers", (BindingFlags)(-1)), val2);
}
internal static void Enable()
{
_hook.Apply();
}
internal static void Disable()
{
_hook.Undo();
}
internal static void Destroy()
{
_hook.Free();
}
private static void ReassignDuplicateTiers(Action orig)
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Invalid comparison between Unknown and I4
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
//IL_004c: Unknown result type (might be due to invalid IL or missing references)
try
{
ItemTier val = (ItemTier)1000;
ItemTierDef val2 = Addressables.LoadAssetAsync<ItemTierDef>((object)RoR2_DLC3.FoodTier_asset).WaitForCompletion();
ItemTierDef[] itemTierDefs = ContentManager.itemTierDefs;
foreach (ItemTierDef val3 in itemTierDefs)
{
if ((int)val3._tier >= 10 && val3._tier != val && (Object)(object)val3 != (Object)(object)val2)
{
val3._tier = val;
}
}
}
catch (Exception data)
{
Log.Error(data);
}
orig();
}
}
internal class FixExtraGameModesMenu
{
private static Hook _hook;
internal static void Init()
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_0047: Expected O, but got Unknown
HookConfig val = default(HookConfig);
val.ManualApply = true;
HookConfig val2 = val;
_hook = new Hook((MethodBase)typeof(MainMenuController).GetMethod("Start", (BindingFlags)(-1)), typeof(FixExtraGameModesMenu).GetMethod("FixIt", (BindingFlags)(-1)), val2);
}
internal static void Enable()
{
_hook.Apply();
}
internal static void Disable()
{
_hook.Undo();
}
internal static void Destroy()
{
_hook.Free();
}
private static void FixIt(Action<MainMenuController> orig, MainMenuController self)
{
orig(self);
MPButton val = ((IEnumerable<MPButton>)((Component)self.extraGameModeMenuScreen).GetComponentsInChildren<MPButton>()).FirstOrDefault((Func<MPButton, bool>)((MPButton b) => ((Object)b).name == "GenericMenuButton (Eclipse)"));
if (Object.op_Implicit((Object)(object)val))
{
val.defaultFallbackButton = true;
}
}
}
internal class FixHasEffectiveAuthority
{
[CompilerGenerated]
private static class <>O
{
public static Manipulator <0>__FixHook;
}
private static ILHook _ilHook;
internal static void Init()
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_0059: Unknown result type (might be due to invalid IL or missing references)
//IL_0063: Expected O, but got Unknown
//IL_004c: Unknown result type (might be due to invalid IL or missing references)
//IL_0051: Unknown result type (might be due to invalid IL or missing references)
//IL_0057: Expected O, but got Unknown
ILHookConfig val = default(ILHookConfig);
val.ManualApply = true;
ILHookConfig val2 = val;
MethodInfo? method = typeof(Util).GetMethod("HasEffectiveAuthority", (BindingFlags)(-1), null, new Type[1] { typeof(NetworkIdentity) }, null);
object obj = <>O.<0>__FixHook;
if (obj == null)
{
Manipulator val3 = FixHook;
<>O.<0>__FixHook = val3;
obj = (object)val3;
}
_ilHook = new ILHook((MethodBase)method, (Manipulator)obj, ref val2);
}
internal static void Enable()
{
_ilHook.Apply();
}
internal static void Disable()
{
_ilHook.Undo();
}
internal static void Destroy()
{
_ilHook.Free();
}
private static void FixHook(ILContext il)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Expected O, but got Unknown
//IL_0080: Unknown result type (might be due to invalid IL or missing references)
//IL_008c: Unknown result type (might be due to invalid IL or missing references)
//IL_009e: Unknown result type (might be due to invalid IL or missing references)
//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
//IL_0101: Unknown result type (might be due to invalid IL or missing references)
ILCursor val = new ILCursor(il);
if (val.TryGotoNext((MoveType)2, new Func<Instruction, bool>[3]
{
(Instruction x) => ILPatternMatchingExt.MatchCallOrCallvirt<NetworkIdentity>(x, "get_clientAuthorityOwner"),
(Instruction x) => ILPatternMatchingExt.MatchLdnull(x),
(Instruction x) => ILPatternMatchingExt.MatchCeq(x)
}))
{
val.Emit(OpCodes.Dup);
val.Emit(OpCodes.Brtrue, val.Next);
val.Emit(OpCodes.Pop);
val.Emit(OpCodes.Ldarg_0);
val.Emit<NetworkIdentity>(OpCodes.Callvirt, "get_clientAuthorityOwner");
val.Emit(OpCodes.Isinst, typeof(ULocalConnectionToClient));
val.Emit(OpCodes.Ldnull);
val.Emit(OpCodes.Ceq);
val.Emit(OpCodes.Ldc_I4_0);
val.Emit(OpCodes.Ceq);
}
else
{
Log.Error("FixHasEffectiveAuthority TryGotoNext failed, not applying patch");
}
}
}
internal class FixLRAPIReturns
{
internal static void Init(PluginInfo pluginInfo)
{
try
{
string text = Path.Combine(Application.streamingAssetsPath, "lrapi_returns.json");
if (File.Exists(text))
{
Log.Info("lrapi_returns.json already exists in StreamingAssets, skipping fix.");
}
else
{
File.Copy(Path.Combine(Directory.GetParent(pluginInfo.Location).FullName, "lrapi_returns.json"), text);
}
}
catch (Exception data)
{
Log.Error(data);
}
}
}
internal class FixNonLethalOneHP
{
[CompilerGenerated]
private static class <>O
{
public static Manipulator <0>__FixLethality;
}
private static ILHook _ilHook;
internal static void Init()
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_0044: Unknown result type (might be due to invalid IL or missing references)
//IL_004e: Expected O, but got Unknown
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_0042: Expected O, but got Unknown
ILHookConfig val = default(ILHookConfig);
val.ManualApply = true;
ILHookConfig val2 = val;
MethodInfo? method = typeof(HealthComponent).GetMethod("TakeDamageProcess", (BindingFlags)(-1));
object obj = <>O.<0>__FixLethality;
if (obj == null)
{
Manipulator val3 = FixLethality;
<>O.<0>__FixLethality = val3;
obj = (object)val3;
}
_ilHook = new ILHook((MethodBase)method, (Manipulator)obj, ref val2);
}
internal static void Enable()
{
_ilHook.Apply();
}
internal static void Disable()
{
_ilHook.Undo();
}
internal static void Destroy()
{
_ilHook.Free();
}
private static void FixLethality(ILContext il)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Expected O, but got Unknown
//IL_008d: Unknown result type (might be due to invalid IL or missing references)
ILCursor val = new ILCursor(il);
ILLabel val2 = default(ILLabel);
if (val.TryGotoNext((MoveType)2, new Func<Instruction, bool>[3]
{
(Instruction x) => ILPatternMatchingExt.MatchLdfld(x, typeof(HealthComponent).GetField("health", (BindingFlags)(-1))),
(Instruction x) => ILPatternMatchingExt.MatchLdcR4(x, 1f),
(Instruction x) => ILPatternMatchingExt.MatchBltUn(x, ref val2)
}))
{
int index = val.Index;
val.Index = index - 1;
val.Emit(OpCodes.Ldarg_0);
val.EmitDelegate<Func<float, HealthComponent, float>>((Func<float, HealthComponent, float>)((float targetHealth, HealthComponent self) => (!(self.health > 0f)) ? targetHealth : 0f));
}
else
{
Log.Error("FixNonLethalOneHP TryGotoNext failed, not applying patch");
}
}
}
internal class FixRuleBookViewerStrip
{
private static Hook _hook;
internal static void Init()
{
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
//IL_0042: Unknown result type (might be due to invalid IL or missing references)
//IL_004c: Expected O, but got Unknown
if (_hook == null)
{
_hook = new Hook((MethodBase)typeof(RuleBookViewerStrip).GetMethod("SetData", (BindingFlags)(-1)), typeof(FixRuleBookViewerStrip).GetMethod("FindIndexAndSetWidth", (BindingFlags)(-1)), new HookConfig
{
ManualApply = true
});
}
}
internal static void Enable()
{
Hook hook = _hook;
if (hook != null)
{
hook.Apply();
}
}
internal static void Disable()
{
Hook hook = _hook;
if (hook != null)
{
hook.Undo();
}
}
internal static void Destroy()
{
Hook hook = _hook;
if (hook != null)
{
hook.Free();
}
_hook = null;
}
private static void FindIndexAndSetWidth(Action<RuleBookViewerStrip, List<RuleChoiceDef>, int> orig, RuleBookViewerStrip self, List<RuleChoiceDef> choices, int index)
{
orig(self, choices, index);
int i = 0;
for (int count = choices.Count; i < count; i++)
{
if (index == choices[i].localIndex)
{
self.currentDisplayChoiceIndex = i;
break;
}
}
if (!Object.op_Implicit((Object)(object)((Component)self).GetComponent<LayoutElement>()))
{
((Component)self).gameObject.AddComponent<LayoutElement>().minWidth = 64f;
}
}
}
internal static class FixRunScaling
{
[CompilerGenerated]
private static class <>O
{
public static Manipulator <0>__CalculateDifficultyCoefficientOnRunStart;
public static Action<Run> <1>__CallRecalculateDifficultyCoefficent;
}
private static ILHook _ilHook;
internal static void Init()
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_0044: Unknown result type (might be due to invalid IL or missing references)
//IL_004e: Expected O, but got Unknown
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_0042: Expected O, but got Unknown
ILHookConfig val = default(ILHookConfig);
val.ManualApply = true;
ILHookConfig val2 = val;
MethodInfo? method = typeof(Run).GetMethod("Start", (BindingFlags)(-1));
object obj = <>O.<0>__CalculateDifficultyCoefficientOnRunStart;
if (obj == null)
{
Manipulator val3 = CalculateDifficultyCoefficientOnRunStart;
<>O.<0>__CalculateDifficultyCoefficientOnRunStart = val3;
obj = (object)val3;
}
_ilHook = new ILHook((MethodBase)method, (Manipulator)obj, ref val2);
}
internal static void Enable()
{
_ilHook.Apply();
}
internal static void Disable()
{
_ilHook.Undo();
}
internal static void Destroy()
{
_ilHook.Free();
}
private static void CalculateDifficultyCoefficientOnRunStart(ILContext il)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Expected O, but got Unknown
//IL_006a: Unknown result type (might be due to invalid IL or missing references)
ILCursor val = new ILCursor(il);
if (val.TryGotoNext((MoveType)2, new Func<Instruction, bool>[1]
{
(Instruction i) => ILPatternMatchingExt.MatchStfld<Run>(i, "allowNewParticipants")
}))
{
if (val.TryGotoNext((MoveType)2, new Func<Instruction, bool>[1]
{
(Instruction i) => ILPatternMatchingExt.MatchStfld<Run>(i, "allowNewParticipants")
}))
{
val.Emit(OpCodes.Ldarg_0);
val.EmitDelegate<Action<Run>>((Action<Run>)CallRecalculateDifficultyCoefficent);
}
else
{
Log.Error("CalculateDifficultyCoefficientOnRunStart TryGotoNext 2 failed, not applying patch");
}
}
else
{
Log.Error("CalculateDifficultyCoefficientOnRunStart TryGotoNext 1 failed, not applying patch");
}
static void CallRecalculateDifficultyCoefficent(Run instance)
{
if (NetworkServer.active && Object.op_Implicit((Object)(object)instance))
{
instance.RecalculateDifficultyCoefficent();
}
}
}
}
internal class FixSystemInitializer
{
[StructLayout(LayoutKind.Auto)]
[CompilerGenerated]
private struct <>c__DisplayClass3_0
{
public HashSet<Type> initializedTypes;
}
[CompilerGenerated]
private sealed class <LogBadCycle>d__3 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
private <>c__DisplayClass3_0 <>8__1;
private Stopwatch <multiLoopTimer>5__2;
private int <yields>5__3;
private StringBuilder <logBadCycle>5__4;
private SystemInitializerAttribute <initializerAttribute2>5__5;
private IEnumerator <thisStep>5__6;
private List<IEnumerator> <coroutineStack>5__7;
private long <accumulatedTime>5__8;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <LogBadCycle>d__3(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>8__1 = default(<>c__DisplayClass3_0);
<multiLoopTimer>5__2 = null;
<logBadCycle>5__4 = null;
<initializerAttribute2>5__5 = null;
<thisStep>5__6 = null;
<coroutineStack>5__7 = null;
<>1__state = -2;
}
private bool MoveNext()
{
HashSet<Type> hashSet;
int num;
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
SystemInitializerAttribute.initializerAttributes = new Queue<SystemInitializerAttribute>();
SystemInitializerAttribute.initThread = new Thread((ThreadStart)SystemInitializerAttribute.ExecuteStatic);
SystemInitializerAttribute.initThread.Start();
<>2__current = null;
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
goto IL_0093;
case 2:
<>1__state = -1;
goto IL_0093;
case 3:
<>1__state = -1;
goto IL_0449;
case 4:
{
<>1__state = -1;
goto IL_0449;
}
IL_0093:
if (SystemInitializerAttribute.initThread.IsAlive)
{
<>2__current = null;
<>1__state = 2;
return true;
}
SystemInitializerAttribute.initThread = null;
hashSet = new HashSet<Type>();
foreach (Type preInitializedType in SystemInitializerAttribute.preInitializedTypes)
{
hashSet.Add(preInitializedType);
}
<>8__1.initializedTypes = hashSet;
SystemInitializerAttribute.preInitializedTypes.Clear();
new Stopwatch().Start();
<multiLoopTimer>5__2 = new Stopwatch();
<multiLoopTimer>5__2.Start();
<yields>5__3 = 0;
num = 0;
<logBadCycle>5__4 = new StringBuilder();
goto IL_0487;
IL_0487:
while (true)
{
if (SystemInitializerAttribute.initializerAttributes.Count > 0)
{
<initializerAttribute2>5__5 = SystemInitializerAttribute.initializerAttributes.Dequeue();
if (<LogBadCycle>g__InitializerDependenciesMet|3_0(<initializerAttribute2>5__5, ref <>8__1))
{
break;
}
<logBadCycle>5__4.Append("Re-enqueuing initializer: Type=" + <initializerAttribute2>5__5.associatedType.FullName + ",Method=" + <initializerAttribute2>5__5.methodInfo.Name);
SystemInitializerAttribute.initializerAttributes.Enqueue(<initializerAttribute2>5__5);
num++;
if (num < SystemInitializerAttribute.initializerAttributes.Count + 10)
{
continue;
}
Log.Error("SystemInitializerAttribute infinite loop detected.currentMethod=" + <initializerAttribute2>5__5.associatedType.FullName + "." + <initializerAttribute2>5__5.methodInfo.Name + $"\n{<logBadCycle>5__4}");
}
SystemInitializerAttribute.initializerAttributes = null;
SystemInitializerAttribute.hasExecuted = true;
return false;
}
<thisStep>5__6 = <initializerAttribute2>5__5.methodInfo.Invoke(null, Array.Empty<object>()) as IEnumerator;
<coroutineStack>5__7 = new List<IEnumerator> { <thisStep>5__6 };
<multiLoopTimer>5__2.Stop();
<accumulatedTime>5__8 = <multiLoopTimer>5__2.ElapsedMilliseconds;
<multiLoopTimer>5__2.Start();
if (<accumulatedTime>5__8 > SystemInitializerAttribute.FRAME_TIME_THRESHOLD_MS)
{
<accumulatedTime>5__8 = 0L;
<multiLoopTimer>5__2.Stop();
<multiLoopTimer>5__2.Reset();
<multiLoopTimer>5__2.Start();
<yields>5__3++;
<>2__current = null;
<>1__state = 3;
return true;
}
goto IL_0449;
IL_0449:
while (<thisStep>5__6 != null)
{
while (<accumulatedTime>5__8 < SystemInitializerAttribute.FRAME_TIME_THRESHOLD_MS && <thisStep>5__6 != null)
{
if (!<thisStep>5__6.MoveNext())
{
<coroutineStack>5__7.RemoveAt(<coroutineStack>5__7.Count - 1);
<thisStep>5__6 = ((<coroutineStack>5__7.Count <= 0) ? null : <coroutineStack>5__7[<coroutineStack>5__7.Count - 1]);
}
else if (<thisStep>5__6.Current != null)
{
<coroutineStack>5__7.Add(<thisStep>5__6.Current as IEnumerator);
<thisStep>5__6 = <coroutineStack>5__7[<coroutineStack>5__7.Count - 1];
}
<multiLoopTimer>5__2.Stop();
<accumulatedTime>5__8 = <multiLoopTimer>5__2.ElapsedMilliseconds;
<multiLoopTimer>5__2.Start();
}
if (<accumulatedTime>5__8 > SystemInitializerAttribute.FRAME_TIME_THRESHOLD_MS)
{
<accumulatedTime>5__8 = 0L;
<multiLoopTimer>5__2.Stop();
<multiLoopTimer>5__2.Reset();
<multiLoopTimer>5__2.Start();
}
if (<thisStep>5__6 != null)
{
<yields>5__3++;
<accumulatedTime>5__8 = 0L;
<multiLoopTimer>5__2.Stop();
<multiLoopTimer>5__2.Reset();
<multiLoopTimer>5__2.Start();
<>2__current = null;
<>1__state = 4;
return true;
}
}
<>8__1.initializedTypes.Add(<initializerAttribute2>5__5.associatedType);
num = 0;
<initializerAttribute2>5__5 = null;
<thisStep>5__6 = null;
<coroutineStack>5__7 = null;
goto IL_0487;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
private static Hook _hook;
private static Hook _hook2;
internal static void Init()
{
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_0034: Expected O, but got Unknown
//IL_005e: Unknown result type (might be due to invalid IL or missing references)
//IL_0068: Expected O, but got Unknown
_hook = new Hook((MethodBase)typeof(SystemInitializerAttribute).GetMethod("ExecuteStatic", (BindingFlags)(-1)), typeof(FixSystemInitializer).GetMethod("EnqueueAllInitializers", (BindingFlags)(-1)));
_hook2 = new Hook((MethodBase)typeof(SystemInitializerAttribute).GetMethod("ExecuteCoroutine", (BindingFlags)(-1)), typeof(FixSystemInitializer).GetMethod("LogBadCycle", (BindingFlags)(-1)));
}
[IteratorStateMachine(typeof(<LogBadCycle>d__3))]
private static IEnumerator LogBadCycle()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <LogBadCycle>d__3(0);
}
private static void EnqueueAllInitializers(Action _)
{
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Expected O, but got Unknown
foreach (SearchableAttribute instance in SearchableAttribute.GetInstances<SystemInitializerAttribute>())
{
MethodInfo methodInfo = (MethodInfo)instance.target;
if (methodInfo.IsStatic)
{
SystemInitializerAttribute val = (SystemInitializerAttribute)instance;
val.methodInfo = methodInfo;
val.associatedType = methodInfo.DeclaringType;
SystemInitializerAttribute.initializerAttributes.Enqueue(val);
}
}
}
[CompilerGenerated]
internal static bool <LogBadCycle>g__InitializerDependenciesMet|3_0(SystemInitializerAttribute initializerAttribute, ref <>c__DisplayClass3_0 P_1)
{
Type[] dependencies = initializerAttribute.dependencies;
foreach (Type item in dependencies)
{
P_1.initializedTypes.Contains(item);
if (!P_1.initializedTypes.Contains(item))
{
return false;
}
}
return true;
}
}
internal static class LogNetworkInvokeException
{
[CompilerGenerated]
private static class <>O
{
public static Manipulator <0>__AddExceptionLogging;
public static Func<string, object, string> <1>__Format;
}
private static IDetour _detour;
internal static void Init()
{
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_003f: Unknown result type (might be due to invalid IL or missing references)
//IL_0040: Unknown result type (might be due to invalid IL or missing references)
//IL_004a: Expected O, but got Unknown
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_002f: Expected O, but got Unknown
MethodInfo? method = typeof(NetworkConnection).GetMethod("InvokeDelegateWithCatch");
object obj = <>O.<0>__AddExceptionLogging;
if (obj == null)
{
Manipulator val = AddExceptionLogging;
<>O.<0>__AddExceptionLogging = val;
obj = (object)val;
}
_detour = (IDetour)new ILHook((MethodBase)method, (Manipulator)obj, new ILHookConfig
{
ManualApply = true
});
}
internal static void Enable()
{
_detour.Apply();
}
internal static void Disable()
{
_detour.Undo();
}
internal static void Destroy()
{
_detour.Free();
}
private static void AddExceptionLogging(ILContext il)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Expected O, but got Unknown
//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
//IL_00b1: Expected O, but got Unknown
//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
//IL_0119: Unknown result type (might be due to invalid IL or missing references)
//IL_0126: Unknown result type (might be due to invalid IL or missing references)
ILCursor val = new ILCursor(il);
ILLabel val3 = default(ILLabel);
string text = default(string);
if (val.TryGotoNext(new Func<Instruction, bool>[3]
{
(Instruction a) => ILPatternMatchingExt.MatchLeaveS(a, ref val3),
(Instruction a) => ILPatternMatchingExt.MatchPop(a),
(Instruction a) => ILPatternMatchingExt.MatchLdstr(a, ref text)
}))
{
val.Index += 1;
VariableDefinition val2 = new VariableDefinition(((MemberReference)val.Body.Method).Module.ImportReference(typeof(Exception)));
val.Body.Variables.Add(val2);
val.Next.Operand = val2;
val.Next.OpCode = OpCodes.Stloc;
val.Index += 2;
Instruction prev = val.Prev;
prev.Operand = prev.Operand?.ToString() + Environment.NewLine + "{0}";
val.Emit(OpCodes.Ldloc, val2);
val.Emit(OpCodes.Call, (MethodBase)new Func<string, object, string>(string.Format).Method);
}
else
{
Log.Error("ILHook LogNetworkInvokeException.AddExceptionLogging failed.");
}
}
}
public class SaferAchievementManager
{
[CompilerGenerated]
private sealed class <>c__DisplayClass12_0
{
public Dictionary<string, AchievementDef> achievementIdentifierToDef;
}
[CompilerGenerated]
private sealed class <>c__DisplayClass12_1
{
public AchievementDef achievementDef;
internal string <SaferCollectAchievementDefs>b__4()
{
return Language.GetStringFormatted("UNLOCK_VIA_ACHIEVEMENT_FORMAT", new object[2]
{
Language.GetString(achievementDef.nameToken),
Language.GetString(achievementDef.descriptionToken)
});
}
internal string <SaferCollectAchievementDefs>b__5()
{
return Language.GetStringFormatted("UNLOCKED_FORMAT", new object[2]
{
Language.GetString(achievementDef.nameToken),
Language.GetString(achievementDef.descriptionToken)
});
}
}
[CompilerGenerated]
private sealed class <>c__DisplayClass12_2
{
public string currentAchievementIdentifier;
public <>c__DisplayClass12_0 CS$<>8__locals1;
internal bool <SaferCollectAchievementDefs>b__6(string v)
{
return CS$<>8__locals1.achievementIdentifierToDef[v].prerequisiteAchievementIdentifier == currentAchievementIdentifier;
}
}
[CompilerGenerated]
private sealed class <SaferCollectAchievementDefs>d__12 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public Dictionary<string, AchievementDef> achievementIdentifierToDef;
private <>c__DisplayClass12_0 <>8__1;
private List<AchievementDef> <achievementDefs>5__2;
private int <typesProcessedThisFrame>5__3;
private List<Assembly>.Enumerator <>7__wrap3;
private IEnumerator<Type> <>7__wrap4;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <SaferCollectAchievementDefs>d__12(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
int num = <>1__state;
if ((uint)(num - -4) <= 1u || num == 1)
{
try
{
if (num == -4 || num == 1)
{
try
{
}
finally
{
<>m__Finally2();
}
}
}
finally
{
<>m__Finally1();
}
}
<>8__1 = null;
<achievementDefs>5__2 = null;
<>7__wrap3 = default(List<Assembly>.Enumerator);
<>7__wrap4 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_02af: Unknown result type (might be due to invalid IL or missing references)
//IL_02b4: Unknown result type (might be due to invalid IL or missing references)
//IL_02c1: Unknown result type (might be due to invalid IL or missing references)
//IL_02ce: Unknown result type (might be due to invalid IL or missing references)
//IL_02db: Unknown result type (might be due to invalid IL or missing references)
//IL_0301: Unknown result type (might be due to invalid IL or missing references)
//IL_0327: Unknown result type (might be due to invalid IL or missing references)
//IL_032f: Unknown result type (might be due to invalid IL or missing references)
//IL_033c: Unknown result type (might be due to invalid IL or missing references)
//IL_034e: Expected O, but got Unknown
//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
//IL_01eb: Expected O, but got Unknown
//IL_0518: Unknown result type (might be due to invalid IL or missing references)
//IL_0527: Unknown result type (might be due to invalid IL or missing references)
//IL_0529: Unknown result type (might be due to invalid IL or missing references)
//IL_054e: Unknown result type (might be due to invalid IL or missing references)
//IL_055d: Unknown result type (might be due to invalid IL or missing references)
//IL_055f: Unknown result type (might be due to invalid IL or missing references)
try
{
int num = <>1__state;
if (num != 0)
{
if (num != 1)
{
return false;
}
<>1__state = -4;
goto IL_0457;
}
<>1__state = -1;
<>8__1 = new <>c__DisplayClass12_0();
<>8__1.achievementIdentifierToDef = achievementIdentifierToDef;
<achievementDefs>5__2 = new List<AchievementDef>();
<>8__1.achievementIdentifierToDef.Clear();
List<Assembly> list = new List<Assembly>();
Assembly assembly = typeof(RoR2BepInExPack).Assembly;
Assembly assembly2 = typeof(BaseAchievement).Assembly;
list.Add(assembly2);
string name = assembly2.GetName().Name;
Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
foreach (Assembly assembly3 in assemblies)
{
if (assembly3.GetName().Name.StartsWith("MMHOOK_") || assembly3 == assembly)
{
continue;
}
AssemblyName[] referencedAssemblies = assembly3.GetReferencedAssemblies();
for (int j = 0; j < referencedAssemblies.Length; j++)
{
if (referencedAssemblies[j].Name == name)
{
list.Add(assembly3);
break;
}
}
}
<typesProcessedThisFrame>5__3 = 0;
<>7__wrap3 = list.GetEnumerator();
<>1__state = -3;
goto IL_0474;
IL_0457:
while (<>7__wrap4.MoveNext())
{
Type current = <>7__wrap4.Current;
RegisterAchievementAttribute val = null;
try
{
val = (RegisterAchievementAttribute)current.GetCustomAttributes(inherit: false).FirstOrDefault((object v) => v is RegisterAchievementAttribute);
if (SaferAchievementManager.OnRegisterAchievementAttributeFound != null)
{
val = SaferAchievementManager.OnRegisterAchievementAttributeFound(current, val);
}
}
catch (Exception ex)
{
Log.Debug("RegisterAchievementAttribute type.GetCustomAttributes(false) failed for : " + current.FullName + Environment.NewLine + ex);
}
if (val == null)
{
continue;
}
if (<>8__1.achievementIdentifierToDef.ContainsKey(val.identifier))
{
Debug.LogErrorFormat("Class {0} attempted to register as achievement {1}, but class {2} has already registered as that achievement.", new object[3]
{
current.FullName,
val.identifier,
AchievementManager.achievementNamesToDefs[val.identifier].type.FullName
});
}
else
{
<>c__DisplayClass12_1 CS$<>8__locals0 = new <>c__DisplayClass12_1();
UnlockableDef unlockableDef = UnlockableCatalog.GetUnlockableDef(val.unlockableRewardIdentifier);
CS$<>8__locals0.achievementDef = new AchievementDef
{
identifier = val.identifier,
unlockableRewardIdentifier = val.unlockableRewardIdentifier,
prerequisiteAchievementIdentifier = val.prerequisiteAchievementIdentifier,
nameToken = "ACHIEVEMENT_" + val.identifier.ToUpper(CultureInfo.InvariantCulture) + "_NAME",
descriptionToken = "ACHIEVEMENT_" + val.identifier.ToUpper(CultureInfo.InvariantCulture) + "_DESCRIPTION",
type = current,
serverTrackerType = val.serverTrackerType,
lunarCoinReward = val.lunarCoinReward
};
if (Object.op_Implicit((Object)(object)unlockableDef) && Object.op_Implicit((Object)(object)unlockableDef.achievementIcon))
{
CS$<>8__locals0.achievementDef.SetAchievedIcon(unlockableDef.achievementIcon);
}
else
{
CS$<>8__locals0.achievementDef.iconPath = "Textures/AchievementIcons/tex" + val.identifier + "Icon";
CS$<>8__locals0.achievementDef.PreloadIcon();
}
AchievementManager.achievementIdentifiers.Add(val.identifier);
<>8__1.achievementIdentifierToDef.Add(val.identifier, CS$<>8__locals0.achievementDef);
<achievementDefs>5__2.Add(CS$<>8__locals0.achievementDef);
if ((Object)(object)unlockableDef != (Object)null)
{
unlockableDef.getHowToUnlockString = () => Language.GetStringFormatted("UNLOCK_VIA_ACHIEVEMENT_FORMAT", new object[2]
{
Language.GetString(CS$<>8__locals0.achievementDef.nameToken),
Language.GetString(CS$<>8__locals0.achievementDef.descriptionToken)
});
unlockableDef.getUnlockedString = () => Language.GetStringFormatted("UNLOCKED_FORMAT", new object[2]
{
Language.GetString(CS$<>8__locals0.achievementDef.nameToken),
Language.GetString(CS$<>8__locals0.achievementDef.descriptionToken)
});
}
}
if (++<typesProcessedThisFrame>5__3 > 100)
{
<typesProcessedThisFrame>5__3 = 0;
<>2__current = null;
<>1__state = 1;
return true;
}
}
<>m__Finally2();
<>7__wrap4 = null;
goto IL_0474;
IL_0474:
if (<>7__wrap3.MoveNext())
{
Type[] types = <>7__wrap3.Current.GetTypes();
<>7__wrap4 = (from _type in types
where _type.IsSubclassOf(typeof(BaseAchievement))
orderby _type.Name
select _type).GetEnumerator();
<>1__state = -4;
goto IL_0457;
}
<>m__Finally1();
<>7__wrap3 = default(List<Assembly>.Enumerator);
SaferAchievementManager.OnCollectAchievementDefs?.Invoke(AchievementManager.achievementIdentifiers, <>8__1.achievementIdentifierToDef, <achievementDefs>5__2);
AchievementManager.achievementDefs = <achievementDefs>5__2.ToArray();
AchievementManager.SortAchievements(AchievementManager.achievementDefs);
AchievementManager.serverAchievementDefs = AchievementManager.achievementDefs.Where((AchievementDef achievementDef) => achievementDef.serverTrackerType != null).ToArray();
for (int k = 0; k < AchievementManager.achievementDefs.Length; k++)
{
AchievementManager.achievementDefs[k].index = new AchievementIndex
{
intValue = k
};
}
for (int l = 0; l < AchievementManager.serverAchievementDefs.Length; l++)
{
AchievementManager.serverAchievementDefs[l].serverIndex = new ServerAchievementIndex
{
intValue = l
};
}
for (int m = 0; m < AchievementManager.achievementIdentifiers.Count; m++)
{
<>c__DisplayClass12_2 CS$<>8__locals1 = new <>c__DisplayClass12_2();
CS$<>8__locals1.CS$<>8__locals1 = <>8__1;
CS$<>8__locals1.currentAchievementIdentifier = AchievementManager.achievementIdentifiers[m];
CS$<>8__locals1.CS$<>8__locals1.achievementIdentifierToDef[CS$<>8__locals1.currentAchievementIdentifier].childAchievementIdentifiers = AchievementManager.achievementIdentifiers.Where((string v) => CS$<>8__locals1.CS$<>8__locals1.achievementIdentifierToDef[v].prerequisiteAchievementIdentifier == CS$<>8__locals1.currentAchievementIdentifier).ToArray();
}
((Action)_achievementManagerOnAchievementsRegisteredFieldInfo.GetValue(null))?.Invoke();
return false;
}
catch
{
//try-fault
((IDisposable)this).Dispose();
throw;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
private void <>m__Finally1()
{
<>1__state = -1;
((IDisposable)<>7__wrap3).Dispose();
}
private void <>m__Finally2()
{
<>1__state = -3;
if (<>7__wrap4 != null)
{
<>7__wrap4.Dispose();
}
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
private static Hook _hook;
private static FieldInfo _achievementManagerOnAchievementsRegisteredFieldInfo;
public static event Func<Type, RegisterAchievementAttribute, RegisterAchievementAttribute> OnRegisterAchievementAttributeFound;
public static event Action<List<string>, Dictionary<string, AchievementDef>, List<AchievementDef>> OnCollectAchievementDefs;
internal static void Init()
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_0047: Expected O, but got Unknown
HookConfig val = default(HookConfig);
val.ManualApply = true;
HookConfig val2 = val;
_hook = new Hook((MethodBase)typeof(AchievementManager).GetMethod("CollectAchievementDefs", (BindingFlags)(-1)), typeof(SaferAchievementManager).GetMethod("SaferCollectAchievementDefs", (BindingFlags)(-1)), val2);
_achievementManagerOnAchievementsRegisteredFieldInfo = typeof(AchievementManager).GetField("onAchievementsRegistered", (BindingFlags)(-1));
}
internal static void Enable()
{
_hook.Apply();
}
internal static void Disable()
{
_hook.Undo();
}
internal static void Destroy()
{
_hook.Free();
}
[IteratorStateMachine(typeof(<SaferCollectAchievementDefs>d__12))]
private static IEnumerator SaferCollectAchievementDefs(Dictionary<string, AchievementDef> achievementIdentifierToDef)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <SaferCollectAchievementDefs>d__12(0)
{
achievementIdentifierToDef = achievementIdentifierToDef
};
}
}
internal class SaferResourceAvailability
{
private delegate void orig_MakeAvailable(ref ResourceAvailability self);
private static Hook _hook;
private static FieldInfo _onAvailableBackingFieldInfo;
internal static void Init()
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_0047: Expected O, but got Unknown
HookConfig val = default(HookConfig);
val.ManualApply = true;
HookConfig val2 = val;
_hook = new Hook((MethodBase)typeof(ResourceAvailability).GetMethod("MakeAvailable", (BindingFlags)(-1)), typeof(SaferResourceAvailability).GetMethod("TryCatchEachLoopIteration", (BindingFlags)(-1)), val2);
_onAvailableBackingFieldInfo = typeof(ResourceAvailability).GetField("onAvailable", BindingFlags.Instance | BindingFlags.NonPublic);
}
internal static void Enable()
{
_hook.Apply();
}
internal static void Disable()
{
_hook.Undo();
}
internal static void Destroy()
{
_hook.Free();
}
private static void TryCatchEachLoopIteration(orig_MakeAvailable orig, ref ResourceAvailability self)
{
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
if (((ResourceAvailability)(ref self)).available)
{
return;
}
((ResourceAvailability)(ref self)).available = true;
Action action = (Action)_onAvailableBackingFieldInfo.GetValue(self);
if (action == null)
{
return;
}
Delegate[] invocationList = action.GetInvocationList();
for (int i = 0; i < invocationList.Length; i++)
{
Action action2 = (Action)invocationList[i];
try
{
action2();
}
catch (Exception data)
{
Log.Error(data);
}
}
_onAvailableBackingFieldInfo.SetValue(self, null);
}
}
internal class SaferSearchableAttribute
{
[CompilerGenerated]
private static class <>O
{
public static Manipulator <0>__SaferScanAssemblyILManipulator;
public static Action<Assembly> <1>__SaferScanAssembly;
}
private static ILHook _ilHook;
internal static void Init()
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_0042: Unknown result type (might be due to invalid IL or missing references)
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_004d: Expected O, but got Unknown
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_0042: Expected O, but got Unknown
ILHookConfig val = default(ILHookConfig);
val.ManualApply = true;
ILHookConfig val2 = val;
MethodInfo? method = typeof(SearchableAttribute).GetMethod("ScanAssembly", (BindingFlags)(-1));
object obj = <>O.<0>__SaferScanAssemblyILManipulator;
if (obj == null)
{
Manipulator val3 = SaferScanAssemblyILManipulator;
<>O.<0>__SaferScanAssemblyILManipulator = val3;
obj = (object)val3;
}
_ilHook = new ILHook((MethodBase)method, (Manipulator)obj, val2);
}
internal static void Enable()
{
_ilHook.Apply();
}
internal static void Disable()
{
_ilHook.Undo();
}
internal static void Destroy()
{
_ilHook.Free();
}
private static void DeterministicInitTimingHook(Action<Console> orig, Console self)
{
try
{
typeof(SearchableAttribute).TypeInitializer.Invoke(null, null);
}
catch (Exception data)
{
Log.Error(data);
}
orig(self);
}
private static void SaferScanAssemblyILManipulator(ILContext il)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
ILCursor val = new ILCursor(il);
val.Emit(OpCodes.Ldarg_0);
val.EmitDelegate<Action<Assembly>>((Action<Assembly>)SaferScanAssembly);
val.Emit(OpCodes.Ret);
}
private static void SaferScanAssembly(Assembly ass)
{
if (SearchableAttribute.assemblyBlacklist.Contains(ass.FullName))
{
return;
}
SearchableAttribute.assemblyBlacklist.Add(ass.FullName);
if (ass.GetCustomAttribute<OptInAttribute>() == null)
{
return;
}
Type[] types = ass.GetTypes();
foreach (Type type in types)
{
SearchableAttribute[] array = Array.Empty<SearchableAttribute>();
try
{
array = (from a in type.GetCustomAttributes(inherit: false)
where a is SearchableAttribute
select a).Cast<SearchableAttribute>().ToArray();
}
catch (Exception ex)
{
Log.Debug("ScanAssembly type.GetCustomAttributes(false) failed for : " + type.FullName + Environment.NewLine + ex);
}
SearchableAttribute[] array2 = array;
foreach (SearchableAttribute val in array2)
{
try
{
SearchableAttribute.RegisterAttribute(val, (object)type);
}
catch (Exception ex2)
{
Log.Debug("SearchableAttribute.RegisterAttribute(attribute, type) failed for : " + type.FullName + Environment.NewLine + ex2);
}
}
MemberInfo[] array3 = Array.Empty<MemberInfo>();
try
{
array3 = type.GetMembers(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
}
catch (Exception ex3)
{
Log.Debug("type.GetMembers failed for : " + type.FullName + Environment.NewLine + ex3);
}
MemberInfo[] array4 = array3;
foreach (MemberInfo memberInfo in array4)
{
SearchableAttribute[] array5 = Array.Empty<SearchableAttribute>();
try
{
array5 = (from a in memberInfo.GetCustomAttributes(inherit: false)
where a is SearchableAttribute
select a).Cast<SearchableAttribute>().ToArray();
}
catch (Exception ex4)
{
Log.Debug("memberInfo.GetCustomAttributes(false) failed for : " + type.FullName + Environment.NewLine + memberInfo.Name + Environment.NewLine + ex4);
}
array2 = array5;
foreach (SearchableAttribute val2 in array2)
{
try
{
SearchableAttribute.RegisterAttribute(val2, (object)memberInfo);
}
catch (Exception ex5)
{
Log.Debug("SearchableAttribute.RegisterAttribute(attribute, memberInfo) failed for : " + type.FullName + Environment.NewLine + memberInfo.Name + Environment.NewLine + ex5);
}
}
}
}
}
}
}
namespace RoR2BepInExPack.UnityEngineHooks
{
internal static class FrankenMonoPrintStackOverflowException
{
[DllImport("kernel32", ExactSpelling = true)]
private unsafe static extern int FlushInstructionCache(nint handle, void* baseAddr, nuint size);
internal unsafe static void Init()
{
Process currentProcess = Process.GetCurrentProcess();
byte* ptr = *(byte**)(void*)(currentProcess.Modules.Cast<ProcessModule>().Single((ProcessModule m) => m.ModuleName == "mono-2.0-bdwgc.dll").BaseAddress + 7697544);
if (*(long*)ptr != 2372415452946843733L)
{
Log.Warning("Unable to apply SOE fix");
return;
}
*ptr = 144;
FlushInstructionCache(currentProcess.Handle, ptr, 128u);
}
[MethodImpl(MethodImplOptions.NoInlining)]
internal static void Recurse()
{
Recurse();
}
}
}
namespace RoR2BepInExPack.ReflectionHooks
{
internal class AutoCatchReflectionTypeLoadException
{
private static Hook _onHook;
private static Hook _onHook2;
internal static void Init()
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_005d: Unknown result type (might be due to invalid IL or missing references)
//IL_0067: Expected O, but got Unknown
//IL_0069: Unknown result type (might be due to invalid IL or missing references)
//IL_0077: Unknown result type (might be due to invalid IL or missing references)
//IL_0078: Unknown result type (might be due to invalid IL or missing references)
//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
//IL_00ce: Expected O, but got Unknown
HookConfig val = default(HookConfig);
val.ManualApply = true;
HookConfig val2 = val;
_onHook = new Hook((MethodBase)typeof(Assembly).GetMethods((BindingFlags)(-1)).First((MethodInfo m) => m.Name == "GetTypes" && m.GetParameters().Length == 0 && (m.MethodImplementationFlags & MethodImplAttributes.InternalCall) == 0), typeof(AutoCatchReflectionTypeLoadException).GetMethod("SaferGetTypes", (BindingFlags)(-1)), ref val2);
val = default(HookConfig);
val.ManualApply = true;
HookConfig val3 = val;
_onHook2 = new Hook((MethodBase)typeof(Assembly).GetMethods((BindingFlags)(-1)).First((MethodInfo m) => m.Name == "GetExportedTypes" && m.GetParameters().Length == 0 && (m.MethodImplementationFlags & MethodImplAttributes.InternalCall) == 0), typeof(AutoCatchReflectionTypeLoadException).GetMethod("SaferGetTypes", (BindingFlags)(-1)), ref val3);
}
internal static void Enable()
{
_onHook.Apply();
_onHook2.Apply();
}
internal static void Disable()
{
_onHook.Undo();
_onHook2.Undo();
}
internal static void Destroy()
{
_onHook.Free();
_onHook2.Fusing System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Data;
using System.Data.SqlTypes;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Dynamic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Linq.Expressions;
using System.Numerics;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters;
using System.Runtime.Versioning;
using System.Security;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using System.Xml;
using System.Xml.Linq;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json.Bson;
using Newtonsoft.Json.Converters;
using Newtonsoft.Json.Linq;
using Newtonsoft.Json.Linq.JsonPath;
using Newtonsoft.Json.Schema;
using Newtonsoft.Json.Serialization;
using Newtonsoft.Json.Utilities;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AllowPartiallyTrustedCallers]
[assembly: AssemblyDelaySign(true)]
[assembly: AssemblyKeyFile("../IdentityPublicKey.snk")]
[assembly: InternalsVisibleTo("Newtonsoft.Json.Schema, PublicKey=0024000004800000940000000602000000240000525341310004000001000100f561df277c6c0b497d629032b410cdcf286e537c054724f7ffa0164345f62b3e642029d7a80cc351918955328c4adc8a048823ef90b0cf38ea7db0d729caf2b633c3babe08b0310198c1081995c19029bc675193744eab9d7345b8a67258ec17d112cebdbbb2a281487dceeafb9d83aa930f32103fbe1d2911425bc5744002c7")]
[assembly: InternalsVisibleTo("Newtonsoft.Json.Tests, PublicKey=0024000004800000940000000602000000240000525341310004000001000100f561df277c6c0b497d629032b410cdcf286e537c054724f7ffa0164345f62b3e642029d7a80cc351918955328c4adc8a048823ef90b0cf38ea7db0d729caf2b633c3babe08b0310198c1081995c19029bc675193744eab9d7345b8a67258ec17d112cebdbbb2a281487dceeafb9d83aa930f32103fbe1d2911425bc5744002c7")]
[assembly: InternalsVisibleTo("Newtonsoft.Json.Dynamic, PublicKey=0024000004800000940000000602000000240000525341310004000001000100cbd8d53b9d7de30f1f1278f636ec462cf9c254991291e66ebb157a885638a517887633b898ccbcf0d5c5ff7be85a6abe9e765d0ac7cd33c68dac67e7e64530e8222101109f154ab14a941c490ac155cd1d4fcba0fabb49016b4ef28593b015cab5937da31172f03f67d09edda404b88a60023f062ae71d0b2e4438b74cc11dc9")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("9ca358aa-317b-4925-8ada-4a29e943a363")]
[assembly: CLSCompliant(true)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("Newtonsoft")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright © James Newton-King 2008")]
[assembly: AssemblyDescription("Json.NET is a popular high-performance JSON framework for .NET")]
[assembly: AssemblyFileVersion("12.0.301")]
[assembly: AssemblyInformationalVersion("12.0.301")]
[assembly: AssemblyProduct("Json.NET")]
[assembly: AssemblyTitle("Json.NET for Unity AOT (IL2CPP)")]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: AssemblyVersion("12.0.0.0")]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class IsReadOnlyAttribute : Attribute
{
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class NullableContextAttribute : Attribute
{
public readonly byte Flag;
public NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
}
namespace System.Diagnostics.CodeAnalysis
{
[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, AllowMultiple = true)]
internal sealed class NotNullAttribute : Attribute
{
}
[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false)]
internal sealed class NotNullWhenAttribute : Attribute
{
public bool ReturnValue { get; }
public NotNullWhenAttribute(bool returnValue)
{
ReturnValue = returnValue;
}
}
[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, Inherited = false)]
internal sealed class MaybeNullAttribute : Attribute
{
}
[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
internal sealed class AllowNullAttribute : Attribute
{
}
[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
internal class DoesNotReturnIfAttribute : Attribute
{
public bool ParameterValue { get; }
public DoesNotReturnIfAttribute(bool parameterValue)
{
ParameterValue = parameterValue;
}
}
}
namespace Newtonsoft.Json
{
public enum ConstructorHandling
{
Default,
AllowNonPublicDefaultConstructor
}
public enum DateFormatHandling
{
IsoDateFormat,
MicrosoftDateFormat
}
public enum DateParseHandling
{
None,
DateTime,
DateTimeOffset
}
public enum DateTimeZoneHandling
{
Local,
Utc,
Unspecified,
RoundtripKind
}
public class DefaultJsonNameTable : JsonNameTable
{
private class Entry
{
internal readonly string Value;
internal readonly int HashCode;
internal Entry Next;
internal Entry(string value, int hashCode, Entry next)
{
Value = value;
HashCode = hashCode;
Next = next;
}
}
private static readonly int HashCodeRandomizer;
private int _count;
private Entry[] _entries;
private int _mask = 31;
static DefaultJsonNameTable()
{
HashCodeRandomizer = Environment.TickCount;
}
public DefaultJsonNameTable()
{
_entries = new Entry[_mask + 1];
}
public override string? Get(char[] key, int start, int length)
{
if (length == 0)
{
return string.Empty;
}
int num = length + HashCodeRandomizer;
num += (num << 7) ^ key[start];
int num2 = start + length;
for (int i = start + 1; i < num2; i++)
{
num += (num << 7) ^ key[i];
}
num -= num >> 17;
num -= num >> 11;
num -= num >> 5;
int num3 = num & _mask;
for (Entry entry = _entries[num3]; entry != null; entry = entry.Next)
{
if (entry.HashCode == num && TextEquals(entry.Value, key, start, length))
{
return entry.Value;
}
}
return null;
}
public string Add(string key)
{
if (key == null)
{
throw new ArgumentNullException("key");
}
int length = key.Length;
if (length == 0)
{
return string.Empty;
}
int num = length + HashCodeRandomizer;
for (int i = 0; i < key.Length; i++)
{
num += (num << 7) ^ key[i];
}
num -= num >> 17;
num -= num >> 11;
num -= num >> 5;
for (Entry entry = _entries[num & _mask]; entry != null; entry = entry.Next)
{
if (entry.HashCode == num && entry.Value.Equals(key, StringComparison.Ordinal))
{
return entry.Value;
}
}
return AddEntry(key, num);
}
private string AddEntry(string str, int hashCode)
{
int num = hashCode & _mask;
Entry entry = new Entry(str, hashCode, _entries[num]);
_entries[num] = entry;
if (_count++ == _mask)
{
Grow();
}
return entry.Value;
}
private void Grow()
{
Entry[] entries = _entries;
int num = _mask * 2 + 1;
Entry[] array = new Entry[num + 1];
for (int i = 0; i < entries.Length; i++)
{
Entry entry = entries[i];
while (entry != null)
{
int num2 = entry.HashCode & num;
Entry next = entry.Next;
entry.Next = array[num2];
array[num2] = entry;
entry = next;
}
}
_entries = array;
_mask = num;
}
private static bool TextEquals(string str1, char[] str2, int str2Start, int str2Length)
{
if (str1.Length != str2Length)
{
return false;
}
for (int i = 0; i < str1.Length; i++)
{
if (str1[i] != str2[str2Start + i])
{
return false;
}
}
return true;
}
}
[Flags]
public enum DefaultValueHandling
{
Include = 0,
Ignore = 1,
Populate = 2,
IgnoreAndPopulate = 3
}
public enum FloatFormatHandling
{
String,
Symbol,
DefaultValue
}
public enum FloatParseHandling
{
Double,
Decimal
}
public enum Formatting
{
None,
Indented
}
public interface IArrayPool<T>
{
T[] Rent(int minimumLength);
void Return(T[]? array);
}
public interface IJsonLineInfo
{
int LineNumber { get; }
int LinePosition { get; }
bool HasLineInfo();
}
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface, AllowMultiple = false)]
public sealed class JsonArrayAttribute : JsonContainerAttribute
{
private bool _allowNullItems;
public bool AllowNullItems
{
get
{
return _allowNullItems;
}
set
{
_allowNullItems = value;
}
}
public JsonArrayAttribute()
{
}
public JsonArrayAttribute(bool allowNullItems)
{
_allowNullItems = allowNullItems;
}
public JsonArrayAttribute(string id)
: base(id)
{
}
}
[AttributeUsage(AttributeTargets.Constructor, AllowMultiple = false)]
public sealed class JsonConstructorAttribute : Attribute
{
}
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface, AllowMultiple = false)]
public abstract class JsonContainerAttribute : Attribute
{
internal bool? _isReference;
internal bool? _itemIsReference;
internal ReferenceLoopHandling? _itemReferenceLoopHandling;
internal TypeNameHandling? _itemTypeNameHandling;
private Type? _namingStrategyType;
private object[]? _namingStrategyParameters;
public string? Id { get; set; }
public string? Title { get; set; }
public string? Description { get; set; }
public Type? ItemConverterType { get; set; }
public object[]? ItemConverterParameters { get; set; }
public Type? NamingStrategyType
{
get
{
return _namingStrategyType;
}
set
{
_namingStrategyType = value;
NamingStrategyInstance = null;
}
}
public object[]? NamingStrategyParameters
{
get
{
return _namingStrategyParameters;
}
set
{
_namingStrategyParameters = value;
NamingStrategyInstance = null;
}
}
internal NamingStrategy? NamingStrategyInstance { get; set; }
public bool IsReference
{
get
{
return _isReference.GetValueOrDefault();
}
set
{
_isReference = value;
}
}
public bool ItemIsReference
{
get
{
return _itemIsReference.GetValueOrDefault();
}
set
{
_itemIsReference = value;
}
}
public ReferenceLoopHandling ItemReferenceLoopHandling
{
get
{
return _itemReferenceLoopHandling.GetValueOrDefault();
}
set
{
_itemReferenceLoopHandling = value;
}
}
public TypeNameHandling ItemTypeNameHandling
{
get
{
return _itemTypeNameHandling.GetValueOrDefault();
}
set
{
_itemTypeNameHandling = value;
}
}
protected JsonContainerAttribute()
{
}
protected JsonContainerAttribute(string id)
{
Id = id;
}
}
public static class JsonConvert
{
public static readonly string True = "true";
public static readonly string False = "false";
public static readonly string Null = "null";
public static readonly string Undefined = "undefined";
public static readonly string PositiveInfinity = "Infinity";
public static readonly string NegativeInfinity = "-Infinity";
public static readonly string NaN = "NaN";
public static Func<JsonSerializerSettings>? DefaultSettings { get; set; }
public static string ToString(DateTime value)
{
return ToString(value, DateFormatHandling.IsoDateFormat, DateTimeZoneHandling.RoundtripKind);
}
public static string ToString(DateTime value, DateFormatHandling format, DateTimeZoneHandling timeZoneHandling)
{
DateTime value2 = DateTimeUtils.EnsureDateTime(value, timeZoneHandling);
using StringWriter stringWriter = StringUtils.CreateStringWriter(64);
stringWriter.Write('"');
DateTimeUtils.WriteDateTimeString(stringWriter, value2, format, null, CultureInfo.InvariantCulture);
stringWriter.Write('"');
return stringWriter.ToString();
}
public static string ToString(DateTimeOffset value)
{
return ToString(value, DateFormatHandling.IsoDateFormat);
}
public static string ToString(DateTimeOffset value, DateFormatHandling format)
{
using StringWriter stringWriter = StringUtils.CreateStringWriter(64);
stringWriter.Write('"');
DateTimeUtils.WriteDateTimeOffsetString(stringWriter, value, format, null, CultureInfo.InvariantCulture);
stringWriter.Write('"');
return stringWriter.ToString();
}
public static string ToString(bool value)
{
if (!value)
{
return False;
}
return True;
}
public static string ToString(char value)
{
return ToString(char.ToString(value));
}
public static string ToString(Enum value)
{
return value.ToString("D");
}
public static string ToString(int value)
{
return value.ToString(null, CultureInfo.InvariantCulture);
}
public static string ToString(short value)
{
return value.ToString(null, CultureInfo.InvariantCulture);
}
[CLSCompliant(false)]
public static string ToString(ushort value)
{
return value.ToString(null, CultureInfo.InvariantCulture);
}
[CLSCompliant(false)]
public static string ToString(uint value)
{
return value.ToString(null, CultureInfo.InvariantCulture);
}
public static string ToString(long value)
{
return value.ToString(null, CultureInfo.InvariantCulture);
}
private static string ToStringInternal(BigInteger value)
{
return value.ToString(null, CultureInfo.InvariantCulture);
}
[CLSCompliant(false)]
public static string ToString(ulong value)
{
return value.ToString(null, CultureInfo.InvariantCulture);
}
public static string ToString(float value)
{
return EnsureDecimalPlace(value, value.ToString("R", CultureInfo.InvariantCulture));
}
internal static string ToString(float value, FloatFormatHandling floatFormatHandling, char quoteChar, bool nullable)
{
return EnsureFloatFormat(value, EnsureDecimalPlace(value, value.ToString("R", CultureInfo.InvariantCulture)), floatFormatHandling, quoteChar, nullable);
}
private static string EnsureFloatFormat(double value, string text, FloatFormatHandling floatFormatHandling, char quoteChar, bool nullable)
{
if (floatFormatHandling == FloatFormatHandling.Symbol || (!double.IsInfinity(value) && !double.IsNaN(value)))
{
return text;
}
if (floatFormatHandling == FloatFormatHandling.DefaultValue)
{
if (nullable)
{
return Null;
}
return "0.0";
}
return quoteChar + text + quoteChar;
}
public static string ToString(double value)
{
return EnsureDecimalPlace(value, value.ToString("R", CultureInfo.InvariantCulture));
}
internal static string ToString(double value, FloatFormatHandling floatFormatHandling, char quoteChar, bool nullable)
{
return EnsureFloatFormat(value, EnsureDecimalPlace(value, value.ToString("R", CultureInfo.InvariantCulture)), floatFormatHandling, quoteChar, nullable);
}
private static string EnsureDecimalPlace(double value, string text)
{
if (double.IsNaN(value) || double.IsInfinity(value) || text.IndexOf('.') != -1 || text.IndexOf('E') != -1 || text.IndexOf('e') != -1)
{
return text;
}
return text + ".0";
}
private static string EnsureDecimalPlace(string text)
{
if (text.IndexOf('.') != -1)
{
return text;
}
return text + ".0";
}
public static string ToString(byte value)
{
return value.ToString(null, CultureInfo.InvariantCulture);
}
[CLSCompliant(false)]
public static string ToString(sbyte value)
{
return value.ToString(null, CultureInfo.InvariantCulture);
}
public static string ToString(decimal value)
{
return EnsureDecimalPlace(value.ToString(null, CultureInfo.InvariantCulture));
}
public static string ToString(Guid value)
{
return ToString(value, '"');
}
internal static string ToString(Guid value, char quoteChar)
{
string text = value.ToString("D", CultureInfo.InvariantCulture);
string text2 = quoteChar.ToString(CultureInfo.InvariantCulture);
return text2 + text + text2;
}
public static string ToString(TimeSpan value)
{
return ToString(value, '"');
}
internal static string ToString(TimeSpan value, char quoteChar)
{
return ToString(value.ToString(), quoteChar);
}
public static string ToString(Uri? value)
{
if (value == null)
{
return Null;
}
return ToString(value, '"');
}
internal static string ToString(Uri value, char quoteChar)
{
return ToString(value.OriginalString, quoteChar);
}
public static string ToString(string? value)
{
return ToString(value, '"');
}
public static string ToString(string? value, char delimiter)
{
return ToString(value, delimiter, StringEscapeHandling.Default);
}
public static string ToString(string? value, char delimiter, StringEscapeHandling stringEscapeHandling)
{
if (delimiter != '"' && delimiter != '\'')
{
throw new ArgumentException("Delimiter must be a single or double quote.", "delimiter");
}
return JavaScriptUtils.ToEscapedJavaScriptString(value, delimiter, appendDelimiters: true, stringEscapeHandling);
}
public static string ToString(object? value)
{
if (value == null)
{
return Null;
}
return ConvertUtils.GetTypeCode(value.GetType()) switch
{
PrimitiveTypeCode.String => ToString((string)value),
PrimitiveTypeCode.Char => ToString((char)value),
PrimitiveTypeCode.Boolean => ToString((bool)value),
PrimitiveTypeCode.SByte => ToString((sbyte)value),
PrimitiveTypeCode.Int16 => ToString((short)value),
PrimitiveTypeCode.UInt16 => ToString((ushort)value),
PrimitiveTypeCode.Int32 => ToString((int)value),
PrimitiveTypeCode.Byte => ToString((byte)value),
PrimitiveTypeCode.UInt32 => ToString((uint)value),
PrimitiveTypeCode.Int64 => ToString((long)value),
PrimitiveTypeCode.UInt64 => ToString((ulong)value),
PrimitiveTypeCode.Single => ToString((float)value),
PrimitiveTypeCode.Double => ToString((double)value),
PrimitiveTypeCode.DateTime => ToString((DateTime)value),
PrimitiveTypeCode.Decimal => ToString((decimal)value),
PrimitiveTypeCode.DBNull => Null,
PrimitiveTypeCode.DateTimeOffset => ToString((DateTimeOffset)value),
PrimitiveTypeCode.Guid => ToString((Guid)value),
PrimitiveTypeCode.Uri => ToString((Uri)value),
PrimitiveTypeCode.TimeSpan => ToString((TimeSpan)value),
PrimitiveTypeCode.BigInteger => ToStringInternal((BigInteger)value),
_ => throw new ArgumentException("Unsupported type: {0}. Use the JsonSerializer class to get the object's JSON representation.".FormatWith(CultureInfo.InvariantCulture, value.GetType())),
};
}
[DebuggerStepThrough]
public static string SerializeObject(object? value)
{
return SerializeObject(value, (Type?)null, (JsonSerializerSettings?)null);
}
[DebuggerStepThrough]
public static string SerializeObject(object? value, Formatting formatting)
{
return SerializeObject(value, formatting, (JsonSerializerSettings?)null);
}
[DebuggerStepThrough]
public static string SerializeObject(object? value, params JsonConverter[] converters)
{
JsonSerializerSettings settings = ((converters != null && converters.Length != 0) ? new JsonSerializerSettings
{
Converters = converters
} : null);
return SerializeObject(value, null, settings);
}
[DebuggerStepThrough]
public static string SerializeObject(object? value, Formatting formatting, params JsonConverter[] converters)
{
JsonSerializerSettings settings = ((converters != null && converters.Length != 0) ? new JsonSerializerSettings
{
Converters = converters
} : null);
return SerializeObject(value, null, formatting, settings);
}
[DebuggerStepThrough]
public static string SerializeObject(object? value, JsonSerializerSettings settings)
{
return SerializeObject(value, null, settings);
}
[DebuggerStepThrough]
public static string SerializeObject(object? value, Type? type, JsonSerializerSettings? settings)
{
JsonSerializer jsonSerializer = JsonSerializer.CreateDefault(settings);
return SerializeObjectInternal(value, type, jsonSerializer);
}
[DebuggerStepThrough]
public static string SerializeObject(object? value, Formatting formatting, JsonSerializerSettings? settings)
{
return SerializeObject(value, null, formatting, settings);
}
[DebuggerStepThrough]
public static string SerializeObject(object? value, Type? type, Formatting formatting, JsonSerializerSettings? settings)
{
JsonSerializer jsonSerializer = JsonSerializer.CreateDefault(settings);
jsonSerializer.Formatting = formatting;
return SerializeObjectInternal(value, type, jsonSerializer);
}
private static string SerializeObjectInternal(object? value, Type? type, JsonSerializer jsonSerializer)
{
StringWriter stringWriter = new StringWriter(new StringBuilder(256), CultureInfo.InvariantCulture);
using (JsonTextWriter jsonTextWriter = new JsonTextWriter(stringWriter))
{
jsonTextWriter.Formatting = jsonSerializer.Formatting;
jsonSerializer.Serialize(jsonTextWriter, value, type);
}
return stringWriter.ToString();
}
[DebuggerStepThrough]
public static object? DeserializeObject(string value)
{
return DeserializeObject(value, (Type?)null, (JsonSerializerSettings?)null);
}
[DebuggerStepThrough]
public static object? DeserializeObject(string value, JsonSerializerSettings settings)
{
return DeserializeObject(value, null, settings);
}
[DebuggerStepThrough]
public static object? DeserializeObject(string value, Type type)
{
return DeserializeObject(value, type, (JsonSerializerSettings?)null);
}
[DebuggerStepThrough]
public static T DeserializeObject<T>(string value)
{
return JsonConvert.DeserializeObject<T>(value, (JsonSerializerSettings?)null);
}
[DebuggerStepThrough]
public static T DeserializeAnonymousType<T>(string value, T anonymousTypeObject)
{
return DeserializeObject<T>(value);
}
[DebuggerStepThrough]
public static T DeserializeAnonymousType<T>(string value, T anonymousTypeObject, JsonSerializerSettings settings)
{
return DeserializeObject<T>(value, settings);
}
[DebuggerStepThrough]
[return: MaybeNull]
public static T DeserializeObject<T>(string value, params JsonConverter[] converters)
{
return (T)DeserializeObject(value, typeof(T), converters);
}
[DebuggerStepThrough]
[return: MaybeNull]
public static T DeserializeObject<T>(string value, JsonSerializerSettings? settings)
{
return (T)DeserializeObject(value, typeof(T), settings);
}
[DebuggerStepThrough]
public static object? DeserializeObject(string value, Type type, params JsonConverter[] converters)
{
JsonSerializerSettings settings = ((converters != null && converters.Length != 0) ? new JsonSerializerSettings
{
Converters = converters
} : null);
return DeserializeObject(value, type, settings);
}
public static object? DeserializeObject(string value, Type? type, JsonSerializerSettings? settings)
{
ValidationUtils.ArgumentNotNull(value, "value");
JsonSerializer jsonSerializer = JsonSerializer.CreateDefault(settings);
if (!jsonSerializer.IsCheckAdditionalContentSet())
{
jsonSerializer.CheckAdditionalContent = true;
}
using JsonTextReader reader = new JsonTextReader(new StringReader(value));
return jsonSerializer.Deserialize(reader, type);
}
[DebuggerStepThrough]
public static void PopulateObject(string value, object target)
{
PopulateObject(value, target, null);
}
public static void PopulateObject(string value, object target, JsonSerializerSettings? settings)
{
JsonSerializer jsonSerializer = JsonSerializer.CreateDefault(settings);
using JsonReader jsonReader = new JsonTextReader(new StringReader(value));
jsonSerializer.Populate(jsonReader, target);
if (settings == null || !settings.CheckAdditionalContent)
{
return;
}
while (jsonReader.Read())
{
if (jsonReader.TokenType != JsonToken.Comment)
{
throw JsonSerializationException.Create(jsonReader, "Additional text found in JSON string after finishing deserializing object.");
}
}
}
public static string SerializeXmlNode(XmlNode? node)
{
return SerializeXmlNode(node, Formatting.None);
}
public static string SerializeXmlNode(XmlNode? node, Formatting formatting)
{
XmlNodeConverter xmlNodeConverter = new XmlNodeConverter();
return SerializeObject(node, formatting, xmlNodeConverter);
}
public static string SerializeXmlNode(XmlNode? node, Formatting formatting, bool omitRootObject)
{
XmlNodeConverter xmlNodeConverter = new XmlNodeConverter
{
OmitRootObject = omitRootObject
};
return SerializeObject(node, formatting, xmlNodeConverter);
}
public static XmlDocument? DeserializeXmlNode(string value)
{
return DeserializeXmlNode(value, null);
}
public static XmlDocument? DeserializeXmlNode(string value, string? deserializeRootElementName)
{
return DeserializeXmlNode(value, deserializeRootElementName, writeArrayAttribute: false);
}
public static XmlDocument? DeserializeXmlNode(string value, string? deserializeRootElementName, bool writeArrayAttribute)
{
return DeserializeXmlNode(value, deserializeRootElementName, writeArrayAttribute, encodeSpecialCharacters: false);
}
public static XmlDocument? DeserializeXmlNode(string value, string? deserializeRootElementName, bool writeArrayAttribute, bool encodeSpecialCharacters)
{
XmlNodeConverter xmlNodeConverter = new XmlNodeConverter();
xmlNodeConverter.DeserializeRootElementName = deserializeRootElementName;
xmlNodeConverter.WriteArrayAttribute = writeArrayAttribute;
xmlNodeConverter.EncodeSpecialCharacters = encodeSpecialCharacters;
return (XmlDocument)DeserializeObject(value, typeof(XmlDocument), xmlNodeConverter);
}
public static string SerializeXNode(XObject? node)
{
return SerializeXNode(node, Formatting.None);
}
public static string SerializeXNode(XObject? node, Formatting formatting)
{
return SerializeXNode(node, formatting, omitRootObject: false);
}
public static string SerializeXNode(XObject? node, Formatting formatting, bool omitRootObject)
{
XmlNodeConverter xmlNodeConverter = new XmlNodeConverter
{
OmitRootObject = omitRootObject
};
return SerializeObject(node, formatting, xmlNodeConverter);
}
public static XDocument? DeserializeXNode(string value)
{
return DeserializeXNode(value, null);
}
public static XDocument? DeserializeXNode(string value, string? deserializeRootElementName)
{
return DeserializeXNode(value, deserializeRootElementName, writeArrayAttribute: false);
}
public static XDocument? DeserializeXNode(string value, string? deserializeRootElementName, bool writeArrayAttribute)
{
return DeserializeXNode(value, deserializeRootElementName, writeArrayAttribute, encodeSpecialCharacters: false);
}
public static XDocument? DeserializeXNode(string value, string? deserializeRootElementName, bool writeArrayAttribute, bool encodeSpecialCharacters)
{
XmlNodeConverter xmlNodeConverter = new XmlNodeConverter();
xmlNodeConverter.DeserializeRootElementName = deserializeRootElementName;
xmlNodeConverter.WriteArrayAttribute = writeArrayAttribute;
xmlNodeConverter.EncodeSpecialCharacters = encodeSpecialCharacters;
return (XDocument)DeserializeObject(value, typeof(XDocument), xmlNodeConverter);
}
}
public abstract class JsonConverter
{
public virtual bool CanRead => true;
public virtual bool CanWrite => true;
public abstract void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer);
public abstract object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer);
public abstract bool CanConvert(Type objectType);
}
public abstract class JsonConverter<T> : JsonConverter
{
public sealed override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
{
if (!((value != null) ? (value is T) : ReflectionUtils.IsNullable(typeof(T))))
{
throw new JsonSerializationException("Converter cannot write specified value to JSON. {0} is required.".FormatWith(CultureInfo.InvariantCulture, typeof(T)));
}
WriteJson(writer, (T)value, serializer);
}
public abstract void WriteJson(JsonWriter writer, [AllowNull] T value, JsonSerializer serializer);
public sealed override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
{
bool flag = existingValue == null;
if (!flag && !(existingValue is T))
{
throw new JsonSerializationException("Converter cannot read JSON with the specified existing value. {0} is required.".FormatWith(CultureInfo.InvariantCulture, typeof(T)));
}
return ReadJson(reader, objectType, flag ? default(T) : ((T)existingValue), !flag, serializer);
}
public abstract T ReadJson(JsonReader reader, Type objectType, [AllowNull] T existingValue, bool hasExistingValue, JsonSerializer serializer);
public sealed override bool CanConvert(Type objectType)
{
return typeof(T).IsAssignableFrom(objectType);
}
}
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Interface | AttributeTargets.Parameter, AllowMultiple = false)]
public sealed class JsonConverterAttribute : Attribute
{
private readonly Type _converterType;
public Type ConverterType => _converterType;
public object[]? ConverterParameters { get; }
public JsonConverterAttribute(Type converterType)
{
if (converterType == null)
{
throw new ArgumentNullException("converterType");
}
_converterType = converterType;
}
public JsonConverterAttribute(Type converterType, params object[] converterParameters)
: this(converterType)
{
ConverterParameters = converterParameters;
}
}
public class JsonConverterCollection : Collection<JsonConverter>
{
}
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface, AllowMultiple = false)]
public sealed class JsonDictionaryAttribute : JsonContainerAttribute
{
public JsonDictionaryAttribute()
{
}
public JsonDictionaryAttribute(string id)
: base(id)
{
}
}
[Serializable]
public class JsonException : Exception
{
public JsonException()
{
}
public JsonException(string message)
: base(message)
{
}
public JsonException(string message, Exception? innerException)
: base(message, innerException)
{
}
public JsonException(SerializationInfo info, StreamingContext context)
: base(info, context)
{
}
internal static JsonException Create(IJsonLineInfo lineInfo, string path, string message)
{
message = JsonPosition.FormatMessage(lineInfo, path, message);
return new JsonException(message);
}
}
[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false)]
public class JsonExtensionDataAttribute : Attribute
{
public bool WriteData { get; set; }
public bool ReadData { get; set; }
public JsonExtensionDataAttribute()
{
WriteData = true;
ReadData = true;
}
}
[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false)]
public sealed class JsonIgnoreAttribute : Attribute
{
}
public abstract class JsonNameTable
{
public abstract string? Get(char[] key, int start, int length);
}
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Interface, AllowMultiple = false)]
public sealed class JsonObjectAttribute : JsonContainerAttribute
{
private MemberSerialization _memberSerialization;
internal MissingMemberHandling? _missingMemberHandling;
internal Required? _itemRequired;
internal NullValueHandling? _itemNullValueHandling;
public MemberSerialization MemberSerialization
{
get
{
return _memberSerialization;
}
set
{
_memberSerialization = value;
}
}
public MissingMemberHandling MissingMemberHandling
{
get
{
return _missingMemberHandling.GetValueOrDefault();
}
set
{
_missingMemberHandling = value;
}
}
public NullValueHandling ItemNullValueHandling
{
get
{
return _itemNullValueHandling.GetValueOrDefault();
}
set
{
_itemNullValueHandling = value;
}
}
public Required ItemRequired
{
get
{
return _itemRequired.GetValueOrDefault();
}
set
{
_itemRequired = value;
}
}
public JsonObjectAttribute()
{
}
public JsonObjectAttribute(MemberSerialization memberSerialization)
{
MemberSerialization = memberSerialization;
}
public JsonObjectAttribute(string id)
: base(id)
{
}
}
internal enum JsonContainerType
{
None,
Object,
Array,
Constructor
}
internal struct JsonPosition
{
private static readonly char[] SpecialCharacters = new char[18]
{
'.', ' ', '\'', '/', '"', '[', ']', '(', ')', '\t',
'\n', '\r', '\f', '\b', '\\', '\u0085', '\u2028', '\u2029'
};
internal JsonContainerType Type;
internal int Position;
internal string? PropertyName;
internal bool HasIndex;
public JsonPosition(JsonContainerType type)
{
Type = type;
HasIndex = TypeHasIndex(type);
Position = -1;
PropertyName = null;
}
internal int CalculateLength()
{
switch (Type)
{
case JsonContainerType.Object:
return PropertyName.Length + 5;
case JsonContainerType.Array:
case JsonContainerType.Constructor:
return MathUtils.IntLength((ulong)Position) + 2;
default:
throw new ArgumentOutOfRangeException("Type");
}
}
internal void WriteTo(StringBuilder sb, ref StringWriter? writer, ref char[]? buffer)
{
switch (Type)
{
case JsonContainerType.Object:
{
string propertyName = PropertyName;
if (propertyName.IndexOfAny(SpecialCharacters) != -1)
{
sb.Append("['");
if (writer == null)
{
writer = new StringWriter(sb);
}
JavaScriptUtils.WriteEscapedJavaScriptString(writer, propertyName, '\'', appendDelimiters: false, JavaScriptUtils.SingleQuoteCharEscapeFlags, StringEscapeHandling.Default, null, ref buffer);
sb.Append("']");
}
else
{
if (sb.Length > 0)
{
sb.Append('.');
}
sb.Append(propertyName);
}
break;
}
case JsonContainerType.Array:
case JsonContainerType.Constructor:
sb.Append('[');
sb.Append(Position);
sb.Append(']');
break;
}
}
internal static bool TypeHasIndex(JsonContainerType type)
{
if (type != JsonContainerType.Array)
{
return type == JsonContainerType.Constructor;
}
return true;
}
internal static string BuildPath(List<JsonPosition> positions, JsonPosition? currentPosition)
{
int num = 0;
if (positions != null)
{
for (int i = 0; i < positions.Count; i++)
{
num += positions[i].CalculateLength();
}
}
if (currentPosition.HasValue)
{
num += currentPosition.GetValueOrDefault().CalculateLength();
}
StringBuilder stringBuilder = new StringBuilder(num);
StringWriter writer = null;
char[] buffer = null;
if (positions != null)
{
foreach (JsonPosition position in positions)
{
position.WriteTo(stringBuilder, ref writer, ref buffer);
}
}
currentPosition?.WriteTo(stringBuilder, ref writer, ref buffer);
return stringBuilder.ToString();
}
internal static string FormatMessage(IJsonLineInfo? lineInfo, string path, string message)
{
if (!message.EndsWith(Environment.NewLine, StringComparison.Ordinal))
{
message = message.Trim();
if (!StringUtils.EndsWith(message, '.'))
{
message += ".";
}
message += " ";
}
message += "Path '{0}'".FormatWith(CultureInfo.InvariantCulture, path);
if (lineInfo != null && lineInfo.HasLineInfo())
{
message += ", line {0}, position {1}".FormatWith(CultureInfo.InvariantCulture, lineInfo.LineNumber, lineInfo.LinePosition);
}
message += ".";
return message;
}
}
[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, AllowMultiple = false)]
public sealed class JsonPropertyAttribute : Attribute
{
internal NullValueHandling? _nullValueHandling;
internal DefaultValueHandling? _defaultValueHandling;
internal ReferenceLoopHandling? _referenceLoopHandling;
internal ObjectCreationHandling? _objectCreationHandling;
internal TypeNameHandling? _typeNameHandling;
internal bool? _isReference;
internal int? _order;
internal Required? _required;
internal bool? _itemIsReference;
internal ReferenceLoopHandling? _itemReferenceLoopHandling;
internal TypeNameHandling? _itemTypeNameHandling;
public Type? ItemConverterType { get; set; }
public object[]? ItemConverterParameters { get; set; }
public Type? NamingStrategyType { get; set; }
public object[]? NamingStrategyParameters { get; set; }
public NullValueHandling NullValueHandling
{
get
{
return _nullValueHandling.GetValueOrDefault();
}
set
{
_nullValueHandling = value;
}
}
public DefaultValueHandling DefaultValueHandling
{
get
{
return _defaultValueHandling.GetValueOrDefault();
}
set
{
_defaultValueHandling = value;
}
}
public ReferenceLoopHandling ReferenceLoopHandling
{
get
{
return _referenceLoopHandling.GetValueOrDefault();
}
set
{
_referenceLoopHandling = value;
}
}
public ObjectCreationHandling ObjectCreationHandling
{
get
{
return _objectCreationHandling.GetValueOrDefault();
}
set
{
_objectCreationHandling = value;
}
}
public TypeNameHandling TypeNameHandling
{
get
{
return _typeNameHandling.GetValueOrDefault();
}
set
{
_typeNameHandling = value;
}
}
public bool IsReference
{
get
{
return _isReference.GetValueOrDefault();
}
set
{
_isReference = value;
}
}
public int Order
{
get
{
return _order.GetValueOrDefault();
}
set
{
_order = value;
}
}
public Required Required
{
get
{
return _required.GetValueOrDefault();
}
set
{
_required = value;
}
}
public string? PropertyName { get; set; }
public ReferenceLoopHandling ItemReferenceLoopHandling
{
get
{
return _itemReferenceLoopHandling.GetValueOrDefault();
}
set
{
_itemReferenceLoopHandling = value;
}
}
public TypeNameHandling ItemTypeNameHandling
{
get
{
return _itemTypeNameHandling.GetValueOrDefault();
}
set
{
_itemTypeNameHandling = value;
}
}
public bool ItemIsReference
{
get
{
return _itemIsReference.GetValueOrDefault();
}
set
{
_itemIsReference = value;
}
}
public JsonPropertyAttribute()
{
}
public JsonPropertyAttribute(string propertyName)
{
PropertyName = propertyName;
}
}
public abstract class JsonReader : IDisposable
{
protected internal enum State
{
Start,
Complete,
Property,
ObjectStart,
Object,
ArrayStart,
Array,
Closed,
PostValue,
ConstructorStart,
Constructor,
Error,
Finished
}
private JsonToken _tokenType;
private object? _value;
internal char _quoteChar;
internal State _currentState;
private JsonPosition _currentPosition;
private CultureInfo? _culture;
private DateTimeZoneHandling _dateTimeZoneHandling;
private int? _maxDepth;
private bool _hasExceededMaxDepth;
internal DateParseHandling _dateParseHandling;
internal FloatParseHandling _floatParseHandling;
private string? _dateFormatString;
private List<JsonPosition>? _stack;
protected State CurrentState => _currentState;
public bool CloseInput { get; set; }
public bool SupportMultipleContent { get; set; }
public virtual char QuoteChar
{
get
{
return _quoteChar;
}
protected internal set
{
_quoteChar = value;
}
}
public DateTimeZoneHandling DateTimeZoneHandling
{
get
{
return _dateTimeZoneHandling;
}
set
{
if (value < DateTimeZoneHandling.Local || value > DateTimeZoneHandling.RoundtripKind)
{
throw new ArgumentOutOfRangeException("value");
}
_dateTimeZoneHandling = value;
}
}
public DateParseHandling DateParseHandling
{
get
{
return _dateParseHandling;
}
set
{
if (value < DateParseHandling.None || value > DateParseHandling.DateTimeOffset)
{
throw new ArgumentOutOfRangeException("value");
}
_dateParseHandling = value;
}
}
public FloatParseHandling FloatParseHandling
{
get
{
return _floatParseHandling;
}
set
{
if (value < FloatParseHandling.Double || value > FloatParseHandling.Decimal)
{
throw new ArgumentOutOfRangeException("value");
}
_floatParseHandling = value;
}
}
public string? DateFormatString
{
get
{
return _dateFormatString;
}
set
{
_dateFormatString = value;
}
}
public int? MaxDepth
{
get
{
return _maxDepth;
}
set
{
if (value <= 0)
{
throw new ArgumentException("Value must be positive.", "value");
}
_maxDepth = value;
}
}
public virtual JsonToken TokenType => _tokenType;
public virtual object? Value => _value;
public virtual Type? ValueType => _value?.GetType();
public virtual int Depth
{
get
{
int num = _stack?.Count ?? 0;
if (JsonTokenUtils.IsStartToken(TokenType) || _currentPosition.Type == JsonContainerType.None)
{
return num;
}
return num + 1;
}
}
public virtual string Path
{
get
{
if (_currentPosition.Type == JsonContainerType.None)
{
return string.Empty;
}
JsonPosition? currentPosition = ((_currentState != State.ArrayStart && _currentState != State.ConstructorStart && _currentState != State.ObjectStart) ? new JsonPosition?(_currentPosition) : null);
return JsonPosition.BuildPath(_stack, currentPosition);
}
}
public CultureInfo Culture
{
get
{
return _culture ?? CultureInfo.InvariantCulture;
}
set
{
_culture = value;
}
}
public virtual Task<bool> ReadAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return cancellationToken.CancelIfRequestedAsync<bool>() ?? Read().ToAsync();
}
public async Task SkipAsync(CancellationToken cancellationToken = default(CancellationToken))
{
if (TokenType == JsonToken.PropertyName)
{
await ReadAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
}
if (JsonTokenUtils.IsStartToken(TokenType))
{
int depth = Depth;
while (await ReadAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false) && depth < Depth)
{
}
}
}
internal async Task ReaderReadAndAssertAsync(CancellationToken cancellationToken)
{
if (!(await ReadAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false)))
{
throw CreateUnexpectedEndException();
}
}
public virtual Task<bool?> ReadAsBooleanAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return cancellationToken.CancelIfRequestedAsync<bool?>() ?? Task.FromResult(ReadAsBoolean());
}
public virtual Task<byte[]?> ReadAsBytesAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return cancellationToken.CancelIfRequestedAsync<byte[]>() ?? Task.FromResult(ReadAsBytes());
}
internal async Task<byte[]?> ReadArrayIntoByteArrayAsync(CancellationToken cancellationToken)
{
List<byte> buffer = new List<byte>();
do
{
if (!(await ReadAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false)))
{
SetToken(JsonToken.None);
}
}
while (!ReadArrayElementIntoByteArrayReportDone(buffer));
byte[] array = buffer.ToArray();
SetToken(JsonToken.Bytes, array, updateIndex: false);
return array;
}
public virtual Task<DateTime?> ReadAsDateTimeAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return cancellationToken.CancelIfRequestedAsync<DateTime?>() ?? Task.FromResult(ReadAsDateTime());
}
public virtual Task<DateTimeOffset?> ReadAsDateTimeOffsetAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return cancellationToken.CancelIfRequestedAsync<DateTimeOffset?>() ?? Task.FromResult(ReadAsDateTimeOffset());
}
public virtual Task<decimal?> ReadAsDecimalAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return cancellationToken.CancelIfRequestedAsync<decimal?>() ?? Task.FromResult(ReadAsDecimal());
}
public virtual Task<double?> ReadAsDoubleAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(ReadAsDouble());
}
public virtual Task<int?> ReadAsInt32Async(CancellationToken cancellationToken = default(CancellationToken))
{
return cancellationToken.CancelIfRequestedAsync<int?>() ?? Task.FromResult(ReadAsInt32());
}
public virtual Task<string?> ReadAsStringAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return cancellationToken.CancelIfRequestedAsync<string>() ?? Task.FromResult(ReadAsString());
}
internal async Task<bool> ReadAndMoveToContentAsync(CancellationToken cancellationToken)
{
bool flag = await ReadAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
if (flag)
{
flag = await MoveToContentAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
}
return flag;
}
internal Task<bool> MoveToContentAsync(CancellationToken cancellationToken)
{
JsonToken tokenType = TokenType;
if (tokenType == JsonToken.None || tokenType == JsonToken.Comment)
{
return MoveToContentFromNonContentAsync(cancellationToken);
}
return AsyncUtils.True;
}
private async Task<bool> MoveToContentFromNonContentAsync(CancellationToken cancellationToken)
{
JsonToken tokenType;
do
{
if (!(await ReadAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false)))
{
return false;
}
tokenType = TokenType;
}
while (tokenType == JsonToken.None || tokenType == JsonToken.Comment);
return true;
}
internal JsonPosition GetPosition(int depth)
{
if (_stack != null && depth < _stack.Count)
{
return _stack[depth];
}
return _currentPosition;
}
protected JsonReader()
{
_currentState = State.Start;
_dateTimeZoneHandling = DateTimeZoneHandling.RoundtripKind;
_dateParseHandling = DateParseHandling.DateTime;
_floatParseHandling = FloatParseHandling.Double;
CloseInput = true;
}
private void Push(JsonContainerType value)
{
UpdateScopeWithFinishedValue();
if (_currentPosition.Type == JsonContainerType.None)
{
_currentPosition = new JsonPosition(value);
return;
}
if (_stack == null)
{
_stack = new List<JsonPosition>();
}
_stack.Add(_currentPosition);
_currentPosition = new JsonPosition(value);
if (!_maxDepth.HasValue || !(Depth + 1 > _maxDepth) || _hasExceededMaxDepth)
{
return;
}
_hasExceededMaxDepth = true;
throw JsonReaderException.Create(this, "The reader's MaxDepth of {0} has been exceeded.".FormatWith(CultureInfo.InvariantCulture, _maxDepth));
}
private JsonContainerType Pop()
{
JsonPosition currentPosition;
if (_stack != null && _stack.Count > 0)
{
currentPosition = _currentPosition;
_currentPosition = _stack[_stack.Count - 1];
_stack.RemoveAt(_stack.Count - 1);
}
else
{
currentPosition = _currentPosition;
_currentPosition = default(JsonPosition);
}
if (_maxDepth.HasValue && Depth <= _maxDepth)
{
_hasExceededMaxDepth = false;
}
return currentPosition.Type;
}
private JsonContainerType Peek()
{
return _currentPosition.Type;
}
public abstract bool Read();
public virtual int? ReadAsInt32()
{
JsonToken contentToken = GetContentToken();
switch (contentToken)
{
case JsonToken.None:
case JsonToken.Null:
case JsonToken.EndArray:
return null;
case JsonToken.Integer:
case JsonToken.Float:
{
object value = Value;
if (value is int)
{
return (int)value;
}
int num;
if (value is BigInteger bigInteger)
{
num = (int)bigInteger;
}
else
{
try
{
num = Convert.ToInt32(value, CultureInfo.InvariantCulture);
}
catch (Exception ex)
{
throw JsonReaderException.Create(this, "Could not convert to integer: {0}.".FormatWith(CultureInfo.InvariantCulture, value), ex);
}
}
SetToken(JsonToken.Integer, num, updateIndex: false);
return num;
}
case JsonToken.String:
{
string s = (string)Value;
return ReadInt32String(s);
}
default:
throw JsonReaderException.Create(this, "Error reading integer. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, contentToken));
}
}
internal int? ReadInt32String(string? s)
{
if (StringUtils.IsNullOrEmpty(s))
{
SetToken(JsonToken.Null, null, updateIndex: false);
return null;
}
if (int.TryParse(s, NumberStyles.Integer, Culture, out var result))
{
SetToken(JsonToken.Integer, result, updateIndex: false);
return result;
}
SetToken(JsonToken.String, s, updateIndex: false);
throw JsonReaderException.Create(this, "Could not convert string to integer: {0}.".FormatWith(CultureInfo.InvariantCulture, s));
}
public virtual string? ReadAsString()
{
JsonToken contentToken = GetContentToken();
switch (contentToken)
{
case JsonToken.None:
case JsonToken.Null:
case JsonToken.EndArray:
return null;
case JsonToken.String:
return (string)Value;
default:
if (JsonTokenUtils.IsPrimitiveToken(contentToken))
{
object value = Value;
if (value != null)
{
string text = ((!(value is IFormattable formattable)) ? ((value is Uri uri) ? uri.OriginalString : value.ToString()) : formattable.ToString(null, Culture));
SetToken(JsonToken.String, text, updateIndex: false);
return text;
}
}
throw JsonReaderException.Create(this, "Error reading string. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, contentToken));
}
}
public virtual byte[]? ReadAsBytes()
{
JsonToken contentToken = GetContentToken();
switch (contentToken)
{
case JsonToken.StartObject:
{
ReadIntoWrappedTypeObject();
byte[] array2 = ReadAsBytes();
ReaderReadAndAssert();
if (TokenType != JsonToken.EndObject)
{
throw JsonReaderException.Create(this, "Error reading bytes. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, TokenType));
}
SetToken(JsonToken.Bytes, array2, updateIndex: false);
return array2;
}
case JsonToken.String:
{
string text = (string)Value;
Guid g;
byte[] array3 = ((text.Length == 0) ? CollectionUtils.ArrayEmpty<byte>() : ((!ConvertUtils.TryConvertGuid(text, out g)) ? Convert.FromBase64String(text) : g.ToByteArray()));
SetToken(JsonToken.Bytes, array3, updateIndex: false);
return array3;
}
case JsonToken.None:
case JsonToken.Null:
case JsonToken.EndArray:
return null;
case JsonToken.Bytes:
if (Value is Guid guid)
{
byte[] array = guid.ToByteArray();
SetToken(JsonToken.Bytes, array, updateIndex: false);
return array;
}
return (byte[])Value;
case JsonToken.StartArray:
return ReadArrayIntoByteArray();
default:
throw JsonReaderException.Create(this, "Error reading bytes. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, contentToken));
}
}
internal byte[] ReadArrayIntoByteArray()
{
List<byte> list = new List<byte>();
do
{
if (!Read())
{
SetToken(JsonToken.None);
}
}
while (!ReadArrayElementIntoByteArrayReportDone(list));
byte[] array = list.ToArray();
SetToken(JsonToken.Bytes, array, updateIndex: false);
return array;
}
private bool ReadArrayElementIntoByteArrayReportDone(List<byte> buffer)
{
switch (TokenType)
{
case JsonToken.None:
throw JsonReaderException.Create(this, "Unexpected end when reading bytes.");
case JsonToken.Integer:
buffer.Add(Convert.ToByte(Value, CultureInfo.InvariantCulture));
return false;
case JsonToken.EndArray:
return true;
case JsonToken.Comment:
return false;
default:
throw JsonReaderException.Create(this, "Unexpected token when reading bytes: {0}.".FormatWith(CultureInfo.InvariantCulture, TokenType));
}
}
public virtual double? ReadAsDouble()
{
JsonToken contentToken = GetContentToken();
switch (contentToken)
{
case JsonToken.None:
case JsonToken.Null:
case JsonToken.EndArray:
return null;
case JsonToken.Integer:
case JsonToken.Float:
{
object value = Value;
if (value is double)
{
return (double)value;
}
double num = ((!(value is BigInteger bigInteger)) ? Convert.ToDouble(value, CultureInfo.InvariantCulture) : ((double)bigInteger));
SetToken(JsonToken.Float, num, updateIndex: false);
return num;
}
case JsonToken.String:
return ReadDoubleString((string)Value);
default:
throw JsonReaderException.Create(this, "Error reading double. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, contentToken));
}
}
internal double? ReadDoubleString(string? s)
{
if (StringUtils.IsNullOrEmpty(s))
{
SetToken(JsonToken.Null, null, updateIndex: false);
return null;
}
if (double.TryParse(s, NumberStyles.Float | NumberStyles.AllowThousands, Culture, out var result))
{
SetToken(JsonToken.Float, result, updateIndex: false);
return result;
}
SetToken(JsonToken.String, s, updateIndex: false);
throw JsonReaderException.Create(this, "Could not convert string to double: {0}.".FormatWith(CultureInfo.InvariantCulture, s));
}
public virtual bool? ReadAsBoolean()
{
JsonToken contentToken = GetContentToken();
switch (contentToken)
{
case JsonToken.None:
case JsonToken.Null:
case JsonToken.EndArray:
return null;
case JsonToken.Integer:
case JsonToken.Float:
{
bool flag = ((!(Value is BigInteger bigInteger)) ? Convert.ToBoolean(Value, CultureInfo.InvariantCulture) : (bigInteger != 0L));
SetToken(JsonToken.Boolean, flag, updateIndex: false);
return flag;
}
case JsonToken.String:
return ReadBooleanString((string)Value);
case JsonToken.Boolean:
return (bool)Value;
default:
throw JsonReaderException.Create(this, "Error reading boolean. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, contentToken));
}
}
internal bool? ReadBooleanString(string? s)
{
if (StringUtils.IsNullOrEmpty(s))
{
SetToken(JsonToken.Null, null, updateIndex: false);
return null;
}
if (bool.TryParse(s, out var result))
{
SetToken(JsonToken.Boolean, result, updateIndex: false);
return result;
}
SetToken(JsonToken.String, s, updateIndex: false);
throw JsonReaderException.Create(this, "Could not convert string to boolean: {0}.".FormatWith(CultureInfo.InvariantCulture, s));
}
public virtual decimal? ReadAsDecimal()
{
JsonToken contentToken = GetContentToken();
switch (contentToken)
{
case JsonToken.None:
case JsonToken.Null:
case JsonToken.EndArray:
return null;
case JsonToken.Integer:
case JsonToken.Float:
{
object value = Value;
if (value is decimal)
{
return (decimal)value;
}
decimal num;
if (value is BigInteger bigInteger)
{
num = (decimal)bigInteger;
}
else
{
try
{
num = Convert.ToDecimal(value, CultureInfo.InvariantCulture);
}
catch (Exception ex)
{
throw JsonReaderException.Create(this, "Could not convert to decimal: {0}.".FormatWith(CultureInfo.InvariantCulture, value), ex);
}
}
SetToken(JsonToken.Float, num, updateIndex: false);
return num;
}
case JsonToken.String:
return ReadDecimalString((string)Value);
default:
throw JsonReaderException.Create(this, "Error reading decimal. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, contentToken));
}
}
internal decimal? ReadDecimalString(string? s)
{
if (StringUtils.IsNullOrEmpty(s))
{
SetToken(JsonToken.Null, null, updateIndex: false);
return null;
}
if (decimal.TryParse(s, NumberStyles.Number, Culture, out var result))
{
SetToken(JsonToken.Float, result, updateIndex: false);
return result;
}
if (ConvertUtils.DecimalTryParse(s.ToCharArray(), 0, s.Length, out result) == ParseResult.Success)
{
SetToken(JsonToken.Float, result, updateIndex: false);
return result;
}
SetToken(JsonToken.String, s, updateIndex: false);
throw JsonReaderException.Create(this, "Could not convert string to decimal: {0}.".FormatWith(CultureInfo.InvariantCulture, s));
}
public virtual DateTime? ReadAsDateTime()
{
switch (GetContentToken())
{
case JsonToken.None:
case JsonToken.Null:
case JsonToken.EndArray:
return null;
case JsonToken.Date:
if (Value is DateTimeOffset dateTimeOffset)
{
SetToken(JsonToken.Date, dateTimeOffset.DateTime, updateIndex: false);
}
return (DateTime)Value;
case JsonToken.String:
return ReadDateTimeString((string)Value);
default:
throw JsonReaderException.Create(this, "Error reading date. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, TokenType));
}
}
internal DateTime? ReadDateTimeString(string? s)
{
if (StringUtils.IsNullOrEmpty(s))
{
SetToken(JsonToken.Null, null, updateIndex: false);
return null;
}
if (DateTimeUtils.TryParseDateTime(s, DateTimeZoneHandling, _dateFormatString, Culture, out var dt))
{
dt = DateTimeUtils.EnsureDateTime(dt, DateTimeZoneHandling);
SetToken(JsonToken.Date, dt, updateIndex: false);
return dt;
}
if (DateTime.TryParse(s, Culture, DateTimeStyles.RoundtripKind, out dt))
{
dt = DateTimeUtils.EnsureDateTime(dt, DateTimeZoneHandling);
SetToken(JsonToken.Date, dt, updateIndex: false);
return dt;
}
throw JsonReaderException.Create(this, "Could not convert string to DateTime: {0}.".FormatWith(CultureInfo.InvariantCulture, s));
}
public virtual DateTimeOffset? ReadAsDateTimeOffset()
{
JsonToken contentToken = GetContentToken();
switch (contentToken)
{
case JsonToken.None:
case JsonToken.Null:
case JsonToken.EndArray:
return null;
case JsonToken.Date:
if (Value is DateTime dateTime)
{
SetToken(JsonToken.Date, new DateTimeOffset(dateTime), updateIndex: false);
}
return (DateTimeOffset)Value;
case JsonToken.String:
{
string s = (string)Value;
return ReadDateTimeOffsetString(s);
}
default:
throw JsonReaderException.Create(this, "Error reading date. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, contentToken));
}
}
internal DateTimeOffset? ReadDateTimeOffsetString(string? s)
{
if (StringUtils.IsNullOrEmpty(s))
{
SetToken(JsonToken.Null, null, updateIndex: false);
return null;
}
if (DateTimeUtils.TryParseDateTimeOffset(s, _dateFormatString, Culture, out var dt))
{
SetToken(JsonToken.Date, dt, updateIndex: false);
return dt;
}
if (DateTimeOffset.TryParse(s, Culture, DateTimeStyles.RoundtripKind, out dt))
{
SetToken(JsonToken.Date, dt, updateIndex: false);
return dt;
}
SetToken(JsonToken.String, s, updateIndex: false);
throw JsonReaderException.Create(this, "Could not convert string to DateTimeOffset: {0}.".FormatWith(CultureInfo.InvariantCulture, s));
}
internal void ReaderReadAndAssert()
{
if (!Read())
{
throw CreateUnexpectedEndException();
}
}
internal JsonReaderException CreateUnexpectedEndException()
{
return JsonReaderException.Create(this, "Unexpected end when reading JSON.");
}
internal void ReadIntoWrappedTypeObject()
{
ReaderReadAndAssert();
if (Value != null && Value.ToString() == "$type")
{
ReaderReadAndAssert();
if (Value != null && Value.ToString().StartsWith("System.Byte[]", StringComparison.Ordinal))
{
ReaderReadAndAssert();
if (Value.ToString() == "$value")
{
return;
}
}
}
throw JsonReaderException.Create(this, "Error reading bytes. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, JsonToken.StartObject));
}
public void Skip()
{
if (TokenType == JsonToken.PropertyName)
{
Read();
}
if (JsonTokenUtils.IsStartToken(TokenType))
{
int depth = Depth;
while (Read() && depth < Depth)
{
}
}
}
protected void SetToken(JsonToken newToken)
{
SetToken(newToken, null, updateIndex: true);
}
protected void SetToken(JsonToken newToken, object? value)
{
SetToken(newToken, value, updateIndex: true);
}
protected void SetToken(JsonToken newToken, object? value, bool updateIndex)
{
_tokenType = newToken;
_value = value;
switch (newToken)
{
case JsonToken.StartObject:
_currentState = State.ObjectStart;
Push(JsonContainerType.Object);
break;
case JsonToken.StartArray:
_currentState = State.ArrayStart;
Push(JsonContainerType.Array);
break;
case JsonToken.StartConstructor:
_currentState = State.ConstructorStart;
Push(JsonContainerType.Constructor);
break;
case JsonToken.EndObject:
ValidateEnd(JsonToken.EndObject);
break;
case JsonToken.EndArray:
ValidateEnd(JsonToken.EndArray);
break;
case JsonToken.EndConstructor:
ValidateEnd(JsonToken.EndConstructor);
break;
case JsonToken.PropertyName:
_currentState = State.Property;
_currentPosition.PropertyName = (string)value;
break;
case JsonToken.Raw:
case JsonToken.Integer:
case JsonToken.Float:
case JsonToken.String:
case JsonToken.Boolean:
case JsonToken.Null:
case JsonToken.Undefined:
case JsonToken.Date:
case JsonToken.Bytes:
SetPostValueState(updateIndex);
break;
case JsonToken.Comment:
break;
}
}
internal void SetPostValueState(bool updateIndex)
{
if (Peek() != 0 || SupportMultipleContent)
{
_currentState = State.PostValue;
}
else
{
SetFinished();
}
if (updateIndex)
{
UpdateScopeWithFinishedValue();
}
}
private void UpdateScopeWithFinishedValue()
{
if (_currentPosition.HasIndex)
{
_currentPosition.Position++;
}
}
private void ValidateEnd(JsonToken endToken)
{
JsonContainerType jsonContainerType = Pop();
if (GetTypeForCloseToken(endToken) != jsonContainerType)
{
throw JsonReaderException.Create(this, "JsonToken {0} is not valid for closing JsonType {1}.".FormatWith(CultureInfo.InvariantCulture, endToken, jsonContainerType));
}
if (Peek() != 0 || SupportMultipleContent)
{
_currentState = State.PostValue;
}
else
{
SetFinished();
}
}
protected void SetStateBasedOnCurrent()
{
JsonContainerType jsonContainerType = Peek();
switch (jsonContainerType)
{
case JsonContainerType.Object:
_currentState = State.Object;
break;
case JsonContainerType.Array:
_currentState = State.Array;
break;
case JsonContainerType.Constructor:
_currentState = State.Constructor;
break;
case JsonContainerType.None:
SetFinished();
break;
default:
throw JsonReaderException.Create(this, "While setting the reader state back to current object an unexpected JsonType was encountered: {0}".FormatWith(CultureInfo.InvariantCulture, jsonContainerType));
}
}
private void SetFinished()
{
_currentState = ((!SupportMultipleContent) ? State.Finished : State.Start);
}
private JsonContainerType GetTypeForCloseToken(JsonToken token)
{
return token switch
{
JsonToken.EndObject => JsonContainerType.Object,
JsonToken.EndArray => JsonContainerType.Array,
JsonToken.EndConstructor => JsonContainerType.Constructor,
_ => throw JsonReaderException.Create(this, "Not a valid close JsonToken: {0}".FormatWith(CultureInfo.InvariantCulture, token)),
};
}
void IDisposable.Dispose()
{
Dispose(disposing: true);
GC.SuppressFinalize(this);
}
protected virtual void Dispose(bool disposing)
{
if (_currentState != State.Closed && disposing)
{
Close();
}
}
public virtual void Close()
{
_currentState = State.Closed;
_tokenType = JsonToken.None;
_value = null;
}
internal void ReadAndAssert()
{
if (!Read())
{
throw JsonSerializationException.Create(this, "Unexpected end when reading JSON.");
}
}
internal void ReadForTypeAndAssert(JsonContract? contract, bool hasConverter)
{
if (!ReadForType(contract, hasConverter))
{
throw JsonSerializationException.Create(this, "Unexpected end when reading JSON.");
}
}
internal bool ReadForType(JsonContract? contract, bool hasConverter)
{
if (hasConverter)
{
return Read();
}
switch (contract?.InternalReadType ?? ReadType.Read)
{
case ReadType.Read:
return ReadAndMoveToContent();
case ReadType.ReadAsInt32:
ReadAsInt32();
break;
case ReadType.ReadAsInt64:
{
bool result = ReadAndMoveToContent();
if (TokenType == JsonToken.Undefined)
{
throw JsonReaderException.Create(this, "An undefined token is not a valid {0}.".FormatWith(CultureInfo.InvariantCulture, contract?.UnderlyingType ?? typeof(long)));
}
return result;
}
case ReadType.ReadAsDecimal:
ReadAsDecimal();
break;
case ReadType.ReadAsDouble:
ReadAsDouble();
break;
case ReadType.ReadAsBytes:
ReadAsBytes();
break;
case ReadType.ReadAsBoolean:
ReadAsBoolean();
break;
case ReadType.ReadAsString:
ReadAsString();
break;
case ReadType.ReadAsDateTime:
ReadAsDateTime();
break;
case ReadType.ReadAsDateTimeOffset:
ReadAsDateTimeOffset();
break;
default:
throw new ArgumentOutOfRangeException();
}
return TokenType != JsonToken.None;
}
internal bool ReadAndMoveToContent()
{
if (Read())
{
return MoveToContent();
}
return false;
}
internal bool MoveToContent()
{
JsonToken tokenType = TokenType;
while (tokenType == JsonToken.None || tokenType == JsonToken.Comment)
{
if (!Read())
{
return false;
}
tokenType = TokenType;
}
return true;
}
private JsonToken GetContentToken()
{
JsonToken tokenType;
do
{
if (!Read())
{
SetToken(JsonToken.None);
return JsonToken.None;
}
tokenType = TokenType;
}
while (tokenType == JsonToken.Comment);
return tokenType;
}
}
[Serializable]
public class JsonReaderException : JsonException
{
public int LineNumber { get; }
public int LinePosition { get; }
public string? Path { get; }
public JsonReaderException()
{
}
public JsonReaderException(string message)
: base(message)
{
}
public JsonReaderException(string message, Exception innerException)
: base(message, innerException)
{
}
public JsonReaderException(SerializationInfo info, StreamingContext context)
: base(info, context)
{
}
public JsonReaderException(string message, string path, int lineNumber, int linePosition, Exception? innerException)
: base(message, innerException)
{
Path = path;
LineNumber = lineNumber;
LinePosition = linePosition;
}
internal static JsonReaderException Create(JsonReader reader, string message)
{
return Create(reader, message, null);
}
internal static JsonReaderException Create(JsonReader reader, string message, Exception? ex)
{
return Create(reader as IJsonLineInfo, reader.Path, message, ex);
}
internal static JsonReaderException Create(IJsonLineInfo? lineInfo, string path, string message, Exception? ex)
{
message = JsonPosition.FormatMessage(lineInfo, path, message);
int lineNumber;
int linePosition;
if (lineInfo != null && lineInfo.HasLineInfo())
{
lineNumber = lineInfo.LineNumber;
linePosition = lineInfo.LinePosition;
}
else
{
lineNumber = 0;
linePosition = 0;
}
return new JsonReaderException(message, path, lineNumber, linePosition, ex);
}
}
[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false)]
public sealed class JsonRequiredAttribute : Attribute
{
}
[Serializable]
public class JsonSerializationException : JsonException
{
public int LineNumber { get; }
public int LinePosition { get; }
public string? Path { get; }
public JsonSerializationException()
{
}
public JsonSerializationException(string message)
: base(message)
{
}
public JsonSerializationException(string message, Exception innerException)
: base(message, innerException)
{
}
public JsonSerializationException(SerializationInfo info, StreamingContext context)
: base(info, context)
{
}
public JsonSerializationException(string message, string path, int lineNumber, int linePosition, Exception? innerException)
: base(message, innerException)
{
Path = path;
LineNumber = lineNumber;
LinePosition = linePosition;
}
internal static JsonSerializationException Create(JsonReader reader, string message)
{
return Create(reader, message, null);
}
internal static JsonSerializationException Create(JsonReader reader, string message, Exception? ex)
{
return Create(reader as IJsonLineInfo, reader.Path, message, ex);
}
internal static JsonSerializationException Create(IJsonLineInfo? lineInfo, string path, string message, Exception? ex)
{
message = JsonPosition.FormatMessage(lineInfo, path, message);
int lineNumber;
int linePosition;
if (lineInfo != null && lineInfo.HasLineInfo())
{
lineNumber = lineInfo.LineNumber;
linePosition = lineInfo.LinePosition;
}
else
{
lineNumber = 0;
linePosition = 0;
}
return new JsonSerializationException(message, path, lineNumber, linePosition, ex);
}
}
public class JsonSerializer
{
internal TypeNameHandling _typeNameHandling;
internal TypeNameAssemblyFormatHandling _typeNameAssemblyFormatHandling;
internal PreserveReferencesHandling _preserveReferencesHandling;
internal ReferenceLoopHandling _referenceLoopHandling;
internal MissingMemberHandling _missingMemberHandling;
internal ObjectCreationHandling _objectCreationHandling;
internal NullValueHandling _nullValueHandling;
internal DefaultValueHandling _defaultValueHandling;
internal ConstructorHandling _constructorHandling;
internal MetadataPropertyHandling _metadataPropertyHandling;
internal JsonConverterCollection? _converters;
internal IContractResolver _contractResolver;
internal ITraceWriter? _traceWriter;
internal IEqualityComparer? _equalityComparer;
internal ISerializationBinder _serializationBinder;
internal StreamingContext _context;
private IReferenceResolver? _referenceResolver;
private Formatting? _formatting;
private DateFormatHandling? _dateFormatHandling;
private DateTimeZoneHandling? _dateTimeZoneHandling;
private DateParseHandling? _dateParseHandling;
private FloatFormatHandling? _floatFormatHandling;
private FloatParseHandling? _floatParseHandling;
private StringEscapeHandling? _stringEscapeHandling;
private CultureInfo _culture;
private int? _maxDepth;
private bool _maxDepthSet;
private bool? _checkAdditionalContent;
private string? _dateFormatString;
private bool _dateFormatStringSet;
public virtual IReferenceResolver? ReferenceResolver
{
get
{
return GetReferenceResolver();
}
set
{
if (value == null)
{
throw new ArgumentNullException("value", "Reference resolver cannot be null.");
}
_referenceResolver = value;
}
}
[Obsolete("Binder is obsolete. Use SerializationBinder instead.")]
public virtual SerializationBinder Binder
{
get
{
if (_serializationBinder is SerializationBinder result)
{
return result;
}
if (_serializationBinder is SerializationBinderAdapter serializationBinderAdapter)
{
return serializationBinderAdapter.SerializationBinder;
}
throw new InvalidOperationException("Cannot get SerializationBinder because an ISerializationBinder was previously set.");
}
set
{
if (value == null)
{
throw new ArgumentNullException("value", "Serialization binder cannot be null.");
}
_serializationBinder = (value as ISerializationBinder) ?? new SerializationBinderAdapter(value);
}
}
public virtual ISerializationBinder SerializationBinder
{
get
{
return _serializationBinder;
}
set
{
if (value == null)
{
throw new ArgumentNullException("value", "Serialization binder cannot be null.");
}
_serializationBinder = value;
}
}
public virtual ITraceWriter? TraceWriter
{
get
{
return _traceWriter;
}
set
{
_traceWriter = value;
}
}
public virtual IEqualityComparer? EqualityComparer
{
get
{
return _equalityComparer;
}
set
{
_equalityComparer = value;
}
}
public virtual TypeNameHandling TypeNameHandling
{
get
{
return _typeNameHandling;
}
set
{
if (value < TypeNameHandling.None || value > TypeNameHandling.Auto)
{
throw new ArgumentOutOfRangeException("value");
}
_typeNameHandling = value;
}
}
[Obsolete("TypeNameAssemblyFormat is obsolete. Use TypeNameAssemblyFormatHandling instead.")]
public virtual FormatterAssemblyStyle TypeNameAssemblyFormat
{
get
{
return (FormatterAssemblyStyle)_typeNameAssemblyFormatHandling;
}
set
{
if (value < FormatterAssemblyStyle.Simple || value > FormatterAssemblyStyle.Full)
{
throw new ArgumentOutOfRangeException("value");
}
_typeNameAssemblyFormatHandling = (TypeNameAssemblyFormatHandling)value;
}
}
public virtual TypeNameAssemblyFormatHandling TypeNameAssemblyFormatHandling
{
get
{
return _typeNameAssemblyFormatHandling;
}
set
{
if (value < TypeNameAssemblyFormatHandling.Simple || value > TypeNameAssemblyFormatHandling.Full)
{
throw new ArgumentOutOfRangeException("value");
}
_typeNameAssemblyFormatHandling = value;
}
}
public virtual PreserveReferencesHandling PreserveReferencesHandling
{
get
{
return _preserveReferencesHandling;
}
set
{
if (value < PreserveReferencesHandling.None || value > PreserveReferencesHandling.All)
{
throw new ArgumentOutOfRangeException("value");
}
_preserveReferencesHandling = value;
}
}
public virtual ReferenceLoopHandling ReferenceLoopHandling
{
get
{
return _referenceLoopHandling;
}
set
{
if (value < ReferenceLoopHandling.Error || value > ReferenceLoopHandling.Serialize)
{
throw new ArgumentOutOfRangeException("value");
}
_referenceLoopHandling = value;
}
}
public virtual MissingMemberHandling MissingMemberHandling
{
get
{
return _missingMemberHandling;
}
set
{
if (value < MissingMemberHandling.Ignore || value > MissingMemberHandling.Error)
{
throw new ArgumentOutOfRangeException("value");
}
_missingMemberHandling = value;
}
}
public virtual NullValueHandling NullValueHandling
{
get
{
return _nullValueHandling;
}
set
{
if (value < NullValueHandling.Include || value > NullValueHandling.Ignore)
{
throw new ArgumentOutOfRangeException("value");
}
_nullValueHandling = value;
}
}
public virtual DefaultValueHandling DefaultValueHandling
{
get
{
return _defaultValueHandling;
}
set
{
if (value < DefaultValueHandling.Include || value > DefaultValueHandling.IgnoreAndPopulate)
{
throw new ArgumentOutOfRangeException("value");
}
_defaultValueHandling = value;
}
}
public virtual ObjectCreationHandling ObjectCreationHandling
{
get
{
return _objectCreationHandling;
}
set
{
if (value < ObjectCreationHandling.Auto || value > ObjectCreationHandling.Replace)
{
throw new ArgumentOutOfRangeException("value");
}
_objectCreationHandling = value;
}
}
public virtual ConstructorHandling ConstructorHandling
{
get
{
return _constructorHandling;
}
set
{
if (value < ConstructorHandling.Default || value > ConstructorHandling.AllowNonPublicDefaultConstructor)
{
throw new ArgumentOutOfRangeException("value");
}
_constructorHandling = value;
}
}
public virtual MetadataPropertyHandling MetadataPropertyHandling
{
get
{
return _metadataPropertyHandling;
}
set
{
if (value < MetadataPropertyHandling.Default || value > MetadataPropertyHandling.Ignore)
{
throw new ArgumentOutOfRangeException("value");
}
_metadataPropertyHandling = value;
}
}
public virtual JsonConverterCollection Converters
{
get
{
if (_converters == null)
{
_converters = new JsonConverterCollection();
}
return _converters;
}
}
public virtual IContractResolver ContractResolver
{
get
{
return _contractResolver;
}
set
{
_contractResolver = value ?? DefaultContractResolver.Instance;
}
}
public virtual StreamingContext Context
{
get
{
return _context;
}
set
{
_context = value;
}
}
public virtual Formatting Formatting
{
get
{
return _formatting.GetValueOrDefault();
}
set
{
_formatting = value;
}
}
public virtual DateFormatHandling DateFormatHandling
{
get
{
return _dateFormatHandling.GetValueOrDefault();
}
set
{
_dateFormatHandling = value;
}
}
public virtual DateTimeZoneHandling DateTimeZoneHandling
{
get
{
return _dateTimeZoneHandling ?? DateTimeZoneHandling.RoundtripKind;
}
set
{
_dateTimeZoneHandling = value;
}
}
public virtual DateParseHandling DateParseHandling
{
get
{
return _dateParseHandling ?? DateParseHandling.DateTime;
}
set
{
_dateParseHandling = value;
}
}
public virtual FloatParseHandling FloatParseHandling
{
get
{
return _floatParseHandling.GetValueOrDefault();
}
set
{
_floatParseHandling = value;
}
}
public virtual FloatFormatHandling FloatFormatHandling
{
get
{
return _floatFormatHandling.GetValueOrDefault();
}
set
{
_floatFormatHandling = value;
}
}
public virtual StringEscapeHandling StringEscapeHandling
{
get
{
return _stringEscapeHandling.GetValueOrDefault();
}
set
{
_stringEscapeHandling = value;
}
}
public virtual string DateFormatString
{
get
{
return _dateFormatString ?? "yyyy'-'MM'-'dd'T'HH':'mm':'ss.FFFFFFFK";
}
set
{
_dateFormatString = value;
_dateFormatStringSet = true;
}
}
public virtual CultureInfo Culture
{
get
{
return _culture ?? JsonSerializerSettings.DefaultCulture;
}
set
{
_culture = value;
}
}
public virtual int? MaxDepth
{
get
{
return _maxDepth;
}
set
{
if (value <= 0)
{
throw new ArgumentException("Value must be positive.", "value");
}
_maxDepth = value;
_maxDepthSet = true;
}
}
public virtual bool CheckAdditionalContent
{
get
{
return _checkAdditionalContent.GetValueOrDefault();
}
set
{
_checkAdditionalContent = value;
}
}
public virtual event EventHandler<Newtonsoft.Json.Serialization.ErrorEventArgs>? Error;
internal bool IsCheckAdditionalContentSet()
{
return _checkAdditionalContent.HasValue;
}
public JsonSerializer()
{
_referenceLoopHandling = ReferenceLoopHandling.Error;
_missingMemberHandling = MissingMemberHandling.Ignore;
_nullValueHandling = NullValueHandling.Include;
_defaultValueHandling = DefaultValueHandling.Include;
_objectCreationHandling = ObjectCreationHandling.Auto;
_preserveReferencesHandling = PreserveReferencesHandling.None;
_constructorHandling = ConstructorHandling.Default;
_typeNameHandling = TypeNameHandling.None;
_metadataPropertyHandling = MetadataPropertyHandling.Default;
_context = JsonSerializerSettings.DefaultContext;
_serializationBinder = DefaultSerializationBinder.Instance;
_culture = JsonSerializerSettings.DefaultCulture;
_contractResolver = DefaultContractResolver.Instance;
}
public static JsonSerializer Create()
{
return new JsonSerializer();
}
public static JsonSerializer Create(JsonSerializerSettings? settings)
{
JsonSerializer jsonSerializer = Create();
if (settings != null)
{
ApplySerializerSettings(jsonSerializer, settings);
}
return jsonSerializer;
}
public static JsonSerializer CreateDefault()
{
return Create(JsonConvert.DefaultSettings?.Invoke());
}
public static JsonSerializer CreateDefault(JsonSerializerSettings? settings)
{
JsonSerializer jsonSerializer = CreateDefault();
if (settings != null)
{
ApplySerializerSettings(jsonSerializer, settings);
}
return jsonSerializer;
}
private static void ApplySerializerSettings(JsonSerializer serializer, JsonSerializerSettings settings)
{
if (!CollectionUtils.IsNullOrEmpty(settings.Converters))
{
for (int i = 0; i < settings.Converters.Count; i++)
{
serializer.Converters.Insert(i, settings.Converters[i]);
}
}
if (settings._typeNameHandling.HasValue)
{
serializer.TypeNameHandling = settings.TypeNameHandling;
}
if (settings._metadataPropertyHandling.HasValue)
{
serializer.MetadataPropertyHandling = settings.MetadataPropertyHandling;
}
if (settings._typeNameAssemblyFormatHandling.HasValue)
{
serializer.TypeNameAssemblyFormatHandling = settings.TypeNameAssemblyFormatHandling;
}
if (settings._preserveReferencesHandling.HasValue)
{
serializer.PreserveReferencesHandling = settings.PreserveReferencesHandling;
}
if (settings._referenceLoopHandling.HasValue)
{
serializer.ReferenceLoopHandling = settings.ReferenceLoopHandling;
}
if (settings._missingMemberHandling.HasValue)
{
serializer.MissingMemberHandling = settings.MissingMemberHandling;
}
if (settings._objectCreationHandling.HasValue)
{
serializer.ObjectCreationHandling = settings.ObjectCreationHandling;
}
if (settings._nullValueHandling.HasValue)
{
serializer.NullValueHandling = settings.NullValueHandling;
}
if (settings._defaultValueHandling.HasValue)
{
serializer.DefaultValueHandling = settings.DefaultValueHandling;
}
if (settings._constructorHandling.HasValue)
{
serializer.ConstructorHandling = settings.ConstructorHandling;
}
if (settings._context.HasValue)
{
serializer.Context = settings.Context;
}
if (settings._checkAdditionalContent.HasValue)
{
serializer._checkAdditionalContent = settings._checkAdditionalContent;
}
if (settings.Error != null)
{
serializer.Error += settings.Error;
}
if (settings.ContractResolver != null)
{
serializer.ContractResolver = settings.ContractResolver;
}
if (settings.ReferenceResolverProvider != null)
{
serializer.ReferenceResolver = settings.ReferenceResolverProvider();
}
if (settings.TraceWriter != null)
{
serializer.TraceWriter = settings.TraceWriter;
}
if (settings.EqualityComparer != null)
{
serializer.EqualityComparer = settings.EqualityComparer;
}
if (settings.SerializationBinder != null)
{
serializer.SerializationBinder = settings.SerializationBinder;
}
if (settings._formatting.HasValue)
{
serializer._formatting = settings._formatting;
}
if (settings._dateFormatHandling.HasValue)
{
serializer._dateFormatHandling = settings._dateFormatHandling;
}
if (settings._dateTimeZoneHandling.HasValue)
{
serializer._dateTimeZoneHandling = settings._dateTimeZoneHandling;
}
if (settings._dateParseHandling.HasValue)
{
serializer._dateParseHandling = settings._dateParseHandling;
}
if (settings._dateFormatStringSet)
{
serializer._dateFormatString = settings._dateFormatString;
serializer._dateFormatStringSet = settings._dateFormatStringSet;
}
if (settings._floatFormatHandling.HasValue)
{
serializer._floatFormatHandling = settings._floatFormatHandling;
}
if (settings._floatParseHandling.HasValue)
{
serializer._floatParseHandling = settings._floatParseHandling;
}
if (settings._stringEscapeHandling.HasValue)
{
serializer._stringEscapeHandling = settings._stringEscapeHandling;
}
if (settings._culture != null)
{
serializer._culture = settings._culture;
}
if (settings._maxDepthSet)
{
serializer._maxDepth = settings._maxDepth;
serializer._maxDepthSet = settings._maxDepthSet;
}
}
[DebuggerStepThrough]
public void Populate(TextReader reader, object target)
{
Populate(new JsonTextReader(reader), target);
}
[DebuggerStepThrough]
public void Populate(JsonReader reader, object target)
{
PopulateInternal(reader, target);
}
internal virtual void PopulateInternal(JsonReader reader, object target)
{
ValidationUtils.ArgumentNotNull(reader, "reader");
ValidationUtils.ArgumentNotNull(target, "target");
SetupReader(reader, out CultureInfo previousCulture, out DateTimeZoneHandling? previousDateTimeZoneHandling, out DateParseHandling? previousDateParseHandling, out FloatParseHandling? previousFloatParseHandling, out int? previousMaxDepth, out string previousDateFormatString);
TraceJsonReader traceJsonReader = ((TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Verbose) ? CreateTraceJsonReader(reader) : null);
new JsonSerializerInternalReader(this).Populate(traceJsonReader ?? reader, target);
if (traceJsonReader != null)
{
TraceWriter.Trace(TraceLevel.Verbose, traceJsonReader.GetDeserializedJsonMessage(), null);
}
ResetReader(reader, previousCulture, previousDateTimeZoneHandling, previousDateParseHandling, previousFloatParseHandling, previousMaxDepth, previousDateFormatString);
}
[DebuggerStepThrough]
public object? Deserialize(JsonReader reader)
{
return Deserialize(reader, null);
}
[DebuggerStepThrough]
public object? Deserialize(TextReader reader, Type objectType)
{
return Deserialize(new JsonTextReader(reader), objectType);
}
[DebuggerStepThrough]
[return: MaybeNull]
public T Deserialize<T>(JsonReader reader)
{
return (T)Deserialize(reader, typeof(T));
}
[DebuggerStepThrough]
public object? Deserialize(JsonReader reader, Type? objectType)
{
return DeserializeInternal(reader, objectType);
}
internal virtual object? DeserializeInternal(JsonReader reader, Type? objectType)
{
ValidationUtils.ArgumentNotNull(reader, "reader");
SetupReader(reader, out CultureInfo previousCulture, out DateTimeZoneHandling? previousDateTimeZoneHandling, out DateParseHandling? previousDateParseHandling, out FloatParseHandling? previousFloatParseHandling, out int? previousMaxDepth, out string previousDateFormatString);
TraceJsonReader traceJsonReader = ((TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Verbose) ? CreateTraceJsonReader(reader) : null);
object? result = new JsonSerializerInternalReader(this).Deserialize(traceJsonReader ?? reader, objectType, CheckAdditionalContent);
if (traceJsonReader != null)
{
TraceWriter.Trace(TraceLevel.Verbose, traceJsonReader.GetDeserializedJsonMessage(), null);
}
ResetReader(reader, previousCulture, previousDateTimeZoneHandling, previousDateParseHandling, previousFloatParseHandling, previousMaxDepth, previousDateFormatString);
return result;
}
private void SetupReader(JsonReader reader, out CultureInfo? previousCulture, out DateTimeZoneHandling? previousDateTimeZoneHandling, out DateParseHandling? previousDateParseHandling, out FloatParseHandling? previousFloatParseHandling, out int? previousMaxDepth, out string? previousDateFormatString)
{
if (_culture != null && !_culture.Equals(reader.Culture))
{
previousCulture = reader.Culture;
reader.Culture = _culture;
}
else
{
previousCulture = null;
}
if (_dateTimeZoneHandling.HasValue && reader.DateTimeZoneHandling != _dateTimeZoneHandling)
{
previousDateTimeZoneHandling = reader.DateTimeZoneHandling;
reader.DateTimeZoneHandling = _dateTimeZoneHandling.GetValueOrDefault();
}
else
{
previousDateTimeZoneHandling = null;
}
if (_dateParseHandling.HasValue && reader.DateParseHandling != _dateParseHandling)
{
previousDateParseHandling = reader.DateParseHandling;
reader.DateParseHandling = _dateParseHandling.GetValueOrDefault();
}
else
{
previousDateParseHandling = null;
}
if (_floatParseHandling.HasValue && reader.FloatParseHandling != _floatParseHandling)
{
previousFloatParseHandling = reader.FloatParseHandling;
reader.FloatParseHandling = _floatParseHandling.GetValueOrDefault();
}
else
{
previousFloatParseHandling = null;
}
if (_maxDepthSet && reader.MaxDepth != _maxDepth)
{
previousMaxDepth = reader.MaxDepth;
reader.MaxDepth = _maxDepth;
}
else
{
previousMaxDepth = null;
}
if (_dateFormatStringSet && reader.DateFormatString != _dateFormatString)
{
previousDateFormatString = reader.DateFormatString;
reader.DateFormatString = _dateFormatString;
}
else
{
previousDateFormatString = null;
}
if (reader is JsonTextReader jsonTextReader && jsonTextReader.PropertyNameTable == null && _contractResolver is DefaultContractResolver defaultContractResolver)
{
jsonTextReader.PropertyNameTable = defaultContractResolver.GetNameTable();
}
}
private void ResetReader(JsonReader reader, CultureInfo? previousCulture, DateTimeZoneHandling? previousDateTimeZoneHandling, DateParseHandling? previousDateParseHandling, FloatParseHandling? previousFloatParseHandling, int? previousMaxDepth, string? previousDateFormatString)
{
if (previousCulture != null)
{
reader.Culture = previousCulture;
}
if (previousDateTimeZoneHandling.HasValue)
{
reader.DateTimeZoneHandling = previousDateTimeZoneHandling.GetValueOrDefault();
}
if (previousDateParseHandling.HasValue)
{
reader.DateParseHandling = previousDateParseHandling.GetValueOrDefault();
}
if (previousFloatParseHandling.HasValue)
{
reader.FloatParseHandling = previousFloatParseHandling.GetValueOrDefault();
}
if (_maxDepthSet)
{
reader.MaxDepth = previousMaxDepth;
}
if (_dateFormatStringSet)
{
reader.DateFormatString = previousDateFormatString;
}
if (reader is JsonTextReader jsonTextReader && jsonTextReader.PropertyNameTable != null && _contractResolver is DefaultContractResolver defaultContractResolver && jsonTextReader.PropertyNameTable == defaultContractResolver.GetNameTable())
{
jsonTextReader.PropertyNameTable = null;
}
}
public void Serialize(TextWriter textWriter, object? value)
{
Serialize(new JsonTextWriter(textWriter), value);
}
public void Serialize(JsonWriter jsonWriter, object? value, Type? objectType)
{
SerializeInternal(jsonWriter, value, objectType);
}
public void Serialize(TextWriter textWriter, object? value, Type objectType)
{
Serialize(new JsonTextWriter(textWriter), value, objectType);
}
public void Serialize(JsonWriter jsonWriter, object? value)
{
SerializeInternal(jsonWriter, value, null);
}
private TraceJsonReader CreateTraceJsonReader(JsonReader reader)
{
TraceJsonReader traceJsonReader = new TraceJsonReader(reader);
if (reader.TokenType != 0)
{
traceJsonReader.WriteCurrentToken();
}
return traceJsonReader;
}
internal virtual void SerializeInternal(JsonWriter jsonWriter, object? value, Type? objectType)
{
ValidationUtils.ArgumentNotNull(jsonWriter, "jsonWriter");
Formatting? formatting = null;
if (_formatting.HasValue && jsonWriter.Formatting != _formatting)
{
formatting = jsonWriter.Formatting;
jsonWriter.Formatting = _formatting.GetValueOrDefault();
}
DateFormatHandling? dateFormatHandling = null;
if (_dateFormatHandling.HasValue && jsonWriter.DateFormatHandling != _dateFormatHandling)
{
dateFormatHandling = jsonWriter.DateFormatHandling;
jsonWriter.DateFormatHandling = _dateFormatHandling.GetValueOrDefault();
}
DateTimeZoneHandling? dateTimeZoneHandling = null;
if (_dateTimeZoneHandling.HasValue && jsonWriter.DateTimeZoneHandling != _dateTimeZoneHandling)
{
dateTimeZoneHandling = jsonWriter.DateTimeZoneHandling;
jsonWriter.DateTimeZoneHandling = _dateTimeZoneHandling.GetValueOrDefault();
}
FloatFormatHandling? floatFormatHandling = null;
if (_floatFormatHandling.HasValue && jsonWriter.FloatFormatHandling != _floatFormatHandling)
{
floatFormatHandling = jsonWriter.FloatFormatHandling;
jsonWriter.FloatFormatHandling = _floatFormatHandling.GetValueOrDefault();
}
StringEscapeHandling? stringEscapeHandling = null;
if (_stringEscapeHandling.HasValue && jsonWriter.StringEscapeHandling != _stringEscapeHandling)
{
stringEscapeHandling = jsonWriter.StringEscapeHandling;
jsonWriter.StringEscapeHandling = _stringEscapeHandling.GetValueOrDefault();
}
CultureInfo cultureInfo = null;
if (_culture != null && !_culture.Equals(jsonWriter.Culture))
{
cultureInfo = jsonWriter.Culture;
jsonWriter.Culture = _culture;
}
string dateFormatString = null;
if (_dateFormatStringSet && jsonWriter.DateFormatString != _dateFormatString)
{
dateFormatString = jsonWriter.DateFormatString;
jsonWriter.DateFormatString = _dateFormatString;
}
TraceJsonWriter traceJsonWriter = ((TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Verbose) ? new TraceJsonWriter(jsonWriter) : null);
new JsonSerializerInternalWriter(this).Serialize(traceJsonWriter ?? jsonWriter, value, objectType);
if (traceJsonWriter != null)
{
TraceWriter.Trace(TraceLevel.Verbose, traceJsonWriter.GetSerializedJsonMessage(), null);
}
if (formatting.HasValue)
{
jsonWriter.Formatting = formatting.GetValueOrDefault();
}
if (dateFormatHandling.HasValue)
{
jsonWriter.DateFormatHandling = dateFormatHandling.GetValueOrDefault();
}
if (dateTimeZoneHandling.HasValue)
{
jsonWriter.DateTimeZoneHandling = dateTimeZoneHandling.GetValueOrDefault();
}
if (floatFormatHandling.HasValue)
{
jsonWriter.FloatFormatHandling = floatFormatHandling.GetValueOrDefault();
}
if (stringEscapeHandling.HasValue)
{
jsonWriter.StringEscapeHandling = stringEscapeHandling.GetValueOrDefault();
}
if (_dateFormatStringSet)
{
jsonWriter.DateFormatString = dateFormatString;
}
if (cultureInfo != null)
{
jsonWriter.Culture = cultureInfo;
}
}
internal IReferenceResolver GetReferenceResolver()
{
if (_referenceResolver == null)
{
_referenceResolver = new DefaultReferenceResolver();
}
return _referenceResolver;
}
internal JsonConverter? GetMatchingConverter(Type type)
{
return GetMatchingConverter(_converters, type);
}
internal static JsonConverter? GetMatchingConverter(IList<JsonConverter>? converters, Type objectType)
{
if (converters != null)
{
for (int i = 0; i < converters.Count; i++)
{
JsonConverter jsonConverter = converters[i];
if (jsonConverter.CanConvert(objectType))
{
return jsonConverter;
}
}
}
return null;
}
internal void OnError(Newtonsoft.Json.Serialization.ErrorEventArgs e)
{
this.Error?.Invoke(this, e);
}
}
public class JsonSerializerSettings
{
internal const ReferenceLoopHandling DefaultReferenceLoopHandling = ReferenceLoopHandling.Error;
internal const MissingMemberHandling DefaultMissingMemberHandling = MissingMemberHandling.Ignore;
internal const NullValueHandling DefaultNullValueHandling = NullValueHandling.Include;
internal const DefaultValueHandling DefaultDefaultValueHandling = DefaultValueHandling.Include;
internal const ObjectCreationHandling DefaultObjectCreationHandling = ObjectCreationHandling.Auto;
internal const PreserveReferencesHandling DefaultPreserveReferencesHandling = PreserveReferencesHandling.None;
internal const ConstructorHandling DefaultConstructorHandling = ConstructorHandling.Default;
internal const TypeNameHandling DefaultTypeNameHandling = TypeNameHandling.None;
internal const MetadataPropertyHandling DefaultMetadataPropertyHandling = MetadataPropertyHandling.Default;
internal static readonly StreamingContext DefaultContext;
internal const Formatting DefaultFormatting = Formatting.None;
internal const DateFormatHandling DefaultDateFormatHandling = DateFormatHandling.IsoDateFormat;
internal const DateTimeZoneHandling DefaultDateTimeZoneHandling = DateTimeZoneHandling.RoundtripKind;
internal const DateParseHandling DefaultDateParseHandling = DateParseHandling.DateTime;
internal const FloatParseHandling DefaultFloatParseHandling = FloatParseHandling.Double;
internal const FloatFormatHandling DefaultFloatFormatHandling = FloatFormatHandling.String;
internal const StringEscapeHandling DefaultStringEscapeHandling = StringEscapeHandling.Default;
internal const TypeNameAssemblyFormatHandling DefaultTypeNameAssemblyFormatHandling = TypeNameAssemblyFormatHandling.Simple;
internal static readonly CultureInfo DefaultCulture;
internal const bool DefaultCheckAdditionalContent = false;
internal const string DefaultDateFormatString = "yyyy'-'MM'-'dd'T'HH':'mm':'ss.FFFFFFFK";
internal Formatting? _formatting;
internal DateFormatHandling? _dateFormatHandling;
internal DateTimeZoneHandling? _dateTimeZoneHandling;
internal DateParseHandling? _dateParseHandling;
internal FloatFormatHandling? _floatFormatHandling;
internal FloatParseHandling? _floatParseHandling;
internal StringEscapeHandling? _stringEscapeHandling;
internal CultureInfo? _culture;
internal bool? _checkAdditionalContent;
internal int? _maxDepth;
internal bool _maxDepthSet;
internal string? _dateFormatString;
internal bool _dateFormatStringSet;
internal TypeNameAssemblyFormatHandling? _typeNameAssemblyFormatHandling;
internal DefaultValueHandling? _defaultValueHandling;
internal PreserveReferencesHandling? _preserveReferencesHandling;
internal NullValueHandling? _nullValueHandling;
internal ObjectCreationHandling? _objectCreationHandling;
internal MissingMemberHandling? _missingMemberHandling;
internal ReferenceLoopHandling? _referenceLoopHandling;
internal StreamingContext? _context;
internal ConstructorHandling? _constructorHandling;
internal TypeNameHandling? _typeNameHandling;
internal MetadataPropertyHandling? _metadataPropertyHandling;
public ReferenceLoopHandling ReferenceLoopHandling
{
get
{
return _referenceLoopHandling.GetValueOrDefault();
}
set
{
_referenceLoopHandling = value;
}
}
public MissingMemberHandling MissingMemberHandling
{
get
{
return _missingMemberHandling.GetValueOrDefault();
}
set
{
_missingMemberHandling = value;
}
}
public ObjectCreationHandling ObjectCreationHandling
{
get
{
return _objectCreationHandling.GetValueOrDefault();
}
set
{
_objectCreationHandling = value;
}
}
public NullValueHandling NullValueHandling
{
get
{
return _nullValueHandling.GetValueOrDefault();
}
set
{
_nullValueHandling = value;
}
}
public DefaultValueHandling DefaultValueHandling
{
get
{
return _defaultValueHandling.GetValueOrDefault();
}
set
{
_defaultValueHandling = value;
}
}
public IList<JsonConverter> Converters { get; set; }
public PreserveReferencesHandling PreserveReferencesHandling
{
get
{
return _preserveReferencesHandling.GetValueOrDefault();
}
set
{
_preserveReferencesHandling = value;
}
}
public TypeNameHandling TypeNameHandling
{
get
{
return _typeNameHandling.GetValueOrDefault();
}
set
{
_typeNameHandling = value;
}
}
public MetadataPropertyHandling MetadataPropertyHandling
{