C# Mark类代码示例

 public void addSubjectMarkToStudent(string subject, string studentNeptunCode, Mark mark)
 {
     if (this.trunk.ContainsKey(subject))
     {
         this.trunk[subject].addMarkToStudent(studentNeptunCode, mark);
     }
 }

 public void TestMarks( string fileName)
 {
     var stream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
     var inputs = new StreamReader(stream).ReadToEnd().Split(new[] {"---\n"}, StringSplitOptions.None);
     foreach (var input in inputs.Skip(1))
     {
         var index = 0;
         var line = 0;
         var column = 0;
         while (index < input.Length && input[index] != '*')
             if (input[index++] == '\n')
             {
                 line++;
                 column = 0;
             }
             else
                 column++;
         var mark = new Mark
                        {
                            Name = fileName,
                            Index = index,
                            Line = line,
                            Column = column,
                            Buffer = new StringBuilder(input),
                            Pointer = index
                        };
         var snippet = mark.GetSnippet(2, 79);
         var lineCount = snippet.Count(c => c == '\n');
         Assert.AreEqual(lineCount, 1);
         var lines = snippet.Split('\n');
         Assert.Less(lines[0].Length, 82);
         Assert.AreEqual(lines[0][lines[1].Length - 1], '*');
     }
     stream.Close();
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="DocumentStart"/> class.
 /// </summary>
 /// <param name="version">The version.</param>
 /// <param name="tags">The tags.</param>
 /// <param name="isImplicit">Indicates whether the event is implicit.</param>
 /// <param name="start">The start position of the event.</param>
 /// <param name="end">The end position of the event.</param>
 public DocumentStart(VersionDirective version, TagDirectiveCollection tags, bool isImplicit, Mark start, Mark end)
     : base(start, end)
 {
     this.version = version;
     this.tags = tags;
     this.isImplicit = isImplicit;
 }

        public void TestConstructor_PassValidValues_ShouldSetValueAndSubjectCorrectly(float value, Subject subject)
        {
            var mark = new Mark(subject, value);

            Assert.AreEqual(mark.Subject, subject);
            Assert.AreEqual(mark.Value, value);
        }

 public static void ValidateMark(Mark mark)
 {
     if (!(mark.MarkValue >= 2.00M && mark.MarkValue <= 6.00M))
     {
         throw new MarkException();
     }
 }

 protected BasePlayer(string name, Mark mark)
 {
     EnsuresNameIsValid(name);
     EnsuresMarkIsValid(mark);
     _name = name;
     _mark = mark;
 }

        public void TestConstructor_PassValidValues_ShouldInitialiseCorrectly(float value, Subject subject)
        {
            var mark = new Mark(subject, value);

            Assert.IsNotNull(mark);
            Assert.IsInstanceOf<Mark>(mark);
        }

        private void btnSave_Click_1(object sender, RoutedEventArgs e)
        {
            SubjectName subject = GetSubjectName();
            TypeOfMarks markType = GetMarkType();

            Mark newMark = new Mark(decimal.Parse(txtMarkValue.Text), markType, student, new Subject(subject));

            // Validate the mark. If the mark is incorrect, throw exception.
            try
            {
                Validation.ValidateMark(newMark);

                ESchoolDiaryData.Marks.Add(newMark);
                studentWindow.lblSubjectContent.Content += lblSubject.Content.ToString();
                studentWindow.lblMarksTypeContent.Content += lblMarkType.Content.ToString();
                studentWindow.lblMarksValueContent.Content += string.Format("{0:0.00}", decimal.Parse(txtMarkValue.Text));

                MessageBox.Show("Mark added.");

                this.Close();
            }
            catch (MarkException markEx)
            {
                MessageBox.Show(markEx.Message);
            }
            finally
            {
                txtMarkValue.Clear();
            }
        }

 public virtual IGrid Fill(IPosition position, Mark mark)
 {
     var grid = new Mark[3, 3];
     Array.Copy(_grid, grid, _grid.Length);
     grid[position.Row, position.Col] = mark;
     return new Grid3X3(grid);
 }

        public async Task<int> Add(string authorId, int imageId, int value)
        {
            var assessingUser = this.users
                .All()
                .FirstOrDefault(u => u.Id == authorId);

            var imageToAttachMarkTo = this.images
                .All()
                .FirstOrDefault(i => i.Id == imageId);

            if (imageToAttachMarkTo == null || assessingUser == null)
            {
                return GlobalConstants.InvalidDbObjectReturnValue;
            }

            var markToAdd = new Mark()
            {
                GivenBy = assessingUser,
                IsDeleted = false,
                Value = value
            };

            imageToAttachMarkTo.Rating.Marks.Add(markToAdd);

            this.images.Update(imageToAttachMarkTo);

            await this.images.SaveChangesAsync();

            return markToAdd.Id;
        }

 private static bool IsRange(int index, Mark mark)
 {
     if (mark.HeadCharIndex >= index && mark.TailCharIndex <= index)
     {
         return true;
     }
     return false;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="Scalar"/> class.
 /// </summary>
 /// <param name="anchor">The anchor.</param>
 /// <param name="tag">The tag.</param>
 /// <param name="value">The value.</param>
 /// <param name="style">The style.</param>
 /// <param name="isPlainImplicit">.</param>
 /// <param name="isQuotedImplicit">.</param>
 /// <param name="start">The start position of the event.</param>
 /// <param name="end">The end position of the event.</param>
 public Scalar(string anchor, string tag, string value, ScalarStyle style, bool isPlainImplicit, bool isQuotedImplicit, Mark start, Mark end)
     : base(anchor, tag, start, end)
 {
     this.value = value;
     this.style = style;
     this.isPlainImplicit = isPlainImplicit;
     this.isQuotedImplicit = isQuotedImplicit;
 }

        private void button1_Click(object sender, EventArgs e)
        {
            Mark m = new Mark("Chris");//constructor runs here.
            m.testThis();

            Mark j = new Mark();
            j.testThis();
        }

 public void addMarkToStudent(string neptunCode, Mark mark)
 {
     Student student = this.findStudent(neptunCode);
     if (student != null)
     {
         student.addMark(mark);
     }
 }

 public Student(string firstName, string secondName, Mark mark, Group group, Dictionary<Subject, Mark> subjectsMarks, DateTime birthDate)
 {
     _firstName = firstName;
     _secondName = secondName;
     _mark = mark;
     CurrentGroup = group;
     _subjectsMarks = subjectsMarks;
     _birthDate = birthDate;
 }