private void CompleteResolverTypeBindings(
ITypeInspector inspector,
INamingConventions naming)
{
foreach (ResolverTypeBindingInfo binding in
_bindings.OfType <ResolverTypeBindingInfo>()
.ToList())
{
ComplexTypeBindingInfo typeBinding = null;
if (binding.SourceType == null)
{
binding.SourceType = typeof(object);
}
if (binding.SourceType != null && binding.TypeName.IsEmpty)
{
typeBinding = _bindings.OfType <ComplexTypeBindingInfo>()
.FirstOrDefault(t => t.Type == binding.SourceType);
if (typeBinding == null)
{
binding.TypeName = naming.GetTypeName(
binding.SourceType, TypeKind.Object);
}
else
{
binding.TypeName = typeBinding.Name;
}
}
typeBinding = _bindings.OfType <ComplexTypeBindingInfo>()
.FirstOrDefault(t => t.Name.Equals(binding.TypeName));
if (typeBinding == null)
{
_bindings.Add(new ComplexTypeBindingInfo
{
Name = binding.TypeName,
Type = binding.SourceType
});
}
else if (binding.SourceType == typeof(object))
{
binding.SourceType = typeBinding.Type;
}
foreach (ResolverFieldBindingInfo field in binding.Fields)
{
if (field.FieldName.IsEmpty)
{
field.FieldName = naming.GetMemberName(
field.FieldMember, MemberKind.ObjectField);
}
}
if (binding.BindingBehavior == BindingBehavior.Implicit)
{
AddImplicitResolverBindings(inspector, naming, binding);
}
}
}
private static void RegisterFields(
ComplexTypeBindingInfo binding,
Dictionary <NameString, RegisteredResolver> registerdResolvers,
Dictionary <NameString, MemberInfo> members)
{
foreach (ComplexTypeFieldBindingInfo field in binding.Fields)
{
if (!members.ContainsKey(field.Name) &&
!members.ContainsValue(field.Member))
{
members.Add(field.Name, field.Member);
if (!registerdResolvers.ContainsKey(field.Name))
{
registerdResolvers.Add(field.Name,
new RegisteredResolver(
binding.Type,
new FieldMember(
binding.Name,
field.Name,
field.Member)));
}
}
}
}
private TypeBindingInfo CreateTypeBindingInfo(
IDescriptorContext context,
ComplexTypeBindingInfo binding)
{
var registerdResolvers =
new Dictionary <NameString, RegisteredResolver>();
var members = new Dictionary <NameString, MemberInfo>();
RegisterResolvers(binding, registerdResolvers);
foreach (ResolverTypeBindingInfo resolverBinding in
_bindings.OfType <ResolverTypeBindingInfo>()
.Where(t => t.TypeName.Equals(binding.Name)))
{
RegisterResolverFields(
binding.Name, resolverBinding,
registerdResolvers, members);
}
RegisterFields(binding, registerdResolvers, members);
return(new TypeBindingInfo(
context,
binding.Name,
binding.Type,
binding.BindingBehavior,
registerdResolvers,
members));
}
private void CompleteResolverBindings(INamingConventions naming)
{
foreach (ResolverBindingInfo binding in
_bindings.OfType <ResolverBindingInfo>()
.ToList())
{
if (binding.TypeName.IsEmpty)
{
ComplexTypeBindingInfo typeBinding =
_bindings.OfType <ComplexTypeBindingInfo>()
.FirstOrDefault(t => t.Type == binding.SourceType);
binding.TypeName = typeBinding == null
? naming.GetTypeName(binding.SourceType)
: typeBinding.Name;
}
if (binding.FieldName.IsEmpty)
{
binding.FieldName = naming.GetMemberName(
binding.Member, MemberKind.ObjectField);
}
if (!_bindings.OfType <ComplexTypeBindingInfo>()
.Any(t => t.Name.Equals(binding.TypeName)))
{
_bindings.Add(new ComplexTypeBindingInfo
{
Name = binding.TypeName,
Type = binding.SourceType
});
}
}
}
private void RegisterResolvers(
ComplexTypeBindingInfo binding,
IDictionary <NameString, RegisteredResolver> registerdResolvers)
{
foreach (ResolverBindingInfo resolver in
_bindings.OfType <ResolverBindingInfo>()
.Where(t => t.TypeName.Equals(binding.Name)))
{
if (!registerdResolvers.ContainsKey(resolver.FieldName))
{
registerdResolvers.Add(resolver.FieldName,
new RegisteredResolver(
binding.Type ?? typeof(object),
new FieldResolver(
binding.Name,
resolver.FieldName,
resolver.Resolver)));
}
}
}
