/// <summary>
/// Converts the <see cref="WitnessCondition"/> from a JSON object.
/// </summary>
/// <param name="json">The <see cref="WitnessCondition"/> represented by a JSON object.</param>
/// <returns>The converted <see cref="WitnessCondition"/>.</returns>
public static WitnessCondition FromJson(JObject json)
{
WitnessConditionType type = Enum.Parse <WitnessConditionType>(json["type"].GetString());
if (ReflectionCache <WitnessConditionType> .CreateInstance(type) is not WitnessCondition condition)
{
throw new FormatException("Invalid WitnessConditionType.");
}
condition.ParseJson(json);
return(condition);
}
private void InjectToBehaviour(MonoBehaviour behaviour)
{
Type componentType = behaviour.GetType();
IMemberInjection[] injections = ReflectionCache.GetInjections(componentType);
foreach (IMemberInjection injection in injections)
{
injection.Inject(behaviour, _context);
}
}
private void DecompressPayload()
{
if (_payload_compressed.Length == 0)
{
return;
}
byte[] decompressed = Flags.HasFlag(MessageFlags.Compressed)
? _payload_compressed.DecompressLz4(PayloadMaxSize)
: _payload_compressed;
Payload = ReflectionCache <MessageCommand> .CreateSerializable(Command, decompressed);
}
public void FindAttributeByType_AttributeExist_List()
{
// Arrange
var reflection = ReflectionCache.GetReflection(typeof(ExampleObject)).Attributes;
// Act
var property = reflection[typeof(CustomAttribute)];
// Assert
Assert.AreEqual(3, property.Count);
}
public void FindMethodsByName_MethodNotExist_EmptyList()
{
// Arrange
ReflectionClass rc = ReflectionCache.GetReflection(typeof(ExampleObject));
// Act
var methods = rc.Methods["TestMethodNotExist"];
// Assert
Assert.AreEqual(0, methods.Count);
}
public void FindPropertyByName_PropertyNotExist_Null()
{
// Arrange
ReflectionClass rc = ReflectionCache.GetReflection(typeof(ExampleObject));
// Act
var property = rc.Properties["Property12"];
// Assert
Assert.IsNull(property);
}
public void FullName_PropertyExist_ShouldContainParentNameAndNameSpace()
{
// Arrange
var reflection = ReflectionCache.GetReflection(typeof(ExampleObject)).Properties["Property1"];
// Act
var name = reflection.FullName;
// Assert
Assert.AreEqual("ReflectionUtilites.Test.ExampleObjects.ExampleObject.Property1", name);
}
/// <summary>
/// 根据名称获取 <see cref="IRecordWrapper"/> 相对应的方法。
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public static MethodInfo GetMethodByName(DbType type)
{
var methodName = GetDbTypeName(type);
if (string.IsNullOrEmpty(methodName))
{
throw new ArgumentNullException(SR.GetString(SRKind.NoMatchRecordWrapperMethod, type.ToString()));
}
return(ReflectionCache.GetMember(methodName, typeof(string), methodName, (_, name) => typeof(IRecordWrapper).GetMethod(name, new[] { typeof(IDataReader), typeof(string) })));
}
public IObservable <T> ObservableUnsortedScan <T>(T start = default(T), T end = default(T))
where T : class
{
var cache = ReflectionCache.For <T>();
var table = LocateTable <T>(cache);
var startKey = ExtractKey(cache, start);
var endKey = ExtractKey(cache, end);
var observable = DataClient.Value.ObserveUnsortedRows(table, startKey, endKey);
return(observable.Select(Inflate <T>));
}
public void GetAttributes_AttributesExists_CountZero()
{
// Arrange
var reflection = ReflectionCache.GetReflection(typeof(ExampleObject)).Properties;
// Act
int count = reflection["Property2"].Attributes.Count;
// Assert
Assert.AreEqual(4, count);
}
public void TestCreateInstance2()
{
TestItem defaultItem = new TestItem1();
object item2 = ReflectionCache <MyTestEnum> .CreateInstance(MyTestEnum.Item2, defaultItem);
(item2 is TestItem2).Should().BeTrue();
object item1 = ReflectionCache <MyTestEnum> .CreateInstance((MyTestEnum)0x02, new TestItem1());
(item1 is TestItem1).Should().BeTrue();
}
public void Static_members_are_not_returned_from_ReflectionCache()
{
//// Act
var propertiesAndFields = ReflectionCache.GetPropertiesAndFields(typeof(TestClass));
//// Assert
Assert.Contains(propertiesAndFields, p => p.MemberInfo.Name == "field");
Assert.DoesNotContain(propertiesAndFields, p => p.MemberInfo.Name == "staticField");
Assert.Contains(propertiesAndFields, p => p.MemberInfo.Name == "property");
Assert.DoesNotContain(propertiesAndFields, p => p.MemberInfo.Name == "staticProperty");
}
/// <inheritdoc/>
public Task Initialize()
{
if (IsInitialized)
{
return(Task.CompletedTask);
}
AvailableBehaviourTypes = ReflectionCache.FindTypes(type => type.IsSubclassOf(typeof(NPCBehaviourBase)) && !type.IsAbstract);
IsInitialized = true;
Debug.Log($"{GetType().Name} scenario editor extension has been initialized.");
return(Task.CompletedTask);
}
public void IsAssignableFrom_ForAssignableInterface_True()
{
// Arrange
var reflection = ReflectionCache.GetReflection(typeof(ExampleObject));
// Act
var result = reflection.IsAssignableFrom(typeof(IExampleInterface));
// Assert
Assert.AreEqual(true, result);
}
public void Name_PropertyExist_ShouldNotContainParentname()
{
// Arrange
var reflection = ReflectionCache.GetReflection(typeof(ExampleObject)).Properties["Property1"];
// Act
var name = reflection.Name;
// Assert
Assert.AreEqual("Property1", name);
}
public PropertyInfo GetProperty(string name, BindingFlags flags)
{
var props = ReflectionCache.GetProperties(this, name, flags);
if (props.Length > 1)
{
throw new AmbiguousMatchException("not unique: " + name);
}
return(props.Length == 0 ? null : props[0]);
}
public void PropertyType_PropertyExist_PropertyType()
{
// Arrange
var reflection = ReflectionCache.GetReflection(typeof(ExampleObject)).Properties["Property4"];
// Act
Type propertyType = reflection.PropertyType;
// Assert
Assert.AreEqual(typeof(ExampleObject), propertyType);
}
public void GetMethodList_MethodCount_WithoutPropertiesWithStandart()
{
// Arrange
ReflectionClass rc = ReflectionCache.GetReflection(typeof(ExampleObject));
// Act
int count = rc.Methods.Count;
// Assert
Assert.AreEqual(7, count);
}
public void Properties_PropertiesExist_Count()
{
// Arrange
var reflection = ReflectionCache.GetReflection(typeof(ExampleObject));
// Act
int count = reflection.Properties.Count;
// Assert
Assert.AreEqual(4, count);
}
public void GetPropertyList_PropertyCount_ExactNumber()
{
// Arrange
ReflectionClass rc = ReflectionCache.GetReflection(typeof(ExampleObject));
// Act
int count = rc.Properties.Count;
// Assert
Assert.AreEqual(4, count);
}
public void Methods_MethodsExist_CountWithStandart()
{
// Arrange
var reflection = ReflectionCache.GetReflection(typeof(ExampleObject));
// Act
int count = reflection.Methods.Count;
// Assert
Assert.AreEqual(7, count);
}
private static string RegexOutput(object schema, object profile, string output)
{
var mappers = cache.TryGetValue(output, () =>
{
var list = new List <AccessorMap>();
var schemaType = schema != null ? schema.GetType() : null;
var profileType = profile != null ? profile.GetType() : null;
var regex = new Regex(@"\{(\w+)\}");
var matches = regex.Matches(output);
foreach (Match match in matches)
{
var group = match.Groups[0];
var name = group.Value.Substring(1, group.Value.Length - 2);
if (schemaType != null)
{
var property = schemaType.GetProperty(name);
if (property != null)
{
list.Add(new AccessorMap
{
GroupName = group.Value,
Accessor = ReflectionCache.GetAccessor(property),
ObjectType = ObjectType.Schema
});
}
}
if (profileType != null)
{
var property = profileType.GetProperty(name);
if (property != null)
{
list.Add(new AccessorMap
{
GroupName = group.Value,
Accessor = ReflectionCache.GetAccessor(property),
ObjectType = ObjectType.Profile
});
}
}
}
return(list);
});
foreach (var p in mappers)
{
var value = GetPropertyValue(schema, profile, p);
output = output.Replace(p.GroupName, value);
}
return(output);
}
public void BaseType_AnyObject_RealObjectType()
{
// Arrange
var reflection = ReflectionCache.GetReflection(typeof(ExampleObject));
// Act
var type = reflection.BaseType;
// Assert
Assert.AreEqual(typeof(ExampleObject), type);
}
public void GetAttributeList_AttributeCount_ExactNumber()
{
// Arrange
var reflection = ReflectionCache.GetReflection(typeof(ExampleObject)).Attributes;
// Act
int count = reflection.Count;
// Assert
Assert.AreEqual(4, count);
}
public void FullName_ForClass_ShouldContainNameSpace()
{
// Arrange
var reflection = ReflectionCache.GetReflection(typeof(ExampleObject));
// Act
var name = reflection.FullName;
// Assert
Assert.AreEqual("ReflectionUtilites.Test.ExampleObjects.ExampleObject", name);
}
public void FindAttributeByType_AttributeNotExist_EmptyList()
{
// Arrange
var reflection = ReflectionCache.GetReflection(typeof(ExampleObject)).Attributes;
// Act
var property = reflection[typeof(TestMethodAttribute)];
// Assert
Assert.AreEqual(0, property.Count);
}
public void Name_ForClass_ShouldNotContainNamespace()
{
// Arrange
var reflection = ReflectionCache.GetReflection(typeof(ExampleObject));
// Act
var name = reflection.Name;
// Assert
Assert.AreEqual("ExampleObject", name);
}
/// <summary>
/// Deserializes an <see cref="WitnessCondition"/> object from a <see cref="MemoryReader"/>.
/// </summary>
/// <param name="reader">The <see cref="MemoryReader"/> for reading data.</param>
/// <param name="maxNestDepth">The maximum nesting depth allowed during deserialization.</param>
/// <returns>The deserialized <see cref="WitnessCondition"/>.</returns>
public static WitnessCondition DeserializeFrom(ref MemoryReader reader, int maxNestDepth)
{
WitnessConditionType type = (WitnessConditionType)reader.ReadByte();
if (ReflectionCache <WitnessConditionType> .CreateInstance(type) is not WitnessCondition condition)
{
throw new FormatException();
}
condition.DeserializeWithoutType(ref reader, maxNestDepth);
return(condition);
}
/// <summary>
/// Deserializes an <see cref="TransactionAttribute"/> object from a <see cref="BinaryReader"/>.
/// </summary>
/// <param name="reader">The <see cref="BinaryReader"/> for reading data.</param>
/// <returns>The deserialized attribute.</returns>
public static TransactionAttribute DeserializeFrom(BinaryReader reader)
{
TransactionAttributeType type = (TransactionAttributeType)reader.ReadByte();
if (ReflectionCache <TransactionAttributeType> .CreateInstance(type) is not TransactionAttribute attribute)
{
throw new FormatException();
}
attribute.DeserializeWithoutType(reader);
return(attribute);
}
public void Parameters_ParametersExist_ListOfParameters()
{
// Arrange
var reflection = ReflectionCache.GetReflection(typeof(ExampleObject)).Methods["TestMethod"][1];
// Act
var parameters = reflection.Parameters;
// Assert
Assert.AreEqual(1, parameters.Length);
}
/// <summary>
/// Animates the current control with some values.
/// </summary>
/// <param name="c">The control to animate.</param>
/// <param name="properties">The anonymous object with name / value pairs.</param>
/// <param name="duration">The duration of the animation.</param>
/// <param name="easing">The Easing object to use.</param>
/// <param name="complete">The callback method to invoke when the animation is finished.</param>
public static void Animate(this Control c, object properties, int duration, Easing easing, Action complete)
{
var t = new Timer();
t.Interval = 30;
var frame = 0;
var maxframes = (int)Math.Ceiling(duration / 30.0);
var reflection = properties.GetType();
var target = c.GetType();
var props = reflection.GetProperties();
var values = new ReflectionCache[props.Length];
for (int i = 0; i < props.Length; i++)
{
values[i] = new ReflectionCache(target.GetProperty(props[i].Name));
values[i].SetStart(values[i].Info.GetValue(c, null));
values[i].SetEnd(props[i].GetValue(properties, null));
}
t.Tick += (s, e) =>
{
frame++;
for (int i = 0; i < values.Length; i++)
{
values[i].Execute(c, easing, frame, maxframes);
}
if (frame == maxframes)
{
t.Stop();
if (complete != null)
complete();
}
};
t.Start();
}
public BuiltinFunctionKey(Type declaringType, ReflectionCache.MethodBaseCache cache, FunctionType funcType) {
Cache = cache;
FunctionType = funcType;
DeclaringType = declaringType;
}
public ReflectionCache(PropertyInfo info)
{
Info = info;
if(info == null)
throw new ArgumentException("Invalid property to animate. The given properties have to match a property of the control.");
var subprops = info.PropertyType.GetProperties().Where(m => m.CanRead && m.CanWrite).ToArray();
if (subprops.Length > 0)
{
SubList = new ReflectionCache[subprops.Length];
for (int i = 0; i < subprops.Length; i++)
SubList[i] = new ReflectionCache(subprops[i]);
}
}
