public static void Main(String[] args)
{
SCG.IComparer <Rec <string, int> > lexico1 = new Lexico();
SCG.IComparer <Rec <string, int> > lexico2 =
new DelegateComparer <Rec <string, int> >(
delegate(Rec <string, int> item1, Rec <string, int> item2) {
int major = item1.X1.CompareTo(item2.X1);
return(major != 0 ? major : item1.X2.CompareTo(item2.X2));
});
Rec <String, int> r1 = new Rec <String, int>("Carsten", 1962);
Rec <String, int> r2 = new Rec <String, int>("Carsten", 1964);
Rec <String, int> r3 = new Rec <String, int>("Christian", 1932);
Console.WriteLine(lexico1.Compare(r1, r1) == 0);
Console.WriteLine(lexico1.Compare(r1, r2) < 0);
Console.WriteLine(lexico1.Compare(r2, r3) < 0);
Console.WriteLine(lexico2.Compare(r1, r1) == 0);
Console.WriteLine(lexico2.Compare(r1, r2) < 0);
Console.WriteLine(lexico2.Compare(r2, r3) < 0);
SCG.IComparer <String> rev
= ReverseComparer <String>(Comparer <String> .Default);
Console.WriteLine(rev.Compare("A", "A") == 0);
Console.WriteLine(rev.Compare("A", "B") > 0);
Console.WriteLine(rev.Compare("B", "A") < 0);
}
private bool SortAndAdd(StringComparison stringComparison, [CanBeNull] XElement newNode)
{
var comparer = new DelegateComparer <string>((left, right) => string.Compare(left, right, stringComparison));
string GetName(XElement node) => node.Attribute(_nameAttributeName)?.Value.TrimStart('>') ?? string.Empty;
var nodes = _documentRoot
.Elements(_dataNodeName)
.ToArray();
var sortedNodes = nodes
.OrderBy(node => GetName(node), comparer)
.ToArray();
var hasContentChanged = SortNodes(nodes, sortedNodes);
if (newNode == null)
{
return(hasContentChanged);
}
var newNodeName = GetName(newNode);
var nextNode = sortedNodes.FirstOrDefault(node => comparer.Compare(GetName(node), newNodeName) > 0);
if (nextNode != null)
{
nextNode.AddBeforeSelf(newNode);
}
else
{
_documentRoot.Add(newNode);
}
return(true);
}
public void Test()
{
// Test a senseless comparison operator.
var c = new DelegateComparer <int>((x, y) => x + y);
Assert.AreEqual(10, c.Compare(3, 7));
}
public void compare_delegates_to_comparison_method()
{
var comparer = new DelegateComparer<int>((x, y) =>
{
Assert.Equal(x, 1);
Assert.Equal(y, 2);
return 3;
});
Assert.Equal(3, comparer.Compare(1, 2));
}
public void Task_01_Compare()
{
var c = new DelegateComparer <string>((x, y) => string.Compare(x, y, StringComparison.Ordinal));
c.Compare(null, null).Should().Be(0);
c.Compare(null, "A").Should().BeLessThan(0);
c.Compare("A", null).Should().BeGreaterThan(0);
c.Compare("A", "A").Should().Be(0);
c.Compare("A", "B").Should().BeLessThan(0);
c.Compare("B", "A").Should().BeGreaterThan(0);
}
public static void AddRange <T, TSort, TEquality>(
this ObservableCollection <T> target,
IEnumerable <T> collection,
Func <T, TSort> sortSelector,
Func <T, TEquality> equalitySelector)
where TSort : IComparable
{
var sortComparer = new DelegateComparer <T>(
(x, y) => sortSelector(x).CompareTo(sortSelector(y)));
var equalityComparer = new DelegateEqualityComparer <T>(
(x, y) => equalitySelector(x).Equals(equalitySelector(y)));
var index = target.Count - 1;
foreach (var addItem in collection.OrderBy(sortSelector))
{
if (index < 0)
{
target.Insert(0, addItem);
}
else
{
while (index >= 0)
{
var currentItem = target[index];
if (sortComparer.Compare(currentItem, addItem) >= 0)
{
if (equalityComparer.Equals(currentItem, addItem) != true)
{
target.Insert(index + 1, addItem);
}
break;
}
index -= 1;
}
}
}
}
public void Test()
{
// Test a senseless comparison operator.
var c = new DelegateComparer<int>((x, y) => x + y);
Assert.AreEqual(10, c.Compare(3, 7));
}
