Perché la serializzazione viene eseguita quando si utilizza LocalChannel in WCF?

Question

Esiste un esempio WCF denominato LocalChannel fornito da Microsoft per mostrare come implementare un'associazione personalizzata per evitare un sovraccarico non necessario quando si chiama un servizio nello stesso ApplicationDomain. E 'la descrizione del campione si afferma che:

Questo è utile per scenari in cui il client e il servizio sono in esecuzione nello stesso dominio applicazione e l'overhead del tipico pila canale WCF (serializzazione e deserializzazione di messaggi) devono essere evitato.

Ho usato questo codice nel mio progetto, ma nonostante il reclamo sembra che la serializzazione abbia luogo quando viene chiamato un servizio.

Per rendere più chiaro, ho modificato il codice nel seguente modo per utilizzare un contratto dati, in modo che possa essere facilmente determinato se la serializzazione viene eseguita o meno.

# region Service Contract 

[ServiceContract] 
public interface IGetPrice 
{ 
    [OperationContract] 
    ProductDTO GetPriceForProduct(int productCode); 
} 


[DataContract] 
public class ProductDTO 
{ 
    private string _price; 

    public ProductDTO(string price) 
    { 
     _price = price; 
    } 

    #region Overrides of Object 

    public override string ToString() 
    { 
     return string.Format("Price = '{0}'", _price); 
    } 

    #endregion 

    [DataMember] 
    public string Price 
    { 
     get { return _price; } 
     set { _price = value; } 
    } 
} 

public class GetPrice : IGetPrice 
{ 
    #region IGetPrice Members 

    public ProductDTO GetPriceForProduct(int productId) 
    { 
     return new ProductDTO((String.Format("The price of product Id {0} is ${1}.", 
              productId, new Random().Next(50, 100)))); 
    } 

    #endregion 
} 

# endregion 



internal class Program 
{ 
    private static void Main(string[] args) 
    { 
     var baseAddress = "net.local://localhost:8080/GetPriceService"; 

     // Start the service host 
     var host = new ServiceHost(typeof (GetPrice), new Uri(baseAddress)); 
     host.AddServiceEndpoint(typeof (IGetPrice), new LocalBinding(), ""); 
     host.Open(); 
     Console.WriteLine("In-process service is now running...\n"); 

     // Start the client 
     var channelFactory 
      = new ChannelFactory<IGetPrice>(new LocalBinding(), baseAddress); 
     var proxy = channelFactory.CreateChannel(); 

     // Calling in-process service 
     var priceForProduct = proxy.GetPriceForProduct(101); 
     Console.WriteLine("Calling in-process service to get the price of product Id {0}: \n\t {1}" 
          , 101, priceForProduct); 
     Console.WriteLine("Calling in-process service to get the price of product Id {0}: \n\t {1}" 
          , 202, proxy.GetPriceForProduct(202)); 
     Console.WriteLine("Calling in-process service to get the price of product Id {0}: \n\t {1}" 
          , 303, proxy.GetPriceForProduct(303)); 

     Console.WriteLine("\nPress <ENTER> to terminate..."); 
     Console.ReadLine(); 
    } 
} 

L'esecuzione di questo codice indica che la proprietà di 'prezzo' classe 'ProductDTO' è essere serializzato e deserializzato durante le chiamate via localbinding!

Qualcuno ha utilizzato questo metodo prima o sa se qualcosa non va?

Answer 1

Con l'aggiunta di callback, posso confermare che in effetti la serializzazione/deserializzazione è sicuramente accadendo:

[OnSerializing] 
internal void OnSerializing(StreamingContext context) { 
    Console.WriteLine("OnSerializing"); 
} 
[OnSerialized] 
internal void OnSerialized(StreamingContext context) { 
    Console.WriteLine("OnSerialized"); 
} 
[OnDeserializing] 
internal void OnDeserializing(StreamingContext context) { 
    Console.WriteLine("OnDeserializing"); 
} 
[OnDeserialized] 
internal void OnDeserialized(StreamingContext context) { 
    Console.WriteLine("OnDeserialized"); 
} 

Ciò suggerisce a me una delle diverse possibilità:

• che si accingono a preservare la copy- semantica che normalmente vedresti in WCF, con client e server che guardano diverse copie
• semplicemente non funziona
• il do documen tazione è sbagliato

Dato che la dichiarazione here dice:

Questo è utile per scenari in cui il client e il servizio sono in esecuzione nello stesso dominio applicazione e l'overhead dello stack tipico canale WCF (serializzazione e deserializzazione dei messaggi) devono essere evitati.

Io invece sospetto che quella di mezzo, vale a dire chi ha scritto il campione assunto si stava lavorando, senza realmente verificare se la serializzazione stava accadendo.

Tuttavia! Potrebbe anche essere che fosse inteso tagliare alcune parti dello stack dello stack (principalmente, lo stack di I/O), ma chiunque abbia scritto la pagina di documentazione non ha capito bene e ha dichiarato erroneamente che anche la serializzazione è stata omessa.