private object ConvertArray(string[] items, Type destinationType, BindingContext context)
{
var elementType = destinationType.GetElementType();
if (elementType == null)
{
return null;
}
var converter = context.TypeConverters.Where(c => c.CanConvertTo(elementType)).FirstOrDefault();
if (converter == null)
{
return null;
}
var returnArray = items.Select(s => converter.Convert(s, elementType, context));
var genericCastMethod = this.enumerableCastMethod.MakeGenericMethod(new[] { elementType });
var generictoArrayMethod = this.enumerableToArrayMethod.MakeGenericMethod(new[] { elementType });
var castArray = genericCastMethod.Invoke(null, new object[] { returnArray });
return generictoArrayMethod.Invoke(null, new[] { castArray });
}
/// <summary>
/// Deserialize the request body to a model
/// </summary>
/// <param name="mediaRange">Content type to deserialize</param>
/// <param name="bodyStream">Request body stream</param>
/// <param name="context">Current context</param>
/// <returns>Model instance</returns>
public object Deserialize(MediaRange mediaRange, Stream bodyStream, BindingContext context)
{
var serializer = new JavaScriptSerializer(
null,
false,
this.configuration.MaxJsonLength,
this.configuration.MaxRecursions,
this.configuration.RetainCasing,
this.configuration.UseISO8601DateFormat,
this.configuration.Converters,
this.configuration.PrimitiveConverters);
serializer.RegisterConverters(this.configuration.Converters, this.configuration.PrimitiveConverters);
bodyStream.Position = 0;
string bodyText;
using (var bodyReader = new StreamReader(bodyStream))
{
bodyText = bodyReader.ReadToEnd();
}
var genericDeserializeMethod = this.deserializeMethod.MakeGenericMethod(context.DestinationType);
var deserializedObject = genericDeserializeMethod.Invoke(serializer, new object[] { bodyText });
return deserializedObject;
}
public WindowsStreamSecurityUpgradeProvider(WindowsStreamSecurityBindingElement bindingElement,
BindingContext context, bool isClient)
: base(context.Binding)
{
this.extractGroupsForWindowsAccounts = TransportDefaults.ExtractGroupsForWindowsAccounts;
this.protectionLevel = bindingElement.ProtectionLevel;
this.scheme = context.Binding.Scheme;
this.isClient = isClient;
this.listenUri = TransportSecurityHelpers.GetListenUri(context.ListenUriBaseAddress, context.ListenUriRelativeAddress);
SecurityCredentialsManager credentialProvider = context.BindingParameters.Find<SecurityCredentialsManager>();
if (credentialProvider == null)
{
if (isClient)
{
credentialProvider = ClientCredentials.CreateDefaultCredentials();
}
else
{
credentialProvider = ServiceCredentials.CreateDefaultCredentials();
}
}
this.securityTokenManager = credentialProvider.CreateSecurityTokenManager();
}
void BindNamed(object commando, PropertyInfo property, List<CommandLineParameter> parameters, NamedArgumentAttribute attribute, BindingContext context)
{
var name = attribute.Name;
var shortHand = attribute.ShortHand;
var parameter = parameters.Where(p => p is NamedCommandLineParameter)
.Cast<NamedCommandLineParameter>()
.SingleOrDefault(p => p.Name == name || p.Name == shortHand);
var value = parameter != null
? Mutate(parameter, property)
: attribute.Default != null
? Mutate(attribute.Default, property)
: null;
if (value == null)
{
context.Report.PropertiesNotBound.Add(property);
if (!attribute.Required) return;
throw Ex("Could not find parameter matching required parameter named {0}", name);
}
property.SetValue(commando, value, null);
context.Report.PropertiesBound.Add(property);
}
protected RabbitMQOutputChannelBase(BindingContext context, EndpointAddress address, Uri via)
: base(context)
{
_address = address;
_via = via;
_sendMethod = Send;
}
public WindowsStreamSecurityUpgradeProvider(WindowsStreamSecurityBindingElement bindingElement,
BindingContext context, bool isClient)
: base(context.Binding)
{
_extractGroupsForWindowsAccounts = TransportDefaults.ExtractGroupsForWindowsAccounts;
_protectionLevel = bindingElement.ProtectionLevel;
_scheme = context.Binding.Scheme;
_isClient = isClient;
_listenUri = TransportSecurityHelpers.GetListenUri(context.ListenUriBaseAddress, context.ListenUriRelativeAddress);
SecurityCredentialsManager credentialProvider = context.BindingParameters.Find<SecurityCredentialsManager>();
if (credentialProvider == null)
{
if (isClient)
{
credentialProvider = ClientCredentials.CreateDefaultCredentials();
}
else
{
throw ExceptionHelper.PlatformNotSupported("WindowsStreamSecurityUpgradeProvider for server is not supported.");
}
}
_securityTokenManager = credentialProvider.CreateSecurityTokenManager();
}
public static void Main ()
{
HttpTransportBindingElement el =
new HttpTransportBindingElement ();
BindingContext bc = new BindingContext (
new CustomBinding (),
new BindingParameterCollection (),
new Uri ("http://localhost:37564"),
String.Empty, ListenUriMode.Explicit);
IChannelListener<IReplyChannel> listener =
el.BuildChannelListener<IReplyChannel> (bc);
listener.Open ();
IReplyChannel reply = listener.AcceptChannel ();
reply.Open ();
if (!reply.WaitForRequest (TimeSpan.FromSeconds (10))) {
Console.WriteLine ("No request reached here.");
return;
}
Console.WriteLine ("Receiving request ...");
RequestContext ctx = reply.ReceiveRequest ();
if (ctx == null)
return;
Console.WriteLine ("Starting reply ...");
ctx.Reply (Message.CreateMessage (MessageVersion.Default, "Ack"));
}
/// <summary>
/// Convert the string representation to the destination type
/// </summary>
/// <param name="input">Input string</param>
/// <param name="destinationType">Destination type</param>
/// <param name="context">Current context</param>
/// <returns>Converted object of the destination type</returns>
public object Convert(string input, Type destinationType, BindingContext context)
{
if (string.IsNullOrEmpty(input))
{
return null;
}
var items = input.Split(',');
// Strategy, schmategy ;-)
if (destinationType.IsCollection())
{
return this.ConvertCollection(items, destinationType, context);
}
if (destinationType.IsArray())
{
return this.ConvertArray(items, destinationType, context);
}
if (destinationType.IsEnumerable())
{
return this.ConvertEnumerable(items, destinationType, context);
}
return null;
}
public static CheckedContext CreateInstance(
BindingContext parentCtx,
bool checkedNormal,
bool checkedConstant)
{
return new CheckedContext(parentCtx, checkedNormal, checkedConstant);
}
void FillMessageEncoder (BindingContext ctx)
{
var mbe = (MessageEncodingBindingElement) ctx.Binding.Elements.FirstOrDefault (be => be is MessageEncodingBindingElement);
if (mbe == null)
mbe = new TextMessageEncodingBindingElement ();
message_encoder = mbe.CreateMessageEncoderFactory ().Encoder;
}
// channel factory
public UdpDuplexChannel (UdpChannelFactory factory, BindingContext ctx, EndpointAddress address, Uri via)
: base (factory)
{
binding_element = factory.Source;
RemoteAddress = address;
Via = via;
}
/// <summary>
/// Deserialize the request body to a model
/// </summary>
/// <param name="mediaRange">Content type to deserialize</param>
/// <param name="bodyStream">Request body stream</param>
/// <param name="context">Current context</param>
/// <returns>Model instance</returns>
public object Deserialize(MediaRange mediaRange, Stream bodyStream, BindingContext context)
{
if (bodyStream.CanSeek)
{
bodyStream.Position = 0;
}
var deserializedObject = ServiceStack.JsonSerializer.DeserializeFromStream(context.DestinationType, bodyStream);
if (deserializedObject == null)
{
return null;
}
IEnumerable<BindingMemberInfo> properties;
IEnumerable<BindingMemberInfo> fields;
if (context.DestinationType.IsGenericType)
{
var genericType = context.DestinationType.GetGenericArguments().FirstOrDefault();
properties = genericType.GetProperties(BindingFlags.Public | BindingFlags.Instance).Select(p => new BindingMemberInfo(p));
fields = genericType.GetFields(BindingFlags.Public | BindingFlags.Instance).Select(p => new BindingMemberInfo(p));
}
else
{
properties = context.DestinationType.GetProperties(BindingFlags.Public | BindingFlags.Instance).Select(p => new BindingMemberInfo(p));
fields = context.DestinationType.GetFields(BindingFlags.Public | BindingFlags.Instance) .Select(p => new BindingMemberInfo(p));
}
return properties.Concat(fields).Except(context.ValidModelBindingMembers).Any()
? CreateObjectWithBlacklistExcluded(context, deserializedObject)
: deserializedObject;
}
public override void OnInspectorGUI()
{
base.OnInspectorGUI();
Target = target as BindingContext;
if (Target == null)
return;
ModeSelection();
switch (Target.ContextMode)
{
case BindingContext.BindingContextMode.MonoBinding:
MonoSelection();
Target.FindModel();
break;
case BindingContext.BindingContextMode.MockBinding:
DrawNamespaceDrop();
DrawTypeDrop();
Target.FindModel();
break;
case BindingContext.BindingContextMode.PropBinding:
PropSelection();
Target.FindModel();
break;
default:
EditorGUILayout.LabelField("Please select a binding mode.");
break;
}
}
public RabbitMQTransportOutputChannel(BindingContext context, EndpointAddress address, Uri via)
: base(context, address, via)
{
_bindingElement = context.Binding.Elements.Find<RabbitMQTransportBindingElement>();
MessageEncodingBindingElement encoderElement;
if (_bindingElement.MessageFormat == MessageFormat.MTOM)
{
encoderElement = context.Binding.Elements.Find<MtomMessageEncodingBindingElement>();
}
else if (_bindingElement.MessageFormat == MessageFormat.NetBinary)
{
encoderElement = context.Binding.Elements.Find<BinaryMessageEncodingBindingElement>();
}
else
{
encoderElement = context.Binding.Elements.Find<TextMessageEncodingBindingElement>();
}
if (encoderElement != null)
{
_encoder = encoderElement.CreateMessageEncoderFactory().Encoder;
}
_messageProcessor = context.BindingParameters.Find<IFaultMessageProcessor>();
}
/// <summary>
/// Convert the string representation to the destination type
/// </summary>
/// <param name="input">Input string</param>
/// <param name="destinationType">Destination type</param>
/// <param name="context">Current context</param>
/// <returns>Converted object of the destination type</returns>
public object Convert(string input, Type destinationType, BindingContext context)
{
// TODO - Lots of reflection in here, should probably cache the methodinfos
if (string.IsNullOrEmpty(input))
{
return null;
}
var items = input.Split(',');
// Strategy, schmategy ;-)
if (this.IsCollection(destinationType))
{
return this.ConvertCollection(items, destinationType, context);
}
if (this.IsArray(destinationType))
{
return this.ConvertArray(items, destinationType, context);
}
if (this.IsEnumerable(destinationType))
{
return this.ConvertEnumerable(items, destinationType, context);
}
return null;
}
internal MsmqIntegrationChannelListener(MsmqBindingElementBase bindingElement, BindingContext context, MsmqReceiveParameters receiveParameters)
: base(bindingElement, context, receiveParameters, null)
{
SetSecurityTokenAuthenticator(MsmqUri.FormatNameAddressTranslator.Scheme, context);
MsmqIntegrationReceiveParameters parameters = receiveParameters as MsmqIntegrationReceiveParameters;
xmlSerializerList = XmlSerializer.FromTypes(parameters.TargetSerializationTypes);
}
protected RabbitMQInputChannelBase(BindingContext context, EndpointAddress localAddress)
:base(context)
{
m_localAddress = localAddress;
m_receiveMethod = new CommunicationOperation<Message>(Receive);
m_tryReceiveMethod = new CommunicationOperation<bool, Message>(TryReceive);
m_waitForMessage = new CommunicationOperation<bool>(WaitForMessage);
}
public Task<IValueProvider> BindAsync(BindingContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
return BindAccountAsync(_account, context.ValueContext);
}
protected SspiSecurityTokenParameters(SspiSecurityTokenParameters other) : base(other)
{
this.requireCancellation = other.requireCancellation;
if (other.issuerBindingContext != null)
{
this.issuerBindingContext = other.issuerBindingContext.Clone();
}
}
public Task<IValueProvider> BindAsync(BindingContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
return BindAsync(context.FunctionCancellationToken, context.ValueContext);
}
protected ZMQReceivingChannelBase(ChannelManagerBase channelManager, BindingContext bindingContext, Context context, Socket socket, SocketMode socketMode)
: base(channelManager, bindingContext, socket, socketMode)
{
_onReceiveHandler = Receive;
_onTryReceiveHandler = TryReceive;
_onWaitForMessageHandler = WaitForMessage;
_context = context;
}
protected RabbitMQInputChannelBase(BindingContext context, EndpointAddress localAddress)
: base(context)
{
_localAddress = localAddress;
_receiveMethod = Receive;
_tryReceiveMethod = TryReceive;
_waitForMessage = WaitForMessage;
}
protected MsmqChannelListenerBase(MsmqBindingElementBase bindingElement,
BindingContext context,
MsmqReceiveParameters receiveParameters,
MessageEncoderFactory messageEncoderFactory)
: base(bindingElement, context, messageEncoderFactory)
{
this.receiveParameters = receiveParameters;
}
/// <summary>
/// Deserialize the request body to a model
/// </summary>
/// <param name="mediaRange">Content type to deserialize</param>
/// <param name="bodyStream">Request body stream</param>
/// <param name="context">Current context</param>
/// <returns>Model instance</returns>
public object Deserialize(MediaRange mediaRange, Stream bodyStream, BindingContext context)
{
if (bodyStream.CanSeek)
{
bodyStream.Position = 0;
}
return RuntimeTypeModel.Default.Deserialize(bodyStream, null, context.DestinationType);
}
public override void ApplyHostedContext(TransportChannelListener listener, BindingContext context)
{
VirtualPathExtension extension = context.BindingParameters.Find<VirtualPathExtension>();
if (extension != null)
{
HostedMetadataBindingParameter parameter = context.BindingParameters.Find<HostedMetadataBindingParameter>();
listener.ApplyHostedContext(extension.VirtualPath, parameter != null);
}
}
private void Startup ()
{
using (var pool = new NSAutoreleasePool ()) {
InvokeOnMainThread (delegate {
var binding = new BindingContext (new MovieListView (), "Movie List View");
navigation.ViewControllers = new UIViewController[] { new DialogViewController (binding.Root, true) };
});
}
}
/// <summary>
/// Convert the string representation to the destination type
/// </summary>
/// <param name="input">Input string</param>
/// <param name="destinationType">Destination type</param>
/// <param name="context">Current context</param>
/// <returns>Converted object of the destination type</returns>
public object Convert(string input, Type destinationType, BindingContext context)
{
if (string.IsNullOrEmpty(input))
{
return null;
}
return System.Convert.ChangeType(input, destinationType, context.Context.Culture);
}
/// <summary>
/// Deserialize the request body to a model
/// </summary>
/// <param name="mediaRange">Content type to deserialize</param>
/// <param name="bodyStream">Request body stream</param>
/// <param name="context">Current <see cref="BindingContext"/>.</param>
/// <returns>Model instance</returns>
public object Deserialize(MediaRange mediaRange, Stream bodyStream, BindingContext context)
{
if (bodyStream.CanSeek)
{
bodyStream.Position = 0;
}
var ser = new XmlSerializer(context.DestinationType);
return ser.Deserialize(bodyStream);
}
public void BuildChannelFactory ()
{
CustomBinding cb = new CustomBinding (
new HttpTransportBindingElement ());
BindingContext ctx = new BindingContext (
cb, new BindingParameterCollection ());
Element el = new Element ();
IChannelFactory<IRequestChannel> cf =
el.BuildChannelFactory<IRequestChannel> (ctx);
}
public RabbitMQOutputChannel(BindingContext context, IModel model, EndpointAddress address)
: base(context, address)
{
m_bindingElement = context.Binding.Elements.Find<RabbitMQTransportBindingElement>();
MessageEncodingBindingElement encoderElement = context.Binding.Elements.Find<MessageEncodingBindingElement>();
if (encoderElement != null) {
m_encoder = encoderElement.CreateMessageEncoderFactory().Encoder;
}
m_model = model;
}
protected override void InitializeFields()
{
base.InitializeFields();
BindingContext bindingContext = this.BindingContext;
}
public QuickJSSources(BindingContext context, IEnumerable <TranslationUnit> units)
: base(context, units)
{
CTypePrinter.PushContext(TypePrinterContextKind.Managed);
}
public BindableToolStripMenuItem(string text) :
base(text)
{
m_Ctx = new BindingContext();
m_DataBindings = new ControlBindingsCollection(this);
}
public CppGenerator(BindingContext context) : base(context)
{
typePrinter = new CppTypePrinter(Context);
}
private void AnnounceBindingContext()
{
System.Diagnostics.Debug.WriteLine(GetType().Name);
System.Diagnostics.Debug.WriteLine($"BindingContext: {BindingContext?.GetType()?.Name}");
}
public void DemoReflectionApi()
{
if (settings == null)
{
var image = UIImage.FromFile("monodevelop-32.png");
settings = new Settings()
{
AccountEnabled = true,
Login = "******",
TimeSamples = new TimeSettings()
{
Appointment = DateTime.Now,
Birthday = new DateTime(1980, 6, 24),
Alarm = new DateTime(2000, 1, 1, 7, 30, 0, 0)
},
FavoriteType = TypeCode.Int32,
Top = image,
Middle = image,
Bottom = image,
ListOfString = new List <string> ()
{
"One", "Two", "Three"
}
};
}
var cb = new Callbacks();
var bc = new BindingContext(cb, settings, "Settings");
cb.Initalize(bc);
var dv = new DialogViewController(bc.Root, true);
// When the view goes out of screen, we fetch the data.
dv.ViewDisappearing += delegate {
// This reflects the data back to the object instance
bc.Fetch();
// Manly way of dumping the data.
Console.WriteLine("Current status:");
Console.WriteLine(
"AccountEnabled: {0}\n" +
"Login: {1}\n" +
"Password: {2}\n" +
"Name: {3}\n"+
"Appointment: {4}\n" +
"Birthday: {5}\n" +
"Alarm: {6}\n" +
"Favorite Type: {7}\n" +
"IEnumerable idx: {8}\n" +
"I like ice cream: {9}\n" +
"I like veggies: {10}\n" +
"Animal kinds: {11}\n" +
"Animal sizes: {12}",
settings.AccountEnabled, settings.Login, settings.Password, settings.Name,
settings.TimeSamples.Appointment, settings.TimeSamples.Birthday,
settings.TimeSamples.Alarm, settings.FavoriteType,
settings.selected,
settings.LikeIceCream, settings.LikeVegetables,
settings.Kinds, settings.Sizes);
};
navigation.PushViewController(dv, true);
}
public void BindingContext_Add_NullListManager_ThrowsArgumentNullException()
{
var context = new BindingContext();
Assert.Throws <ArgumentNullException>("listManager", () => context.Add(1, null));
}
public override IChannelListener <TChannel> BuildChannelListener <TChannel>(BindingContext context)
{
IChannelListener <TChannel> listener = (IChannelListener <TChannel>)base.BuildChannelListener <TChannel>(context);
return(listener);
}
protected override void OnBindingContextChanged()
{
base.OnBindingContextChanged();
UpdateBackgroundColor(BindingContext.Equals(_previouslySelectedBindingContext));
}
protected override void OnBindingContextChanged()
{
base.OnBindingContextChanged();
System.Diagnostics.Debug.WriteLine(BindingContext.ToString());
}
protected override void OnShown()
{
base.OnShown();
BindingContext = new BindingContext();
customers = new List <Customer>()
{
new Customer()
{
CompanyID = 1, CompanyName = "Acme Workshop"
},
new Customer()
{
CompanyID = 2, CompanyName = "Sirius Tech"
}
};
formscombobox1.DataSource = customers;
formscombobox1.DisplayMember = "CompanyName";
formscombobox1.ValueMember = "CompanyID";
formslabel1.DataBindings.Add("Text", customers, "CompanyId");
customers2 = new NotifiedBindingList <Customer>()
{
new Customer()
{
CompanyID = 1, CompanyName = "Acme Workshop"
},
new Customer()
{
CompanyID = 2, CompanyName = "Sirius Tech"
}
};
bsrcCustomers = new BindingSource()
{
DataSource = customers2
};
formscombobox2.DataSource = bsrcCustomers;
formscombobox2.DisplayMember = "CompanyName";
formscombobox2.ValueMember = "CompanyID";
formslabel2.DataBindings.Add("Text", bsrcCustomers, "CompanyId");
customers3 = new NotifiedBindingList <Customer>()
{
new Customer()
{
CompanyID = 1, CompanyName = "Acme Workshop"
},
new Customer()
{
CompanyID = 2, CompanyName = "Sirius Tech"
}
};
formscomboboxentry1.DataSource = customers3;
formscomboboxentry1.DisplayMember = "CompanyName";
formscomboboxentry1.ValueMember = "CompanyID";
formscomboboxentry1.DataBindings.Add("Text", customers3, "CompanyName", true, DataSourceUpdateMode.OnPropertyChanged);
formslabel3.DataBindings.Add("Text", customers3, "CompanyId");
formslabel4.DataBindings.Add("Text", customers3, "CompanyName");
var bsrcCities = new BindingSource()
{
DataSource = new NotifiedBindingList <string> {
"Warszawa", "Krakow"
}
};
//formscombobox3.DataSource = bsrcCities;
City city = new City();
//city.CityName = "Krakow";
formscombobox3.DataSource = bsrcCities;
formscombobox3.DataBindings.Add("SelectedItem", city, "CityName", false, DataSourceUpdateMode.OnPropertyChanged);
formscombobox3.DataBindings[0].WriteValue();
labelCityName.DataBindings.Add("Text", city, "CityName");
// formscombobox3.DataSource = bsrcCities;
city.CityType = CityTypes.City;
comboboxEnum.DataSource = Enum.GetValues(typeof(CityTypes));
comboboxEnum.DataBindings.Add("SelectedItem", city, "CityType", false, DataSourceUpdateMode.OnPropertyChanged);
// comboboxEnum.DataSource = Enum.GetValues (typeof(CityTypes));
labelEnum.DataBindings.Add("Text", city, "CityType");
City city2 = new City();
comboboxEnum2.DataSource = Enum.GetValues(typeof(CityTypes));
comboboxEnum2.DataBindings.Add("SelectedItem", city2, "CityType", false, DataSourceUpdateMode.OnPropertyChanged);
comboboxEnum2.DataBindings [0].WriteValue();
labelEnum2.DataBindings.Add("Text", city2, "CityType");
}
public AmqpChannelFactory(AmqpTransportBindingElement transportBindingElement, BindingContext context) : base(transportBindingElement, context)
{
this.transportBindingElement = transportBindingElement;
this.sharedAmqpConnections = new ConcurrentDictionary <string, AmqpChannelFactory.SharedAmqpConnection>();
this.sharedAmqpLinks = new ConcurrentDictionary <string, AmqpChannelFactory.SharedAmqpLink>();
this.amqpChannelEvents = new AmqpChannelFactory.AmqpChannelEvents(this);
}
public MyChannelFactory(BindingContext context)
{
this.InnerChannelFactory = context.BuildInnerChannelFactory <TChannel>();
}
public Task <IValueProvider> BindAsync(BindingContext context)
{
return(BindAsync(context, null));
}
public CHeaders(BindingContext context, TranslationUnit unit)
: base(context, unit)
{
}
public override bool CanBuildChannelFactory <TChannel>(BindingContext context)
{
return(false);
}
public void BindingContext_UpdateBinding_NullBinding_ThrowsArgumentNullException()
{
Assert.Throws <ArgumentNullException>("binding", () => BindingContext.UpdateBinding(new BindingContext(), null));
}
public CSharpTypePrinter(BindingContext context)
{
Context = context;
}
public void Bind(BindingContext <object> ctx)
{
ctx.ObjectValue = arg;
next(ctx);
}
public SimpleSessionChannelFactory(BindingContext context)
: base(context)
{
this.Print("SimpleSessionChannelFactory()");
}
public ChoToolStripBindableButton()
{
DataBindings = new ControlBindingsCollection(this);
BindingContext = new BindingContext();
}
private static async Task ProcessOutputBindingsAsync(Collection <FunctionBinding> outputBindings, object input, Binder binder,
Dictionary <string, object> bindingData, Dictionary <string, object> scriptExecutionContext, object functionResult)
{
if (outputBindings == null)
{
return;
}
var bindings = (Dictionary <string, object>)scriptExecutionContext["bindings"];
var returnValueBinding = outputBindings.SingleOrDefault(p => p.Metadata.IsReturn);
if (returnValueBinding != null)
{
// if there is a $return binding, bind the entire function return to it
// if additional output bindings need to be bound, they'll have to use the explicit
// context.bindings mechanism to set values, not return value.
bindings[ScriptConstants.SystemReturnParameterBindingName] = functionResult;
}
else
{
// if the function returned binding values via the function result,
// apply them to context.bindings
IDictionary <string, object> functionOutputs = functionResult as IDictionary <string, object>;
if (functionOutputs != null)
{
foreach (var output in functionOutputs)
{
bindings[output.Key] = output.Value;
}
}
}
foreach (FunctionBinding binding in outputBindings)
{
// get the output value from the script
object value = null;
bool haveValue = bindings.TryGetValue(binding.Metadata.Name, out value);
if (!haveValue && binding.Metadata.Type == "http")
{
// http bindings support a special context.req/context.res programming
// model, so we must map that back to the actual binding name if a value
// wasn't provided using the binding name itself
haveValue = bindings.TryGetValue("res", out value);
}
// apply the value to the binding
if (haveValue && value != null)
{
value = ConvertBindingValue(value);
BindingContext bindingContext = new BindingContext
{
TriggerValue = input,
Binder = binder,
BindingData = bindingData,
Value = value
};
await binding.BindAsync(bindingContext);
}
}
}
public override bool CanBuildChannelListener <TChannel>(BindingContext context)
{
return(typeof(TChannel) == typeof(IReplyChannel));
}
public BindableToolStripMenuItem(System.Drawing.Image image) :
base(image)
{
m_Ctx = new BindingContext();
m_DataBindings = new ControlBindingsCollection(this);
}
public BindableToolStripMenuItem(string text, System.Drawing.Image image, EventHandler onClick, string name) :
base(text, image, onClick, name)
{
m_Ctx = new BindingContext();
m_DataBindings = new ControlBindingsCollection(this);
}
protected BaseModuleControl(Func <object> viewModelnjector)
{
BindingContext = new BindingContext();
viewModelCore = viewModelnjector();
InitServices();
}
public BindableToolStripMenuItem(string text, System.Drawing.Image image, params ToolStripItem[] dropDownItems) :
base(text, image, dropDownItems)
{
m_Ctx = new BindingContext();
m_DataBindings = new ControlBindingsCollection(this);
}
public void Bind(BindingContext <string> ctx)
{
}
public override IChannelListener <TChannel> BuildChannelListener <TChannel>(BindingContext context)
{
context.BindingParameters.Add(this);
return(context.BuildInnerChannelListener <TChannel>());
}
public override bool CanBuildChannelListener <TChannel>(BindingContext context)
{
return(context.CanBuildInnerChannelListener <TChannel>());
}
