Gegeben eine Art Instanz, wie eine generische Typ-Namen in C#?

Gegeben ein generischer Typ, einschließlich

List<string>
Nullable<Int32>

wie bekomme ich ein generischer name für C#?

var t = typeof(Nullable<DateTime>);    
var s = t.GetGenericTypeDefinition().Name + "<" + t.GetGenericArguments()[0].Name + ">";

Diese Erträge

"Nullable`1<DateTime>"

aber ich brauche

"Nullable<DateTime>"

InformationsquelleAutor George Polevoy | 2010-03-15

c#code-generation reflection

58

Sehe ich Sie bereits akzeptiert eine Antwort, aber ganz ehrlich, diese Antwort ist nicht genug, um dazu zuverlässig, wenn Sie kombinieren Sie einfach, was es mit dem, was du schon geschrieben hast. Es ist auf dem richtigen Weg, aber dein code funktioniert nur für generische Typen mit genau einen generischen parameter, und es funktioniert nur, wenn der generische Typ-parameter selbst ist nicht generisch!

Dies ist eine Funktion (geschrieben als eine Erweiterung Methode), die sollte eigentlich in allen Fällen funktionieren:
```
public static class TypeExtensions
{
    public static string ToGenericTypeString(this Type t)
    {
        if (!t.IsGenericType)
            return t.Name;
        string genericTypeName = t.GetGenericTypeDefinition().Name;
        genericTypeName = genericTypeName.Substring(0,
            genericTypeName.IndexOf('`'));
        string genericArgs = string.Join(",",
            t.GetGenericArguments()
                .Select(ta => ToGenericTypeString(ta)).ToArray());
        return genericTypeName + "<" + genericArgs + ">";
    }
}
```
Diese Funktion ist rekursiv und sicher. Wenn Sie führen Sie es auf dieses input:
```
Console.WriteLine(
    typeof(Dictionary<string, List<Func<string, bool>>>)
    .ToGenericTypeString());
```
Erhalten Sie diese (korrekte) Ausgabe:
```
Dictionary<String,List<Func<String,Boolean>>>
```
- Es ist eine Schande, dass die CLR nicht kommen mit dieser Funktion.
- Ruane: ich Stimme zu, dass es nützlich sein könnte, in bestimmten Fällen jedoch, die CLR ist sprachunabhängig, und es gäbe keine Möglichkeit, etwas umzusetzen, wie dies so funktionieren genauso gut in C#, VB.NET, F#, IronPython, und alle anderen CLR-Sprachen. Die seltsam aussehenden Namen mit der backtick ist eigentlich die true CLR-Typ name; format über C# - spezifisch.
- Ah ja, guter Punkt. Ich habe tunnel C# - vision!
- Es könnte mindestens eine helper-Funktion in der Microsoft.Namespace CSharp. Dieser namespace enthält die Sprache-spezifische Klassen.
- Während diese Antwort ist wirklich toll, es wird nicht funktionieren, wenn der Umgang mit geschachtelten Klassen oder arrays von generischen Objekten, siehe meine Antwort für eine vollständige Lösung
InformationsquelleAutor Aaronaught

Während die akzeptierte Lösung ist gut nur für den Namen oder für eine nicht verschachtelte vollständigen Namen (durch ersetzen von Namen, vollständiger name, wie in @Ose-E Antwort), aber für geschachtelte Typen, die es immer noch nicht funktionieren, und auch nicht für arrays von generischen Typen.

So, hier ist eine Lösung, die funktioniert, (aber beachten Sie, dass diese Lösung werden nur die tatsächlichen Argumente, nur, wenn alle Argumente gesetzt sind, und in anderen Worten, selbst wenn die Deklaration Typ geliefert hat, geben Sie arguemts, solange der innerste generischen Typ nicht, es wird immer noch nicht angezeigt, auch für die Basis).

    public static string ToGenericTypeString(this Type t, params Type[] arg)
    {
        if (t.IsGenericParameter || t.FullName == null) return t.Name;//Generic argument stub
        bool isGeneric = t.IsGenericType || t.FullName.IndexOf('`') >= 0;//an array of generic types is not considered a generic type although it still have the genetic notation
        bool isArray = !t.IsGenericType && t.FullName.IndexOf('`') >= 0;
        Type genericType = t;
        while (genericType.IsNested && genericType.DeclaringType.GetGenericArguments().Count()==t.GetGenericArguments().Count())//Non generic class in a generic class is also considered in Type as being generic
        {
            genericType = genericType.DeclaringType;
        }
        if (!isGeneric) return t.FullName.Replace('+', '.');

        var arguments = arg.Any() ? arg : t.GetGenericArguments();//if arg has any then we are in the recursive part, note that we always must take arguments from t, since only t (the last one) will actually have the constructed type arguments and all others will just contain the generic parameters
        string genericTypeName = genericType.FullName;
        if (genericType.IsNested)
        {
            var argumentsToPass = arguments.Take(genericType.DeclaringType.GetGenericArguments().Count()).ToArray();//Only the innermost will return the actual object and only from the GetGenericArguments directly on the type, not on the on genericDfintion, and only when all parameters including of the innermost are set
            arguments = arguments.Skip(argumentsToPass.Count()).ToArray();
            genericTypeName = genericType.DeclaringType.ToGenericTypeString(argumentsToPass) + "." + genericType.Name;//Recursive
        }
        if (isArray)
        {
            genericTypeName = t.GetElementType().ToGenericTypeString() + "[]";//this should work even for multidimensional arrays
        }
        if (genericTypeName.IndexOf('`') >= 0)
        {
            genericTypeName = genericTypeName.Substring(0, genericTypeName.IndexOf('`'));
            string genericArgs = string.Join(",", arguments.Select(a => a.ToGenericTypeString()).ToArray());
                //Recursive
            genericTypeName = genericTypeName + "<" + genericArgs + ">";
            if (isArray) genericTypeName += "[]";
        }
        if (t != genericType)
        {
            genericTypeName += t.FullName.Replace(genericType.FullName, "").Replace('+','.');
        }
        if (genericTypeName.IndexOf("[") >= 0 && genericTypeName.IndexOf("]") != genericTypeName.IndexOf("[") +1) genericTypeName = genericTypeName.Substring(0, genericTypeName.IndexOf("["));//For a non generic class nested in a generic class we will still have the type parameters at the end 
        return genericTypeName;
    }

