run Upgrade_20211130_ChunksAndMinBy

signumsoftware · Nov 30, 2021 · 45303a1 · 45303a1 · olmobrutall · Nov 30, 2021
1 parent d1ef304
commit 45303a1
Show file tree

Hide file tree

Showing 30 changed files with 57 additions and 165 deletions.
diff --git a/Signum.Engine.Extensions/Authorization/TypeAuthLogic.Conditions.cs b/Signum.Engine.Extensions/Authorization/TypeAuthLogic.Conditions.cs
@@ -134,7 +134,7 @@ static void AssertAllowed<T>(PrimaryKey[] requested, TypeAllowedBasic typeAllowe
     {
         using (DisableQueryFilter())
         {
-            var found = requested.GroupsOf(1000).SelectMany(gr => Database.Query<T>().Where(a => gr.Contains(a.Id)).Select(a => new
+            var found = requested.Chunks(1000).SelectMany(gr => Database.Query<T>().Where(a => gr.Contains(a.Id)).Select(a => new
             {
                 a.Id,
                 Allowed = a.IsAllowedFor(typeAllowed, ExecutionMode.InUserInterface),

diff --git a/Signum.Engine.Extensions/Dynamic/DynamicSqlMigrationLogic.cs b/Signum.Engine.Extensions/Dynamic/DynamicSqlMigrationLogic.cs
@@ -159,7 +159,7 @@ public static void AddDynamicRename(string replacementKey, string oldName, strin
     private static string AutoReplacementEnums(Replacements.AutoReplacementContext ctx)
     {
         StringDistance sd = new StringDistance();
-        return ctx.NewValues!.WithMin(nv => sd.LevenshteinDistance(nv, ctx.OldValue))!;
+        return ctx.NewValues!.MinBy(nv => sd.LevenshteinDistance(nv, ctx.OldValue))!;
     }
 
     public static string? DynamicAutoReplacementsSimple(Replacements.AutoReplacementContext ctx, List<DynamicRenameEntity> lastRenames, string replacementKey)

diff --git a/Signum.Engine.Extensions/Dynamic/DynamicTypeLogic.cs b/Signum.Engine.Extensions/Dynamic/DynamicTypeLogic.cs
@@ -274,7 +274,7 @@ public string GetFileCode()
     public string GetEntityCode()
     {
         StringBuilder sb = new StringBuilder();
-        foreach (var gr in GetEntityAttributes().GroupsOf(a => a.Length, 100))
+        foreach (var gr in GetEntityAttributes().Chunk(a => a.Length, 100))
         {
             sb.AppendLine("[" + gr.ToString(", ") + "]");
         }
@@ -494,7 +494,7 @@ private string GetValidatorAttribute(DynamicValidator v)
 
     protected virtual void WriteAttributeTag(StringBuilder sb, IEnumerable<string> attributes)
     {
-        foreach (var gr in attributes.GroupsOf(a => a.Length, 100))
+        foreach (var gr in attributes.Chunk(a => a.Length, 100))
         {
             sb.AppendLine("[" + gr.ToString(", ") + "]");
         }

diff --git a/Signum.Engine.Extensions/Isolation/IsolationLogic.cs b/Signum.Engine.Extensions/Isolation/IsolationLogic.cs
@@ -195,7 +195,7 @@ public static IEnumerable<T> WhereCurrentIsolationInMemory<T>(this IEnumerable<T
 
     public static Lite<IsolationEntity>? GetOnlyIsolation<T>(IEnumerable<Lite<Entity>> selectedEntities) where T : Entity
     {
-        return selectedEntities.Cast<Lite<T>>().GroupsOf(100).Select(gr =>
+        return selectedEntities.Cast<Lite<T>>().Chunk(100).Select(gr =>
             Database.Query<T>().Where(e => gr.Contains(e.ToLite())).Select(e => e.Isolation()).Only()
             ).NotNull().Only();
     }

diff --git a/Signum.Engine.Extensions/MachineLearning/PredictorSimpleSaver.cs b/Signum.Engine.Extensions/MachineLearning/PredictorSimpleSaver.cs
@@ -62,7 +62,7 @@ public void SavePredictions(PredictorTrainingContext ctx)
 
                     var pc = PredictorPredictLogic.CreatePredictContext(ctx.Predictor);
                     int grIndex = 0;
-                    foreach (var gr in dictionary.GroupsOf(PredictionBatchSize))
+                    foreach (var gr in dictionary.Chunk(PredictionBatchSize))
                     {
                         using (HeavyProfiler.LogNoStackTrace("Group"))
                         {
@@ -110,7 +110,7 @@ public void SavePredictions(PredictorTrainingContext ctx)
 
                     if (SaveAllResults)
                     {
-                        var groups = toInsert.GroupsOf(PredictionBatchSize).ToList();
+                        var groups = toInsert.Chunk(PredictionBatchSize).ToList();
                         foreach (var iter in groups.Iterate())
                         {
                             ctx.ReportProgress($"Inserting {typeof(PredictSimpleResultEntity).NicePluralName()}", iter.Position / (decimal)groups.Count);

diff --git a/Signum.Engine.Extensions/Mailing/EmailPackageLogic.cs b/Signum.Engine.Extensions/Mailing/EmailPackageLogic.cs
@@ -126,7 +126,7 @@ public void Execute(ExecutingProcess executingProcess)
         using (AuthLogic.Disable())
         {
 
-            foreach (var group in emails.GroupsOf(EmailLogic.Configuration.ChunkSizeSendingEmails))
+            foreach (var group in emails.Chunk(EmailLogic.Configuration.ChunkSizeSendingEmails))
             {
                 var retrieved = group.RetrieveFromListOfLite();
                 foreach (var m in retrieved)

diff --git a/Signum.Engine.Extensions/Mailing/Pop3/Pop3ConfigurationLogic.cs b/Signum.Engine.Extensions/Mailing/Pop3/Pop3ConfigurationLogic.cs
@@ -402,7 +402,7 @@ public static Pop3ReceptionEntity ReceiveEmailsFullComparation(this Pop3Configur
                 {
                     var messageInfos = client.GetMessageInfos();
 
-                    var already = messageInfos.Select(a => a.Uid).GroupsOf(50).SelectMany(l =>
+                    var already = messageInfos.Select(a => a.Uid).Chunk(50).SelectMany(l =>
                         (from em in Database.Query<EmailMessageEntity>()
                          let ri = em.Mixin<EmailReceptionMixin>().ReceptionInfo
                          where ri != null && l.Contains(ri.UniqueId)

diff --git a/Signum.Engine.Extensions/Processes/PackageLogic.cs b/Signum.Engine.Extensions/Processes/PackageLogic.cs
@@ -132,7 +132,7 @@ public static PackageEntity CreateLines(this PackageEntity package, IEnumerable<
 
         int inserts =
             lites.GroupBy(a => a.EntityType).Sum(gr =>
-                gr.GroupsOf(100).Sum(gr2 =>
+                gr.Chunk(100).Sum(gr2 =>
                     giInsertPackageLines.GetInvoker(gr.Key)(package, gr2)));
 
         return package;
@@ -144,7 +144,7 @@ public static PackageEntity CreateLines(this PackageEntity package, IEnumerable<
 
         int inserts =
             entities.GroupBy(a => a.GetType()).Sum(gr =>
-                gr.GroupsOf(100).Sum(gr2 =>
+                gr.Chunk(100).Sum(gr2 =>
                     giInsertPackageLines.GetInvoker(gr.Key)(package, gr2.Select(a => a.ToLite()))));
 
         return package;

diff --git a/Signum.Engine.Extensions/Translation/AzureTranslator.cs b/Signum.Engine.Extensions/Translation/AzureTranslator.cs
@@ -58,7 +58,7 @@ public AzureTranslator(Func<string?> azureKey, Func<string?>? region = null, Fun
         if(this.AzureKey() == null)
             return null;
 
-        var result = list.GroupsOf(10).SelectMany(listPart => Task.Run(async () =>
+        var result = list.Chunk(10).SelectMany(listPart => Task.Run(async () =>
         {
             return await this.TranslateBatchAsync(listPart, from, to);
         }).Result!).ToList();

diff --git a/Signum.Engine.Extensions/Translation/TranslatedInstanceSynchronizer.cs b/Signum.Engine.Extensions/Translation/TranslatedInstanceSynchronizer.cs
@@ -16,7 +16,7 @@ public static TypeInstancesChanges GetTypeInstanceChangesTranslated(ITranslator[
 
         totalInstances = instances.Count;
         if (instances.Sum(a => a.TotalOriginalLength()) > MaxTotalSyncCharacters)
-            instances = instances.GroupsOf(a => a.TotalOriginalLength(), MaxTotalSyncCharacters).First().ToList();
+            instances = instances.Chunk(a => a.TotalOriginalLength(), MaxTotalSyncCharacters).First().ToList();
 
         return TranslateInstances(translators, type, targetCulture, instances);
     }

diff --git a/Signum.Engine.Extensions/Translation/TranslationSynchronizer.cs b/Signum.Engine.Extensions/Translation/TranslationSynchronizer.cs
@@ -20,7 +20,7 @@ public static LocalizedAssemblyChanges GetAssemblyChanges(ITranslator[] translat
         totalTypes = types.Count;
 
         if (types.Sum(a => a.TotalOriginalLength()) > MaxTotalSyncCharacters)
-            types = types.GroupsOf(a => a.TotalOriginalLength(), MaxTotalSyncCharacters).First().ToList();
+            types = types.Chunk(a => a.TotalOriginalLength(), MaxTotalSyncCharacters).First().ToList();
 
         var result = Translate(translators, target, types);
 

diff --git a/Signum.Engine.MachineLearning.TensorFlow/TensorFlowNeuralNetworkPredictor.cs b/Signum.Engine.MachineLearning.TensorFlow/TensorFlowNeuralNetworkPredictor.cs
@@ -209,7 +209,7 @@ public void Train(PredictorTrainingContext ctx)
             }
         }
 
-        var best = candidate.WithMin(a => a.ResultValidation.Loss!.Value)!;
+        var best = candidate.MinBy(a => a.ResultValidation.Loss!.Value)!;
 
         p.ResultTraining = best.ResultTraining;
         p.ResultValidation = best.ResultValidation;

diff --git a/Signum.Engine/CodeGeneration/EntityCodeGenerator.cs b/Signum.Engine/CodeGeneration/EntityCodeGenerator.cs
@@ -158,7 +158,7 @@ protected virtual string GetNamespace(string fileName)
 
     protected virtual void WriteAttributeTag(StringBuilder sb, IEnumerable<string> attributes)
     {
-        foreach (var gr in attributes.GroupsOf(a => a.Length, 100))
+        foreach (var gr in attributes.Chunk(a => a.Length, 100))
         {
             sb.AppendLine("[" + gr.ToString(", ") + "]");
         }

diff --git a/Signum.Engine/CodeGeneration/ReactCodeGenerator.cs b/Signum.Engine/CodeGeneration/ReactCodeGenerator.cs
@@ -310,7 +310,7 @@ protected virtual string WriteClientFile(Module mod)
         foreach (var gr in mod.Types.GroupBy(a => a.Namespace))
         {
             sb.AppendLine("import { "
-                + gr.Select(t => t.Name).GroupsOf(5).ToString(a => a.ToString(", "), ",\r\n")
+                + gr.Select(t => t.Name).Chunk(5).ToString(a => a.ToString(", "), ",\r\n")
                 + " } from './" + gr.Key + "'");
         }
 

diff --git a/Signum.Engine/Database.cs b/Signum.Engine/Database.cs
@@ -2,6 +2,7 @@
 using Signum.Engine.Maps;
 using Signum.Entities.Basics;
 using Signum.Entities.Internal;
+using Signum.Utilities;
 using Signum.Utilities.Reflection;
 using System.Collections;
 using System.Collections.ObjectModel;
@@ -701,16 +702,16 @@ static List<T> RetrieveFromDatabaseOrCache<T>(List<PrimaryKey> ids, string? mess
         }
 
         if (message == null)
-            return ids.GroupsOf(Schema.Current.Settings.MaxNumberOfParameters)
+            return ids.Chunk(Schema.Current.Settings.MaxNumberOfParameters)
                 .SelectMany(gr => Database.Query<T>().Where(a => gr.Contains(a.Id)))
                 .ToList();
         else
         {
             SafeConsole.WriteLineColor(ConsoleColor.Cyan, message == "auto" ? "Retriving " + typeof(T).Name : message);
 
             var result = new List<T>();
-            var groups = ids.GroupsOf(Schema.Current.Settings.MaxNumberOfParameters).ToList();
-            groups.ProgressForeach(gr => gr.Count.ToString(), gr =>
+            var groups = ids.Chunk(Schema.Current.Settings.MaxNumberOfParameters).ToList();
+            groups.ProgressForeach(gr => gr.Length.ToString(), gr =>
             {
                 result.AddRange(Database.Query<T>().Where(a => gr.Contains(a.Id)));
             });
@@ -794,7 +795,7 @@ static async Task<List<T>> RetrieveFromDatabaseOrCache<T>(List<PrimaryKey> ids,
             }
         }
 
-        var tasks = ids.GroupsOf(Schema.Current.Settings.MaxNumberOfParameters)
+        var tasks = ids.Chunk(Schema.Current.Settings.MaxNumberOfParameters)
             .Select(gr => Database.Query<T>().Where(a => gr.Contains(a.Id)).ToListAsync(token))
             .ToList();
 
@@ -837,7 +838,7 @@ public static List<Lite<T>> RetrieveListLite<T>(List<PrimaryKey> ids)
                 return ids.Select(id => (Lite<T>)new LiteImp<T>(id, cc.GetToString(id))).ToList();
             }
 
-            var retrieved = ids.GroupsOf(Schema.Current.Settings.MaxNumberOfParameters).SelectMany(gr => Database.Query<T>().Where(a => gr.Contains(a.Id)).Select(a => a.ToLite())).ToDictionary(a => a.Id);
+            var retrieved = ids.Chunk(Schema.Current.Settings.MaxNumberOfParameters).SelectMany(gr => Database.Query<T>().Where(a => gr.Contains(a.Id)).Select(a => a.ToLite())).ToDictionary(a => a.Id);
 
             var missing = ids.Except(retrieved.Keys);
 
@@ -865,7 +866,7 @@ public static async Task<List<Lite<T>>> RetrieveListLiteAsync<T>(List<PrimaryKey
                 return ids.Select(id => (Lite<T>)new LiteImp<T>(id, cc.GetToString(id))).ToList();
             }
 
-            var tasks = ids.GroupsOf(Schema.Current.Settings.MaxNumberOfParameters)
+            var tasks = ids.Chunk(Schema.Current.Settings.MaxNumberOfParameters)
                 .Select(gr => Database.Query<T>().Where(a => gr.Contains(a.Id)).Select(a => a.ToLite()).ToListAsync(token))
                 .ToList();
 
@@ -1059,7 +1060,7 @@ public static void DeleteList<T>(IList<PrimaryKey> ids)
         {
             using (var tr = new Transaction())
             {
-                var groups = ids.GroupsOf(Schema.Current.Settings.MaxNumberOfParameters);
+                var groups = ids.Chunk(Schema.Current.Settings.MaxNumberOfParameters);
                 int result = 0;
                 foreach (var group in groups)
                     result += Database.Query<T>().Where(a => group.Contains(a.Id)).UnsafeDelete();

diff --git a/Signum.Engine/Engine/Saver.cs b/Signum.Engine/Engine/Saver.cs
@@ -94,7 +94,7 @@ private static void SaveGraph(Schema schema, DirectedGraph<Entity> identifiables
         {
             IGrouping<(Type type, bool isNew), Entity> group = clone.Sinks()
                 .GroupBy(ident => (ident.GetType(), ident.IsNew))
-                .WithMin(g => stats[g.Key] - g.Count())!;
+                .MinBy(g => stats[g.Key] - g.Count())!;
 
             foreach (var node in group)
                 clone.RemoveFullNode(node, inv.RelatedTo(node));

diff --git a/Signum.Engine/Engine/Synchronizer.cs b/Signum.Engine/Engine/Synchronizer.cs
@@ -300,7 +300,7 @@ public virtual void AskForReplacements(
 
         while (oldOnly.Count > 0 && newOnly.Count > 0)
         {
-            var oldDist = distances.WithMin(kvp => kvp.Value.Values.Min());
+            var oldDist = distances.MinBy(kvp => kvp.Value.Values.Min());
 
             var alternatives = oldDist.Value.OrderBy(a => a.Value).Select(a => a.Key).ToList();
 

diff --git a/Signum.Engine/Operations/OperationLogic.cs b/Signum.Engine/Operations/OperationLogic.cs
@@ -673,7 +673,7 @@ internal static Dictionary<OperationSymbol, string> GetContextualGraphCanExecute
     {
         var getState = Graph<E, S>.GetState;
 
-        var states = lites.GroupsOf(200).SelectMany(list =>
+        var states = lites.Chunk(200).SelectMany(list =>
             Database.Query<T>().Where(e => list.Contains(e.ToLite())).Select(getState).Distinct()).Distinct().ToList();
 
         return (from o in operations.Cast<Graph<E, S>.IGraphFromStatesOperation>()

diff --git a/Signum.Engine/Patterns/DeletePart.cs b/Signum.Engine/Patterns/DeletePart.cs
@@ -35,7 +35,7 @@ public static FluentInclude<T> WithDeletePart<T, L>(this FluentInclude<T> fi, Ex
             var toDelete = filteredQuery.Select(relatedEntity).Select(a => a.ToLite()).ToList().NotNull().Distinct().ToList();
             return new Disposable(() =>
             {
-                var groups = toDelete.GroupsOf(Connector.Current.Schema.Settings.MaxNumberOfParameters).ToList();
+                var groups = toDelete.Chunk(Connector.Current.Schema.Settings.MaxNumberOfParameters).ToList();
                 groups.ForEach(l => Database.DeleteList(l));
             });
         };

diff --git a/Signum.Engine/Retriever.cs b/Signum.Engine/Retriever.cs
@@ -180,7 +180,7 @@ public async Task CompleteAllPrivate(CancellationToken? token)
         {
             while (requests.Count > 0)
             {
-                var group = requests.WithMax(a => a.Value.Count);
+                var group = requests.MaxBy(a => a.Value.Count);
 
                 var dic = group.Value;
 
@@ -305,7 +305,7 @@ static async Task<Dictionary<PrimaryKey, string>> GetStrings<T>(List<PrimaryKey>
         }
         else if (token != null)
         {
-            var tasks = ids.GroupsOf(Schema.Current.Settings.MaxNumberOfParameters)
+            var tasks = ids.Chunk(Schema.Current.Settings.MaxNumberOfParameters)
                .Select(gr => Database.Query<T>().Where(e => gr.Contains(e.Id)).Select(a => KeyValuePair.Create(a.Id, a.ToString())).ToListAsync(token!.Value))
                .ToList();
 
@@ -316,7 +316,7 @@ static async Task<Dictionary<PrimaryKey, string>> GetStrings<T>(List<PrimaryKey>
         }
         else
         {
-            var dic = ids.GroupsOf(Schema.Current.Settings.MaxNumberOfParameters)
+            var dic = ids.Chunk(Schema.Current.Settings.MaxNumberOfParameters)
                 .SelectMany(gr => Database.Query<T>().Where(e => gr.Contains(e.Id)).Select(a => KeyValuePair.Create(a.Id, a.ToString())))
                 .ToDictionaryEx();
 

diff --git a/Signum.Entities.Extensions/Authorization/ActiveDirectoryConfiguration.cs b/Signum.Entities.Extensions/Authorization/ActiveDirectoryConfiguration.cs
@@ -1,3 +1,4 @@
+using Signum.Entities.Scheduler;
 using System.ComponentModel;
 
 namespace Signum.Entities.Authorization;
@@ -163,3 +164,10 @@ public static class ADGroupOperation
     public static readonly ExecuteSymbol<ADGroupEntity> Save;
     public static readonly DeleteSymbol<ADGroupEntity> Delete;
 }
+
+[AutoInit]
+public static class ActiveDirectoryTask
+{
+    public static readonly SimpleTaskSymbol DeactivateUsers;
+}
+
diff --git a/Signum.React.Extensions/Authorization/ActiveDirectoryController.cs b/Signum.React.Extensions/Authorization/ActiveDirectoryController.cs
@@ -18,7 +18,7 @@ public Task<List<ActiveDirectoryUser>> FindADUsers(string subString, int count,
     {
         var config = ((ActiveDirectoryAuthorizer)AuthLogic.Authorizer!).GetConfig();
         if (config.Azure_ApplicationID.HasText())
-            return MicrosoftGraphLogic.FindActiveDirectoryUsers(subString, count, token);
+            return AzureADLogic.FindActiveDirectoryUsers(subString, count, token);
 
         if (config.DomainName.HasText())
             return ActiveDirectoryLogic.SearchUser(subString);
@@ -33,7 +33,7 @@ public Lite<UserEntity> CreateADUser([FromBody][Required] ActiveDirectoryUser us
         var config = ((ActiveDirectoryAuthorizer)AuthLogic.Authorizer!).GetConfig();
 
         if (config.Azure_ApplicationID.HasText())
-            return MicrosoftGraphLogic.CreateUserFromAD(user).ToLite();
+            return AzureADLogic.CreateUserFromAD(user).ToLite();
 
         if (config.DomainName.HasText())
             return ActiveDirectoryLogic.CreateUserFromAD(user).ToLite();

diff --git a/Signum.React.Extensions/Authorization/Signum.Entities.Authorization.ts b/Signum.React.Extensions/Authorization/Signum.Entities.Authorization.ts
@@ -7,6 +7,7 @@ import * as Entities from '../../Signum.React/Scripts/Signum.Entities'
 import * as Basics from '../../Signum.React/Scripts/Signum.Entities.Basics'
 import * as Signum from '../Basics/Signum.Entities.Basics'
 import * as Mailing from '../Mailing/Signum.Entities.Mailing'
+import * as Scheduler from '../Scheduler/Signum.Entities.Scheduler'
 
 export interface UserEntity {
     newPassword: string;
@@ -59,6 +60,10 @@ export module ActiveDirectoryPermission {
   export const InviteUsersFromAD : PermissionSymbol = registerSymbol("Permission", "ActiveDirectoryPermission.InviteUsersFromAD");
 }
 
+export module ActiveDirectoryTask {
+  export const DeactivateUsers : Scheduler.SimpleTaskSymbol = registerSymbol("SimpleTask", "ActiveDirectoryTask.DeactivateUsers");
+}
+
 export const ADGroupEntity = new Type<ADGroupEntity>("ADGroup");
 export interface ADGroupEntity extends Entities.Entity {
   Type: "ADGroup";

diff --git a/Signum.Upgrade/Upgrades/Upgrade_20211130_ChunksAndMinBy.cs b/Signum.Upgrade/Upgrades/Upgrade_20211130_ChunksAndMinBy.cs
@@ -2,15 +2,15 @@ namespace Signum.Upgrade.Upgrades;
 
 class Upgrade_20211130_ChunksAndMinBy : CodeUpgradeBase
 {
-    public override string Description => "Replace some Signum.Utilities methods (GroupsOf, WithMin, WithMax) with the .Net 6 counterparts (Chunks, MinBy, MaxBy)";
+    public override string Description => "Replace some Signum.Utilities methods (GroupsOf, WithMin, WithMax) with the .Net 6 counterparts (Chunk, MinBy, MaxBy)";
 
     public override void Execute(UpgradeContext uctx)
     {
         uctx.ForeachCodeFile(@"*.cs", file =>
         {
             file.Replace(".WithMin(", ".MinBy(");
             file.Replace(".WithMax(", ".MaxBy(");
-            file.Replace(".GroupsOf(", ".Chunks(");
+            file.Replace(".GroupsOf(", ".Chunk(");
         });
     }
 }
diff --git a/Signum.Utilities/ConsoleSwitch.cs b/Signum.Utilities/ConsoleSwitch.cs
@@ -204,7 +204,7 @@ int GetIndex(string value)
             return exact;
 
         var sd = new StringDistance();
-        var best = dictionary.Keys.WithMin(a => sd.LevenshteinDistance(input.ToLowerInvariant(), a.ToLowerInvariant()));
+        var best = dictionary.Keys.MinBy(a => sd.LevenshteinDistance(input.ToLowerInvariant(), a.ToLowerInvariant()));
         if (best != null && sd.LevenshteinDistance(input.ToLowerInvariant(), best.ToLowerInvariant()) <= 2)
         {
             if (SafeConsole.Ask($"Did you mean '{best}'?"))

diff --git a/Signum.Utilities/DataStructures/DirectedEdgedGraph.cs b/Signum.Utilities/DataStructures/DirectedEdgedGraph.cs
@@ -496,7 +496,7 @@ public DirectedEdgedGraph<T, E> FeedbackEdgeSet()
 
             Func<T, int> fanInOut = n => clone.RelatedTo(n).Count() - inv.RelatedTo(n).Count();
 
-            MinMax<T> mm = clone.WithMinMaxPair(fanInOut);
+            MinMax<T> mm = clone.MinMaxBy(fanInOut);
 
             if (fanInOut(mm.Max) > -fanInOut(mm.Min))
             {

diff --git a/Signum.Utilities/DataStructures/DirectedGraph.cs b/Signum.Utilities/DataStructures/DirectedGraph.cs
@@ -464,7 +464,7 @@ public DirectedGraph<T> FeedbackEdgeSet()
 
             int fanInOut(T n) => clone.RelatedTo(n).Count() - inv.RelatedTo(n).Count();
 
-            MinMax<T> mm = clone.WithMinMaxPair(fanInOut);
+            MinMax<T> mm = clone.MinMaxBy(fanInOut);
 
             if (fanInOut(mm.Max) > -fanInOut(mm.Min))
             {