C#

var list1 = new List<ItemOne>
                        {
                            new ItemOne {IDItem = 1, OneProperty = "1"},
                            new ItemOne {IDItem = 2, OneProperty = null},
                            new ItemOne {IDItem = 3, OneProperty = "3"},
                            new ItemOne {IDItem = 4, OneProperty = "4"}
                        };
            var list2 = new List<ItemTwo>
                        {
                            new ItemTwo {IDItem = 2, TwoProperty = "2"},
                            new ItemTwo {IDItem = 3, TwoProperty = "3"},
                        };


            var query = list1.Join(list2, l1 => l1.IDItem, l2 => l2.IDItem, (l1, l2) =>
            {
                l1.OneProperty = l2.TwoProperty;
                return l1;
            });

join b in list2
                       on a.IDItem equals b.IDItem into c
                       from d in c.DefaultIfEmpty()
                       select new
                       {
                           a.OneProperty=(d==null ? string.Empty : d.TwoProperty)
                       }).ToList();

var list1 = new []{
    new { CountryID = 12, CountryData = "Has good gras", regionUID = 4567  },
    new { CountryID = 12, CountryData = "nice weather", regionUID = 6789  },
    new { CountryID = 16, CountryData = "stormy weather", regionUID = 1234 }};

var list2 = new []{
    new { CountryID = 12, CountryName = "green hill"},
    new { CountryID = 16, CountryName = "stormy mountain"}
};

var list3 = new []{
    new {regionUID = 4567, regionName = "above 1000feet"},
    new {regionUID = 6789, regionName = "on the ground"},
    new {regionUID = 1234, regionName = "on the hill"}
};

var result = from m1 in list1
    join m2 in list2 on m1.CountryID equals m2.CountryID
    select new { m2.CountryName, m1.CountryData, m1.regionUID } into intermediate
    join m3 in list3 on intermediate.regionUID equals m3.regionUID
    select new { intermediate.CountryName, intermediate.CountryData, m3.regionName};

private string rootDir = @"C:\Backup";        

private void FormView_Load(object sender, EventArgs e)        {                       
   List<string> ls = Directory.GetDirectories(rootDir).Select(Path.GetFileName).ToList();            
    ls.Sort((a, b) => -1 * a.CompareTo(b));        
    listBoxComputer.Sorted = false;            
    listBoxComputer.DataSource = ls;            
    listBoxUser.SelectedIndex =-1;           
}

