2つの異なる型のList同士で、共通している要素（重複要素）を削除したい

Question

AppleクラスとOrangeクラスがあり、それぞれリンゴとミカンの性質（重さ、値段、色、出荷日…）をプロパティで保持しているとします。
二つのクラスは型も名称も同じプロパティを多く持っていますが、全プロパティが共通しているわけではありません。

List<Apple>とList<Orange>を生成し、
AppleとOrangeの「重さ」と「値段」の二つが同じ要素は削除したいです。
・重さ、値段はint型です
・AppleとOrangeどちらかを残すかという優先度はありません。
・Aplle、Orangeともに自クラス内では重さと値段で一意となっています。

思いついたのはList<Apple>から重さと値段の組み合わせを抽出して、
List<Orange>に一致するものがあれば消すという方法です。

しかし、List<AppleAndOrange>のような、
両方の型を入れられるようなListを作って、
重さと値段が一致する要素は初めの要素だけ残すやり方ができれば
よりスマートだなと思っています。
このようなやり方はできますでしょうか？

また、他により良いアイデアがあればご教示いただきたいです。

Comments

[退会済みユーザー]

「重さ」と「値段」の型は何ですか？　double と decimal？

[galmacher]

int型でお願いします。質問文にもその旨を明記いたしました。

Answer 1

こんな構成のクラスを作っておいて

interface IFruits
{
    decimal Weight { get; set; }
    decimal Price { get; set; }
}

class EquatableFruits : IFruits, IEquatable<EquatableFruits>
{
    public decimal Weight { get; set; }
    public decimal Price { get; set; }

    public override int GetHashCode()
    {
        return Weight.GetHashCode() ^ Price.GetHashCode();
    }

    public virtual bool Equals(EquatableFruits other)
    {
        return
            this.Price == other.Price
            &&
            this.Weight == other.Weight;
    }
}

class Orange : EquatableFruits
{         
    public bool IsNoSeed { get; set; }
}

class Apple : EquatableFruits
{
    public bool WithHoney { get; set; }
}

こんな感じで使います。

var fruits = new List<EquatableFruits>();

var apples = new List<Apple>
{
    new Apple
    {
        Price = 100,
        Weight = 200,
        WithHoney = true
    }
};

var oranges = new List<Orange>
{
    new Orange
    {
        Price = 100,
        IsNoSeed = true,
        Weight = 200
    }
};

fruits.AddRange(apples);
fruits.AddRange(oranges);

var result = fruits.Distinct().ToList();

--- 追記 --
あるいは基底クラス(EquatableFruits)を用いずにIFruitsの比較クラスを用意して

class FruitsEqualtyComparer : IEqualityComparer<IFruits>
{
    public bool Equals(IFruits x, IFruits y)
    {
        return x.Price == y.Price && x.Weight == y.Weight;
    }

    public int GetHashCode(IFruits obj)
    {
        return obj.Price.GetHashCode() ^ obj.Weight.GetHashCode();
    }
}

var fruits2 = new List<IFruits>();
fruits2.AddRange(apples);
fruits2.AddRange(oranges);

var result2 = fruits.Distinct(new FruitsEqualtyComparer()).ToList();

のほうが汎用的かもしれません。

Comments

[退会済みユーザー]

IEnumerable<T> で T が匿名型の場合は Distinct() メソッドで期待通り重複のない結果が得られますが、T にカスタムデータ型を使った場合はそうはいかないと理解していますが、いかがでしょう？

http://surferonwww.info/BlogEngine/post/2015/12/08/anonymous-type-and-distinct-method.aspx

[hihijiji]

Distinct() メソッドが使えるEquatableFruitsを作ったつもりでしたが、
EquatableFruitsの実装に間違いがありましたの修正しました。

[galmacher]

ご回答ありがとうございました。IEquatable、IEqualityComparerを使用したそれぞれの方法を挙げてくださり、大変参考になりました。

