using System.Runtime.Serialization;
namespace Correctamundo.Wcf.ContractTypes
{
[DataContract]
public class Question
{
[DataMember]
public bool IsCorrect { get; set; }

[DataMember]
public string Answer { get; set; }
}
}

using System.Collections.Generic;
using System.Runtime.Serialization;
namespace Correctamundo.Wcf.ContractTypes
{
[DataContract]
public class Section
{
[DataMember]
public IEnumerable<Question> Questions { get; set; }
}
}

using System;
using System.Collections.Generic;
using System.Runtime.Serialization;
namespace Correctamundo.Wcf.ContractTypes
{
[DataContract]
public class Test
{
[DataMember]
public Guid Id { get; set; }

[DataMember]
public IEnumerable<Section> Sections { get; set; }
}
}

using System.Runtime.Serialization;
namespace Correctamundo.Wcf.OperationTypes
{
[DataContract]
public class TestCorrectorRequest
{
}
}

using System.Runtime.Serialization;
namespace Correctamundo.Wcf.OperationTypes
{
[DataContract]
public class TestCorrectorResponse
{
[DataMember]
bool Success { get; set; }

[DataMember]
string Response { get; set; }
}
}

using Correctamundo.Wcf.ContractTypes;
using Correctamundo.Wcf.OperationTypes;
namespace Correctamundo.Wcf.OperationTypes
{
public class CorrectAnswersRequest : TestCorrectorRequest
{
public Test Test { get; set; }
}

}

using Correctamundo.Wcf.ContractTypes;
using Correctamundo.Wcf.OperationTypes;
namespace Correctamundo.Wcf.OperationTypes
{
public class CorrectAnswersResponse : TestCorrectorResponse
{
public Test Test { get; set; }

public bool Success { get; set; }

public string Response { get; set; }
}
}

using Correctamundo.Wcf.ContractTypes;
using Correctamundo.Wcf.OperationTypes;
namespace Correctamundo.Wcf.Factories.Interfaces
{
public interface IResponseFactory
{
CorrectAnswersResponse CreateCorrectAnswersResponse(bool success, string response, Test test = null);
}
}

using Correctamundo.Wcf.ContractTypes;
using Correctamundo.Wcf.Factories.Interfaces;
using Correctamundo.Wcf.OperationTypes;
namespace Correctamundo.Wcf.Factories.Implementations
{
public class ResponseFactory : IResponseFactory
{
public CorrectAnswersResponse CreateCorrectAnswersResponse(bool success, string response, Test test = null)
{
return new CorrectAnswersResponse
{
Success = success,
Response = response,
Test = test
};
}
}
}

namespace Correctamundo.Wcf.TypeMappers.Interfaces
{
public interface ITestMapper
{
Domain.Entities.Test Map(ContractTypes.Test test);
ContractTypes.Test Map(Domain.Entities.Test test);
}
}

namespace Correctamundo.Wcf.TypeMappers.Interfaces
{
public interface ISectionMapper
{
Domain.Entities.Section Map(ContractTypes.Section test);
ContractTypes.Section Map(Domain.Entities.Section test);
}
}

namespace Correctamundo.Wcf.TypeMappers.Interfaces
{
public interface IQuestionMapper
{
Domain.Entities.Question Map(ContractTypes.Question test);
ContractTypes.Question Map(Domain.Entities.Question test);
}
}

namespace Correctamundo.Wcf.TypeMappers.Implementations
{
public class TestMapper : ITestMapper
{
private readonly ISectionMapper _mapper;

public TestMapper(ISectionMapper mapper)
{
if (mapper == null)
throw new ArgumentNullException("mapper");

_mapper = mapper;
}

public Domain.Entities.Test Map(ContractTypes.Test test)
{
IEnumerable<Domain.Entities.Section> sections = MapFrom(test.Sections);
return new Domain.Entities.Test(sections);
}

private IEnumerable<Domain.Entities.Section> MapFrom(IEnumerable<ContractTypes.Section> sections)
{
foreach (ContractTypes.Section q in sections)
{
yield return _mapper.Map(q);
}
}

public ContractTypes.Test Map(Domain.Entities.Test test)
{
IEnumerable<ContractTypes.Section> sections = MapFrom(test.Sections);
return new ContractTypes.Test
{
Sections = sections
};
}

private IEnumerable<ContractTypes.Section> MapFrom(IEnumerable<Domain.Entities.Section> sections)
{
foreach (Domain.Entities.Section q in sections)
{
yield return _mapper.Map(q);
}
}
}
}

