internal Route(Component routeOutComponent, TRouteOut routeOut, Component routeInComponent, TRouteIn routeIn, RouteConverter routeConverter)
{
if (routeOutComponent == null)
{
throw new ArgumentNullException("routeOutComponent");
}
if (routeOut == null)
{
throw new ArgumentNullException("routeOut");
}
if (routeInComponent == null)
{
throw new ArgumentNullException("routeInComponent");
}
if (routeIn == null)
{
throw new ArgumentNullException("routeIn");
}
this._routeConverter = routeConverter;
this._routeIn = routeIn;
this._routeInComponent = routeInComponent;
this._routeOut = routeOut;
this._routeOutComponent = routeOutComponent;
}
public static PropertyToMethodRoute Create <TRouteOutType, TRouteInType>(Component routeOutComponent, Expression <Func <Component, TRouteOutType> > propertyExpresson, Component routeInComponent, Expression <Action <TRouteInType> > methodExpression, RouteConverter routeConverter)
{
MemberExpression memberExpression = null;
MethodCallExpression methodCallExpression = null;
if (propertyExpresson == null)
{
throw new ArgumentNullException("propertyExpression");
}
if (methodExpression == null)
{
throw new ArgumentNullException("methodExpression");
}
memberExpression = propertyExpresson.Body as MemberExpression;
methodCallExpression = methodExpression.Body as MethodCallExpression;
if (memberExpression == null)
{
throw new ArgumentException("The property expression is not valid. Could not get MemberExpression.", "propertyExpression");
}
if (methodCallExpression == null)
{
throw new ArgumentException("The method expression is not valid. Could not get MethodCallExpression.", "methodExpression");
}
if (memberExpression.Member.MemberType != MemberTypes.Property)
{
throw new ArgumentException(string.Format(System.Globalization.CultureInfo.CurrentCulture, "The propertyExpression is not a valid type. Type found: {0}.", memberExpression.Member.MemberType), "propertyExpression");
}
if (methodCallExpression.Method.MemberType != MemberTypes.Method)
{
throw new ArgumentException(string.Format(System.Globalization.CultureInfo.CurrentCulture, "The methodExpression is not a valid type. Type found: {0}.", methodCallExpression.Method.MemberType), "methodExpression");
}
return(new PropertyToMethodRoute(routeOutComponent, memberExpression.Member.Name, routeInComponent, methodCallExpression.Method.Name, routeConverter));
}
private PropertyToMethodRoute(Component routeOutComponent, string propertyOutName, Component routeInComponent, string methodName, RouteConverter routeConverter) : base(routeOutComponent, propertyOutName, routeInComponent, methodName, routeConverter)
{
if (string.IsNullOrWhiteSpace(propertyOutName))
{
throw new ArgumentNullException("propertyOutName");
}
if (string.IsNullOrWhiteSpace(methodName))
{
throw new ArgumentNullException("methodName");
}
this._propertyOutInfo = this.RouteOutComponent.GetType().GetProperty(this.RouteOut, BindingFlags.Instance | BindingFlags.Public | BindingFlags.Static).GetGetMethod();
this._methodInfo = this.RouteInComponent.GetType().GetMethod(this.RouteIn, BindingFlags.Instance | BindingFlags.Public | BindingFlags.Static);
if (this._propertyOutInfo == null)
{
throw new ArgumentException("The property could not be found.", "propertyOutName");
}
if (this._methodInfo == null)
{
throw new ArgumentException("The in method could not be found.", "methodName");
}
this._routeInType = this._methodInfo.GetParameters()[0].ParameterType;
this._routeOutType = this._propertyOutInfo.ReturnType;
}
public static PropertyToPropertyRoute Create <TRouteType>(Component routeOutComponent, string propertyName, Component routeInComponent, Expression <Func <Component, TRouteType> > propertyInExpresson, RouteConverter routeConverter)
{
MemberExpression memberInExpression = null;
if (string.IsNullOrWhiteSpace(propertyName))
{
throw new ArgumentNullException("propertyName");
}
if (propertyInExpresson == null)
{
throw new ArgumentNullException("propertyInExpression");
}
memberInExpression = propertyInExpresson.Body as MemberExpression;
if (memberInExpression == null)
{
throw new ArgumentException("The property expression is not valid. Could not get MemberExpression.", "propertyInExpression");
}
if (memberInExpression.Member.MemberType != MemberTypes.Property)
{
throw new ArgumentException(string.Format(System.Globalization.CultureInfo.CurrentCulture, "The propertyInExpression is not a valid type. Type found: {0}.", memberInExpression.Member.MemberType), "propertyInExpression");
}
return(new PropertyToPropertyRoute(routeOutComponent, propertyName, routeInComponent, memberInExpression.Member.Name, routeConverter));
}
internal EventRoute(Component routeOutComponent, string eventName, Component routeInComponent, string handlerName, RouteConverter routeConverter) : base(routeOutComponent, eventName, routeInComponent, handlerName, routeConverter)
{
}
public static EventToMethodRoute Create <TRouteType>(Component routeOutComponent, EventInfo eventInfo, Component routeInComponent, Expression <Action <TRouteType> > methodExpression, RouteConverter routeConverter)
{
if (eventInfo == null)
{
throw new ArgumentNullException("eventInfo");
}
return(EventToMethodRoute.Create(routeOutComponent, eventInfo.Name, routeInComponent, methodExpression, routeConverter));
}
private EventToMethodRoute(Component routeOutComponent, string eventName, Component routeInComponent, string methodName, RouteConverter routeConverter) : base(routeOutComponent, eventName, routeInComponent, methodName, routeConverter)
{
if (string.IsNullOrWhiteSpace(eventName))
{
throw new ArgumentNullException("eventName");
}
if (string.IsNullOrWhiteSpace(methodName))
{
throw new ArgumentNullException("methodName");
}
this._eventInfo = this.RouteOutComponent.GetType().GetEvent(this.RouteOut, BindingFlags.Instance | BindingFlags.Public | BindingFlags.Static);
this._methodInfo = this.RouteInComponent.GetType().GetMethod(this.RouteIn, BindingFlags.Instance | BindingFlags.Public | BindingFlags.Static);
if (this._eventInfo == null)
{
throw new ArgumentException("The event could not be found.", "eventName");
}
if (this._methodInfo == null)
{
throw new ArgumentException("The method could not be found.", "methodName");
}
this._routeInType = this._methodInfo.GetParameters()[0].ParameterType;
this._routeOutType = this._eventInfo.EventHandlerType.GetMethod("Invoke").GetParameters()[1].ParameterType;
}
public static EventToPropertyRoute Create <TRouteType>(Component routeOutComponent, string eventName, Component routeInComponent, Expression <Func <Component, TRouteType> > propertyExpression, RouteConverter routeConverter)
{
MemberExpression propertyMember = null;
if (propertyExpression == null)
{
throw new ArgumentNullException("propertyExpression");
}
propertyMember = propertyExpression.Body as MemberExpression;
if (propertyMember == null)
{
throw new ArgumentException("The property expression is not valid. Could not get MemberExpression.", "propertyExpression");
}
if (propertyMember.Member.MemberType != MemberTypes.Property)
{
throw new ArgumentException(string.Format(System.Globalization.CultureInfo.CurrentCulture, "The propertyExpression is not a valid type. Type found: {0}.", propertyMember.Member.MemberType), "propertyExpression");
}
return(new EventToPropertyRoute(routeOutComponent, eventName, routeInComponent, propertyMember.Member.Name, routeConverter));
}
public static EventToPropertyRoute Create <TRouteType>(Component routeOutComponent, EventInfo eventInfo, Component routeInComponent, Expression <Func <Component, TRouteType> > propertyExpression, RouteConverter routeConverter)
{
if (eventInfo == null)
{
throw new ArgumentNullException("eventInfo");
}
return(EventToPropertyRoute.Create(routeOutComponent, eventInfo.Name, routeInComponent, propertyExpression, routeConverter));
}
internal PropertyRoute(Component routeOutComponent, string propertyName, Component routeInComponent, string handlerName, RouteConverter routeConverter) : base(routeOutComponent, propertyName, routeInComponent, handlerName, routeConverter)
{
}