Answer 2

みなさん Distinct を使われていますが、求められるのは和集合であり、価格と重さの組み合わせはもともとの集合の中では一意ということなので Union を使ってみました。

CustomEqualityComparer は比較用クラスですが、これを作っておけば実際に使用する際にはラムダ式から作成できるので何かと便利です。

LINQ は他にも集合演算ができます。今回は和集合を求める質問でしたが、もしも本来の目的が和集合ではなく差集合または排他的論理和集合であるなら、次の資料をご覧ください。

LINQの集合演算

using System;
using System.Collections.Generic;
using System.Linq;

namespace ConsoleApp1
{
	public class CustomEqualityComparer<T> : IEqualityComparer<T>
	{
		public CustomEqualityComparer(Func<T, T, bool> equals, Func<T, int> getHashCode = null)
		{
			this.equals = equals;
			this.getHashCode = getHashCode;
		}
		private readonly Func<T, int> getHashCode;
		private readonly Func<T, T, bool> equals;

		public bool Equals(T x, T y)
		{
			return equals?.Invoke(x, y) ?? false;
		}

		public int GetHashCode(T obj)
		{
			return getHashCode?.Invoke(obj) ?? 0;
		}
	}

	public interface IFruit
	{
		int Weight { get; set; }
		int Price { get; set; }
	}

	public class Apple : IFruit
	{
		public int Weight { get; set; }
		public int Price { get; set; }
	}

	public class Orange : IFruit
	{
		public int Weight { get; set; }
		public int Price { get; set; }
	}

	class Program
	{
		static void Main(string[] args)
		{
			List<Apple> apples = new List<Apple>()
			{
				new Apple() { Weight = 10, Price = 10 },
				new Apple() { Weight = 20, Price = 20 },
			};
			List<Orange> oranges = new List<Orange>()
			{
				new Orange() { Weight = 20, Price = 20 },
				new Orange() { Weight = 30, Price = 30 },
			};
			var comparer = new CustomEqualityComparer<IFruit>(
				(a, b) => a.Price == b.Price && a.Weight == b.Weight);
			var fruits = apples.Union(oranges, comparer);
			foreach (var fruit in fruits)
			{
				Console.WriteLine(fruit.Weight);
			}
			Console.ReadKey();
		}
	}
}

Comments

[galmacher]

ご回答ありがとうございました。ジェネリックとデリゲートのおかげで、呼び出し元から汎用的に比較を行える仕組みがとても参考になりました。

[Zuishin]

今回 GetHashCode の戻り値を 0 に固定していて、それで結果は問題ないんですが、大量のデータを扱う場合にはパフォーマンスが悪くなる場合があるので、そのような時にはここもきちんと設定してください。

比較する各数値の排他的論理和を使うのが簡単ですが、値に偏りがある場合には乗算と加算を組み合わせて使えば演算結果にバラつきが出てもう少しパフォーマンスが上がる可能性もあります。例えば排他的論理和の場合は (10, 20) と (20, 10) は同じ値になり、また小さな数字ばかりの時には上位ビットが遊んでいるのでバラつきは小さくなります。乗算と加算をうまく使えば上位ビットにも仕事をさせることができます。

このあたりはどのようなデータを扱うかによって最適解が変わります。データの数が少ない場合には差は出ませんから、速度が遅いと感じた時にチューニングしても間に合うと思います。

Answer 3

しかし、List<AppleAndOrange>のような、両方の型を入れられるようなListを作って、

AppleAndOrange クラスは（名前、重さ、値段、色、出荷日…）というような構造になるのでしょうか？　

List<Apple> と List<Orange> から List<AppleAndOrange> を作るということでよければ、以下の記事の 1 または 2 いずれかの方法で Distinct メソッドで「重さ」と「値段」の重複をチェックできるようにしていかがですか？

匿名型と Distinct メソッド
http://surferonwww.info/BlogEngine/post/2015/12/08/anonymous-type-and-distinct-method.aspx

