C# Linq查询以查找特定图像，但如果可以'；我找不到

问题：

我有以下资料：

[NotMapped]
public Image GetLargeSizeImage
{
    get
    {
            // pseudo code
            return this.ImageSet
                    .Where( x => x.ImageSizeType.Key == ImageSizeType.Large)
                    .IfNothingFoundThenOrderBy( x => x.ImageSizeType.Order)
                    .Where( x => x.ImageSizeType.Key != ImageSizeType.Original ) // Because we don't just want to go and get the original (largest size) if we can't find the Large size
                    .First();
    }
}

[NotMapped]
public Image GetMediumSizeImage 
{
    ...

基本上，我想通过调用我的函数来获得大图像。。。但是 这个特殊的东西没有大的图像。。。所以我想要它 下一个最好的尝试。它可以通过使用我给它的order列来实现这一点

类似这样的功能可以工作，但它有两个数据库调用：

    public Image GetMediumSizeImage
    {
        get
        {
            Image image;

            try
            {
                image = this.ImageSet.Where( x => x.ImageSizeType.Key == ImageSizeType.Medium).First();                    
            }
            catch(Exception e )
            {
                image = this.ImageSet
                            .OrderBy( x => x.ImageSizeType.Order )
                            .Where( x => x.ImageSizeType.Key != ImageSizeType.Original )
                            .First();
            }

            return image;
        }
    }

额外注释

---

已解决

public class BaseImage
{
    public virtual List<Image> ImageSet { get; set; }

    public Image GetImageBySize( string imageSizeTypeKey )
    {
        // If requesting original, we can just go get it
        if( imageSizeTypeKey == ImageSizeType.Original )
        {
            return this.ImageSet.Where( x => x.ImageSizeType.Key == imageSizeTypeKey ).First();
        }
        else
        {
            // This checks if image actually exists, if it doesn't it gets the next best one... Thumbnail wil always exist so it will always find one

            return this.ImageSet.Where( i => i.ImageSizeType.Key != ImageSizeType.Original )
            .OrderByDescending( i => i.ImageSizeType.Key == imageSizeTypeKey )
            .ThenBy(i => i.ImageSizeType.Order)
            .FirstOrDefault();
        }
    }
}

公共类基本映像
{
公共虚拟列表映像集{get；set；}
公共图像GetImageBySize（字符串imageSizeTypeKey）
{
//如果要原件，我们可以去拿
if（ImageSizeType==ImageSizeType.Original）
{
返回此.ImageSet.Where（x=>x.ImageSizeType.Key==ImageSizeType.First（）；
}
其他的
{
//这将检查图像是否确实存在，如果不存在，它将获得下一个最佳图像…缩略图将始终存在，因此它将始终找到一个
返回此.ImageSet.Where（i=>i.ImageSizeType.Key！=ImageSizeType.Original）
.OrderByDescending（i=>i.ImageSizeType.Key==ImageSizeType）
.ThenBy（i=>i.ImageSizeType.Order）
.FirstOrDefault（）；
}
}
}

这会行不通吗？当然，这将进行3次数据库访问

    return this.ImageSet.OrderBy( x => x.ImageSizeType.Order )
           .Where( x => x.ImageSizeType.Key == ImageSizeType.Large )
           .FirstOrDefault()
        ?? this.ImageSet.OrderBy( x => x.ImageSizeType.Order )
           .Where( x => x.ImageSizeType.Key == ImageSizeType.Medium )
           .FirstOrDefault()
        ?? this.ImageSet.OrderBy( x => x.ImageSizeType.Order )
           .Where( x => x.ImageSizeType.Key == ImageSizeType.Small )
           .FirstOrDefault();

或者，如果

ImageSizeType.Order

将在L=3、M=2、S=1的位置结束排序

return this.ImageSet.OrderByDescending( x => x.ImageSizeType.Order )
           .FirstOrDefault();

---

这样不行吗？当然，这将进行3次数据库访问

    return this.ImageSet.OrderBy( x => x.ImageSizeType.Order )
           .Where( x => x.ImageSizeType.Key == ImageSizeType.Large )
           .FirstOrDefault()
        ?? this.ImageSet.OrderBy( x => x.ImageSizeType.Order )
           .Where( x => x.ImageSizeType.Key == ImageSizeType.Medium )
           .FirstOrDefault()
        ?? this.ImageSet.OrderBy( x => x.ImageSizeType.Order )
           .Where( x => x.ImageSizeType.Key == ImageSizeType.Small )
           .FirstOrDefault();

或者，如果

ImageSizeType.Order

将在L=3、M=2、S=1的位置结束排序

return this.ImageSet.OrderByDescending( x => x.ImageSizeType.Order )
           .FirstOrDefault();

---

这样不行吗？当然，这将进行3次数据库访问

    return this.ImageSet.OrderBy( x => x.ImageSizeType.Order )
           .Where( x => x.ImageSizeType.Key == ImageSizeType.Large )
           .FirstOrDefault()
        ?? this.ImageSet.OrderBy( x => x.ImageSizeType.Order )
           .Where( x => x.ImageSizeType.Key == ImageSizeType.Medium )
           .FirstOrDefault()
        ?? this.ImageSet.OrderBy( x => x.ImageSizeType.Order )
           .Where( x => x.ImageSizeType.Key == ImageSizeType.Small )
           .FirstOrDefault();

或者，如果

ImageSizeType.Order

将在L=3、M=2、S=1的位置结束排序

return this.ImageSet.OrderByDescending( x => x.ImageSizeType.Order )
           .FirstOrDefault();

---

这样不行吗？当然，这将进行3次数据库访问

    return this.ImageSet.OrderBy( x => x.ImageSizeType.Order )
           .Where( x => x.ImageSizeType.Key == ImageSizeType.Large )
           .FirstOrDefault()
        ?? this.ImageSet.OrderBy( x => x.ImageSizeType.Order )
           .Where( x => x.ImageSizeType.Key == ImageSizeType.Medium )
           .FirstOrDefault()
        ?? this.ImageSet.OrderBy( x => x.ImageSizeType.Order )
           .Where( x => x.ImageSizeType.Key == ImageSizeType.Small )
           .FirstOrDefault();

或者，如果

ImageSizeType.Order

将在L=3、M=2、S=1的位置结束排序

return this.ImageSet.OrderByDescending( x => x.ImageSizeType.Order )
           .FirstOrDefault();

---

如果您有其他助手属性（这些属性应该是方法，因为您将它们命名为动词），则可以将它们链接在一起

[NotMapped]
public Image GetLargeSizeImage
{
    get
    {
        return this
               .ImageSet.OrderBy( x => x.ImageSizeType.Order )
               .Where( x => x.ImageSizeType.Key == ImageSizeType.Large )
               .FirstOrDefault() ?? GetMediumSizeImage;
        }
    }
}

