OOPS Concepts And .NET - Part One - Classes, Objects, And Structures


The following article kicks off a three-part article series that will present definitions and samples for different Object-Oriented Programming concepts and its implementation in .NET. The first part will examine the concepts of classes,objects, and structures.The second part will examine the concepts of inheritance, abstraction, and polymorphism. The third and last part will examine the concepts of interface, multiple interface inheritance, collections, and overloading.


Object-Oriented Programming (OOP) is a software development paradigm that suggests developers split a program in building blocks known as objects. The OOP paradigm allows developers to define the object's data, functions, and its relationship with other objects.

Microsoft created the .NET Framework using OOP, and knowing this concepts has helped me to understand the .NET Framework and to design and develop better software components. The purpose of this article is to describe the basic OOP concepts using real world scenarios and to provide some code samples that demonstrate how to work with OOP and .NET.


The most common definition states that a class is a template for an object. Suppose that someone builds a paper pattern for a shirt. All the shirts done with the same paper pattern will be identical (same design, size, etc.). In this sample, the paper pattern is the class and the shirt is the object. To build the same exact shirt over and over, you need the paper pattern as a template. Another great example are house plans and blueprints. The plans and blueprints define the number of rooms, the size of the kitchen, the number of floors, and more. In this real world sample, the house plans and blueprints are the class and the house is the object. In OOP you program a class as a template for a specific object or groups ob objects that will always have the same features.

Class members

A class has different members, and developers in Microsoft suggest to program them in the following order:

  • Namespace
    The namespace is a keyword that defines a distinctive name or last name for the class. A namespace categorizes and organizes the library (assembly) where the class belongs and avoids collisions with classes that share the same name.

  • Class declaration
    Line of code where the class name and type are defined.

  • Fields
    Set of variables declared in a class block.

  • Constants
    Set of constants declared in a class block.

  • Constructors
    A method or group of methods that contains code to initialize the class.

  • Properties
    The set of descriptive data of an object.

  • Events
    Program responses that get fired after a user or application action.

  • Methods
    Set of functions of the class.

  • Destructor
    A method that is called when the class is destroyed. In managed code, the Garbage Collector is in charge of destroying objects; however, in some cases developers need to take extra actions when objects are being released, such as freeing handles or deallocating unmanaged objects. In .NET, there is no concept of deterministic destructors. The Garbage Collector will call the Finalize() method at a non-deterministic time while reclaiming memory for the application.

Access keywords

Access keywords define the access to class members from the same class and from other classes. The most common access keywords are:

  • Public
    Allows access to the class member from any other class.

  • Private
    Allows access to the class member only in the same class.

  • Protected
    Allows access to the class member only within the same class and from inherited classes.

  • Internal
    Allows access to the class member only in the same assembly.

  • Protected internal
    Allows access to the class member only within the same class, from inherited classes, and other classes in the same assembly.

  • Static
    Indicates that the member can be called without first instantiating the class.

The following sample code illustrates a sample class in C#,

  1. /// C#   
  2. ///Imported namespaces  
  3. using System;  
  4. /// Namespace: Consider using CompanyName.Product.ComponentType  
  5. namespace DotNetTreats.OOSE.OOP_CSharp {  
  6.     ///Class declaration  
  7.     public class employee {  
  8.         ///Fields  
  9.         private string _name;  
  10.         private int _salary;  
  11.         ///Constants  
  12.         private  
  13.         const int anualBonus = 1000;  
  14.         ///Constructor  
  15.         public employee() {}  
  16.         ///Properties  
  17.         public string Name {  
  18.             get {  
  19.                 return _name;  
  20.             }  
  21.             set {  
  22.                 _name = value;  
  23.             }  
  24.         }  
  25.         public int Salary {  
  26.             get {  
  27.                 return _salary;  
  28.             }  
  29.             set {  
  30.                 _salary = value;  
  31.             }  
  32.         }  
  33.         /// Event handlers  
  34.         public event EventHandler OnPromotion {  
  35.             add {}  
  36.             remove {}  
  37.         }  
  38.         /// Methods  
  39.         public void DuplicateSalary() {  
  40.             _salary = _salary * 2;  
  41.         }  
  42.     }  
  43. }  

Listing 1. Sample class implementation in C#

