Welcome to the Lounge

Quote:

It is efficient by default and guarantees that no implicit conversions (including narrowing conversions), temporary objects, or wrapper indirections will occur. In particular, prefer using auto instead of function<> to name lambdas unless you need the type erasure and indirection.

public class T1 {
    int m_count;

    public T1(int cnt) 
    {
        m_count = cnt;
    }

    public static implicit operator T2(T1 t1) {
        return new T2(t1.m_count.ToString());
    }
}

public class T2 {
    string m_count;
    public T2(string count) {
        m_count = count;
    }
}

public class Class1
{
    T1 GenerateValue() {
        return new T1(22);
    }

    void temp() {
        
        // The following creates an instance of T1, converts it to T2 and 
        // leaves T1 for the GC to clean up.
        // Is it clear to a developer that they just created this overhead?
        T2 t2_implicit = GenerateValue();

        // The following creates and holds an instance of T1
        T1 t1_explicit = GenerateValue();

        // The following also creates and holds an instance of T1
        var t1_implicit = GenerateValue();
    }
}

Quote:

Although I haven't used C#, I'd be surprised if best practices for when to use the heap versus the stack weren't the same in both languages.