Employing static properties and methods effectively

Normally, you keep data and behaviors that reflect an object within the class definition. In the previous example, OutputName() and SetName() appeared as part of the Program class, which definitely breaks the Object-Oriented Programming (OOP) encapsulation rules. You could rewrite the Student class from the previous section in a better way, as shown in the StudentClass1 program:

internal class Student
{
private static int _numStudents = 1;

internal string Name { get; set; }

internal static void OutputName(Student student)
{
Console.WriteLine($"Student's name is {student.Name}.");
}

internal static int NumStudents { get => _numStudents; }

internal static void SetNumStudents(int NumStudents)
{
if (NumStudents > 0)
_numStudents = NumStudents;
else
throw new ArgumentOutOfRangeException(
"Value must be greater than 0", "NumStudents");
}

internal static void OutputNumStudents()
{
Console.WriteLine($"The number of students is: {_numStudents}.");
}
}

This version of the class focuses on moving OutputName(), which is implemented as a static method, to the class. It directly accesses the instance property Name. The reason you create OutputName() as a static method is that it works just fine for any instance. One instance won't use one version of OutputName(), while another instance uses a completely different version. The resulting confusion of such a scenario would boggle anyone’s mind. So, you can combine static methods and instance properties as needed within your application.

You also see a new static property member, NumStudents. The reason you implement NumStudents as a static property, rather than an instance property, is that the number of students at a school will apply to every student equally. Unless some funny stuff is going on, every student will see the same number of students at the school, rather than see some invisible students that only they can see. Accessing _numStudents, which is the field that holds the NumStudents property value, requires a somewhat different form of get accessor because you now have an actual named field. Also notice that _numStudents has a private scope because nothing outside the class needs to access it. Normally, static properties are get-only, so this example provides a specific SetNumStudents() static method to change the value. Notice that this set accessor provides error trapping in the form of an ArgumentOutOfRangeException. Finally, the OutputNumStudents() method outputs the current number of students in a formatted manner. In general, you don't combine static properties with instance methods; you use static methods to access static properties.

The Main() method is changed from the previous example in that it provides access to the new static property. However, this version of Main() is also broken because Name no longer provides any error trapping. Don't worry, this problem gets fixed in the next section. Here is the current Main() code.

static void Main(string[] args)
{
Student student = new Student();

// Set the number of students.
try
{
Student.SetNumStudents(2);

// Display the number of students.
Student.OutputNumStudents();
Console.WriteLine($"The Number of Students is: " +
$"{Student.NumStudents}.");
}
catch (ArgumentOutOfRangeException e)
{
Console.WriteLine(e.Message);
}

// Try to supply a bad name.
Console.WriteLine(" Trying a bad value:");
try
{
student.Name = "";
Student.OutputName(student);
}
catch (ArgumentException e)
{
Console.WriteLine(e.Message);
Console.WriteLine($"Sent {e.ParamName} "" value.");
}

// Change the name using a method.
Console.WriteLine(" After being modified:");
try
{
student.Name = "Sally";
Student.OutputName(student);
}
catch (ArgumentException e)
{
Console.WriteLine(e.Message);
Console.WriteLine($"Sent {e.ParamName} "" value.");
}
Console.Read();
}

This version of Main() will form most of the basis for the code in the next section, where you'll see the current problems fixed. For now, supplying a blank name doesn’t trigger an error message, as shown here:

The number of students is: 2.
The Number of Students is: 2.

Trying a bad value:
Student's name is .

After being modified:
Student's name is Sally.

Employing instance properties and methods effectively

Instance properties and methods tend to focus on object elements that differ between instances or are somehow instance-specific. The updated version of the Student class found in the StudentClass2 program shows some interesting changes that make the class work a lot better than the version in the previous section.

