public Task<IBinding> TryCreateAsync(BindingProviderContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
// Determine whether we should bind to the current parameter
ParameterInfo parameter = context.Parameter;
SampleAttribute attribute = parameter.GetCustomAttribute<SampleAttribute>(inherit: false);
if (attribute == null)
{
return Task.FromResult<IBinding>(null);
}
// TODO: Include any other parameter types this binding supports in this check
IEnumerable<Type> supportedTypes = StreamValueBinder.GetSupportedTypes(FileAccess.ReadWrite);
if (!ValueBinder.MatchParameterType(context.Parameter, supportedTypes))
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture,
"Can't bind SampleAttribute to type '{0}'.", parameter.ParameterType));
}
return Task.FromResult<IBinding>(new SampleBinding(parameter));
}
public Task<IBinding> TryCreateAsync(BindingProviderContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
ParameterInfo parameter = context.Parameter;
ServiceBusAttribute attribute = parameter.GetCustomAttribute<ServiceBusAttribute>(inherit: false);
if (attribute == null)
{
return Task.FromResult<IBinding>(null);
}
string queueOrTopicName = Resolve(attribute.QueueOrTopicName);
IBindableServiceBusPath path = BindableServiceBusPath.Create(queueOrTopicName);
ValidateContractCompatibility(path, context.BindingDataContract);
IArgumentBinding<ServiceBusEntity> argumentBinding = InnerProvider.TryCreate(parameter);
if (argumentBinding == null)
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, "Can't bind ServiceBus to type '{0}'.", parameter.ParameterType));
}
ServiceBusAccount account = ServiceBusAccount.CreateFromConnectionString(_config.ConnectionString);
IBinding binding = new ServiceBusBinding(parameter.Name, argumentBinding, account, path, attribute.Access);
return Task.FromResult(binding);
}
public void CreateDefaultMessage_CreatesExpectedMessage(SlackAttribute attribute, SlackConfiguration config, Dictionary<string, object> bindingData, INameResolver nameResolver,SlackMessage targetMessage, String targetUrl)
{
ParameterInfo parameter = GetType().GetMethod("TestMethod", BindingFlags.Static | BindingFlags.NonPublic).GetParameters().First();
Dictionary<string, Type> contract = new Dictionary<string, Type>
{
{"ChannelParam", typeof(string) },
{"IconParam", typeof(string) },
{"TextParam", typeof(string) },
{"UsernameParam", typeof(string) },
{"WebHookUrlParam", typeof(string) }
};
BindingProviderContext context = new BindingProviderContext(parameter, contract, CancellationToken.None);
SlackBinding binding = new SlackBinding(parameter, attribute, config, nameResolver, context);
// Generate message with input data
SlackMessage message = binding.CreateDefaultMessage(bindingData);
// Check that the right values were used to initialize the funtion
Assert.Equal(targetMessage.Channel, message.Channel);
Assert.Equal(targetMessage.IconEmoji, message.IconEmoji);
Assert.Equal(targetMessage.Text, message.Text);
Assert.Equal(targetMessage.Username, message.Username);
Assert.Equal(targetMessage.Mrkdwn, message.Mrkdwn);
Assert.Equal(targetUrl, binding._client.BaseUrl);
}
public SendGridBinding(ParameterInfo parameter, SendGridAttribute attribute, SendGridConfiguration config, BindingProviderContext context)
{
_parameter = parameter;
_attribute = attribute;
_config = config;
_sendGrid = new Web(_config.ApiKey);
if (!string.IsNullOrEmpty(_attribute.To))
{
_toFieldBinding = new BindablePath(_attribute.To);
_toFieldBinding.ValidateContractCompatibility(context.BindingDataContract);
}
if (!string.IsNullOrEmpty(_attribute.Subject))
{
_subjectFieldBinding = new BindablePath(_attribute.Subject);
_subjectFieldBinding.ValidateContractCompatibility(context.BindingDataContract);
}
if (!string.IsNullOrEmpty(_attribute.Text))
{
_textFieldBinding = new BindablePath(_attribute.Text);
_textFieldBinding.ValidateContractCompatibility(context.BindingDataContract);
}
}
public Task<IBinding> TryCreateAsync(BindingProviderContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
ParameterInfo parameter = context.Parameter;
EventHubAttribute attribute = parameter.GetCustomAttribute<EventHubAttribute>(inherit: false);
if (attribute == null)
{
return Task.FromResult<IBinding>(null);
}
string name = attribute.EventHubName;
var resolvedName = _nameResolver.ResolveWholeString(name);
Func<string, EventHubClient> invokeStringBinder = (invokeString) => _eventHubConfig.GetEventHubClient(invokeString);
IBinding binding = BindingFactory.BindCollector<EventData, EventHubClient>(
parameter,
_converterManager,
(client, valueBindingContext) => new EventHubAsyncCollector(client),
resolvedName,
invokeStringBinder);
return Task.FromResult(binding);
}
public SlackBinding(ParameterInfo parameter, SlackAttribute attribute, SlackConfiguration config, INameResolver nameResolver, BindingProviderContext context)
{
_parameter = parameter;
_attribute = attribute;
_config = config;
_nameResolver = nameResolver;
if(!string.IsNullOrEmpty(_attribute.WebHookUrl))
{
_webHookUrlBindingTemplate = CreateBindingTemplate(_attribute.WebHookUrl, context.BindingDataContract);
}
if (!string.IsNullOrEmpty(_attribute.Text))
{
_textBindingTemplate = CreateBindingTemplate(_attribute.Text, context.BindingDataContract);
}
if (!string.IsNullOrEmpty(_attribute.Username))
{
_usernameBindingTemplate = CreateBindingTemplate(_attribute.Username, context.BindingDataContract);
}
if (!string.IsNullOrEmpty(_attribute.IconEmoji))
{
_iconEmojiBindingTemplate = CreateBindingTemplate(_attribute.IconEmoji, context.BindingDataContract);
}
if (!string.IsNullOrEmpty(_attribute.Channel))
{
_channelBindingTemplate = CreateBindingTemplate(_attribute.Channel, context.BindingDataContract);
}
}
/// <inheritdoc/>
public Task<IBinding> TryCreateAsync(BindingProviderContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
// Determine whether we should bind to the current parameter
ParameterInfo parameter = context.Parameter;
FileAttribute attribute = parameter.GetCustomAttribute<FileAttribute>(inherit: false);
if (attribute == null)
{
return Task.FromResult<IBinding>(null);
}
// first, verify the file path binding (if it contains binding parameters)
string path = attribute.Path;
if (_nameResolver != null)
{
path = _nameResolver.ResolveWholeString(path);
}
BindingTemplate bindingTemplate = BindingTemplate.FromString(path);
bindingTemplate.ValidateContractCompatibility(context.BindingDataContract);
IEnumerable<Type> types = StreamValueBinder.GetSupportedTypes(attribute.Access)
.Union(new Type[] { typeof(FileStream), typeof(FileInfo) });
if (!ValueBinder.MatchParameterType(context.Parameter, types))
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture,
"Can't bind FileAttribute to type '{0}'.", parameter.ParameterType));
}
return Task.FromResult<IBinding>(new FileBinding(_config, parameter, bindingTemplate));
}
public void Binding_UsesNameResolver()
{
ParameterInfo parameter = GetType().GetMethod("TestMethod", BindingFlags.Static | BindingFlags.NonPublic).GetParameters().First();
SendGridAttribute attribute = new SendGridAttribute
{
To = "%param1%",
From = "%param2%",
Subject = "%param3%",
Text = "%param4%"
};
SendGridConfiguration config = new SendGridConfiguration
{
ApiKey = "12345"
};
Dictionary<string, Type> contract = new Dictionary<string, Type>();
BindingProviderContext context = new BindingProviderContext(parameter, contract, CancellationToken.None);
var nameResolver = new TestNameResolver();
nameResolver.Values.Add("param1", "*****@*****.**");
nameResolver.Values.Add("param2", "*****@*****.**");
nameResolver.Values.Add("param3", "Value3");
nameResolver.Values.Add("param4", "Value4");
SendGridBinding binding = new SendGridBinding(parameter, attribute, config, nameResolver, context);
Dictionary<string, object> bindingData = new Dictionary<string, object>();
SendGridMessage message = binding.CreateDefaultMessage(bindingData);
Assert.Equal("*****@*****.**", message.To.Single().Address);
Assert.Equal("*****@*****.**", message.From.Address);
Assert.Equal("Value3", message.Subject);
Assert.Equal("Value4", message.Text);
}
public Task<IBinding> TryCreateAsync(BindingProviderContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
ParameterInfo parameter = context.Parameter;
SlackAttribute attribute = parameter.GetCustomAttribute<SlackAttribute>(inherit: false);
if(attribute == null)
{
return Task.FromResult<IBinding>(null);
}
if(context.Parameter.ParameterType != typeof(SlackMessage) &&
context.Parameter.ParameterType != typeof(SlackMessage).MakeByRefType())
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, "Can't bind SlackAttribute to type '{0}'.", parameter.ParameterType));
}
if(string.IsNullOrEmpty(_config.WebHookUrl))
{
throw new InvalidOperationException(
string.Format("You must specify a Slack WebHook URL via a '{0}' app setting, via a '{0}' environment variable, or directly in code via SlackConfiguration.WebHookUrl",
SlackConfiguration.AzureWebJobsSlackWebHookKeyName));
}
return Task.FromResult<IBinding>(new SlackBinding(parameter, attribute, _config, _nameResolver, context));
}
public async Task<IBinding> TryCreateAsync(BindingProviderContext context)
{
ParameterInfo parameter = context.Parameter;
QueueAttribute queueAttribute = parameter.GetCustomAttribute<QueueAttribute>(inherit: false);
if (queueAttribute == null)
{
return null;
}
string queueName = Resolve(queueAttribute.QueueName);
IBindableQueuePath path = BindableQueuePath.Create(queueName);
path.ValidateContractCompatibility(context.BindingDataContract);
IArgumentBinding<IStorageQueue> argumentBinding = _innerProvider.TryCreate(parameter);
if (argumentBinding == null)
{
throw new InvalidOperationException("Can't bind Queue to type '" + parameter.ParameterType + "'.");
}
IStorageAccount account = await _accountProvider.GetStorageAccountAsync(context.Parameter, context.CancellationToken);
StorageClientFactoryContext clientFactoryContext = new StorageClientFactoryContext
{
Parameter = parameter
};
IStorageQueueClient client = account.CreateQueueClient(clientFactoryContext);
IBinding binding = new QueueBinding(parameter.Name, argumentBinding, client, path);
return binding;
}
public Task<IBinding> TryCreateAsync(BindingProviderContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
ParameterInfo parameter = context.Parameter;
RedisAttribute attribute = parameter.GetCustomAttribute<RedisAttribute>(inherit: false);
if (attribute == null)
{
return Task.FromResult<IBinding>(null);
}
IArgumentBinding<RedisEntity> argumentBinding = Provider.TryCreate(parameter);
if (argumentBinding == null)
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture,
"Can't bind to type '{0}'.", parameter.ParameterType));
}
var account = RedisAccount.CreateDbFromConnectionString(_config.ConnectionString);
IBinding binding = new RedisBinding(parameter.Name, argumentBinding, account, attribute, context, _trace);
return Task.FromResult(binding);
}
public SendGridBinding(ParameterInfo parameter, SendGridAttribute attribute, SendGridConfiguration config, INameResolver nameResolver, BindingProviderContext context)
{
_parameter = parameter;
_attribute = attribute;
_config = config;
_nameResolver = nameResolver;
_sendGrid = new Web(_config.ApiKey);
if (!string.IsNullOrEmpty(_attribute.To))
{
_toFieldBindingTemplate = CreateBindingTemplate(_attribute.To, context.BindingDataContract);
}
if (!string.IsNullOrEmpty(_attribute.From))
{
_fromFieldBindingTemplate = CreateBindingTemplate(_attribute.From, context.BindingDataContract);
}
if (!string.IsNullOrEmpty(_attribute.Subject))
{
_subjectFieldBindingTemplate = CreateBindingTemplate(_attribute.Subject, context.BindingDataContract);
}
if (!string.IsNullOrEmpty(_attribute.Text))
{
_textFieldBindingTemplate = CreateBindingTemplate(_attribute.Text, context.BindingDataContract);
}
}
public Task<IBinding> TryCreateAsync(BindingProviderContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
ParameterInfo parameter = context.Parameter;
SendGridAttribute attribute = parameter.GetCustomAttribute<SendGridAttribute>(inherit: false);
if (attribute == null)
{
return Task.FromResult<IBinding>(null);
}
if (context.Parameter.ParameterType != typeof(SendGrid.SendGridMessage))
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture,
"Can't bind SendGridAttribute to type '{0}'.", parameter.ParameterType));
}
if (string.IsNullOrEmpty(_config.ApiKey))
{
throw new InvalidOperationException(
string.Format("The SendGrid ApiKey must be set either via a '{0}' app setting, via a '{0}' environment variable, or directly in code via SendGridConfiguration.ApiKey.",
SendGridConfiguration.AzureWebJobsSendGridApiKeyName));
}
return Task.FromResult<IBinding>(new SendGridBinding(parameter, attribute, _config, context));
}
public async Task<IBinding> TryCreateAsync(BindingProviderContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
ParameterInfo parameter = context.Parameter;
ServiceBusAttribute attribute = parameter.GetCustomAttribute<ServiceBusAttribute>(inherit: false);
if (attribute == null)
{
return null;
}
string queueOrTopicName = Resolve(attribute.QueueOrTopicName);
IBindableServiceBusPath path = BindableServiceBusPath.Create(queueOrTopicName);
ValidateContractCompatibility(path, context.BindingDataContract);
IArgumentBinding<ServiceBusEntity> argumentBinding = InnerProvider.TryCreate(parameter);
if (argumentBinding == null)
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, "Can't bind ServiceBus to type '{0}'.", parameter.ParameterType));
}
string connectionName = ServiceBusAccount.GetAccountOverrideOrNull(context.Parameter);
ServiceBusAccount account = new ServiceBusAccount
{
MessagingFactory = await _config.MessagingProvider.CreateMessagingFactoryAsync(queueOrTopicName, connectionName),
NamespaceManager = _config.MessagingProvider.CreateNamespaceManager(connectionName)
};
IBinding binding = new ServiceBusBinding(parameter.Name, argumentBinding, account, path, attribute.Access);
return binding;
}
public async Task<IBinding> TryCreateAsync(BindingProviderContext context)
{
ParameterInfo parameter = context.Parameter;
TableAttribute tableAttribute = parameter.GetCustomAttribute<TableAttribute>(inherit: false);
if (tableAttribute == null)
{
return null;
}
string tableName = Resolve(tableAttribute.TableName);
IStorageAccount account = await _accountProvider.GetStorageAccountAsync(context.Parameter, context.CancellationToken);
StorageClientFactoryContext clientFactoryContext = new StorageClientFactoryContext
{
Parameter = context.Parameter
};
IStorageTableClient client = account.CreateTableClient(clientFactoryContext);
bool bindsToEntireTable = tableAttribute.RowKey == null;
IBinding binding;
if (bindsToEntireTable)
{
IBindableTablePath path = BindableTablePath.Create(tableName);
path.ValidateContractCompatibility(context.BindingDataContract);
IStorageTableArgumentBinding argumentBinding = _tableBindingProvider.TryCreate(parameter);
if (argumentBinding == null)
{
throw new InvalidOperationException("Can't bind Table to type '" + parameter.ParameterType + "'.");
}
binding = new TableBinding(parameter.Name, argumentBinding, client, path);
}
else
{
string partitionKey = Resolve(tableAttribute.PartitionKey);
string rowKey = Resolve(tableAttribute.RowKey);
IBindableTableEntityPath path = BindableTableEntityPath.Create(tableName, partitionKey, rowKey);
path.ValidateContractCompatibility(context.BindingDataContract);
IArgumentBinding<TableEntityContext> argumentBinding = _entityBindingProvider.TryCreate(parameter);
if (argumentBinding == null)
{
throw new InvalidOperationException("Can't bind Table entity to type '" + parameter.ParameterType + "'.");
}
binding = new TableEntityBinding(parameter.Name, argumentBinding, client, path);
}
return binding;
}
private static BindingProviderContext CreateBindingContext(string parameterName, Type parameterType)
{
ParameterInfo parameter = new StubParameterInfo(parameterName, parameterType);
Dictionary<string, Type> bindingDataContract = new Dictionary<string, Type>
{
{ parameterName, parameterType }
};
BindingProviderContext context = new BindingProviderContext(parameter, bindingDataContract,
CancellationToken.None);
return context;
}
public async Task TryCreateAsync_DefaultAccount()
{
_mockMessagingProvider.Setup(p => p.CreateNamespaceManager(null)).Returns<NamespaceManager>(null);
_mockMessagingProvider.Setup(p => p.CreateMessagingFactoryAsync("test", null)).ReturnsAsync(null);
ParameterInfo parameter = GetType().GetMethod("TestJob").GetParameters()[0];
BindingProviderContext context = new BindingProviderContext(parameter, new Dictionary<string, Type>(), CancellationToken.None);
IBinding binding = await _provider.TryCreateAsync(context);
_mockMessagingProvider.VerifyAll();
}
public RedisBinding(string parameterName, IArgumentBinding<RedisEntity> argumentBinding,
RedisAccount account, RedisAttribute attribute, BindingProviderContext context, TraceWriter trace)
{
_parameterName = parameterName;
_argumentBinding = argumentBinding;
_account = account;
_attribute = attribute;
_mode = attribute.Mode;
_channelOrKeyPath = BindingTemplate.FromString(attribute.ChannelOrKey);
_trace = trace;
}
public async Task<IBinding> TryCreateAsync(BindingProviderContext context)
{
foreach (IBindingProvider provider in _providers)
{
IBinding binding = await provider.TryCreateAsync(context);
if (binding != null)
{
return binding;
}
}
return null;
}
public Task<IBinding> TryCreateAsync(BindingProviderContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
if (context.Parameter.ParameterType != typeof(ExecutionContext))
{
return Task.FromResult<IBinding>(null);
}
return Task.FromResult<IBinding>(new ExecutionContextBinding(context.Parameter));
}
public Task<IBinding> TryCreateAsync(BindingProviderContext context)
{
if (context == null)
throw new ArgumentNullException(nameof(context));
var parameter = context.Parameter;
var attribute = parameter.GetCustomAttributes(typeof(FtpAttribute), inherit: false);
if (attribute == null || attribute.Length == 0)
return Task.FromResult<IBinding>(null);
// TODO: Include any other parameter types this binding supports in this check
var supportedTypes = new List<Type> { typeof(FtpMessage) };
if (!ValueBinder.MatchParameterType(context.Parameter, supportedTypes))
throw new InvalidOperationException($"Can't bind {nameof(FtpAttribute)} to type '{parameter.ParameterType}'.");
return Task.FromResult<IBinding>(new FtpBinding(_config, parameter, _trace, (FtpAttribute)attribute[0]));
}
private static bool CanBind(BindingProviderContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
// first, verify the file path binding (if it contains binding parameters)
ParameterInfo parameter = context.Parameter;
FileAttribute attribute = parameter.GetCustomAttribute<FileAttribute>(inherit: false);
BindablePath path = new BindablePath(attribute.Path);
path.ValidateContractCompatibility(context.BindingDataContract);
// next, verify that the type is one of the types we support
IEnumerable<Type> types = StreamValueBinder.SupportedTypes.Union(new Type[] { typeof(FileStream) });
return ValueBinder.MatchParameterType(parameter, types);
}
public Task<IBinding> TryCreateAsync(BindingProviderContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
ParameterInfo parameter = context.Parameter;
if (parameter.ParameterType != typeof(TraceWriter) &&
parameter.ParameterType != typeof(TextWriter))
{
return Task.FromResult<IBinding>(null);
}
IBinding binding = new TraceWriterBinding(parameter);
return Task.FromResult(binding);
}
public void CreateDefaultMessage_CreatesExpectedMessage()
{
ParameterInfo parameter = GetType().GetMethod("TestMethod", BindingFlags.Static | BindingFlags.NonPublic).GetParameters().First();
SendGridAttribute attribute = new SendGridAttribute
{
To = "{Param1}",
Subject = "Test {Param2}",
Text = "Test {Param3}"
};
SendGridConfiguration config = new SendGridConfiguration
{
ApiKey = "12345",
FromAddress = new MailAddress("*****@*****.**", "Test2"),
ToAddress = "*****@*****.**"
};
Dictionary<string, Type> contract = new Dictionary<string, Type>();
contract.Add("Param1", typeof(string));
contract.Add("Param2", typeof(string));
contract.Add("Param3", typeof(string));
BindingProviderContext context = new BindingProviderContext(parameter, contract, CancellationToken.None);
var nameResolver = new TestNameResolver();
SendGridBinding binding = new SendGridBinding(parameter, attribute, config, nameResolver, context);
Dictionary<string, object> bindingData = new Dictionary<string, object>();
bindingData.Add("Param1", "*****@*****.**");
bindingData.Add("Param2", "Value2");
bindingData.Add("Param3", "Value3");
SendGridMessage message = binding.CreateDefaultMessage(bindingData);
Assert.Same(config.FromAddress, message.From);
Assert.Equal("*****@*****.**", message.To.Single().Address);
Assert.Equal("Test Value2", message.Subject);
Assert.Equal("Test Value3", message.Text);
// If no To value specified, verify it is defaulted from config
attribute = new SendGridAttribute
{
Subject = "Test {Param2}",
Text = "Test {Param3}"
};
binding = new SendGridBinding(parameter, attribute, config, nameResolver, context);
message = binding.CreateDefaultMessage(bindingData);
Assert.Equal("*****@*****.**", message.To.Single().Address);
}
public Task <IBinding> TryCreateAsync(BindingProviderContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
var parameter = context.Parameter;
var typeUser = parameter.ParameterType;
if (typeUser.IsByRef)
{
return(Task.FromResult <IBinding>(null));
}
var type = typeof(ExactBinding <>).MakeGenericType(typeof(TAttribute), typeof(TType), typeUser);
var method = type.GetMethod("TryBuild", BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
var binding = BindingFactoryHelpers.MethodInvoke <IBinding>(method, this, context);
return(Task.FromResult <IBinding>(binding));
}
public Task <IBinding> TryCreateAsync(BindingProviderContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
ParameterInfo parameter = context.Parameter;
TAttribute attributeSource = parameter.GetCustomAttribute <TAttribute>(inherit: false);
if (attributeSource == null)
{
return(Task.FromResult <IBinding>(null));
}
var cloner = new AttributeCloner <TAttribute>(attributeSource, context.BindingDataContract, _nameResolver);
IBinding binding = new Binding(cloner, parameter, _builder);
return(Task.FromResult(binding));
}
public Task <IBinding> TryCreateAsync(BindingProviderContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
Type parametertype = context.Parameter.ParameterType;
var attr = context.Parameter.GetCustomAttribute <TAttribute>();
var cloner = new AttributeCloner <TAttribute>(attr, context.BindingDataContract, _nameResolver);
var attrNameResolved = cloner.GetNameResolvedAttribute();
// This may do validation and throw too.
bool canBind = _predicate(attrNameResolved, parametertype);
if (!canBind)
{
return(Task.FromResult <IBinding>(null));
}
return(_inner.TryCreateAsync(context));
}
public async Task <IBinding> TryCreateAsync(BindingProviderContext context)
{
var attr = context.Parameter.GetCustomAttribute <TAttribute>();
if (attr == null)
{
return(null);
}
if (_validator != null)
{
// Expected this will throw on errors.
Type parameterType = context.Parameter.ParameterType;
var cloner = new AttributeCloner <TAttribute>(attr, context.BindingDataContract, _nameResolver);
var attrNameResolved = cloner.GetNameResolvedAttribute();
_validator(attrNameResolved, parameterType);
}
foreach (IBindingProvider provider in _providers)
{
IBinding binding = await provider.TryCreateAsync(context);
if (binding != null)
{
return(binding);
}
}
// Nobody claimed it.
string resourceName = typeof(TAttribute).Name;
const string Suffix = "Attribute";
if (resourceName.EndsWith(Suffix))
{
resourceName = resourceName.Substring(0, resourceName.Length - Suffix.Length);
}
throw new InvalidOperationException("Can't bind " + resourceName + " to type '" + context.Parameter.ParameterType + "'.");
}
/// <inheritdoc/>
public Task<IBinding> TryCreateAsync(BindingProviderContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
// Determine whether we should bind to the current parameter
ParameterInfo parameter = context.Parameter;
FileAttribute attribute = parameter.GetCustomAttribute<FileAttribute>(inherit: false);
if (attribute == null)
{
return Task.FromResult<IBinding>(null);
}
if (!CanBind(context))
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture,
"Can't bind FileAttribute to type '{0}'.", parameter.ParameterType));
}
return Task.FromResult<IBinding>(new FileBinding(_config, parameter));
}
public Task <IBinding> TryCreateAsync(BindingProviderContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
var parameter = context.Parameter;
var typeUser = parameter.ParameterType;
if (typeUser.IsByRef)
{
typeUser = typeUser.GetElementType(); // Can't generic instantiate a ByRef.
}
var type = typeof(StreamBinding);
var method = type.GetMethod("TryBuild", BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
method = method.MakeGenericMethod(typeUser);
var binding = BindingFactoryHelpers.MethodInvoke <IBinding>(method, this, context);
return(Task.FromResult <IBinding>(binding));
}
public Task <IBinding> TryCreateAsync(BindingProviderContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
ParameterInfo parameter = context.Parameter;
if (parameter.ParameterType != typeof(ILogger))
{
return(Task.FromResult <IBinding>(null));
}
if (_loggerFactory == null)
{
throw new ArgumentException("A parameter of type ILogger cannot be used without a registered ILoggerFactory.");
}
IBinding binding = new ILoggerBinding(parameter, _loggerFactory);
return(Task.FromResult(binding));
}
public async Task <IBinding> TryCreateAsync(BindingProviderContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
var binding = await _inner.TryCreateAsync(context);
if (binding != null)
{
// Only run the validator if the inner binding claims it.
// Expected this will throw on errors.
Type parameterType = context.Parameter.ParameterType;
var attr = context.Parameter.GetCustomAttribute <TAttribute>();
var cloner = new AttributeCloner <TAttribute>(attr, context.BindingDataContract, _configuration, _nameResolver);
var attrNameResolved = cloner.GetNameResolvedAttribute();
_validator(attrNameResolved, parameterType);
}
return(binding);
}
public Task<IBinding> TryCreateAsync(BindingProviderContext context)
{
ParameterInfo parameter = context.Parameter;
FakeQueueAttribute attribute = parameter.GetCustomAttribute<FakeQueueAttribute>(inherit: false);
if (attribute == null)
{
return Task.FromResult<IBinding>(null);
}
string resolvedName = "fakequeue";
Func<string, FakeQueueClient> invokeStringBinder = (invokeString) => _client;
IBinding binding = BindingFactory.BindCollector<FakeQueueData, FakeQueueClient>(
parameter,
_converterManager,
(client, valueBindingContext) => client,
resolvedName,
invokeStringBinder
);
return Task.FromResult(binding);
}
public static ExactBinding <TUserType> TryBuild(
TriggerAdapterBindingProvider <TAttribute, TTriggerValue> parent,
BindingProviderContext context)
{
IConverterManager cm = parent._converterManager;
var converter = cm.GetConverter <TTriggerValue, TUserType, TAttribute>();
if (converter == null)
{
return(null);
}
var parameter = context.Parameter;
var attributeSource = TypeUtility.GetResolvedAttribute <TAttribute>(parameter);
return(new ExactBinding <TUserType>
{
_converter = converter,
_directInvoker = GetDirectInvoker(cm),
_getInvokeString = GetDirectInvokeString(cm),
_attribute = attributeSource
});
}
public static ExactBinding <TMessage> TryBuild(
AsyncCollectorBindingProvider <TAttribute, TType> parent,
Mode mode,
BindingProviderContext context)
{
var patternMatcher = parent._patternMatcher;
var parameter = context.Parameter;
var attributeSource = TypeUtility.GetResolvedAttribute <TAttribute>(parameter);
FuncAsyncConverter buildFromAttribute;
FuncAsyncConverter <TMessage, TType> converter = null;
// Prefer the shortest route to creating the user type.
// If TType matches the user type directly, then we should be able to directly invoke the builder in a single step.
// TAttribute --> TUserType
var checker = OpenType.FromType <TType>();
if (checker.IsMatch(typeof(TMessage)))
{
buildFromAttribute = patternMatcher.TryGetConverterFunc(
typeof(TAttribute), typeof(IAsyncCollector <TMessage>));
}
else
{
var converterManager = parent._converterManager;
// Try with a converter
// Find a builder for : TAttribute --> TType
// and then couple with a converter: TType --> TParameterType
converter = converterManager.GetConverter <TMessage, TType, TAttribute>();
if (converter == null)
{
// Preserves legacy behavior. This means we can only have 1 async collector.
// However, the collector's builder object can switch.
throw NewMissingConversionError(typeof(TMessage));
}
buildFromAttribute = patternMatcher.TryGetConverterFunc(
typeof(TAttribute), typeof(IAsyncCollector <TType>));
}
if (buildFromAttribute == null)
{
context.BindingErrors.Add(String.Format(Constants.BindingAssemblyConflictMessage, typeof(TType).AssemblyQualifiedName, typeof(TMessage).AssemblyQualifiedName));
return(null);
}
ParameterDescriptor param;
if (parent.BuildParameterDescriptor != null)
{
param = parent.BuildParameterDescriptor(attributeSource, parameter, parent._nameResolver);
}
else
{
param = new ParameterDescriptor
{
Name = parameter.Name,
DisplayHints = new ParameterDisplayHints
{
Description = "output"
}
};
}
var cloner = new AttributeCloner <TAttribute>(attributeSource, context.BindingDataContract, parent._nameResolver);
return(new ExactBinding <TMessage>(cloner, param, mode, buildFromAttribute, converter));
}
public static ExactBinding TryBuild(
BindToInputBindingProvider <TAttribute, TType> parent,
BindingProviderContext context)
{
var cm = parent._converterManager;
var patternMatcher = parent._patternMatcher;
var parameter = context.Parameter;
var userType = parameter.ParameterType;
var attributeSource = TypeUtility.GetResolvedAttribute <TAttribute>(parameter);
var cloner = new AttributeCloner <TAttribute>(attributeSource, context.BindingDataContract, parent._configuration, parent._nameResolver);
FuncAsyncConverter buildFromAttribute;
FuncAsyncConverter converter = null;
// Prefer the shortest route to creating the user type.
// If TType matches the user type directly, then we should be able to directly invoke the builder in a single step.
// TAttribute --> TUserType
var checker = OpenType.FromType <TType>();
if (checker.IsMatch(userType))
{
buildFromAttribute = patternMatcher.TryGetConverterFunc(typeof(TAttribute), userType);
}
else
{
// Try with a converter
// Find a builder for : TAttribute --> TType
// and then couple with a converter: TType --> TParameterType
converter = cm.GetConverter <TAttribute>(typeof(TType), userType);
if (converter == null)
{
var targetType = typeof(TType);
context.BindingErrors.Add(String.Format(Resource.BindingAssemblyConflictMessage, targetType.AssemblyQualifiedName, userType.AssemblyQualifiedName));
return(null);
}
buildFromAttribute = patternMatcher.TryGetConverterFunc(typeof(TAttribute), typeof(TType));
}
if (buildFromAttribute == null)
{
return(null);
}
ParameterDescriptor param;
if (parent.BuildParameterDescriptor != null)
{
param = parent.BuildParameterDescriptor(attributeSource, parameter, parent._nameResolver);
}
else
{
param = new ParameterDescriptor
{
Name = parameter.Name,
DisplayHints = new ParameterDisplayHints
{
Description = "input"
}
};
}
return(new ExactBinding(cloner, param, buildFromAttribute, converter, userType));
}
public static IBinding TryBuild <TUserType>(
BindToStreamBindingProvider <TAttribute> parent,
BindingProviderContext context)
{
// Allowed Param types:
// Stream
// any T with a Stream --> T conversion
// out T, with a Out<Stream,T> --> void conversion
var parameter = context.Parameter;
var parameterType = parameter.ParameterType;
var attributeSource = TypeUtility.GetResolvedAttribute <TAttribute>(parameter);
// Stream is either way; all other types are known.
FileAccess?declaredAccess = GetFileAccessFromAttribute(attributeSource);
Type argHelperType;
bool isRead;
IConverterManager cm = parent._converterManager;
INameResolver nm = parent._nameResolver;
IConfiguration config = parent._configuration;
object converterParam = null;
{
if (parameter.IsOut)
{
var outConverter = cm.GetConverter <ApplyConversion <TUserType, Stream>, object, TAttribute>();
if (outConverter != null)
{
converterParam = outConverter;
isRead = false;
argHelperType = typeof(OutArgBaseValueProvider <>).MakeGenericType(typeof(TAttribute), typeof(TUserType));
}
else
{
throw new InvalidOperationException($"No stream converter to handle {typeof(TUserType).FullName}.");
}
}
else
{
var converter = cm.GetConverter <Stream, TUserType, TAttribute>();
if (converter != null)
{
converterParam = converter;
if (parameterType == typeof(Stream))
{
if (!declaredAccess.HasValue)
{
throw new InvalidOperationException("When binding to Stream, the attribute must specify a FileAccess direction.");
}
switch (declaredAccess.Value)
{
case FileAccess.Read:
isRead = true;
break;
case FileAccess.Write:
isRead = false;
break;
default:
throw new NotImplementedException("ReadWrite access is not supported. Pick either Read or Write.");
}
}
else
{
// For backwards compat, we recognize TextWriter as write;
// anything else should explicitly set the FileAccess flag.
if (typeof(TextWriter).IsAssignableFrom(typeof(TUserType)))
{
isRead = false;
}
else
{
isRead = true;
}
}
argHelperType = typeof(ValueProvider <>).MakeGenericType(typeof(TAttribute), typeof(TUserType));
}
else
{
// This rule can't bind.
// Let another try.
context.BindingErrors.Add(String.Format(Resource.BindingAssemblyConflictMessage, typeof(Stream).AssemblyQualifiedName, typeof(TUserType).AssemblyQualifiedName));
return(null);
}
}
}
VerifyAccessOrThrow(declaredAccess, isRead);
if (!parent.IsSupportedByRule(isRead))
{
return(null);
}
var cloner = new AttributeCloner <TAttribute>(attributeSource, context.BindingDataContract, config, nm);
ParameterDescriptor param;
if (parent.BuildParameterDescriptor != null)
{
param = parent.BuildParameterDescriptor(attributeSource, parameter, nm);
}
else
{
param = new ParameterDescriptor
{
Name = parameter.Name,
DisplayHints = new ParameterDisplayHints
{
Description = isRead ? "Read Stream" : "Write Stream"
}
};
}
var fileAccess = isRead ? FileAccess.Read : FileAccess.Write;
IBinding binding = new StreamBinding(cloner, param, parent, argHelperType, parameterType, fileAccess, converterParam);
return(binding);
}
public static ExactBinding <TMessage> TryBuild(
AsyncCollectorBindingProvider <TAttribute, TType> parent,
Mode mode,
BindingProviderContext context)
{
var patternMatcher = parent._patternMatcher;
var parameter = context.Parameter;
TAttribute attributeSource = parameter.GetCustomAttribute <TAttribute>(inherit: false);
Func <TAttribute, Task <TAttribute> > hookWrapper = null;
if (parent.PostResolveHook != null)
{
hookWrapper = (attrResolved) => parent.PostResolveHook(attrResolved, parameter, parent._nameResolver);
}
Func <object, object> buildFromAttribute;
FuncConverter <TMessage, TAttribute, TType> converter = null;
// Prefer the shortest route to creating the user type.
// If TType matches the user type directly, then we should be able to directly invoke the builder in a single step.
// TAttribute --> TUserType
var checker = ConverterManager.GetTypeValidator <TType>();
if (checker.IsMatch(typeof(TMessage)))
{
buildFromAttribute = patternMatcher.TryGetConverterFunc(
typeof(TAttribute), typeof(IAsyncCollector <TMessage>));
}
else
{
var converterManager = parent._converterManager;
// Try with a converter
// Find a builder for : TAttribute --> TType
// and then couple with a converter: TType --> TParameterType
converter = converterManager.GetConverter <TMessage, TType, TAttribute>();
if (converter == null)
{
// Preserves legacy behavior. This means we can only have 1 async collector.
// However, the collector's builder object can switch.
throw NewMissingConversionError(typeof(TMessage));
}
buildFromAttribute = patternMatcher.TryGetConverterFunc(
typeof(TAttribute), typeof(IAsyncCollector <TType>));
}
if (buildFromAttribute == null)
{
return(null);
}
ParameterDescriptor param;
if (parent.BuildParameterDescriptor != null)
{
param = parent.BuildParameterDescriptor(attributeSource, parameter, parent._nameResolver);
}
else
{
param = new ParameterDescriptor
{
Name = parameter.Name,
DisplayHints = new ParameterDisplayHints
{
Description = "output"
}
};
}
var cloner = new AttributeCloner <TAttribute>(attributeSource, context.BindingDataContract, parent._nameResolver, hookWrapper);
return(new ExactBinding <TMessage>(cloner, param, mode, buildFromAttribute, converter));
}
public static ExactBinding <TUserType> TryBuild(
BindToInputBindingProvider <TAttribute, TType> parent,
BindingProviderContext context)
{
var cm = parent._converterManager;
var patternMatcher = parent._patternMatcher;
var parameter = context.Parameter;
TAttribute attributeSource = parameter.GetCustomAttribute <TAttribute>(inherit: false);
Func <TAttribute, Task <TAttribute> > hookWrapper = null;
if (parent.PostResolveHook != null)
{
hookWrapper = (attrResolved) => parent.PostResolveHook(attrResolved, parameter, parent._nameResolver);
}
var cloner = new AttributeCloner <TAttribute>(attributeSource, context.BindingDataContract, parent._nameResolver, hookWrapper);
Func <object, object> buildFromAttribute;
FuncConverter <TType, TAttribute, TUserType> converter = null;
// Prefer the shortest route to creating the user type.
// If TType matches the user type directly, then we should be able to directly invoke the builder in a single step.
// TAttribute --> TUserType
var checker = ConverterManager.GetTypeValidator <TType>();
if (checker.IsMatch(typeof(TUserType)))
{
buildFromAttribute = patternMatcher.TryGetConverterFunc(typeof(TAttribute), typeof(TUserType));
}
else
{
// Try with a converter
// Find a builder for : TAttribute --> TType
// and then couple with a converter: TType --> TParameterType
converter = cm.GetConverter <TType, TUserType, TAttribute>();
if (converter == null)
{
return(null);
}
buildFromAttribute = patternMatcher.TryGetConverterFunc(typeof(TAttribute), typeof(TType));
}
if (buildFromAttribute == null)
{
return(null);
}
ParameterDescriptor param;
if (parent.BuildParameterDescriptor != null)
{
param = parent.BuildParameterDescriptor(attributeSource, parameter, parent._nameResolver);
}
else
{
param = new ParameterDescriptor
{
Name = parameter.Name,
DisplayHints = new ParameterDisplayHints
{
Description = "input"
}
};
}
return(new ExactBinding <TUserType>(cloner, param, buildFromAttribute, converter));
}
