Using implicit operator generates a StackOverflowException

Thanks to @Gbianchi's comment, he got the error.

The error, in a nutshell, is that my class DocumentViewModel, in its implicit conversion, is expecting to return an object of type DocumentViewModel, when it is returning an object of type Document, then, when returning Document, the constructor it is exiting from is called, causing a loop unexpected, which is what triggers the exception.

To fix this, the implicit conversion should return DocumentViewModel, as follows:

public class DocumentViewModel
    {
        /// <summary>
        /// ID
        /// </summary>
        public string Id { get; set; } //se añade parámetro ID al documentViewModel, esto no estaba antes.
        
        /// <summary>
        /// implicit model
        /// </summary>
        /// <param name="document"></param>
        public static implicit operator DocumentViewModel(Document document)
        {
            return new DocumentViewModel //se cambia lo que se retorna al tipo correcto.
            {
                Id = document.Id,
            };
        }
    }

With this change, the program runs normally. Thank you very much for the help! :D

Let's try the following code on dotnetfiddle (it's just code to emulate the problem):

using System;

class Document
{
    public string Id { get; set; }
}

class DocumentViewModel
{
      public static implicit operator DocumentViewModel(Document document)
      {
           return new Document
           {
               Id = document.Id,
           };
      }
 }

public class Program
{
    public static void Main()
    {
        DocumentViewModel results;
        Document doc = new Document();
        results = doc; 
    }
}

When executing the program, it gives us the following result:

Stack overflow.
Repeat 130903 times:
--------------------------------
   at DocumentViewModel.op_Implicit(Document)
--------------------------------
   at Program.Main()
Command terminated by signal 6

With our intuition we can deduce that the problem is in this line but we do not have the slightest idea why a stack overflow is happening :

results = doc; 

To find out in more detail what is really going on, let's convert the C# code to IL code using SharpLab . Click on this link to see the IL code.

In the end we are only interested in this part of the generated IL code:

.class private auto ansi beforefieldinit DocumentViewModel
    extends [System.Private.CoreLib]System.Object
{
    // Methods
    .method public hidebysig specialname static 
        class DocumentViewModel op_Implicit (
            class Document document
        ) cil managed 
    {
        // Method begins at RVA 0x206c
        // Code size 29 (0x1d)
        .maxstack 3
        .locals init (
            [0] class DocumentViewModel
        )

        IL_0000: nop
        IL_0001: newobj instance void Document::.ctor()
        IL_0006: dup
        IL_0007: ldarg.0
        IL_0008: callvirt instance string Document::get_Id()
        IL_000d: callvirt instance void Document::set_Id(string)
        IL_0012: nop
        // El causante del error es esta línea:
        IL_0013: call class DocumentViewModel DocumentViewModel::op_Implicit(class Document) // Aquí sucede una recursión infinita, sin fin...
        IL_0018: stloc.0
        IL_0019: br.s IL_001b

        IL_001b: ldloc.0
        IL_001c: ret
    } // end of method DocumentViewModel::op_Implicit

We can translate the IL code above to C# to better understand what the compiler is doing:

class DocumentViewModel
{
      public static DocumentViewModel op_Implicit(Document document)
      {
          Document document2 = new Document();
          document2.set_Id(document.get_Id());
          return op_Implicit(document);
      }
 }

// Nuestro Main quedaría así
public class Program
{
    public static void Main()
    {
        DocumentViewModel results;
        Document doc = new Document();
        results = DocumentViewModel.op_Implicit(doc); // Aquí es donde empieza todo el problema..
    }
}

This is crazy! The truth is yes. The reason for the stack overflow is precisely because the method is being called op_Implicitrecursively without a base case.

The compiler generated this erroneous code due to programmer oversight, as they said in the comments, when overloading the operator, the method must return an object of type DocumentViewModel.

Following the corrections mentioned in Ronquillo 's response , the example code (the one that emulates the behavior of the problem) would look like this:

using System;

class Document
{
    public string Id { get; set; }
}

class DocumentViewModel
{
      public string Id { get; set; }
    
      public static implicit operator DocumentViewModel(Document document)
      {
           return new DocumentViewModel
           {
               Id = document.Id,
           };
      }
 }

By converting the above code to IL :

    .method public hidebysig specialname static 
        class DocumentViewModel op_Implicit (
            class Document document
        ) cil managed 
    {
        // Method begins at RVA 0x207c
        // Code size 24 (0x18)
        .maxstack 3
        .locals init (
            [0] class DocumentViewModel
        )

        IL_0000: nop
        IL_0001: newobj instance void DocumentViewModel::.ctor()
        IL_0006: dup
        IL_0007: ldarg.0
        IL_0008: callvirt instance string Document::get_Id()
        IL_000d: callvirt instance void DocumentViewModel::set_Id(string)
        IL_0012: nop
        // La recursión infinita desapareció... 
        IL_0013: stloc.0
        IL_0014: br.s IL_0016

        IL_0016: ldloc.0
        IL_0017: ret
    } // end of method DocumentViewModel::op_Implicit

Effectively, the compiler no longer generates any bad code. As you can see, the method op_Implicitdoes not call itself indefinitely. The stack overflow disappeared.

The above IL code can be better understood like this:

class DocumentViewModel
{
      public string Id { get; set; }

      public static DocumentViewModel op_Implicit(Document document)
      {
           DocumentViewModel documentViewModel = new DocumentViewModel();
           documentViewModel.Id = document.Id;
           return documentViewModel;
      }
 }

Now the code generated by the compiler makes sense and the program will work correctly.