internal static MetadataImport GetMetadataImport(RuntimeModule module)
{
return(new MetadataImport(ModuleHandle._GetMetadataImport(module.GetNativeHandle()), module));
}
public override string ResolveString(int metadataToken)
{
return(RuntimeModule.ResolveString(this, _impl, metadataToken));
}
public override Type ResolveType(int metadataToken, Type[]?genericTypeArguments, Type[]?genericMethodArguments)
{
return(RuntimeModule.ResolveType(this, _impl, metadataToken, genericTypeArguments, genericMethodArguments));
}
private void Init(string name,
MethodAttributes attributes,
CallingConventions callingConvention,
Type?returnType,
Type[]?signature,
Type?owner,
Module?m,
bool skipVisibility,
bool transparentMethod)
{
DynamicMethod.CheckConsistency(attributes, callingConvention);
// check and store the signature
if (signature != null)
{
m_parameterTypes = new RuntimeType[signature.Length];
for (int i = 0; i < signature.Length; i++)
{
if (signature[i] == null)
{
throw new ArgumentException(SR.Arg_InvalidTypeInSignature);
}
m_parameterTypes[i] = (signature[i].UnderlyingSystemType as RuntimeType) !;
if (m_parameterTypes[i] == null || m_parameterTypes[i] == typeof(void))
{
throw new ArgumentException(SR.Arg_InvalidTypeInSignature);
}
}
}
else
{
m_parameterTypes = Array.Empty <RuntimeType>();
}
// check and store the return value
m_returnType = (returnType == null) ? (RuntimeType)typeof(void) : (returnType.UnderlyingSystemType as RuntimeType) !;
if (m_returnType == null)
{
throw new NotSupportedException(SR.Arg_InvalidTypeInRetType);
}
if (transparentMethod)
{
Debug.Assert(owner == null && m == null, "owner and m cannot be set for transparent methods");
m_module = GetDynamicMethodsModule();
if (skipVisibility)
{
m_restrictedSkipVisibility = true;
}
}
else
{
Debug.Assert(m != null || owner != null, "Constructor should ensure that either m or owner is set");
Debug.Assert(m == null || !m.Equals(s_anonymouslyHostedDynamicMethodsModule), "The user cannot explicitly use this assembly");
Debug.Assert(m == null || owner == null, "m and owner cannot both be set");
if (m != null)
{
m_module = m.ModuleHandle.GetRuntimeModule(); // this returns the underlying module for all RuntimeModule and ModuleBuilder objects.
}
else
{
RuntimeType?rtOwner = null;
if (owner != null)
{
rtOwner = owner.UnderlyingSystemType as RuntimeType;
}
if (rtOwner != null)
{
if (rtOwner.HasElementType || rtOwner.ContainsGenericParameters ||
rtOwner.IsGenericParameter || rtOwner.IsInterface)
{
throw new ArgumentException(SR.Argument_InvalidTypeForDynamicMethod);
}
m_typeOwner = rtOwner;
m_module = rtOwner.GetRuntimeModule();
}
}
m_skipVisibility = skipVisibility;
}
// initialize remaining fields
m_ilGenerator = null;
m_fInitLocals = true;
m_methodHandle = null;
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
m_dynMethod = new RTDynamicMethod(this, name, attributes, callingConvention);
}
internal void GetCallableMethod(RuntimeModule module, DynamicMethod dm)
{
dm.m_methodHandle = ModuleHandle.GetDynamicMethod(dm,
module, m_method.Name, (byte[])m_scope[m_methodSignature], new DynamicResolver(this));
}
private static extern void _RunModuleConstructor(RuntimeModule module);
internal static extern void LoadInMemoryTypeByName(RuntimeModule module, string className);
public DeveloperModule(RuntimeModule module)
{
}
public ServerCountModule(RuntimeModule m)
{
m.JoinedGuild = OnUpdateGuilds;
m.LeftGuild = OnUpdateGuilds;
}
internal void GetCallableMethod(RuntimeModule module, DynamicMethod dm)
{
dm.m_methodHandle = ModuleHandle.GetDynamicMethod(dm, module, base.m_methodBuilder.Name, (byte[])this.m_scope[this.m_methodSigToken], new DynamicResolver(this));
}
internal static extern void CheckAttributeAccess(RuntimeFieldHandle fieldHandle, RuntimeModule decoratedTarget);
static private extern void PrepareForSavingManifestToDisk(RuntimeAssembly assembly, RuntimeModule assemblyModule); // module to contain assembly information if assembly is embedded
internal extern static void LoadInMemoryTypeByName(RuntimeModule module, String className);
private string GetWorkshopContentTooltip(ref bool runtimeCheck)
{
IRuntimeModuleSubscriptionService service = Services.GetService <IRuntimeModuleSubscriptionService>();
string[] source = null;
string[] source2 = null;
string str = string.Empty;
if (service != null)
{
this.GameSaveRuntimeConfigurationState = service.GetRuntimeModuleListState(this.LobbyDescription.RuntimeConfiguration, out source, out source2);
}
RuntimeModuleConfigurationState gameSaveRuntimeConfigurationState = this.GameSaveRuntimeConfigurationState;
if (gameSaveRuntimeConfigurationState != RuntimeModuleConfigurationState.Yellow)
{
if (gameSaveRuntimeConfigurationState == RuntimeModuleConfigurationState.Red)
{
runtimeCheck = true;
str = AgeLocalizer.Instance.LocalizeString("%MPSessionInvalidRuntimeModulesDescription") + "\n \n - ";
}
}
else
{
runtimeCheck = true;
str = AgeLocalizer.Instance.LocalizeString("%MPSessionCanBeFixedRuntimeModulesDescription") + "\n \n - ";
}
IDatabase <RuntimeModule> database = Databases.GetDatabase <RuntimeModule>(true);
List <string> list = new List <string>();
int i = 0;
int num = this.LobbyDescription.RuntimeConfiguration.Length;
while (i < num)
{
if (source.Contains(this.LobbyDescription.RuntimeConfiguration[i]) || source2.Contains(this.LobbyDescription.RuntimeConfiguration[i]))
{
if (this.LobbyDescription.RuntimeConfiguration[i].Contains(global::RuntimeManager.Folders.Workshop.Affix))
{
string newValue = this.LobbyDescription.RuntimeConfiguration[i].Replace(global::RuntimeManager.Folders.Workshop.Affix, string.Empty);
list.Add(AgeLocalizer.Instance.LocalizeString("%MissingModuleTitle").Replace("$ModuleFolder", "Workshop").Replace("$ModuleName", newValue));
}
else if (this.LobbyDescription.RuntimeConfiguration[i].Contains(global::RuntimeManager.Folders.UGC.Affix))
{
string newValue2 = this.LobbyDescription.RuntimeConfiguration[i].Replace(global::RuntimeManager.Folders.UGC.Affix, string.Empty);
list.Add(AgeLocalizer.Instance.LocalizeString("%MissingModuleTitle").Replace("$ModuleFolder", "UGC").Replace("$ModuleName", newValue2));
}
else
{
list.Add(AgeLocalizer.Instance.LocalizeString("%MissingModuleTitle").Replace("$ModuleFolder", "Community").Replace("$ModuleName", this.LobbyDescription.RuntimeConfiguration[i]));
}
}
else
{
RuntimeModule runtimeModule = database.FirstOrDefault((RuntimeModule module) => module.Name == this.LobbyDescription.RuntimeConfiguration[i]);
if (runtimeModule != null)
{
list.Add(AgeLocalizer.Instance.LocalizeString(runtimeModule.Title));
}
}
i++;
}
return(str + string.Join("\n - ", list.ToArray()));
}
internal ModuleHandle(RuntimeModule module)
{
this.m_ptr = module;
}
internal static extern IRuntimeMethodInfo GetDynamicMethod(DynamicMethod method, RuntimeModule module, string name, byte[] sig, Resolver resolver);
public override MemberInfo ResolveMember(int metadataToken, Type [] genericTypeArguments, Type [] genericMethodArguments)
{
return(RuntimeModule.ResolveMember(this, _impl, metadataToken, genericTypeArguments, genericMethodArguments));
}
internal static extern int GetToken(RuntimeModule module);
private static extern void nConvertTypeLibToMetadata(object typeLib, RuntimeAssembly asmBldr, RuntimeModule modBldr, string nameSpace, TypeLibImporterFlags flags, ITypeLibImporterNotifySink notifySink, out ArrayList eventItfInfoList);
private static extern unsafe void ResolveType(RuntimeModule module, int typeToken, IntPtr *typeInstArgs, int typeInstCount, IntPtr *methodInstArgs, int methodInstCount, ObjectHandleOnStack type);
private static extern IntPtr GetHINSTANCE(RuntimeModule m);
internal static IRuntimeMethodInfo ResolveMethodHandleInternal(RuntimeModule module, int methodToken)
{
return(ModuleHandle.ResolveMethodHandleInternal(module, methodToken, (RuntimeTypeHandle[])null, (RuntimeTypeHandle[])null));
}
[System.Security.SecurityCritical] // auto-generated
private unsafe void Init(String name,
MethodAttributes attributes,
CallingConventions callingConvention,
Type returnType,
Type[] signature,
Type owner,
Module m,
bool skipVisibility,
bool transparentMethod,
ref StackCrawlMark stackMark)
{
DynamicMethod.CheckConsistency(attributes, callingConvention);
// check and store the signature
if (signature != null)
{
m_parameterTypes = new RuntimeType[signature.Length];
for (int i = 0; i < signature.Length; i++)
{
if (signature[i] == null)
{
throw new ArgumentException(Environment.GetResourceString("Arg_InvalidTypeInSignature"));
}
m_parameterTypes[i] = signature[i].UnderlyingSystemType as RuntimeType;
if (m_parameterTypes[i] == null || !(m_parameterTypes[i] is RuntimeType) || m_parameterTypes[i] == (RuntimeType)typeof(void))
{
throw new ArgumentException(Environment.GetResourceString("Arg_InvalidTypeInSignature"));
}
}
}
else
{
m_parameterTypes = Array.Empty <RuntimeType>();
}
// check and store the return value
m_returnType = (returnType == null) ? (RuntimeType)typeof(void) : returnType.UnderlyingSystemType as RuntimeType;
if ((m_returnType == null) || !(m_returnType is RuntimeType) || m_returnType.IsByRef)
{
throw new NotSupportedException(Environment.GetResourceString("Arg_InvalidTypeInRetType"));
}
if (transparentMethod)
{
Contract.Assert(owner == null && m == null, "owner and m cannot be set for transparent methods");
m_module = GetDynamicMethodsModule();
if (skipVisibility)
{
m_restrictedSkipVisibility = true;
}
#if FEATURE_COMPRESSEDSTACK
m_creationContext = CompressedStack.Capture();
#endif // FEATURE_COMPRESSEDSTACK
}
else
{
Contract.Assert(m != null || owner != null, "PerformSecurityCheck should ensure that either m or owner is set");
Contract.Assert(m == null || !m.Equals(s_anonymouslyHostedDynamicMethodsModule), "The user cannot explicitly use this assembly");
Contract.Assert(m == null || owner == null, "m and owner cannot both be set");
if (m != null)
{
m_module = m.ModuleHandle.GetRuntimeModule(); // this returns the underlying module for all RuntimeModule and ModuleBuilder objects.
}
else
{
RuntimeType rtOwner = null;
if (owner != null)
{
rtOwner = owner.UnderlyingSystemType as RuntimeType;
}
if (rtOwner != null)
{
if (rtOwner.HasElementType || rtOwner.ContainsGenericParameters ||
rtOwner.IsGenericParameter || rtOwner.IsInterface)
{
throw new ArgumentException(Environment.GetResourceString("Argument_InvalidTypeForDynamicMethod"));
}
m_typeOwner = rtOwner;
m_module = rtOwner.GetRuntimeModule();
}
}
m_skipVisibility = skipVisibility;
}
// initialize remaining fields
m_ilGenerator = null;
m_fInitLocals = true;
m_methodHandle = null;
if (name == null)
{
throw new ArgumentNullException("name");
}
#if FEATURE_APPX
if (AppDomain.ProfileAPICheck)
{
if (m_creatorAssembly == null)
{
m_creatorAssembly = RuntimeAssembly.GetExecutingAssembly(ref stackMark);
}
if (m_creatorAssembly != null && !m_creatorAssembly.IsFrameworkAssembly())
{
m_profileAPICheck = true;
}
}
#endif // FEATURE_APPX
m_dynMethod = new RTDynamicMethod(this, name, attributes, callingConvention);
}
internal static unsafe RuntimeMethodHandleInternal ResolveMethodHandleInternalCore(RuntimeModule module, int methodToken, IntPtr[] typeInstantiationContext, int typeInstCount, IntPtr[] methodInstantiationContext, int methodInstCount)
{
ModuleHandle.ValidateModulePointer(module);
if (!ModuleHandle.GetMetadataImport(module.GetNativeHandle()).IsValidToken(methodToken))
{
throw new ArgumentOutOfRangeException("metadataToken", Environment.GetResourceString("Argument_InvalidToken", (object)methodToken, (object)new ModuleHandle(module)));
fixed(IntPtr *typeInstArgs = typeInstantiationContext)
fixed(IntPtr * methodInstArgs = methodInstantiationContext)
return(ModuleHandle.ResolveMethod(module.GetNativeHandle(), methodToken, typeInstArgs, typeInstCount, methodInstArgs, methodInstCount));
}
internal MemberInfo ResolveOrGetRegisteredToken(int metadataToken, Type[] genericTypeArguments, Type[] genericMethodArguments)
{
ResolveTokenError error;
MemberInfo? m = RuntimeModule.ResolveMemberToken(_impl, metadataToken, RuntimeModule.ptrs_from_types(genericTypeArguments), RuntimeModule.ptrs_from_types(genericMethodArguments), out error);
if (m != null)
{
return(m);
}
m = GetRegisteredToken(metadataToken) as MemberInfo;
if (m == null)
{
throw RuntimeModule.resolve_token_exception(Name, metadataToken, error, "MemberInfo");
}
else
{
return(m);
}
}
private static extern unsafe RuntimeMethodHandleInternal ResolveMethod(RuntimeModule module, int methodToken, IntPtr *typeInstArgs, int typeInstCount, IntPtr *methodInstArgs, int methodInstCount);
public override byte[] ResolveSignature(int metadataToken)
{
return(RuntimeModule.ResolveSignature(this, _impl, metadataToken));
}
internal static unsafe IRuntimeFieldInfo ResolveFieldHandleInternal(RuntimeModule module, int fieldToken, RuntimeTypeHandle[] typeInstantiationContext, RuntimeTypeHandle[] methodInstantiationContext)
{
ModuleHandle.ValidateModulePointer(module);
if (!ModuleHandle.GetMetadataImport(module.GetNativeHandle()).IsValidToken(fieldToken))
throw new ArgumentOutOfRangeException("metadataToken", Environment.GetResourceString("Argument_InvalidToken", (object)fieldToken, (object)new ModuleHandle(module)));
}
private static extern void GetTypeByNameUsingCARules(string name, RuntimeModule scope, ObjectHandleOnStack type);
private static extern IntPtr _GetMetadataImport(RuntimeModule module);
