Suche eine saubere Lösung: zwei Methoden durch eine dynamische ersetzen

Hallo,

habe gerade folgende Funktionen "prodziert" und bin eigentlich der Meinung, dass es eine möglichkeit geben müste diese in eine zu kombienieren, der man dann nur noch ein enum mit den entsprechenden drei Klassenname übergibt.
Mir fällt aber leider nichts ein.

private Type GetLargerFloatType(Type newType, Type refType)
{
	if (refType == null) {
		return newType;
	}
	if (object.ReferenceEquals(refType, typeof(float))) {
		if ((object.ReferenceEquals(newType, typeof(double))) || (object.ReferenceEquals(newType, typeof(decimal)))) {
			return newType;
		}
	}
	if (object.ReferenceEquals(refType, typeof(double))) {
		if ((object.ReferenceEquals(newType, typeof(decimal)))) {
			return newType;
		}
	}
	return refType;
}


private Type GetLargerIntType(Type newType, Type refType)
{
	if (refType == null) {
		return newType;
	}
	if (object.ReferenceEquals(refType, typeof(Int16))) {
		if ((object.ReferenceEquals(newType, typeof(Int32))) || (object.ReferenceEquals(newType, typeof(Int64)))) {
			return newType;
		}
	}
	if (object.ReferenceEquals(refType, typeof(Int32))) {
		if ((object.ReferenceEquals(newType, typeof(Int64)))) {
			return newType;
		}
	}
	return refType;
}

Vielen Dank!

Und was soll das ergeben?

[...]ein enum mit den entsprechenden drei Klassenname übergibt

Was für ein Enum und welche drei Klassennamen?
Außerdem: Ich kann mir zwar in etwa denken, was die Methoden zurückliefern sollen, allerdings wäre es schön, wenn du noch einmal definierst, wann ein Typ "größer" als ein anderer ist.

BTW: Warum vergleichst du nicht einfach mit ==?

Vielleicht bringt dich folgender code weiter:

public Type GetLargerType(Type a, Type b)
{
    int sizeA=Marshal.SizeOf(a);
    int sizeB=Marshal.SizeOf(b);
    return (sizeA>=sizeB)? a:b;
}

Du musst allerdings beim typ char in kombination mit Marshal.SizeOf etwas aufpassen^^

Hallo,

ich weiß nicht obs für dein Problem überhaupt relevant ist, aber

GetLargerFloatType(...)  
...  
typeof(decimal)  
...  

decimal ist kein Fließkommatyp sondern ein Festkommatyp.

Ansonsten sollte der Code schon wesentlich schöner aussehen wenn du dN!3Ls Tipp mit dem Vergleichsoperator berücksichtigst.

decimal ist kein Fließkommatyp sondern ein Festkommatyp.

das Stimmt natürlich, in sofern ist die bezeichnung der Methode sicher nicht optimal gewählt.

wie die genaua Herleitung ist und warum diese so ist würde hier eindeutig zu weit führen und ändert auch nichts an dem Problem. Für meine Zwecke gilt:
int16 < int32 < int64 und:
single< double < decimal

dabei ist die tatsächliche größe des Datentyps egal. Es könnte genauso gelten int < string < datetime (was zugegebener maßen wenig sinnvoll ist, aber nichts am problem ändert.)

meine Grundidee wäre etwas in der Form:

public enum IntTypes
{
	Int16 = 0,
	Int32,
	Int64
}

IntTypes enumType;

private Type GetLargerType(Type newType, Type refType, Type enumType)

so dass es keinen festen Typen zum Vergleich gibt, sondern dieser Dynamisch aus einem übergabeparamter ermittelt wird. Denn die Vergleichslogik ist die selbe, die Methoden unterscheiden sich nur in den Typen.

sry dachte es wäre klar genug gewesen

[edit]

BTW: Warum vergleichst du nicht einfach mit ==?

Arbeite im moment in VB und habs nur schnell durch nen Converter gejagt 😉

Du kannst deine Typen in eine Ordnung bringen und dann beim "größten" Typen anfangen und dann schrittweise prüfen, ob er mit einem übergebenen Typ übereinstimmt. Wenn ja, dann gibst du diesen zurück.

public Type GetGreatestType(params Type[] types)
{
	IEnumerable<Type> orderedTypes = new[] { typeof(Int64), typeof(Int32), typeof(Int16), typeof(Byte), typeof(Decimal), typeof(Double), typeof(Single) };
	foreach (Type currentType in orderedTypes)
		foreach (Type paramType in types)
			if (currentType==paramType)
				return paramType;
	throw new ArgumentException();
}

So gibt dir bspw. GetGreatestType(typeof(Int32),typeof(Int64)); den Typ typeof(Int64) zurück.

ich weiß nicht ob es besser ist als es in zwei funktionen zu machen. So habe ich auch wieder die abhängikeiten in der Funktion. Und auch wenn ich den enumarable raus nehme und als parameter übergebe, finde ich das nicht optimal, da er in für mein Empfinden nicht optimal. Zum einen hab ich dann alle Types an einer Stelle, was lang werden dürfte wenn es erweitert wird und zum anderen hab ich dann immer die Instanzen irgendwo rumliegen (oder müste es jedesmal instanzieiren).

hmm ich muss da noch mal drüber nachdenken. Werde es wohl erstmal bei zwei Funktionen lassen solange keine neuen Anforderungen kommen.

danke für eure Vorschläge.

Wenn ich mir diese zwei Funktionen so anschaue, würde mich gerne der Anwendungsfall interessieren, so etwas in Code gießen zu müssen...