Generische Mathematik (Überblick), generische Attribute (falls relevant)
Emulieren Sie generische Mathematik ohne moderne Sprachfunktionen: Übergeben Sie einen Ops-Provider oder Delegates, schränken Sie Typen sorgfältig ein und simulieren Sie „generische Attribute“ über Type-Parameter.
Generische Mathematik (Überblick), generische Attribute (falls relevant) ist eine kostenlose C# Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 3. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C# Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C# Academy-Kurs umfasst insgesamt 3 Lektionen.
Generische Arithmetik in C# 6
Ziel: Numerische Algorithmen in C# 6 generisch schreiben.
- Keine statischen abstrakten Operatoren für T
- Workarounds: eine ops-provider-Schnittstelle oder kleine Delegates
- Für Annotationen: Attribute mit Type-Parametern verwenden
Ops-Provider-Muster
Stellen Sie Zero und Add über eine Schnittstelle bereit. Der generische Algorithmus ruft diese Methoden auf, statt + für T zu verwenden.
using System;
using System.Collections.Generic;
public interface INumericOps<T>
{
T Zero { get; }
T Add(T a, T b);
}
public sealed class IntOps : INumericOps<int>
{
public int Zero { get { return 0; } }
public int Add(int a, int b) { return a + b; }
}
public sealed class DoubleOps : INumericOps<double>
{
public double Zero { get { return 0.0; } }
public double Add(double a, double b) { return a + b; }
}
public class Program
{
static T Sum<T>(IEnumerable<T> items, INumericOps<T> ops)
{
T acc = ops.Zero;
foreach (T x in items) acc = ops.Add(acc, x);
return acc;
}
public static void Main(string[] args)
{
int s1 = Sum(new int[] {1,2,3}, new IntOps());
double s2 = Sum(new double[] {1.5, 2.0}, new DoubleOps());
Console.WriteLine("Sum int = " + s1);
Console.WriteLine("Sum double = " + s2);
}
}
Durchschnitt mit Helfern
Für Vorgänge, die sich nicht generisch ausdrücken lassen (etwa Division), übergeben Sie einen kleinen Konverter oder ein zusätzliches Delegate.
using System;
using System.Collections.Generic;
public interface INumericOps<T>
{
T Zero { get; }
T Add(T a, T b);
}
public sealed class DoubleOps : INumericOps<double>
{
public double Zero { get { return 0.0; } }
public double Add(double a, double b) { return a + b; }
}
public class Program
{
static double Average<T>(IEnumerable<T> items, INumericOps<T> ops, Func<T,double> toDouble)
{
T acc = ops.Zero;
int count = 0;
foreach (T x in items) { acc = ops.Add(acc, x); count++; }
if (count == 0) throw new ArgumentException("Empty sequence", "items");
// convert with a delegate for division
return toDouble(acc) / count;
}
public static void Main(string[] args)
{
double avg = Average<double>(new double[] {2.0, 4.0, 6.0}, new DoubleOps(), delegate(double d) { return d; });
Console.WriteLine("Avg = " + avg);
}
}
Fold mit Delegates
Delegates halten den Ansatz minimal: Übergeben Sie einen Startwert und eine Kombinationsfunktion. Das eignet sich gut für kleine Hilfsfunktionen.
using System;
public class Program
{
static T Fold<T>(T[] xs, T seed, Func<T,T,T> combine)
{
T acc = seed;
for (int i = 0; i < xs.Length; i++) acc = combine(acc, xs[i]);
return acc;
}
public static void Main(string[] args)
{
int sum = Fold<int>(new int[] {1,2,3}, 0, delegate(int a, int b) { return a + b; });
double sumD = Fold<double>(new double[] {1.5, 2.5}, 0.0, delegate(double a, double b) { return a + b; });
Console.WriteLine("Sum ints = " + sum);
Console.WriteLine("Sum doubles = " + sumD);
}
}
Workaround für Attribute
In C# 6 gibt es keine echten generischen Attribute. Übergeben Sie dem Attribut ein Type, um den zugehörigen generischen Typ anzugeben.
using System;
using System.Reflection;
// C# 6 cannot declare generic attributes. Workaround: pass a Type.
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
public sealed class ValidatorForAttribute : Attribute
{
public Type TargetType { get; private set; }
public ValidatorForAttribute(Type targetType) { TargetType = targetType; }
}
public sealed class Customer { public string Name; }
[ValidatorFor(typeof(Customer))]
public sealed class CustomerValidator
{
public bool IsValid(Customer c) { return c != null && !string.IsNullOrEmpty(c.Name); }
}
public class Program
{
public static void Main(string[] args)
{
Type t = typeof(CustomerValidator);
object[] attrs = t.GetCustomAttributes(typeof(ValidatorForAttribute), false);
if (attrs.Length > 0)
{
ValidatorForAttribute a = (ValidatorForAttribute)attrs[0];
Console.WriteLine("Validator targets: " + a.TargetType.Name);
}
}
}
Tipps und Auswahl
Tipps:
- Bevorzugen Sie für wiederverwendbare numerische Algorithmen einen ops-provider.
- Verwenden Sie Delegates für kleine Hilfsfunktionen (Kombinieren, Konvertieren).
- Übergeben Sie für Annotationen Type in Attributen und lesen Sie den Wert per Reflection aus.
Workaround für generische Arithmetik
Zusammenfassung
Zusammenfassung: Übergeben Sie Ihren Algorithmen ohne moderne generische Arithmetik ops oder Delegates. Verwenden Sie für Annotationen Attribute, die einen Type enthalten, und lesen Sie ihn per Reflection aus.
Häufig gestellte Fragen
Ist die Lektion „Generische Mathematik (Überblick), generische Attribute (falls relevant)“ kostenlos?
Ja — der vollständige Text von „Generische Mathematik (Überblick), generische Attribute (falls relevant)“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C# Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C# Academy-Kurs umfasst insgesamt 3 Lektionen.
Was lerne ich in „Generische Mathematik (Überblick), generische Attribute (falls relevant)“?
Emulieren Sie generische Mathematik ohne moderne Sprachfunktionen: Übergeben Sie einen Ops-Provider oder Delegates, schränken Sie Typen sorgfältig ein und simulieren Sie „generische Attribute“ über T… Du übst C# Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um C# Academy zu starten?
Keine Vorkenntnisse erforderlich. C# Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 3.
Wie lange dauert die Lektion „Generische Mathematik (Überblick), generische Attribute (falls relevant)“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser C# Academy-Lektion Code schreiben und ausführen?
Ja. Jede C# Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- unmanaged, notnull, new() (C#-6-Emulation)
- Generische Mathematik (Überblick), generische Attribute (falls relevant)
- Wiederverwendbare generische Hilfsfunktionen