The following sample code illustrates a sample class in VB.NET,

  1. ' VB.NET   
  2. 'Imported namespaces  
  3. Imports System  
  4. ' Namespace: Consider using CompanyName.Product.ComponentType  
  5. Namespace DotNetTreats.OOSE.OOP_VBNET  
  6. 'Class declaration  
  7. Public Class employee  
  8. 'Fields  
  9. Private _name As String  
  10. Private _salary As Integer  
  11. 'Constants  
  12. Private Const anualBonus As Integer = 1000  
  13. 'Constructors   
  14. Public Sub New()  
  15. MyBase.New()  
  16. End Sub  
  17. 'Properties  
  18. Public Property Name() As String  
  19. Get  
  20. Return _name  
  21. End Get  
  22. Set(ByVal Value As String)  
  23. _name = value  
  24. End Set  
  25. End Property  
  26. Public Property Salary() As Integer  
  27. Get  
  28. Return _salary  
  29. End Get  
  30. Set(ByVal Value As Integer)  
  31. _salary = value  
  32. End Set  
  33. End Property  
  34. ' Event handlers  
  35. Public Event OnPromotion As EventHandler  
  36. 'Methods  
  37. Public Sub DuplicateSalary()  
  38. _salary = (_salary * 2)  
  39. End Sub  
  40. End Class  
  41. End Namespace  

Listing 2. Sample class implementation in VB.NET


Objects are the building blocks of OOP and are commonly defined as variables or data structures that encapsulate behavior and data in a programmed unit. Objects are items that can be individually created, manipulated, and represent real world things in an abstract way.

Object composition

Every object is composed by:

  • Object identity
    Means that every object is unique and can be differentiated from other objects. Each time and object is created (instantiated) the object identity is defined.

  • Object behavior
    What the object can do. In OOP, methods work as functions that define the set of actions that the object can do.

  • Object state
    The data stored within the object at any given moment. In OOP, fields, constants, and properties define the state of an object.


Not everything in the real world should be represented as a class. Structures are suitable to represent lightweight objects. Structures can have methods and properties and are useful for defining types that act as user-defined primitives, but contain arbitrary composite fields. The .NET Framework defines some structures such as System.Drawing.Rectangle, System.Drawing.Point, and System.Drawing.Color.

The following code sample represents a structures in C#:

  1. /// C#  
  2. struct Point {  
  3.     private int _x;  
  4.     private int _y;  
  5.     Point(int x, int y) {  
  6.         this._x = x;  
  7.         this._y = y;  
  8.     }  
  9.     public int X {  
  10.         get {  
  11.             return _x;  
  12.         }  
  13.         set {  
  14.             _x = value;  
  15.         }  
  16.     }  
  17.     public int Y {  
  18.         get {  
  19.             return _y;  
  20.         }  
  21.         set {  
  22.             _y = value;  
  23.         }  
  24.     }  
  25. }  

Listing 3. Sample structure implementation in C#

The following code sample represents a structure in VB.NET,


  1. Structure Point  
  2. Private _x As Integer  
  3. Private _y As Integer  
  4. Sub New(ByVal x As IntegerByVal y As Integer)  
  5. MyBase.New()  
  6. Me._x = x  
  7. Me._y = y  
  8. End Sub  
  9. Public Property X() As Integer  
  10. Get  
  11. Return _x  
  12. End Get  
  13. Set(ByVal Value As Integer)  
  14. _x = value  
  15. End Set  
  16. End Property  
  17. Public Property Y() As Integer  
  18. Get  
  19. Return _y  
  20. End Get  
  21. Set(ByVal Value As Integer)  
  22. _y = value  
  23. End Set  
  24. End Property  
  25. End Structure  

Listing 4. Sample structure implementation in VB.NET


OOP is full of abstract concepts, and the best approach to understand them is practical and not only theoretical. I learned more OOP after making some designs and after implementing some components. The concepts presented in this article might clarify the meaning, but I strongly recommend to go and have fun playing around with OOP. In this article, I examined the concept of classes, objects, and structs. The second part will examine the concepts of inheritance, abstraction, and polymorphism.


  • Matt Weisfeld, The Object-Oriented Thought Process, SAMS, 2000.
  • Don Box, Chris Sells, Essential .NET, Addison-Wesley, 2002.

Recommended Ebook

The SOLID Principles

Download Now!
Similar Articles