Question

I am having trouble understanding if I am doing this correctly or not. I have 3 entities that are dependent on each other. I am trying to add new objects to these entities and then call save changes ultimately adding the corresponding records to the tables honoring the FK constraints.

I am getting the error:

The relationship between the two objects cannot be defined because they are attached to different ObjectContext objects.

In my code I am parsing some XML with linq while adding the new objects to the context as I go. In my service layer I have the following method to handle processing the incoming data.

public void ProcessSurvey(int surveyContentId, int caseNo, string surveyTitle, string reportVersion, string reportXml)
{
    // get surveyid 
    var surveyContent = _surveyContentRepository.GetSurveyContent(surveyContentId);
    // create response obj
    var surveyResponse = new SurveyResponse()
    {
        SurveyId = surveyContent.SurveyId,
        CaseNo = caseNo,
        SurveyTitle = surveyTitle,
        ReportVersion = reportVersion,
        Created = DateTime.Now,
        ResponseXML = reportXml
    };
    // add response obj to context?
    _surveyResponseRepository.Add(surveyResponse);
    // get the questions elements from the xml data
    var questions = SurveyResponseHelper.GetResponseQuestions(reportXml);
    // iterate over questions
    foreach (XElement question in questions)
        {
        SurveyQuestion thisSurveyQuestion = SurveyResponseHelper.ProcSurveyQuestion(question, surveyContentId);
        // add question?
        _surveyQuestionRepository.Add(thisSurveyQuestion);
        // get question answer
        SurveyAnswer thisSurveyAnswer = SurveyResponseHelper.GetAnswer(question);
        //update the answer with the question and response obj to satisfy the FK reference
        thisSurveyAnswer.SurveyQuestion = thisSurveyQuestion;
        thisSurveyAnswer.SurveyResponse = surveyResponse; // This is where it breaks ERRROR: The relationship between the two objects cannot be defined because they are attached to different ObjectContext objects
        _surveyAnswerRepository.Add(thisSurveyAnswer);
        }
    //commit
    _surveyAnswerRepository.Save();
}

My Repositories look like this..

public interface ISurveyAnswerRepository
{
    void Add(SurveyAnswer surveyAnswer);
    void Save();
}
public class SurveyAnswerRepository : Repository, ISurveyAnswerRepository
{

    //private DiversionProgramsEntities _db;

    public SurveyAnswerRepository()
    {
        //_db = new DiversionProgramsEntities();
    }

    public void Add(SurveyAnswer surveyAnswer)
    {
        this.DataContext.SurveyAnswers.AddObject(surveyAnswer);


    }

    public void Save()
    {
        this.DataContext.SaveChanges();

    }

my base repository

public class Repository
{
    private DiversionProgramsEntities _dataContext;

    public DiversionProgramsEntities DataContext
    {
        get { return _dataContext ?? (_dataContext = DatabaseFactory.CreateContext()); }
    }


}

and static class / method to create the context

public static class DatabaseFactory
{

    public static DiversionProgramsEntities CreateContext()
    {
        return new DiversionProgramsEntities();
    }

}

here is my helper code..

public class SurveyResponseHelper
{
public static IEnumerable<XElement> GetResponseQuestions(string xmlResponseData)
{
    XElement xmlData = XElement.Parse(xmlResponseData);
    var questions = from n in xmlData.Descendants()
                    where n.Parent.Name.LocalName == "questions"
                    select n;

    return questions;
}

public static SurveyQuestion ProcSurveyQuestion(XElement question, int surveyContentId)
{
    // get the question type
    var questionType = question.Name.LocalName;
    // get question element text. This is the actual question text
    var questionText = question.Elements().Where(e => e.Name.LocalName == "direction").SingleOrDefault().Value;
    // check to see if this question exists in the data table, if it does then we will use the questionid from that which will get used to tie the SurveyAnswer to this question.
    // if question does not already exist then a new one will be created
    SurveyQuestionRepository surveyQuestionRepository = new SurveyQuestionRepository();
    SurveyQuestion surveyQuestion;
    surveyQuestion = surveyQuestionRepository.GetSurveyQuestion(surveyContentId, questionType, questionText);
    if (surveyQuestion == null)
    {
        surveyQuestion = new SurveyQuestion()
        {
            QuestionText = questionText,
            QuestionType = questionType,
            SurveyContentId = surveyContentId
        };
    }

    return surveyQuestion;
}

public static SurveyAnswer GetAnswer(XElement question)
{
    // get the answer index value
    var answers = question.Elements().Where(e => e.Name.LocalName == "answers").SingleOrDefault();
    int userAnswerIndex = Int32.Parse(answers.Attribute("userAnswerIndex").Value);
    // move the answers to an array so we can use the index to get the correct answer
    XElement[] answersArray = answers.Elements().ToArray();
    SurveyAnswer answer = new SurveyAnswer()
    {
        AnswerText = answersArray[userAnswerIndex].Value
    };

    return answer;
}



}

Answer 1

As @TimHoolihan stated the issue is that you are not using the same Data Context for accessing the Survey Responses and Survey Questions and actually I believe the issue lines in the line below from the ProcSurveyQuestion method.

    SurveyQuestionRepository surveyQuestionRepository = new SurveyQuestionRepository();

I see that you have a singleton DataContext in the DiversionProgramsEntities class, but I cannot infer from your code if the SurveyQuestionRepository and SurveryResponseRepositories are also using that same context. Based on the error you are getting, I am guessing that they are using separate contexts, so again as @TimHoolihan suggested, you need to modify your code to use the same context for both.

You should also look into the UnitOfWork pattern as this is what you are trying to accomplish here, but you do not have a common context to track all of your changes across.