you get two lists of Component, one of which holds the Type property and the other holds the Details property? Anyway it sounds like you should refactor this design. If this is not possible try using IEnumerables linq methods for example:

list1.ForEach(x => list2.First(v => v.Name == x.Name));

edit

Ok, you added your code so it's clearer now. Really it doesn't sound as if you need the Component class at all here. You should refactor IMO. Something like this:

protected void btnGetComparisionResult_Click(object sender, EventArgs e) {
    Dictionary<string, ComponentDetails> sourceComponentsDetails //key is component name
      = GetSourceComponentDetails();
    Dictionary<string, ComponentDetails> destinationComponentDetails //key is component name
      = GetDestinationComponentsDetials();

    foreach(string name in sourceComponentsDetails.Keys) {
        if(destinationComponentDetails.Contains(name)) {
            // create report here with name, sourceComponentsDetails[name].Size,
            // sourceComponentsDetails[name].Date, destinationComponentDetails[name].Size
            // and destinationComponentDetails[name].Date
        }
    }

If you can't refactor, or don't want to, linq is concise and as performant as foreach. I saw several people answered wth linq examples so you should look at that.

I couldn't test my answer because I don't have any data, but this should work. You can do whatever you want with the extracted information instead of printing it.

    List<Component> Source = new List<Component>();
    List<Component> Destination = new List<Component>();

    foreach (Component c in Destination)
    {
        Console.WriteLine(c.Details);
    }

Something like this:

    var matched = from s in source
        join d in destination on s.Type equals d.Type
        select d;

Will join your source and destination on matching Type properties and select the object from destination

If you need both the source and destination objects (so you can compare details), you could:

    var matched = from s in source
        join d in destination on s.Type equals d.Type
        select new { s, d };

If you want to make it a left join (so all records in source are returned even if they don't have an match in destination) then you could do:

    var matched = from s in source
        join d in destination on s.Type equals d.Type into tmp
        from t in tmp.DefaultIfEmpty()
        select new { s, d = t };

Here's an example: https://dotnetfiddle.net/J7iDmJ

Here is an 'old school' loop method for searching through all the items:

public static void GenericTester()
{
    var source = GetSourceComponents();
    var destination = GetDestinationComponents();

    // Go through each source item
    foreach (var srcItem in source)
    {
        // And for each source, look through each destination item
        foreach (var dstItem in destination)
        {
            // See if the destination has the same Type as the source
            if (srcItem.Type == dstItem.Type)
            {
                // source and destination are the same type, so examine file details
                foreach (var srcDetail in srcItem.Details)
                {
                    foreach (var dstDetail in dstItem.Details)
                    {
                        // See if destination detail has a filename that matches the source detail filename
                        if (srcDetail.Filename == dstDetail.Filename)
                        {
                            // Do some comparison between the source.ComponentDetail 
                            // and destination.ComponentDetail here:
                            // . . .

                            break;
                        }
                    }
                }

                break;
            }
        }
    }
}