protobuf-net Specified method is not supported

Question

I have recently decided to use protobuf-net to serialize large plain text data files my application uses to see if there is any performance gain over parsing the plain text data.

Data Class:

[ProtoContract]
public class ClimateFile : BaseModel
{
    #region Properties
    [ProtoMember(1)]
    public double Latitude { get { return GetValue(() => Latitude); } private set { SetValue(() => Latitude, value); } }

    [ProtoMember(2)]
    public double Longitude { get { return GetValue(() => Longitude); } private set { SetValue(() => Longitude, value); } }

    [ProtoMember(3)]
    public string Notes { get { return GetValue(() => Notes); } set { SetValue(() => Notes, value); } }

    [ProtoMember(4)]
    public DateTime MinDate { get { return GetValue(() => MinDate); } private set { SetValue(() => MinDate, value); } }

    [ProtoMember(5)]
    public DateTime MaxDate { get { return GetValue(() => MaxDate); } private set { SetValue(() => MaxDate, value); } }

    [ProtoMember(6)]
    public List<ClimateDailyData> DailyData { get { return GetValue(() => DailyData); } private set { SetValue(() => DailyData, value); } }
    #endregion

    #region Method
    public static ClimateFile Load(string filePath)
    {
        try
        {
            var ext = Path.GetExtension(filePath).ToUpper();
            if (ext == ".P51")
                return new ClimateFile(filePath);
            else if (ext == ".P51X")
            {
                ClimateFile climateFile;
                using (var file = File.OpenRead(filePath))
                {
                    climateFile = Serializer.Deserialize<ClimateFile>(file);
                }
                return climateFile;
            }
        }
        catch (Exception e)
        {
            throw new InvalidDataException(String.Format("The file \"{0}\" could not be opened, {1}", filePath, ExceptionUtilities.JoinExceptionMessages(e)));
        }

        throw new ArgumentException("filePath was not a .P51 or .P51X file.");
    }

    public void LoadP51File(string filePath)
    {
        List<string[]> lines = GetFileLines(filePath);
        Latitude = double.Parse(lines[0][0]);
        Longitude = double.Parse(lines[0][1]);
        for (int i = 2; i < lines[0].Length; ++i)
            Notes += String.Format("{0} ", lines[0][i]);
        MinDate = GetDate(lines[2][0]);
        MaxDate = GetDate(lines[lines.Count - 1][0]);

        // Parse daily data
        lines.RemoveRange(0, 2);
        var dailyData = lines.Select(row => new ClimateDailyData()
            {
                DataDate = GetDate(row[0]),
                MaxTemperature = double.Parse(row[2]),
                MinTemperature = double.Parse(row[3]),
                Rainfall = double.Parse(row[4]),
                Evaporation = double.Parse(row[5]),
                SolarRadiation = double.Parse(row[6])
            }).ToList();
        DailyData = dailyData;
    }

    public void SaveP51XFile(string filePath)
    {
        using (var file = File.Create(filePath))
        {
            Serializer.Serialize<ClimateFile>(file, this);
        }
    }

    public List<string[]> GetFileLines(string filePath)
    {
        var rows = new List<string[]>();
        var cells = new List<string>();
        var cell = new StringBuilder();
        using (var fs = new BufferedStream(File.OpenRead(filePath)))
        {
            int buffer;
            while ((buffer = fs.ReadByte()) != -1)
            {
                char nextChar = (char)buffer;

                if (nextChar >= '!') // If the character is a non-whitespace printable character
                {
                    cell.Append(nextChar);
                    continue;
                }

                if (nextChar == ' ' || nextChar == '\t')
                {
                    if (cell.Length > 0)
                    {
                        cells.Add(cell.ToString());
                        cell.Clear();
                    }
                    continue;
                }

                if (nextChar == '\r' || nextChar == '\n')
                {
                    if (cell.Length > 0)
                    {
                        cells.Add(cell.ToString());
                        cell.Clear();
                    }
                    if (cells.Count > 0)
                    {
                        rows.Add(cells.ToArray());
                        cells.Clear();
                    }
                    continue;
                }
                throw new InvalidDataException("The climate file contains unknown characters.");
            }

            if (cell.Length > 0)
                cells.Add(cell.ToString());
            if (cells.Count > 0)
                rows.Add(cells.ToArray());
        }
        return rows;
    }

    public DateTime GetDate(string date)
    {
        return DateTime.ParseExact(date, "yyyyMMdd", CultureInfo.InvariantCulture, DateTimeStyles.None);
    }

    public override void Dispose()
    {
        if (Disposed)
            return;
        if (DailyData != null)
            foreach (ClimateDailyData dailyData in DailyData)
                dailyData.Dispose();
        base.Dispose();
    }
    #endregion

    #region Initialization
    public ClimateFile()
    {
    }