[NotMapped]
public Image GetMediumSizeImage
{
    get
    {
        return this
               .ImageSet.OrderBy( x => x.ImageSizeType.Order )
               .Where( x => x.ImageSizeType.Key == ImageSizeType.Medium)
               .FirstOrDefault() ?? GetSmallSizeImage;
        }
    }
}

---

如果您有其他助手属性（这些属性应该是方法，因为您将它们命名为动词），则可以将它们链接在一起

[NotMapped]
public Image GetLargeSizeImage
{
    get
    {
        return this
               .ImageSet.OrderBy( x => x.ImageSizeType.Order )
               .Where( x => x.ImageSizeType.Key == ImageSizeType.Large )
               .FirstOrDefault() ?? GetMediumSizeImage;
        }
    }
}

[NotMapped]
public Image GetMediumSizeImage
{
    get
    {
        return this
               .ImageSet.OrderBy( x => x.ImageSizeType.Order )
               .Where( x => x.ImageSizeType.Key == ImageSizeType.Medium)
               .FirstOrDefault() ?? GetSmallSizeImage;
        }
    }
}

---

如果您有其他助手属性（这些属性应该是方法，因为您将它们命名为动词），则可以将它们链接在一起

[NotMapped]
public Image GetLargeSizeImage
{
    get
    {
        return this
               .ImageSet.OrderBy( x => x.ImageSizeType.Order )
               .Where( x => x.ImageSizeType.Key == ImageSizeType.Large )
               .FirstOrDefault() ?? GetMediumSizeImage;
        }
    }
}

