Hente størrelse på en generic T der er et array

Der er en GetValue metode til at hente værdien af en property med.

Men hvis du ved at det er en ArrayList så skal du nok erklære argumentet som ArrayList og så kan du bruge Count property direkte. Eller langt bedre lad det være List<T> !

Hmmm dvs. jeg altså skal bruge:

var properties = t.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance);

Jeg tror, jeg næsten har den...men kan ikke se nogen GetValue i min intellisense :(

Måske denne ->
var count = (int) properties.GetValue(1);

T er faktisk en List<T>. Så jeg kan i virkeligheden bare lade min signatur hedde (List<T> t) istedet for (T t)?

var count = (int) properties.GetValue(1); 
Gav en invalid cast exception.

Min værdi der kommer ind er en List<Foo> som jeg ville have T til at repræsentere i min generiske metode.

Det viser sig, jeg får "Int32 Count" tilbage fra min GetValue(1);

Sidder stadigvæk fast her :(

Hvad er det reelt set du prøvet på? Siden du vil finde størrelse på dit T t ? som du siger er en ArrayList ... hvis du allerede ved det er en ArrayList så er det vel lidt mærkeligt at finde størrelse på det ...

Hvad nu hvis en anden bruger det som en T t der er en integer? eller en SqlConnection ?

mvh

Okay Buzzz...alting virker meget mærkeligt for dig...hvad jeg synes er mærkeligt er at du slet ikke har leget med generics...jeg kan ikke vide, hvilken type List<foo1> List<foo2>, jeg får ind. De kommer ind som en parameter på min generiske metode.
Jeg skal håndtere dette i min kode...jeg har lavet noget lignende før med succes, men bare ikke med arrays... Finder jeg størrelsen...er jeg ret langt fremme i min kode...

Synes du skal sætte dig ind i generics....Jeg har lavet en constraint på min metode, så den kun kan kaldes med arrays...ellers kommer der en fejl. Desuden hedder metoden også noget med array, så man er selv udenom at smide noget crap ind.

Nej, det virker ikke mærkeligt for mig, men vil bare gerne vide hvad du prøver på, der det virker mytisk i min verden via reflection at skulle kigge efter antal Element i dit Array.

Har jeg skrevet jeg ikke bruger Generics ? :-)

Derfor jeg efterlyser lidt hvad du prøver på.

Hvis du alligevel har en constraint på at det skal være et Array ... eller what ever ... hvad er der så Generic ved det ?

Hvorfor så ikke bruge IList<T> eller List<T> som Arve_v også skriver i starten ?

Fordi det er ikke er det, der kommer ind.

List<Foo> foo = new List<Foo>();

Kald til min generiske metode...

SomeHelperClass.DoStuffWithMyArray(foo);

Simplificeret signatur på min generic metode:
public static void DoStuffWithMyArray<T>(T t) {

Jeg kan jo ikke skrive List<T> i min signatur, da det vil være en List<> af en List<foo>.

DoStuffWithMany<T>(IList<T> list)

Burde virke ...

Men hvis du vil den anden vej:
ArrayList t = new ArrayList();
var propertyInfos = t.GetType().GetProperties();
var propertyInfo = propertyInfos.Single(a => a.Name == "Count");
var value = propertyInfo.GetValue(t, null);
Console.WriteLine(value);

mvh

private static void DoStuffWithMany<T>(IList<T> list)
        {
            Console.WriteLine(list.Count);
        }


Det kan du så kalde med:
private static void Main(string[] args)
        {
            IList<int> list2 = new List<int>();
            DoStuffWithMany(list2);
        }

Der er altså et mismatch mellem din parameter og din signatur. Du har tydeligvis ikke testet det...

Nej ... det virker ... det er bare en liste med en liste ... 100% valid.

Du kan også:
private static void DoStuffWithMany<T>(T list) where T : ArrayList
{
    Console.WriteLine(list.Count);
}

Og nej, det er faktisk ingengnag en liste med en list ...

Via inference eller hvad det nu hedder finder den selv ud af typen.
using System;
using System.Collections.Generic;

namespace Executor
{
    public class Program2
    {
        private static readonly Random _Random = new Random();

        private static void DoStuffWithMany<T>(IList<T> list)
        {
            Console.WriteLine(list.Count);
            foreach (T t in list)
            {
                Console.WriteLine(t);
            }
        }

        private static void Main(string[] args)
        {
            IList<int> list2 = new List<int>();
            list2.Add(20);
            DoStuffWithMany(list2);
        }
    }
}

Virker ikke desværre...

Jeg prøver igen imorgen. Tak for tiden.

Alt hvad jeg har postet virker og er testet ... så hvad er det som ikke virker ?

Prøv at komme med hele din metode og hvordan du kalder den.

mvh

Eksempel med GetProperty GetValue og List<T>:

using System;
using System.Collections.Generic;

namespace E
{
    public class Program
    {
        public static string VeryBad<T>(T o)
        {
            int len = (int)typeof(T).GetProperty("Count").GetValue(o, null);
            return (string)typeof(T).GetProperty("Item").GetValue(o, new object[] { (len-1)/2});
        }
        public static T Better<T>(List<T> o)
        {
            int len = o.Count;
            return o[(len-1)/2];
        }
        public static void Main(string[] args)
        {
            List<string> lst = new List<string>();
            lst.Add("A");
            lst.Add("BB");
            lst.Add("CCC");
            Console.WriteLine(VeryBad(lst));
            Console.WriteLine(Better(lst));
            Console.ReadKey();
        }
    }
}

Arne...du er min helt...denne linje:

int len = (int)typeof(T).GetProperty("Count").GetValue(o, null);

Var lige præcis det, jeg havde brug for at vide...jeg var der næsten men røg af ved GetValue's anden parameter, som du blot har sat til null...jeg faldt ned ved object[] index...og var ikke sikker, hvad jeg skulle smide med ind her...

Fuld points til dig...tusinde tak. Du forstod mit problem i koden.

Smid gerne et svar ind

Hvorfor er den verybad?

Det er en generic metode hvor argumentet er af type T, men den giver fejl ved stort set alt andet en List<string>.

Pointen med generic er at undgå fejl ikke at skabe dem.

Better metode sikrer at den kun kaldes med en List<> og metoden kan returne enhver type ikke kun string.

Meget bedre!!

Sjovt nok. Jeg får fejl...kan det have noget at gøre med at jeg ikke bruger string eller int...jeg bruger mit eget objekt i en List<Foo>. Jeg får en mismatch mellem typerne.

Derudover skal du være opmærksom på at reflection metoder er forholdsvis dyre.

Kalder du Assembly.Load en gang er det ligegyldigt.

Men kalder du Type.GetProperty inden i en løkke som kaldes en million gange, så vil du opdage at performance lider.

Kan man ikke lave en constraint på metoden?
where T : new(), List<T> agtigt uden af have testet den...

VeryBad virker ikke med List<Foo>.

Du kan naturligvis rette metode til at returnere Foo og så virker den med Foo. Men ikke med Bar.

Better bør virke med List<string>, List<Foo> og List<Bar>.

Du kan godt lave en constraint. Lad mig lige fixe et eksampel.

Sjovt...jeg kan kun få verybad til at virke...jeg må kigge på det...men jeg fik et gennembrug...resten må jeg eftertjekke imorgen...ret sent her i DK og skal på arbejde imorgen.

Send du bare et svar ind.
Buzz du kan godt være med, så kan jeg hælde noget over hos dig

Ahh mange tak...jeg ville nemlig satse på et constraint...som jeg faktisk også tidligere havde nævnt for buzzz

using System;
using System.Collections.Generic;

namespace E
{
    public class Program
    {
        public static string VeryBad<T>(T o)
        {
            int len = (int)typeof(T).GetProperty("Count").GetValue(o, null);
            return (string)typeof(T).GetProperty("Item").GetValue(o, new object[] { (len-1)/2});
        }
        public static T2 PrettyBad<T,T2>(T o) where T : List<T2>
        {
            int len = (int)typeof(T).GetProperty("Count").GetValue(o, null);
            return (T2)typeof(T).GetProperty("Item").GetValue(o, new object[] { (len-1)/2});
        }
        public static T2 AlmostThere<T,T2>(T o) where T : List<T2>
        {
            int len = o.Count;
            return o[(len-1)/2];
        }
        public static T Better<T>(List<T> o)
        {
            int len = o.Count;
            return o[(len-1)/2];
        }
        public static void Main(string[] args)
        {
            List<string> lst = new List<string>();
            lst.Add("A");
            lst.Add("BB");
            lst.Add("CCC");
            Console.WriteLine(VeryBad(lst));
            Console.WriteLine(PrettyBad<List<string>,string>(lst));
            Console.WriteLine(AlmostThere<List<string>,string>(lst));
            Console.WriteLine(Better(lst));
            Console.ReadKey();
        }
    }
}

Lol så faktisk er der ikke brug for constraints...
Better er always better... :D

Med både string og int:

using System;
using System.Collections.Generic;

namespace E
{
    public class Program
    {
        public static string VeryBad<T>(T o)
        {
            int len = (int)typeof(T).GetProperty("Count").GetValue(o, null);
            return (string)typeof(T).GetProperty("Item").GetValue(o, new object[] { (len-1)/2});
        }
        public static T2 PrettyBad<T,T2>(T o) where T : List<T2>
        {
            int len = (int)typeof(T).GetProperty("Count").GetValue(o, null);
            return (T2)typeof(T).GetProperty("Item").GetValue(o, new object[] { (len-1)/2});
        }
        public static T2 AlmostThere<T,T2>(T o) where T : List<T2>
        {
            int len = o.Count;
            return o[(len-1)/2];
        }
        public static T Better<T>(List<T> o)
        {
            int len = o.Count;
            return o[(len-1)/2];
        }
        public static void Main(string[] args)
        {
            List<string> lst = new List<string>();
            lst.Add("A");
            lst.Add("BB");
            lst.Add("CCC");
            Console.WriteLine(VeryBad(lst));
            Console.WriteLine(PrettyBad<List<string>,string>(lst));
            Console.WriteLine(AlmostThere<List<string>,string>(lst));
            Console.WriteLine(Better(lst));
            List<int> lst2 = new List<int>();
            lst2.Add(1);
            lst2.Add(22);
            lst2.Add(333);
            // vil smide en fejl // Console.WriteLine(VeryBad(lst2));
            Console.WriteLine(PrettyBad<List<int>,int>(lst2));
            Console.WriteLine(AlmostThere<List<int>,int>(lst2));
            Console.WriteLine(Better(lst2));
            Console.ReadKey();
        }
    }
}

Ja - Better er altid bedre!

:-)

Bemærk at alle mine eksempler returnere det midterste element. Hvis din metode gør noget andet, så er der måske andre problemer som kommer ind.

Hvis du poster noget komplet kode der kan oversættes er det meget nemmere for os at finde og forklare fejl.

Og et svar fra mig.

Smid bare et svar ind... jeg kigger på det imorgen. kl. er 02 og jeg har vel leget nok med generics...(det er ikke engang arbejde, bare fun med generics) skal på arbejde imorgen...må hellere få mig de 5 timer jeg har tilbage inden jeg skal op igen :S

Mange tak og godnat fra DK

Nu fik buzzzz så ikke noget.

Så endte du alligevel faktisk ud med det jeg skrev, omend Arne_v altid har en lidt anden og bedre måde at skrive tingene på :-)

