public void TestDuplicateUnbinding()
{
Binder binder = new Binder();
var equivalent = new EventEquivalent();
List<Handler> handlerChain = new List<Handler>();
binder.Bind(new SampleEvent1 { Foo = 1 }, new MethodHandler<SampleEvent1>(OnSampleEvent1));
binder.Bind(new SampleEvent1 { Foo = 2 }, new MethodHandler<SampleEvent1>(OnSpecificSampleEvent1));
binder.Unbind(new SampleEvent1 { Foo = 1 }, new MethodHandler<SampleEvent1>(OnSampleEvent1));
binder.Unbind(new SampleEvent1 { Foo = 1 }, new MethodHandler<SampleEvent1>(OnSampleEvent1));
handlerChain.Clear();
Assert.AreEqual(0, binder.BuildHandlerChain(new SampleEvent1 { Foo = 1 }, equivalent, handlerChain));
Assert.AreEqual(1, binder.BuildHandlerChain(new SampleEvent1 { Foo = 2 }, equivalent, handlerChain));
Assert.AreEqual(new MethodHandler<SampleEvent1>(OnSpecificSampleEvent1), handlerChain[0]);
// with EventSink
var sink = new SampleEventSink();
sink.Bind(new SampleEvent1 { Foo = 1 }, sink.OnSampleEvent1);
sink.Unbind(new SampleEvent1 { Foo = 1 }, sink.OnSampleEvent1);
sink.Bind(new SampleEvent1 { Foo = 1 }, sink.OnSampleEvent1);
handlerChain.Clear();
Assert.AreEqual(0, binder.BuildHandlerChain(new SampleEvent1 { Foo = 1 }, equivalent, handlerChain));
Assert.AreEqual(1, binder.BuildHandlerChain(new SampleEvent1 { Foo = 2 }, equivalent, handlerChain));
Assert.AreEqual(new MethodHandler<SampleEvent1>(OnSpecificSampleEvent1), handlerChain[0]);
}
public void TestContainsByType()
{
var binder = new Binder();
binder.Bind<MockClassToDepend>().ToSelf();
binder.Bind<IMockInterface>().To<MockIClassWithAttributes>();
var contains = binder.ContainsBindingFor(typeof(IMockInterface));
Assert.AreEqual(true, contains);
}
public void TestGetAll()
{
var binder = new Binder();
binder.Bind(typeof(IMockInterface)).To<MockIClassWithAttributes>();
binder.Bind<IMockInterface>().To<MockIClassWithAttributes>().As("test");
var bindings = binder.GetBindings();
Assert.AreEqual(2, bindings.Count);
}
public void TestContainsByIdentifier()
{
var binder = new Binder();
binder.Bind<IMockInterface>().To<MockIClass>();
binder.Bind<IMockInterface>().To<MockIClassWithAttributes>().As("Identifier");
var contains = binder.ContainsBindingFor("Identifier");
Assert.AreEqual(true, contains);
}
public void TestBinder()
{
var model = new ModelTestClass
{
Number = 1,
Text = "First"
};
var control = new ControlTestClass
{
Text = "Wrong",
Number = -1
};
var textProp = new BindableProperty<ControlTestClass, string>(control, o => o.Text, (o, action) => o.TextChanged += (sender, args) => action());
int[] controlCounts = { 0 };
textProp.PropertyChanged += (sender, args) => controlCounts[0]++;
int[] modelCounts = { 0 };
model.PropertyChanged += (sender, args) => modelCounts[0]++;
var binder = new Binder<ModelTestClass, ControlTestClass, string, string>(m => m.Text, () => DataConverter<string>.EmptyConverter);
var bInfo = binder.Bind(model, textProp, BindingMode.OneTime);
TestOneTimeBindingInfo(bInfo, model, control, ref modelCounts[0], ref controlCounts[0]);
bInfo.Unbind();
model.Text = "First";
modelCounts[0] = 0;
control.Text = "Wrong";
controlCounts[0] = 0;
textProp = new BindableProperty<ControlTestClass, string>(control, o => o.Text, (o, action) => o.TextChanged += (sender, args) => action());
bInfo = binder.Bind(model, textProp, BindingMode.OneWay);
TestOneWayBindingInfo(bInfo, model, control, ref modelCounts[0], ref controlCounts[0]);
bInfo.Unbind();
model.Text = "Wrong";
control.Text = "First";
modelCounts[0] = 0;
controlCounts[0] = 0;
textProp = new BindableProperty<ControlTestClass, string>(control, o => o.Text, (o, action) => o.TextChanged += (sender, args) => action());
bInfo = binder.Bind(model, textProp, BindingMode.OneWayToSource);
TestOneWayToSourceBindingInfo(bInfo, model, control, modelCounts, controlCounts);
bInfo.Unbind();
model.Text = "First";
modelCounts[0] = 0;
control.Text = "Wrong";
controlCounts[0] = 0;
textProp = new BindableProperty<ControlTestClass, string>(control, o => o.Text, (o, action) => o.TextChanged += (sender, args) => action());
bInfo = binder.Bind(model, textProp, BindingMode.TwoWay);
TestTwoWayBindingInfo(bInfo, model, control, ref modelCounts[0], ref controlCounts[0]);
bInfo.Unbind();
}
public void TestBindNotAssignableInstanceTypeToInstance()
{
var binder = new Binder();
var instance = new MockClassToDepend();
binder.Bind<MockClassToDepend>().To(typeof(MockClassVerySimple), instance);
}
public void TestAfterInject()
{
var eventCalled = false;
IReflectionCache cache = new ReflectionCache();
IBinder binder = new Binder();
IInjector injector = new Injector(cache, binder);
var instanceToInject = new MockClassVerySimple();
injector.afterInject += delegate(IInjector source, ref object instance, ReflectedClass reflectedClass) {
//The if below is just to avoid checking when injecting on MockIClass.
if (reflectedClass.type != typeof(MockClassVerySimple)) return;
Assert.AreEqual(injector, source);
Assert.AreEqual(instanceToInject, instance);
Assert.AreEqual(typeof(MockIClass), instanceToInject.field.GetType());
eventCalled = true;
};
binder.Bind<IMockInterface>().To<MockIClass>();
injector.Inject(instanceToInject);
Assert.IsTrue(eventCalled);
}
public void TestAfterResolve()
{
var eventCalled = false;
IReflectionCache cache = new ReflectionCache();
IBinder binder = new Binder();
IInjector injector = new Injector(cache, binder);
IMockInterface resolvedInstance = null;
injector.afterResolve += delegate(IInjector source,
Type type,
InjectionMember member,
object parentInstance,
object identifier,
ref object resolutionInstance) {
Assert.AreEqual(injector, source);
Assert.AreEqual(typeof(IMockInterface), type);
Assert.AreEqual(InjectionMember.None, member);
Assert.IsNull(parentInstance);
Assert.IsNull(identifier);
Assert.IsNotNull(resolutionInstance);
resolvedInstance = (IMockInterface)resolutionInstance;
eventCalled = true;
return false;
};
binder.Bind<IMockInterface>().To<MockIClass>();
var instance = injector.Resolve<IMockInterface>();
Assert.IsTrue(eventCalled);
Assert.AreEqual(typeof(MockIClass), instance.GetType());
Assert.AreEqual(resolvedInstance, instance);
}
public void TestGetBindingsForGenerics()
{
var binder = new Binder();
binder.Bind<MockClassToDepend>().ToSelf();
binder.Bind(typeof(IMockInterface)).To<MockIClassWithAttributes>();
binder.Bind<IMockInterface>().To<MockIClassWithAttributes>().As("test");
var bindings = binder.GetBindingsFor<IMockInterface>();
Assert.AreEqual(2, bindings.Count);
Assert.AreEqual(typeof(IMockInterface), bindings[0].type);
Assert.IsNull(bindings[0].identifier);
Assert.AreEqual(typeof(IMockInterface), bindings[1].type);
Assert.AreEqual("test", bindings[1].identifier);
}
public void TestBinding()
{
Binder binder = new Binder();
var equivalent = new EventEquivalent();
binder.Bind(new SampleEvent1(), new MethodHandler<SampleEvent1>(OnSampleEvent1));
var e1 = new SampleEvent1();
var e2 = new SampleEvent1 { Foo = 1 };
var e3 = new SampleEvent1 { Foo = 1, Bar = "bar" };
List<Handler> handlerChain = new List<Handler>();
handlerChain.Clear();
Assert.AreEqual(1, binder.BuildHandlerChain(e1, equivalent, handlerChain));
Assert.AreEqual(new MethodHandler<SampleEvent1>(OnSampleEvent1), handlerChain[0]);
handlerChain.Clear();
Assert.AreEqual(1, binder.BuildHandlerChain(e2, equivalent, handlerChain));
Assert.AreEqual(new MethodHandler<SampleEvent1>(OnSampleEvent1), handlerChain[0]);
handlerChain.Clear();
Assert.AreEqual(1, binder.BuildHandlerChain(e3, equivalent, handlerChain));
Assert.AreEqual(new MethodHandler<SampleEvent1>(OnSampleEvent1), handlerChain[0]);
binder.Unbind(new SampleEvent1(), new MethodHandler<SampleEvent1>(OnSampleEvent1));
handlerChain.Clear();
Assert.AreEqual(0, binder.BuildHandlerChain(e1, equivalent, handlerChain));
handlerChain.Clear();
Assert.AreEqual(0, binder.BuildHandlerChain(e2, equivalent, handlerChain));
handlerChain.Clear();
Assert.AreEqual(0, binder.BuildHandlerChain(e3, equivalent, handlerChain));
}
public void TestBindNotAssignableKeyTypeToInstance()
{
var binder = new Binder();
var instance = new MockClassToDepend();
binder.Bind<IMockInterface>().To<MockClassToDepend>(instance);
}
public void TestBindingToMultipleSingletonByInstance()
{
var binder = new Binder();
binder.Bind<MockIClassWithAttributes>().To(new MockIClassWithAttributes());
binder.Bind<IMockInterface>().ToSingleton<MockIClassWithAttributes>();
var bindings1 = binder.GetBindingsFor<MockIClassWithAttributes>();
var bindings2 = binder.GetBindingsFor<IMockInterface>();
Assert.AreEqual(1, bindings1.Count);
Assert.AreEqual(1, bindings2.Count);
Assert.AreEqual(BindingInstance.Singleton, bindings1[0].instanceType);
Assert.AreEqual(BindingInstance.Singleton, bindings2[0].instanceType);
Assert.AreEqual(typeof(MockIClassWithAttributes), bindings1[0].type);
Assert.AreEqual(typeof(IMockInterface), bindings2[0].type);
Assert.AreEqual(bindings1[0].value, bindings1[0].value);
}
public void TestBindingToFactoryTypeFromInterface()
{
var binder = new Binder();
var type = typeof(MockFactory);
binder.Bind<IMockInterface>().ToFactory(type);
var bindings = binder.GetBindingsFor<IMockInterface>();
Assert.AreEqual(1, bindings.Count);
Assert.AreEqual(BindingInstance.Factory, bindings[0].instanceType);
Assert.AreEqual(typeof(IMockInterface), bindings[0].type);
Assert.AreEqual(type, bindings[0].value);
}
public void TestBindingToInstanceFromInterface()
{
var binder = new Binder();
var instance = new MockIClassWithAttributes();
binder.Bind<IMockInterface>().To<MockIClassWithAttributes>(instance);
var bindings = binder.GetBindingsFor<IMockInterface>();
Assert.AreEqual(1, bindings.Count);
Assert.AreEqual(BindingInstance.Singleton, bindings[0].instanceType);
Assert.AreEqual(typeof(IMockInterface), bindings[0].type);
Assert.AreEqual(instance, bindings[0].value);
}
public void TestDuplicateBinding()
{
Binder binder = new Binder();
List<Handler> handlerChain = new List<Handler>();
binder.Bind(new SampleEvent1 { Foo = 1 }, new MethodHandler<SampleEvent1>(OnSampleEvent1));
binder.Bind(new SampleEvent1 { Foo = 1 }, new MethodHandler<SampleEvent1>(OnSampleEvent1));
binder.Unbind(new SampleEvent1 { Foo = 1 }, new MethodHandler<SampleEvent1>(OnSampleEvent1));
Assert.AreEqual(0, binder.BuildHandlerChain(new SampleEvent1 { Foo = 1 }, handlerChain));
// with EventSink
var sink = new SampleEventSink();
sink.Bind(new SampleEvent1 { Foo = 1 }, sink.OnSampleEvent1);
sink.Bind(new SampleEvent1 { Foo = 1 }, sink.OnSampleEvent1);
sink.Unbind(new SampleEvent1 { Foo = 1 }, sink.OnSampleEvent1);
handlerChain.Clear();
Assert.AreEqual(0, binder.BuildHandlerChain(new SampleEvent1 { Foo = 1 }, handlerChain));
}
public void TestBeforeAddBindingEvent()
{
var eventCalled = false;
IBinder binder = new Binder();
binder.beforeAddBinding += delegate(IBinder source, ref BindingInfo binding) {
Assert.AreEqual(binder, source);
Assert.AreEqual(typeof(IMockInterface), binding.type);
Assert.AreEqual(0, binder.GetBindings().Count);
eventCalled = true;
};
binder.Bind<IMockInterface>().To<MockIClass>();
Assert.IsTrue(eventCalled);
}
public void TestBasicPerformance()
{
Binder binder = new Binder();
var equivalent = new EventEquivalent();
List<Handler> handlerChain = new List<Handler>();
binder.Bind(new SampleEvent1 { Foo = 1 }, new MethodHandler<SampleEvent1>(OnSampleEvent1));
// const int testCount = 1000000;
const int testCount = 1;
for (var i = 0; i < testCount; ++i)
{
binder.BuildHandlerChain(new SampleEvent1 {Foo = 1}, equivalent, handlerChain);
}
// 1,000,000 counts in 342 ms in release mode
}
public void TestAfterRemoveBindingEvent()
{
var eventCalled = false;
IBinder binder = new Binder();
binder.afterRemoveBinding += delegate(IBinder source, Type type, IList<BindingInfo> bindings) {
Assert.AreEqual(binder, source);
Assert.AreEqual(typeof(IMockInterface), type);
Assert.AreEqual(1, bindings.Count);
Assert.AreEqual(typeof(MockIClass), bindings[0].value);
Assert.AreEqual(0, binder.GetBindings().Count);
eventCalled = true;
};
binder.Bind<IMockInterface>().To<MockIClass>();
binder.Unbind<IMockInterface>();
Assert.IsTrue(eventCalled);
}
public void ShouldBindIndexedField()
{
var binder = new Binder<UniversalStub>();
var stub = new UniversalStub();
stub.Dictionary = new ObservableDictionary<string>();
binder.Bind(x => x.Dictionary["test"]).To(x => x.String);
using (binder.Attach(stub))
{
stub.String.ShouldBe(null);
using (stub.VerifyChangedOnce("String"))
{
stub.Dictionary.Add("test", "a");
}
stub.String.ShouldBe("a");
}
}
public void ShouldBindAggregatedCollectionOfValueTypes()
{
var binder = new Binder<AggregatedCollection<int>>();
binder.Bind(x => x.Sum()).To(x => x.Aggregate);
var collection = new AggregatedCollection<int>();
using (binder.Attach(collection))
{
collection.Aggregate.ShouldBe(0);
using (collection.VerifyChangedOnce("Aggregate"))
{
collection.Add(1);
}
collection.Aggregate.ShouldBe(1);
using (collection.VerifyChangedOnce("Aggregate"))
{
collection.Add(2);
}
collection.Aggregate.ShouldBe(3);
using (collection.VerifyChangedOnce("Aggregate"))
{
collection[0] = 3;
}
collection.Aggregate.ShouldBe(5);
using (collection.VerifyChangedOnce("Aggregate"))
{
collection.RemoveAt(1);
}
collection.Aggregate.ShouldBe(3);
using (collection.VerifyChangedOnce("Aggregate"))
{
collection.Clear();
}
collection.Aggregate.ShouldBe(0);
}
}
public MvxBindableTableViewCell(string bindingText, IntPtr handle)
: base(handle)
{
InitialiseImageHelper();
_bindings = Binder.Bind(null, this, bindingText).ToList();
}
public MvxBindableTableViewCell(IEnumerable <MvxBindingDescription> bindingDescriptions, IntPtr handle)
: base(handle)
{
InitialiseImageHelper();
_bindings = Binder.Bind(null, this, bindingDescriptions).ToList();
}
public void TestUnbindByType()
{
var binder = new Binder();
binder.Bind<MockClassToDepend>().ToSelf();
binder.Bind<IMockInterface>().To<MockIClassWithAttributes>();
binder.Unbind(typeof(IMockInterface));
var bindings = binder.GetBindings();
Assert.AreEqual(1, bindings.Count);
Assert.AreEqual(typeof(MockClassToDepend), bindings[0].type);
}
public void Render()
{
Binder?.Bind();
Renderer?.Render();
}
public virtual void OnViewModelChanged(IViewModel newValue)
{
Binder.Unbind();
Binder.Bind(newValue);
}
/// <summary>
/// Generates the appropriate MSI file for the package.
/// </summary>
/// <param name="sourceDoc">WiX document to create MSI from.</param>
/// <param name="outputFile">File path for the MSI file.</param>
/// <returns>True if generation works, false if anything goes wrong.</returns>
private bool GenerateMsi(XmlDocument sourceDoc, string outputFile)
{
// Create the Compiler.
Compiler compiler = new Compiler();
compiler.Message += this.core.MessageEventHandler;
// Compile the source document.
Intermediate intermediate = compiler.Compile(sourceDoc);
if (intermediate == null)
{
return false;
}
// Create the variable resolver that will be used in the Linker and Binder.
WixVariableResolver wixVariableResolver = new WixVariableResolver();
wixVariableResolver.Message += this.core.MessageEventHandler;
// Create the Linker.
Linker linker = new Linker();
linker.Message += this.core.MessageEventHandler;
linker.WixVariableResolver = wixVariableResolver;
// Load the isolatedapp.wixlib.
System.Reflection.Assembly assembly = System.Reflection.Assembly.GetExecutingAssembly();
Library appLib = LoadLibraryHelper(assembly, "Microsoft.Tools.WindowsInstallerXml.Extensions.OfficeAddin.Data.OfficeAddin.wixlib", linker.TableDefinitions);
// Link the compiled source document and the isolatedapp.wixlib together.
SectionCollection sections = new SectionCollection();
sections.AddRange(intermediate.Sections);
sections.AddRange(appLib.Sections);
Output output = linker.Link(sections);
if (output == null)
{
return false;
}
// Tweak the compiled output to add a few GUIDs for Components from the oaddin.wixlib.
Table components = output.Tables["Component"];
foreach (Row row in components.Rows)
{
switch ((string)row[0])
{
case "ThisApplicationVersionRegistryKeyComponent":
row[1] = Guid.NewGuid().ToString("B");
break;
case "ThisApplicationCacheFolderComponent":
row[1] = Guid.NewGuid().ToString("B");
break;
case "ThisApplicationShortcutComponent":
row[1] = Guid.NewGuid().ToString("B");
break;
}
}
// Bind the final output.
Binder binder = new Binder();
binder.FileManager = new BinderFileManager();
binder.FileManager.SourcePaths.Add(Path.GetDirectoryName(outputFile));
binder.FileManager.SourcePaths.Add(this.source);
binder.FileManager.SourcePaths.Add(Path.GetDirectoryName(assembly.Location));
binder.Message += this.core.MessageEventHandler;
binder.WixVariableResolver = wixVariableResolver;
return binder.Bind(output, outputFile);
}
public static void AddBindings(this IMvxBindingContextOwner view, object target, string bindingText, object clearKey = null)
{
var bindings = Binder.Bind(view.BindingContext.DataContext, target, bindingText);
view.AddBindings(bindings, clearKey);
}
internal override Node Bind(Binder b)
{
b.Bind(Args);
return(null);
}
void IBindable.Bind()
{
Binder?.Bind();
}
public void Configure(Binder binder)
{
binder.Bind <ApplicationACLsManager>().ToInstance(new ApplicationACLsManager(new Configuration
()));
}
internal override Node Bind(Binder b)
{
b.Bind(ref Expr);
Expr.RequireGetAccess();
return(null);
}
public void TestGetBindingsForIdentifier()
{
var binder = new Binder();
binder.Bind<MockClassToDepend>().ToSelf();
binder.Bind(typeof(MockIClassWithAttributes)).ToSelf();
binder.Bind<IMockInterface>().To<MockIClass>();
binder.Bind<IMockInterface>().To<MockIClassWithAttributes>().As("Identifier");
binder.Bind<IMockInterface>().To<MockIClassWithoutAttributes>().As("Identifier");
var bindings = binder.GetBindingsFor("Identifier");
Assert.AreEqual(2, bindings.Count);
Assert.AreEqual(typeof(IMockInterface), bindings[0].type);
Assert.AreEqual(typeof(MockIClassWithAttributes), bindings[0].value);
Assert.AreEqual("Identifier", bindings[0].identifier);
Assert.AreEqual(typeof(IMockInterface), bindings[1].type);
Assert.AreEqual(typeof(MockIClassWithoutAttributes), bindings[1].value);
Assert.AreEqual("Identifier", bindings[1].identifier);
}
public void TestBindToInterfaceSingleton()
{
var binder = new Binder();
binder.Bind<IMockInterface>().ToSingleton();
}
public void TestHandlerChainBuilding()
{
Binder binder = new Binder();
var equivalent = new EventEquivalent();
binder.Bind(new SampleEvent1(), new MethodHandler<SampleEvent1>(OnSampleEvent1));
binder.Bind(new SampleEvent1 { Foo = 1 }, new MethodHandler<SampleEvent1>(OnSpecificSampleEvent1));
binder.Bind(new Event(), new MethodHandler<Event>(OnEvent));
var e1 = new SampleEvent1();
var e2 = new SampleEvent1 { Foo = 1 };
var e3 = new SampleEvent1 { Foo = 1, Bar = "bar" };
var e4 = new SampleEvent1 { Foo = 2 };
var e5 = new SampleEvent2 { Foo = 1, Bar = "bar" };
var e6 = new SampleEvent2 { Foo = 2, Bar = "bar" };
List<Handler> handlerChain = new List<Handler>();
handlerChain.Clear();
Assert.AreEqual(2, binder.BuildHandlerChain(e1, equivalent, handlerChain));
Assert.AreEqual(new MethodHandler<SampleEvent1>(OnSampleEvent1), handlerChain[0]);
Assert.AreEqual(new MethodHandler<Event>(OnEvent), handlerChain[1]);
handlerChain.Clear();
Assert.AreEqual(3, binder.BuildHandlerChain(e2, equivalent, handlerChain));
Assert.AreEqual(new MethodHandler<SampleEvent1>(OnSampleEvent1), handlerChain[0]);
Assert.AreEqual(new MethodHandler<SampleEvent1>(OnSpecificSampleEvent1), handlerChain[1]);
Assert.AreEqual(new MethodHandler<Event>(OnEvent), handlerChain[2]);
handlerChain.Clear();
Assert.AreEqual(3, binder.BuildHandlerChain(e3, equivalent, handlerChain));
Assert.AreEqual(new MethodHandler<SampleEvent1>(OnSampleEvent1), handlerChain[0]);
Assert.AreEqual(new MethodHandler<SampleEvent1>(OnSpecificSampleEvent1), handlerChain[1]);
Assert.AreEqual(new MethodHandler<Event>(OnEvent), handlerChain[2]);
handlerChain.Clear();
Assert.AreEqual(2, binder.BuildHandlerChain(e4, equivalent, handlerChain));
Assert.AreEqual(new MethodHandler<SampleEvent1>(OnSampleEvent1), handlerChain[0]);
Assert.AreEqual(new MethodHandler<Event>(OnEvent), handlerChain[1]);
handlerChain.Clear();
Assert.AreEqual(3, binder.BuildHandlerChain(e5, equivalent, handlerChain));
Assert.AreEqual(new MethodHandler<SampleEvent1>(OnSampleEvent1), handlerChain[0]);
Assert.AreEqual(new MethodHandler<SampleEvent1>(OnSpecificSampleEvent1), handlerChain[1]);
Assert.AreEqual(new MethodHandler<Event>(OnEvent), handlerChain[2]);
handlerChain.Clear();
Assert.AreEqual(2, binder.BuildHandlerChain(e6, equivalent, handlerChain));
Assert.AreEqual(new MethodHandler<SampleEvent1>(OnSampleEvent1), handlerChain[0]);
Assert.AreEqual(new MethodHandler<Event>(OnEvent), handlerChain[1]);
binder.Unbind(new SampleEvent1(), new MethodHandler<SampleEvent1>(OnSampleEvent1));
handlerChain.Clear();
Assert.AreEqual(1, binder.BuildHandlerChain(e1, equivalent, handlerChain));
Assert.AreEqual(new MethodHandler<Event>(OnEvent), handlerChain[0]);
binder.Unbind(new Event(), new MethodHandler<Event>(OnEvent));
handlerChain.Clear();
Assert.AreEqual(1, binder.BuildHandlerChain(e2, equivalent, handlerChain));
Assert.AreEqual(new MethodHandler<SampleEvent1>(OnSpecificSampleEvent1), handlerChain[0]);
handlerChain.Clear();
Assert.AreEqual(1, binder.BuildHandlerChain(e3, equivalent, handlerChain));
Assert.AreEqual(new MethodHandler<SampleEvent1>(OnSpecificSampleEvent1), handlerChain[0]);
handlerChain.Clear();
Assert.AreEqual(0, binder.BuildHandlerChain(e4, equivalent, handlerChain));
}
public void TestBindToInterfaceTransient()
{
var binder = new Binder();
binder.Bind<IMockInterface>().To<IMockInterface>();
}
public IEnumerable <object> BuildCallingArguments(RequestContext context, IApiMethodCall methodToCall)
{
var callArg = new List <object>();
var requestParams = GetRequestParams(context);
var methodParams = methodToCall.GetParams().Where(x => !x.IsRetval).OrderBy(x => x.Position);
foreach (var parameterInfo in methodParams)
{
if (requestParams[parameterInfo.Name] != null)
{
//convert
var values = requestParams.GetValues(parameterInfo.Name);
if (values != null && values.Any())
{
if (Binder.IsCollection(parameterInfo.ParameterType))
{
callArg.Add(Binder.Bind(parameterInfo.ParameterType, requestParams, parameterInfo.Name));
continue; //Go to next loop
}
try
{
callArg.Add(ConvertUtils.GetConverted(values.First(), parameterInfo)); //NOTE; Get first value!
}
catch (ApiArgumentMismatchException)
{
//Failed to convert. Try bind
callArg.Add(Binder.Bind(parameterInfo.ParameterType, requestParams, parameterInfo.Name));
}
}
}
else
{
//try get request param first. It may be form\url-encoded
if (!"GET".Equals(context.HttpContext.Request.HttpMethod, StringComparison.InvariantCultureIgnoreCase) && !string.IsNullOrEmpty(context.HttpContext.Request[parameterInfo.Name]))
{
//Drop to
callArg.Add(ConvertUtils.GetConverted(context.HttpContext.Request[parameterInfo.Name], parameterInfo));
}
else if (parameterInfo.ParameterType == typeof(ContentType) && !string.IsNullOrEmpty(context.HttpContext.Request.ContentType))
{
callArg.Add(new ContentType(context.HttpContext.Request.ContentType));
}
else if (parameterInfo.ParameterType == typeof(ContentDisposition) && !string.IsNullOrEmpty(context.HttpContext.Request.Headers["Content-Disposition"]))
{
var disposition = new ContentDisposition(context.HttpContext.Request.Headers["Content-Disposition"]);
disposition.FileName = HttpUtility.UrlDecode(disposition.FileName); //Decode uri name
callArg.Add(disposition);
}
else if (parameterInfo.ParameterType.IsSubclassOf(typeof(HttpPostedFile)) && context.HttpContext.Request.Files[parameterInfo.Name] != null)
{
callArg.Add(context.HttpContext.Request.Files[parameterInfo.Name]);
}
else if (Binder.IsCollection(parameterInfo.ParameterType) && parameterInfo.ParameterType.IsGenericType && parameterInfo.ParameterType.GetGenericArguments().First() == typeof(HttpPostedFileBase))
{
//File catcher
var files = new List <HttpPostedFileBase>(context.HttpContext.Request.Files.Count);
files.AddRange(from string key in context.HttpContext.Request.Files select context.HttpContext.Request.Files[key]);
callArg.Add(files);
}
else
{
if (parameterInfo.ParameterType.IsSubclassOf(typeof(Stream)) || parameterInfo.ParameterType == typeof(Stream))
{
//First try get files
var file = context.HttpContext.Request.Files[parameterInfo.Name];
callArg.Add(file != null ? file.InputStream : context.HttpContext.Request.InputStream);
}
else
{
//Try bind
//Note: binding moved here
if (IsTypeBindable(parameterInfo.ParameterType))
{
//Custom type
var binded = Binder.Bind(parameterInfo.ParameterType,
requestParams,
parameterInfo.Name);
if (binded != null)
{
callArg.Add(binded);
continue; //Go to next loop
}
}
//Create null
var obj = parameterInfo.ParameterType.IsValueType ? Activator.CreateInstance(parameterInfo.ParameterType) : null;
callArg.Add(obj);
}
}
}
}
return(callArg);
}
public void TestUnbindByIdentifier()
{
var binder = new Binder();
binder.Bind<MockClassToDepend>().ToSelf();
binder.Bind<IMockInterface>().To<MockIClassWithAttributes>().As("Mock1");
binder.Bind<IMockInterface>().To<MockIClassWithAttributes>().As("Mock2");
binder.Unbind("Mock1");
var bindings = binder.GetBindings();
Assert.AreEqual(2, bindings.Count);
Assert.AreEqual(typeof(MockClassToDepend), bindings[0].type);
Assert.AreEqual(typeof(IMockInterface), bindings[1].type);
Assert.AreEqual("Mock2", bindings[1].identifier);
}
public void TestBindingEvaluation()
{
var eventCalled = false;
IReflectionCache cache = new ReflectionCache();
IBinder binder = new Binder();
IInjector injector = new Injector(cache, binder);
injector.bindingEvaluation += delegate(IInjector source, ref BindingInfo binding) {
Assert.AreEqual(injector, source);
Assert.NotNull(binding);
eventCalled = true;
return new MockIClassWithoutAttributes();
};
binder.Bind<IMockInterface>().To<MockIClass>();
var instance = injector.Resolve<IMockInterface>();
Assert.IsTrue(eventCalled);
Assert.AreEqual(typeof(MockIClassWithoutAttributes), instance.GetType());
}
public void TestBindNotAssignableKeyTypeToTransient()
{
var binder = new Binder();
binder.Bind<IMockInterface>().To<MockClassToDepend>();
}
public void Bind(IRestApiClient apiClient)
{
_binder.Bind(apiClient);
}
public void TestBindToInterfaceSelf()
{
var binder = new Binder();
binder.Bind<IMockInterface>().ToSelf();
}