[NotMapped]
public Image GetMediumSizeImage
{
    get
    {
        return this
               .ImageSet.OrderBy( x => x.ImageSizeType.Order )
               .Where( x => x.ImageSizeType.Key == ImageSizeType.Medium)
               .FirstOrDefault() ?? GetSmallSizeImage;
        }
    }
}

---

如果您有其他助手属性（这些属性应该是方法，因为您将它们命名为动词），则可以将它们链接在一起

[NotMapped]
public Image GetLargeSizeImage
{
    get
    {
        return this
               .ImageSet.OrderBy( x => x.ImageSizeType.Order )
               .Where( x => x.ImageSizeType.Key == ImageSizeType.Large )
               .FirstOrDefault() ?? GetMediumSizeImage;
        }
    }
}

[NotMapped]
public Image GetMediumSizeImage
{
    get
    {
        return this
               .ImageSet.OrderBy( x => x.ImageSizeType.Order )
               .Where( x => x.ImageSizeType.Key == ImageSizeType.Medium)
               .FirstOrDefault() ?? GetSmallSizeImage;
        }
    }
}

---

下面的方法获取给定目标大小的图像，如果目标不存在，则返回最大的另一个（由

顺序

定义），不包括

原始

private Image GetMeTheImage(string targetSizeType) 
{
    return this.ImageSet
        .Where(i => i.ImageSizeType.Key != ImageSizeType.Original)
        .OrderByDescending(i => i.ImageSizeType.Key == targetSizeType)
        .ThenBy(i => i.ImageSizeType.Order)
        .FirstOrDefault();
}

public Image GetLargeSizeImage
{
    get
    {
        // Given OPs example table where Large is missing, 
        // this should return the ExtraLarge image.
        return GetMeTheImage(ImageSizeType.Large);

    }
}

---

下面的方法获取给定目标大小的图像，如果目标不存在，则返回最大的另一个（由

顺序

定义），不包括

原始

private Image GetMeTheImage(string targetSizeType) 
{
    return this.ImageSet
        .Where(i => i.ImageSizeType.Key != ImageSizeType.Original)
        .OrderByDescending(i => i.ImageSizeType.Key == targetSizeType)
        .ThenBy(i => i.ImageSizeType.Order)
        .FirstOrDefault();
}

public Image GetLargeSizeImage
{
    get
    {
        // Given OPs example table where Large is missing, 
        // this should return the ExtraLarge image.
        return GetMeTheImage(ImageSizeType.Large);

    }
}

---

下面的方法获取给定目标大小的图像，如果目标不存在，则返回最大的另一个（由

顺序

定义），不包括

原始

private Image GetMeTheImage(string targetSizeType) 
{
    return this.ImageSet
        .Where(i => i.ImageSizeType.Key != ImageSizeType.Original)
        .OrderByDescending(i => i.ImageSizeType.Key == targetSizeType)
        .ThenBy(i => i.ImageSizeType.Order)
        .FirstOrDefault();
}

public Image GetLargeSizeImage
{
    get
    {
        // Given OPs example table where Large is missing, 
        // this should return the ExtraLarge image.
        return GetMeTheImage(ImageSizeType.Large);

    }
}

---

下面的方法获取给定目标大小的图像，如果目标不存在，则返回最大的另一个（由

顺序

定义），不包括

原始

private Image GetMeTheImage(string targetSizeType) 
{
    return this.ImageSet
        .Where(i => i.ImageSizeType.Key != ImageSizeType.Original)
        .OrderByDescending(i => i.ImageSizeType.Key == targetSizeType)
        .ThenBy(i => i.ImageSizeType.Order)
        .FirstOrDefault();
}

public Image GetLargeSizeImage
{
    get
    {
        // Given OPs example table where Large is missing, 
        // this should return the ExtraLarge image.
        return GetMeTheImage(ImageSizeType.Large);

    }
}

---

您可以创建优先级列表并加入ImageSet：

private Image GetAppropriatedImage() 
{
    return this.ImageSet
      .Join(orderList, x => x.ImageSizeType.Key, y => y.Key,
                (x, y) => new { Image =x, Order = y.Order })
      .OrderBy(x => x.Order)
      .Select(x => x.Image) 
      .FirstOrDefault();
}

