How to identify one item from a list based on some criteria in C#

Question

How to identify one item from a list based on some criteria in C#

One07k-4914 101

Hi ,

According to some criteria, I have to find out one item from a list.

For more information, please see my inline comments.

using System;

using System.Collections.Generic;

using System.IO;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace BranchFinder

{

    class Program

    {

        static void Main(string[] args)

        {

            var file = new List<FileChanges>

            {

                new FileChanges

                {

                    LocalFilePath =

                        @"D:\LD\WF\ARM\Modules\Reference\MM\DD\Client\Events\Publisher.cs",

                    ServerFilePath =

                        "$/TD/Dev/ARM/ARM/Modules/Reference/MM/DD/Client/Events/Publisher.cs"

                },

                new FileChanges

                {

                    LocalFilePath =

                        @"D:\LD\WF\ARM\Modules\Reference\ModuleCommon.sln",

                    ServerFilePath = "$/TD/Dev/ARM/ARM/Modules/Reference/ModuleCommon.sln"

                }

            };

            var branches = new List<Branches>

            {

                new Branches

                {

                    Id=1,

                    LocalItem = @"D:\LD\WF",

                    ServerItem = "$/TD/Dev/WF"

                },

                new Branches

                {

                    Id=2,

                    LocalItem = @"D:\LD\WF\ARM",

                    ServerItem = "$/TD/Dev/ARM/ARM"

                }

            };

            var b = GetBranch(file, branches);

            Console.ReadLine();

        }

        private static object GetBranch(List<FileChanges> file, List<Branches> branches)

        {



            //TODO:My requirement is to retrive from branches where Id=2;


            /*  Details
            Filtering criteria:

For Eg:

Id = 2

Branches.LocalItem = @"D:\LD\WF\ARM"

FileChange.LocalFilePath = @"D:\LD\WF\ARM\Modules\Reference\MM\DD\Client\Events\Publisher.cs"

Both Branches.LocalItem and FileChange.LocalFilePath should starts exactly same.

//Below approach is not working becoz

Id = 1

Branches.LocalItem = @"D:\LD\WF",

FileChange.LocalFilePath = @"D:\LD\WF\ARM\Modules\Reference\MM\DD\Client\Events\Publisher.cs"

            var s = branches.Where(branch =>

                   file.Any(x => x.LocalFilePath.Contains(branch.LocalItem)))

               .Distinct().ToList();

            Both LocalItem @"D:\LD\WF" and  @"D:\LD\WF\ARM" are starts with same string  @"D:\LD\WF".

Any solution will be helpful.

    */




        }

    }

    public class FileChanges

    {

        public string LocalFilePath { get; set; }

        public string ServerFilePath { get; set; }

    }

    public class Branches

    {

        public int Id { get; set; }

        public string LocalItem { get; set; }

        public string ServerItem { get; set; }

    }

}

//includedChanges

//LocalFilePath -D:\LD\WF\ARM\Modules\Reference\MM\DD\Client\Events\Publisher.cs

//ServerFilePath- $/TD/Dev/ARM/ARM/Modules/Reference/MM/DD/Client/Events/Publisher.cs

//includedChanges

//LocalFilePath -D:\LD\WF\ARM\Modules\Reference\ModuleCommon.sln

//ServerFilePath- $/TD/Dev/ARM/ARM/Modules/Reference/ModuleCommon.sln

//Branch

//LocalItem -D:\LD\WF

//ServerItem- $/TD/Dev/WF

//Branch

//LocalItem -D:\LD\WF\ARM

//ServerItem- $/TD/Dev/ARM/ARM

Accepted answer

0 additional answers

Your answer

Answer 1

Jiachen Li-MSFT 34,221 Microsoft External Staff

Hi @One07k-4914 ,

The following code filters Branches that match all of the corresponding properties of List<includeChanges>.

If I misunderstand your question, please point it out.

        private static object GetBranch(List<FileChanges> file, List<Branches> branches) {

            return branches.Where(x => x.test1(file)).ToList();

        }

    public class Branches {

        public int Id { get; set; }

        public string LocalItem { get; set; }

        public string ServerItem { get; set; }

        public bool test1(List<FileChanges> fc) {
            bool res = true;
            foreach (FileChanges fileChanges in fc) {
                if (!fileChanges.LocalFilePath.Contains(LocalItem) || !fileChanges.ServerFilePath.Contains(ServerItem)) {
                    res = false;
                    break;
                }
            }

            return res;
        }

    }

