C# Note类代码示例

    /// <summary>
    /// Submit Button Click Event
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void btnSubmit_Click(object sender, EventArgs e)
    {
        NoteAdmin _Noteadmin = new NoteAdmin();
        Note _NoteAccess = new Note();

        _NoteAccess.CaseID = ItemID;
        _NoteAccess.AccountID = null;
        _NoteAccess.CreateDte = System.DateTime.Now;
        _NoteAccess.CreateUser = HttpContext.Current.User.Identity.Name;
        _NoteAccess.NoteTitle = txtNoteTitle.Text.Trim();
        _NoteAccess.NoteBody = ctrlHtmlText.Html ;

        bool Check = _Noteadmin.Insert(_NoteAccess);

        if (Check)
        {
            //redirect to main page
            Response.Redirect(CancelLink);
        }
        else
        {
            //display error message
            lblError.Text  = "An error occurred while updating. Please try again.";
            lblError.Visible = true;
        }
    }

        protected override void OnNavigatedTo(System.Windows.Navigation.NavigationEventArgs e)
        {
            base.OnNavigatedTo(e);

            string item = null;
            _isEditMode = false;

            if (NavigationContext.QueryString.TryGetValue("item", out item))
            {
                //call get note;
                if (_manager != null)
                {
                    _currentNote = _manager.Retrieve(Convert.ToInt32(item));
                    //set node properties to the UI
                    if (_currentNote == null)
                    {
                        tbContent.Text = string.Empty;
                        tbTitle.Text = string.Empty;
                    }
                    else
                    {
                        tbContent.Text = _currentNote.Content;
                        tbTitle.Text = _currentNote.Title;
                        _isEditMode = true;
                    }
                }
            }
        }

 /// <summary>
 /// Play an array of Notes
 /// </summary>
 /// <param name="notes">An array of Note objects, each defining a frequency and duration</param>
 public void Play(Note[] notes)
 {
     foreach (Note note in notes)
     {
         Play(note.Frequency, note.Duration);
     }
 }

 //Button Add click handler
 private void btnAdd_Click(object sender, EventArgs e)
 {
     if (CheckUpCount() == true)
     {
         try
         {
             //show Editor dialog
             frmEditor EditorForm = new frmEditor();
             EditorForm.ShowDialog();
             //add new data to data-collection
             if (EditorForm.IsCanceled == false)
             {
                 Note NewNote = new Note(EditorForm.TextName, EditorForm.TextArray);
                 EncryptedData.AddNote(NewNote);
             }
         }
         catch (OutOfMemoryException Exc)
         {
             MessageBox.Show(Exc.ToString());
         }
         catch (ArgumentException Exc)
         {
             MessageBox.Show(Exc.ToString());
         }
         //add new record to grid
         UpdateGrid();
     }
 }

		private void NoteDeletedHandler (object noteMgr, Note deletedNote)
		{
			deletedNotes [deletedNote.Id] = deletedNote.Title;
			fileRevisions.Remove (deletedNote.Id);

			Write (localManifestFilePath);
		}

        async void CheckForResumedStartup()
        {
            if (await FileHelper.ExistsAsync(App.TransientFilename))
            {
                // Read the file.
                string str = await FileHelper.ReadTextAsync(App.TransientFilename);

                // Delete the file.
                await FileHelper.DeleteFileAsync(App.TransientFilename);

                // Break down the file contents.
                string[] contents = str.Split('\x1F');
                string filename = contents[0];
                bool isNoteEdit = Boolean.Parse(contents[1]);
                string entryText = contents[2];
                string editorText = contents[3];

                // Create the Note object and initialize it with saved data.
                Note note = new Note(filename);
                note.Title = entryText;
                note.Text = editorText;

                // Navigate to NotePage.
                NotePage notePage = new NotePage(note, isNoteEdit);
                await this.Navigation.PushAsync(notePage);
            }
        }

    public void Open(List<Minion> minions, List<Note> notes)
    {
        //Transform parent = this.transform.parent;

        this.minion = null;
        foreach (Minion m in minions) {
            if (m.gameObject.name == this.minionName) {
                this.minion = m;
                break;
            }
        }

        this.note = null;
        foreach (Note n in notes) {
            if (n.gameObject.name == this.noteName) {
                this.note = n;
                break;
            }
        }

        if (this.minion != null) {
            this.minion.EnableClicks();
            this.minion.gameObject.GetComponent<SpriteRenderer>().color = Color.white;
        }
        if (this.note != null) {
            this.note.EnableClicks();
            this.note.gameObject.GetComponent<SpriteRenderer>().color = Color.white;
        }
    }

        public void AddNotes(string SqlWhereClause = null)
        {
            int idFld = m_NotesTable.FindField("Notes_ID");
            int ownerFld = m_NotesTable.FindField("OwnerID");
            int typeFld = m_NotesTable.FindField("Type");
            int notesFld = m_NotesTable.FindField("Notes");
            int dsFld = m_NotesTable.FindField("DataSourceID");

            ICursor theCursor;

            if (SqlWhereClause == null) { theCursor = m_NotesTable.Search(null, false); }
            else
            {
                IQueryFilter QF = new QueryFilterClass();
                QF.WhereClause = SqlWhereClause;
                theCursor = m_NotesTable.Search(QF, false);
            }

            IRow theRow = theCursor.NextRow();

            while (theRow != null)
            {
                Note anNote = new Note();
                anNote.Notes_ID = theRow.get_Value(idFld).ToString();
                anNote.OwnerID = theRow.get_Value(ownerFld).ToString();
                anNote.Notes = theRow.get_Value(notesFld).ToString();
                anNote.Type = theRow.get_Value(typeFld).ToString();
                anNote.DataSourceID = theRow.get_Value(dsFld).ToString();
                anNote.RequiresUpdate = true;

                m_NotesDictionary.Add(anNote.Notes_ID, anNote);

                theRow = theCursor.NextRow();
            }
        }

        private static void Go(long userId)
        {
            var settings = new MongoServerSettings
            {
                Server = new MongoServerAddress("127.0.0.1", 27017),
                SafeMode = SafeMode.False
            };
            var mongoServer = new MongoServer(settings);

            var database = mongoServer.GetDatabase("Test");

            var map = new NoteMap();
            var collection = new EntityCollection<Note>(database, map.GetDescriptor(), true);

            var note = new Note
            {
                NoteID = "1",
                Title = "This is a book.",
                Content = "Oh yeah",
                UserID = 123321L
            };
            // collection.InsertOnSubmit(note);
            // collection.SubmitChanges();
            // var data = collection.SelectTo(n => new { n.NoteID, n.UserID });
            collection.Log = Console.Out;
            var a = 4;
            collection.Update(
                n => new Note { },
                n => true);
        }

        public float ComputeFitness(Note[] individual)
        {
            float weighted_sum = 0;
            for (int i = 0; i < metrics.Length; i++)
            {
                var x = metrics[i].Generate(individual);
                var t = target_metrics[i];
                float magx = 0;
                float magt = 0;
                float dot = 0;
                foreach(var v in x.Values)
                    magx += v * v;
                foreach(var v in t.Values)
                    magt += v * v;
                foreach (var p in x.Keys)
                {
                    float f1 = x[p];
                    if (!t.ContainsKey(p))
                        continue;

                    float f2 = t[p];
                    dot += f1 * f2;
                }
                magx = (float)Math.Sqrt(magx);
                magt = (float)Math.Sqrt(magt);
                if (magx == 0 || magt == 0)
                    return 0;
                weighted_sum += dot / (magx * magt);
            }
            return weighted_sum / metrics.Length;
        }

        public List<Note> GetNotes(Roll roll)
        {
            string sql = NotesSql(roll);
            var reader = Data_Context.RunSelectSQLQuery(sql, 30);

            var notes = new List<Note>();

            if (reader.HasRows)
            {
                var sReader = new SpecialistsReader();
                while (reader.Read())
                {
                    string uName = reader["Author"] as string;
                    var spec = sReader.GetSpecialist(uName);
                    string n = reader["Note"] as string;
                    DateTime date = reader.GetDateTime(4);
                    string step = reader["StepTypeID"] as string;

                    var note = new Note(spec, n, date, step);
                    notes.Add(note);
                }
                return notes;
            }
            else return null;
        }

        public NoteContent(object sender , object sender1)
        {
            this.InitializeComponent();
            item = (Button)sender;
            item1 = (Button) sender1;
            notepadRepository = new NotepadRepository();
            ourNotes = notepadRepository.GetNotes(item.Content.ToString().ToLower());
            notepad = ourNotes[0].notepad;

            foreach (Note note in ourNotes)
            {
                if (note.title == item1.Content.ToString().ToLower())
                    CurrNote = note;
            }
            if (CurrNote != null)
            {
                if (CurrNote.title == "+")
                    CurrNote.title = "New Title";
                NoteAct.Text = CurrNote.content;
                //NoteAct.Document.SetText(new Windows.UI.Text.TextSetOptions(), CurrNote.content);
                NoteName.Text = CurrNote.title;
            }
            AppTitle.Text = notepad;
                foreach (Note note in ourNotes)
            {
                notes.Items.Add(createNoteButton(note.title,note.content));
            }
        }

        public NewItemWindow(Note source)
            : this()
        {
            Title = "Edit Note";

            NoteEditControl.SourceNote = source;
        }

        /// <summary>
        /// Handles the Click event of the lbAddNote control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param>
        protected void lbAddNote_Click( object sender, EventArgs e )
        {
            var rockContext = new RockContext();
            var service = new NoteService( rockContext );

            var note = new Note();
            note.IsSystem = false;
            note.IsAlert = false;
            note.NoteTypeId = noteType.Id;
            note.EntityId = contextEntity.Id;
            note.Text = tbNewNote.Text;

            if ( noteType.Sources != null )
            {
                var source = noteType.Sources.DefinedValues.FirstOrDefault();
                if ( source != null )
                {
                    note.SourceTypeValueId = source.Id;
                }
            }

            service.Add( note );
            rockContext.SaveChanges();

            ShowNotes();
        }

 public static int getNoteIndex(Note note)
 {
     switch (note)
     {
         case Note.C1:
         case Note.Cs:
             return 0;
         case Note.D1:
         case Note.Ds:
             return 1;
         case Note.E1:
             return 2;
         case Note.F1:
         case Note.Fs:
             return 3;
         case Note.G1:
         case Note.Gs:
             return 4;
         case Note.A1:
         case Note.As:
             return 5;
         case Note.B1:
             return 6;
         case Note.C2:
             return 7;
         default:
             return -1;
     }
 }