> I'm trying to build a class that can track changes to itself.
Class MyClass
{
public int value1=0;
public int value2=0;
private int oldvalue1=0;
private int oldvalue2=0;
public void WhatIsChanged()
{
if(oldvalue1!=value1) Console.WriteLine("value1 is changed");
if(oldvalue2!=value2) Console.WriteLine("value2 is changed");
oldvalue1=value1;
oldvalue2=value2;
}
}
class myprogram
{
MyClass nn = new MyClass()
nn.value1=2;
nn.WhatIsChanged();
}
But there MUST be a simpler way of doing this?
So if I use MemberwiseClone(); will it be like?
Class MyClass
{
public int value1=0;
public int value2=0;
private oldvalues=null;
MyClass()
{
oldvalues=(MyClass)this.MemberwiseClone();
}
public void WhatIsChanged()
{
if(oldvalues.value1!=this.value1) Console.WriteLine("value1 is
changed");
if(oldvalues.value2!=this.value2) Console.WriteLine("value2 is
changed");
oldvalues=(MyClass)this.MemberwiseClone();
}
}
class myprogram
{
MyClass nn = new MyClass()
nn.value1=2;
nn.WhatIsChanged();
}
But this don't work!
I would opt for more of a observer (.NET style) type of pattern. And let
another object be responsible for tracking changes.
public class Class1
{
/// <summary>
/// The main entry point for the application.
/// </summary>
[STAThread]
private static void Main()
{
new Class1();
}
public Class1()
{
MyClass original = new MyClass(5, 2);
original.Value1Changed += new MyClass.IntegerChangedHandler(original_Value1Chang ed);
original.Value2Changed += new MyClass.IntegerChangedHandler(original_Value2Chang ed);
original.Value1 = 32;
original.Value2 = 1024;
original.Value1 = 5;
original.Value2 = 2;
Console.ReadLine();
}
private void original_Value1Changed(int oldValue, int newValue)
{
Console.WriteLine("Value1 has changed from {0} to {1}.", oldValue, newValue);
}
private void original_Value2Changed(int oldValue, int newValue)
{
Console.WriteLine("Value2 has changed from {0} to {1}.", oldValue, newValue);
}
}
public class MyClass
{
public delegate void IntegerChangedHandler(int oldValue, int newValue);
public event IntegerChangedHandler Value1Changed;
public event IntegerChangedHandler Value2Changed;
private int value1;
private int value2;
public MyClass()
{}
public MyClass(int value1, int value2)
{
this.value1 = value1;
this.value2 = value2;
}
public int Value1
{
get { return value1; }
set
{
OnValue1Changed(value1, value);
value1 = value;
}
}
public int Value2
{
get { return value2; }
set
{
OnValue2Changed(value2, value);
value2 = value;
}
}
protected virtual void OnValue1Changed(int oldValue, int newValue)
{
IntegerChangedHandler handler = Value1Changed;
if (handler != null)
{
handler(oldValue, newValue);
}
}
protected virtual void OnValue2Changed(int oldValue, int newValue)
{
IntegerChangedHandler handler = Value2Changed;
if (handler != null)
{
handler(oldValue, newValue);
}
}
}
