/// <summary>
/// Attaches an <see cref="AnnotationsContext" /> of type <typeparamref name="TContext" />
/// using a converter of type <typeparamref name="TConverter" />.
/// </summary>
/// <param name="graphClient">The graph client.</param>
/// <param name="entityService">
/// The service that provides entity information. Ideally, only one instance of <see cref="EntityService" /> should
/// exist.
/// This parameter is optional and can be null, however, you can get a new instance from
/// <see cref="AnnotationsContext.CreateNewEntityService" />.
/// </param>
/// <returns></returns>
public static IGraphClient WithAnnotationsConverter <TContext, TConverter>
(this IGraphClient graphClient, EntityService entityService)
where TContext : AnnotationsContext
where TConverter : EntityConverter, new()
{
return(WithAnnotationsConverter <TContext, TConverter>(graphClient, entityService, out var context));
}
/// <summary>
/// Attaches an <see cref="AnnotationsContext" /> of type <typeparamref name="TContext" />
/// using a converter of type <typeparamref name="TConverter" />.
/// </summary>
/// <param name="graphClient">The graph client.</param>
/// <param name="entityService">
/// The service that provides entity information. Ideally, only one instance of <see cref="EntityService" /> should
/// exist.
/// This parameter is optional and can be null, however, you can get a new instance from
/// <see cref="AnnotationsContext.CreateNewEntityService" />.
/// </param>
/// <param name="context">The newly created <typeparamref name="TContext" />.</param>
/// <returns></returns>
public static IGraphClient WithAnnotationsConverter <TContext, TConverter>
(this IGraphClient graphClient, EntityService entityService, out TContext context)
where TContext : AnnotationsContext
where TConverter : EntityConverter, new()
{
return(SharedWithAnnotations <TContext, EntityResolver, TConverter>(graphClient, entityService, out context,
true));
}
protected AnnotationsContext(
IGraphClient graphClient,
EntityResolver resolver,
EntityConverter converter,
EntityService entityService)
{
GraphClient = graphClient ?? throw new ArgumentNullException(nameof(graphClient));
if (entityService == null)
{
entityService = DefaultEntityService;
}
EntityService = entityService ?? throw new ArgumentNullException(nameof(entityService));
EntityResolver = resolver;
EntityConverter = EntityResolver == null ? converter : null;
if (EntityResolver == null && EntityConverter == null)
{
EntityResolver = new EntityResolver(); //use resolver by default
}
Init();
}
public EntitySet(EntityService entityService)
{
EntityService = entityService ?? throw new ArgumentNullException(nameof(entityService));
entityService.AddEntityType(typeof(T));
}
public AnnotationsContext(IGraphClient graphClient, EntityConverter converter, EntityService entityService)
: this(graphClient, null, converter, entityService)
{
}
public AnnotationsContext(IGraphClient graphClient, EntityResolver resolver, EntityService entityService)
: this(graphClient, resolver, null, entityService)
{
}
public AnnotationsContext(IGraphClient graphClient, EntityService entityService)
: this(graphClient, null, null, entityService)
{
}
/// <summary>
/// Attaches an <see cref="AnnotationsContext" /> of type <typeparamref name="TContext" /> to the
/// <see cref="IGraphClient" />
/// using a resolver of type <see cref="EntityResolver" />.
/// </summary>
/// <param name="graphClient">The graph client.</param>
/// <param name="entityService">
/// The service that provides entity information. Ideally, only one instance of <see cref="EntityService" /> should
/// exist.
/// This parameter is optional and can be null, however, you can get a new instance from
/// <see cref="AnnotationsContext.CreateNewEntityService" />.
/// </param>
/// <returns></returns>
public static IGraphClient WithAnnotations <TContext>(this IGraphClient graphClient, EntityService entityService)
where TContext : AnnotationsContext
{
return(WithAnnotations <TContext, EntityResolver>(graphClient, entityService));
}
/// <summary>
/// Attaches an <see cref="AnnotationsContext" /> of type <see cref="AnnotationsContext" /> to the
/// <see cref="IGraphClient" />
/// using a resolver of type <see cref="EntityResolver" />.
/// </summary>
/// <param name="graphClient">The graph client.</param>
/// <param name="entityService">
/// The service that provides entity information. Ideally, only one instance of <see cref="EntityService" /> should
/// exist.
/// This parameter is optional and can be null, however, you can get a new instance from
/// <see cref="AnnotationsContext.CreateNewEntityService" />.
/// </param>
/// <returns></returns>
public static IGraphClient WithAnnotations(this IGraphClient graphClient, EntityService entityService)
{
return(WithAnnotations <AnnotationsContext>(graphClient, entityService));
}
internal static IGraphClient SharedWithAnnotations <TContext, TResolver, TConverter>
(this IGraphClient graphClient, EntityService entityService, out TContext context, bool useConverter)
where TContext : AnnotationsContext
where TResolver : EntityResolver, new()
where TConverter : EntityConverter, new()
{
if (graphClient == null)
{
throw new ArgumentNullException(nameof(graphClient));
}
context = graphClient.GetAnnotationsContext() as TContext;
if (context != null &&
(!useConverter
? context.EntityResolver?.GetType() == typeof(TResolver)
: context.EntityConverter?.GetType() == typeof(TConverter)) &&
(entityService == null || context.EntityService.GetType() == entityService.GetType()))
{
//already attached
return(graphClient);
}
TResolver resolver = null;
TConverter converter = null;
if (!useConverter)
{
resolver = new TResolver();
}
else
{
converter = new TConverter();
}
var resolverConverterObj = resolver ?? (object)converter;
//find best constructor
var parameters = new[] { graphClient, resolverConverterObj, entityService }.Where(p => p != null).ToArray();
var flags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
var orderedConstructors = typeof(TContext).GetConstructors(flags)
.OrderByDescending(c => c.GetParameters().Length)
.Select(c => new
{
ctor = c,
validParams = c.GetParameters().Select(p => parameters.FirstOrDefault
(ip => p.ParameterType.IsAssignableFrom(ip.GetType())))
.ToArray()
})
.OrderBy(nc => nc.validParams.Count(p => p == null))
.ToArray();
if (orderedConstructors?.Length > 0)
{
//find a constructor willing to create a valid instance with the available parameters
foreach (var octor in orderedConstructors)
{
try
{
context = octor.ctor.Invoke(octor.validParams) as TContext;
break;
}
catch
{
}
}
}
if (context == null)
{
throw new InvalidOperationException(string.Format(Messages.NoValidConstructorError,
typeof(TContext).Name));
}
return(graphClient);
}