无法将“ MyClass”转换为“ MyClass”

Question

I am trying to create a Stub class for Unit Testing purposes. The Stub points to the EXACT SAME EmployeeData class definition, but the compiler thinks they are different, somehow. As a result I keep getting the following message:

Cannot implicitly convert type 'MeasurementContracts.Business.Services.EmployeeData' to 'EmployeeData'

• There ARE NO OTHER definitions for 'EmployeeData'
• For some reason it "thinks" there are 2

What would cause this?

THE CLASS LOOKS LIKE:

namespace MeasurementContracts.Business.Services
{
    /// <summary>A data service model</summary>
    public class EmployeeData
    {
        public int EmployeeId { get; set; }

        public string FirstName { get; set; }

        public string LastName { get; set; }

        public string MiddleName { get; set; }

        public string EmailAddress { get; set; }

        public string KnownAs { get; set; }

        public string Login { get; set; }

        public string DomainName { get; set; }

        public string EmployeeStatusName { get; set; }

        public string WorkNumber { get; set; }

        public string SystemPersonType { get; set; }

        public string PersonType { get; set; }

        public string CellPhoneNumber { get; set; }

        public string OrganizationOrCostCenter { get; set; }

        public string OrganizationalLevel1Description { get; set; }

        public string PositionName { get; set; }

        public int SupervisorId { get; set; }

        public string GetName(bool useKnowAs = true)
        {
            if (useKnowAs && !string.IsNullOrWhiteSpace(this.KnownAs))
                return $"{this.KnownAs} {this.LastName}";

            return $"{this.FirstName} {this.LastName}";
        }

    }
}

THE STUB LOOKS LIKE:

namespace MeasurementContracts.UnitTests
{
    using OData.Client;
    using MeasurementContracts.Business.Services;
    using System;
    using System.Collections.Generic;
    using System.Linq;

    /// <summary>A proxy stub</summary>
    public class ODataProxyStub : ODataProxy
    {
        #region <Constructors>

        public ODataProxyStub()
        {
            Entities = new List<EmployeeData>();
        }

        #endregion

        #region <Properties>

        public List<EmployeeData> Entities { get; set; }

        #endregion

        #region <Properties>

        public override EmployeeData GetItem<EmployeeData>(string query)
        {
            // This is NOT working?
            return Entities.FirstOrDefault();
        }

        public override IEnumerable<EmployeeData> GetList<EmployeeData>(string query)
        {
            throw new NotImplementedException();
        }

        public override EmployeeData Post<EmployeeData>(string query, IEnumerable<object> parameters)
        {
            throw new NotImplementedException();
        }

        #endregion
    }
}

THE PROXY BASE LOOKS LIKE:

namespace OData.Client
{
    public class ODataProxy
    {
        protected readonly HttpClient Client;

        public ODataProxy();

        public string BaseUrl { get; set; }

        public virtual T GetItem<T>(string query);
        public virtual IEnumerable<T> GetList<T>(string query);
        public virtual T Post<T>(string query, IEnumerable<object> parameters);
    }
}

Answer 1

Actually it doesn't refer to the same class at all. In fact, the second EmployeeData doesn't refer to any class. It's the name of the generic.

Your ODataProxy defines a method:

public virtual IEnumerable<T> GetList<T>(string query);

which the ODataProxyStub implements using:

public override IEnumerable<EmployeeData> GetList<EmployeeData>(string query)

This is not a specialized version for the EmployeeData type (something C# doesn't support), but you simply renamed T to EmployeeData .

Thus the compiler thinks that the generic template parameter EmployeeData can't be converted to the concrete class EmployeeData which is of course correct.

---

What you might have intended is:

class ODataProxy<T>
{
    public virtual IEnumerable<T> GetList(string query)
    {
    }
}

class ODataProxyStub : ODataProxy<EmployeeData>
{
    public override IEnumerable<EmployeeData> GetList(string query)
    {
    }
}

---

LINQpad example to reproduce the issue:

class Data
{
}

class Proxy
{
    public virtual T Get<T>()
    {
        return default(T);
    }
}

class Stub : Proxy
{
    private Data x = default(Data);

    public override Data Get<Data>()
    {
        return x;
    }
}

Cannot implicitly convert type 'UserQuery.Data' to 'Data'