i am trying to make a note pad but it's not working from any tutorials from youtube.

Question

i am trying to add notepad or make notepad in wpf. but there is a line in tutorials "DataTable note= new DataTable" i am not able to add in Visual studio 2022. add after that when I try to add it in my .xaml.cs file the app keeps on crashing. i had to undo and restart the app but it's not entering. the errror is
"can't add" to "can't find dataTable in window"..
i need to submit project in uni.
help me. how to make notepad(note taking app)

Accepted Answer

Hi,@_ ati . Welcome Microsoft Q&A.
For creating NotePad application in wpf project, you could refer to the code below.

Project structure：

MainWindow.xaml:

FontDialog:

  
      
          
          
            12  
            18  
            26  
            36  
            72  
          
          
            Normal  
            Bold  
            ExtraBold  
          
          
            Normal  
            Italic  
            Oblique  
          
      
      
          
              
              
          
          
              
              
          
          
            Font Family  
              
                  
                      
                          
                      
  
                  
              
             
          
          
             Font Size  
              
          
          
            Font Styles  
              
          
          
            Font Weight

Codebehind:

using Microsoft.Win32;  
using System;  
using System.ComponentModel;  
using System.IO;  
using System.Runtime.CompilerServices;  
using System.Windows;  
using System.Windows.Input;  
using System.Windows.Media;  
  
