SerializationException Typ "ist nicht als serialisierbar markiert" - Aber es ist

In Windows Forms .NET Framework 4.0, ich bin versucht zu Serialisieren wird eine Instanz einer Klasse, die ich schrieb.

Die Klasse wird als Serialisierbar markiert, aber die form, die diese Klasse verwendet (offensichtlich) nicht.

Möchte ich nicht Serialisieren wird eine Instanz der form. Ich möchte zum Serialisieren der Daten habe ich in meiner Klasse.

Alles in meiner Klasse wird als Serialisierbar markiert, also warum bin ich noch immer der SerializationException?

(Klicken Sie auf >> HIER << öffnen, Bild in voller Größe in einem neuen Fenster)

Update:

Hier ist mein BrazierCuttoff - Klasse und verwandter Teile:

[Serializable()]
public class BrazierCuttoff : IEquatable<BrazierCuttoff> {
  private int qty;
  private int[] joint, pass, shift;
  private float mult;
  private BrazierPay a, b, c, d, e;
  public event EventHandler BrazierCuttoffChanged;
  public const int MAXIMUMSMALLQUANTITY = 20;
  EnumeratedLevel[,] eLvArray;
  ///<summary>
  ///Gets or Sets the Brazier Matrix values
  ///</summary>
  ///<param name="passRatioIndex">0=100%,1=95,2=90,3=85,4=80,5=75,6=70,7=65</param>
  ///<param name="minJointIndex">0=900,1=1200,2=1400,3=1600,4=1800,5=2000,6=2100,=2200</param>
  ///<returns>Brazier Matrix value</returns>
  public EnumeratedLevel this[int passRatioIndex, int minJointIndex] {
    get { return eLvArray[passRatioIndex, minJointIndex]; }
    set { eLvArray[passRatioIndex, minJointIndex] = value; }
  }
  ///<summary>
  ///Initializes a new Form Values object using default values
  ///</summary>
  public BrazierCuttoff() {
    A = new BrazierPay(5.0f);
    B = new BrazierPay(4.0f);
    C = new BrazierPay(3.0f);
    D = new BrazierPay(2.0f);
    E = new BrazierPay(1.0f);
    NA = new BrazierPay(0.0f);
    ShiftMinimum = new int[] { 12, 12, 12 };
    PassRatio = new int[] { 100, 95, 90, 85, 80, 75, 70, 65 };
    JointMinimum = new int[] { 900, 1200, 1400, 1600, 1800, 2000, 2100, 2200 };
    eLvArray = new EnumeratedLevel[8, 8];
    EnumeratedLevel level = EnumeratedLevel.NA_Silver;
    for (int y = 0; y < 8; y++) {
      for (int x = 0; x < 8; x++) {
        switch (y) {
          case 0: level = (x < 2) ? EnumeratedLevel.B_Blue : EnumeratedLevel.A_Violet; break;
          case 1: level = (x == 0) ? EnumeratedLevel.C_Green : (x < 3) ? EnumeratedLevel.B_Blue : EnumeratedLevel.A_Violet; break;
          case 2: level = (x < 2) ? EnumeratedLevel.C_Green : (x < 5) ? EnumeratedLevel.B_Blue : EnumeratedLevel.A_Violet; break;
          case 3: level = (x == 0) ? EnumeratedLevel.D_Yellow : (x < 4) ? EnumeratedLevel.C_Green : (x < 6) ? EnumeratedLevel.B_Blue : EnumeratedLevel.A_Violet; break;
          case 4: level = (x < 2) ? EnumeratedLevel.D_Yellow : (x < 5) ? EnumeratedLevel.C_Green : EnumeratedLevel.B_Blue; break;
          case 5: level = (x == 0) ? EnumeratedLevel.E_Orange : (x < 3) ? EnumeratedLevel.D_Yellow : (x < 6) ? EnumeratedLevel.C_Green : EnumeratedLevel.B_Blue; break;
          case 6: level = (x < 2) ? EnumeratedLevel.E_Orange : (x < 5) ? EnumeratedLevel.D_Yellow : EnumeratedLevel.C_Green; break;
          default: level = (x == 0) ? EnumeratedLevel.NA_Silver : (x < 5) ? EnumeratedLevel.E_Orange : EnumeratedLevel.D_Yellow; break;
        }
        eLvArray[x, y] = level;
      }
    }
  }

  private void broadcast() {
    if (BrazierCuttoffChanged != null) {
      BrazierCuttoffChanged(this, new EventArgs());
    }
  }
  ///<summary>
  ///Gets or Sets the A Pay Level data
  ///</summary>
  public BrazierPay A { get { return a; } set { if (a != value) { a = value; broadcast(); } } }
  ///<summary>
  ///Gets or Sets the B Pay Level data
  ///</summary>
  public BrazierPay B { get { return b; } set { if (b != value) { b = value; broadcast(); } } }
  ///<summary>
  ///Gets or Sets the C Pay Level data
  ///</summary>
  public BrazierPay C { get { return c; } set { if (c != value) { c = value; broadcast(); } } }
  ///<summary>
  ///Gets or Sets the D Pay Level data
  ///</summary>
  public BrazierPay D { get { return d; } set { if (d != value) { d = value; broadcast(); } } }
  ///<summary>
  ///Gets or Sets the E Pay Level data
  ///</summary>
  public BrazierPay E { get { return e; } set { if (e != value) { e = value; broadcast(); } } }
  ///<summary>
  ///Gets or Sets the N/A Pay Level data
  ///</summary>
  public BrazierPay NA { get; private set; }

