EntityStateObjects, to me, are one of the most important little pieces of the EF puzzle. IT is the EntityStateObject that maintains all of the critical info for change tracking. But it's hard to get the big picture of what's going on in there when debugging because all of the important stuff is delivered through methods, not properties.
I wanted so badly to write a debugger visualizer for them but they are not serializable (big pout) so instead, I wrote an extension method that uses a ConditionalAttribute to ensure it doesn't pop up during run time. It's for my book but I didn't want to hold onto it until October when the book should be published.
Since it's not a Debugger Visualiser, I refer to it as a DebugTime visualizer. 
Here's what my ObjectStateEntry Visualizer looks like in action:
All of the info is pulled from the ObjectStateEntry. At the top it tells the fully qualified name of the type of the object being inspected as well as the object's EntityState.
Then I use the various methods of the ObjectStateENtry to get the Original Values, the Current Values, the names of the fields and a list of the names of the modified fields.
All of this data I feed into the grid.
If the object is detached, then there is no ObjectStateEntry and the visualizer shows this message when you try to run it:
So enough with the screenshots. Here's the code. And here's a collection of important punctuations for you C# programmers who feel a need to translate
[ ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ; ;]
Imports System.Runtime.CompilerServices
Imports System.Data.Objects
'NOTE: The objects in use here are not serializable so they can't be used
'in debugger visualizers. Instead, you'll need to use them directly, but you can
'give them a debug attribute so they are only available during debug mode.
<Extension()> _
Public Module Visualizers
<ConditionalAttribute("DEBUG")> _
<Extension()> _
Public Sub VisualizeObjectStateEntry(ByVal eKey As EntityKey, ByVal context As ObjectContext)
Dim ose As ObjectStateEntry = Nothing
If Not context.ObjectStateManager.TryGetObjectStateEntry(eKey, ose) Then
Windows.Forms.MessageBox.Show("Object is not currently being change tracked and no ObjectStateEntry exists.", _
"ObjectStateEntry Visualizer", Windows.Forms.MessageBoxButtons.OK, Windows.Forms.MessageBoxIcon.Warning)
Else
Dim currentValues = ose.CurrentValues
Dim originalValues = ose.OriginalValues
Dim valueArray As New ArrayList
For i = 0 To currentValues.FieldCount - 1
'you can get from the ObjectStateEntry into the MetaData which actually comes from the EDM
Dim sName = currentValues.DataRecordInfo.FieldMetadata.Item(i).FieldType.Name
Dim sCurrVal = currentValues.Item(i)
Dim sOrigVal = originalValues.Item(i)
'nothing like a little LINQ query to find some info
Dim changedProp = (From prop In ose.GetModifiedProperties Where prop = sName).FirstOrDefault
Dim propModified As String
propModified = If(changedProp = Nothing, "", "X")
'the funky property naming in this anonymous type is to get around a wierdness with
'LINQ databinding that only occurs in VB - it alphabetizes the fields
valueArray.Add(New With _
{._Index = i.ToString, ._Property = sName, .Current = sCurrVal, _
.Original = sOrigVal, .ValueModified = propModified})
Next
Dim frm As New debuggerForm
With frm.DataGridView1
.DataSource = valueArray
End With
frm.lblState.Text = ose.State.ToString
frm.lblType.Text = ose.Entity.ToString
frm.ShowDialog()
End If
End Sub
End Module
The form has no code, just a few controls:
I created an assembly for my Entity Framework extension methods and just reference the assembly anywhere I want to use it.
Then when I want to use it, I call it against the EntityKey of an Entity Object:
context = new AWModel.AWModel.AWEntities();
cust = context.Customers.Where(c => c.CustomerID == 223).First();
cust.CompanyName = "JULIE COMPANY";
cust.EntityKey.VisualizeObjectStateEntry(context);
This has been an enormously useful tool for when I have been presenting as well as just working.
Enjoy!