Best Regards.
Jiachen Li
----------
If the answer is helpful, please click "Accept Answer" and upvote it.
Note: Please follow the steps in our documentation to enable e-mail notifications if you want to receive the related email notification for this thread.

One07k-4914 101

Hi Jiachen Li,

For below sample it will not work right?

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace BranchFinder
{
    class Program
    {
        static void Main(string[] args)
        {
    

            var file = new List<FileChanges>
            {

                new FileChanges
                {
                    LocalFilePath =
                        @"D:\Proxy\ClientProxy\Package\Audit\ProxyAudit.cs",
                    ServerFilePath =
                        "$/Client/DEV/ClientProxy/Client_Package/Audit/ProxyAudit.cs"
                }
            };


            var branches = new List<Branches>
            {

                new Branches
                {
                    Id = 1,
                    LocalItem = @"D:\Proxy\ClientProxy",
                    ServerItem = "$/Client/DEV/ClientProxy"
                },
                new Branches
                {
                    Id = 2,
                    LocalItem = @"D:\Proxy\ClientProxy\Package",
                    ServerItem = "$/Client/DEV/ClientProxy/Client_Package"
                }
            };

            var aa = Test.GetBranch(file, branches);
       
            //Console.WriteLine(b.Item1.LocalItem + "\n" + b.Item1.ServerItem + "\n" + b.Item1.Id);
            //Console.WriteLine(b.Item1.LocalItem + "\n" + b.Item1.ServerItem + "\n" + b.Item1.Id);

            Console.ReadLine();

        }






    }

    public class Test
    {
        public static object GetBranch(List<FileChanges> file, List<Branches> branches)
        {

            return branches.Where(x => x.test1(file)).ToList();

        }

 
    }


    public class FileChanges
    {
        public string LocalFilePath { get; set; }

        public string ServerFilePath { get; set; }

    }

    public class Branches
    {
        public int Id { get; set; }
        public string LocalItem { get; set; }

        public string ServerItem { get; set; }

        public bool test1(List<FileChanges> fc)
        {
            bool res = true;
            foreach (FileChanges fileChanges in fc)
            {
                if (!fileChanges.LocalFilePath.Contains(LocalItem) || !fileChanges.ServerFilePath.Contains(ServerItem))
                {
                    res = false;
                    break;
                }
            }

            return res;
        }
    }
}

One07k-4914 101

Hi Jaichen Li,

I figured out one way.I think it will works.What do you think.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace BranchFinder
{
    class Program
    {
        static void Main(string[] args)
        {
    

            var file = new List<FileChanges>
            {

                new FileChanges
                {
                    LocalFilePath =
                        @"D:\Proxy\ClientProxy\Package\Audit\ProxyAudit.cs",
                    ServerFilePath =
                        "$/Client/DEV/ClientProxy/Client_Package/Audit/ProxyAudit.cs"
                }
            };


            var branches = new List<Branches>
            {

                new Branches
                {
                    Id = 1,
                    LocalItem = @"D:\Proxy\ClientProxy",
                    ServerItem = "$/Client/DEV/ClientProxy"
                },
                new Branches
                {
                    Id = 2,
                    LocalItem = @"D:\Proxy\ClientProxy\Package",
                    ServerItem = "$/Client/DEV/ClientProxy/Client_Package"
                }
            };

           // var aa = Test.GetBranch(file, branches);
            var b = GetBranch(file, branches);

            Console.WriteLine(b.Item1.LocalItem + "\n" + b.Item1.ServerItem + "\n" + b.Item1.Id);
            Console.WriteLine(b.Item1.LocalItem + "\n" + b.Item1.ServerItem + "\n" + b.Item1.Id);

            Console.ReadLine();

        }



        private static Tuple<Branches,FileChanges> GetBranch(List<FileChanges> file, List<Branches> branches)
        {

            Branches br = null;
            FileChanges fc=null;
            foreach (var obj1 in branches)
            {
                foreach (var obj2 in file)
                {
                    if (obj2.LocalFilePath.StartsWith(obj1.LocalItem))
                    {

                        var tempPath = obj2.ServerFilePath.Replace(obj1.ServerItem, string.Empty).Replace("/", "\\");

                        var path = string.Concat(obj1.LocalItem, tempPath);
                        if (path == obj2.LocalFilePath && obj2.ServerFilePath.Contains(obj1.ServerItem)&&obj2.ServerFilePath.StartsWith(obj1.ServerItem))
                        {
                            if (br == null)
                            {
                                br = obj1;
                                fc = obj2;
                                break;
                            }
                        }
                    }
                }
                if (br == null)
                {
                    continue;
                }
            }

            //Linq?
            var s = branches.Where(branch => file.Any(x => x.LocalFilePath.Contains(branch.LocalItem)&&x.ServerFilePath.Contains(branch.ServerItem)))
               .Distinct().ToList();



            return new Tuple<Branches, FileChanges>(br,fc);
        }


    }

    public class Test
    {
        public static object GetBranch(List<FileChanges> file, List<Branches> branches)
        {

            return branches.Where(x => x.test1(file)).ToList();

        }

 
    }


    public class FileChanges
    {
        public string LocalFilePath { get; set; }

        public string ServerFilePath { get; set; }

    }

    public class Branches
    {
        public int Id { get; set; }
        public string LocalItem { get; set; }

        public string ServerItem { get; set; }

        public bool test1(List<FileChanges> fc)
        {
            bool res = true;
            foreach (FileChanges fileChanges in fc)
            {
                if (!fileChanges.LocalFilePath.Contains(LocalItem) || !fileChanges.ServerFilePath.Contains(ServerItem))
                {
                    res = false;
                    break;
                }
            }

            return res;
        }
    }
}

