Example #1
0
        private static void Main(string[] args)
        {
            // Back ground runner
            //BackGroundTask bgt = new BackGroundTask();
            //bgt.TaskRunner();

            ExecuteCode cb = new ExecuteCode();

            ShowEmbeddedResources();

            ShowExpressionTrees();

            Console.ReadKey();
        }
Example #2
0
        /// <summary>
        /// 以管理员身份运行相关代码
        /// </summary>
        /// <param name="exec"></param>
        /// <returns></returns>
        public static bool RunAdminCode(ExecuteCode exec)
        {
            bool blnResult = false;

            using (IdentityAnalogue ID = new IdentityAnalogue())
            {
                if (ID.TryLogonAs(".", ConfigurationManager.AppSettings["AnalogueID"],
                                  new SymmetricMethod().Decrypto(ConfigurationManager.AppSettings["AnaloguePWD"])))
                {
                    exec();
                    blnResult = true;
                }
            }
            return(blnResult);
        }
//	static string[] commands;
//	static int location;
    void Awake()
    {
        instance = this;
    }
Example #4
0
        /// <summary>
        /// Handles the Click event of the CmdCalculateStationResults control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="RoutedEventArgs"/> instance containing the event data.</param>
        private void CmdCalculateStationResults_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                if (MessageBox.Show("Wirklich?", "Stationsergebnisse berechnen", MessageBoxButton.YesNo) == MessageBoxResult.Yes)
                {
                    // neu berechnen
                    using (var db = new WintertalentiadeDataContext2(Properties.Settings.Default.WintertalentiadeConnectionString, txtUser.Text, txtPwd.Text))
                    {
                        // alles einlesen
                        var allAthlets               = db.T_Athlets.ToList();
                        var allStations              = db.T_Stations.ToList();
                        var allStationValues         = db.T_StationValues.ToList();
                        var allResults               = db.T_Results.ToList();
                        var calculatedStationResults = db.T_CalculatedStationResults.ToList();

                        // alle Stationen durchgehen
                        foreach (var station in allStations)
                        {
                            // Stationswerte der aktuellen Station
                            var stationValues   = allStationValues.Where(asv => asv.StationId == station.StationId).OrderBy(asv => asv.StationValueIndex).ToList();
                            var stationValueIds = stationValues.Select(sv => sv.StationValueId).ToList();

                            var executeCode = new ExecuteCode(station.StationFormula);

                            // alle Athleten durchgehen
                            foreach (var athlet in allAthlets)
                            {
                                // die Ergebnisse des aktuellen Athleten an der aktuellen Station
                                var results = allResults.Where(r => (r.AthletId == athlet.AthletId) && stationValueIds.Contains(r.StationValueId)).ToList();

                                float points;

                                // es muss genau so viele Ergebnisse geben wie Stationswerte
                                if (results.Count() == stationValues.Count())
                                {
                                    // passt

                                    // Ergebnisse müssen genau so sortiert sein wie die Stationswerte!
                                    // ('stationValues' ist gemäß 'StationValueIndex' sortiert und demnach auch 'stationValueIds')
                                    var sortedResults = stationValueIds.Select(svid => results.Single(r => r.StationValueId == svid)).ToList();

                                    // Punkte berechnen
                                    var resultValues = sortedResults.Select(r => r.ResultValue).ToList();

                                    try
                                    {
                                        points = executeCode.CallCalculateResult(resultValues);
                                    }
#pragma warning disable CS0168 // Variable is declared but never used
                                    catch (Exception ex)
#pragma warning restore CS0168 // Variable is declared but never used
                                    {
                                        var message = $"Fehler bei Formel: '{station.StationFormula}', Werte: {string.Join(" / ", resultValues)}";
                                        MessageBox.Show(message);
                                        throw new Exception(message);
                                    }
                                }
                                else
                                {
                                    // passt nicht
                                    // => dann kann man auch keine Punkte berechnen
                                    points = 0;
                                }

                                // Punkte speichern
                                var calculatedStationResult = calculatedStationResults.SingleOrDefault(csr => (csr.AthletId == athlet.AthletId) && (csr.StationId == station.StationId));
                                if (calculatedStationResult == null)
                                {
                                    // es gibt noch kein Ergebnis
                                    var newCalculatedStationResult = new T_CalculatedStationResult()
                                    {
                                        AthletId    = athlet.AthletId,
                                        StationId   = station.StationId,
                                        ResultValue = points
                                    };

                                    db.T_CalculatedStationResults.InsertOnSubmit(newCalculatedStationResult);
                                }
                                else
                                {
                                    // es gibt schon ein Ergebnis
                                    calculatedStationResult.ResultValue = points;
                                }
                            }
                        }

                        db.SubmitChanges();
                    }

                    MessageBox.Show("Fertig");
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show("Fehler: " + ex.ToString());
            }
        }