public void Initialize(ExtensionConfigContext context)
{
var bindingFactory = context.Config.BindingFactory;
var converterManager = bindingFactory.ConverterManager;
converterManager.AddConverter <string, HttpRequestMessage, OutgoingHttpRequestAttribute>(
(body, attribute) => BuildHttpRequestMessage(attribute, new StringContent(body)));
converterManager.AddConverter <HttpContent, HttpRequestMessage, OutgoingHttpRequestAttribute>(
(content, attribute) => BuildHttpRequestMessage(attribute, content));
var bindingOut = bindingFactory.BindToAsyncCollector <OutgoingHttpRequestAttribute, HttpRequestMessage>((attrib, message) =>
{
if (message.RequestUri == null)
{
message.RequestUri = new Uri(attrib.Uri);
}
message.Method = new HttpMethod("POST");
return(_client.SendAsync(message));
});
var bindingClient = bindingFactory.BindToExactType <OutgoingHttpRequestAttribute, HttpClient>(attrib => _client);
var bindingProvider = bindingFactory.BindToGenericValueProvider <OutgoingHttpRequestAttribute>((attrib, paramType) =>
{
return(Task.FromResult <IValueBinder>(new TextWriterValueBinder(attrib.Uri)));
});
context.RegisterBindingRules <OutgoingHttpRequestAttribute>(bindingOut, bindingClient, bindingProvider);
}
public void Initialize(ExtensionConfigContext context)
{
var bf = context.Config.BindingFactory;
var rule = bf.BindToInput <TestAttribute, AlphaType>(typeof(AlphaBuilder));
context.RegisterBindingRules <TestAttribute>(rule);
}
public void Initialize(ExtensionConfigContext context)
{
var bf = context.Config.BindingFactory;
// Add [Test] support
var rule = bf.BindToGenericItem <TestAttribute>(Builder);
context.RegisterBindingRules <TestAttribute>(rule);
}
public void Initialize(ExtensionConfigContext context)
{
var bf = context.Config.BindingFactory;
// No explicit converters - just use implicit ones like inheritence
var rule1 = bf.BindToInput <TestAttribute, AlphaDerivedType>(typeof(GeneralBuilder <>));
var rule2 = bf.BindToInput <TestAttribute, object>(this); // 2nd rule
context.RegisterBindingRules <TestAttribute>(rule1, rule2);
}
public void Initialize(ExtensionConfigContext context)
{
var bf = context.Config.BindingFactory;
// Replaces BindToGeneric
var rule = bf.BindToInput <TestAttribute, OpenType>(typeof(GeneralBuilder <>));
context.RegisterBindingRules <TestAttribute>(rule);
}
public void Initialize(ExtensionConfigContext context)
{
var bf = context.Config.BindingFactory;
// Add [Test] support
var rule = bf.BindToExactType <TestAttribute, Widget>(attr => new Widget());
context.RegisterBindingRules <TestAttribute>(ValidateAtIndexTime, rule);
}
public void Initialize(ExtensionConfigContext context)
{
var bf = context.Config.BindingFactory;
// This is an error. The rule specifies OpenType,which allows any type.
// But the builder can only produce Alpha types.
var rule = bf.BindToInput <TestAttribute, OpenType>(typeof(AlphaBuilder));
context.RegisterBindingRules <TestAttribute>(rule);
}
public void Initialize(ExtensionConfigContext context)
{
var bf = context.Config.BindingFactory;
// Add [Test] support
var rule = bf.BindToExactType <TestAttribute, string>(attr => attr.Path);
var ruleValidate = bf.AddFilter <TestAttribute>(Filter, rule);
var rule2 = bf.BindToExactType <TestAttribute, string>(attr => "xxx");
context.RegisterBindingRules <TestAttribute>(ruleValidate, rule2);
}
public void Initialize(ExtensionConfigContext context)
{
var bf = context.Config.BindingFactory;
// Add [Test] support
var rule = bf.BindToInput <TestAttribute, string>(typeof(Converter1));
var ruleValidate = bf.AddFilter <TestAttribute>(Filter, rule);
var rule2 = bf.BindToInput <TestAttribute, string>(typeof(Converter2));
context.RegisterBindingRules <TestAttribute>(ruleValidate, rule2);
}
public void Initialize(ExtensionConfigContext context)
{
var bf = context.Config.BindingFactory;
// Add [Test] support
var rule1 = bf.BindToExactType <TestAttribute, Widget>(attr => new Widget());
var rule2 = bf.BindToExactType <TestAttribute, Widget2>(attr => new Widget2());
var rule2Validator = bf.AddValidator <TestAttribute>(LocalValidator, rule2);
context.RegisterBindingRules <TestAttribute>(rule2Validator, rule1);
}
public void Initialize(ExtensionConfigContext context)
{
var bf = context.Config.BindingFactory;
var cm = bf.ConverterManager;
cm.AddConverter <AlphaType, BetaType>(ConvertAlpha2Beta);
cm.AddConverter <BetaType, string>((beta) => $"Str({beta._value})");
var rule = bf.BindToInput <TestAttribute, AlphaType>(typeof(AlphaBuilder));
context.RegisterBindingRules <TestAttribute>(rule);
}
public void Initialize(ExtensionConfigContext context)
{
var bf = context.Config.BindingFactory;
bf.ConverterManager.AddConverter <AlphaType, BetaType>(ConvertAlpha2Beta);
// The AlphaType restriction here means that although we have a GeneralBuilder<> that *could*
// directly build a BetaType, we can only use it to build AlphaTypes, and so we must invoke the converter.
var rule = bf.BindToInput <TestAttribute, AlphaType>(typeof(GeneralBuilder <>));
context.RegisterBindingRules <TestAttribute>(rule);
}
public void Initialize(ExtensionConfigContext context)
{
var bf = context.Config.BindingFactory;
var cm = bf.ConverterManager;
// Have an explicit converter to object.
cm.AddConverter <AlphaType, object, TestAttribute>(this);
var rule1 = bf.BindToInput <TestAttribute, AlphaType>(typeof(GeneralBuilder <>));
context.RegisterBindingRules <TestAttribute>(rule1);
}
public void Initialize(ExtensionConfigContext context)
{
var bf = context.Config.BindingFactory;
// The converter rule is the key switch.
// If TParam==SingleType, then that means we can only convert from non-array types to AlphaType.
// that means object[] converts to AlphaType[] (many)
// If TParam==OpenType, then we can convert any type (including arrays) to an AlphaType.
// that means object[] converts to AlphaType (one)
bf.ConverterManager.AddConverter <TParam, AlphaType, TestAttribute>(typeof(Object2AlphaConverter));
var rule1 = bf.BindToCollector <TestAttribute, AlphaType>(this);
context.RegisterBindingRules <TestAttribute>(rule1);
}
