what is a member vs. a property

A friend who is new to OO programming asked me the difference between a Member and Property, and I was ashamed to admit that I couldn’t give him a good answer. Since properties can also be objects themselves, I was left with a general description and list of exceptions.

Can somebody please lay out a good definition of when to consider something a member vs. a property? Maybe I’m bastardizing the concept, or is it just that a member is just the internal name I use, and the property is what’s exposed to other objects?

I don’t think that not knowing the answer to this question has affected the quality of my programming, and it’s just a semantics point, but it still bothers me that I can’t explain it to him.

WCF: DataMember attribute on property vs. member

In wcf, what is the difference between applying the DataMember attribute on a property private int m_SomeValue; [DataMember] public int SomeValue { get {…} set {…} } instead of a member variable

What’s the difference between encapsulating a private member as a property and defining a property without a private member?

What’s the difference (Performance, memory…etc) between encapsulating a private member like this private int age; public int Age { get { return age; } set { age = value; } } and define a property l

Difference between member variable and member property?

There are situations where I declare member variables at the top of my class and then also declare a property to access or set that member variable, but I ask myself if the property is necessary if it

Member function vs. nonmember function?

What is your rule for which functions that operate on a class should be member functions vs. nonmember functions? For example, I have a class which represents a maze using a matrix of bools. I am maki

Member type in PowerShell (ScriptProperty,Property,NoteProperty)

What are the member types in PowerShell like ScriptProperty,Property,Method,NoteProperty,Alias and EventProperty.For example CPU is ScriptProperty, how can we classify it as ScriptProperty I want brie

Access array property member with variable property name

In the context of a class method, what syntax is used to get the value of a array member using a variable property name? class { private $aFruits=array(‘Apple’=>’Red’,’Banana’=>’Yellow’,’Orange’

Embed Interop Type” property in VS 2008

does “Embed Interop Type” property exist in VS 2008 , and if not What is the alternative ? Thanks,

using get vs property vs method [duplicate]

This question already has an answer here: Exposing Member Objects As Properties or Methods in .NET 6 answers if i have a private property in a class, i’m wondering what technically the differen

Accessing member by index via property

How can I access an element by index of a member List via a property? For example: public class foo{ private List<type> list = new List<type>; public List{ get{/*basically, what goes here?

Struct member [ array vs pointer ]

What is the benefit of declaring a C structure member as in array of size 1 instead of a pointer : struct { a_struct_t a_member[1]; … }b_struct; Thanks in advance

Answers

A property is one kind of member. Others might be constructors, methods, fields, nested types, conversions, indexers etc – depending on the language/platform, of course. A lot of the time the exact meaning of terminology depends on the context.

To give a C#-specific definition, from the C# 3.0 spec, section 1.6.1:

The following table provides an overview of the kinds of members a class can contain.
(Rows for…)

  • Constants
  • Fields
  • Methods
  • Properties
  • Indexers
  • Events
  • Operators
  • Constructors
  • Destructors
  • Types

Note that that’s members of a class. Different “things” have different kinds of members – in C#, an interface can’t have a field as a member, for example.

Members are just objects or primitive types belonging to a class.

Properties give you more power than members. It’s like a simplified way to create getters and setters letting you make, for instance, public getters and private setters; and put whatever logic you want in the way it will be read or written to. They can be used as a way to expose members, being possible to change the reading and writing policy later more easily.

This applies to C#. Not sure if this is true for the other languages though.

A member (variable) is just some part of the object. A property is (I’ll qualify this with “usually” – I’m not sure that it’s a technically clear word that has unambiguous meaning across multiple languages) is a publicly accessible aspect of the object, e.g. through getter and setter methods.

So while (almost always) a property is a reacheable member variable, you can have a property that’s not really part of the object state (not that this is good design):

public class Foo {
  public String getJunk()
  { return "Junk";}

  public void setJunk(String ignore){;}
  }
}

Properties are a way to expose members, where members are the actual variables. For example (C#):

class Foo {
  private int member;
  public int property {
    get { return member; }
    set { member = value; }
  }
}

Both properties and methods are members of an object. A property describes some aspect of the object while a method accesses or uses the owning object.
An example in pseudo-code:

Object Ball
Property color(some Value)
Method bounce(subroutine describing the movement of the Ball)

Where the ball is defined and given a color(property) while the method bounce is a subroutine that describes the how the ball will react on hitting another object.
Not all languages have properties, i.e. Java only has fields that must be accessed by getters and setters.

Properties is one kind of members.

In C#, for example, a class can have the following members:

  • Constructors
  • Destructors
  • Constants
  • Fields
  • Methods
  • Properties
  • Indexers
  • Operators
  • Events
  • Delegates
  • Classes
  • Interfaces
  • Structs

MSDN: C#: class

Neither of the two terms has any defined meaning whatsoever in Object-Oriented Programming or Object-Oriented Design. Nor do they have any defined meaning in the overwhelming majority of programming languages.

Only a very small number of programming languages have a concept called property or member, and even fewer have both.

Some examples of languages that have either one of the two are C++ (which has members), ECMAScript (which has properties) and C# (which has both). However, these terms don’t necessarily denote the same concepts in different programming languages. For example, the term “member” means roughly the same thing in C++ and C#, but the term “property” means completely different things in ECMAScript and C#. In fact, the term “property” in ECMAScript denotes roughly the same concept (ie. means roughly the same thing) as the term “member” in C++ and C#.

All this is just to say that those two terms mean exactly what the relevant specification for the programming language says they mean, no more and no less. (Insert gratuitous Lewis Carroll quote here.)

from PHP manual:

Class member variables are called “properties”. You may also see them referred to using other terms such as “attributes” or “fields”. They are defined by using one of the keywords public, protected, or private, followed by a normal variable declaration. This declaration may include an initialization.

Member is a generic term (likely originated in C++, but also defined in Java) used to denote a component of a class. Property is a broad concept used to denote a particular characteristic of a class which, once the class is instantiated, will help define the object’s state.

The following passages, extracted from “Object-Oriented Analysis and Design” by Grady Booch help clarify the subject. Firstly, it’s important to understand the concepts of state and behaviour:

The state of an object encompasses all of the (usually static) properties of the object plus the current (usually dynamic) values of each of these properties. By properties, we mean the totality of the object’s attributes and relationships with other objects.

Behaviour is how an object acts and reacts, in terms of its state changes and message passing (methods); the outwardly visible and testable activity of an object.

So, the behaviour of an object depends on the available operations and its state (properties and their current values). Note that OOP is quite generic regarding certain nomenclature, as it varies wildly from language to language:

The terms field (Object Pascal), instance variable (Smalltalk), member object (C++), and slot (CLOS) are interchangeable, meaning a repository for part of the state of an object. Collectively, they constitute the object’s structure.

An operation upon an object, defined as part of the declaration of a class. The terms message (Smalltalk), method (many OO languages), member function (C++), and operation are usually interchangeable.

But the notation introduced by the author is precise:

An attribute denotes a part of an aggregate object, and so is used during analysis as well as design to express a singular property of the class. Using the language-independent syntax, an attribute may have a name, a class, or both, and optionally a default expression: A:C=E.

An operation denotes some service provided by the class. Operations (…) are distinguished from attributes by appending parentheses or by providing the operation’s complete signature, composed of return class, name, and formal arguments (if any): R N(Arguments)

In summary, you can think of members as everything that composes the class, and properties as the members (attributes) that collectively define the structure of the class, plus its relationships to other classes. When the class is instantiated, values are assigned to its properties in order to define the object’s state.

Cheers