c# - 如何在 WCF 中将 Noda Time(或任何第三方类型)对象作为参数传递？

Question

我有一个在 OperationContract 参数中使用 Noda Time 类型(LocalDate 和 ZonedDateTime)的服务，但是当我尝试发送例如 LocalDate(1990,7 ,31) 服务器接收到一个具有默认值 (1970/1/1) 的对象。客户端或服务器不会抛出任何错误。

以前它与相应的 BCL 类型 (DateTimeOffset) 配合得很好。我知道 WCF 可能不“知道”Noda Time 类型，但我不知道应该如何添加它们。我检查了 this page in the documentation about known types , 但它没有帮助。

有什么方法可以避免从 BCL 类型到 BCL 类型的肮脏(并且可能不完整)手动转换/序列化？

谢谢。

Answer 1

感谢 Aron 的建议，我能够想出一个 IDataContractSurrogate 的实现，这对于通过 WCF 传递非基本类型的对象非常有帮助(不仅是 Noda Time)。

有兴趣的 friend ，这里有完整的代码和解释，支持LocalDate、LocalDateTime和ZonedDateTime。序列化方式当然可以根据需要定制，比如使用Json.NET序列化，我的简单实现是不会序列化年历信息的。

或者，我已经在这个要点上发布了完整的代码:https://gist.github.com/mayerwin/6468178 .

首先，负责序列化/转换为基类型的帮助类:

public static class DatesExtensions {
    public static DateTime ToDateTime(this LocalDate localDate) {
        return new DateTime(localDate.Year, localDate.Month, localDate.Day);
    }

    public static LocalDate ToLocalDate(this DateTime dateTime) {
        return new LocalDate(dateTime.Year, dateTime.Month, dateTime.Day);
    }

    public static string Serialize(this ZonedDateTime zonedDateTime) {
        return LocalDateTimePattern.ExtendedIsoPattern.Format(zonedDateTime.LocalDateTime) + "@O=" + OffsetPattern.GeneralInvariantPattern.Format(zonedDateTime.Offset) + "@Z=" + zonedDateTime.Zone.Id;
    }

    public static ZonedDateTime DeserializeZonedDateTime(string value) {
        var match = ZonedDateTimeRegex.Match(value);
        if (!match.Success) throw new InvalidOperationException("Could not parse " + value);
        var dtm = LocalDateTimePattern.ExtendedIsoPattern.Parse(match.Groups[1].Value).Value;
        var offset = OffsetPattern.GeneralInvariantPattern.Parse(match.Groups[2].Value).Value;
        var tz = DateTimeZoneProviders.Tzdb.GetZoneOrNull(match.Groups[3].Value);
        return new ZonedDateTime(dtm, tz, offset);
    }

    public static readonly Regex ZonedDateTimeRegex = new Regex(@"^(.*)@O=(.*)@Z=(.*)$");
}

然后是包含序列化数据的 ReplacementType 类(序列化应该只存储 WCF 序列化程序已知的类型)并且可以通过 WCF 传递:

public class ReplacementType {
    [DataMember(Name = "Serialized")]
    public object Serialized { get; set; }
    [DataMember(Name = "OriginalType")]
    public string OriginalTypeFullName { get; set; }
}

序列化/反序列化规则包装在 Translator 泛型类中以简化向代理项添加规则(只有一个代理项分配给服务端点，因此它应该包含所有必要的规则):

public abstract class Translator {
    public abstract object Serialize(object obj);
    public abstract object Deserialize(object obj);
}

public class Translator<TOriginal, TSerialized> : Translator {
    private readonly Func<TOriginal, TSerialized> _Serialize;

    private readonly Func<TSerialized, TOriginal> _Deserialize;

    public Translator(Func<TOriginal, TSerialized> serialize, Func<TSerialized, TOriginal> deserialize) {
        this._Serialize = serialize;
        this._Deserialize = deserialize;
    }

    public override object Serialize(object obj) {
        return new ReplacementType { Serialized = this._Serialize((TOriginal)obj), OriginalTypeFullName = typeof(TOriginal).FullName };
    }

    public override object Deserialize(object obj) {
        return this._Deserialize((TSerialized)obj);
    }
}

最后是代理类，每个翻译规则都可以很容易地添加到静态构造函数中:

public class CustomSurrogate : IDataContractSurrogate {
    /// Type.GetType only works for the current assembly or mscorlib.dll
    private static readonly Dictionary<string, Type> AllLoadedTypesByFullName = AppDomain.CurrentDomain.GetAssemblies().SelectMany(a => a.GetTypes()).Distinct().GroupBy(t => t.FullName).ToDictionary(t => t.Key, t => t.First());

