Hi,

Sorry for letting you wait.

After performing some modification to the MSDN article project I can
reproduce the behavior: the OptionalFieldAttribute is not needed for
version tolerance.

Actually, this is caused by BinaryFormatter.AssemblyFormat property as you
suspected.

In .Net 1.1, we can set the "BinaryFormatter.AssemblyFormat" to
"FormatterAssemblyStyle.Simple" to allow more version tolerance. In this
way, no exception will be thrown if a particular field is not found from
the stored stream.
In .Net 2.0, the property is by default "Simple", not "Full"(You can
verify this by watching BinaryFormatter.AssemblyFormat in debugger), so
even we do not specify "OptionalFieldAttribute", no exception is thrown.
"OptionalFieldAttribute" is needed only when "FormatterAssemblyStyle.Full"
needs to work with missing fields.

Hope this helps.

Best regards,
Jeffrey Tan
Microsoft Online Community Support
==================================================
When responding to posts, please "Reply to Group" via your newsreader so
that others may learn and benefit from your issue.
==================================================
This posting is provided "AS IS" with no warranties, and confers no rights.

Hi Andy,

Thanks for your feedback!

[quoted text, click to view]
Yes, I assume he is talking about .Net1.1. Also, since this article is
written in October 2004, which .Net2.0 is still in beta version, if the
author is talking about .Net2.0, I assume that this behavior has changed in
RTM.

[quoted text, click to view]
Sorry, I am not sure I understand you completely. Can you provided more
information regarding the "dictionary classes", which classes in FCL do you
refer to? Is it possible for you to provide a little sample project for us
to reproduce this problem? Thanks

[quoted text, click to view]
I have performed some research in this issue and found the key point lies
in the System.Runtime.Serialization.Formatters.Binary.ObjectReader.Bind
method and
System.Runtime.Serialization.Formatters.Binary.ObjectReader.FastBindToType
method.(From Reflector), below is the code snippet:

internal Type Bind(string assemblyString, string typeString)
{
Type type1 = null;
if ((this.m_binder != null) && !this.IsInternalType(assemblyString,
typeString))
{
type1 = this.m_binder.BindToType(assemblyString, typeString);
}
if (type1 == null)
{
type1 = this.FastBindToType(assemblyString, typeString);
}
return type1;
}

internal Type FastBindToType(string assemblyName, string typeName)
{
.....
if (this.bSimpleAssembly)
{
try
{
ObjectReader.sfileIOPermission.Assert();
try
{
StackCrawlMark mark1 =
StackCrawlMark.LookForMe;
assembly2 =
Assembly.LoadWithPartialNameInternal(assemblyName, null, ref mark1);
if ((assembly2 == null) && (assemblyName !=
null))
{
assembly2 =
Assembly.LoadWithPartialNameInternal(new AssemblyName(assemblyName).Name,
null, ref mark1);
}
}
finally
{
CodeAccessPermission.RevertAssert();
}
}
catch (Exception)
{
}
}
else
{
try
{
ObjectReader.sfileIOPermission.Assert();
try
{
assembly2 = Assembly.Load(assemblyName);
}
finally
{
CodeAccessPermission.RevertAssert();
}
}
catch (Exception)
{
}
}
.....
}

As we can see, FastBindToType checks bSimpleAssembly field(which maps to
FormatterAssemblyStyle.Full/Simple) to use Assembly.Load or
Assembly.LoadWithPartialNameInternal. From Applied .net Framwork written by
"Jeffrey Richter", we know that Assembly.Load will check the version
explicitly, while Assembly.LoadWithPartialNameInternal will ignore the
assembly version.

Also, in Bind method, we can see that Binder.BindToType method gives us a
hook over the FastBindToType method, which may help us to jmp over
FastBindToType method.

OptionalFieldAttribute is used in
System.Runtime.Serialization.Formatters.Binary.ReadObjectInfo.GetMemberTypes
method:

internal Type[] GetMemberTypes(string[] inMemberNames, Type objectType)
{
......
if (!flag2)
{
object[] objArray1 =
this.cache.memberInfos[num2].GetCustomAttributes(typeof(OptionalFieldAttribu
te), false);
if (((objArray1 == null) || (objArray1.Length ==
0)) && !this.bSimpleAssembly)
{
throw new
SerializationException(string.Format(CultureInfo.CurrentCulture,
Environment.GetResourceString("Serialization_MissingMember"), new object[]
{ this.cache.memberNames[num2], objectType,
typeof(OptionalFieldAttribute).FullName }));
}
}
}
}
return typeArray1;
}

So FCL uses System.Reflection.MemberInfo.GetCustomAttributes method to
access the OptionalFieldAttribute. If you want to determine if there is any
additionally attribute can meet your need without changing the formatter
itself, you may set a breakpoint in
System.Reflection.MemberInfo.GetCustomAttributes method in debugger and
monitor if Deserialize method will trigger other breakpoint that is not
looking for OptionalFieldAttribute. Based on my research, I can not find a
such attribute. So you may still have to touch the formatter itself to hook
the process.

