Überladene Methode überladene Methode aufrufen

Question

Ich habe eine Methode, die ich schreibe, dass eine weitere überladene Methode darin aufrufen. Ich möchte nur eine äußere Methode schreiben, da der Parameter auf die äußere Methode ist an der inneren ein geleitet wird. Gibt es eine Möglichkeit, dies zu tun?

Ich habe versucht, die Verwendung von Generika, aber ich weiß nicht genug, um dies zu, so ist es nicht funktioniert:

public void OuterMethod<T>(T parameter)
{
    InnerMethod(parameter); // InnerMethod accepts an int or a string
}

Ich weiß, dass ich dies tun:

public void OuterMethod(string parameter)
{
    InnerMethod(parameter);
}

public void OuterMethod(int parameter)
{
    InnerMethod(parameter);
}

Aber ich würde lieber tun dies die richtige Art und Weise statt Kopieren / Einfügen von Code. Was ist der beste Weg, dies zu erreichen?

Answer 1

Sie können dies tun, in C ++, aber nicht in C # (es sei denn, die innere Methode auch generisch sein kann, anstatt überlastet).

---

Als Alternative (wenn Sie nicht nehmen ‚Nein‘ für eine Antwort), können Sie einen Laufzeitschalter auf Art tun, wie zum Beispiel ...

public void OuterMethod(object parameter)
{
    if (parameter is int)
        InnerMethod((int)parameter);
    else if (parameter is string)
        InnerMethod((string)parameter);
    else
        throw new SomeKindOfException();
}

... aber natürlich ist dies eine Laufzeit, keine Compile-Zeit zu überprüfen.

  

Aber ich würde lieber statt Kopieren / Einfügen von Code, um diese richtig tun.

Sie können auch Software schreiben Sie Ihre äußere Methoden schreiben (z System.CodeDom Klassen), anstatt sie von Hand zu schreiben, aber das ist wahrscheinlich mehr Mühe, als es wert ist.

Answer 2

Wie die anderen gesagt, kann man nicht wirklich tun, was Sie versuchen, Sie in Ihrer Frage erwähnt zu tun und die Option ist die beste Wahl.

Sie müßten eigentlich den Wert konvertieren, wenn Sie die allgemeine Verwendung. Ansonsten können Sie durch die Annahme eines Objekts niedergeschlagenen als ChrisW vermuten lässt.

 public void OuterMethod<T>(T parameter) 
            {
                T temp = parameter;
                if (temp is string )
                    InnerMethod(Convert.ToString(temp));
                if (temp is int)
                    InnerMethod(Convert.ToInt32(temp));// InnerMethod accepts an int or a string
            }

Hier ist ein Link zur Übersicht des Generics: http: // msdn .microsoft.com / en-us / library / ms172193.aspx

Answer 3

Aus Ihrer Beschreibung erscheint dies wie Überoptimierung.

Wie wäre:

public void OuterMethod(string parameter)
{
    InnerMethod(parameter);
}

public void OuterMethod(int parameter)
{
    InnerMethod(parameter**.ToString()**);
}

Answer 4

Sie können einen dynamic Typen verwenden, um die Überladungsauflösung bis zur Laufzeit zu verschieben.

public void OuterMethod(dynamic parameter)
{
    InnerMethod(parameter);
}

public void InnerMethod(int parameter) { }
public void InnerMethod(string parameter) { }

Caveat Ausdrücke vom Typ dynamischer werden nicht aufgelöst oder Typ vom Compiler überprüft. Und es könnte auch eine Leistungseinbuße sein.

Answer 5

Wenn OuterMethod immer ruft InnerMethod und InnerMethod akzeptiert nur ein int oder string, dann OuterMethod keinen Sinn machen.

Wenn die nur Unterschied ist, dass man nennt InnerMethod (int) und die anderen Anrufe InnerMethod (string) Sie so etwas tun könnte:

public void OuterMethod(string parameter)
{
    InnerMethodA(parameter);
}

public void OuterMethod(int parameter)
{
    InnerMethodA(parameter);
}

private void InnerMethodA(object parameter)
{
    // Whatever other implementation stuff goes here

    if (parameter is string)
    {
        InnerMethodB((string) parameter);
    }
    else if (parameter is int)
    {
        InnerMethodB((string) parameter);
    }
    else
    {
        throw new ArgumentException(...);
    }
}

private void InnerMethodB(string parameter)
{
    // ...
}

private void InnerMethodB(int parameter)
{
    // ...
}

Answer 6

Ok Ich habe eine ähnliche Situation, sein ein Zugriffskontrollverfahren in meiner Business-Logik.

Es gibt eine Funktion speichern, die jedem meiner persistance Schicht Objekte angewendet werden können.

, so dass wie folgt aussieht

public static Save<T>(AccessControl.User user,T entity) where T:PersistanceLayerBaseClass
{
    if(CanWrite(user, entity))
    {
        entity.save();
    }
    else
    {
        throw new Exception("Cannot Save");
    }
}

Wie auch immer ich einige benutzerdefinierte Code für bestimmte Einheiten in Bezug auf die Zugangskontrolle haben, so schrieb ich folgendes, sucht er nach einem Verfahren besser geeignet, um die Frage System.Reflection nutzen „kann diese Entität dieses Benutzers geschrieben werden?“

public static Boolean CanWrite<T>(AccessControl.User user, T entity) where T : PersistanceLayerBaseClass
        {
            int? clubId = null;
            MethodInfo methodInfo = entity.GetType().GetMethod("CanWrite", new Type[] { typeof(AccessControl.User), entity.GetType() });
            if(methodInfo != null)
            {
                return (Boolean)methodInfo.Invoke(null, new object[] { user, entity }) ;
            }
            else 
            {
                //generic answer
            }
            return HasRole(user.UserID, "Administrator") || (clubId.HasValue && user.MemberObject.ClubId == clubId.Value && HasRole(user.UserID, "AdministerClub"));
        }

Nun jedes Mal, wenn ich hinzufügen, oder ein Verfahren entfernen, muß ich nur hinzufügen, oder es an einem Ort entfernen