在实体版本 6 的 WCF 中使用“include”语法时，复杂对象不会返回

好吧，这让我很困惑，因为我刚刚看到我的客户端在返回带有“include”的对象时基本上断开连接并终止。然而，如果没有 WCF 服务，它也可以正常工作。问题是我真的希望通过导航设置那些连接的对象。

基本上，代码是一个复杂的对象返回：

public teCIF getCif(int aCifId)
        {
            using (CIFContainer context = GetCifContext())
            {
                var thing = context.teCIFs
                    .Include("Product_TYPE")
                    .FirstOrDefault(i => i.CIF_ID == aCifId);

                return thing;
            }
        }

现在奇怪的是，当我注释掉 include 语句时，这会工作得很好。就像通过 WCF 服务发送的复杂类型不喜欢包含语句一样，只是说：“不，不会那样做”。

作为参考，我已经对我的复杂对象进行了相当多的修改，因为它是从数据库（缩写）中生成的 T4 对象：

[Serializable]
    public partial class teCIF
    {
        public int CIF_ID { get; set; }
        public string CUSTOMER_NAME { get; set; }
        public string SITE_NAME { get; set; }
        [System.Xml.Serialization.XmlIgnore]
        public int PRODUCT_TYPE_ID { get; set; }

        public virtual tlPRODUCT_TYPE Product_TYPE { get; set; }
    }

链接复杂项目的更新：

[Serializable]
public partial class tlPRODUCT_TYPE
{
    public tlPRODUCT_TYPE()
    {
        this.teCIFs = new HashSet<teCIF>();
    }

    [System.Xml.Serialization.XmlIgnore]
    public int PRODUCT_TYPE_ID { get; set; }
    public string VALUE { get; set; }

    [System.Xml.Serialization.XmlIgnore]
    public virtual ICollection<teCIF> teCIFs { get; set; }
}

我已尝试删除属性，但尚未弄乱 WCF 喜欢的“数据成员”类型。我只是不明白为什么这不起作用，因为我发誓我在过去的实体版本 4 中已经使用具有与其他复杂类型相关的导航属性的复杂类型完成了此操作。

好吧，我实际上得到了一位朋友的帮助，但我认为这可能会出现在其他人身上，所以我应该回答这个问题，因为它可能会帮助其他人。我必须添加一个自定义属性，我为其创建一个类来确定循环引用。基本上，在使用 WCF 时，导航的指针会以某种方式丢失，但在未连接到服务时却很好。这不好，因为我希望我的服务使用 WCF 托管方法，而不仅仅是直接使用 Entity V6 进行客户端调用。

    [ServiceContract]
    public interface ICifService
    {

        [OperationContract]
        [CyclicReferencesAware(true)]
        teCIF getCif(int aCifId);
    }

