public void TestMethodInClass()
{
var info = new AssemblyBrowserLib.TypeInfo(typeof(Class3));
var methodInfo = new TypeMemberInfo(typeof(Class3).GetMember("DoSmt")[0]);
Assert.AreEqual(info.Members[0].Info, methodInfo.Info);
}
protected virtual void SerializeElement(XmlWriter writer, object obj, TypeMemberInfo element)
{
object entityValue = GetEntityValue(obj, element);
if (Settings.OmitMembersWithDefaultValues)
{
if (element.HasDefaultValue(entityValue))
{
return;
}
}
writer.WriteStartElement(element.EntityName);
// now we resolve a type serializer to do the work
ITypeSerializer typeSerializer =
Factory.CallMethod(new[] { element.DataType }, "GetTypeSerializer") as ITypeSerializer;
if (typeSerializer != null)
{
typeSerializer.Serialize(writer, element.DataType, entityValue);
}
else
// Since there was no bound custom type serializer we default to the GenericTypeSerializer
{
var defaultSerializer = Factory.GetDefaultSerializer();
defaultSerializer.Serialize(writer, element.DataType, entityValue);
}
writer.WriteEndElement();
}
public void Map(ref object local, DiffPart diff, MapContext context)
{
if (context.Path.Count == 0)
{
local = diff.DiffType == DiffPartType.Exclude ? TypeHelpers.CreateDefaultState(context.Type) : diff.Value;
}
else
{
var member = TypeMemberInfo.GetPublicMember(local.GetType(), context.Path.Pop() as string);
var fi = member as FieldInfo;
if (fi != null)
{
object fieldLocal = fi.GetValue(local);
Type type = (fieldLocal == null) ? fi.FieldType : fieldLocal.GetType();
if (diff.DiffType == DiffPartType.Exclude)
{
if (context.Path.Count == 0)
{
fi.SetValue(local, TypeHelpers.CreateDefaultState(type));
}
else
{
context.Resolvers.FindResolver(type).Map(ref fieldLocal, diff, new MapContext(context, type));
// fi.SetValue(local, fieldLocal);
}
}
else
{
context.Resolvers.FindResolver(type).Map(ref fieldLocal, diff, new MapContext(context, type));
fi.SetValue(local, fieldLocal);
}
}
var pi = member as PropertyInfo;
if (pi != null)
{
object propertyLocal = pi.GetValue(local);
Type type = (propertyLocal == null) ? pi.PropertyType : propertyLocal.GetType();
if (diff.DiffType == DiffPartType.Exclude)
{
if (context.Path.Count == 0)
{
pi.SetValue(local, TypeHelpers.CreateDefaultState(pi.PropertyType));
}
else
{
context.Resolvers.FindResolver(type).Map(ref propertyLocal, diff, new MapContext(context, type));
// pi.SetValue(local, propertyLocal);
}
}
else
{
context.Resolvers.FindResolver(type).Map(ref propertyLocal, diff, new MapContext(context, type));
pi.SetValue(local, propertyLocal);
}
}
}
}
public static MemberInfo getInfo(TypeInfo type) {
var result = type.getUserData(typeof(TypeMemberInfo));
if (result == null) {
result = new TypeMemberInfo(type);
type.addUserData(result);
}
return result;
}
public void SetWorkingMember(TypeMemberInfo member)
{
if (member == null)
{
throw new ArgumentNullException("member");
}
CaptureStack.Peek().CurrentMember = member;
}
protected override object GetEntityValue(object entity, TypeMemberInfo memberInfo)
{
var result = base.GetEntityValue(entity, memberInfo);
if (memberInfo.Name == "<Name>k__BackingField")
{
result = string.Format("{0} {1}", Title, result);
}
return(result);
}
public static MemberInfo getInfo(TypeInfo type)
{
var result = type.getUserData(typeof(TypeMemberInfo));
if (result == null)
{
result = new TypeMemberInfo(type);
type.addUserData(result);
}
return(result);
}
public DiffChain Resolve(object local, object remote, ResolveContext context)
{
if (local == null && remote == null)
{
return(DiffChain.Empty());
}
IEnumerable <MemberInfo> members = TypeMemberInfo.GetAllPublicMembers(context.Type);
var result = new DiffChain();
if (local == null)
{
result.Add(context.CreateDiffFromCurrentPath(remote));
}
else if (remote == null)
{
result.Add(context.CreateDiffFromCurrentPath());
}
else
{
foreach (var member in members)
{
if (IgnoreMembersLogic.IgnoredByAttribute(context.Options, member))
{
continue;
}
var fi = member as FieldInfo;
if (fi != null)
{
var fieldLocal = fi.GetValue(local);
var fieldRemote = fi.GetValue(remote);
var memberType = GetType(fieldLocal, fieldRemote);
if (memberType != null)
{
result.Add(context.Resolvers.FindResolver(memberType).Resolve(fieldLocal, fieldRemote, new ResolveContext(context, member.Name, memberType)));
}
continue;
}
var pi = member as PropertyInfo;
if (pi != null)
{
var propertyLocal = pi.GetValue(local);
var propertyRemote = pi.GetValue(remote);
var memberType = GetType(propertyLocal, propertyRemote);
if (memberType != null)
{
result.Add(context.Resolvers.FindResolver(memberType).Resolve(propertyLocal, propertyRemote, new ResolveContext(context, member.Name, memberType)));
}
}
}
}
result.Lock();
return(result);
}
public SameAssemblyBaseEnumState(INamedTypeSymbol type, ITypeSymbol keyType)
{
_type = type;
TypeFullyQualified = type.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
TypeMinimallyQualified = type.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat);
Settings = new EnumSettings(type.FindEnumGenerationAttribute());
InnerTypesInfo = new TypeMemberInfo(type);
ConstructorArguments = GetConstructorArguments(type, Settings.CreateKeyProperty(keyType));
Items = type.EnumerateEnumItems().Select(InstanceMemberInfo.CreateFrom).ToList();
}
public BaseEnumState(INamedTypeSymbol type)
{
_type = type;
TypeFullyQualified = type.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
TypeMinimallyQualified = type.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat);
Settings = new EnumSettings(type.FindEnumGenerationAttribute());
InnerTypesInfo = new TypeMemberInfo(type);
ConstructorArguments = GetConstructorArguments(type);
Items = _type.EnumerateEnumItems().Select(DefaultMemberState.CreateFrom).ToList();
}
public void CaptureLateBinding(int id, TypeMemberInfo info)
{
if (id == 0)
{
throw new ArgumentNullException("id");
}
if (info == null)
{
throw new ArgumentNullException("info");
}
CaptureStack.Peek().CaptureNodes.Add(new CaptureNode(id, info));
}
protected virtual object GetEntityValue(object entity, TypeMemberInfo memberInfo)
{
entity = entity.WrapIfValueType();
switch (memberInfo.Type)
{
case TypeMemberInfo.MemberType.Field:
return(entity.GetFieldValue(memberInfo.Name));
case TypeMemberInfo.MemberType.Property:
return(entity.GetPropertyValue(memberInfo.Name));
default:
throw new SerializerException("Cannot serialize unknown member type");
}
}
public GetTypeResponseMessage GetTypeInfo()
{
var msg = new GetTypeResponseMessage {
IndexerLength = this.target.Length,
Members = new List<TypeMemberInfo>()
};
var tmi = new TypeMemberInfo {
Name = "length",
//MemberId = this.target.Length,
DispatchType = DispatchType.PropertyGet
};
msg.Members.Add(tmi);
return msg;
}
public static MemberInfoModel ConvertFrom(TypeMemberInfo member)
{
return(new MemberInfoModel
{
Id = member.ID,
Name = member.Name,
Value = member.Value,
Comment = member.Comment,
Tags = member.Tags.ToString(),
DerivedTags = member.DerivedTags.ToString(),
IsEnabled = member.IsEnabled,
Creator = member.CreationInfo.ID,
CreatedDateTime = member.CreationInfo.DateTime,
Modifier = member.ModificationInfo.ID,
ModifiedDateTime = member.ModificationInfo.DateTime
});
}
private IDictionary <string, object> GetMemberInfo(TypeMemberInfo memberInfo)
{
var props = new Dictionary <string, object>
{
{ nameof(memberInfo.ID), memberInfo.ID },
{ nameof(memberInfo.Name), memberInfo.Name },
{ nameof(memberInfo.Value), memberInfo.Value },
{ nameof(memberInfo.Comment), memberInfo.Comment },
{ nameof(memberInfo.Tags), $"{memberInfo.Tags}" },
{ nameof(memberInfo.DerivedTags), $"{memberInfo.DerivedTags}" },
{ nameof(memberInfo.IsEnabled), memberInfo.IsEnabled },
{ CremaSchema.Creator, memberInfo.CreationInfo.ID },
{ CremaSchema.CreatedDateTime, memberInfo.CreationInfo.DateTime },
{ CremaSchema.Modifier, memberInfo.ModificationInfo.ID },
{ CremaSchema.ModifiedDateTime, memberInfo.ModificationInfo.DateTime }
};
return(props);
}
public static void CreateTypeMember(CodeTypeDeclaration classType, TypeMemberInfo typeMemberInfo, CodeGenerationInfo generationInfo)
{
var cmm = new CodeMemberField();
cmm.Name = typeMemberInfo.Name;
cmm.InitExpression = new CodePrimitiveExpression(typeMemberInfo.Value);
if (generationInfo.OmitComment == false)
{
cmm.Comments.AddSummary(typeMemberInfo.Comment);
}
if (generationInfo.OmitSignatureDate == false)
{
cmm.Comments.Add(CremaCodeGenerator.Creator, typeMemberInfo.CreationInfo.ID);
cmm.Comments.Add(CremaCodeGenerator.CreatedDateTime, typeMemberInfo.CreationInfo.DateTime);
cmm.Comments.Add(CremaCodeGenerator.Modifier, typeMemberInfo.ModificationInfo.ID);
cmm.Comments.Add(CremaCodeGenerator.ModifiedDateTime, typeMemberInfo.ModificationInfo.DateTime);
}
classType.Members.Add(cmm);
}
private static void CreateDataMember(CodeTypeDeclaration classType, TypeMemberInfo typeMemberInfo, CodeGenerationInfo generationInfo)
{
var cmm = new CodeMemberField();
cmm.Name = typeMemberInfo.Name;
cmm.InitExpression = new CodeSnippetExpression(generationInfo.EnumFomrat(typeMemberInfo.Value));
if (generationInfo.NoComment == false)
{
cmm.Comments.AddSummary(typeMemberInfo.Comment);
}
if (generationInfo.NoChanges == false)
{
cmm.Comments.Add(CremaSchema.Creator, typeMemberInfo.CreationInfo.ID);
cmm.Comments.Add(CremaSchema.CreatedDateTime, typeMemberInfo.CreationInfo.DateTime);
cmm.Comments.Add(CremaSchema.Modifier, typeMemberInfo.ModificationInfo.ID);
cmm.Comments.Add(CremaSchema.ModifiedDateTime, typeMemberInfo.ModificationInfo.DateTime);
}
classType.Members.Add(cmm);
}
public void TestMethodInfo()
{
TypeMemberInfo info = new TypeMemberInfo(typeof(UnitTest1).GetMember("Method1")[0]);
Assert.AreEqual("Method Method1()", info.Info);
}
/// <summary>
/// Initializes a new instance of the <see cref="CaptureNode" /> class.
/// </summary>
/// <param name="id"></param>
/// <param name="memberInfo"></param>
/// <param name="indices"></param>
public CaptureNode(int id, TypeMemberInfo memberInfo, int[] indices)
{
Id = id;
MemberInfo = memberInfo;
Indices = indices;
}
public GetTypeResponseMessage GetTypeInfo()
{
GetTypeResponseMessage msg = new GetTypeResponseMessage {
IndexerLength = 0,
Members = new List<TypeMemberInfo>()
};
foreach (KeyValuePair<string, int> item in idsByName) {
MemberInfo mi = GetMember(item.Value);
DispatchType dt;
if (mi is MethodInfo) {
dt = DispatchType.Method;
}
else if (mi is PropertyInfo) {
dt = DispatchType.PropertyGet | DispatchType.PropertySet;
}
else {
throw new InvalidOperationException();
}
TypeMemberInfo tmi = new TypeMemberInfo {
Name = item.Key,
//MemberId = item.Value,
DispatchType = dt
};
msg.Members.Add(tmi);
}
return msg;
}
/// <summary>
/// Initializes a new instance of the <see cref="XmlNodeMap" /> class.
/// </summary>
internal XmlNodeMap(string name, TypeMemberInfo.MemberType memberType, Type dataType)
{
Info = new TypeMemberInfo(name, memberType, dataType);
}
/// <summary>
/// Initializes a new instance of the <see cref="CaptureNode" /> class.
/// </summary>
/// <param name="id"></param>
/// <param name="memberInfo"></param>
public CaptureNode(int id, TypeMemberInfo memberInfo)
{
Id = id;
MemberInfo = memberInfo;
Indices = null;
}
public void TestFieldInfo()
{
TypeMemberInfo info = new TypeMemberInfo(typeof(UnitTest1).GetField("_field1", BindingFlags.NonPublic | BindingFlags.Instance));
Assert.AreEqual("Field System.Byte _field1", info.Info);
}
public void TestPropertyInfo()
{
TypeMemberInfo info = new TypeMemberInfo(typeof(UnitTest1).GetProperty("Property1"));
Assert.AreEqual("Property System.String Property1", info.Info);
}