internal class Student
{
private string _name = "";
private static int _numStudents = 1;

internal string Name
{
get => _name;
set
{
if (value.Length > 1)
_name = value;
else
throw new ArgumentException("Blank names not allowed!",
"Name");
}
}

internal static void OutputName(Student student)
{
Console.WriteLine($"Student's name is {student.Name}.");
}

public override string ToString()
{
// Output current student's name.
return $"Student's name is {Name}.";
}

internal static int NumStudents { get => _numStudents; }

internal static void SetNumStudents(int NumStudents)
{
if (NumStudents > 0)
_numStudents = NumStudents;
else
throw new ArgumentOutOfRangeException(
"Value must be greater than 0", "NumStudents");
}

internal static void OutputNumStudents()
{
Console.WriteLine($"The number of students is: {_numStudents}.");
}
}

The first thing to notice is that the Name property now uses a field, just as NumStudents does. It's likewise set to have a private scope for reasons of security. The Name property code now includes the same kind of security features as the SetName() method did in the first example, but now it's part of the actual property code, where it belongs. Because of the addition of the _name field, the get accessor also needs to change as shown.

As you're looking down the list of methods, you notice a law breaker, the ToString() method. The standard ToString() method, which is provided by default with every class, outputs StudentClass.Student, which is singularly uninformative. So, this version of the class defines a new ToString() method by overriding the default version using the override keyword. Because you're overriding an existing method, you must use the same scope that it uses for your override. This is an instance method because you want the string value of the current class instance, rather than the class as a whole. Using this version of ToString(), you can replace Student.OutputName(student); with Console.WriteLine(student.ToString()); in Main(). Using the ToString() approach offers significant advantages, such as being able to modify the string as needed for a specific requirement. Now that the Student class is fixed, you see this output:

The number of students is: 2.
The Number of Students is: 2.

Trying a bad value:
Blank names not allowed!
Parameter name: Name
Sent Name "" value.

After being modified:
Student's name is Sally.
Student's name is Sally.

Expanding a method's full name

A subtle but important problem exists with the method names found in some applications. To see the problem, consider this sample code snippet:

public class Person
{
public void Address()
{
Console.WriteLine("Hi");
}
}

public class Letter
{
string address;

// Store the address.
public void Address(string newAddress)
{
address = newAddress;
}
}

Any subsequent discussion of the Address() method is now ambiguous. The Address() method within Person has nothing to do with the Address() method in Letter. If an application needs to access the Address() method, which Address() does it access? The problem lies not with the methods themselves, but rather with the description. In fact, no Address() method exists as an independent entity — only a Person.Address() and a Letter.Address() method. Attaching the class name to the beginning of the method name clearly indicates which method is intended.

This description is quite similar to people's names. At home, you might not ever experience any ambiguity because you’re the only person who has your name. However, at work, you might respond to a yell when someone means to attract the attention of another person with the same name as yours. Of course, this is the reason that people resort to using last names. Thus, you can consider Address() to be the first name of a method, with its class as the family name.

What is the this keyword?

Unlike most arguments, the current object doesn't appear in the method argument list, so it isn’t assigned a name by the programmer. Instead, C# assigns this object the less-than-imaginative name this, which is useful in the few situations in which you need to refer directly to the current object. Thus you could write the previous example this way (as shown in CurrentObject3):

internal class Student
{
// The name information to describe a student
private string firstName;
private string lastName;

// SetName -- Save name information.
internal void SetName(string FirstName, string LastName)
{
this.SetFirstName(FirstName);
this.SetLastName(LastName);
}

private void SetFirstName(string FirstName)
{
this.firstName = FirstName;
}

private void SetLastName(string LastName)
{
this.lastName = LastName;
}

public override string ToString()
{
return $"{firstName} {lastName}";
}
}

Notice the explicit addition of the keyword this. Adding it to the member references doesn't add anything because this is assumed. However, when Main() makes the following call, this references student1 throughout SetName() and any other method it may call:

student1.SetName("John", "Smith");

When is the this keyword explicit?