实现类的工作原理如下：

    using System;
    using System.ServiceModel;
    using System.ServiceModel.Description;
    using System.Runtime.Serialization;
    using System.Xml;
    using System.Collections.Generic;

    [AttributeUsage(AttributeTargets.Interface | AttributeTargets.Method)]
    public class CyclicReferencesAwareAttribute : Attribute, IContractBehavior, IOperationBehavior
    {
        private readonly bool _on = true;

        public CyclicReferencesAwareAttribute(bool on)
        {
            _on = on;
        }

        public bool On
        {
            get { return _on; }
        }

        #region IOperationBehavior Members

        void IOperationBehavior.AddBindingParameters(OperationDescription operationDescription, System.ServiceModel.Channels.BindingParameterCollection bindingParameters)
        {
        }

        void IOperationBehavior.ApplyClientBehavior(OperationDescription operationDescription, System.ServiceModel.Dispatcher.ClientOperation clientOperation)
        {
            CyclicReferencesAwareContractBehavior.ReplaceDataContractSerializerOperationBehavior(operationDescription, On);
        }

        void IOperationBehavior.ApplyDispatchBehavior(OperationDescription operationDescription, System.ServiceModel.Dispatcher.DispatchOperation dispatchOperation)
        {
            CyclicReferencesAwareContractBehavior.ReplaceDataContractSerializerOperationBehavior(operationDescription, On);
        }

        void IOperationBehavior.Validate(OperationDescription operationDescription)
        {
        }

        #endregion

        #region IContractBehavior Members

        void IContractBehavior.AddBindingParameters(ContractDescription contractDescription, ServiceEndpoint endpoint, System.ServiceModel.Channels.BindingParameterCollection bindingParameters)
        {
        }

        void IContractBehavior.ApplyClientBehavior(ContractDescription contractDescription, ServiceEndpoint endpoint, System.ServiceModel.Dispatcher.ClientRuntime clientRuntime)
        {
            CyclicReferencesAwareContractBehavior.ReplaceDataContractSerializerOperationBehaviors(contractDescription, On);
        }

        void IContractBehavior.ApplyDispatchBehavior(ContractDescription contractDescription, ServiceEndpoint endpoint, System.ServiceModel.Dispatcher.DispatchRuntime dispatchRuntime)
        {
            CyclicReferencesAwareContractBehavior.ReplaceDataContractSerializerOperationBehaviors(contractDescription, On);
        }

        void IContractBehavior.Validate(ContractDescription contractDescription, ServiceEndpoint endpoint)
        {
        }

        #endregion
    }

    public class CyclicReferencesAwareContractBehavior : IContractBehavior
    {
        private const int MaxItemsInObjectGraph = 2147483647;
        private const bool IgnoreExtensionDataObject = false;

        private bool _on;

        public CyclicReferencesAwareContractBehavior(bool on)
        {
            _on = on;
        }

        #region IContractBehavior Members

        public void AddBindingParameters(ContractDescription contractDescription, ServiceEndpoint endpoint, System.ServiceModel.Channels.BindingParameterCollection bindingParameters)
        {
        }

        public void ApplyClientBehavior(ContractDescription contractDescription, ServiceEndpoint endpoint, System.ServiceModel.Dispatcher.ClientRuntime clientRuntime)
        {
            ReplaceDataContractSerializerOperationBehaviors(contractDescription, _on);
        }

        public void ApplyDispatchBehavior(ContractDescription contractDescription, ServiceEndpoint endpoint, System.ServiceModel.Dispatcher.DispatchRuntime dispatchRuntime)
        {
            ReplaceDataContractSerializerOperationBehaviors(contractDescription, _on);
        }

        public void Validate(ContractDescription contractDescription, ServiceEndpoint endpoint)
        {
        }

        internal static void ReplaceDataContractSerializerOperationBehaviors(ContractDescription contractDescription, bool on)
        {
            foreach (var operation in contractDescription.Operations)
            {
                ReplaceDataContractSerializerOperationBehavior(operation, on);
            }
        }

        internal static void ReplaceDataContractSerializerOperationBehavior(OperationDescription operation, bool on)
        {
            if (operation.Behaviors.Remove(typeof(DataContractSerializerOperationBehavior)) || operation.Behaviors.Remove(typeof(ApplyCyclicDataContractSerializerOperationBehavior)))
            {
                operation.Behaviors.Add(new ApplyCyclicDataContractSerializerOperationBehavior(operation, MaxItemsInObjectGraph, IgnoreExtensionDataObject, on));
            }
        }
        #endregion
    }

    internal class ApplyCyclicDataContractSerializerOperationBehavior : DataContractSerializerOperationBehavior
    {
        private readonly int _maxItemsInObjectGraph;
        private readonly bool _ignoreExtensionDataObject;
        private readonly bool _preserveObjectReferences;

        public ApplyCyclicDataContractSerializerOperationBehavior(OperationDescription operationDescription, int maxItemsInObjectGraph, bool ignoreExtensionDataObject, bool preserveObjectReferences)
            : base(operationDescription)
        {
            _maxItemsInObjectGraph = maxItemsInObjectGraph;
            _ignoreExtensionDataObject = ignoreExtensionDataObject;
            _preserveObjectReferences = preserveObjectReferences;
        }

        public override XmlObjectSerializer CreateSerializer(Type type, string name, string ns, IList<Type> knownTypes)
        {
            return new DataContractSerializer(type, name, ns, knownTypes, _maxItemsInObjectGraph, _ignoreExtensionDataObject, _preserveObjectReferences, null /*dataContractSurrogate*/);
        }

        public override XmlObjectSerializer CreateSerializer(Type type, XmlDictionaryString name, XmlDictionaryString ns, IList<Type> knownTypes)
        {
            return new DataContractSerializer(type, name, ns, knownTypes, _maxItemsInObjectGraph, _ignoreExtensionDataObject, _preserveObjectReferences, null /*dataContractSurrogate*/);
        }
    }

一旦我将此属性应用于我的服务界面中的任何操作，它对于任何复杂类型都可以正常工作。