warrentyexpired/ModernUO
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Spawner wouldn't spawn Types with optional parameters in ctor due to parameter length check (#92)

Browse source
This commit is contained in:
Reetus 2020-02-20 18:08:01 +08:00 • committed by GitHub
parent 717e192cf7
commit 11cac69eba
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
2 changed files with 118 additions and 55 deletions
Download patch file Download diff file Expand all files Collapse all files

70
Projects/Scripts/Engines/Spawner/Spawner.cs
View file

@ -4,6 +4,7 @@ using System.IO;
using System.Reflection; using System.Reflection;
using Server.Commands; using Server.Commands;
using Server.Items; using Server.Items;
using Server.Utilities;
using CPA = Server.CommandPropertyAttribute; using CPA = Server.CommandPropertyAttribute;
namespace Server.Mobiles namespace Server.Mobiles
@ -472,49 +473,58 @@ namespace Server.Mobiles
else else
paramargs = entry.Parameters.Trim().Split(' '); paramargs = entry.Parameters.Trim().Split(' ');
ConstructorInfo[] ctors = type.GetConstructors(); if (paramargs.Length == 0)
for (int i = 0; i < ctors.Length; ++i)
{ {
ConstructorInfo ctor = ctors[i]; o = ActivatorUtil.CreateInstance(type, ci => Add.IsConstructible(ci, AccessLevel.Developer));
}
else
{
ConstructorInfo[] ctors = type.GetConstructors();
if (Add.IsConstructible(ctor, AccessLevel.Developer)) for (int i = 0; i < ctors.Length; ++i)
{ {
ParameterInfo[] paramList = ctor.GetParameters(); ConstructorInfo ctor = ctors[i];
if (paramargs.Length == paramList.Length) if (Add.IsConstructible(ctor, AccessLevel.Developer))
{ {
object[] paramValues = Add.ParseValues(paramList, paramargs); ParameterInfo[] paramList = ctor.GetParameters();
if (paramValues != null) if (paramargs.Length == paramList.Length)
{ {
o = ctor.Invoke(paramValues); object[] paramValues = Add.ParseValues(paramList, paramargs);
for (int j = 0; j < realProps.Length; j++)
if (realProps[j] != null)
{
object toSet = null;
string result = Properties.ConstructFromString(realProps[j].PropertyType, o,
props[j, 1], ref toSet);
if (result == null)
{
realProps[j].SetValue(o, toSet, null);
}
else
{
flags = EntryFlags.InvalidProps;
(o as ISpawnable)?.Delete(); if (paramValues != null)
{
return false; o = ctor.Invoke(paramValues);
} break;
} }
break;
} }
} }
} }
} }
for (int i = 0; i < realProps.Length; i++)
{
if (realProps[i] != null)
{
object toSet = null;
string result = Properties.ConstructFromString(realProps[i].PropertyType, o, props[i, 1], ref toSet);
if (result == null)
{
realProps[i].SetValue(o, toSet, null);
}
else
{
flags = EntryFlags.InvalidProps;
(o as ISpawnable)?.Delete();
return false;
}
}
}
if (o is Mobile m) if (o is Mobile m)
{ {
Spawned.Add(m, entry); Spawned.Add(m, entry);

103
Projects/Server/Utilities/ActivatorUtil.cs
View file

@ -1,4 +1,5 @@
using System; using System;
using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Reflection; using System.Reflection;
@ -6,68 +7,120 @@ namespace Server.Utilities
{ {
public static class ActivatorUtil public static class ActivatorUtil
{ {
public static ConstructorInfo GetConstructor(Type type, Predicate<ConstructorInfo> predicate = null)
{
ConstructorInfo emptyCtor = type.GetConstructor(Type.EmptyTypes);
public static ConstructorInfo GetConstructor(Type type) if (emptyCtor != null && predicate?.Invoke(emptyCtor) != false)
{
try
{ {
return type.GetConstructor(Type.EmptyTypes) return emptyCtor;
?? type.GetConstructors().Single(info => info.GetParameters().All(x => x.IsOptional))
?? throw new TypeInitializationException(type.ToString(), new Exception($"There is no empty/default constructor for {type}"));
} }
catch (Exception e)
ConstructorInfo optionalCtor = type.GetConstructors().SingleOrDefault(info =>
predicate?.Invoke(info) != false && info.GetParameters().All(x => x.IsOptional));
if (optionalCtor != null)
{ {
throw new TypeInitializationException(type.ToString(), e); return optionalCtor;
} }
throw new TypeInitializationException(type.ToString(),
new Exception($"There is no empty/default constructor for {type} that matches predicate."));
} }
public static ConstructorInfo GetConstructor(Type type, params Type[] args)
public static ConstructorInfo GetConstructor(Type type, Predicate<ConstructorInfo> predicate, params Type[] args)
{ {
try try
{ {
return args.All(x => x != null) ? type.GetConstructor(args) : null ?? type.GetConstructors().Single(info => ConstructorInfo ctor;
if (args.All(x => x != null))
{
ctor = type.GetConstructor(args);
if (ctor != null && predicate?.Invoke(ctor) != false)
{ {
var paramList = info.GetParameters().ToList(); return ctor;
}
}
else
{
ctor = type.GetConstructors().SingleOrDefault(info =>
{
if (predicate?.Invoke(info) == false)
{
return false;
}
List<ParameterInfo> paramList = info.GetParameters().ToList();
// If more args are given than parameters, skip. // If more args are given than parameters, skip.
if (args.Length > paramList.Count) if (args.Length > paramList.Count)
{
return false; return false;
}
// check all given args map to params. // check all given args map to params.
for (int i = 0; i < args.Length; i++) for (int i = 0; i < args.Length; i++)
{ {
// if a null reference is passed, but the type is not nullable // if a null reference is passed, but the type is not nullable
if ((args[i] == null && paramList[i].ParameterType.IsValueType) if (args[i] == null && paramList[i].ParameterType.IsValueType
// or if an arg is not null and is not assignable to the parameter type, skip. // or if an arg is not null and is not assignable to the parameter type, skip.
|| !(args[i] == null || paramList[i].ParameterType.IsAssignableFrom(args[i]))) || !(args[i] == null || paramList[i].ParameterType.IsAssignableFrom(args[i])))
{
return false; return false;
}
} }
// If there are more parameters, check if they any are not optional, if any are not, skip. // If there are more parameters, check if they any are not optional, if any are not, skip.
// Otherwise all checks have passed. We have found a match // Otherwise all checks have passed. We have found a match
return args.Length <= paramList.Count || paramList.GetRange(args.Length, paramList.Count - args.Length).All(x => x.IsOptional); return args.Length <= paramList.Count || paramList.GetRange(args.Length, paramList.Count - args.Length)
}) ?? throw new Exception($"There is no empty/default constructor for {type}"); .All(x => x.IsOptional);
});
if (ctor != null)
{
return ctor;
}
}
throw new Exception($"There is no empty/default constructor for {type} that matches predicate.");
} }
catch (Exception e) catch (Exception e)
{ {
throw new TypeInitializationException(type.ToString(), e); throw new TypeInitializationException(type.ToString(), e);
} }
} }
public static object CreateInstance(Type type)
public static object CreateInstance(Type type, Predicate<ConstructorInfo> constructorPredicate = null)
{ {
var cctor = GetConstructor(type); ConstructorInfo cctor = GetConstructor(type, constructorPredicate);
var args = cctor.GetParameters(); ParameterInfo[] args = cctor.GetParameters();
if (args.Length == 0) if (args.Length == 0)
{
return cctor.Invoke(Type.EmptyTypes); return cctor.Invoke(Type.EmptyTypes);
var argList = new object[args.Length]; }
object[] argList = new object[args.Length];
Array.Fill(argList, Type.Missing); Array.Fill(argList, Type.Missing);
return cctor.Invoke(argList); return cctor.Invoke(argList);
} }
public static object CreateInstance(Type type, params object[] args)
public static object CreateInstance(Type type, Predicate<ConstructorInfo> constructorPredicate = null,
params object[] args)
{ {
if (args == null || args.Length == 0) if (args == null || args.Length == 0)
return CreateInstance(type); {
var cctor = GetConstructor(type, args.Select(x => x?.GetType()).ToArray()); return CreateInstance(type, constructorPredicate);
}
ConstructorInfo cctor = GetConstructor(type, constructorPredicate, args.Select(x => x?.GetType()).ToArray());
return cctor.Invoke(args); return cctor.Invoke(args);
} }
public static T CreateInstance<T>() => (T)CreateInstance(typeof(T)); public static object CreateInstance(Type type, params object[] args) => CreateInstance(type, null, args);
public static T CreateInstance<T>(params object[] args) => (T)CreateInstance(typeof(T), args); public static T CreateInstance<T>(Predicate<ConstructorInfo> constructorPredicate = null) => (T)CreateInstance(typeof(T), constructorPredicate);
public static T CreateInstance<T>(params object[] args) => (T)CreateInstance(typeof(T), null, args);
} }
} }