protected override IEnumerable <LiveObject> GetObjects() { var center = ReferenceSystem.ScreenOriginalPoint; var angles = CalAngles(Model.ObjectNumber); var radius = InnerMapper.GetScreenLocation(ReferenceSystem.Right, 0).X - center.X; foreach (float angle in angles) { var x = center.X + radius * (float)Math.Sin(Functions.DegreeToRadian(angle + RotateAngle)); var y = center.Y - radius * (float)Math.Cos(Functions.DegreeToRadian(angle + RotateAngle)); yield return(new LiveLine(center, new PointF(x, y)) { Value = angle }); } }
/// <summary> /// Maps the <paramref name="source"/> <see cref="System.Collections.IEnumerable"/> to an <see cref="System.Collections.IEnumerable"/> of <typeparamref name="TDestination"/>. /// Caches the mapping func and type of elements and therefore should perform better than <see cref="Map{TSource, TDestination}"/> for IEnumerables. /// </summary> /// <typeparam name="TSource">Source type to map from.</typeparam> /// <typeparam name="TDestination">Target type to map to.</typeparam> /// <param name="source">Source enumerable to map from. The type of all elements of <paramref name="source"/> has to be the same type /// as the mapping function is only evaluated for the first element in the enumerable.</param> /// <returns>Enumerable of target type objects. The mappings are lazy evaluated, therefore if the result is not consumed no mapping will take place.</returns> public IEnumerable <TDestination> MapList <TSource, TDestination>(IEnumerable <TSource> source) { var func = InnerMapper <TSource, TDestination> .GetMap(); return(source.Select(func)); }
/// <summary> /// Maps the <paramref name="source"/> object to <typeparamref name="TDestination"/> type. /// </summary> /// <typeparam name="TSource">Source type to map from.</typeparam> /// <typeparam name="TDestination">Target type to map to.</typeparam> /// <param name="source">Source object to map from. The source type is looked up at runtime. If this is a <see cref="System.Collections.IEnumerable"/> consider using <see cref="MapList{TSource, TDestination}"/> instead.</param> /// <returns>The mapped object.</returns> public TDestination Map <TSource, TDestination>(TSource source) where TSource : class where TDestination : class => InnerMapper <TSource, TDestination> .GetMap()(source);
/// <summary> /// Registers a new mapping function. /// </summary> /// <typeparam name="TSource">Source type to be mapped from.</typeparam> /// <typeparam name="TDestination">Target type to map to.</typeparam> /// <param name="mappingFunc">Mapping function which will perform the mapping on call of <see cref="Map{TSource, TDestination}"/>.</param> public void RegisterMap <TSource, TDestination>(Func <TSource, TDestination> mappingFunc) where TSource : class where TDestination : class { InnerMapper <TSource, TDestination> .RegisterMap(mappingFunc); }