Map- und Reduce-Funktionen in C# erstellen

1. Verwenden Sie LINQ, um Map- und Reduce-Funktionen in C# zu erstellen
2. Erstellen Sie Map- und Reduce-Funktionen von Grund auf neu in C#

Die Funktionen Map und Reduce in C# wurden entwickelt, um Algorithmen zur Verarbeitung einer grossen Menge an Rohdaten zu schreiben. Parallel Computing ermöglicht es Entwicklern, solch große Mengen verteilter Daten zu verarbeiten, um die erforderliche Berechnung in der Nähe des Datenspeicherorts auszuführen.

In diesem Tutorial lernen Sie zwei verschiedene Methoden zur Verwendung und Erstellung der Funktionen Map und Reduce und deren Implementierung in C# kennen. Sie können diese Funktionen entweder von Grund auf neu schreiben oder mit Hilfe von LINQ, während Sie die Komplexität der Parallelisierung, Datenverteilung, Fehlertoleranz usw. verbergen.

Sowohl die Map- als auch die Reduce-Funktion laufen auf einem unabhängigen Satz von Eingabedaten, und jede Funktion verarbeitet ihre Datenquelle.

Der Cluster Map und Reduce umfasst mehrere Computer, was zusätzliche Komplexität in den Prozess bringt. C#-Entwickler müssen mit Multithread-Programmierung und Sperren vertraut sein, wenn sie Algorithmen von parallel ausgeführten Map- und Reduce-Programmen schreiben.

Verwenden Sie LINQ, um Map- und Reduce-Funktionen in C# zu erstellen

Die Funktionen Map und Reduce implementieren verschiedene mathematische Algorithmen, um Aufgaben in kleine Teile zu zerlegen und sie mehreren Systemen zuzuweisen. Technisch gesehen hilft der Map- und Reduce-Algorithmus dabei, die Sortier-, Such-, Indizierungs- und andere Map- und Reduce-Aufgaben an die entsprechenden Server in einem Cluster zu senden.

Während Map- und Reduce-Funktionen, die LINQ verwenden, agile und belastbare Ansätze zur Lösung von Big-Data-Problemen sind, bedeutet ihre inhärente Komplexität, dass C#-Entwickler Zeit brauchen, um sich Fachwissen anzueignen. Die logische Ausführung eines einfachen Map- und Reduce-Programms sieht so aus:

// Logical execution

map(String key, String value):
    // key: it holds the name of a document
    // value: it holds the content of a document
    for each word i in value:
        EmitIntermediate(i, "1");

reduce(String key, Iterator values):
    // key: it represents a word
    // values: it holds the values of a work
    int result = 0;
    for each x in values:
        resultReduce += ParseInt(x);
    Emit(AsString(resultReduce));

Die funktionale C#-Programmierung mit LINQ ist ein beliebter Ansatz zum Schreiben von Algorithmen. LINQ und C# 3.5 und höher haben ähnliche Funktionen unter anderen Namen.

1. Die Karte ist für Auswählen | Enumerable.Range(1, 10).Select(x => x + 2);.
2. Das Reduzieren steht für Aggregat | Enumerable.Range(1, 10).Aggregate(0, (acc, x) => acc + x);.

Mit LINQ können Sie die oben beschriebenen Programme Map und Reduce implementieren:

Map-Funktion in C# mit LINQ:

// Add `System.Linq` and `System.Collections.Generic` namespace references in your C# project before
// executing the code
using System;
using System.Collections.Generic;
using System.Linq;
using static System.Console;

// Map function in C# using LINQ
namespace MapReduce {
  class ProgramMap {
    static void Main(string[] args) {
      var numbers = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
      var result = numbers.Select(x => x * x).ToArray();
      foreach (var n in result) Write(n + " ");
      Console.Read();
    }
  }
}

Reduce-Funktion in C# mit LINQ:

// Add `System.Linq` and `System.Collections.Generic` namespace referances in your C# project before
// executing the code
using System;
using System.Collections.Generic;
using System.Linq;
using static System.Console;