优先列表，如：

var priorityImages = new List<string>(){ ImageSizeType.Large, ImageSizeType.Medium };
var orderList =   priorityImages.Select(y => new { Key = y, Order = priorityImages.IndexOf(y) }).ToList();

---

您可以创建优先级列表并加入ImageSet：

private Image GetAppropriatedImage() 
{
    return this.ImageSet
      .Join(orderList, x => x.ImageSizeType.Key, y => y.Key,
                (x, y) => new { Image =x, Order = y.Order })
      .OrderBy(x => x.Order)
      .Select(x => x.Image) 
      .FirstOrDefault();
}

优先列表，如：

var priorityImages = new List<string>(){ ImageSizeType.Large, ImageSizeType.Medium };
var orderList =   priorityImages.Select(y => new { Key = y, Order = priorityImages.IndexOf(y) }).ToList();

---

您可以创建优先级列表并加入ImageSet：

private Image GetAppropriatedImage() 
{
    return this.ImageSet
      .Join(orderList, x => x.ImageSizeType.Key, y => y.Key,
                (x, y) => new { Image =x, Order = y.Order })
      .OrderBy(x => x.Order)
      .Select(x => x.Image) 
      .FirstOrDefault();
}

优先列表，如：

var priorityImages = new List<string>(){ ImageSizeType.Large, ImageSizeType.Medium };
var orderList =   priorityImages.Select(y => new { Key = y, Order = priorityImages.IndexOf(y) }).ToList();

---

您可以创建优先级列表并加入ImageSet：

private Image GetAppropriatedImage() 
{
    return this.ImageSet
      .Join(orderList, x => x.ImageSizeType.Key, y => y.Key,
                (x, y) => new { Image =x, Order = y.Order })
      .OrderBy(x => x.Order)
      .Select(x => x.Image) 
      .FirstOrDefault();
}

优先列表，如：

var priorityImages = new List<string>(){ ImageSizeType.Large, ImageSizeType.Medium };
var orderList =   priorityImages.Select(y => new { Key = y, Order = priorityImages.IndexOf(y) }).ToList();

---

---

ImageSizeType.Key==ImageSizeType.Original

的定义是指其

Order==1

还是图像的最低可能

Order

值？在这种情况下，

OrderBy

似乎毫无意义。无论出于何种原因，

Where

子句都找不到匹配项。我会在那里设置一个断点，并仔细检查实际值。可以像数据库中的尾随空格一样简单，也可以只是没有填充到对象中。对于每个图像，您只保存一个原始图像，对吗？如果是这样，为什么需要对结果进行排序？我添加了一张图片来解释我的目的。可能是我当前的代码让你迷惑不解。你能告诉我们你期望的是什么吗（假设是原创的）那么您实际得到的是什么记录呢？

ImageSizeType.Key==ImageSizeType.Original

的定义是否意味着它的

Order==1

或者是图像可能的最低

Order

值？在这种情况下，

OrderBy

似乎毫无意义。无论出于何种原因，

Where

子句都找不到匹配项。我会在那里设置一个断点，并仔细检查实际值。可以像数据库中的尾随空格一样简单，也可以只是没有填充到对象中。对于每个图像，您只保存一个原始图像，对吗？如果是这样，为什么需要对结果进行排序？我添加了一张图片来解释我的目的。可能是我当前的代码让你迷惑不解。你能告诉我们你期望的是什么吗（假设是原创的）那么您实际得到的是什么记录呢？

ImageSizeType.Key==ImageSizeType.Original

的定义是否意味着它的

Order==1

或者是图像可能的最低

Order

值？在这种情况下，

OrderBy

似乎毫无意义。无论出于何种原因，

Where

子句都找不到匹配项。我会在那里设置一个断点，并仔细检查实际值。可以像数据库中的尾随空格一样简单，也可以只是没有填充到对象中。对于每个图像，您只保存一个原始图像，对吗？如果是这样，为什么需要对结果进行排序？我添加了一张图片来解释我的目的。可能是我当前的代码让你迷惑不解。你能告诉我们你期望的是什么（假设是原创的）吗