Jiachen Li-MSFT 34,221 Microsoft External Staff

Hi @One07k-4914 ,

For your own solution, there are some issues with the loop logic in the GetBranch function.

For the solution I provided, you can use it by following the code below.

namespace BranchFinder {

    class Program {

        static void Main(string[] args) {


            var file = new List<FileChanges>
            {

                new FileChanges
                {
                    LocalFilePath =
                        @"D:\Proxy\ClientProxy\Package\Audit\ProxyAudit.cs",
                    ServerFilePath =
                        "$/Client/DEV/ClientProxy/Client_Package/Audit/ProxyAudit.cs"
                },

            };


            var branches = new List<Branches>
            {

                new Branches
                {
                    Id = 1,
                    LocalItem = @"D:\Proxy\ClientProxy",
                    ServerItem = "$/Client/DEV/ClientProxy"
                },
                new Branches
                {
                    Id = 2,
                    LocalItem = @"D:\Proxy\ClientProxy\Package",
                    ServerItem = "$/Client/DEV/ClientProxy/Client_Package"
                }
            };

            // var aa = Test.GetBranch(file, branches);

            var res = GetBranch(file, branches);

            foreach (var branch in res) {
                Console.WriteLine(branch.LocalItem + "\n" + branch.ServerItem + "\n" + branch.Id);
            }

            Console.ReadLine();

        }
        public static List<Branches> GetBranch(List<FileChanges> file, List<Branches> branches) {

            return branches.Where(x => x.test1(file)).ToList();

        }


        public class FileChanges {
            public string LocalFilePath { get; set; }

            public string ServerFilePath { get; set; }

        }

        public class Branches {
            public int Id { get; set; }
            public string LocalItem { get; set; }

            public string ServerItem { get; set; }

            public bool test1(List<FileChanges> fc) {
                bool res = true;
                foreach (FileChanges fileChanges in fc) {
                    if (!fileChanges.LocalFilePath.Contains(LocalItem) || !fileChanges.ServerFilePath.Contains(ServerItem)) {
                        res = false;
                        break;
                    }
                }

                return res;
            }
        }

    }
}

One07k-4914 101

Hi Jiachen Li-MSFT,