// Reduce function in C# using LINQ
namespace MapReduce {
  class ProgramMap {
    static void Main(string[] args) {
      var numbers = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
      var result = numbers.Aggregate((acc, x) => acc + x);
      WriteLine($"Sum = {result}");
      Console.Read();
    }
  }
}

Map und Reduce in C# verarbeiten große Datenmengen, und viele Frameworks wie MapReduce und Hadoop implementieren diese Funktionen. Das C#-Programm Map und Reduce mit LINQ veranschaulicht Prozesse, die auf einem einzelnen Computer ausgeführt werden, wobei mehrere Threads gleichzeitig verschiedenen Teilen der Eingabedaten zugeordnet werden, wobei die Zuordnungsergebnisse an einem zentralen Ort zur weiteren Verarbeitung durch andere Threads abgelegt werden, wobei Reduce funktioniert.

Erstellen Sie Map- und Reduce-Funktionen von Grund auf neu in C#

Wenn Sie mit relationalen Datenbanken arbeiten und auf Datenaggregation stoßen, denken Sie sofort an eine GroupBy-Klausel und die Standardoperationen wie Min, Max und Count. Die Funktionen Map und reduce in C# sind eine Form der Datenaggregation, bei der Sie eine große Menge an Informationen nehmen und in kleinere Teile reduzieren können.

Vor dem Reduzieren können Sie die Informationen in ein strukturelles Design für den benutzerdefinierten Reduzierprozess übersetzen (abbilden). Die Map ist eine Funktion höherer Ordnung, die eine Funktion annimmt, und eine Liste wendet diese Funktion auf jede Liste an und gibt die resultierende Liste zurück.

Gegeben sei die Funktion x = x + 2 und eine Liste von ganzen Zahlen 1 -> 3. Das Folgende ist die C#-Implementierung der Map-Funktion:

static void Main(string[] args) {
  var testList = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
  var mapList = Map<int, int>(x => x + 2, testList);

  mapList.ToList<int>().ForEach(i => Console.Write(i + " "));
  Console.WriteLine();
  Console.ReadKey();
}

static IEnumerable<TResult> Map<T, TResult>(Func<T, TResult> func, IEnumerable<T> list) {
  foreach (var i in list) yield return func(i);
}

Ausgang:

3 4 5 6 7 8 9 10 11 12

“Reduzieren” nimmt eine Liste von Elementen und gibt eine Funktion zurück, die auf alle Elemente dieser Liste angewendet wird. Bei gegebener Funktion (x, t) => x + y und einer Liste der Elemente 1 bis 3 lautet die C#-Implementierung der Funktion Reduce wie folgt:

static void Main(string[] args) {
  var testList = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
  Console.WriteLine(Reduce<int, int>((x, y) => x + y, testList, 0));
  Console.ReadKey();
}

static T Reduce<T, U>(Func<U, T, T> func, IEnumerable<U> list, T acc) {
  foreach (var i in list) acc = func(i, acc);

  return acc;
}

Ausgang:

55

Map- und Reduce-Funktionen als Abstraktionen höherer Ordnung verdecken die Parallelisierung zu tiefer liegenden Funktionen.

In C# kümmert sich das zugrunde liegende System um das Ausführen und Verwalten der Ausführung der Funktionen Map und Reduce, und echte Komplexität und Raffinesse können vermieden werden, indem Sie selbst eine schreiben.

In diesem Tutorial haben Sie die Grundkonzepte von Map und Reduce gelernt und wie Sie diese in C# erstellen und verwenden.

Mit oder ohne LINQ in C# bieten die Funktionen Map und Reduce einen innovativen Ansatz für die schnelle Nutzung extrem grosser und komplexer Datenverarbeitungsaufgaben. Die Sprache C# eignet sich gut für die Verarbeitung von Map und Reduce.

Mit Hilfe der Funktionen Map und Reduce lassen sich EDV-Aufgaben nahezu jeder Grösse abdecken.