quote: Original post by NotAnAnonymousPoster
So to make the object immutable I could just define the constructors but make all the properties read only?

quote:
In the case of a point class, wouldn''t I want to be able to still allow the x,y properties to be altered. That way if I changed a point from (0,0) to (3,5) it would change from "a corner shop" to "a house" when I looked it up in the hash table.

quote:
In what way does an immutable object have value semantics? i.e: What *are* value semantics? I know that value types exist on the stack and get passed by value but that''s about it.

quote:
One other thing about value types. It says in my book that if a struct inherits an interface and its methods are accessed through an interface reference, it is the boxed type that gets altered and not the original struct. It says as a design guideline that you shouldn''t access structs from an interface reference, but wouldn''t it be a better design guideline to never inherit an interface in a struct in the first place?

quote: Original post by Arild Fines
If you change an object you have used as a hashtable key, that won''t change it''s location internally in the hashtable. Basically, you won''t be able to find the object ever again since the hashcode will now be different.

  class Point{	public Point(int x, int y)	{		this.x = x;		this.y = y;	}	public int X { get {return x;} set {x = value;} }	public int Y { get {return y;} set {y = value;} }		public override string ToString()	{		return "(" + x + "," + y + ")";	}	public override bool Equals(object rhs)	{		Point p = rhs as Point;		if (p != null)		{			return (p.x == x && p.y == y);		}		return false;	}	public override int GetHashCode()	{		return x^y;	}		private int x,y;}namespace Hashtables{	using System;	using System.Collections;	/// <summary>	/// Summary description for Class1.	/// </summary>	class Hashtables	{		/// <summary>		/// The main entry point for the application.		/// </summary>		[STAThread]		static void Main(string[] args)		{			Hashtable myHT = new Hashtable();			myHT.Add(new Point(3,5), "a house");			myHT.Add(new Point(1,2), "a church");			myHT.Add(new Point(0,0), "a corner shop");			Point point = new Point(0,0);			Console.WriteLine(point + "=" + myHT[point]);			point.X = 3;			point.Y = 5;			Console.WriteLine(point + "=" + myHT[point]);			point.X = 1;			point.Y = 2;						Console.WriteLine(point + "=" + myHT[point]);		}	}}  

quote:
I was referring mainly to the fact that you can pass a reference to an immutable object to another method without worrying that the method might change the state of the object. This works the same as if you had passed a primitive to the method.

quote:
Hard to avoid - think of things like IComparable, IConvertible etc... But most of the interfaces implemented by value types in the BCL don''t have methods that expect to modify the object.

quote: Original post by NotAnAnonymousPoster
That works fine. Are you talking about something different?

      Point key = new Point( 4, 2);hashTable[ key ] = "forty two";key.x = 6;key.y = 9;object obj = hashTable[ new Point( 4,2 ) ]; //will return null since key no longer is at (4,2)object obj2 = hashTable[ new Point( 6,9) ]; //will _probably_ return null                                             //since key will be in wrong bucket  

quote:
Guess you have to be careful about how you write interfaces and use structs then.

quote:
Scott Meyer's needs to write Effective C#.