Partial objects

[ssougnez]

Hello,

first of all, sorry if this has already been proposed (I did a search and didn't find anything) or if it already exists in C#.

Use case

I'm using the NEST NuGet to interact with ElasticSearch. It exists a "Bulk" method used to update several documents in one go. The class used to represent a document in ES is the following:

public class Document
{
    public int Id { get; set; }
    public int ContributorId { get; set; }
    public DateTime CreatedAt { get; set; }
    public string Description { get; set; }
    public string Extension { get; set; }
    public bool IsLinked { get; set; }
    public string[] Keywords { get; set; }
    public string Language { get; set; }
    public string RawContent { get; set; }
    public string Path { get; set; }
    public int[] Processes { get; set; }
    public string Root { get; set; }
    public string Title { get; set; }
    public string Version { get; set; }
}

As you can see, there are "a lot of" properties and I have some use cases where I only want to update one of them for several documents. For example, if I delete a process, I'll have to update the "Processes" properties of each impacted document. There are two solutions for this. Either I fetch all the document properties and I execute the bulk request with all the properties or I used an anonymous object to only update the process, something like :

var partials = versionsProcesses.Select(kvp => new
{
    Id = kvp.Key,
    Processes = kvp.Value
});

And it works very well. However, the issue here is that, as I'm using an anonymous object, I can define whatever property names I want but it also includes typos. So I could have typed "Proceses" instead of "Processes" and the compiler wouldn't have complained about that. Or worse, maybe I have to renamed the "Document" class property "Processes" in "Procedures". In this case, I might miss the fact that I also have to change it in the anonymous object.

Proposal

Therefore, I thought that it would be pretty handy to be able to do something like this:

var partials = versionsProcesses.Select(kvp => new Partial<Document>
{
    Id = kvp.Key,
    Processes = kvp.Value
});

In this case, the fact that I'm using a partial "Document", the intellisense and the compiler would know the list of properties that I can define. However, at the end, it would generate an anonymous object with only these two properties because it simply created a "Document" object, all the properties that I didn't defined would be set to their default value and updated in Elastic Search, which I don't want.

Conclusion

In conclusion, I'd say that it could come pretty handy in specific situation to be able to define an anonymous objects that are a partial representation of an existing class.

[HaloFour]

In this case, the fact that I'm using a partial "Document", the intellisense and the compiler would know the list of properties that I can define. However, at the end, it would generate an anonymous object with only these two properties because it simply created a "Document" object, all the properties that I didn't defined would be set to their default value and updated in Elastic Search, which I don't want.

IMO sounds like a good use case for an analyzer.

[bernd5]

Yes, I'm not quite sure if we can write custom intelli-sense providers like analyzers - but right something like that must be written.

[333fred]

Yes, I'm not quite sure if we can write custom intelli-sense providers like analyzers - but right something like that must be written.

You can, though you'll have to ask @CyrusNajmabadi how to do it: all I know is that it's possible.

[ssougnez]

So it seems that a new syntaxic sugar is out of question ? :p

Something like

var x = new (Document) { ... }

By placing the class name between bracket, it could imply an anonymous object that can only contains a subset of the Document properties?

[bernd5]

But an attribute for anonymous objects could be an option.
So you could write new [FooBar] { Something = 4711 }

But what should happen with such an attribute? Only for analyzer usage? Or should it be placed on the generated class, too? And what happens if the attribute-sets of the anonymous type are different?

[ssougnez]

To be honest, I'm not familiar with analyzers nor the generated class for anonymous objects.

If I had to give my opinion, I'd say that this attribute should not have any impact on the generated code.
If I'm not wrong (but I surely am), classes are automatically generated based on the anonymous definition, so, according to me, such an attribute (if it is possible) should be used to help the development.

Basically, it should allow the intellisense to propose the available properties but also trigger build error if you use properties that don't belong to the type defined in the attribute.

It would basically be a bit like TypeScript where you define the types but at the end, types are not present in the resulting Javascript code.