Support Cast/As for non enumerable properties

[dsidedp]

Consider the following

    public class BaseClass {}

    public class DerivedClass1 
    {
        public int DerivedProperty1 { get; set; }
    }

    public class DerivedClass2
    {
        public int DerivedProperty2 { get; set; }
    }

    public class SomeClass
    {
        public BaseClass Item { get; set; }
    }

As far as I understand, currently, it is not possible to filter List<SomeClass> based on SomeClass.Item derived class property value since there is no way to cast non-enumerable property SomeClass.Item to DerivedClass1 or DerivedClass2:

Please consider supporting Cast/As/Is for non-enumerable properties.

    var list = new List<SomeClass>(){.....};
    //cast function
    var result1 = list.Where("Cast(Item, DerivedClass1).DerivedProperty1 == str")
    //this should correspond to 
     var linq1 = list.Where(x=> ((DerivedClass1)x.Item).DerivedProperty1 == str)

    //as/is as operators or functions
    var result2 = list.Where("(Item as DerivedClass1).DerivedProperty1 == str")
    var result3 = list.Where("As(Item, DerivedClass1).DerivedProperty1 == str")
    var linq2 = list.Where(x=> (x.Item as DerivedClass1).DerivedProperty1 == str)

result1 and corresponding linq1 cases are very useful when parsed expression is passed to EF or other ORMs with inheritance support.

Thanks.

[StefH]

Hello @dsidedp , did you also investigate if the OfType functionality could help in this scenario?

See below links on how to use it:

• https://github.com/zzzprojects/System.Linq.Dynamic.Core/blob/9ca9b3428961ebb757e8e4129195486b9be5dddf/test/System.Linq.Dynamic.Core.Tests/QueryableTests.Is%2COfType%2CAs%2CCast.cs
• https://dynamic-linq.net/basic-query-operators#cast-and-oftype

[dsidedp]

OfType is applicable to enumerables only. As is applied to It but not to It.Property.

Maybe I miss something, but I was not able to cast property of it when property is not Enumerable.

[StefH]

@dsidedp
This is already implemented.

See this example:
https://github.com/zzzprojects/System.Linq.Dynamic.Core/blob/master/test/System.Linq.Dynamic.Core.Tests/QueryableTests.Is%2COfType%2CAs%2CCast.cs#L304

[dsidedp]

This is not the case.

In example you referred to, cast is applied to it to get access to it.DerivedProperty. And I'm talking about casting it.Property to get access to it.Property.DerivedProperty.

If it.Property is Enumerable, then OfType can be used. But there are no options if it.Property is an object.
Take a look at pseudo-code example provided in the first comment.

BTW, here is the similar issue #519

Here is the simple test for this case

    public void Test1()
    {
        // Assign
        var qry = new[]
        {
            new { Employee = (BaseEmployee)new Worker { Name = "1", Other = "x" }},
            new { Employee = (BaseEmployee)new Boss { Name = "2", Function = "y" }}
        }.AsQueryable();

        // Act
        var cast = qry.Count(x=>(x.Employee as Worker).Other == "x");
        var castDynamic = ????

        // Assert
        Check.That(cast).Equals(castDynamic);
    }

Or similar to one you referred to but for case when property is an object.

    public void Test2()
    {
        // Assign
        var qry = new[]
        {
            new { Employee = (BaseEmployee)new Worker { Name = "1", Other = "x" }},
            new { Employee = (BaseEmployee)new Boss { Name = "2", Function = "y" }}
        }.AsQueryable();

        // Act
        var cast = qry.Select(x=>(x.Employee is Worker) ? (x.Employee as Worker).Other : "-").ToArray();
        var castDynamic = ????

        // Assert
        Check.That(cast.Length).Equals(castDynamic.Length);
    }

[StefH]

@dsidedp
I understand.

This is not yet supported, but this can be added.

Would this syntax be ok?

        [Fact]
        public void IsAndCastToType_Dynamic_ActingOnProperty_And_GetProperty()
        {
            // Assign
            var qry = new []
            {
                new EmployeeWrapper { Employee = new Worker { Name = "1", Other = "x" } }, 
                new EmployeeWrapper { Employee = new Boss { Name = "2", Function = "y" } }
            }.AsQueryable();

            // Act
            var cast = qry.Select(c => c.Employee is Worker ? ((Worker) c.Employee).Other : "-").ToArray();
            var castDynamic = qry.Select("iif(Is(Employee, \"System.Linq.Dynamic.Core.Tests.Entities.Worker\"), Cast(Employee, \"System.Linq.Dynamic.Core.Tests.Entities.Worker\").Other, \"-\")").ToDynamicArray();

            // Assert
            Check.That(cast.Length).Equals(castDynamic.Length);
        }

[dsidedp]

Sure.

IMHO, that's the simplest and most obvious syntax. (assuming simple type resolution will be supported here)

[StefH]

simple type resolution will be supported with:

var config = new ParsingConfig
{
  ResolveTypesBySimpleName = true
};

[StefH]

A new version will be released soon.

#567

[dsidedp]

Thank you for the fast update.