using System;
using System.Collections;
using System.Collections.Generic;
using System.Data.Linq;
using System.Linq;

namespace DataContextDiscardChanges
{
partial class NorthwindDataContext
{
#region Public Members

public void DiscardChanges()
{
this.DiscardUpdates();
this.DiscardInserts();
this.DiscardDeletes();
}

public void DiscardInserts(Func predicate = null)
{
if (predicate != null)
discardInserts(this.GetChangeSet().Inserts.OfType().Where(predicate));
else
discardInserts(this.GetChangeSet().Inserts.OfType());
}

public void DiscardInserts()
{
discardInserts(this.GetChangeSet().Inserts);
}

public void DiscardDeletes(Func predicate = null)
{
if (predicate != null)
discardDeletes(this.GetChangeSet().Deletes.OfType().Where(predicate));
else
discardDeletes(this.GetChangeSet().Deletes.OfType());
}

public void DiscardDeletes()
{
discardDeletes(this.GetChangeSet().Deletes);
}

public void DiscardUpdates(Func predicate = null)
{
if (predicate != null)
discardUpdates(this.GetChangeSet().Updates.OfType().Where(predicate));
else
discardUpdates(this.GetChangeSet().Updates.OfType());
}

public void DiscardUpdates()
{
discardUpdates(this.GetChangeSet().Updates);
}

#endregion Public Members

#region Private Memebers

private void discardInserts(IEnumerable insertedEntities)
{
foreach (var insertedItem in insertedEntities)
{
this.GetTable(insertedItem.GetType()).DeleteOnSubmit(insertedItem);
}
}

private void discardDeletes(IEnumerable deletedEntities)
{
foreach (var deletedItem in deletedEntities)
{
this.GetTable(deletedItem.GetType()).InsertOnSubmit(deletedItem);
}
}

private void discardUpdates(IEnumerable updatedEntities)
{
foreach (var updatedItem in updatedEntities)
{
ModifiedMemberInfo[] modifiedMembers = this.GetTable(updatedItem.GetType()).GetModifiedMembers(updatedItem);

foreach (var modifiedMember in modifiedMembers)
{
updatedItem.GetType().GetProperty(modifiedMember.Member.Name).SetValue(updatedItem, modifiedMember.OriginalValue, null);
}
}
}

#endregion Private Memebers
}
}

Discard Updated with Refresh method, reads orginal data from database and it’s not good way to Discard in-memory objects

i’m using reflection to solve this problem:

public void DiscardUpdates()
{
var changeSet = this.GetChangeSet();
foreach (var updatedItem in changeSet.Updates)
{
ModifiedMemberInfo[] modifiedMembers = this.GetTable(updatedItem.GetType()).GetModifiedMembers(updatedItem);

foreach (var modifiedMember in modifiedMembers)
{
updatedItem.GetType().GetProperty(modifiedMember.Member.Name).SetValue(updatedItem, modifiedMember.OriginalValue, null);
}
}
}

Thanks so much!

With a read-only subclass, it seems to me that all you’d have to do would be to upcast and then you could use all the base class’s functions including the ones that modify the object.

Anyway, it seems to require considerable gyrations to do this kind of thing, which in C++, as you say, can be done with the use of a single keyword.

I agree that the lack of const references and const pointers in Java and C# is a big drawback.