C＃匿名类型foreach循环，更好的方法吗？

Question

I have this simple foreach loop of an anonymous type and I'm wondering if there is a way to make it more efficient.

If it loops through 155 items, it takes about 20 seconds to complete. I've omitted some of the other properties it's setting on the boAsset object, but nothing special - just Strings / Integers .

Any thoughts?

List<BoAsset> assetList = new List<BoAsset>();
foreach (var asset in result)
{
     BoAsset boAsset = new BoAsset();
     boAsset.Description = asset.Description;
     boAsset.DetailedDescription = asset.DetailedDescription;
     boAsset.AssetCustomerID = asset.AssetCustomerID;
     boAsset.AssetId = asset.AssetId;
     boAsset.Keywords = asset.Keywords;
     boAsset.Notes = asset.Notes;
     boAsset.Photographer = asset.Photographer;
     boAsset.PhotographerEmail = asset.PhotographerEmail;
     boAsset.Notes = asset.Notes;
     boAsset.Author = asset.Author;
     boAsset.FileName = asset.FileName;
     boAsset.FileExtension = asset.FileExtension;
     boAsset.AssetCreateDate = asset.AssetCreateDate;
     boAsset.AssetExpireDate = asset.AssetExpireDate;

     assetList.Add(boAsset);
}


var query =   (from a in context.Assets
              join subAf1 in context.AssetFiles on new { aid = a.AssetID, ftid = 1 } equals new { aid = subAf1.AssetID, ftid = subAf1.AssetTypeID } into theAf1
              from Af1 in theAf1.DefaultIfEmpty()
              join subAf2 in context.AssetFiles on new { aid = a.AssetID, ftid = 2 } equals new { aid = subAf2.AssetID, ftid = subAf2.AssetTypeID } into theAf2
              from Af2 in theAf2.DefaultIfEmpty()
              join subAf3 in context.AssetFiles on new { aid = a.AssetID, ftid = 3 } equals new { aid = subAf3.AssetID, ftid = subAf3.AssetTypeID } into theAf3
              from Af3 in theAf3.DefaultIfEmpty()
              join subAf4 in context.AssetFiles on new { aid = a.AssetID, ftid = 4 } equals new { aid = subAf4.AssetID, ftid = subAf4.AssetTypeID } into theAf4
              from Af4 in theAf4.DefaultIfEmpty()
              join subAf5 in context.AssetFiles on new { aid = a.AssetID, ftid = 5 } equals new { aid = subAf5.AssetID, ftid = subAf5.AssetTypeID } into theAf5
              from Af5 in theAf5.DefaultIfEmpty()
              join subFp in context.FilePaths on new { fpid = Af1.FilePathID } equals new { fpid = subFp.FilePathID } into theFp1
              from fp1 in theFp1.DefaultIfEmpty()
              //join fp in context.FilePaths on Af1.FilePathID equals fp.FilePathID

              where a.AssetCustomerID == custId && a.AssetID == assetId
              select new { a, Af1, Af2, Af3, Af4, Af5, fp1 }).Distinct();

var result =   from q in query
               select new
               {
                   AssetId = q.a.AssetID,
                   AssetCustomerId = q.a.AssetCustomerID,
                   StockImage = q.a.StockImage,
                   Description = q.a.Description,
                   DetailedDescription = q.a.DetailedDescription,
                   Author = q.a.Author,
                   FileName = q.Af1.FileName, //was 1
                   FileExtension = q.Af1.FileExtension, //was 1
                   AssetCreateDate = q.a.AssetCreateDate,
                   AssetExpireDate = q.a.AssetExpireDate,
                   AssetActivateDate = q.a.AssetActivateDate,

                   Notes = q.a.Notes,
                   Keywords = q.a.Keywords,
                       Photographer = q.a.Photographer,
                       PhotographerEmail = q.a.PhotographerEmail
               }

Answer 1

The time for creating 155 objects and copying the data into them would be something like a millisecond. There is nothing that you could do to that code to make any significant (or even noticable) improvement.

If you want to save any time, you should look at the query that creates the result. That's what's taking time.

Answer 2

I think that your query is far too complex (too many joins), especially given that there are a few that are not even used.

Note that some LINQ providers (such as LINQ to Entities) can take quite a bit of time in simply processing a query tree to transform it into SQL, if the query is complex. (I have already had some queries take 10 or 15 seconds just for EF to analyze it.)

If, as I suspect, the LINQ implementation that you are using is hitting a database, then use a SQL profiling tool in order to check what actual SQL is being passed to the server, and how performant that SQL is.

Also, note that given the fields you are using, you could actually do away with the foreach loop by materializing results directly into the BoAsset objects.

That is:

var result = from q in query
             select new BoAsset
             {
                 AssetId = q.a.AssetID,
                 AssetCustomerId = q.a.AssetCustomerID,
                 StockImage = q.a.StockImage,
                 Description = q.a.Description,
                 DetailedDescription = q.a.DetailedDescription,
                 Author = q.a.Author,
                 FileName = q.Af1.FileName, //was 1
                 FileExtension = q.Af1.FileExtension, //was 1
                 AssetCreateDate = q.a.AssetCreateDate,
                 AssetExpireDate = q.a.AssetExpireDate,
                 AssetActivateDate = q.a.AssetActivateDate,
                 Notes = q.a.Notes,
                 Keywords = q.a.Keywords,
                 Photographer = q.a.Photographer,
                 PhotographerEmail = q.a.PhotographerEmail
             };

List<BoAsset> assetList = result.ToList();