    public static Type GetTypeExt(string typeFullName) {
        return Type.GetType(typeFullName) ?? AllLoadedTypesByFullName[typeFullName];
    }

    private static readonly Dictionary<Type, Translator> Translators;
    static CustomSurrogate() {
        Translators = new Dictionary<Type, Translator> {
            {typeof(LocalDate), new Translator<LocalDate, DateTime>(serialize: d => d.ToDateTime(), deserialize: d => d.ToLocalDate())},
            {typeof(LocalDateTime), new Translator<LocalDateTime, DateTime>(serialize:  d => d.ToDateTimeUnspecified(), deserialize: LocalDateTime.FromDateTime)},
            {typeof(ZonedDateTime), new Translator<ZonedDateTime, string> (serialize: d => d.Serialize(), deserialize: DatesExtensions.DeserializeZonedDateTime)}
        };
    }

    public Type GetDataContractType(Type type) {
        if (Translators.ContainsKey(type)) {
            type = typeof(ReplacementType);
        }
        return type;
    }

    public object GetObjectToSerialize(object obj, Type targetType) {
        Translator translator;
        if (Translators.TryGetValue(obj.GetType(), out translator)) {
            return translator.Serialize(obj);
        }
        return obj;
    }

    public object GetDeserializedObject(object obj, Type targetType) {
        var replacementType = obj as ReplacementType;
        if (replacementType != null) {
            var originalType = GetTypeExt(replacementType.OriginalTypeFullName);
            return Translators[originalType].Deserialize(replacementType.Serialized);
        }
        return obj;
    }

    public object GetCustomDataToExport(MemberInfo memberInfo, Type dataContractType) {
        throw new NotImplementedException();
    }

    public object GetCustomDataToExport(Type clrType, Type dataContractType) {
        throw new NotImplementedException();
    }

    public void GetKnownCustomDataTypes(Collection<Type> customDataTypes) {
        throw new NotImplementedException();
    }

    public Type GetReferencedTypeOnImport(string typeName, string typeNamespace, object customData) {
        throw new NotImplementedException();
    }

    public CodeTypeDeclaration ProcessImportedType(CodeTypeDeclaration typeDeclaration, CodeCompileUnit compileUnit) {
        throw new NotImplementedException();
    }
}

现在要使用它，我们定义一个名为 SurrogateService 的服务:

[ServiceContract]
public interface ISurrogateService {
    [OperationContract]
    Tuple<LocalDate, LocalDateTime, ZonedDateTime> GetParams(LocalDate localDate, LocalDateTime localDateTime, ZonedDateTime zonedDateTime);
}

public class SurrogateService : ISurrogateService {
    public Tuple<LocalDate, LocalDateTime, ZonedDateTime> GetParams(LocalDate localDate, LocalDateTime localDateTime, ZonedDateTime zonedDateTime) {
        return Tuple.Create(localDate, localDateTime, zonedDateTime);
    }
}

要在同一台机器上完全独立地运行客户端和服务器(在控制台应用程序中)，我们只需将以下代码添加到静态类并调用函数 Start ():

public static class SurrogateServiceTest {
    public static void DefineSurrogate(ServiceEndpoint endPoint, IDataContractSurrogate surrogate) {
        foreach (var operation in endPoint.Contract.Operations) {
            var ob = operation.Behaviors.Find<DataContractSerializerOperationBehavior>();
            ob.DataContractSurrogate = surrogate;
        }
    }

    public static void Start() {
        var baseAddress = "http://" + Environment.MachineName + ":8000/Service";
        var host = new ServiceHost(typeof(SurrogateService), new Uri(baseAddress));
        var endpoint = host.AddServiceEndpoint(typeof(ISurrogateService), new BasicHttpBinding(), "");
        host.Open();
        var surrogate = new CustomSurrogate();
        DefineSurrogate(endpoint, surrogate);

        Console.WriteLine("Host opened");

        var factory = new ChannelFactory<ISurrogateService>(new BasicHttpBinding(), new EndpointAddress(baseAddress));
        DefineSurrogate(factory.Endpoint, surrogate);
        var client = factory.CreateChannel();
        var now = SystemClock.Instance.Now.InUtc();
        var p = client.GetParams(localDate: now.Date, localDateTime: now.LocalDateTime, zonedDateTime: now);

        if (p.Item1 == now.Date && p.Item2 == now.LocalDateTime && p.Item3 == now) {
            Console.WriteLine("Success");
        }
        else {
            Console.WriteLine("Failure");
        }
        ((IClientChannel)client).Close();
        factory.Close();

        Console.Write("Press ENTER to close the host");
        Console.ReadLine();
        host.Close();
    }
}

瞧! :)