You don't normally need to refer to this explicitly because it is understood where necessary by the compiler. However, two common cases require this. You may need it when initializing data members, as in this example:

internal class Person
{
private string name; // This is this.name below.
private int id; // And this is this.id below.

internal void Init(string name, int id) // These are method arguments.
{
this.name = name; // Argument names same as data member names
this.id = id;
}
}

The parameters in the Init() method declaration are named name and id, which match the names of the corresponding data members. The method is then easy to read because you know immediately which argument is stored where. The only problem is that the name name in the argument list obscures the name of the data member. The compiler complains about it.

The addition of this clarifies which name is intended. Within Init(), the variable name refers to the method parameter, but this.name refers to the name field. Of course, the best way to avoid needing to use this in this example is to ensure that the field name differs from the parameter name, which is considered good coding practice now. Using this is likely not required in most instances where a developer uses good variable name choices and proper scoping.

Creating a basic local function

Here's a simple example of a local function that you can also find in BasicLocalFunction:

static void Main(string[] args)
{
//Create a local function
int Sum(int x, int y) { return x + y; }

// Use the local function to output some sums.
Console.WriteLine(Sum(1, 2));
Console.WriteLine(Sum(5, 6));
Console.Read();
}

The Sum() method is relatively simple, but it demonstrates how a local function could work. The function encapsulates some code that only Main() uses. Because Main() performs the required task more than once, using Sum() makes sense to make the code more readable, easier to understand, and easier to maintain.

Local functions have all the functionality of any method except that you can't declare them as static in most cases (you have the option of declaring them static when using C# 8.0 or later—the article at https://www.telerik.com/blogs/c-8-static-local-functions-and-using-declarations provides some additional information on this topic). A local function has access to all the variables found within the enclosing method, so if you need a variable found in Main(), you can access it from Sum().

Using attributes with local functions

C# 9.0 introduces the ability to use attributes with local functions. An attribute is a special code decorator that defines how and when a particular piece of code should interact with the rest of the application. This section discusses a couple of simple examples using the LocalFunctionWithAttributes program. Before you move forward, however, make sure to add the required C# 9.0 to your .csproj file when writing the code on your own, rather than using the downloadable source (which already has all of the required additions for you). You also add this using statement to the top of the Program.cs file:

using System.Diagnostics;

The example uses two attributes, as shown in the following code:

class Program
{
static void Main(string[] args)
{
//Create a debug local function
[Obsolete]
[Conditional("DEBUG")]
static void DebugInfo(int x, int y)
{
Console.WriteLine($"Input x: {x} Input y: {y}");
}

static int Sum(int x, int y) { return x + y; }

// Use the local function to output some sums.
Console.WriteLine(Sum(1, 2));
DebugInfo(1, 2);
Console.WriteLine(Sum(5, 6));
DebugInfo(5, 6);
Console.Read();
}
}

The [Obsolete] attribute tells the compiler that this particular function is still included in the code, but that the developer plans to deprecate it at some point. When the user compiles the code, the following warning appears in the Error List window for each use of the local function:

Warning CS0612 'DebugInfo(int, int)' is obsolete

The [Conditional("DEBUG")] attribute tells the compiler to add the function into the debug builds of the application only. Both the function and the call to the function are removed from the release version of the application. Consequently, when in debug mode, you see this output:

3
Input x: 1
Input y: 2
11
Input x: 5
Input y: 6

There are special requirements for using the [Conditional] attribute (https://docs.microsoft.com/en-us/dotnet/api/system.diagnostics.conditionalattribute) on local functions:

• You must declare the function as static.
• The function can't return a value.
• You must be using C# 9.0 or later.

Different attributes will have different requirements for use, so it pays to spend some time determining just how you plan to use the attribute. For example, the [Obsolete] attribute works on any local function, so you don’t need to do anything special to use it. The [Obsolete] attribute provides considerable additional functionality, which you can read about at https://docs.microsoft.com/en-us/dotnet/api/system.obsoleteattribute.