private static Lazy <T, TMetadata> CreateStronglyTypedLazyOfTM <T, TMetadata>(Func <object> funcOfObject, object metadata)
{
Requires.NotNull(funcOfObject, nameof(funcOfObject));
Requires.NotNullAllowStructs(metadata, nameof(metadata));
return(new Lazy <T, TMetadata>(funcOfObject.As <T>(), (TMetadata)metadata));
}
public void RegisterFunc <TType>(Func <TType> func)
{
CheckAlreadyAdded <TType>();
var resolver = new FuncResolver(func.As <Func <object> >());
_resolvers.Add(typeof(TType), resolver);
}
public void As()
{
Func <object> fo = () => 5;
Func <int> fi = fo.As <int>();
int result = fi();
Assert.Equal(5, result);
}
public static jQueryObject AddValidationRule(this jQueryObject element, string eventClass,
Func<jQueryObject, string> rule)
{
if (element.Length == 0)
return element;
if (rule == null)
throw new Exception("rule is null!");
element.AddClass("customValidate")
.Bind("customValidate." + eventClass, rule.As<jQueryEventHandler>());
return element;
}
public void TestAsFunction()
{
var d = new DynInst();
var t = d.As <Two>();
t();
var p = new {
Two = new Func <bool>(() => {
Console.WriteLine("In Func<bool> for Two!");
return(true);
})
};
var q = p.As <Two>();
q();
var z = new {
};
// this creates a dummy function now.
var tz = z.As <Two>();
tz();
Func <bool> fTwo = new Func <bool>(() => {
Console.WriteLine("In fTwo");
return(true);
});
fTwo.As <Two>()();
Assert.Throws <Exception>(() => {
Func <string> fThree = new Func <string>(() => {
Console.WriteLine("In fThree");
return("true");
});
fThree.As <Two>()();
});
}
public static jQueryObject AddValidationRule(this jQueryObject element, string eventClass,
Func <jQueryObject, string> rule)
{
if (element.Length == 0)
{
return(element);
}
if (rule == null)
{
throw new Exception("rule is null!");
}
element.AddClass("customValidate")
.Bind("customValidate." + eventClass, rule.As <jQueryEventHandler>());
return(element);
}
public void CheckForAcceptableTypes()
{
using (CaptureConsole) {
var x = new ActualImplementation().As <ClientInterface>();
var y = x.ActuallyReturnsString();
var z = x.ActuallyReturnsFileStream();
Console.WriteLine("Y is {0}", y.GetType().Name);
Console.WriteLine("Z is {0}", z.GetType().Name);
// this function doesn't match anything in the implemention
// so a stub method gets created (which returns null)
// MemoryStream a = x.ActuallyRetunsMemoryStream();
// Assert.Null(a);
// the clientinterface is more restricted than the implementation
// but that's ok.
MemoryStream ms = new MemoryStream();
Assert.True(x.TakesAStream(ms));
// the clientinterface is less restrictive than the implementation
// and that's not ok.
Assert.False(x.TakesAFileStream(ms));
var shouldWork = new {
TakesAStream = new Func <Stream, bool>(stream => { return(stream != null); })
}.As <ClientInterface>();
Assert.True(shouldWork.TakesAStream(ms));
var shouldNotWork = new {
TakesAFileStream = new Func <MemoryStream, bool>(stream => {
Console.WriteLine("never called");
return(stream != null);
})
}.As <ClientInterface>();
Assert.False(shouldWork.TakesAFileStream(ms));
var shouldWorkToo = new {
ActuallyReturnsString = new Func <object>(() => "hello")
}.As <ClientInterface>();
Assert.NotNull(shouldWorkToo.ActuallyReturnsString());
var shouldNotWorkToo = new {
ActuallyRetunsMemoryStream = new Func <Stream>(() => new MemoryStream())
}.As <ClientInterface>();
Assert.Null(shouldNotWorkToo.ActuallyRetunsMemoryStream());
Func <object> fReturnsAString = new Func <object>(() => "hello");
var fShouldWork = fReturnsAString.As <ReturnsAnObject>();
Assert.NotNull(fShouldWork());
Assert.Throws <Exception>(() => {
// this shouldn't work because the return type object
// can't be expressed as a string.
var fShouldNotWork = fReturnsAString.As <ReturnsAString>();
});
}
}
public static Predicate <T> AsPredicate <T>([NotNull] this Func <T, bool> function)
{
return(function.As <Predicate <T> >());
}
public static Comparison <T> AsComparison <T>([NotNull] this Func <T, T, int> function)
{
return(function.As <Comparison <T> >());
}
private static Lazy <T> CreateStronglyTypedLazyOfT <T>(Func <object> funcOfObject, object metadata)
{
Requires.NotNull(funcOfObject, nameof(funcOfObject));
return(new Lazy <T>(funcOfObject.As <T>()));
}
public SignalHandler(Func <ISubscriber, TInput, object?, CancellationToken, Task> handler, out string inputMessageName)
: this(handler.As <MulticastDelegate>(), out inputMessageName)
{
}
public void TestAsFunction()
{
using (CaptureConsole) {
var d = new DynInst();
var t = d.As<Two>();
t();
var p = new {
Two = new Func<bool>(() => {
Console.WriteLine("In Func<bool> for Two!");
return true;
})
};
var q = p.As<Two>();
q();
var z = new {
};
// this creates a dummy function now.
var tz = z.As<Two>();
tz();
Func<bool> fTwo = new Func<bool>(() => {
Console.WriteLine("In fTwo");
return true;
});
fTwo.As<Two>()();
Assert.Throws<Exception>(() => {
Func<string> fThree = new Func<string>(() => {
Console.WriteLine("In fThree");
return "true";
});
fThree.As<Two>()();
});
}
}
public void CheckForAcceptableTypes()
{
using (CaptureConsole) {
var x = new ActualImplementation().As<ClientInterface>();
var y = x.ActuallyReturnsString();
var z = x.ActuallyReturnsFileStream();
Console.WriteLine("Y is {0}", y.GetType().Name);
Console.WriteLine("Z is {0}", z.GetType().Name);
// this function doesn't match anything in the implemention
// so a stub method gets created (which returns null)
// MemoryStream a = x.ActuallyRetunsMemoryStream();
// Assert.Null(a);
// the clientinterface is more restricted than the implementation
// but that's ok.
MemoryStream ms = new MemoryStream();
Assert.True(x.TakesAStream(ms));
// the clientinterface is less restrictive than the implementation
// and that's not ok.
Assert.False(x.TakesAFileStream(ms));
var shouldWork = new {
TakesAStream = new Func<Stream, bool>(stream => {return stream != null;})
}.As<ClientInterface>();
Assert.True(shouldWork.TakesAStream(ms));
var shouldNotWork = new {
TakesAFileStream = new Func<MemoryStream, bool>(stream => {
Console.WriteLine("never called");
return stream != null;
})
}.As<ClientInterface>();
Assert.False(shouldWork.TakesAFileStream(ms));
var shouldWorkToo = new {
ActuallyReturnsString = new Func<object>(() => "hello")
}.As<ClientInterface>();
Assert.NotNull(shouldWorkToo.ActuallyReturnsString());
var shouldNotWorkToo = new {
ActuallyRetunsMemoryStream = new Func<Stream>(() => new MemoryStream())
}.As<ClientInterface>();
Assert.Null(shouldNotWorkToo.ActuallyRetunsMemoryStream());
Func<object> fReturnsAString = new Func<object>(() => "hello");
var fShouldWork = fReturnsAString.As<ReturnsAnObject>();
Assert.NotNull(fShouldWork());
Assert.Throws<Exception>(() => {
// this shouldn't work because the return type object
// can't be expressed as a string.
var fShouldNotWork = fReturnsAString.As<ReturnsAString>();
});
}
}
public RpcHandler(Func <TInput, object?, CancellationToken, Task <TOutput> > handler, out string inputMessageName)
: this(handler.As <MulticastDelegate>(), out inputMessageName)
{
}