Mit dieser Lösung an einem Projekt an dem ich arbeite, funktioniert Super

InformationsquelleAutor yoel halb

Dies ist meine Lösung, es ist auch Arbeit für verschachtelte Klassen und generics:

    public static string GenericTypeString(this Type t)
    {
        if (!t.IsGenericType)
        {
            return t.GetFullNameWithoutNamespace()
                    .ReplacePlusWithDotInNestedTypeName();
        }

        return t.GetGenericTypeDefinition()
                .GetFullNameWithoutNamespace()
                .ReplacePlusWithDotInNestedTypeName()
                .ReplaceGenericParametersInGenericTypeName(t);
    }

    private static string GetFullNameWithoutNamespace(this Type type)
    {
        if (type.IsGenericParameter)
        {
            return type.Name;
        }

        const int dotLength = 1;
        return type.FullName.Substring(type.Namespace.Length + dotLength);
    }

    private static string ReplacePlusWithDotInNestedTypeName(this string typeName)
    {
        return typeName.Replace('+', '.');
    }

    private static string ReplaceGenericParametersInGenericTypeName(this string typeName, Type t)
    {
        var genericArguments = t.GetGenericArguments();

        const string regexForGenericArguments = @"`[1-9]\d*";

        var rgx = new Regex(regexForGenericArguments);

        typeName = rgx.Replace(typeName, match =>
        {
            var currentGenericArgumentNumbers = int.Parse(match.Value.Substring(1));
            var currentArguments = string.Join(",", genericArguments.Take(currentGenericArgumentNumbers).Select(GenericTypeString));
            genericArguments = genericArguments.Skip(currentGenericArgumentNumbers).ToArray();
            return string.Concat("<", currentArguments, ">");
        });

        return typeName;
    }

InformationsquelleAutor pmarek

-1

Kleine Ergänzung zu @Aaronaught

public string ToGenericTypeString(Type t)
{
    if (!t.IsGenericType)
        return t.FullName;
    string genericTypeName = t.GetGenericTypeDefinition().FullName;
    genericTypeName = genericTypeName.Substring(0,
        genericTypeName.IndexOf('`'));
    string genericArgs = string.Join(",",
        t.GetGenericArguments()
            .Select(ta => ToGenericTypeString(ta)).ToArray());
    return genericTypeName + "<" + genericArgs + ">";
}

Wie es aussieht ist die einzige Sache, die Sie geändert haben, ist aus Name zu FullName? Ich bin mir nicht sicher, ob das wesentlich ändern genug, um zu rechtfertigen, eine alternative Antwort - es sollte wohl wurden geschrieben als Kommentar.
Es ist nicht eine alternative. Fullname hilft bei der namespace-Auflösung.

InformationsquelleAutor Osa E

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.