private static IEnumerable <Type> ResolveKnownTypes(Type type, KnownTypeAttribute attribute)
{
if (attribute.Type != null)
{
return(new[] { attribute.Type });
}
var types = (IEnumerable <Type>)type
.GetMethod(attribute.MethodName, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)
.Invoke(null, new object[0]);
return(types);
}
public void TestMembersWithPrimitiveEnumTypeGeneration()
{
ProjectMappingManagerSetup.InitializeManager(ServiceProvider, "ProjectMapping.DataContractDsl.Tests.xml");
DataContract rootElement = CreateDefaultDataContract();
DataContractEnum enumElement = new DataContractEnum(Store);
enumElement.Name = PrimitiveDataElementName1;
rootElement.DataContractModel.Contracts.Add(enumElement);
rootElement.DataMembers.AddRange(LoadLinkedElements(enumElement));
string content = RunTemplate(rootElement);
this.EnsureType(ref content, PrimitiveDataElementName1);
Type generatedType = CompileAndGetType(content);
KnownTypeAttribute knownTypeAttr = TypeAsserter.AssertAttribute <KnownTypeAttribute>(generatedType);
Assert.AreEqual <string>(PrimitiveDataElementName1, knownTypeAttr.Type.Name);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
// Load JObject from stream
JObject jObject = JObject.Load(reader);
// Create target object based on JObject
System.Attribute[] attrs = System.Attribute.GetCustomAttributes(objectType); // Reflection.
// Displaying output.
foreach (System.Attribute attr in attrs)
{
if (attr is KnownTypeAttribute)
{
KnownTypeAttribute k = (KnownTypeAttribute)attr;
var props = k.Type.GetProperties();
bool found = true;
foreach (var f in jObject)
{
if (!props.Any(z => z.Name == f.Key))
{
found = false;
break;
}
}
if (found)
{
var target = Activator.CreateInstance(k.Type);
serializer.Populate(jObject.CreateReader(), target);
return(target);
}
}
}
throw new ObjectNotFoundException();
// Populate the object properties
}
public override LoginServletResponse ReadJson(JsonReader reader, Type objectType, LoginServletResponse existingValue, bool hasExistingValue, JsonSerializer serializer)
{
//LoginResponse loginResponse = new LoginResponse();
JObject jObject = JObject.Load(reader);
System.Attribute[] attrs = System.Attribute.GetCustomAttributes(objectType); // Reflection.
// Displaying output.
foreach (System.Attribute attr in attrs)
{
if (attr is KnownTypeAttribute)
{
KnownTypeAttribute k = (KnownTypeAttribute)attr;
var target = Activator.CreateInstance(k.Type);
var props = k.Type.GetProperties();
bool found = true;
foreach (var pair in jObject)
{
if (props.Any(z => z.Name == pair.Key))
{
var value = ParseDelimeters((string)pair.Value);
target.GetType().GetProperty(pair.Key).SetValue(props, pair.Value);
}
}
return((LoginServletResponse)target);
}
}
/*foreach (var pair in jObject)
* {
* var key = pair.Key;
* var value = ParseDelimeters((string)pair.Value);
*
* }*/
return(null);
}
SerializableType CompileType(Type type, bool describedOnly)
{
var typeAttributes = type.GetTypeInfo().GetCustomAttributes(typeof(AmqpContractAttribute), false);
if (!typeAttributes.Any())
{
if (describedOnly)
{
return(null);
}
else
{
return(CompileNonContractTypes(type));
}
}
AmqpContractAttribute contractAttribute = (AmqpContractAttribute)typeAttributes.First();
SerializableType baseType = null;
if (type.GetTypeInfo().BaseType != typeof(object))
{
baseType = this.CompileType(type.GetTypeInfo().BaseType, true);
if (baseType != null)
{
if (baseType.Encoding != contractAttribute.Encoding)
{
throw new SerializationException(AmqpResources.GetString(AmqpResources.AmqpEncodingTypeMismatch, type.Name, contractAttribute.Encoding, type.GetTypeInfo().BaseType.Name, baseType.Encoding));
}
this.customTypeCache.TryAdd(type.GetTypeInfo().BaseType, baseType);
}
}
string descriptorName = contractAttribute.Name;
ulong? descriptorCode = contractAttribute.InternalCode;
if (descriptorName == null && descriptorCode == null)
{
descriptorName = type.FullName;
}
List <SerialiableMember> memberList = new List <SerialiableMember>();
if (contractAttribute.Encoding == EncodingType.List && baseType != null)
{
memberList.AddRange(baseType.Members);
}
int lastOrder = memberList.Count + 1;
MemberInfo[] memberInfos = type.GetMembers(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
MethodAccessor onDeserialized = null;
foreach (MemberInfo memberInfo in memberInfos)
{
if (memberInfo.DeclaringType != type)
{
continue;
}
if (memberInfo is FieldInfo ||
memberInfo is PropertyInfo)
{
var memberAttributes = memberInfo.GetCustomAttributes(typeof(AmqpMemberAttribute), true);
if (memberAttributes.Count() != 1)
{
continue;
}
AmqpMemberAttribute attribute = (AmqpMemberAttribute)memberAttributes.First();
SerialiableMember member = new SerialiableMember();
member.Name = attribute.Name ?? memberInfo.Name;
member.Order = attribute.InternalOrder ?? lastOrder++;
member.Mandatory = attribute.Mandatory;
member.Accessor = MemberAccessor.Create(memberInfo, true);
// This will recursively resolve member types
Type memberType = memberInfo is FieldInfo ? ((FieldInfo)memberInfo).FieldType : ((PropertyInfo)memberInfo).PropertyType;
member.Type = GetType(memberType);
memberList.Add(member);
}
else if (memberInfo is MethodInfo)
{
var memberAttributes = memberInfo.GetCustomAttributes(typeof(OnDeserializedAttribute), false);
if (memberAttributes.Count() == 1)
{
onDeserialized = MethodAccessor.Create((MethodInfo)memberInfo);
}
}
}
if (contractAttribute.Encoding == EncodingType.List)
{
memberList.Sort(MemberOrderComparer.Instance);
int order = -1;
foreach (SerialiableMember member in memberList)
{
if (order > 0 && member.Order == order)
{
throw new SerializationException(AmqpResources.GetString(AmqpResources.AmqpDuplicateMemberOrder, order, type.Name));
}
order = member.Order;
}
}
SerialiableMember[] members = memberList.ToArray();
Dictionary <Type, SerializableType> knownTypes = null;
foreach (object o in type.GetTypeInfo().GetCustomAttributes(typeof(KnownTypeAttribute), false))
{
KnownTypeAttribute knownAttribute = (KnownTypeAttribute)o;
if (knownAttribute.Type.GetTypeInfo().GetCustomAttributes(typeof(AmqpContractAttribute), false).Any())
{
if (knownTypes == null)
{
knownTypes = new Dictionary <Type, SerializableType>();
}
// KnownType compilation is delayed and non-recursive to avoid circular references
knownTypes.Add(knownAttribute.Type, null);
}
}
if (contractAttribute.Encoding == EncodingType.List)
{
return(SerializableType.CreateDescribedListType(this, type, baseType, descriptorName,
descriptorCode, members, knownTypes, onDeserialized));
}
else if (contractAttribute.Encoding == EncodingType.Map)
{
return(SerializableType.CreateDescribedMapType(this, type, baseType, descriptorName,
descriptorCode, members, knownTypes, onDeserialized));
}
else
{
throw new NotSupportedException(contractAttribute.Encoding.ToString());
}
}
private static bool IsKnownType(KnownTypeAttribute attribute, string discriminator)
{
var type = attribute.Type;
return(type != null && GetSchemaName(type) == discriminator);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
// Load JObject from stream
JObject jObject = JObject.Load(reader);
// Create target object based on JObject
System.Attribute[] attrs = System.Attribute.GetCustomAttributes(objectType); // Reflection.
// Displaying output.
foreach (System.Attribute attr in attrs)
{
if (attr is KnownTypeAttribute)
{
KnownTypeAttribute k = (KnownTypeAttribute)attr;
var props = k.Type.GetProperties();
bool found = true;
foreach (var f in jObject)
{
if (props.Any(z => z.Name.Equals("UnreadCount")) && f.Key.Equals("unread_count"))
{
object target = null;
target = Activator.CreateInstance(typeof(Chats));
serializer.Populate(jObject.CreateReader(), target);
return(target);
}
if (props.Any(z => z.Name.Equals("Token")) && f.Key.Equals("token"))
{
object target = null;
target = Activator.CreateInstance(typeof(UserData));
serializer.Populate(jObject.CreateReader(), target);
return(target);
}
if (props.Any(z => z.Name.Equals("PopupId")) && f.Key.Equals("popup_id"))
{
object target = null;
target = Activator.CreateInstance(typeof(CheckBonusResponse));
serializer.Populate(jObject.CreateReader(), target);
return(target);
}
if (props.Any(z => z.Name.Equals("Type")) && f.Key.Equals("type") && f.Value.ToObject <string>().Equals("product"))
{
object target = null;
target = Activator.CreateInstance(typeof(Product));
serializer.Populate(jObject.CreateReader(), target);
return(target);
}
if (props.Any(z => z.Name.Equals("Chats")) && f.Key.Equals("chats"))
{
object target = null;
target = Activator.CreateInstance(typeof(Counters));
serializer.Populate(jObject.CreateReader(), target);
return(target);
}
if (props.Any(z => z.Name.Equals("Height")) && f.Key.Equals("height"))
{
object target = null;
target = Activator.CreateInstance(typeof(ImageResponse));
serializer.Populate(jObject.CreateReader(), target);
return(target);
}
if (props.Any(z => z.Name.Equals("SlugSeo")) && f.Key.Equals("slug_seo"))
{
object target = null;
target = Activator.CreateInstance(typeof(Categorys));
serializer.Populate(jObject.CreateReader(), target);
return(target);
}
}
}
}
throw new NotSupportedException();
}
public void FillFromAttribute(Model model, Describer describer, KnownTypeAttribute attr)
{
MethodName = attr.MethodName;
Type = describer.GetTypeRefAddOutlineToModel(model, attr.Type);
}
public KnownTypeItem(Model model, Describer describer, KnownTypeAttribute attr)
{
FillFromAttribute(model, describer, attr);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (reader.TokenType == JsonToken.Null)
{
return(Variant.FromObject(null));
}
if (reader.TokenType != JsonToken.StartArray)
{
throw new Exception("Invalid JSON for Variant type");
}
var codeValue = reader.ReadAsInt32();
Debug.Assert(codeValue != null, "codeValue != null");
var typeCode = (TypeEnum)(byte)codeValue;
TypeEnum subTypeCode = TypeEnum.None;
if (typeCode == TypeEnum.Array)
{
var subTypeCodeValue = reader.ReadAsInt32();
Debug.Assert(subTypeCodeValue != null, "subTypeCodeValue != null");
subTypeCode = (TypeEnum)(byte)subTypeCodeValue;
if (subTypeCode == TypeEnum.FixedBinary)
{
throw new NotImplementedException("Need special handling of fixed binary values");
}
}
if (typeCode == TypeEnum.FixedBinary)
{
//var size = reader.ReadAsInt32();
throw new NotImplementedException("Need special handling of fixed binary values");
}
object obj;
if (typeCode == TypeEnum.Object)
{
var objectTypeCodeValue = reader.ReadAsInt32();
Debug.Assert(objectTypeCodeValue != null, "objectTypeCodeValue != null");
var objectTypeCode = (byte)objectTypeCodeValue;
var type = KnownTypeAttribute.GetType(objectTypeCode);
if (!reader.Read())
{
throw new Exception("Cannot read JSON");
}
obj = serializer.Deserialize(reader, type);
}
else if (typeCode != TypeEnum.None)
{
if (!reader.Read())
{
throw new Exception("Cannot read JSON");
}
var type = VariantHelper.GetType(typeCode, subTypeCode);
obj = serializer.Deserialize(reader, type);
}
else
{
obj = Variant.Create(null);
}
if (!reader.Read())
{
throw new Exception("Cannot read JSON");
}
Trace.Assert(reader.TokenType == JsonToken.EndArray);
return(Variant.FromObject(obj));
}
private SerializableType CompileType(Type type, bool describedOnly)
{
int valueOrDefault;
object[] customAttributes = type.GetCustomAttributes(typeof(AmqpContractAttribute), false);
if ((int)customAttributes.Length == 0)
{
if (describedOnly)
{
return(null);
}
return(this.CompileNonContractTypes(type));
}
AmqpContractAttribute amqpContractAttribute = (AmqpContractAttribute)customAttributes[0];
SerializableType serializableType = null;
if (type.BaseType != typeof(object))
{
serializableType = this.CompileType(type.BaseType, true);
if (serializableType != null)
{
if (serializableType.Encoding != amqpContractAttribute.Encoding)
{
throw new SerializationException(SRAmqp.AmqpEncodingTypeMismatch(type.Name, amqpContractAttribute.Encoding, type.BaseType.Name, serializableType.Encoding));
}
this.customTypeCache.TryAdd(type.BaseType, serializableType);
}
}
string name = amqpContractAttribute.Name;
ulong? internalCode = amqpContractAttribute.InternalCode;
if (name == null && !internalCode.HasValue)
{
name = type.FullName;
}
List <SerialiableMember> serialiableMembers = new List <SerialiableMember>();
if (amqpContractAttribute.Encoding == EncodingType.List && serializableType != null)
{
serialiableMembers.AddRange(serializableType.Members);
}
int count = serialiableMembers.Count + 1;
MemberInfo[] members = type.GetMembers(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
MethodAccessor methodAccessor = null;
MemberInfo[] memberInfoArray = members;
for (int i = 0; i < (int)memberInfoArray.Length; i++)
{
MemberInfo memberInfo = memberInfoArray[i];
if (memberInfo.DeclaringType == type)
{
if (memberInfo.MemberType == MemberTypes.Field || memberInfo.MemberType == MemberTypes.Property)
{
object[] objArray = memberInfo.GetCustomAttributes(typeof(AmqpMemberAttribute), true);
if ((int)objArray.Length == 1)
{
AmqpMemberAttribute amqpMemberAttribute = (AmqpMemberAttribute)objArray[0];
SerialiableMember serialiableMember = new SerialiableMember()
{
Name = amqpMemberAttribute.Name ?? memberInfo.Name
};
SerialiableMember serialiableMember1 = serialiableMember;
int?internalOrder = amqpMemberAttribute.InternalOrder;
if (internalOrder.HasValue)
{
valueOrDefault = internalOrder.GetValueOrDefault();
}
else
{
valueOrDefault = count;
count = valueOrDefault + 1;
}
serialiableMember1.Order = valueOrDefault;
serialiableMember.Mandatory = amqpMemberAttribute.Mandatory;
serialiableMember.Accessor = MemberAccessor.Create(memberInfo, true);
serialiableMember.Type = this.GetType((memberInfo.MemberType == MemberTypes.Field ? ((FieldInfo)memberInfo).FieldType : ((PropertyInfo)memberInfo).PropertyType));
serialiableMembers.Add(serialiableMember);
}
}
else if (memberInfo.MemberType == MemberTypes.Method && (int)memberInfo.GetCustomAttributes(typeof(OnDeserializedAttribute), false).Length == 1)
{
methodAccessor = MethodAccessor.Create((MethodInfo)memberInfo);
}
}
}
if (amqpContractAttribute.Encoding == EncodingType.List)
{
serialiableMembers.Sort(AmqpContractSerializer.MemberOrderComparer.Instance);
int order = -1;
foreach (SerialiableMember serialiableMember2 in serialiableMembers)
{
if (order > 0 && serialiableMember2.Order == order)
{
throw new SerializationException(SRAmqp.AmqpDuplicateMemberOrder(order, type.Name));
}
order = serialiableMember2.Order;
}
}
SerialiableMember[] array = serialiableMembers.ToArray();
Dictionary <Type, SerializableType> types = null;
object[] customAttributes1 = type.GetCustomAttributes(typeof(KnownTypeAttribute), false);
for (int j = 0; j < (int)customAttributes1.Length; j++)
{
KnownTypeAttribute knownTypeAttribute = (KnownTypeAttribute)customAttributes1[j];
if ((int)knownTypeAttribute.Type.GetCustomAttributes(typeof(AmqpContractAttribute), false).Length > 0)
{
if (types == null)
{
types = new Dictionary <Type, SerializableType>();
}
types.Add(knownTypeAttribute.Type, null);
}
}
if (amqpContractAttribute.Encoding == EncodingType.List)
{
return(SerializableType.CreateDescribedListType(this, type, serializableType, name, internalCode, array, types, methodAccessor));
}
if (amqpContractAttribute.Encoding != EncodingType.Map)
{
throw new NotSupportedException(amqpContractAttribute.Encoding.ToString());
}
return(SerializableType.CreateDescribedMapType(this, type, serializableType, name, internalCode, array, types, methodAccessor));
}