    public ClimateFile(string filePath)
    {
        LoadP51File(filePath);
    }
    #endregion
}

Collection Data Class:

    [ProtoContract]
public class ClimateDailyData : BaseModel
{
    [ProtoMember(1)]
    public DateTime DataDate { get { return GetValue(() => DataDate); } set { SetValue(() => DataDate, value); } }

    [ProtoMember(2)]
    public int JulianDay { get { return DataDate.DayOfYear; } }

    [ProtoMember(3)]
    public double MaxTemperature { get { return GetValue(() => MaxTemperature); } set { SetValue(() => MaxTemperature, value); } }

    [ProtoMember(4)]
    public double MinTemperature { get { return GetValue(() => MinTemperature); } set { SetValue(() => MinTemperature, value); } }

    [ProtoMember(5)]
    public double Rainfall { get { return GetValue(() => Rainfall); } set { SetValue(() => Rainfall, value); } }

    [ProtoMember(6)]
    public double Evaporation { get { return GetValue(() => Evaporation); } set { SetValue(() => Evaporation, value); } }

    [ProtoMember(7)]
    public double SolarRadiation { get { return GetValue(() => SolarRadiation); } set { SetValue(() => SolarRadiation, value); } }
}

Serialization Command:

public ICommand ImportP51
    {
        get
        {
            return new RelayCommand(delegate
                {
                    OpenFileDialog openDialogue = new OpenFileDialog()
                    {
                        AddExtension = true,
                        CheckPathExists = true,
                        CheckFileExists = true,
                        DefaultExt = ".p51",
                        Filter = "Climate Files|*.p51",
                        InitialDirectory = DataPath,
                        Multiselect = false,
                        Title = "Select a File to Open"
                    };

                    if ((bool)openDialogue.ShowDialog())
                    {
                        string filePath = String.Empty;
                        try
                        {
                            filePath = openDialogue.FileName;
                            var climate = new Climate();
                            climate.FilePath = filePath;
                            var savePath = String.Format("{0}\\{1}.p51x", ClimateDataPath, Path.GetFileNameWithoutExtension(filePath));
                            climate.FileData.SaveP51XFile(savePath);
                        }
                        catch (Exception e)
                        {
                            MessageBox.Show(String.Format("The file \"{0}\" could not be opened, {1}", filePath, ExceptionUtilities.JoinExceptionMessages(e)), "Invalid File");
                        }
                    }
                });
        }
    }

When executing ImportP51, I get the exception "Specified method is not supported", I am using protobuf-net V2 r594 which was released on the 12/10/2012 and am thinking of trying to use one of the previous versions if I cannot get it to work with this version. Can someone please tell me what I am doing wrong?

Answer 1

I've tried to reconstruct a working version of the code (since I don't have your BaseModel) which I've done by using automatically implemented properties and adding an initializer for the list (DailyData), and explicitly referencing r594 from google-code. The only error I get is:

Cannot apply changes to property ClimateDailyData.JulianDay

which makes sense, because it can't rightly deserialize data into a read-only property, so I removed the serialization marker from that one:

// [ProtoMember(2)] removed - serialized implicitly via DataData
public int JulianDay { get { return DataDate.DayOfYear; } }

After that it worked fine. Since I don't have your command framework, I have:

static class Program
{
    static void Main()
    {
        var climateFile = new ClimateFile();
        climateFile.InitSomeDataForSerialization();

        climateFile.SaveP51XFile("foo.P51X");
        var clone = ClimateFile.Load("foo.P51X");
    }
}

where InitSomeDataForSerialization just sets some of the values (since they have private setters, I can't do that in Main):

public void InitSomeDataForSerialization()
{
    Longitude = 10; Latitude = 4; Notes = "Test";

    DailyData.Add(
        new ClimateDailyData { DataDate = DateTime.Today, MinTemperature = 12, MaxTemperature = 35}
    );
}

And... it works.

On a hunch, I checked what happens if you reference "CoreOnly" instead of "Full", but that then refuses to compile because Serializer.Serialize<T> and Serializer.Deserialize<T> don't exist.

I'm happy to help, but as far as I can tell, nothing is wrong.

Things I would suggest next:

• show the full stack-trace of what happens in this exception, including any inner-exceptions (see the fix below)
• please check exactly which file you referenced in the 594 zip (look at "What Files Do I Need.txt", but I'd guess the correct one for you is "Full/net30/..."; the nuget package configures the most appropriate files automatically)
• please show a fully reproducible example, i.e. where I can press F5 and see the exact exception (I had to change the code in the example for it to compile, which means I am no longer testing the same thing)

Fix for correct exception wrapping:

catch (Exception e)
{
    throw new InvalidDataException(String.Format("The file \"{0}\" could not be opened", filePath), e);
}