不明点がある場合、やってみたがうまくいかない場合は連絡ください。

【追記】

上に紹介した記事「匿名型と Distinct メソッド」の 1. の方法で Distinct メソッドによる重複排除ができるようにしたサンプルを書いておきます。これでは質問者さんの目的が果たせない場合は、どこをどう直すべきか具体的に連絡ください。

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

namespace ConsoleAppDistinct
{
    public class Apple
    {
        public int Weight { get; set; }
        public int Price { get; set; }
    }

    public class Orange
    {
        public int Weight { get; set; }
        public int Price { get; set; }
    }

    public class AppleAndOrange : IEquatable<AppleAndOrange>
    {
        public string Name { get; set; }
        public int Weight { get; set; }
        public int Price { get; set; }

        public bool Equals(AppleAndOrange other)
        {
            if (Object.ReferenceEquals(other, null)) return false;

            if (Object.ReferenceEquals(this, other)) return true;

            return Price.Equals(other.Price) && Weight.Equals(other.Weight);
        }

        // If Equals() returns true for a pair of objects  
        // then GetHashCode() must return the same value for these objects. 
        public override int GetHashCode()
        {
            return Price.GetHashCode() ^ Weight.GetHashCode();
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            List<Apple> apples = new List<Apple>
            {
                new Apple { Price = 100, Weight = 100 },
                new Apple { Price = 110, Weight = 110 },
                new Apple { Price = 120, Weight = 120 },
                new Apple { Price = 130, Weight = 130 },
                new Apple { Price = 140, Weight = 140 }
            };

            List<Orange> oranges = new List<Orange>
            {
                new Orange { Price = 100, Weight = 110 },
                new Orange { Price = 105, Weight = 100 },
                new Orange { Price = 120, Weight = 120 },
                new Orange { Price = 130, Weight = 125 },
                new Orange { Price = 140, Weight = 140 }
            };

            List<AppleAndOrange> applesAndOranges = new List<AppleAndOrange>();

            foreach(Apple a in apples)
            {
                applesAndOranges.Add(new AppleAndOrange { Name = "Apple", Price = a.Price, Weight = a.Weight });
            }

            foreach (Orange o in oranges)
            {
                applesAndOranges.Add(new AppleAndOrange { Name = "Orange", Price = o.Price, Weight = o.Weight });
            }

            foreach (AppleAndOrange x in applesAndOranges)
            {
                Console.WriteLine($"Name: {x.Name}, Price: {x.Price}, Weight: {x.Weight}");
            }

            Console.WriteLine("-------------------------");

            foreach (AppleAndOrange x in applesAndOranges.Distinct())
            {
                Console.WriteLine($"Name: {x.Name}, Price: {x.Price}, Weight: {x.Weight}");
            }

        }
    }
}

実行結果は以下の通りとなります。

Name: Apple, Price: 100, Weight: 100
Name: Apple, Price: 110, Weight: 110
Name: Apple, Price: 120, Weight: 120
Name: Apple, Price: 130, Weight: 130
Name: Apple, Price: 140, Weight: 140
Name: Orange, Price: 100, Weight: 110
Name: Orange, Price: 105, Weight: 100
Name: Orange, Price: 120, Weight: 120
Name: Orange, Price: 130, Weight: 125
Name: Orange, Price: 140, Weight: 140
－－－－－－－－－－－－－－－－－－
Name: Apple, Price: 100, Weight: 100
Name: Apple, Price: 110, Weight: 110
Name: Apple, Price: 120, Weight: 120
Name: Apple, Price: 130, Weight: 130
Name: Apple, Price: 140, Weight: 140
Name: Orange, Price: 100, Weight: 110
Name: Orange, Price: 105, Weight: 100
Name: Orange, Price: 130, Weight: 125

Comments

[galmacher]

ご回答ありがとうございました。1,2の方法ともに参考になりました。