private static IRegistrationBuilder<object, IConcreteActivatorData, SingleRegistrationStyle> ApplyResolver(ContainerBuilder builder, DynamicResolver resolver)
{
return builder.Register(ctx => resolver.FactoryFunc());
}
private static ComponentRegistration<object> ApplyResolver(ComponentRegistration<object> registration, DynamicResolver resolver)
{
return registration.UsingFactoryMethod(resolver.FactoryFunc);
}
ConstraintsViolationException ValidateObjectField(string key,
object value,
State state,
JsonSchemaRegistory reg)
{
var matched = false;
if (_schema._dynamicResolverTag != null)
{
Type dynElemType;
if (DynamicResolver.Find(_schema._dynamicResolverTag, key, out dynElemType))
{
var dynElemSchema = JsonSchemaAttribute.CreateFromType(dynElemType, reg, true);
var ex = dynElemSchema.Validate(value, state, reg);
if (ex != null)
{
return(new ConstraintsViolationException("DynamicResolver", ex));
}
}
}
if (_schema.Properties != null)
{
JsonSchemaAttribute itemSchema = null;
if (_schema.Properties.TryGetValue(key, out itemSchema))
{
matched = true;
var ex = itemSchema.Validate(value, state, reg);
if (ex != null)
{
return(new ConstraintsViolationException("Property", ex));
}
}
}
if (_schema.PatternProperties != null)
{
foreach (var pprop in _schema.PatternProperties)
{
if (Regex.IsMatch(key, pprop.Key))
{
matched = true;
var ex = pprop.Value.Validate(value, state, reg);
if (ex != null)
{
return(new ConstraintsViolationException("PatternProperties", ex));
}
}
}
}
if (_schema.AdditionalProperties != null && !matched)
{
var ex = _schema.AdditionalProperties.Validate(value, state, reg);
if (ex != null)
{
return(new ConstraintsViolationException("AdditionalProperties", ex));
}
}
return(null);
}
public void Register <T>(Func <T> builder)
{
_bindings[typeof(T)] = new DynamicResolver <T>(builder);
}
static Resolver()
{
// A example for registration of resolvers!
DynamicResolver.Register <Resolver>("a", typeof(SomeObject));
}
private static LambdaInstance<object> ApplyResolver(GenericFamilyExpression builder, DynamicResolver resolver)
{
return builder.Add(c => resolver.FactoryFunc());
}
static Resolver()
{
// A example for registration of resolvers
DynamicResolver.Register <Resolver>("b", typeof(int));
}
private static ComponentRegistration <object> ApplyResolver(ComponentRegistration <object> registration, DynamicResolver resolver)
{
return(registration.UsingFactoryMethod(resolver.FactoryFunc));
}
public static void RegisterExtension(string name, Type type)
{
DynamicResolver.Register <ExtensionsResolverTag>(name, type);
}
private bool Update2(PermissionSetTriple currentTriple, FrameSecurityDescriptorWithResolver fsdWithResolver)
{
DynamicResolver resolver = fsdWithResolver.Resolver;
CompressedStack securityContext = resolver.GetSecurityContext();
securityContext.CompleteConstruction(null);
return(this.Update(currentTriple, securityContext.PLS));
}
private static bool CheckDynamicMethodHelper(DynamicResolver dynamicResolver, IPermission demandIn, PermissionToken permToken, RuntimeMethodHandleInternal rmh)
{
CompressedStack securityContext = dynamicResolver.GetSecurityContext();
try
{
return(securityContext.CheckDemandNoHalt((CodeAccessPermission)demandIn, permToken, rmh));
}
catch (SecurityException ex)
{
throw new SecurityException(Environment.GetResourceString("Security_AnonymouslyHostedDynamicMethodCheckFailed"), (Exception)ex);
}
}
private static bool CheckDynamicMethodSetHelper(DynamicResolver dynamicResolver, PermissionSet demandSet, out PermissionSet alteredDemandSet, RuntimeMethodHandleInternal rmh)
{
CompressedStack securityContext = dynamicResolver.GetSecurityContext();
try
{
return(securityContext.CheckSetDemandWithModificationNoHalt(demandSet, out alteredDemandSet, rmh));
}
catch (SecurityException ex)
{
throw new SecurityException(Environment.GetResourceString("Security_AnonymouslyHostedDynamicMethodCheckFailed"), (Exception)ex);
}
}
public void PassTest()
{
Type ty;
Assert.False(DynamicResolver.Find <Tag>("a", out ty));
DynamicResolver.Register <Tag>("a", typeof(int));
DynamicResolver.Register <Tag>("b", typeof(string));
Assert.True(DynamicResolver.Find <Tag>("a", out ty));
Assert.True(DynamicResolver.Find <Tag>("b", out ty));
Assert.False(DynamicResolver.Find <Tag>("c", out ty));
DynamicResolver.DeRegister <Tag>("b");
Assert.True(DynamicResolver.Find <Tag>("a", out ty));
Assert.False(DynamicResolver.Find <Tag>("b", out ty)); // "b" is unregisterd
DynamicResolver.DeRegister <Tag>();
Assert.False(DynamicResolver.Find <Tag>("a", out ty)); // All keys for Tag are unregisterd
}
