Aprenda Static vs Instance Members | Static Classes and Members

Understanding the distinction between static and instance members is essential for designing effective C# classes. Static members belong to the class itself, while instance members belong to individual objects created from the class. This difference affects how you access these members and how they store and share data. Static members are shared across all instances of a class, meaning there is only one copy in memory. In contrast, each object has its own set of instance members, allowing for unique values in each object. Choosing between static and instance members depends on whether the data or behavior should be shared or unique to each object.

Definition

An instance member is a field, property, or method that belongs to an individual object created from a class. Each object has its own copy of instance members, allowing for unique values or behavior per object.

Program.cs


              1234567891011121314151617181920212223242526272829303132333435363738394041424344
            
using System;

namespace ConsoleApp
{
    public class Counter
    {
        // Static field shared by all Counter objects
        public static int TotalCount = 0;

        // Instance field unique to each Counter object
        public int InstanceCount = 0;

        // Static method to increment and display the static count
        public static void IncrementTotal()
        {
            TotalCount++;
            Console.WriteLine("TotalCount (static): " + TotalCount);
        }

        // Instance method to increment and display the instance count
        public void IncrementInstance()
        {
            InstanceCount++;
            Console.WriteLine("InstanceCount (instance): " + InstanceCount);
        }
    }

    public class Program
    {
        public static void Main(string[] args)
        {
            Counter c1 = new Counter();
            Counter c2 = new Counter();

            c1.IncrementInstance(); // InstanceCount for c1: 1
            c2.IncrementInstance(); // InstanceCount for c2: 1
            c1.IncrementInstance(); // InstanceCount for c1: 2

            Counter.IncrementTotal(); // TotalCount: 1
            Counter.IncrementTotal(); // TotalCount: 2
            Counter.IncrementTotal(); // TotalCount: 3
        }
    }
}

In the Counter example, the difference between static and instance members is clear. The static field TotalCount keeps track of a value shared by all Counter objects, so every time any code calls IncrementTotal, the same TotalCount is updated. In contrast, each Counter object has its own InstanceCount, so calling IncrementInstance on one object does not affect the InstanceCount of another. Notice also that static methods can be called using the class name, while instance methods require an object. Although it is technically possible to call a static method through an object reference, it is clearer and more conventional to use the class name for static members.

ConfusingCounter.cs


              1234567891011121314151617181920212223242526272829
            
namespace ConsoleApp
{
    public class ConfusingCounter
    {
        // Static field
        public static int SharedCount = 0;

        // Instance field
        public int MyCount = 0;

        // Static method modifies static field
        public static void AddToShared()
        {
            SharedCount++;
        }

        // Instance method modifies instance field
        public void AddToMyCount()
        {
            MyCount++;
        }

        // Poor practice: instance method modifies static field
        public void AddToSharedFromInstance()
        {
            SharedCount++;
        }
    }
}

When deciding between static and instance members, follow these guidelines:

Use static members when the data or behavior should be shared by all instances or when the functionality does not depend on object state;
Use instance members when each object should maintain its own state or behavior;
Avoid accessing or modifying static members from instance methods unless absolutely necessary;
Access static members using the class name for clarity;
Reserve static methods for operations that do not require access to instance data.

Tudo estava claro?

Obrigado pelo seu feedback!

Seção 3. Capítulo 5

Pergunte à IA

Pergunte o que quiser ou experimente uma das perguntas sugeridas para iniciar nosso bate-papo

Suggested prompts:

Can you give an example of when to use a static member versus an instance member?

What are some common mistakes when using static and instance members in C#?

Can you explain why it's better to access static members using the class name?

Deslize para mostrar o menu