namespace Correctamundo.Wcf.TypeMappers.Implementations
{
public class SectionMapper : ISectionMapper
{
private readonly IQuestionMapper _mapper;

public SectionMapper(IQuestionMapper mapper)
{
if (mapper == null)
throw new ArgumentNullException("mapper");

_mapper = mapper;
}

public Domain.Entities.Section Map(ContractTypes.Section test)
{
IEnumerable<Domain.Entities.Question> questions = MapFrom(test.Questions);
return new Domain.Entities.Section(questions);
}

private IEnumerable<Domain.Entities.Question> MapFrom(IEnumerable<ContractTypes.Question> questions)
{
foreach(ContractTypes.Question q in questions)
{
yield return _mapper.Map(q);
}
}

public ContractTypes.Section Map(Domain.Entities.Section test)
{
IEnumerable<ContractTypes.Question> questions = MapFrom(test.Questions);
return new ContractTypes.Section
{
Questions = questions
};
}

private IEnumerable<ContractTypes.Question> MapFrom(IEnumerable<Domain.Entities.Question> questions)
{
foreach (Domain.Entities.Question q in questions)
{
yield return _mapper.Map(q);
}
}
}
}

namespace Correctamundo.Wcf.TypeMappers.Implementations
{
public class QuestionMapper : IQuestionMapper
{
public Domain.Entities.Question Map(ContractTypes.Question test)
{
return new Domain.Entities.Question(test.Answer, test.IsCorrect);
}

public ContractTypes.Question Map(Domain.Entities.Question test)
{
return new ContractTypes.Question
{
Answer = test.Answer,
IsCorrect = test.IsCorrect
};
}
}
}

namespace Correctamundo.Wcf.Services.Interfaces
{
[ServiceContract]
public interface ITestCorrectorService
{
[OperationContract]
CorrectAnswersResponse AddCorrectAnswers(CorrectAnswersRequest request);

[OperationContract]
CorrectAnswersResponse GetCorrectAnswers(CorrectAnswersRequest request);

}

}

namespace Correctamundo.Wcf.Services.Implementations
{
public class TestCorrectorService : ITestCorrectorService
{
private readonly ITestCorrector _testCorrector;
private readonly IResponseFactory _responseFactory;
private readonly ITestMapper _mapper;

public TestCorrectorService(ITestCorrector testCorrector, IResponseFactory responseFactory, ITestMapper mapper)
{
if (testCorrector == null)
throw new ArgumentNullException("testCorrector");
if (responseFactory == null)
throw new ArgumentNullException("responseFactory");
if (mapper == null)
throw new ArgumentNullException("mapper");


_testCorrector = testCorrector;
_responseFactory = responseFactory;
_mapper = mapper;
}

public CorrectAnswersResponse AddCorrectAnswers(CorrectAnswersRequest request)
{
CorrectAnswersResponse response;

try
{
Domain.Entities.Test test = _mapper.Map(request.Test);


Guid id = _testCorrector.AddTestKey(test);

request.Test.Id = id;

response = _responseFactory.CreateCorrectAnswersResponse(true, "Success", request.Test);
}
catch(Exception ex)
{
response = _responseFactory.CreateCorrectAnswersResponse(false, ex.Message);
}

return response;
}

public CorrectAnswersResponse GetCorrectAnswers(CorrectAnswersRequest request)
{
CorrectAnswersResponse response;

try
{
Domain.Entities.Test domain = _mapper.Map(request.Test);

domain = _testCorrector.CorrectTest(request.Test.Id, domain);

ContractTypes.Test service = _mapper.Map(domain);

response = _responseFactory.CreateCorrectAnswersResponse(true, "Success", service);
}
catch (Exception ex)
{
response = _responseFactory.CreateCorrectAnswersResponse(false, ex.Message);
}

return response;
}
}
}

namespace Correctamundo.Wcf
{
public class AutofacModule : Module
{
protected override void Load(ContainerBuilder builder)
{
builder.RegisterType<ResponseFactory>().As<IResponseFactory>();
builder.RegisterType<TestCorrectorService>();
builder.RegisterType<TestMapper>().As<ITestMapper>();
builder.RegisterType<SectionMapper>().As<ISectionMapper>();
builder.RegisterType<QuestionMapper>().As<IQuestionMapper>();
}
}
}

namespace Correctamundo.Wcf
{
public class CorrectamundoServiceHostFactory : AutofacServiceHostFactory
{
public override System.ServiceModel.ServiceHostBase CreateServiceHost(string constructorString, Uri[] baseAddresses)
{
ContainerBuilder builder = new ContainerBuilder();

Assembly[] assemblies = BuildManager.GetReferencedAssemblies().Cast<Assembly>().ToArray();
builder.RegisterAssemblyModules(assemblies);
Container = builder.Build();

return base.CreateServiceHost(constructorString, baseAddresses);
}
}
}

<?xml version="1.0" encoding="utf-8"?>
<configuration>

