C# DataModel类代码示例

    public void GeneratePeopleAndCompute()
    {
        int numberOfPeople = 0;
        try { numberOfPeople = int.Parse(NumberOfPeopleField.text); } catch { NumberOfPeopleField.text = numberOfPeople.ToString(); }
        int startingYear = 1900;
        try { startingYear = int.Parse(StartingYearField.text); } catch { StartingYearField.text = startingYear.ToString(); }
        int endingYear = 2000;
        try { endingYear = int.Parse(EndingYearField.text); } catch { EndingYearField.text = endingYear.ToString(); }
        int maxLifespan = 100;
        try { maxLifespan = int.Parse(MaxLifespanField.text); } catch { MaxLifespanField.text = maxLifespan.ToString(); }

        if (startingYear > endingYear )
        {
            int temp = startingYear;
            startingYear = endingYear;
            endingYear = temp;
            StartingYearField.text = startingYear.ToString();
            EndingYearField.text = endingYear.ToString();
        }

        DataModel model = new DataModel(numberOfPeople, startingYear, endingYear, maxLifespan);

        PeopleView.PopulatePeopleView(model.People);

        int[] mappingOfPopulationToDate = DateComputation.ComputeNumberOfLivingForEachYear(model.People, startingYear, endingYear);
        Graph.PopulateGraph(startingYear, endingYear, numberOfPeople, mappingOfPopulationToDate);

        int mostPopulousYear = DateComputation.ComputeDateOfMostLiving(mappingOfPopulationToDate, startingYear);
        MostPopulousYearField.text = mostPopulousYear.ToString();
        PopulationField.text = mappingOfPopulationToDate[mostPopulousYear - startingYear].ToString();
    }

 public ActionResult Index()
 {
     var dataModel = new DataModel {HiveQl = "SELECT * FROM sample_08 LIMIT 100;"};
     var dt = new DataTable();
     dataModel.Dt = dt;
     return View(dataModel);
 }

 /// <summary>
 /// Driver to find the proper translator for a particular object type
 /// </summary>
 /// <param name="iCalObjectName"></param>
 /// <param name="rawModel"></param>
 /// <returns></returns>
 private static IEnumerable<object> TranslateBlock(string iCalObjectName, DataModel.RawModel[] rawModel)
 {
     if (!_translators.ContainsKey(iCalObjectName))
         return null;
     var translator = _translators[iCalObjectName];
     return rawModel.Select(rm => translator(rm));
 }

 public Person(DataModel.Person data) {
   Data = data;
   Id = data.Id;
   Title = data.Name;
   IconName = "appbar_people";
   PeopleGroupId = data.PeopleGroupId;
 }

        private void notifyCompletedLearners(DataModel context, ILog log)
        {
            var learnersByDivision = Enrollment.CompletedToday(context)
                .Include(e => e.Learner)
                .Select(e => e.Learner)
                .Include(l => l.Division).ToList()
                .GroupBy(l => l.Division);

            foreach (var grouping in learnersByDivision)
            {
                var division = grouping.Key;

                var mail = new MailMessage("[email protected]", division.Email);
                var builder = new StringBuilder();
                builder.AppendLine("The following learners have completed their enrollments today:");
                foreach (var learner in grouping)
                {
                    log.Info($"Notified {learner.DivisionAbreviation} that learner {learner.LearnerNumber} completed their enrollment.");
                    builder.AppendLine($"{learner.DivisionAbreviation}{learner.LearnerNumber}\t{learner.Surname}, {learner.Name}");
                }
                mail.Subject = "Learners that have completed their enrollments";
                mail.Body = builder.ToString();

                var outbox = new Outbox();
                outbox.Send(mail);
            }
        }

        private async Task InsertTodoItem(DataModel.TodoItem todoItem)
        {
            string errorString = string.Empty;

            if (media != null)
            {
                todoItem.ContainerName = "todoitemimages";
                todoItem.ResourceName = Guid.NewGuid().ToString();
            }

            await todoTable.InsertAsync(todoItem);

            if (!string.IsNullOrEmpty(todoItem.SasQueryString))
            {
                StorageCredentials cred = new StorageCredentials(todoItem.SasQueryString);
                var imageUri = new Uri(todoItem.ImageUri);

                CloudBlobContainer container = new CloudBlobContainer(
                    new Uri(string.Format("https://{0}/{1}",
                        imageUri.Host, todoItem.ContainerName)), cred);

                using (var inputStream = await media.OpenReadAsync())
                {
                    CloudBlockBlob blobFromSASCredential =
                        container.GetBlockBlobReference(todoItem.ResourceName);
                    await blobFromSASCredential.UploadFromStreamAsync(inputStream);
                }
                
                await ResetCaptureAsync();
            }

            items.Add(todoItem);
        }

        public override void Execute(DataModel context, ILog log)
        {
            var scannedLearners = context.ScannedInLearners.ToList().Where(s => DateTime.Now - s.TimeIn > TimeSpan.FromHours(5));
            var scans = scannedLearners.Select(scannedLearner =>
               new LearnerScan()
               {
                   CreatedAt = DateTime.Now,
                   Activity = "Scanned Out",
                   Details = "Out (Automatic Midnight)",
                   ScanType = "Attendance",
                   Division = scannedLearner.Division,
                   LearnerNumber = scannedLearner.LearnerNumber,
                   Username = "System",
                   Session = scannedLearner.Session,
                   PartnerID = scannedLearner.LinkID
               }
            ).ToList();

            context.LearnerScans.AddRange(scans);
            context.SaveChanges();

            foreach (var scan in scans)
            {
                log.Info($"Scanning out learner: {scan.LearnerNumber} from {scan.Division}");
                if (scan.PartnerID == null) continue;
                var partner = context.LearnerScans.FirstOrDefault(s => s.ID == scan.PartnerID);
                if (partner != null)
                {
                    partner.PartnerID = scan.ID;
                }
            }
            context.ScannedInLearners.RemoveRange(scannedLearners);

            context.SaveChanges();
        }

        public int CreateEvent(string currentUsername, DataModel.Event baseEvent)
        {
            var usBusiness = new Business.Users(base.db);
            CityAngels.DataModel.User loggedUser = usBusiness.GetUser(currentUsername);

            // create event
            if (baseEvent.DateTo == DateTime.MinValue) baseEvent.DateTo = null;

            // standart schedule type (weekly)
            if (baseEvent.IsPeriodic)
            {
                baseEvent.EventSchedulingTypeId = (int)Data.Enum.ScheduleType.WEEKLY;
            }

            // baseEvent.RefEventId = null; <- non rimuovo il riferimento all'evento ripetuto, mi serve per non ripetere due volte l'evento nella giornata
            baseEvent.IsEnabled = true;
            baseEvent.CreateDate = DateTime.Now;
            baseEvent.CreatorUserId = loggedUser.UserId;
            baseEvent.UpdateDate = DateTime.Now;
            baseEvent.UpdateUserId = loggedUser.UserId;

            db.Events.Add(baseEvent);

            // log for other users
            Business.Logs log = new Business.Logs(base.db, Data.Enum.LogTypes.NEW, loggedUser);
            log.Push(baseEvent);

            db.SaveChanges();

            return baseEvent.EventId;
        }

        public void PopulateDataModel(DataModel model)
        {
            Instruction[] dynamicMethodCalls = ExtractDynamicMethodCallInstructions();
            if (dynamicMethodCalls.Length == 0) { return; }

            Instruction[] cachedReflectedFields = ExtractInitialReflectedCachedFieldReferenceInstructions();
            if (cachedReflectedFields.Length == 0) { return; }

            var references = cachedReflectedFields
                .Select(field => field.ParseToFieldReferenceCreation())
                .Reverse<string>()
                .ToList<string>();

            if (references.Count != 2) { return; }

            string tableName = references[0];
            string columnName = references[1].Replace("FindBy", "");
            Type columnType = null;

            var actualCall = dynamicMethodCalls.Last();

            var current = actualCall.Previous;
            if(current.OpCode.Code == Code.Ldstr)
            {
                columnType = typeof (string);
            } 
            else if (current.OpCode.Code == Code.Ldc_I4_4) // etc
            {
                columnType = typeof(int);
            }

            model.Table(tableName)
                .Column(columnName)
                .SetType(columnType);
        }

 public ActionResult ReturnAPage(string hiveQl)
 {
     var dataModel = new DataModel {HiveQl = hiveQl};
     DataTable dt = new HiveQueryDataService().GetDataFromHivet(dataModel.HiveQl);
     dataModel.Dt = dt;
     return View("Index", dataModel);
 }

        public static async Task<DataGroup> NewsGoVnGroup_Parse(string xmlString, DataModel.DataGroup group, int takeNum)
        {
            StringReader _stringReader = new StringReader(xmlString);
            XDocument _xdoc = XDocument.Load(_stringReader);
            var channelElement = _xdoc.Element("rss").Element("channel");
            if (channelElement != null)
            {
                group.Title = channelElement.Element("title").Value;
                group.Subtitle = channelElement.Element("title").Value;
                group.Description = channelElement.Element("description").Value;

                var items = channelElement.Elements("item");
                foreach (var item in items)
                {
                    if (group.Items.Count == takeNum && takeNum >= 0) break;

                    DataItem dataItem = new DataItem();
                    dataItem.Title = item.Element("title").Value;
                    dataItem.Description = StripHTML(item.Element("description").Value);
                    dataItem.Link = new Uri(item.Element("link").Value, UriKind.Absolute);
                    dataItem.PubDate = item.Element("pubDate").Value;

                    HtmlAgilityPack.HtmlDocument htmlDoc = new HtmlAgilityPack.HtmlDocument();
                    htmlDoc.Load(new StringReader(item.Element("description").Value));

                    HtmlAgilityPack.HtmlNode imageLink = getFirstNode("img", htmlDoc.DocumentNode);
                    dataItem.ImageUri = new Uri(imageLink.GetAttributeValue("src", string.Empty).Replace("96.62.jpg", "240.155.jpg"), UriKind.Absolute);

                    dataItem.Group = group;
                    group.Items.Add(dataItem);
                }
            }

            return group;
        }

 public void SaveConfig(DataModel.xTraceConfig xConfig)
 {
     localSettings.Values["ISFIRSTRUN"] = xConfig.ISFIRSTRUN;
     localSettings.Values["IPADDR"] = xConfig.IPADDR;
     localSettings.Values["PORT"] = xConfig.PORT;
     CurrentSettings = xConfig;
 }

 public static IQueryable<Enrollment> ToBeCompleted(DataModel context)
 {
     var enrollmentIDs = context.Database.SqlQuery<long>(@"
         SELECT e.idEnrollments
         FROM enrollments e
         JOIN learner_details l ON l.learnerKey = e.learnerKey
         WHERE e.completed IS NULL
         AND (
           SELECT COUNT(*)
           FROM learnerEnrollmentComponents lecom
           WHERE lecom.idEnrollments = e.idEnrollments
           AND lecom.moderated = 'yes'
         ) > 0
         AND 'Competent' = ALL (
           SELECT outcome
           FROM learnerEnrollmentComponents lecom
           WHERE lecom.idEnrollments = e.idEnrollments
         )
         AND 'yes' = ALL (
           SELECT moderated
           FROM learnerEnrollmentComponents lecom
           WHERE lecom.idEnrollments = e.idEnrollments
         );
     ").ToList();
     return context.Enrollments.Where(e => enrollmentIDs.Contains(e.ID));
 }

        public UserEntity AddUser(DataModel.UserEntity user)
        {
            var userToUpdate = new User();
            userToUpdate.FirstName = user.FirstName;
            userToUpdate.LastName = user.LastName;
            userToUpdate.Email = user.Email;
            userToUpdate.PositionId = user.PositionId;
            userToUpdate.UserName = user.UserName;
            userToUpdate.Password = user.Password;

            if (user.Projects.Count > 0)
            {
                foreach (var item in user.Projects)
                {
                    Project p = dataContext.Projects.Where(q => q.ProjectId == item.ProjectId).First();
                    userToUpdate.Projects.Add(p);
                }
            }

            if (user.Rights.Count > 0)
            {
                foreach (var item in user.Rights)
                {
                    Right r = dataContext.Rights.First(c => c.RightId == item.RightId);
                    userToUpdate.Rights.Add(r);
                }
            }

            dataContext.Users.Add(userToUpdate);
            dataContext.SaveChanges();

            return user;
        }

        public PlaylistItem(MPDSongResponseBlock block, DataModel dataModel)
        {
            Path = new Path(block.File);
            Position = block.Pos;
            Id = block.Id;

            if (Path.IsStream())
            {
                Artist = null;
                Album = null;
                AudioStream stream = dataModel.StreamsCollection.StreamByPath(Path);

                if (stream != null)
                {
                    Title = stream.Label;
                }
                else
                {
                    Title = block.Name ?? Path.ToString();
                }
            }
            else
            {
                Title = block.Title;
                Album = block.Album;

                if (Settings.Default.UseAlbumArtist)
                {
                    Artist = block.AlbumArtist ?? block.Artist;
                }

                Artist = block.Artist;
            }
        }