常规WCF服务

Question

I know there are a lot of questions with and without answer about this topic but none seem to match exactly with the issue that I have.

I'm trying to write manager services for my project's entities. For the main, big and important ones I have already done it but the business contains a lot of descriptors (entities with only ID and Name that are used by other entities) that I'd like to be able to manage as services too.

One solution would be to have a specific manager for each of them but that would definitely break maintainability due to the number of descriptors. So I wrote 2 interfaces as follows

public interface IIdentifiableEntity
{
    string EntityId { get; set; }
}

public interface IDescriptorEntity: IIdentifiableEntity
{
    string EntityDesc { get; set; }
}

This is due to my main entities implement IIdentifiableEntity and my descriptors implement IDescriptorEntity

Here is an example of one of my descriptor entities:

public class JobCode: IDescriptorEntity
{
    [DataMember]
    public string JobCodeID { get; set; }
    [DataMember]
    public string JobCodeDesc { get; set; }

    public string EntityId
    {
        get
        {
            return JobCodeID;
        }

        set
        {
            JobCodeID = value;
        }
    }

    public string EntityDesc
    {
        get
        {
            return JobCodeDesc;
        }

        set
        {
            JobCodeDesc = value;
        }
    }
}

Then I wrote my service contract as follows:

public interface IDescriptorService : IServiceContract
{
    [OperationContract]
    [FaultContract(typeof(NotFoundException))]
    T Get<T>(string id) where T : class, IDescriptorEntity, new();

    [OperationContract]
    T[] GetAll<T>() where T : class, IDescriptorEntity, new();

    [OperationContract]
    [TransactionFlow(TransactionFlowOption.Allowed)]
    T Add<T>(T descriptor) where T : class, IDescriptorEntity, new();

    [OperationContract]
    [TransactionFlow(TransactionFlowOption.Allowed)]
    T Update<T>(T descriptor) where T : class, IDescriptorEntity, new();

    [OperationContract]
    [TransactionFlow(TransactionFlowOption.Allowed)]
    void Delete<T>(string id) where T : class, IDescriptorEntity, new();
}

And my manager (the service itself) as follows:

[ServiceBehavior(InstanceContextMode = InstanceContextMode.PerCall,
    ConcurrencyMode = ConcurrencyMode.Multiple,
    ReleaseServiceInstanceOnTransactionComplete = false)]
[Export(typeof(IDescriptorService))]
public class DescriptorManager : ManagerBase, IDescriptorService
{
    public DescriptorManager()
    {
        ObjectBase.Container.SatisfyImportsOnce(this);
    }

    #region No MEF Discovery constructors
    public DescriptorManager(IDataRepositoryFactory dataRepositoryFactory)
    {
        _DataRepositoryFactory = dataRepositoryFactory;
    }
    #endregion

    [Import]
    IDataRepositoryFactory _DataRepositoryFactory;

    [PrincipalPermission(SecurityAction.Demand, Authenticated = true)]
    public TEntityType Get<TEntityType>(string id) where TEntityType : class, IDescriptorEntity, new() => ExecuteFaultHandledOperation(() =>
    {
        IDataRepository<TEntityType> repository = _DataRepositoryFactory.GetDataRepositoryOf<TEntityType>();

        TEntityType entity = repository.Get(id);

        if (entity == null)
        {
            NotFoundException ex
                = new NotFoundException(string.Format("{0} with ID of {1} is not in the database", typeof(TEntityType).Name, id));

            throw new FaultException<NotFoundException>(ex, ex.Message);
        }

        return entity;
    });

    [PrincipalPermission(SecurityAction.Demand, Authenticated = true)]
    public TEntityType[] GetAll<TEntityType>() where TEntityType : class, IDescriptorEntity, new() => ExecuteFaultHandledOperation(() =>
    {
        IDataRepository<TEntityType> repository = _DataRepositoryFactory.GetDataRepositoryOf<TEntityType>();

        IEnumerable<TEntityType> entities = repository.Get();

        return entities.ToArray();
    });

    [OperationBehavior(TransactionScopeRequired = true)]
    [PrincipalPermission(SecurityAction.Demand, Authenticated = true)]
    public TEntityType Update<TEntityType>(TEntityType entity) where TEntityType : class, IDescriptorEntity, new() => ExecuteFaultHandledOperation(() =>
    {
        IDataRepository<TEntityType> repository = _DataRepositoryFactory.GetDataRepositoryOf<TEntityType>();

        TEntityType updatedEntity = repository.Update(entity);

        return updatedEntity;
    });