<appSettings>
<add key="aspnet:UseTaskFriendlySynchronizationContext" value="true" />
</appSettings>
<system.web>
<compilation debug="true" targetFramework="4.5" />
<httpRuntime targetFramework="4.5" />
</system.web>
<system.serviceModel>
<serviceHostingEnvironment aspNetCompatibilityEnabled="true" multipleSiteBindingsEnabled="true">
<serviceActivations>
<add factory="Correctamundo.Wcf.CorrectamundoServiceHostFactory, Correctamundo" service="Correctamundo.Wcf.Services.Implementations.TestCorrectorService, Correctamundo" relativeAddress="TestCorrectorService.svc"/>
</serviceActivations>
</serviceHostingEnvironment>
<services>
<service name="Correctamundo.Wcf.Services.Implementations.TestCorrectorService">
<endpoint binding="basicHttpBinding" contract="Correctamundo.Wcf.Services.Interfaces.ITestCorrectorService" />
</service>
</services>
<behaviors>
<serviceBehaviors>
<behavior>
<!-- To avoid disclosing metadata information, set the values below to false before deployment -->
<serviceMetadata httpGetEnabled="true" httpsGetEnabled="true" />
<!-- To receive exception details in faults for debugging purposes, set the value below to true. Set to false before deployment to avoid disclosing exception information -->
<serviceDebug includeExceptionDetailInFaults="true" />
</behavior>
</serviceBehaviors>
</behaviors>
<bindings>
<basicHttpBinding>
<binding>
<security mode="None">

</security>
</binding>
</basicHttpBinding>
</bindings>
<protocolMapping>
<add binding="basicHttpsBinding" scheme="https" />
</protocolMapping>
</system.serviceModel>
<system.webServer>
<modules runAllManagedModulesForAllRequests="true" />
<!--
To browse web app root directory during debugging, set the value below to true.
Set to false before deployment to avoid disclosing web app folder information.
-->
<directoryBrowse enabled="true" />
</system.webServer>

<runtime>

<assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">

<dependentAssembly>

<assemblyIdentity name="Autofac" publicKeyToken="17863af14b0044da" culture="neutral" />

<bindingRedirect oldVersion="0.0.0.0-3.5.0.0" newVersion="3.5.0.0" />

</dependentAssembly>

</assemblyBinding>

</runtime>
</configuration>

namespace Correctamundo.Domain
{
public class AutofacModule : Module
{
protected override void Load(ContainerBuilder builder)
{
builder.RegisterType<TestRepository>().As<ITestRepository>().SingleInstance();
builder.RegisterType<TestCorrector>().As<ITestCorrector>();
}
}
}

namespace Correctamundo.Domain.Entities
{
public class Question
{
public Question(string answer, bool correct)
{
if (string.IsNullOrEmpty(answer))
throw new ArgumentException("Answer cannot be null or empty");

Answer = answer;
IsCorrect = correct;
}

public string Answer { get; private set; }

public bool IsCorrect { get; private set; }

public Question CorrectQuestion(Question question)
{
string answer = string.Format("You marked: {0}. Correct Answer: {1}", question.Answer, Answer);
return new Question(answer, question.Answer.Equals(Answer));
}
}
}

namespace Correctamundo.Domain.Entities
{
public class Section
{
public Section(IEnumerable<Question> questions)
{
if (questions == null || !questions.Any())
throw new ArgumentException("Answers cannot be null or empty");
Questions = questions;
}

public IEnumerable<Question> Questions { get; private set; }

public Section CorrectSection(Section section)
{
return new Section(Questions.Zip(section.Questions, (answer, choice) => answer.CorrectQuestion(choice)));
}
}
}

namespace Correctamundo.Domain.Entities
{
public class Test
{
public Test(IEnumerable<Section> sections)
{
if (sections == null || !sections.Any())
throw new ArgumentException("Sections cannot be null or empty");
Sections = sections;
}

public IEnumerable<Section> Sections { get; internal set; }


public Test CorrectTest(Test test)
{
return new Test(Sections.Zip(test.Sections, (answer, choice) => answer.CorrectSection(choice)));
}
}
}

namespace Correctamundo.Domain.Repositories.Interfaces
{
public interface ITestRepository
{
Test GetTest(Guid id);
Guid AddTest(Test test);
}
}

namespace Correctamundo.Domain.Repositories.Implementations
{
public class TestRepository : ITestRepository
{
private readonly Dictionary<Guid, Test> _tests;
public TestRepository()
{
_tests = new Dictionary<Guid, Test>();
}

public Test GetTest(Guid id)
{
Test test = null;
if(!_tests.TryGetValue(id, out test))
throw new ArgumentException("Test does not exist");
return test;
}

public Guid AddTest(Test test)
{
if (test == null)
throw new ArgumentNullException("test");

Guid id = Guid.NewGuid();

_tests.Add(id, test);

return id;
}
}
}

namespace Correctamundo.Domain.Services.Interfaces
{
public interface ITestCorrector
{
Guid AddTestKey(Test test);
Test CorrectTest(Guid id, Test test);
}
}

namespace Correctamundo.Domain.Services.Implementations
{
public class TestCorrector : ITestCorrector
{
private readonly ITestRepository _repository;

public TestCorrector(ITestRepository repository)
{
if (repository == null)
throw new ArgumentNullException("repository");

_repository = repository;
}


public Guid AddTestKey(Test test)
{
return _repository.AddTest(test);
}

public Test CorrectTest(Guid id, Test test)
{
Test key = _repository.GetTest(id);
return key.CorrectTest(test);
}
}
}

<?xml version="1.0" encoding="utf-8"?>
<packages>
<package id="Autofac" version="3.5.2" targetFramework="net45" />
<package id="Autofac.Wcf" version="4.0.0" targetFramework="net45" />
</packages>