  public void Refresh() {
    const float delta = 0.01f;
    while (A.Dirty || B.Dirty || C.Dirty || D.Dirty || E.Dirty) {
      if (A.Dirty) {
        if (A.Value <= B.Value) B.Value = A.Value - delta;
        A.Dirty = false;
      } else if (B.Dirty) {
        if (B.Value <= C.Value) C.Value = B.Value - delta;
        if (A.Value <= B.Value) A.Value = B.Value + delta;
        B.Dirty = false;
      } else if (C.Dirty) {
        if (C.Value <= D.Value) D.Value = C.Value - delta;
        if (B.Value <= C.Value) B.Value = C.Value + delta;
        C.Dirty = false;
      } else if (D.Dirty) {
        if (D.Value <= E.Value) E.Value = D.Value - delta;
        if (C.Value <= D.Value) C.Value = D.Value + delta;
        D.Dirty = false;
      } else if (E.Dirty) {
        if (D.Value <= E.Value) D.Value = E.Value + delta;
        E.Dirty = false;
      }
    }
  }
  ///<summary>
  ///Gets the minimum Average Joints requirement
  ///</summary>
  public int AverageJoints { get { return JointMinimum[0]; } }
  ///<summary>
  ///Gets the minimum Chamber Pass Ratio requirement
  ///</summary>
  public int FirstTimePassRate { get { return PassRatio[PassRatio.Length - 1]; } }
  ///<summary>
  ///Gets or sets the Minimum Average Joints requirements (Range: 0 @ 900 to 7 @ 2200)
  ///</summary>
  public int[] JointMinimum { get { return joint; } set { if (joint != value) { joint = value; broadcast(); } } }
  ///<summary>
  ///Gets or Sets the Chamber Pass Ratio levels (Range: 0 @ 100% to 7 @ 65%)
  ///</summary>
  public int[] PassRatio { get { return pass; } set { if (pass != value) { pass = value; broadcast(); } } }
  ///<summary>
  ///Gets or Sets the Integral Array of minimum shifts required to qualify for a bonus
  ///</summary>
  public int[] ShiftMinimum { get { return shift; } set { if (shift != value) { shift = value; broadcast(); } } }
  ///<summary>
  ///Gets or Sets the Small Workorder Multiplier (1 is default/disable)
  ///</summary>
  public float SmallWoMulti { get { return mult; } set { if (mult != value) { mult = value; broadcast(); } } }
  ///<summary>
  ///Gets or Sets the Small Workorder Quantity value (0 is disable)
  ///</summary>
  public int SmallWoQty { get { return qty; } set { if (qty != value) { qty = value; broadcast(); } } }

  #region IEquatable<BrazierCuttoff> Members

  public bool Equals(BrazierCuttoff other) {
    if (other != null) {
      if ((A == other.A) && (B == other.B) && (C == other.C) && (D == other.D) && (E == other.E) && (NA == other.NA)) {
        if ((ShiftMinimum == other.ShiftMinimum) && (PassRatio == other.PassRatio) && (JointMinimum == other.JointMinimum)) {
          return (eLvArray == other.eLvArray);
        }
      }
    }
    return false;
  }

  #endregion

}

Dies ist die BrazierPay - Objekt, das verwendet wird in der obigen Klasse:

[Serializable()]
public class BrazierPay {
  float pay;
  public BrazierPay(float payLevel) {
    Dirty = false;
    pay = payLevel;
  }
  public float Value {
    get { return pay; }
    set {
      if (pay != value) {
        Dirty = true;
        pay = value;
      }
    }
  }
  public bool Dirty { get; set; }
  public string DollarValue { get { return string.Format("{0:C}", pay); } }
  public string Formatted { get { return string.Format("{0:F}", pay); } }
  public override string ToString() { return Formatted; }
}

Ich auch markiert dieser Aufzählungstyp als Serialisierbar (obwohl, es sollte es nicht brauchen):

[Serializable()]
public enum EnumeratedLevel {
  NA_Silver = Clicker.NA_Silver, //Color.Silver
  E_Orange = Clicker.E_Orange, //Color.Orange
  D_Yellow = Clicker.D_Yellow, //Color.Yellow
  C_Green = Clicker.C_Green, //Color.Lime
  B_Blue = Clicker.B_Blue, //Color.DodgerBlue
  A_Violet = Clicker.A_Violet, //Color.Violet
}