c# how to use Property

Question

I want to learn more about c#, and I've heard that you should use Private specifier and use get/set to make it public.

I got a small application that take textbox data and writes it to a file. And it encrypts the file.

But I can't graps the concept about getters and setters. Here is my one of my classes and Methods that writes to a file.

     class MyClass
{
     public static bool WriteToFile(string text)
    {
        string FileName = "C:\\crypt\\crypt.txt";
        try
        {
            using (System.IO.StreamWriter WriteToFile = new System.IO.StreamWriter(FileName))
            {
                WriteToFile.Write(text);
                WriteToFile.Close();
            }
            return true;
        }
        catch
        {
            return false;
        }
    }

But instead i want to use a property. How should i do it?

This is how i pass in the textbox-data from my main class.

        public void button1_Click(object sender, EventArgs e)
    {
        MyClass c = new MyClass();
        if (MyClass.WriteToFile(textBox1.Text))
            MessageBox.Show("success, managed to write to the file");
        else
            MessageBox.Show("Error, Could not write to file. Please check....");

I've looked at various tutorials such as https://channel9.msdn.com/series/C-Fundamentals-for-Absolute-Beginners/15 and tutorials, but I really stuggling.

Answer 1

There is not much to change to your design besides one little thing. But first things first:

Could you place that code into a property? Sure. Should you? Not at all. Your method WriteToFile is actually doing sth. and thats what methods are for. Properties on the other hand are used for modifying/storing data.

Thats why property-names sound more like Names while method-names generally sound like Commands:

Example

public class Sample
{
    private string someText;

    // This Property Stores or modifies SomeText
    public string SomeText 
    {
        get { return this.someText; }        
        set { this.someText = value; }
    }

    // Method that does sth. (writes sometext to a given File)
    public void WriteSomeTextToFile(string File)
    {
         // ...
    }
}

Why properties/modifiers?

it is considered good pratice to encapsulate data within propeties like in the example above. A small improvement could be the use of an AutoProperty like so:

public string SomeText { get; set; }

which basically results in the same structure as the combination of an encapsulated field like in the first example.

Why?: because this makes it easy to switch it out or to add logic to your get/set-operations.

For example, you could add validation:

public string SomeText 
{
        // ...
        set
        { 
            if (value.Length > 100)
                throw new Exception("The given text is to long!");

            this.someText = value; 
        }        
}

SideNote: Possible improvement to your class

The only improvement I could think of is not to swallow the exception in your write method:

public void WriteToFile()
{
    using (var fileWriter= new System.IO.StreamWriter(FileName))
    {
        fileWriter.Write(_text);
        fileWriter.Close();
    }
}

This is much cleaner and you would not have to "decision" cascades handling the same issue (your try/catch and if/else) are practically doing the same.

public void button1_Click(object sender, EventArgs e)
{
    try
    {
        var c = new MyClass();
        c.WriteToFile(textBox1.Text))
        MessageBox.Show("success, managed to write to the file");
    }
    catch(Exception e)
    {
        MessageBox.Show("Error, Could not write to file. " + e.Message);
    }
}

This way, you do not only have the same behaviour, but you also have more information than just the raw fact that your operation was unsuccessful (false)