public IObjectFieldDescriptor Field(NameString name)
{
var fieldDescriptor = new ObjectFieldDescriptor(Context, name);
Fields.Add(fieldDescriptor);
return(fieldDescriptor);
}
protected ObjectTypeDescriptor(
IDescriptorContext context,
ObjectTypeDefinition definition)
: base(context)
{
Definition = definition ?? throw new ArgumentNullException(nameof(definition));
foreach (var field in definition.Fields)
{
Fields.Add(ObjectFieldDescriptor.From(Context, field));
}
}
protected override void OnCompleteFields(
IDictionary <NameString, ObjectFieldDefinition> fields,
ISet <MemberInfo> handledMembers)
{
HashSet <string> subscribeResolver = null;
if (Definition.Fields.IsImplicitBinding())
{
FieldDescriptorUtilities.AddImplicitFields(
this,
Definition.FieldBindingType,
p =>
{
var descriptor = ObjectFieldDescriptor.New(
Context, p, Definition.RuntimeType, Definition.FieldBindingType);
Fields.Add(descriptor);
return(descriptor.CreateDefinition());
},
fields,
handledMembers,
include: IncludeField);
}
base.OnCompleteFields(fields, handledMembers);
bool IncludeField(IReadOnlyList <MemberInfo> all, MemberInfo current)
{
if (subscribeResolver is null)
{
subscribeResolver = new HashSet <string>();
foreach (MemberInfo member in all)
{
if (member.IsDefined(typeof(SubscribeAttribute)))
{
SubscribeAttribute attribute =
member.GetCustomAttribute <SubscribeAttribute>();
if (attribute.With is not null)
{
subscribeResolver.Add(attribute.With);
}
}
}
}
return(!subscribeResolver.Contains(current.Name));
}
}
protected override void OnCompleteFields(
IDictionary <NameString, ObjectFieldDefinition> fields,
ISet <MemberInfo> handledMembers)
{
if (Definition.Fields.IsImplicitBinding())
{
FieldDescriptorUtilities.AddImplicitFields(
this,
p => ObjectFieldDescriptor
.New(Context, p)
.CreateDefinition(),
fields,
handledMembers);
}
base.OnCompleteFields(fields, handledMembers);
}
private void AddResolvers(
IDictionary <NameString, ObjectFieldDefinition> fields,
ISet <string> processed,
Type sourceType,
Type resolverType)
{
foreach (MemberInfo member in Context.TypeInspector.GetMembers(resolverType))
{
if (IsResolverRelevant(sourceType, member))
{
ObjectFieldDefinition fieldDefinition =
ObjectFieldDescriptor
.New(Context, member, sourceType, resolverType)
.CreateDefinition();
if (processed.Add(fieldDefinition.Name))
{
fields[fieldDefinition.Name] = fieldDefinition;
}
}
}
}
public IObjectFieldDescriptor Field <TResolver, TPropertyType>(
Expression <Func <TResolver, TPropertyType> > propertyOrMethod)
{
if (propertyOrMethod == null)
{
throw new ArgumentNullException(nameof(propertyOrMethod));
}
MemberInfo member = propertyOrMethod.ExtractMember();
if (member is PropertyInfo || member is MethodInfo)
{
var fieldDescriptor = new ObjectFieldDescriptor(
Context, member, typeof(TResolver));
Fields.Add(fieldDescriptor);
return(fieldDescriptor);
}
throw new ArgumentException(
TypeResources.ObjectTypeDescriptor_MustBePropertyOrMethod,
nameof(member));
}
public IObjectFieldDescriptor Field <TResolver>(
Expression <Func <TResolver, object> > propertyOrMethod)
{
if (propertyOrMethod == null)
{
throw new ArgumentNullException(nameof(propertyOrMethod));
}
MemberInfo member = propertyOrMethod.ExtractMember();
if (member is PropertyInfo || member is MethodInfo)
{
var fieldDescriptor = new ObjectFieldDescriptor(
Context, member, typeof(TResolver));
Fields.Add(fieldDescriptor);
return(fieldDescriptor);
}
// TODO : resources
throw new ArgumentException(
"A field of an entity can only be a property or a method.",
nameof(member));
}
public IObjectFieldDescriptor Field(NameString name)
{
ObjectFieldDescriptor fieldDescriptor =
Fields.FirstOrDefault(t => t.Definition.Name.Equals(name));
if (fieldDescriptor is { })
protected override void OnCompleteFields(
IDictionary <NameString, ObjectFieldDefinition> fields,
ISet <MemberInfo> handledMembers)
{
HashSet <string> subscribeResolver = null;
if (Definition.Fields.IsImplicitBinding() &&
Definition.FieldBindingType is not null)
{
FieldDescriptorUtilities.AddImplicitFields(
this,
Definition.FieldBindingType,
p =>
{
var descriptor = ObjectFieldDescriptor.New(
Context, p, Definition.RuntimeType, Definition.FieldBindingType);
if (Definition.IsExtension && Context.TypeInspector.IsMemberIgnored(p))
{
descriptor.Ignore();
}
Fields.Add(descriptor);
return(descriptor.CreateDefinition());
},
fields,
handledMembers,
include: IncludeField,
includeIgnoredMembers
: Definition.IsExtension);
}
base.OnCompleteFields(fields, handledMembers);
bool IncludeField(IReadOnlyList <MemberInfo> all, MemberInfo current)
{
NameString name = Context.Naming.GetMemberName(current, MemberKind.ObjectField);
if (Fields.Any(t => t.Definition.Name.Equals(name)))
{
return(false);
}
if (subscribeResolver is null)
{
subscribeResolver = new HashSet <string>();
foreach (MemberInfo member in all)
{
HandlePossibleSubscribeMember(member);
}
}
return(!subscribeResolver.Contains(current.Name));
}
void HandlePossibleSubscribeMember(MemberInfo member)
{
if (member.IsDefined(typeof(SubscribeAttribute)))
{
if (member.GetCustomAttribute <SubscribeAttribute>() is { With : not null } attr)
{
subscribeResolver.Add(attr.With);
}
}
}
}
public static ObjectFieldDescriptor ToDescriptor(
this ObjectFieldDefinition definition,
IDescriptorContext context)
=> ObjectFieldDescriptor.From(context, definition);