    [OperationBehavior(TransactionScopeRequired = true)]
    [PrincipalPermission(SecurityAction.Demand, Authenticated = true)]
    public TEntityType Add<TEntityType>(TEntityType entity) where TEntityType : class, IDescriptorEntity, new() => ExecuteFaultHandledOperation(() =>
    {
        IDataRepository<TEntityType> repository = _DataRepositoryFactory.GetDataRepositoryOf<TEntityType>();

        TEntityType updatedEntity = repository.Add(entity);

        return updatedEntity;
    });

    [OperationBehavior(TransactionScopeRequired = true)]
    [PrincipalPermission(SecurityAction.Demand, Authenticated = true)]
    public void Delete<TEntityType>(string id) where TEntityType : class, IDescriptorEntity, new() => ExecuteFaultHandledOperation(() =>
    {
        IDataRepository<TEntityType> repository = _DataRepositoryFactory.GetDataRepositoryOf<TEntityType>();

        repository.Remove(id);
    });
}

And the hosting app as a console app as follows:

class Program
{
    static void Main(string[] args)
    {
        ObjectBase.Container = MEFLoader.Init();

        Console.WriteLine("Starting up services...");
        Console.WriteLine("");

        SM.ServiceHost hostDescriptorManager = new SM.ServiceHost(typeof(DescriptorManager));
        SM.ServiceHost hostPositionManager = new SM.ServiceHost(typeof(PositionManager));
        SM.ServiceHost hostEmployeeManager = new SM.ServiceHost(typeof(EmployeeManager));

        StartService(hostDescriptorManager, "DescriptorManager");
        StartService(hostPositionManager, "PositionManager");
        StartService(hostEmployeeManager, "EmployeeManager");

        Console.WriteLine("");
        Console.WriteLine("Press [Enter] to exit.");
        Console.ReadLine();

        StopService(hostDescriptorManager, "DescriptorManager");
        StopService(hostPositionManager, "PositionManager");
        StopService(hostEmployeeManager, "EmployeeManager");
    }

    static void StartService(SM.ServiceHost host, string serviceDescription)
    {
        host.Open();
        Console.WriteLine("Service {0} started", serviceDescription);

        foreach (var endpoint in host.Description.Endpoints)
        {
            Console.WriteLine("Listening on endpoints:");
            Console.WriteLine("Adress: {0}", endpoint.Address.Uri);
            Console.WriteLine("Binding: {0}", endpoint.Binding.Name);
            Console.WriteLine("Contract: {0}", endpoint.Contract.Name);
        }

        Console.WriteLine();
    }

    static void StopService(SM.ServiceHost host, string serviceDescription)
    {
        host.Close();
        Console.WriteLine("Service {0} stopped.", serviceDescription);
    }
}

I'd also like to have some composition and DI (I'm using MEF to compose the whole app) and thus I have my entities (descriptors included) in a separate assembly that I load. Therefore having "KnownType" directly hard coded in my classes and interfaces would just not work.

So I tried following this example from MSDN and write the known types in a config file (that I can change later and so maintain my composition). Following a part of the config in which I'm trying to add the JobCode descriptor as KnownType.

<system.runtime.serialization>
<dataContractSerializer>
  <declaredTypes>
    <add type="Core.Common.Contracts.IDescriptorEntity,Core.Common.Contracts">
      <knownType type="XXXX.Business.Entities.JobCode,XXXX.Business.Entities"/>
    </add>
  </declaredTypes>
</dataContractSerializer>

Yet when I try to run the host I get again the "Open Generics" error at the first method of the IDescriptorService interface.

What am I doing wrong?

Answer 1

One solution would be to have a specific manager for each of them but that would definitely break maintainability due to the number of descriptors

And really that's the correct solution. A WCF Service has to have a contract that tells the client the shape of the entity to expect. You write a T4 Template to generate all the Service Contracts and Service Classes.

Stepping back, having web services for CRUD on your entities isn't a really good practice. You're generally better off accessing the entity model directly, rather than across web services. It's obviously much simpler, and performs much better. And accessing your entities across web services doesn't really accomplish anything useful.