Hope this helps. If you have any further concern or need any other help,
please feel free to tell me, thanks!

Best regards,
Jeffrey Tan
Microsoft Online Community Support
==================================================
When responding to posts, please "Reply to Group" via your newsreader so
that others may learn and benefit from your issue.
==================================================
This posting is provided "AS IS" with no warranties, and confers no rights.

Hi Andy,

Have you managed to create a sample project for demonstration? Does my
reply make sense to you? If you have anything unclear or any concern,
please feel free to let me known, thanks!

Best regards,
Jeffrey Tan
Microsoft Online Community Support
==================================================
When responding to posts, please "Reply to Group" via your newsreader so
that others may learn and benefit from your issue.
==================================================
This posting is provided "AS IS" with no warranties, and confers no rights.

Hi, Jeffrey,

1) I've pasted the partial class code for a form class that, if you put into
a windows forms project and build, should demo problem (1). I've also sent
you the full project as an email attachment.

2) I haven't seen any attribute for the serializee to control versioning
serialization; like I said, it seems you have to change properties on the
formatter itself. This is a problem for me because I'm trying to use the
caching application block. Can you ask that team how they recommend to
versioning of objects cached with that block? I'd rather not change that
block, but if I do, perhaps I'll change it to use XmlSerializer (not
SoapFormatter), which seems cleaner.

Thanks for your help!



--------------------------------------------------------------
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;

using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;


namespace DemoDictionarySerializeIssue
{
/*
This program demonstrates the following problem:

* ---------------------------------------------------------
If you serialize non-Dictionary classes, then setting AssemblyFormat to
simple seems to cause the OptionalFieldAttribute to not be needed, AND seems
to make the deserializer not care if the assembly version changes. However,
if I serialize dictionary classes, then the deserializer requires the
assembly version to match, even if I set AssemblyFormat to simple. Is there
a way to get the rules to apply consistently?
* ---------------------------------------------------------

If we serialize dictionaries that have items as entries,
then we have a dependency on the assembly version;
If we serialize itemholder that has an item member, we don't seem to have a
dependency
on the assembly version:


1) Run the program, click on serialize, then click on deserialize. See
that it works properly

2) close the program, change the AssemblyVersion from 1 to 2 in
AssemblyInfo.cs, and rebuild

3) Run the program, click on deserialize - see the File Load exception - it
appears
that the correct assembly version couldn't be found

4) uncheck "use dictionary", click on serialize, then click on deserialize.
See that it
works properly.

5) close the program, change the AssemblyVersion from 2 to 3 in
AssemblyInfo.cs, and rebuild

6) Run the program, uncheck "use dictionary", then click on deserialize -
note that it now
works fine

*/

/// </summary>
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}

private void m_btnSerialize_Click(object sender, EventArgs e)
{
MyDictionary dictionary = new MyDictionary();
Item item1 = new Item("entry1","one");
dictionary[item1.m_sName] = item1;

Item item2 = new Item("entry2", "two");
dictionary[item2.m_sName] = item2;

try
{
BinaryFormatter bf = new BinaryFormatter();
bf.AssemblyFormat =
System.Runtime.Serialization.Formatters.FormatterAssemblyStyle.Simple;
using (FileStream bfStream = new FileStream(m_sFileName, FileMode.Create))
{
if (m_cbUseDictionary.Checked)
{
bf.Serialize(bfStream, dictionary);
}
else
{
MyItemHolder ih1 = new MyItemHolder();
ih1.m_item = item1;
bf.Serialize(bfStream, ih1);
}

}
}
catch (Exception except)
{
MessageBox.Show(except.ToString());
}
}

private void m_btnDeserialize_Click(object sender, EventArgs e)
{
try
{
BinaryFormatter bf = new BinaryFormatter();
bf.AssemblyFormat =
System.Runtime.Serialization.Formatters.FormatterAssemblyStyle.Simple;
using (FileStream bfStream = new FileStream(m_sFileName, FileMode.Open))
{
if (m_cbUseDictionary.Checked)
{
MyDictionary dictionary = (MyDictionary)bf.Deserialize(bfStream);
Item item1 = dictionary["entry1"];
Item item2 = dictionary["entry2"];
}
else
{
MyItemHolder ih1 = (MyItemHolder)bf.Deserialize(bfStream);
Item item1 = ih1.m_item;
}
}
}
catch (Exception except)
{
MessageBox.Show(except.ToString());
}
}

private const string m_sFileName = "serialized.dat";
}


[Serializable]
public class Item
{
public Item(string sName, string sValue)
{
m_sName = sName;
m_sValue = sValue;
}

public Item()
{
}

public string m_sName;
public string m_sValue;
}

[Serializable]
public class MyDictionary : Dictionary<string, Item>
{
protected MyDictionary(SerializationInfo info, StreamingContext context)
: base(info, context)
{
}

public MyDictionary()
{
}
}

[Serializable]
public class MyItemHolder
{
public Item m_item;
}

}

[quoted text, click to view]