wcf exponing generics

Question

Tengo una aplicación donde el cliente y el servidor comparten tipos, y la interoperabilidad no es una de nuestras preocupaciones. Estoy planeando tener un repositorio único para todos los objetos habilitados para la web, y estaba pensando en una interfaz genérica para mi servicio expuesto.

algo así como T GetObject (int id)

pero WCF no le gusta que desde su tratar de exponer su esquema (que realmente no importa)

es posible hacer tal cosa con WCF ?, puedo usar cualquier tipo de enlace no tiene que ser httpbinding o wsbinding ...

Answer 1

supongo que esto es posible, aunque no estoy seguro de que quieres esto. Tomaría el siguiente enfoque (no probado, no estoy seguro de si funciona).En primer lugar crear la siguiente estructura del proyecto en su solución:

• ServiceInterfaces
• ServiceImplementations (referencias ServiceInterfaces y ModelClasses)
• ModelClasses
• Host (Referencias ServiceInterfaces y ServiceImplementations)
• Client (referencias ServiceInterfaces y ModelClasses)

En ServiceInterfaces tiene una interfaz como esta (Me salté los espacios de nombres, etc., para que el ejemplo sea más corto):

[ServiceContract] 
public interface IMyService<T> 
{ 
    T GetObject(int id); 
} 

En ServiceImplementations tiene una clase que implementa IMyService<T>:

public class MyService<T> : IMyService<T> 
{ 
    T GetObject(int id) 
    { 
     // Create something of type T and return it. Rather difficult 
     // since you only know the type at runtime. 
    } 
} 

En Host tiene la configuración correcta para su servicio en un archivo App.config (o Web.config) y el siguiente código para alojar su servicio (dado que es una aplicación independiente) :

ServiceHost host = new ServiceHost(typeof(MessageManager.MessageManagerService)) 
host.Open(); 

Y finalmente en Client se utiliza una clase ChannelFactory<TChannel> para definir un proxy:

Binding binding = new BasicHttpBinding(); // For the example, could be another binding. 
EndpointAddress address = new EndpointAddress("http://localhost:8000/......"); 
IMyService<string> myService = 
    ChannelFactory<IMyService<string>>.CreateChannel(binding, address); 
string myObject = myService.GetObject(42); 

Una vez más, no estoy seguro de si esto funciona. El truco es compartir sus interfaces de servicio (en ServiceInterfaces) y los objetos del modelo de dominio (en ModelClasses) entre el host y el cliente. En mi ejemplo, uso una cadena para regresar del método de servicio, pero podría ser cualquier tipo de contrato de datos del proyecto ModelClasses.

Answer 2

No, no puedes. Ya sea que desee o necesite interoperabilidad, la base más básica de WCF es el intercambio de mensajes.

El cliente envía un mensaje al servidor y recibe una respuesta. Ese mensaje es todo lo que pasa entre el cliente y el servidor, y necesita ser serializable en un formato XML o binario. Es por eso que cualquier información que se transmita debe ser atómica (como int, cadena) o un DataContract: una descripción de la pila de servicios WCF sobre cómo serializar y deserializar dichos objetos.

No se puede pasar ninguna interfaz u otro "truco": todo lo que va entre el cliente y el servidor debe poder expresarse en un esquema XML, básicamente.

Así que me temo que lo que estás tratando de lograr es bastante contrario a lo que ofrece WCF. El mundo y los paradigmas de SOA (Aplicaciones orientadas a servicios) son bastante diferentes y no siempre están 100% sincronizados con la idea y los mecanismos de OOP.

Marc

Answer 3

PUEDE HACER eso si utiliza ServiceKnownTypesDiscovery.

Por ejemplo:

[ServiceKnownType("GetKnownTypes", typeof(ServiceKnownTypesDiscovery))] 
public interface ISomeService 
{ 
    [OperationContract] 
    object Request(IRequestBase parameters); 
} 

donde GetKnownTypes podría ser declarado como tal:

public static class ServiceKnownTypesDiscovery 
{ 
    public static IEnumerable<Type> GetKnownTypes(ICustomAttributeProvider provider) 
    { 
     var types = new List<Type>(); 

     foreach (var asmFile in Directory.GetFiles(AppDomain.CurrentDomain.RelativeSearchPath ?? AppDomain.CurrentDomain.BaseDirectory, "*.dll")) 
     { 
      Assembly asm = Assembly.LoadFrom(asmFile); 
      types.AddRange(asm.GetTypes().Where(p=> Attribute.IsDefined(p,typeof(DataContractAttribute)))); 
     } 

     return types; 
    } 
} 

En este caso todo lo declarado con [DataContract] (siempre y cuando se pueden descubrir en el servidor y el lado del cliente) se puede serializar.

¡Espero que haya sido útil!

Answer 4

Siguiendo el ejemplo anterior, puede declarar DataContract con un objeto como DataMember. Luego, podría agregar un método de extensión para obtener y establecer un tipo genérico en el miembro de datos del objeto. También podría hacer que esto sea interno, de esta manera estaría obligado a usar los métodos de extensión para obtener y establecer el valor.

Por supuesto, solo funciona si genera el cliente usando svcutil (o Visual Studio) y hace referencia al conjunto que contiene el contrato de datos y la clase con los métodos de extensiones.

Espero que esto ayude ...