namespace NotePadDemo  
{  
    public partial class MainWindow : Window  
    {  
        public MainWindow()  
        {  
            InitializeComponent();  
  
        }  
    }  
    public class BaseModel : INotifyPropertyChanged  
    {  
        public event PropertyChangedEventHandler? PropertyChanged;  
        protected void NotifyPropertyChanged([CallerMemberName] String propertyName = null)  
        {  
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));  
        }  
    }  
    public class DocumentModel: BaseModel  
    {  
        private string text;  
        public string Text  
        {  
            get { return text; }  
            set  
            {  
                text = value;  
                NotifyPropertyChanged("Text");  
            }  
        }  
        private string filePath;  
        public string FilePath  
        {  
            get { return filePath; }  
            set  
            {  
                filePath = value;  
                NotifyPropertyChanged("FilePath");  
            }  
        }  
        private string fileName;  
        public string FileName  
        {  
            get { return fileName; }  
            set  
            {  
                fileName = value;  
                NotifyPropertyChanged("FileName");  
            }  
        }  
        public bool isEmpty  
        {  
            get  
            {  
                if (string.IsNullOrEmpty(FileName) || string.IsNullOrEmpty(FilePath))  
                    return true;  
                return false;  
            }  
        }  
    }  
    public class FormatModel : BaseModel  
    {  
        private FontStyle style;  
        public FontStyle Style  
        {  
            get { return style; }  
            set  
            {  
                style = value;  
                NotifyPropertyChanged("Style");  
            }  
        }  
        private FontWeight weight;  
        public FontWeight Weight  
        {  
            get { return weight; }  
            set  
            {  
                weight = value;  
                NotifyPropertyChanged("Weight");  
            }  
        }  
        private FontFamily? family;  
        public FontFamily? Family  
        {  
            get { return family; }  
            set  
            {  
                family = value;  
                NotifyPropertyChanged("Family");  
            }  
        }  
        private TextWrapping wrap;  
        public TextWrapping Wrap  
        {  
            get { return wrap; }  
            set  
            {  
                wrap = value;  
                NotifyPropertyChanged("Wrap");  
                IsWrapped = value == TextWrapping.Wrap ? true : false;  
            
            }  
        }  
        private bool isWrapped;  
        public bool IsWrapped  
        {  
            get { return isWrapped; }  
            set  
            {  
                isWrapped = value;  
                NotifyPropertyChanged("IsWrapped");  
            }  
        }  
        private double size;  
        public double Size  
        {  
            get { return size; }  
            set  
            {  
                size = value;  
                NotifyPropertyChanged("Size");  
            }  
        }  
    }  
  
    public class MainViewModel  
    {  
        private DocumentModel document;  
        public EditorViewMode Editor { get; set; }  
        public FileViewModel File { get; set; }  
        public HelpViewModel Help { get; set; }  
        public MainViewModel()   
        {  
            document = new DocumentModel();  
            Editor = new EditorViewMode(document);  
            File = new FileViewModel(document);  
            Help = new HelpViewModel();  
        }  
    }  
    public class HelpViewModel : BaseModel  
    {  
        public ICommand HelpCommand { get; }  
        public HelpViewModel()  
        {  
            HelpCommand = new RelayCommand(DisplayAbout);  
        }  
        private void DisplayAbout()  
        {  
           //about  
        }  
    }  
    public class FileViewModel  
    {  
        public DocumentModel Document { get; private set; }  
  
        public ICommand NewCommand { get; }  
        public ICommand SaveCommand { get; }  
        public ICommand SaveAsCommand { get; }  
        public ICommand OpenCommand { get; }  
        public FileViewModel( DocumentModel document)  
        {  
            Document = document;  
            NewCommand = new RelayCommand(NewFile);  
            SaveCommand = new RelayCommand(SaveFile);  
            SaveAsCommand = new RelayCommand(SaveFileAs);  
            OpenCommand = new RelayCommand(OpenFile);  
        }  
        public void NewFile()  
        {  
            Document.FileName = string.Empty;  
            Document.FilePath = string.Empty;  
            Document.Text = string.Empty;  
        }  
        private void SaveFile()  
        {  
            File.WriteAllText(Document.FilePath, Document.Text);  
        }  
        private void SaveFileAs()  
        {  
            var saveFileDialog = new SaveFileDialog();  
            saveFileDialog.Filter = "Text File (*.txt)|*.txt";  
            if (saveFileDialog.ShowDialog() == true)  
            {  
                DockFile(saveFileDialog);  
                File.WriteAllText(saveFileDialog.FileName, Document.Text);  
            }  
        }  
        private void OpenFile()  
        {  
            var openFileDialog = new OpenFileDialog();  
            if (openFileDialog.ShowDialog() == true)  
            {  
                DockFile(openFileDialog);  
                Document.Text=File.ReadAllText(openFileDialog.FileName);  
            }  
        }  
        private void DockFile(T dialog) where T :FileDialog  
        {  
            Document.FilePath = dialog.FileName;  
            Document.FileName = dialog.SafeFileName;  
        }  
    }  
    public class EditorViewMode  
    {  
        public ICommand FormatCommand { get; }  
        public ICommand WrapCommand { get; }  
        public FormatModel Format { get; set; }  
        public DocumentModel Document { get; set; }  
        public EditorViewMode(DocumentModel document)  
        {  
            Document = document;  
            Format = new FormatModel();  
            FormatCommand = new RelayCommand(OnpenStyleDialog);  
            WrapCommand = new RelayCommand(ToggleWrap);  
        }  
        private void OnpenStyleDialog()  
        {  
            var fontDialog = new FontDialog();  
            fontDialog.DataContext = Format;  
            fontDialog.ShowDialog();  
        }  
        private void ToggleWrap()  
        {  
            if (Format.Wrap == TextWrapping.Wrap)  
                Format.Wrap = TextWrapping.NoWrap;  
            else  
                Format.Wrap = TextWrapping.Wrap;  
        }  
    }  
    public class RelayCommand : ICommand  
    {  
  
        readonly Action _execute;  
        readonly Func _canExecute;  
        public RelayCommand(Action execute, Func canExecute)  
        {  
            if (execute == null)  
                throw new NullReferenceException("execute");  
            _execute = execute;  
            _canExecute = canExecute;  
  
        }  
        public RelayCommand(Action execute) : this(execute, null)  
        {  
  
        }  
        public event EventHandler? CanExecuteChanged  
        {  
            add { CommandManager.RequerySuggested += value; }  
            remove { CommandManager.RequerySuggested -= value; }  
        }  
        public bool CanExecute(object? parameter)  
        {  
            return _canExecute == null ? true : _canExecute();  
        }  
  
        public void Execute(object? parameter)  
        {  
            _execute.Invoke();  
        }  
         
    }  
}

The result:

Update:
Modify SaveFile() as follows：

private void SaveFile()  
        {  
            if (Document.FilePath == null)  
            {  
                var saveFileDialog = new SaveFileDialog();  
                saveFileDialog.Filter = "Text File (*.txt)|*.txt";  
                if (saveFileDialog.ShowDialog() == true)  
                {  
                    DockFile(saveFileDialog);  
                    File.WriteAllText(saveFileDialog.FileName, Document.Text);  
                }  
            }  
            else  
            {  
                File.WriteAllText(Document.FilePath, Document.Text);  
            }  
             
        }

If the response is helpful, please click "Accept Answer" and upvote it.
Note: Please follow the steps in our documentation to enable e-mail notifications if you want to receive the related email notification for this thread.

Answer

Hello, you'll have to flesh out your question a little more. For starters, what are you using the DataTable for? It seems maybe you're storing your notes on a database. If what you want is a simple note taking app, I'll go with a simple TextBox for basic text input and editing, a tool bar with File menu to open and save text files, and instead of saving the text from TextBox in a database (in case this is what you're doing) I'd save them as plain text files in the file system.

i am trying to make a note pad but it's not working from any tutorials from youtube.

1 additional answer