Ähnliche/Gleiche Funktion von WCF-Services in Projekt zusammenfassen - Welche Architektur?

Nabend zusammen,

ich habe mal eine grundsätzliche Frage zu WCF-Services, dazu folgendes Szenario:
Ich habe eine Projektmappe in der drei Projekte sind:

• Core
• InnerService
• OuterService

In Core liegen meine DataContracts für beide Service und diverse Klassen/Methoden (Verschlüsselungslogik usw.)

Ich habe nun den Fall, dass einige OperationContracts in beiden Services gleich heißen und auch ziemlich genau das gleiche machen.
Das würde ich nun gerne (in Core) zusammenlegen, also dass für Login() z.B. beides Services den gleichen Code verwenden.

Exemplarisch ist das bisher so aufgebaut:

Core

namespace Core
{
     [DataContract]
     public class LoginToken
     {
       //members
     }
}

Inner:

using Core;
namespace Inner
{
        [ServiceContract]
        public interface IInnerService
        {
            [OperationContract]
            bool Login(LoginToken token);
        }

        public class InnerService: IInnerService
        {
            public bool Login(LoginToken token)
            {
                 //do stuff
            }
         }
}

Outer:

using Core;
namespace Outer
{
        [ServiceContract]
        public interface IOuterService
        {
            [OperationContract]
            bool Login(LoginToken token);
        }

        public class OuterService: IOuterService
        {
            public bool Login(LoginToken token)
            {
                 //do the same stuff
            }
         }
}

Meine erste Idee wäre den Login-Code in Core zu verschieben und von dort in den Services aufzurufen.
Mein Bauch sagt mir aber, dass das nicht die eleganteste Lösung wäre. Und was wäre formal der richtige Ansatz?

Beste Grüße und einen schönen Start ins Wochenende
Timm

Erste Frage: warum überhaupt noch WCF und nicht ordentliches REST mit ASP.NET (Core) / NancyFX?

An für sich macht es natürlich Sinn, gemeinsame Funktionalitäten auch in einem gemeinsamen Projekt (jeweils mit eigenem Deployment) umzusetzen.
=> Modularität.

Zur eigentlichen Frage aber:
Was wäre die formal beste Umsetzung?
Eine statische Klasse mit statischen Methoden in Core wäre wahrscheinlich die simpelste Lösung, erscheint mir aber wie gesagt nicht als der beste Weg.

Noch mal zu meiner Frage...?

Deine Frage hab zumindest ich bereits beantwortet.

Hallo emuuu,

den Login-Code in Core zu verschieben

Das ist auch passend so. Ob du dann Vererbung od. Komposition verwendest hängt von den näheren Umständen deines Projekts ab.

Z.B.

using System.ServiceModel;

namespace Core
{
	public class LoginToken
	{
		//
	}

	[ServiceContract]
	public interface ICoreService
	{
		[OperationContract]
		bool Login(LoginToken token);
	}

	public class CoreService : ICoreService
	{
		public bool Login(LoginToken token)
		{
			//
			return true;
		}
	}
}

using System.ServiceModel;
using Core;

namespace InnerService
{
	[ServiceContract]
	public interface IInnerService : ICoreService
	{
		[OperationContract]
		int GetUltimateAnswer();
	}

	public class InnerService : CoreService, IInnerService
	{
		public int GetUltimateAnswer()
		{
			return 42;
		}
	}
}

mfG Gü