WCF: Für welchen Eigenschaftstyp muss ich SetLink aufrufen

Question

Ich möchte eine wirklich generische Klasse erstellen, um Objekte in einem WCF-Dienst zu speichern. Ich bekomme ein beliebiges Objekt und analysiere die Objekteigenschaften durch Reflektion. Wenn ich das Objekt in den Service-Kontext speichere, muss ich wissen, ob ich die SetLink(...) Methode der DataServiceContext für eine Eigenschaft aufrufen muss oder nicht.

Daher brauche ich eine Methode um herauszufinden, ob ich SetLink(...) anrufen muss oder nicht. Ich habe bereits versucht, es selbst zu tun:

private bool IsLinkedProperty(PropertyInfo propertyInfo) 
{ 
    return (propertyInfo != null) && propertyInfo.PropertyType.IsClass; 
} 

Aber diese Funktion funktioniert nicht für String-Eigenschaften und vielleicht auch für andere. Hat jemand dafür eine passende Funktion?

Answer 1

Ich endete mit der folgenden Lösung. Ich fand einen Hinweis in der qestion of Nathan Ridley:

/// <summary> 
/// Helper class for analyzing a type. 
/// </summary> 
public static class TypeAnalyzer 
{ 
    /// <summary> 
    /// Calculates if the given type is a "simple" type. 
    /// </summary> 
    /// <param name="type">Type to be checked for simplicity.</param> 
    /// <returns>True, if the type is "simple";false otherwise.</returns> 
    /// <remarks> 
    /// The following types are assumed to be simple: 
    /// <list type="*"> 
    ///  <item>string</item> 
    ///  <item>int</item> 
    ///  <item>decimal</item> 
    ///  <item>float</item> 
    ///  <item><see cref="StringComparison"/> (enum type)</item> 
    ///  <item>int? (nullable simple types)</item> 
    /// </list> 
    /// The following types are not simple: 
    /// <list type="*"> 
    ///  <item>Point (struct)</item> 
    ///  <item>Point? (nullable struct)</item> 
    ///  <item>StringBuilder (class)</item> 
    /// </list> 
    /// </remarks> 
    public static bool IsSimple(this Type type) 
    { 
     if (IsNullableType(type)) 
      return IsNestedTypeSimple(type); 

     return type.IsPrimitive 
      || type.IsEnum 
      || type.Equals(typeof(string)) 
      || type.Equals(typeof(decimal)) 
      || type.Equals(typeof(DateTime)) 
      || type.Equals(typeof(Guid)); 
    } 

    private static bool IsNestedTypeSimple(Type type) 
    { 
     var nestedType = Nullable.GetUnderlyingType(type); 
     return IsSimple(nestedType); 
    } 

    private static bool IsNullableType(Type type) 
    { 
     return Nullable.GetUnderlyingType(type) != null; 
    } 
} 

Testfälle geschrieben in NUnit sind:

[TestFixture] 
public class TypeAnalyzerTests 
{ 
    [TestCase(typeof(string), true)] 
    [TestCase(typeof(int), true)] 
    [TestCase(typeof(decimal), true)] 
    [TestCase(typeof(float), true)] 
    [TestCase(typeof(StringComparison), true)] 
    [TestCase(typeof(int?), true)] 
    [TestCase(typeof(decimal?), true)] 
    [TestCase(typeof(StringComparison?), true)] 
    [TestCase(typeof(object), false)] 
    [TestCase(typeof(Point), false)] 
    [TestCase(typeof(Point?), false)] 
    [TestCase(typeof(StringBuilder), false)] 
    [TestCase(typeof(DateTime), true)] 
    [TestCase(typeof(Guid), true)] 
    [TestCase(typeof(Guid?), true)] 
    public void IsSimple_WhenCalledForType_ReturnsExpectedResult(Type type, bool expectedResult) 
    { 
     var isSimple = TypeAnalyzer.IsSimple(type); 

     Assert.That(isSimple, Is.EqualTo(expectedResult)); 
    } 
} 

Schließlich änderte ich die in der Anfrage genannten Methode:

private bool IsLinkedProperty() 
{ 
    return (_propertyInfo != null) && !_propertyInfo.PropertyType.IsSimple(); 
}