Oppiskele Refactoring Structs to Classes | Composition, Inheritance, and Refactoring

When designing your applications in C#, you will often decide between using a struct or a class. Both are used to define custom types, but they behave differently and are suited for different scenarios. A struct is a value type, which means it holds its data directly and is typically used for small, simple objects that do not require inheritance or complex behavior. A class, on the other hand, is a reference type, storing a reference to its data on the heap. Classes are more flexible and are the foundation for most object-oriented programming features in C#, such as inheritance and polymorphism.

Understanding the differences between structs and classes is crucial for making effective design decisions. Structs are ideal for lightweight objects that represent a single value or a small group of related values, such as coordinates or colors. Classes are preferable when your object needs to support advanced features, such as inheritance, encapsulation, or when you expect to manage complex state or behavior.

Definition

A struct in C# is a value type used for small, simple objects and is stored on the stack.
A class is a reference type used for more complex objects and is stored on the heap.
The key differences are that structs are copied by value and cannot inherit from other types, while classes are copied by reference and support inheritance and advanced object-oriented features.

Program.cs


              123456789101112131415161718192021222324252627282930313233
            
using System;

namespace ConsoleApp
{
    public struct Point
    {
        public int X;
        public int Y;

        public Point(int x, int y)
        {
            X = x;
            Y = y;
        }

        public void Move(int dx, int dy)
        {
            X += dx;
            Y += dy;
        }
    }

    public class Program
    {
        public static void Main(string[] args)
        {
            Point p1 = new Point(2, 3);
            p1.Move(1, 2);

            Console.WriteLine($"Point is at ({p1.X}, {p1.Y})");
        }
    }
}

To address these issues, you can refactor your struct into a class. Begin by changing the struct keyword to class, and update any code that instantiates or manipulates Point objects. This change allows you to add more advanced features, such as properties, methods, and inheritance. Additionally, as a reference type, the class version of Point will be passed by reference, which can be more efficient for larger objects or when you want changes to persist across method calls.

Point.cs


              12345678910111213141516171819202122232425262728293031323334
            
namespace ConsoleApp
{
    // Refactored Point as a class with added features
    public class Point
    {
        public int X { get; set; }
        public int Y { get; set; }

        public Point(int x, int y)
        {
            X = x;
            Y = y;
        }

        public void Move(int dx, int dy)
        {
            X += dx;
            Y += dy;
        }

        public double DistanceTo(Point other)
        {
            int dx = X - other.X;
            int dy = Y - other.Y;
            return System.Math.Sqrt(dx * dx + dy * dy);
        }

        public override string ToString()
        {
            return $"({X}, {Y})";
        }
    }
}

The distinction between value types (structs) and reference types (classes) has a significant impact on how your application manages memory and performance. Value types are allocated on the stack and copied when passed to methods or assigned to new variables, making them fast and efficient for small data structures. Reference types are allocated on the heap, and only the reference is copied, not the entire object. This means changes made to an object through one reference are visible through all references to that object. In real-world applications, using classes for objects that are shared or mutated across different parts of your program can help avoid subtle bugs and improve performance for complex data structures.

Oliko kaikki selvää?

Kiitos palautteestasi!

Osio 4. Luku 3

Kysy tekoälyä

Kysy mitä tahansa tai kokeile jotakin ehdotetuista kysymyksistä aloittaaksesi keskustelumme

Pyyhkäise näyttääksesi valikon