class Program
{
  static void Main()
  {
    var bar = new Bar
    {
      Name = "bar",
      Zot = 123
    };
    Console.WriteLine(bar);
    byte[] data;
    using(var ms = new MemoryStream())
    {
      var bf = new BinaryFormatter();
      var surrogateTypes = new[] { typeof(Bar) };
      var ss = new SurrogateSelector();
      foreach(var t in surrogateTypes)
        ss.AddSurrogate(t, new StreamingContext(StreamingContextStates.All), new NonSerialiazableTypeSurrogate());
      bf.SurrogateSelector = ss;
      bf.Serialize(ms, bar);
      data = ms.ToArray();
    }
    using (var ms = new MemoryStream(data))
    {
      var bf = new BinaryFormatter();
      var surrogateTypes = new[] { typeof(Bar) };
      var ss = new SurrogateSelector();
      foreach (var t in surrogateTypes)
        ss.AddSurrogate(t, new StreamingContext(StreamingContextStates.All), new NonSerialiazableTypeSurrogate());
      bf.SurrogateSelector = ss;
      var bar2 = bf.Deserialize(ms) as Bar;
      Console.WriteLine(bar2?.ToString() ?? "null");
      
    }
    Console.WriteLine("done");
    Console.ReadKey(true);
  }
}

class Foo
{
  public int Zot { get; set; }
}

[Serializable]
class Bar : Foo
{
  public string Name { get; set; }
  public override string ToString()
  {
    return string.Concat(Name, "#", Zot);
  }
}

internal class NonSerialiazableTypeSurrogate : ISerializationSurrogate
{
  public void GetObjectData(object obj, SerializationInfo info, StreamingContext context)
  {
    GetObjectData(obj.GetType(), obj, info);
  }

  static void GetObjectData(Type type, object obj, SerializationInfo info)
  {
    var fieldInfos = type.GetFields(
      BindingFlags.Instance |
      BindingFlags.Public |
      BindingFlags.NonPublic);
    foreach (var fi in fieldInfos)
      if (IsKnownType(fi.FieldType))
        info.AddValue(fi.Name, fi.GetValue(obj));
      else if (fi.FieldType.IsClass)
        info.AddValue(fi.Name, fi.GetValue(obj));
    var bt = type.BaseType;
    if (bt!=typeof(object))
      GetObjectData(bt, obj, info);
  }

  public object SetObjectData(object obj, SerializationInfo info, StreamingContext context, ISurrogateSelector selector)
  {
    SetObjectData(obj.GetType(), obj, info);
    return obj;
  }

  static void SetObjectData(Type type, object obj, SerializationInfo info)
  {
    var fieldInfos = type.GetFields(
      BindingFlags.Instance |
      BindingFlags.Public |
      BindingFlags.NonPublic);
    foreach (var fi in fieldInfos)
    {
      if (IsKnownType(fi.FieldType))
      {
        if (IsNullableType(fi.FieldType))
        {
          var argumentValueForTheNullableType = GetFirstArgumentOfGenericType(fi.FieldType);
          fi.SetValue(obj, info.GetValue(fi.Name, argumentValueForTheNullableType));
        }
        else
          fi.SetValue(obj, info.GetValue(fi.Name, fi.FieldType));
      }
      else if (fi.FieldType.IsClass)
        fi.SetValue(obj, info.GetValue(fi.Name, fi.FieldType));
    }
    var bt = type.BaseType;
    if (bt != typeof(object))
      SetObjectData(bt, obj, info);
  }

  static Type GetFirstArgumentOfGenericType(Type type)
  {
    return type.GetGenericArguments()[0];
  }

  static bool IsNullableType(Type type)
  {
    if (type.IsGenericType)
      return type.GetGenericTypeDefinition() == typeof(Nullable<>);
    return false;
  }

  static bool IsKnownType(Type type)
  {
    return type == typeof(string) ||
           type.IsPrimitive ||
           type.IsSerializable;
  }
}

bar#123
bar#123