//Creates a menu based on the definition in the object's Menu method
public override void CreateMenu(IMetamodelBuilder metamodel)
{
var menu = new MenuImpl(metamodel, method.DeclaringType, false, GetMenuName(Spec));
InvokeUtils.InvokeStatic(method, new object[] { menu });
Menu = menu;
}
public static object CallDynamicInvokeMethod(
object thisPtr,
IntPtr methodToCall,
object thisPtrDynamicInvokeMethod,
IntPtr dynamicInvokeHelperMethod,
IntPtr dynamicInvokeHelperGenericDictionary,
object defaultParametersContext,
object[] parameters,
BinderBundle binderBundle,
bool wrapInTargetInvocationException,
bool invokeMethodHelperIsThisCall,
bool methodToCallIsThisCall)
{
object result = InvokeUtils.CallDynamicInvokeMethod(
thisPtr,
methodToCall,
thisPtrDynamicInvokeMethod,
dynamicInvokeHelperMethod,
dynamicInvokeHelperGenericDictionary,
defaultParametersContext,
parameters,
binderBundle,
wrapInTargetInvocationException,
invokeMethodHelperIsThisCall,
methodToCallIsThisCall);
System.Diagnostics.DebugAnnotations.PreviousCallContainsDebuggerStepInCode();
return(result);
}
public static dynamic GetQueryableOfDerivedType(this EntityObjectStore.LocalContext context, Type type)
{
Type mostBaseType = context.GetMostBaseType(type);
MethodInfo mi = typeof(ObjectContextUtils).GetMethod("GetObjectSetOfType").MakeGenericMethod(type, mostBaseType);
return(InvokeUtils.InvokeStatic(mi, new object[] { context }));
}
public static object CallDynamicInvokeMethod(object thisPtr, IntPtr methodToCall, object thisPtrDynamicInvokeMethod, IntPtr dynamicInvokeHelperMethod, IntPtr dynamicInvokeHelperGenericDictionary, string defaultValueString, object[] parameters, bool invokeMethodHelperIsThisCall, bool methodToCallIsThisCall)
{
object result = InvokeUtils.CallDynamicInvokeMethod(thisPtr, methodToCall, thisPtrDynamicInvokeMethod, dynamicInvokeHelperMethod, dynamicInvokeHelperGenericDictionary, defaultValueString, parameters, invokeMethodHelperIsThisCall, methodToCallIsThisCall);
System.Diagnostics.DebugAnnotations.PreviousCallContainsDebuggerStepInCode();
return(result);
}
//Creates a menu based on the definition in the object's Menu method
public override void CreateMenu(IMetamodelBuilder metamodel)
{
MethodInfo m = GetType().GetMethod("CreateTypedMenu").MakeGenericMethod(method.DeclaringType);
var menu = (MenuImpl)m.Invoke(this, new object[] { metamodel, GetMenuName(Spec()) });
InvokeUtils.InvokeStatic(method, new object[] { menu });
Menu = menu;
}
public override string InvalidReason(INakedObject target, INakedObject proposedValue)
{
if (proposedValue != null)
{
return((string)InvokeUtils.Invoke(method, target, new[] { proposedValue }));
}
return(null);
}
public static object CreateObject(this EntityObjectStore.LocalContext context, Type type)
{
object objectSet = context.GetObjectSet(type);
var methods = objectSet.GetType().GetMethods();
var mi = methods.Single(m => m.Name == "CreateObject" && m.IsGenericMethod).MakeGenericMethod(type);
return(InvokeUtils.Invoke(mi, objectSet, null));
}
public static IQueryable <TDerived> GetObjectSetOfType <TDerived, TBase>(this EntityObjectStore.LocalContext context) where TDerived : TBase
{
MethodInfo mi = context.WrappedObjectContext.GetType().GetMethod("CreateObjectSet", Type.EmptyTypes).MakeGenericMethod(typeof(TBase));
var os = (IQueryable <TBase>)InvokeUtils.Invoke(mi, context.WrappedObjectContext, null);
((ObjectQuery)os).MergeOption = context.DefaultMergeOption;
return(os.OfType <TDerived>());
}
public override void SetProperty(INakedObjectAdapter nakedObjectAdapter, INakedObjectAdapter value, ITransactionManager transactionManager, ISession session, ILifecycleManager lifecycleManager)
{
try {
property.SetValue(nakedObjectAdapter.GetDomainObject(), value.GetDomainObject(), null);
}
catch (TargetInvocationException e) {
InvokeUtils.InvocationException("Exception executing " + property, e);
}
}
public void InitProperty(INakedObject nakedObject, INakedObject value)
{
try {
property.SetValue(nakedObject.GetDomainObject(), value.GetDomainObject(), null);
}
catch (TargetInvocationException e) {
InvokeUtils.InvocationException("Exception executing " + property, e);
}
}
public override void SetProperty(INakedObject nakedObject, INakedObject value, ITransactionManager transactionManager)
{
try {
property.SetValue(nakedObject.GetDomainObject(), value.GetDomainObject(), null);
}
catch (TargetInvocationException e) {
InvokeUtils.InvocationException("Exception executing " + property, e);
}
}
public string HiddenReason(INakedObject nakedObject)
{
if (nakedObject == null)
{
return(null);
}
var isHidden = (bool)InvokeUtils.Invoke(method, nakedObject);
return(isHidden ? Resources.NakedObjects.Hidden : null);
}
public object GetProperty(INakedObject nakedObject)
{
try {
return(propertyMethod.GetValue(nakedObject.GetDomainObject(), null));
}
catch (TargetInvocationException e) {
InvokeUtils.InvocationException("Exception executing " + propertyMethod, e);
return(null);
}
}
public string InvalidReason(INakedObjectAdapter target, INakedObjectAdapter[] proposedArguments)
{
if (methodDelegate != null)
{
return((string)methodDelegate(target.GetDomainObject(), proposedArguments.Select(no => no.GetDomainObject()).ToArray()));
}
//Fall back (e.g. if method has > 6 params) on reflection...
Log.WarnFormat("Invoking validate method via reflection as no delegate {0}.{1}", target, method);
return((string)InvokeUtils.Invoke(method, target, proposedArguments));
}
private static void SetValue(PropertyInfo property, object injectee, object value)
{
if (property != null)
{
try {
property.SetValue(injectee, value, null);
}
catch (TargetInvocationException e) {
InvokeUtils.InvocationException("Exception executing " + property, e);
}
}
}
public override INakedObject Invoke(INakedObject inObject, INakedObject[] parameters, ILifecycleManager lifecycleManager, IMetamodelManager manager, ISession session, INakedObjectManager nakedObjectManager)
{
if (parameters.Length != paramCount)
{
Log.Error(actionMethod + " requires " + paramCount + " parameters, not " + parameters.Length);
}
object result = InvokeUtils.Invoke(actionMethod, inObject, parameters);
INakedObject adaptedResult = nakedObjectManager.CreateAdapter(result, null, null);
Log.DebugFormat("Action result {0}", adaptedResult);
return(adaptedResult);
}
protected virtual void InstallFixture(object fixture)
{
var property = fixture.GetType().GetProperty("Service");
SetValue(property, fixture, fixtureServices);
var installMethod = GetInstallMethod(fixture);
try {
installMethod.Invoke(fixture, new object[0]);
}
catch (TargetInvocationException e) {
InvokeUtils.InvocationException("Exception executing " + installMethod, e);
}
}
public object[] GetCompletions(INakedObject inObject, string autoCompleteParm)
{
try {
object autoComplete = InvokeUtils.Invoke(method, inObject.GetDomainObject(), new object[] { autoCompleteParm });
var complete = autoComplete as IQueryable;
if (complete != null)
{
return(complete.Take(PageSize).ToArray());
}
throw new NakedObjectDomainException("Must return IQueryable from autoComplete method: " + method.Name);
}
catch (ArgumentException ae) {
string msg = string.Format("autoComplete exception: {0} has mismatched parameter type - must be string", method.Name);
throw new InvokeException(msg, ae);
}
}
public object[] GetChoices(INakedObject inObject, IDictionary <string, INakedObject> parameterNameValues)
{
INakedObject[] parms = FacetUtils.MatchParameters(parameterNames, parameterNameValues);
try {
object options = InvokeUtils.Invoke(method, inObject, parms);
var enumerable = options as IEnumerable;
if (enumerable != null)
{
return(enumerable.Cast <object>().ToArray());
}
throw new NakedObjectDomainException("Must return IEnumerable from choices method: " + method.Name);
}
catch (ArgumentException ae) {
string msg = string.Format("Choices exception: {0} has mismatched (ie type of parameter does not match type of property) parameter types", method.Name);
throw new InvokeException(msg, ae);
}
}
public override object[] GetChoices(INakedObject nakedObject, IDictionary <string, INakedObject> parameterNameValues)
{
INakedObject[] parms = FacetUtils.MatchParameters(parameterNames, parameterNameValues);
try {
var options = InvokeUtils.Invoke(choicesMethod, nakedObject, parms) as IEnumerable;
if (options != null)
{
return(options.Cast <object>().ToArray());
}
throw new NakedObjectDomainException("Must return IEnumerable from choices method: " + choicesMethod.Name);
}
catch (ArgumentException ae) {
string msg = string.Format("Choices exception: {0} has mismatched (ie type of choices parameter does not match type of action parameter) parameter types", choicesMethod.Name);
throw new InvokeException(msg, ae);
}
}
public override INakedObjectAdapter Invoke(INakedObjectAdapter inObjectAdapter, INakedObjectAdapter[] parameters, ILifecycleManager lifecycleManager, IMetamodelManager manager, ISession session, INakedObjectManager nakedObjectManager, IMessageBroker messageBroker, ITransactionManager transactionManager)
{
if (parameters.Length != paramCount)
{
logger.LogError($"{ActionMethod} requires {paramCount} parameters, not {parameters.Length}");
}
object result;
if (ActionDelegate != null)
{
result = ActionDelegate(inObjectAdapter.GetDomainObject(), parameters.Select(no => no.GetDomainObject()).ToArray());
}
else
{
logger.LogWarning($"Invoking action via reflection as no delegate {OnType}.{ActionMethod}");
result = InvokeUtils.Invoke(ActionMethod, inObjectAdapter, parameters);
}
return(nakedObjectManager.CreateAdapter(result, null, null));
}
public override INakedObjectAdapter Invoke(INakedObjectAdapter inObjectAdapter, INakedObjectAdapter[] parameters, INakedObjectsFramework framework)
{
if (parameters.Length != paramCount)
{
logger.LogError($"{ActionMethod} requires {paramCount} parameters, not {parameters.Length}");
}
object result;
if (ActionDelegate != null)
{
result = ActionDelegate(inObjectAdapter.GetDomainObject(), parameters.Select(no => no.GetDomainObject()).ToArray());
}
else
{
logger.LogWarning($"Invoking action via reflection as no delegate {OnType}.{ActionMethod}");
result = InvokeUtils.Invoke(ActionMethod, inObjectAdapter, parameters);
}
return(framework.NakedObjectManager.CreateAdapter(result, null, null));
}
public override INakedObjectAdapter Invoke(INakedObjectAdapter inObjectAdapter, INakedObjectAdapter[] parameters, ILifecycleManager lifecycleManager, IMetamodelManager manager, ISession session, INakedObjectManager nakedObjectManager, IMessageBroker messageBroker, ITransactionManager transactionManager)
{
if (parameters.Length != paramCount)
{
Log.Error(actionMethod + " requires " + paramCount + " parameters, not " + parameters.Length);
}
object result;
if (actionDelegate != null)
{
result = actionDelegate(inObjectAdapter.GetDomainObject(), parameters.Select(no => no.GetDomainObject()).ToArray());
}
else
{
Log.WarnFormat("Invoking action via reflection as no delegate {0}.{1}", onType, actionMethod);
result = InvokeUtils.Invoke(actionMethod, inObjectAdapter, parameters);
}
INakedObjectAdapter adaptedResult = nakedObjectManager.CreateAdapter(result, null, null);
return(adaptedResult);
}
public override Tuple <object, TypeOfDefaultValue> GetDefault(INakedObject nakedObject)
{
// type safety is given by the reflector only identifying methods that match the
// parameter type
return(new Tuple <object, TypeOfDefaultValue>(InvokeUtils.Invoke(method, nakedObject), TypeOfDefaultValue.Explicit));
}
public override string GetTitle(INakedObject nakedObject, INakedObjectManager nakedObjectManager)
{
return(InvokeUtils.Invoke(method, nakedObject) as string);
}
public static Object CheckArgument(Object srcObject, RuntimeTypeHandle dstType)
{
return(InvokeUtils.CheckArgument(srcObject, dstType));
}
public override string GetTitle(INakedObject nakedObject, INakedObjectManager nakedObjectManager)
{
object obj = InvokeUtils.Invoke(method, nakedObject);
return(obj == null ? null : nakedObjectManager.CreateAdapter(obj, null, null).TitleString());
}
public static object CheckArgument(object srcObject, RuntimeTypeHandle dstType, BinderBundle binderBundle)
{
return(InvokeUtils.CheckArgument(srcObject, dstType, binderBundle));
}
// FieldInfo.SetValueDirect() has a completely different set of rules on how to coerce the argument from
// the other Reflection api.
public static object CheckArgumentForDirectFieldAccess(object srcObject, RuntimeTypeHandle dstType)
{
return(InvokeUtils.CheckArgument(srcObject, dstType.ToEETypePtr(), InvokeUtils.CheckArgumentSemantics.SetFieldDirect, binderBundle: null));
}
public override void Invoke(INakedObject nakedObject, ISession session, ILifecycleManager lifecycleManager, IMetamodelManager metamodelManager)
{
InvokeUtils.Invoke(method, nakedObject);
}
