C# 使用序列化时发生强制转换错误

我刚才问了这个问题，但没有得到一个有用的答案。基本上，由于无效的强制转换异常，我无法使复制对象的方法正常工作。但我可以在复制方法之外把事情处理得很好

这是复制方法

public static class ObjectDuplicator
{
    public static T Clone<T>(T source)
    {
        if (!typeof(T).IsSerializable)
        {
            throw new ArgumentException("the Type must be serializable.", "source");
        }

        if (Object.ReferenceEquals(source, null)) //dont try to serialize a null object
        {
            return default(T);
        }

        IFormatter formatter = new BinaryFormatter();
        Stream stream = new MemoryStream();
        using (stream)
        {
            formatter.Serialize(stream, source);
            stream.Seek(0, SeekOrigin.Begin);
            return (T)formatter.Deserialize(stream);
        }
    }
}

我真的不知道是什么问题。正如我所说的，在这种方法之外，casting工作得很好，我知道这段代码以前也工作过。有什么想法吗

---

谢谢

如果您只是想要复制，而不是序列化，为什么不直接实现

IClonable

？每种类型都有一个受保护的方法，称为

MemberwiseClone

，它大大简化了所涉及的工作。

我找到了它。在某个时候，我将其编译为.dll，以便在另一个项目中引用。我忘了从bin目录中删除.dll，所以程序是从dll加载我的类，而不是从新版本的代码加载。我意识到，在我尝试直接复制同一类型的objct并看到它引用了.dll和.exe中的某些内容之后。删除.dll修复了它。我真傻。

序列化代码看起来不错。我很确定我在什么地方做过这件事。我来看看。是的，我序列化了一个派生类型，并在反序列化时将其转换为它的基类型。你的问题看起来很棘手，我不明白。对不起，我帮不了你。你能提供一个完整的异常堆栈跟踪吗？还有内部异常。最后，试着将强制转换到

T

移动到另一行，这样你就可以检查对象了。我只是觉得有一种方法来复制对象比有一种方法来复制每种类型更容易

public void AddJob(Job job)
{
    if (!Jobs.Contains(job))
    {
        Job newcopy = Utilities.ObjectDuplicator.Clone<Job>(job);

        Jobs.Add(newcopy);
    }
}

[Serializable]
public class Job : Ability
{
    protected JobCommand basecommand1;
    protected JobCommand basecommand2;
    protected JobCommand basecommand3;
    protected JobCommand basecommand4;
    protected JobCommand command1;
    protected JobCommand command2;
    protected JobCommand command3;
    protected JobCommand command4;
    bool mastered;
    protected FFJob job;
    protected string name;
    int level;

    public FFJob SetJob
    {
        get
        {
            return job;
        }
    }

    public bool Mastered
    {
        get
        {
            return mastered;
        }
    }

    public JobCommand Command1
    {
        get
        {
            return command1;
        }
        set
        {
            command1 = value;
        }
    }

    public JobCommand DefaultCommand1
    {
        get
        {
            return basecommand1;
        }
    }

    public JobCommand Command2
    {
        get
        {
            return command2;
        }
        set
        {
            command2 = value;
        }
    }

    public JobCommand DefaultCommand2
    {
        get
        {
            return basecommand2;
        }
    }

    public JobCommand Command3
    {
        get
        {
            return command3;
        }
        set
        {
            command3 = value;
        }
    }

    public JobCommand DefaultCommand3
    {
        get
        {
            return basecommand3;
        }
    }

    public JobCommand Command4
    {
        get
        {
            return command4;
        }
        set
        {
            command4 = value;
        }
    }

    public JobCommand DefaultCommand4
    {
        get
        {
            return basecommand4;
        }
    }

    public Job(string name, string description, int jobID)
        : base(name, description, jobID, -1, -1, null, null, -1, -1)
    {
    }

    public static bool operator ==(Job job1, Job job2)
    {
        if (System.Object.ReferenceEquals(job1, job2))
            return true;
        if (((object)job1 == null) || ((object)job2 == null))
            return false;
        return (job1.Name == job2.Name && job1.UID == job2.UID);
    }

    public static bool operator !=(Job job1, Job job2)
    {
        return !(job1 == job2);
    }


    // public abstract void CharacterModifier(BaseCharacter character);

    // public abstract void CharacterDemodifier(BaseCharacter character);
}

[Serializable]
public class Freelancer : Job
{
    public Freelancer()
        : base("Freelancer", "A character not specializing in any class. Can combine the power of all mastered Jobs.", Globals.JobID.ID)
    {
        basecommand1 = JobCommand.Attack;
        basecommand2 = JobCommand.Free;
        basecommand3 = JobCommand.Free;
        basecommand4 = JobCommand.Items;
        command1 = basecommand1;
        command2 = basecommand2;
        command3 = basecommand3;
        command4 = basecommand4;
        job = FFJob.Freelancer;
    }
}