C#

CREATE TABLE [dbo].[Persons]
(
    Id                          INT IDENTITY(1,1) PRIMARY KEY NOT NULL,
    RemoteId                    UNIQUEIDENTIFIER NOT NULL,
    ClientRepId                 INT NULL FOREIGN KEY (ClientRepId) REFERENCES Persons(Id),
    SupervisorId                INT NULL FOREIGN KEY (SupervisorId) REFERENCES Persons(Id),
    PersonType                  INT NOT NULL,
    Prefix                      INT NULL,
    FirstName                   VARCHAR(MAX),
    LastName                    VARCHAR(MAX),
    NickName                    VARCHAR(MAX),
    Suffix                      INT NULL,
    Title                       VARCHAR(MAX)
)

namespace CLOI.Entities
{
    public class PersonEntity : _EntityBase
    {
        private PersonType _PersonType;
        public PersonType PersonType
        {
            get { return _PersonType; }
            set
            {
                SetProperty<PersonType>("PersonType", ref _PersonType, value);
            }
        }

        private NamePrefix _Prefix;
        public NamePrefix Prefix
        {
            get { return _Prefix; }
            set
            {
                SetProperty<NamePrefix>("Prefix", ref _Prefix, value);
            }
        }

        private string _FirstName;
        public string FirstName
        {
            get { return _FirstName; }
            set
            {
                SetProperty<string>("FirstName", ref _FirstName, value);
            }
        }

        private string _LastName;
        public string LastName
        {
            get { return _LastName; }
            set
            {
                SetProperty<string>("LastName", ref _LastName, value);
            }
        }

        private string _NickName;
        public string NickName
        {
            get { return _NickName; }
            set
            {
                SetProperty<string>("NickName", ref _NickName, value);
            }
        }

        private NameSuffix _Suffix;
        public NameSuffix Suffix
        {
            get { return _Suffix; }
            set
            {
                SetProperty<NameSuffix>("Suffix", ref _Suffix, value);
            }
        }

        private string _Title;
        public string Title
        {
            get { return _Title; }
            set
            {
                SetProperty<string>("Title", ref _Title, value);
            }
        }

        public string FullName
        {
            get { return $"{FirstName} {LastName}"; }
        }

        private int _ClientRepId;
        public int ClientRepId
        {
            get { return _ClientRepId; }
            set
            {
                SetProperty<int>("ClientRepId", ref _ClientRepId, value);
            }
        }
    }
}

results = (from p in dc.Persons
            select new PersonEntity
            {
                RemoteId = p.RemoteId,
                ClientRepId = p.ClientRepId ?? 0,
                SupervisorId = p.SupervisorId ?? 0,
                PersonType = (PersonType)p.PersonType ?? PersonType.None,
                Prefix = (NamePrefix)p.Prefix ?? NamePrefix.None,
                FirstName = p.FirstName,
                LastName = p.LastName,
                NickName = p.NickName,
                Suffix = (NameSuffix)p.Suffix ?? NameSuffix.None,
                Title = p.Title,
                CreatedById = p.CreatedById,
                CreatedDT = p.CreatedDT,
                LastModifiedById = p.Id,
                LastModifiedDT = p.ModifiedByDT.Value,
                DeletedById = p.DeletedById,
                DeletedDT = p.DeletedByDT.Value
            }).Where(predicate).ToList();

Prefix = (NamePrefix)p.Prefix ?? NamePrefix.None,

Operator '??' cannot be applied to operands of type 'PersonType' and 'PersonType'

using (IDbCommand clientCommand = Connection.CreateCommand())
{
    clientCommand.CommandText = clientSql;
    using (IDataReader clientReader = clientCommand.ExecuteReader()
    {
        while(clientReader.Read())
        {
            AddDataToList(clientReader);
        }

        if(List.Count >= 100)
        {
            using (var com = warehouseConnection.CreateCommand())
            {
                com.CommandText = GetInsertScript(List);
                AddedCount += com.ExecuteNonQuery();
            }
        }
    }
}

public IEnumerator<object[]> GetTableContent()
{
    SqlCommand command = new SqlCommand("command", SqlConnection);
    using (var reader = command.ExecuteReader())
    {
        var items = new object[reader.FieldCount];
        reader.GetValues(items);
        yield return items;
    }
}

public void GetTableContent(Action<object[]> dataAction)
{
    SqlCommand command = new SqlCommand("command", SqlConnection);
    using (var reader = command.ExecuteReader())
    {
        var items = new object[reader.FieldCount];
        reader.GetValues(items);
        dataAction.Invoke(items);
    }
}

var maxRev = 2;
var jobSequenceSheets = (from jss in dc.JobSequenceSheets
                            where jss.JobId == jobId &&
                                jss.RevisionNumber == maxRev
                            select jss).OrderBy(x => x.Plan)
                                       .ThenBy(x => x.Elevation)
                                       .DistinctBy(c => new { c.Plan, c.Elevation})
                                       .ToList();