mvh

Nej, ked af det Buzzz...men det blev sent...og jeg ville gerne give points inden jeg gik i seng...jeg skal nok sørge for at du får nogle points næste gang muligheden opstår...hvad den helt sikkert gør...

Helt fint ...

Generics er vejen frem ... i hvert fald mange steder.

Et venligt tip Buzzz...skift billedet ud...det er nemmere at tage dig seriøst, når du ikke har det billede, der bedst egner sig til facebook....

<:o)

Bliver brugt mange steder da de henter det fra gravatar ...

Men ja ... har overvejet det, men orker ikke at skifte det ud. Man skal ikke altid se proff ud, så er det nemmere at give folk "wow" effekten, når der rent faktisk kommer noget intelligent u daf mig :-)

mvh

Jeg oplever desværre den modsatte effekt...jeg har svært ved at tage vedkommende alvorligt...og det vedkommende siger, bliver desværre farvet af det...desværre ingen wow effekt. Desuden behøver en wow effekt ikke have et billede.

Har du det godt med det...så beholder du bare billedet...men bare et venligt tip...

Desværre andres problem, hvis de bliver farvet af et billede og det er jeg bestemt ikke i tvivl om du gør. Man bare læse dette spørgsmål igennem for at finde de svinere du smider efter mig :-).

Men verden er også lille, og nu er det sket to gange på 3 år.

mvh