I copied your code but its still returning 2 items in the list.I have update my solution could you please check it.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace BranchFinder
{
    class Program
    {
        static void Main(string[] args)
        {


            var file = new List<FileChanges>
            {

                new FileChanges
                {
                    LocalFilePath =
                        @"D:\Proxy\ClientProxy\Package\Audit\ProxyAudit.cs",
                    ServerFilePath =
                        "$/Client/DEV/ClientProxy/Client_Package/Audit/ProxyAudit.cs"
                }
            };


            var branches = new List<Branches>
            {

                new Branches
                {
                    Id = 1,
                    LocalItem = @"D:\Proxy\ClientProxy",
                    ServerItem = "$/Client/DEV/ClientProxy"
                },
                new Branches
                {
                    Id = 2,
                    LocalItem = @"D:\Proxy\ClientProxy\Package",
                    ServerItem = "$/Client/DEV/ClientProxy/Client_Package"
                }
            };

            // var aa = Test.GetBranch(file, branches);
            var bb = GetBranch(file, branches);

            foreach (var b in bb)
            {
                Console.WriteLine(b.LocalItem + "\n" + b.ServerItem + "\n" + b.Id);

            }


            Console.ReadLine();

        }



        private static List<Branches> GetBranch(List<FileChanges> file, List<Branches> branches)
        {

            List<Branches> br = new List<Branches>();
            FileChanges fc = null;
            foreach (var obj1 in branches)
            {
                foreach (var obj2 in file)
                {
                    if (obj2.LocalFilePath.StartsWith(obj1.LocalItem))
                    {

                        var tempPath = obj2.ServerFilePath.Replace(obj1.ServerItem, string.Empty).Replace("/", "\\");

                        var path = string.Concat(obj1.LocalItem, tempPath);
                        if (path == obj2.LocalFilePath && obj2.ServerFilePath.Contains(obj1.ServerItem) &&
                            obj2.ServerFilePath.StartsWith(obj1.ServerItem))
                        {

                            br.Add(obj1);
                            fc = obj2;


                        }
                    }
                }
             
            }

            return br.GroupBy(x => x.LocalItem).Select(y => y.First())?.Distinct().ToList();


        }


    }

    public class Test
    {
        public static object GetBranch(List<FileChanges> file, List<Branches> branches)
        {

            return branches.Where(x => x.test1(file)).ToList();

        }


    }


    public class FileChanges
    {
        public string LocalFilePath { get; set; }

        public string ServerFilePath { get; set; }

    }

    public class Branches
    {
        public int Id { get; set; }
        public string LocalItem { get; set; }

        public string ServerItem { get; set; }

        public bool test1(List<FileChanges> fc)
        {
            bool res = true;
            foreach (FileChanges fileChanges in fc)
            {
                if (!fileChanges.LocalFilePath.Contains(LocalItem) || !fileChanges.ServerFilePath.Contains(ServerItem))
                {
                    res = false;
                    break;
                }
            }

            return res;
        }
    }
}

Jiachen Li-MSFT 34,221 Reputation points Microsoft External Staff

2023-03-22T01:35:22.9866667+00:00

Hi @One07k-4914 ,

As far as your current code is concerned, it's correct.

Like I said before, it's not clear to me what you expect it to get.

Is it the Branches in branches that match all files or the Branches in branches that match a single file?

One07k-4914 101

     var file = new List<FileChanges>
            {

                new FileChanges
                {
                    LocalFilePath =
                        @"D:\Proxy\ClientProxy\Package\Audit\ProxyAudit.cs",
                    ServerFilePath =
                        "$/Client/DEV/ClientProxy/Client_Package/Audit/ProxyAudit.cs"
                }
            };


            var branches = new List<Branches>
            {

                new Branches
                {
                    Id = 1,
                    LocalItem = @"D:\Proxy\ClientProxy",
                    ServerItem = "$/Client/DEV/ClientProxy"
                },
                new Branches
                {
                    Id = 2,
                    LocalItem = @"D:\Proxy\ClientProxy\Package",
                    ServerItem = "$/Client/DEV/ClientProxy/Client_Package"
                }
            };

My requirement is Find the unique branches based on the FileChanges content.That means for the above example

    new FileChanges
                {
                    LocalFilePath =
                        @"D:\Proxy\ClientProxy\Package\Audit\ProxyAudit.cs",
                    ServerFilePath =
                        "$/Client/DEV/ClientProxy/Client_Package/Audit/ProxyAudit.cs"
                }


     new Branches
                {
                    Id = 2,
                    LocalItem = @"D:\Proxy\ClientProxy\Package",
                    ServerItem = "$/Client/DEV/ClientProxy/Client_Package"
                }

Based on the file name and paths are matching only with Branches with Id=2.

Jiachen Li-MSFT 34,221 Reputation points Microsoft External Staff

2023-03-22T05:57:14.05+00:00

Then I think your code should work.
One07k-4914 101 Reputation points

2023-03-22T06:19:53.27+00:00

Thanks Jiachern Li
Jiachen Li-MSFT 34,221 Reputation points Microsoft External Staff

2023-03-23T09:49:47.6+00:00

Glad to see your problem solved, you could accept the helpful answer to change its status to Answered. It will also help others to solve the similar issue.

Thanks for your cooperation.
One07k-4914 101 Reputation points

2023-03-24T09:07:14.3133333+00:00

Thanks Jiachern Li for your valuable help.

Share via

How to identify one item from a list based on some criteria in C#

0 additional answers

Your answer