Proposal: Allow Anonymous Type Implement Interface(s)

[Timothy-Liu]

using System;
using System.Linq;
using System.Collections.Generic;

namespace Proposal {

    interface IProduct {
        int Id { get; set; }
        string Name { get; set; }
    }

    class Record {
        public int RecordId { get; set; }
        public int SKU { get; set; }
        public string Name { get; set; }
        // other members ...
    }

    class Program {
        static void Main(string[] args) {
            var produtcs = new List<IProduct> { /*data from database*/ };
            var records = new List<Record> {/*data from database*/ };
            var products1 = records.Select(r => new { Id = r.SKU, Name = r.Name }); // current
            var products2 = records.Select(r => new IProduct { Id = r.SKU, Name = r.Name }); // proposal: lightweight anonymous type implements the interface, similar to Java
            produtcs.AddRange(products2); // benefit
        }
    }
}

[ufcpp]

#1542 #738 dotnet/roslyn#13 (comment)

[ackava]

@Timothy-Liu what is the benefit? Wherever you are writing interface, you can simply declare it as a class.

[snys98]

@Timothy-Liu what is the benefit? Wherever you are writing interface, you can simply declare it as a class.

There is still situation that you may want to combine two or more interfaces, but you can't inherit two classes!

[Spacefish]

Main benefit would be multi callback calls..

public interface IResultCallback {
   void OnSuccess(string result);
   void OnFailure(string failureReason);
}

Imagine a function like DoThings(string someInput, IResultCallback callback)

you could call it like this:

DoThings("myInput", new IResultCallback { 
   OnSuccess = (x) => { Console.WriteLine("yeay: " + x); },
  OnFailure = (fr) => {  Console.WriteLine("I failed...:" + fr); }
 });

[poke]

I would like to see this as well. My use case right now is MassTransit where the recommendation is to use interface types as message types:

It is strongly suggested to use interfaces for message contracts, based on experience over several years with varying levels of developer experience. MassTransit will create dynamic interface implementations for the messages, ensuring a clean separation of the message contract from the consumer. (source)

If you follow this, then you will find yourself often in a situation where you will have to do something like this:

await publishEndpoint.Publish<IOrderSubmitted>(new
{
    OrderId = "27",
    OrderDate = DateTime.UtcNow,
});

The anonymous type you pass there is supposed to be compatible to IOrderSubmitted. The message will be serialized and when it gets deserialized on the consuming end, then MassTransit will create a dynamic type implementing that interface.

So on the consumer side, you can totally work with interfaces only. Doing so on the producing side means that you will either have to create additional classes that don’t do anything other than implementing the interface, or you will have to deal with anonymous types. That has the drawback that you do not get any IntelliSense though which means that you will not get any validation of the properties.

Having an anonymous type that implements an interface would help this a lot, e.g.:

await publishEndpoint.Publish(new IOrderSubmitted
{
    OrderId = "27",
    OrderDate = DateTime.UtcNow,
});

[RemcoBlok]

You may like to check out this Roslyn analyzer I wrote to structurally compare an anonymous type with a message contract + code fix for adding properties from the message contract that are missing in the anonymous type: https://github.com/RemcoBlok/MessageContractAnalyzer

I also submitted a Pull Request to add this Roslyn analyzer to MassTransit, which was accepted. The Roslyn analyzer is now further developed by MassTransit and a NuGet package made available (still in prerelease at time of writing). See https://twitter.com/PhatBoyG/status/1235331842217332737

The use case extends beyond MassTransit as well. I use EventStore in a CQRS + Event Sourcing pattern and all events stored in EventStore are also defined as read-only interfaces that I initialize using anonymous types in combination with the Roslyn analyzer I wrote.

[GalaxiaGuy]

@Spacefish That callback example looks quite similar to some of the things discussed in #2517

[Spacefish]

@GalaxiaGuy well there are straight forward ways to do things.. This is the most obvious intuitive one IMHO.. Though in don´t agree with the generic interface that is implemented by a funciton and not a class in #2517 as this is already covered by delegates..

[Spongman]

@Timothy-Liu what is the benefit? Wherever you are writing interface, you can simply declare it as a class.

if that's the case, then why do we have anonymous classes? the same argument could be used to eliminate those...

[mkoppanen]

I am somewhat new to c# due to work circumstances and was surprised to find this is not a language level feature. Especially on callback driven code there is quick convolution of short dispatch handlers that could be better handled as anonymous interface implementations on caller side.