private static Type GetAssociateMetadataTypeFromAttribute(Type type)
{
Attribute[] customAttributes = ReflectionUtils.GetAttributes(type, null, true);
foreach (Attribute attribute in customAttributes)
{
Type attributeType = attribute.GetType();
// only test on attribute type name
// attribute assembly could change because of type forwarding, etc
if (string.Equals(attributeType.FullName, "System.ComponentModel.DataAnnotations.MetadataTypeAttribute", StringComparison.Ordinal))
{
const string metadataClassTypeName = "MetadataClassType";
if (_metadataTypeAttributeReflectionObject == null)
{
_metadataTypeAttributeReflectionObject = ReflectionObject.Create(attributeType, metadataClassTypeName);
}
return((Type)_metadataTypeAttributeReflectionObject.GetValue(attribute, metadataClassTypeName));
}
}
return(null);
}
/// <summary>
/// Writes the JSON representation of the object.
/// </summary>
/// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
/// <param name="value">The value.</param>
/// <param name="serializer">The calling serializer.</param>
public override void WriteJson(JsonWriter writer, object?value, JsonSerializer serializer)
{
if (value == null)
{
writer.WriteNull();
return;
}
ReflectionObject reflectionObject = ReflectionObjectPerType.Get(value.GetType());
DefaultContractResolver?resolver =
serializer.ContractResolver as DefaultContractResolver;
writer.WriteStartObject();
writer.WritePropertyName(
(resolver != null) ? resolver.GetResolvedPropertyName(KeyName) : KeyName
);
serializer.Serialize(
writer,
reflectionObject.GetValue(value, KeyName),
reflectionObject.GetType(KeyName)
);
writer.WritePropertyName(
(resolver != null) ? resolver.GetResolvedPropertyName(ValueName) : ValueName
);
serializer.Serialize(
writer,
reflectionObject.GetValue(value, ValueName),
reflectionObject.GetType(ValueName)
);
writer.WriteEndObject();
}
private void EnsureReflectionObject(Type t)
{
if (_reflectionObject == null)
{
_reflectionObject = ReflectionObject.Create(t, t.GetConstructor(new[] { typeof(byte[]) }), BinaryToArrayName);
}
}
public override void Do(EventModel model, ref List <MessageModel> replyMessages)
{
var message = model.message.text.Split(' ');
var actionReply = ReflectionObject.GenericReflectionWithParm <Reply>($"{message[0].FirstCharToUpper()}Reply", new object[] { _context });
actionReply.Do(message, ref replyMessages);
}
private static Type GetAssociateMetadataTypeFromAttribute(Type type)
{
Type metadataTypeAttributeType = GetMetadataTypeAttributeType();
if (metadataTypeAttributeType == null)
{
return(null);
}
Attribute attribute = ReflectionUtils.GetAttributes(type, metadataTypeAttributeType, true).SingleOrDefault();
if (attribute == null)
{
return(null);
}
const string metadataClassTypeName = "MetadataClassType";
if (_metadataTypeAttributeReflectionObject == null)
{
_metadataTypeAttributeReflectionObject = ReflectionObject.Create(metadataTypeAttributeType, metadataClassTypeName);
}
return((Type)_metadataTypeAttributeReflectionObject.GetValue(attribute, metadataClassTypeName));
}
private static void EnsureReflectionObject(Type objectType)
{
if (_reflectionObject == null)
{
_reflectionObject = ReflectionObject.Create(objectType, KeyPropertyName, ValuePropertyName);
}
}
private void EnsureReflectionObject(Type t)
{
if (this._reflectionObject == null)
{
this._reflectionObject = ReflectionObject.Create(t, t.GetConstructor(new Type[] { typeof(byte[]) }), new string[] { "ToArray" });
}
}
/// <summary>
/// The get transitions.
/// </summary>
/// <param name="record">
/// The record.
/// </param>
/// <param name="rootActivity">
/// The root activity.
/// </param>
/// <returns>
/// A collection of possible transitions
/// </returns>
public static IList<Transition> GetTransitions(this StateMachineStateRecord record, Activity rootActivity)
{
var activity = WorkflowInspectionServices.Resolve(rootActivity, record.Activity.Id);
dynamic internalState = new ReflectionObject(activity);
dynamic transitions = new ReflectionObject(internalState.Transitions);
return ((ReflectionObject)transitions).Inner as IList<Transition>;
}
public override object ReadJson(JsonReader reader, Type objectType, [Nullable(2)] object existingValue, JsonSerializer serializer)
{
EntityKeyMemberConverter.EnsureReflectionObject(objectType);
object obj = EntityKeyMemberConverter._reflectionObject.Creator(new object[0]);
EntityKeyMemberConverter.ReadAndAssertProperty(reader, "Key");
reader.ReadAndAssert();
ReflectionObject reflectionObject = EntityKeyMemberConverter._reflectionObject;
object target = obj;
string member = "Key";
object value = reader.Value;
reflectionObject.SetValue(target, member, (value != null) ? value.ToString() : null);
EntityKeyMemberConverter.ReadAndAssertProperty(reader, "Type");
reader.ReadAndAssert();
object value2 = reader.Value;
Type type = Type.GetType((value2 != null) ? value2.ToString() : null);
EntityKeyMemberConverter.ReadAndAssertProperty(reader, "Value");
reader.ReadAndAssert();
EntityKeyMemberConverter._reflectionObject.SetValue(obj, "Value", serializer.Deserialize(reader, type));
reader.ReadAndAssert();
return(obj);
}
private static void EnsureReflectionObject(Type t)
{
if (BinaryConverter._reflectionObject == null)
{
BinaryConverter._reflectionObject = ReflectionObject.Create(t, t.GetConstructor(new Type[] { typeof(byte[]) }), new string[] { "ToArray" });
}
}
private static Type GetAssociateMetadataTypeFromAttribute(Type type)
{
object[] customAttributes;
#if !PORTABLE
customAttributes = type.GetCustomAttributes(false);
#else
customAttributes = type.GetTypeInfo().GetCustomAttributes(false).Cast <object>().ToArray();
#endif
foreach (var attribute in customAttributes)
{
Type attributeType = attribute.GetType();
if (string.Equals(attributeType.Name, "MetadataTypeAttribute", StringComparison.Ordinal) &&
attributeType.Assembly().FullName.StartsWith("System.ComponentModel.DataAnnotations", StringComparison.Ordinal))
{
const string metadataClassTypeName = "MetadataClassType";
if (_metadataTypeAttributeReflectionObject == null)
{
_metadataTypeAttributeReflectionObject = ReflectionObject.Create(attributeType, metadataClassTypeName);
}
return((Type)_metadataTypeAttributeReflectionObject.GetValue(attribute, metadataClassTypeName));
}
}
return(null);
}
private static void EnsureReflectionObject(Type objectType)
{
if (EntityKeyMemberConverter._reflectionObject == null)
{
EntityKeyMemberConverter._reflectionObject = ReflectionObject.Create(objectType, new string[] { "Key", "Value" });
}
}
private static Type GetAssociateMetadataTypeFromAttribute(Type type)
{
object[] customAttributes;
#if !PORTABLE
customAttributes = type.GetCustomAttributes(false);
#else
customAttributes = type.GetTypeInfo().GetCustomAttributes(false).Cast <object>().ToArray();
#endif
foreach (var attribute in customAttributes)
{
Type attributeType = attribute.GetType();
// only test on attribute type name
// attribute assembly could change because of type forwarding, etc
if (string.Equals(attributeType.FullName, "System.ComponentModel.DataAnnotations.MetadataTypeAttribute", StringComparison.Ordinal))
{
const string metadataClassTypeName = "MetadataClassType";
if (_metadataTypeAttributeReflectionObject == null)
{
_metadataTypeAttributeReflectionObject = ReflectionObject.Create(attributeType, metadataClassTypeName);
}
return((Type)_metadataTypeAttributeReflectionObject.GetValue(attribute, metadataClassTypeName));
}
}
return(null);
}
private static void EnsureReflectionObject(Type objectType)
{
if (_reflectionObject == null)
{
string[] memberNames = new string[] { "Key", "Value" };
_reflectionObject = ReflectionObject.Create(objectType, memberNames);
}
}
private static ReflectionObject InitializeReflectionObject(Type t)
{
Type[] genericArguments = t.GetGenericArguments();
Type item = ((IList <Type>)genericArguments)[0];
Type type = ((IList <Type>)genericArguments)[1];
return(ReflectionObject.Create(t, t.GetConstructor(new Type[] { item, type }), new string[] { "Key", "Value" }));
}
private static ReflectionObject InitializeReflectionObject(Type t)
{
IList <Type> genericArguments = t.GetGenericArguments();
Type keyType = genericArguments[0];
Type valueType = genericArguments[1];
return(ReflectionObject.Create(t, t.GetConstructor(new[] { keyType, valueType }), KeyName, ValueName));
}
private void EnsureReflectionObject(Type t)
{
if (this._reflectionObject == null)
{
Type[] types = new Type[] { typeof(byte[]) };
string[] memberNames = new string[] { "ToArray" };
this._reflectionObject = ReflectionObject.Create(t, t.GetConstructor(types), memberNames);
}
}
public static void Quit()
{
Engine.TickWorkQueue.Enqueue(() =>
{
dynamic game = new ReflectionObject(Reflection.GetTypePropertyValue <dynamic>("ClassicUO.Client", "Game", null));
game.Exit();
});
}
private static ReflectionObject InitializeReflectionObject(Type t)
{
Type[] genericArguments = t.GetGenericArguments();
Type type = genericArguments[0];
Type type2 = genericArguments[1];
Type[] types = new Type[] { type, type2 };
string[] memberNames = new string[] { "Key", "Value" };
return(ReflectionObject.Create(t, t.GetConstructor(types), memberNames));
}
/// <summary>
/// Serves as a hash function for a particular type.
/// </summary>
/// <returns>
/// A hash code for the current <see cref="T:System.Object"/>.
/// </returns>
/// <filterpriority>2</filterpriority>
public override int GetHashCode()
{
unchecked
{
int result = Level;
result = (result * 397) ^ (ReflectionObject != null ? ReflectionObject.GetHashCode() : 0);
result = (result * 397) ^ (Node != null ? Node.GetHashCode() : 0);
return(result);
}
}
private void EnsureReflectionObject(Type t)
{
if (this._reflectionObject != null)
{
return;
}
this._reflectionObject = ReflectionObject.Create(t, (MethodBase)t.GetConstructor(new Type[1]
{
typeof(byte[])
}), "ToArray");
}
private static ReflectionObject InitializeReflectionObject(Type t)
{
Type[] genericArguments = t.GetGenericArguments();
Type type1 = ((IList <Type>)genericArguments)[0];
Type type2 = ((IList <Type>)genericArguments)[1];
return(ReflectionObject.Create(t, (MethodBase)t.GetConstructor(new Type[2] {
type1,
type2
}), "Key", "Value"));
}
private void EnsureReflectionObject(Type t)
{
if (_reflectionObject == null)
{
#if NETSTANDARD1_3 || NETSTANDARD1_4 || NETSTANDARD1_5
_reflectionObject = ReflectionObject.Create(t, System.Reflection.TypeExtensions.GetConstructor(t, new[] { typeof(byte[]) }), BinaryToArrayName);
#else
_reflectionObject = ReflectionObject.Create(t, t.GetConstructor(new[] { typeof(byte[]) }), BinaryToArrayName);
#endif
}
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
ReflectionObject reflectionObject = KeyValuePairConverter.ReflectionObjectPerType.Get(value.GetType());
DefaultContractResolver contractResolver = serializer.ContractResolver as DefaultContractResolver;
writer.WriteStartObject();
writer.WritePropertyName((contractResolver != null ? contractResolver.GetResolvedPropertyName("Key") : "Key"));
serializer.Serialize(writer, reflectionObject.GetValue(value, "Key"), reflectionObject.GetType("Key"));
writer.WritePropertyName((contractResolver != null ? contractResolver.GetResolvedPropertyName("Value") : "Value"));
serializer.Serialize(writer, reflectionObject.GetValue(value, "Value"), reflectionObject.GetType("Value"));
writer.WriteEndObject();
}
/// <summary>
/// Writes the JSON representation of the object.
/// </summary>
/// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
/// <param name="value">The value.</param>
/// <param name="serializer">The calling serializer.</param>
public override void WriteJson(JsonWriter writer, object value, JsonSerializerWriter internalWriter)
{
ReflectionObject reflectionObject = ReflectionObjectPerType.Get(value.GetType());
DefaultContractResolver resolver = internalWriter.Serializer.ContractResolver as DefaultContractResolver;
writer.WriteStartObject();
writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(KeyName) : KeyName);
internalWriter.Serialize(writer, reflectionObject.GetValue(value, KeyName), reflectionObject.GetType(KeyName));
writer.WritePropertyName((resolver != null) ? resolver.GetResolvedPropertyName(ValueName) : ValueName);
internalWriter.Serialize(writer, reflectionObject.GetValue(value, ValueName), reflectionObject.GetType(ValueName));
writer.WriteEndObject();
}
/// <summary>
/// Reads the JSON representation of the object.
/// </summary>
/// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
/// <param name="objectType">Type of the object.</param>
/// <param name="existingValue">The existing value of object being read.</param>
/// <param name="serializer">The calling serializer.</param>
/// <returns>The object value.</returns>
public override object?ReadJson(JsonReader reader, Type objectType, object?existingValue, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.Null)
{
if (!ReflectionUtils.IsNullableType(objectType))
{
throw JsonSerializationException.Create(reader, "Cannot convert null value to KeyValuePair.");
}
return(null);
}
object?key = null;
object?value = null;
reader.ReadAndAssert();
Type t = ReflectionUtils.IsNullableType(objectType)
? Nullable.GetUnderlyingType(objectType)
: objectType;
ReflectionObject reflectionObject = ReflectionObjectPerType.Get(t);
Serialization.JsonContract keyContract = serializer.ContractResolver.ResolveContract(reflectionObject.GetType(KeyName));
Serialization.JsonContract valueContract = serializer.ContractResolver.ResolveContract(reflectionObject.GetType(ValueName));
while (reader.TokenType == JsonToken.PropertyName)
{
string propertyName = reader.Value !.ToString();
if (string.Equals(propertyName, KeyName, StringComparison.OrdinalIgnoreCase))
{
reader.ReadForTypeAndAssert(keyContract, false);
key = serializer.Deserialize(reader, keyContract.UnderlyingType);
}
else if (string.Equals(propertyName, ValueName, StringComparison.OrdinalIgnoreCase))
{
reader.ReadForTypeAndAssert(valueContract, false);
value = serializer.Deserialize(reader, valueContract.UnderlyingType);
}
else
{
reader.Skip();
}
reader.ReadAndAssert();
}
return(reflectionObject.Creator !(key, value));
}
public void Invoke_ShouldCallInvokeOnBothMocks_AndReturnTrue()
{
// Arrange
MockMockMethodWithParam <string> mockMockMethodWithParam = new MockMockMethodWithParam <string> .Builder().Invoke().Build();
MockMockMethodWithResponse <bool> mockMockMethodWithResponse = new MockMockMethodWithResponse <bool> .Builder().Invoke(true).Build();
MockMethodWithParamAndResponse <string, bool> subject = new ReflectionObject <MockMethodWithParamAndResponse <string, bool> >("methodName", mockMockMethodWithParam, mockMockMethodWithResponse).Object();
// Act
bool actual = subject.Invoke("expected");
// Assert
actual.Should().BeTrue();
}
public void Invoke_ShouldFlagInvoked_AndNotExcept()
{
// Arrange
MockMockMethodWithParam <string> mockMockMethodWithParam = new MockMockMethodWithParam <string> .Builder().Invoke().Build();
MockMockMethodWithResponse <bool> mockMockMethodWithResponse = new MockMockMethodWithResponse <bool> .Builder().Invoke(true).Build();
MockMethodWithParamAndResponse <string, bool> subject = new ReflectionObject <MockMethodWithParamAndResponse <string, bool> >("methodName", mockMockMethodWithParam, mockMockMethodWithResponse).Object();
// Act
bool actual = subject.Invoke("expected");
// Assert
subject.AssertInvoked();
}
public async Task InvokeTask_ShouldCallInvokeOnBothMocks_AndReturnFalse()
{
// Arrange
MockMockMethodWithParam <string> mockMockMethodWithParam = new MockMockMethodWithParam <string> .Builder().Invoke().Build();
MockMockMethodWithResponse <bool> mockMockMethodWithResponse = new MockMockMethodWithResponse <bool> .Builder().Invoke(false).Build();
MockMethodWithParamAndResponse <string, bool> subject = new ReflectionObject <MockMethodWithParamAndResponse <string, bool> >("methodName", mockMockMethodWithParam, mockMockMethodWithResponse).Object();
// Act
bool actual = await subject.InvokeTask("expected");
// Assert
actual.Should().BeFalse();
}
public async Task Post([FromBody] ReceiveMessageApiModel content)
{
List <MessageModel> replyMessages = new List <MessageModel>();
EventModel receiveEvent = content.events?.FirstOrDefault();
string replyToken = receiveEvent.replyToken;
var lineEvent = ReflectionObject.GenericReflectionWithParm <LineEvent>($"{receiveEvent.type.FirstCharToUpper()}LineEvent", new object[] { _context });
if (lineEvent != null)
{
lineEvent.Do(receiveEvent, ref replyMessages);
}
await ResponseLine(replyToken, replyMessages);
}
public override object ReadJson(
JsonReader reader,
Type objectType,
object existingValue,
JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.Null)
{
if (!ReflectionUtils.IsNullableType(objectType))
{
throw JsonSerializationException.Create(reader, "Cannot convert null value to KeyValuePair.");
}
return((object)null);
}
object obj1 = (object)null;
object obj2 = (object)null;
reader.ReadAndAssert();
Type key = ReflectionUtils.IsNullableType(objectType) ? Nullable.GetUnderlyingType(objectType) : objectType;
ReflectionObject reflectionObject = KeyValuePairConverter.ReflectionObjectPerType.Get(key);
while (reader.TokenType == JsonToken.PropertyName)
{
string a = reader.Value.ToString();
if (string.Equals(a, "Key", StringComparison.OrdinalIgnoreCase))
{
reader.ReadAndAssert();
obj1 = serializer.Deserialize(reader, reflectionObject.GetType("Key"));
}
else if (string.Equals(a, "Value", StringComparison.OrdinalIgnoreCase))
{
reader.ReadAndAssert();
obj2 = serializer.Deserialize(reader, reflectionObject.GetType("Value"));
}
else
{
reader.Skip();
}
reader.ReadAndAssert();
}
return(reflectionObject.Creator(new object[2] {
obj1,
obj2
}));
}
private static void EnsureReflectionObject(Type objectType)
{
if (_reflectionObject == null)
_reflectionObject = ReflectionObject.Create(objectType, KeyPropertyName, ValuePropertyName);
}
/// <summary>
/// The get activity.
/// </summary>
/// <param name="activityInfo">
/// The activity info.
/// </param>
/// <returns>
/// The System.Activities.Activity.
/// </returns>
public static Activity GetActivity(this ActivityInfo activityInfo)
{
dynamic activityObj = new ReflectionObject(activityInfo);
return activityObj.Activity;
}
/// <summary>
/// The get transitions.
/// </summary>
/// <param name="record">
/// The record.
/// </param>
/// <returns>
/// A collection of possible transitions
/// </returns>
public static IList<Transition> GetTransitions(this StateMachineStateRecord record)
{
dynamic internalState = new ReflectionObject(record.Activity.GetActivity());
dynamic transitions = new ReflectionObject(internalState.Transitions);
return ((ReflectionObject)transitions).Inner as IList<Transition>;
}
public static ReflectionObject ParseString(String s)
{
if (s == null || s == "") return null;
ReflectionObject o = new ReflectionObject();
if (s.EndsWith(")")) o.type = Types.Methods;
else o.type = Types.Fields;
int i = s.LastIndexOf('.');
if (i == -1)
{
o.nmSpace = "";
if (o.type == Types.Fields)
o.name = s;
else
o.name = s.Substring(0, s.IndexOf('('));
}
else
{
o.nmSpace = s.Substring(0, i);
i++;
if (o.type == Types.Fields)
{
o.name = s.Substring(i, s.Length - i);
}
else
{
o.name = s.Substring(i, s.IndexOf('(') - i);
}
}
return o;
}
private void EnsureReflectionObject(Type t)
{
if (_reflectionObject == null)
_reflectionObject = ReflectionObject.Create(t, t.GetConstructor(new[] { typeof(byte[]) }), BinaryToArrayName);
}