private void UpdateCommentFirst(string strCommentPath, string TickerName)
{
    int counter = 0;
    bool QcViewAllFileExist = false;
    bool QcCommentFileExist = false;
    bool AllowUpdate = false;
    string savepath = Convert.ToString(ConfigurationManager.AppSettings["OutputPath"]).Trim() + TickerName + "\\" + TickerName + "_QC-ViewwAll.xml";
    DataSet QCCommentstmp = new DataSet();
    DataSet QCViewAlltmp = new DataSet();

    if (File.Exists(strCommentPath))
    {
        QCCommentstmp.ReadXml(strCommentPath);
        QcCommentFileExist = true;
    }

    if (File.Exists(savepath))
    {
        QCViewAlltmp.ReadXml(savepath);
        QcViewAllFileExist = true;
    }

    if (QcCommentFileExist && QcViewAllFileExist)
    {
        if (QCCommentstmp.Tables.Count > 0)
        {
            if (!QCCommentstmp.Tables[0].Columns.Contains("IgnoreData"))
            {
                AllowUpdate = true;
            }
        }

        if (AllowUpdate)
        {

            List<clsCommentPopup> QCCommentlist = QCCommentstmp.Tables[0].AsEnumerable()
                .Select(row => new clsCommentPopup
                {
                    //BrokerFor,Formula,LineItem,Section,PeriodCollection
                    bolFollowUP = (row.Field<string>("FollowUP")) == null ? false : Convert.ToBoolean((row.Field<string>("FollowUP"))),
                    bolThisPeriod = (row.Field<string>("ThisPeriod")) == null ? false : Convert.ToBoolean((row.Field<string>("ThisPeriod"))),
                    Formula = (row.Field<string>("Formula")) == null ? string.Empty : (row.Field<string>("Formula")),
                    ModelValue = (row.Field<string>("ModelValue")) == null ? string.Empty : (row.Field<string>("ModelValue")),
                    ExternalComment = (row.Field<string>("ExternalComment")) == null ? string.Empty : (row.Field<string>("ExternalComment")),
                    InternalComment = (row.Field<string>("InternalComment")) == null ? string.Empty : (row.Field<string>("InternalComment")),
                    strEndPeriod = (row.Field<string>("EndPeriod")) == null ? string.Empty : (row.Field<string>("EndPeriod")),
                    strStartPeriod = (row.Field<string>("StartPeriod")) == null ? string.Empty : (row.Field<string>("StartPeriod")),
                    PeriodType = (row.Field<string>("PeriodType")) == null ? string.Empty : (row.Field<string>("PeriodType")),
                    SectionFor = (row.Field<string>("Section")) == null ? string.Empty : (row.Field<string>("Section")),
                    LiFor = (row.Field<string>("LineItem")) == null ? string.Empty : (row.Field<string>("LineItem")),
                    QcPeriodFor = (row.Field<string>("QcPeriod")) == null ? string.Empty : (row.Field<string>("QcPeriod")),
                    BrokerFor = (row.Field<string>("BrokerFor")) == null ? string.Empty : (row.Field<string>("BrokerFor")),
                    PeriodCollection = (row.Field<string>("PeriodCollection")) == null ? string.Empty : (row.Field<string>("PeriodCollection")),
                    boolIgnoreValue = (row.Field<string>("IgnoreValue")) == null ? false : Convert.ToBoolean((row.Field<string>("IgnoreValue"))),
                    IgnoreData = (!QCCommentstmp.Tables[0].Columns.Contains("IgnoreData") ? string.Empty : (row.Field<string>("IgnoreData") == null ? string.Empty : row.Field<string>("IgnoreData")))
                }).ToList();


            if (QCCommentlist != null)
            {
                foreach (var comment in QCCommentlist)
                {
                    string section = comment.SectionFor;
                    string li = comment.LiFor;
                    string broker = comment.BrokerFor;
                    string period = comment.PeriodCollection;
                    string strQCPeriodValue = "";

                    if (comment.boolIgnoreValue && period.Trim() != "")
                    {
                        var QcViewColumnName = QCViewAlltmp.Tables[0].Columns.Cast<DataColumn>().AsParallel()
                          .Where(x => x.ColumnName.Contains(period))
                          .Select(x => new { x.ColumnName }).FirstOrDefault();

                        if (QcViewColumnName != null)
                        {
                            period = QcViewColumnName.ColumnName;

                            if (period.Trim() != "")
                            {
                                var datarow = QCViewAlltmp.Tables[0].AsEnumerable().AsParallel()
                                    .Where(row => row.Field<string>("GroupKey").Split('~')[0].ToUpper() == section.ToUpper()
                                    && row.Field<string>("GroupKey").Split('~')[1].ToUpper() == li.ToUpper()
                                    && row.Field<string>("Section ").ToUpper() == broker.ToUpper());

                                if (datarow != null && datarow.Count() > 0)
                                {
                                    strQCPeriodValue = (datarow.FirstOrDefault()[period] != null ? datarow.FirstOrDefault()[period].ToString() : string.Empty);
                                    if (strQCPeriodValue.Trim() != string.Empty)
                                    {
                                        comment.IgnoreData = strQCPeriodValue;
                                        counter++;
                                    }
                                }
                            }
                        }
                    }
                }
            }

            SerializeQcComment(QCCommentlist);
            toolTip1.Hide(this);
        }
    }
}

QCCommentstmp.Tables[0].Columns.Contains("IgnoreData")