Exemple #1
0
 public override bool Equals(object obj)
 {
     if (obj is KeySet <T> )
     {
         obj = ((KeySet <T>)obj).m_data;
     }
     //if (obj is IEnumerator)
     //{
     //    IEnumerator enumerator = obj as IEnumerator;
     //    while (enumerator.MoveNext())
     //    {
     //        if (!(enumerator.Current is T) || !m_data.Contains((T)enumerator.Current))
     //        {
     //            return false;
     //        }
     //    }
     //    return true;
     //}
     if (obj is IEnumerable)
     {
         foreach (var item in obj as IEnumerable)
         {
             if (!(item is T) || !m_data.Contains((T)item))
             {
                 return(false);
             }
         }
         return(true);
     }
     return(false);
 }
        /// <summary>
        /// 计算进度
        /// </summary>
        /// <returns></returns>
        public float Calculate()
        {
            if (State == null)
            {
                return(0);
            }
            if (State.StudiedChapterIds == null || State.StudiedChapterIds.Length < 1)
            {
                return(0);
            }
            if (State.CourseChapters == null || State.CourseChapters.Count() < 1)
            {
                return(0);
            }

            //筛选出状态正常的课程
            var data = from p in State.CourseChapters
                       where p.Key.Status == (int)CourseStatus.ENABLED
                       select p.Value;

            //筛选出状态正常的课程下的有效章节
            var chapters = new Func <List <long> >(() =>
            {
                List <long> chapterIds = new List <long>();

                foreach (var cha in data)
                {
                    if (cha != null)
                    {
                        chapterIds.AddRange(cha.Where(p => p.Status == (int)ChapterStatus.ENABLED).Select(p => p.ChapterId));
                    }
                }

                return(chapterIds);
            }).Invoke();

            //用户学习过的章节
            var studiedChapterIds = State.StudiedChapterIds.Where(p => chapters.Contains(p));

            float total   = chapters.Count();
            float studied = studiedChapterIds != null?studiedChapterIds.Count() : 0;

            if (total > 0)
            {
                return((float)Math.Round(studied / total, 2, MidpointRounding.ToEven));
            }
            else
            {
                return(0F);
            }
        }
    private void chPortfolioFutureValueDataBind(bool recalculateAll)
    {
        try
        {
            var seriesSpecs = new[] {
                new { SeriesName = "Volatiliteit (95%)", CreateSeries = (Func<string, Series>)createSeries_Volatility_2x },
                new { SeriesName = "Volatiliteit (68%)", CreateSeries = (Func<string, Series>)createSeries_Volatility_1x },
                new { SeriesName = "Doelvermogen", CreateSeries = (Func<string, Series>)createSeries_TargetValue },
                new { SeriesName = "Zonder aanpassing", CreateSeries = (Func<string, Series>)createSeries_BeforeAdjust },
                new { SeriesName = "Met aanpassing", CreateSeries = (Func<string, Series>)createSeries_AfterAdjust },
                new { SeriesName = "Historie", CreateSeries = (Func<string, Series>)createSeries_History }
            };

            Func<string, Series>[] alwaysRecalculate = new Func<string, Series>[] {
                createSeries_Volatility_2x,
                createSeries_Volatility_1x,
                createSeries_AfterAdjust
            };

            Dictionary<string, Series> cachedSeriesDict = chPortfolioFutureValue.Series.Cast<Series>()
                                                                                       .ToDictionary(s => s.Name, s => s);

            Series[] newSeriesList = seriesSpecs.Select(s =>
                                                    recalculateAll || alwaysRecalculate.Contains(s.CreateSeries) ?
                                                        s.CreateSeries(s.SeriesName) :
                                                    cachedSeriesDict.ContainsKey(s.SeriesName) ?
                                                        cachedSeriesDict[s.SeriesName] :
                                                        null)
                                                .Where(series => series != null)
                                                .ToArray();

            chPortfolioFutureValue.Series.Clear();
            foreach (Series series in newSeriesList)
                chPortfolioFutureValue.Series.Add(series);
        }
        catch (Exception ex) { displayErrorMessage(ex); }
    }
Exemple #4
0
        private void SetChannelAdjustments(AdoDataConnection connection, DataRescueOperation operation)
        {
            int operationID = operation.ID;

            HashSet <int> previouslyAdjusted = new Func <HashSet <int> >(() =>
            {
                const string QueryFormat =
                    "SELECT ChannelID " +
                    "FROM DataRescueChannelAdjustment " +
                    "WHERE DataRescueOperationID = {0}";

                using (DataTable table = connection.RetrieveData(QueryFormat, operationID))
                {
                    IEnumerable <int> channelIDs = table
                                                   .AsEnumerable()
                                                   .Select(row => row.ConvertField <int>("ChannelID"));

                    return(new HashSet <int>(channelIDs));
                }
            })();

            List <DataRescueChannelAdjustment> channelAdjustments = operation.ChannelAdjustments;

            IEnumerable <DataRescueChannelAdjustment> newAdjustments = channelAdjustments
                                                                       .Where(adjustment => !previouslyAdjusted.Contains(adjustment.ChannelID));

            IEnumerable <DataRescueChannelAdjustment> updatedAdjustments = channelAdjustments
                                                                           .Where(adjustment => previouslyAdjusted.Contains(adjustment.ChannelID));

            IEnumerable <int> removedAdjustments = previouslyAdjusted
                                                   .Except(channelAdjustments.Select(adjustment => adjustment.ChannelID));

            foreach (DataRescueChannelAdjustment adjustment in newAdjustments)
            {
                const string InsertFormat =
                    "INSERT INTO DataRescueChannelAdjustment(DataRescueOperationID, ChannelID, Multiplier, Adder) " +
                    "VALUES({0}, {1}, {2}, {3})";

                int    channelID  = adjustment.ChannelID;
                double multiplier = adjustment.Multiplier;
                double adder      = adjustment.Adder;
                connection.ExecuteNonQuery(InsertFormat, operationID, channelID, multiplier, adder);
            }

            foreach (DataRescueChannelAdjustment adjustment in updatedAdjustments)
            {
                const string UpdateFormat =
                    "UPDATE DataRescueChannelAdjustment " +
                    "SET " +
                    "    Multiplier = {2}, " +
                    "    Adder = {3} " +
                    "WHERE " +
                    "    DataRescueOperationID = {0} AND " +
                    "    ChannelID = {1}";

                int    channelID  = adjustment.ChannelID;
                double multiplier = adjustment.Multiplier;
                double adder      = adjustment.Adder;
                connection.ExecuteNonQuery(UpdateFormat, operationID, channelID, multiplier, adder);
            }

            foreach (int channelID in removedAdjustments)
            {
                const string DeleteFormat =
                    "DELETE FROM DataRescueChannelAdjustment " +
                    "WHERE " +
                    "    DataRescueOperationID = {0} AND " +
                    "    ChannelID = {1}";

                connection.ExecuteNonQuery(DeleteFormat, operationID, channelID);
            }
        }