delegate instance

[colin]

Hi,

How can I use a delegate that I can set to call a non static function
but of any instance of the class ?

eg

class TypeTeader<T>
{
delegate T readDelegate<T> ();
readDelegate<TR eadFunction;
public TypeTeader(read Delegate d)
{
ReadFunction=d;
}
public void read<T>(BinaryR eader reader,ref T p)
{
//use the ReadFunction delegate to acces the relevant function of reader
}
}

TypeReader<Int3 2Int32reader(/*pass ReadInt32 function of BinaryReader*/);

this is ofc simplified,
ive expanded BinaryReader to read countless types.

thanks
Colin =^.^=

[Alberto Poblacion]

"colin" <co*********@nt world.NOSPAM.co mwrote in message
news:l5******** ***********@new sfe2-gui.ntli.net...

How can I use a delegate that I can set to call a non static function
but of any instance of the class ?

eg

class TypeTeader<T>
{
delegate T readDelegate<T> ();
readDelegate<TR eadFunction;
public TypeTeader(read Delegate d)
{
ReadFunction=d;
}
public void read<T>(BinaryR eader reader,ref T p)
{
//use the ReadFunction delegate to acces the relevant function of
reader
}
}

TypeReader<Int3 2Int32reader(/*pass ReadInt32 function of
BinaryReader*/);

If I have understood what you want, I think that you can achieve it by
means of a MethodInfo instead of a delegate:

using System.Reflecti on;
....
class TypeTeader<T>
{
MethodInfo ReadFunction;
public TypeReader(Meth odInfo d)
{
ReadFunction=d;
}
public void read<T>(BinaryR eader reader,ref T p)
{
p = (T)ReadFunction .Invoke(reader, null);
}
}
....
Type t = typeof(BinaryRe ader);
TypeReader<Int3 2Int32reader = new
TypeReader<Int3 2>(t.GetMethod( "ReadInt32" ));

[Ignacio Machin ( .NET/ C# MVP )]

On Apr 23, 12:03*pm, "colin" <colin.ro...@nt world.NOSPAM.co mwrote:

Hi,

How can I use a delegate that I can set to call a non static function
but of any instance of the class ?

eg

class TypeTeader<T>
{
*delegate T readDelegate<T> ();
*readDelegate<T ReadFunction;
*public TypeTeader(read Delegate d)
*{
* ReadFunction=d;
*}
*public void read<T>(BinaryR eader reader,ref T p)
*{
* * //use the ReadFunction delegate to acces the relevant function of reader
*}

}

TypeReader<Int3 2Int32reader(/*pass ReadInt32 function of BinaryReader*/);

this is ofc simplified,
ive expanded BinaryReader to read countless types.

thanks
Colin =^.^=

Hi,

public delegate T readDelegate<T> ();
public class TypeTeader<T{
readDelegate<TR eadFunction;
public readDelegate<TS etDelegate{
get{return ReadFunction;}
set { ReadFunction = value; }
}
public void read(T p) {
if (ReadFunction != null)
ReadFunction();
}
}

[colin]

thanks,
I was trying to avoid using reflection,
Ive used reflection extensivly and its proved far too slow,
Ive directly coded for the most common structures and its a lot faster.

but now I wish to make it easier to add more directly coded conversions.

however this does give me an idea I could cache the reflection info rather
than
fetch it every time I read in a variable.

im considering either making a class containing static functions instead of
members,
or to have a seperate delegate for each instance ie one set for each file,
this sounds a bit over complicated.

I might try this aproach to see how fast it is though thanks :)

Idealy I would like to use the c++ type of member pointer,
even though I always seemed to have a real trouble trying to remember the
syntax,
I just assumed it was difuclt in c#, but ive been looking into various
things behind the language
and see why its not doable.

Colin =^.^=
"Alberto Poblacion" <ea************ *************** ***@poblacion.o rgwrote
in message news:%2******** ********@TK2MSF TNGP03.phx.gbl. ..

"colin" <co*********@nt world.NOSPAM.co mwrote in message
news:l5******** ***********@new sfe2-gui.ntli.net...

>How can I use a delegate that I can set to call a non static function
but of any instance of the class ?

eg

class TypeTeader<T>
{
delegate T readDelegate<T> ();
readDelegate<T ReadFunction;
public TypeTeader(read Delegate d)
{
ReadFunction=d;
}
public void read<T>(BinaryR eader reader,ref T p)
{
//use the ReadFunction delegate to acces the relevant function of
reader
}
}

TypeReader<Int 32Int32reader(/*pass ReadInt32 function of
BinaryReader */);

If I have understood what you want, I think that you can achieve it by
means of a MethodInfo instead of a delegate:

using System.Reflecti on;
...
class TypeTeader<T>
{
MethodInfo ReadFunction;
public TypeReader(Meth odInfo d)
{
ReadFunction=d;
}
public void read<T>(BinaryR eader reader,ref T p)
{
p = (T)ReadFunction .Invoke(reader, null);
}
}
...
Type t = typeof(BinaryRe ader);
TypeReader<Int3 2Int32reader = new
TypeReader<Int3 2>(t.GetMethod( "ReadInt32" ));

[colin]

Hi,
I cant work out how your code can speciify the relevant instance
of BinaryReader when calling the delegate.

I dont think what I want to do is possible using non static functions.
I gues il have to change everything to static functions.
however this also poses problems as static functions cant be overriden.

Ive also run into problems with using MethodInfo becuase I need to pass an
argument as a ref,
although it runs ok the ref is boxed wich no longer is a ref to the original
object >.<

thanks
Colin =^.^=
"Ignacio Machin ( .NET/ C# MVP )" <ig************ @gmail.comwrote in
message
news:83******** *************** ***********@26g 2000hsk.googleg roups.com...
On Apr 23, 12:03 pm, "colin" <colin.ro...@nt world.NOSPAM.co mwrote:

Hi,

How can I use a delegate that I can set to call a non static function
but of any instance of the class ?

eg

class TypeTeader<T>
{
delegate T readDelegate<T> ();
readDelegate<TR eadFunction;
public TypeTeader(read Delegate d)
{
ReadFunction=d;
}
public void read<T>(BinaryR eader reader,ref T p)
{
//use the ReadFunction delegate to acces the relevant function of reader
}

}

TypeReader<Int3 2Int32reader(/*pass ReadInt32 function of
BinaryReader*/);

this is ofc simplified,
ive expanded BinaryReader to read countless types.

thanks
Colin =^.^=

Hi,

public delegate T readDelegate<T> ();
public class TypeTeader<T{
readDelegate<TR eadFunction;
public readDelegate<TS etDelegate{
get{return ReadFunction;}
set { ReadFunction = value; }
}
public void read(T p) {
if (ReadFunction != null)
ReadFunction();
}
}

[colin]

Ive found a way to do it neatly, fast and type safe.
it also ensures the defualt type ties up with the read type.

public class UStruct
{
public delegate ValueType DefualtReadDele gate(SerializeS tream file);
public static Dictionary<stri ng, DefualtReadDele gateNativeStruc ts =
GetNativeStruct s();
public DefualtReadDele gate defualtReadDele gate;
private static Dictionary<stri ng, DefualtReadDele gateGetNativeSt ructs()
{
NativeStructs = new Dictionary<stri ng, DefualtReadDele gate>();
NativeStructs.A dd("PointRegion ", delegate(Serial izeStream file)
{ PointRegion x = default(PointRe gion); if (file != null)
file.Serialize( ref x); return x; });
NativeStructs.A dd("Scale", delegate(Serial izeStream file)
{ UScale x = default(UScale) ; if (file != null) file.Serialize( ref x);
return x; });
NativeStructs.A dd("Vector", delegate(Serial izeStream file)
{ Vector x = default(Vector) ; if (file != null) file.Serialize( ref x);
return x; });
NativeStructs.A dd("Color", delegate(Serial izeStream file)
{ FColor x = default(FColor) ; if (file != null) file.Serialize( ref x);
return x; });
NativeStructs.A dd("Rotator", delegate(Serial izeStream file)
{ Rotator x = default(Rotator ); if (file != null) file.Serialize( ref x);
return x; });
NativeStructs.A dd("ADrop", delegate(Serial izeStream file)
{ ADrop x = default(ADrop); if (file != null) file.Serialize( ref x);
return x; });
return NativeStructs;
}
public UStruct(string s)
{
NativeStructs.T ryGetValue(Name , out defualtReadDele gate);
}
public ValueType Defualt(string StructName)
{
if (defualtReadDel egate != null)
return defualtReadDele gate(null);
...get custom build defualt...
}
}

public class Property
{
private void ReadStruct(Seri alizeReader file,UObject uObj,UData udata)
{//would be easier if there was a direct reference to UStruct
UStruct.Defualt ReadDelegate found;
if (UStruct.Native Structs.TryGetV alue(StructName , out found))
{
udata.data = found(file);
return;
}
... read custom
}
}

il need to add write capability too, the SerializeStream is the base class
for read and write,
and can handle both ok.
im not sure how the format of the data to write will need to be yet.

thanks for the helps
Colin =^.^=

[Ben Voigt [C++ MVP]]

colin wrote:

thanks,
I was trying to avoid using reflection,
Ive used reflection extensivly and its proved far too slow,
Ive directly coded for the most common structures and its a lot
faster.
but now I wish to make it easier to add more directly coded
conversions.
however this does give me an idea I could cache the reflection info
rather than
fetch it every time I read in a variable.

im considering either making a class containing static functions
instead of members,
or to have a seperate delegate for each instance ie one set for each
file, this sounds a bit over complicated.

I might try this aproach to see how fast it is though thanks :)

Idealy I would like to use the c++ type of member pointer,
even though I always seemed to have a real trouble trying to remember
the syntax,
I just assumed it was difuclt in c#, but ive been looking into various
things behind the language
and see why its not doable.

It is doable, it is called an "open delegate". You have to use reflection
to create it, but then you have a real delegate that runs at full speed.

See http://msdn2.microsoft.com/en-us/library/53cz7sc6.aspx

>
Colin =^.^=
"Alberto Poblacion" <ea************ *************** ***@poblacion.o rg>
wrote in message news:%2******** ********@TK2MSF TNGP03.phx.gbl. ..

>"colin" <co*********@nt world.NOSPAM.co mwrote in message
news:l5******* ************@ne wsfe2-gui.ntli.net...

>>How can I use a delegate that I can set to call a non static
function but of any instance of the class ?

eg

class TypeTeader<T>
{
delegate T readDelegate<T> ();
readDelegate< TReadFunction;
public TypeTeader(read Delegate d)
{
ReadFunction=d;
}
public void read<T>(BinaryR eader reader,ref T p)
{
//use the ReadFunction delegate to acces the relevant function of
reader
}
}

TypeReader<In t32Int32reader(/*pass ReadInt32 function of
BinaryReade r*/);

If I have understood what you want, I think that you can achieve
it by means of a MethodInfo instead of a delegate:

using System.Reflecti on;
...
class TypeTeader<T>
{
MethodInfo ReadFunction;
public TypeReader(Meth odInfo d)
{
ReadFunction=d;
}
public void read<T>(BinaryR eader reader,ref T p)
{
p = (T)ReadFunction .Invoke(reader, null);
}
}
...
Type t = typeof(BinaryRe ader);
TypeReader<Int 32Int32reader = new
TypeReader<Int 32>(t.GetMethod ("ReadInt32" ));

[colin]

oooh that looks cool, I didnt come accros that,
theres quite a lot to read...
why is the information I need always so hard to find that I have to
make so many posts here lol.

many thanks
Colin =^.^=
"Ben Voigt [C++ MVP]" <rb*@nospam.nos pamwrote in message
news:%2******** ********@TK2MSF TNGP05.phx.gbl. ..

colin wrote:

>thanks,
I was trying to avoid using reflection,
Ive used reflection extensivly and its proved far too slow,
Ive directly coded for the most common structures and its a lot
faster.
but now I wish to make it easier to add more directly coded
conversions.
however this does give me an idea I could cache the reflection info
rather than
fetch it every time I read in a variable.

im considering either making a class containing static functions
instead of members,
or to have a seperate delegate for each instance ie one set for each
file, this sounds a bit over complicated.

I might try this aproach to see how fast it is though thanks :)

Idealy I would like to use the c++ type of member pointer,
even though I always seemed to have a real trouble trying to remember
the syntax,
I just assumed it was difuclt in c#, but ive been looking into various
things behind the language
and see why its not doable.

It is doable, it is called an "open delegate". You have to use reflection
to create it, but then you have a real delegate that runs at full speed.

See http://msdn2.microsoft.com/en-us/library/53cz7sc6.aspx

>>
Colin =^.^=
"Alberto Poblacion" <ea************ *************** ***@poblacion.o rg>
wrote in message news:%2******** ********@TK2MSF TNGP03.phx.gbl. ..

>>"colin" <co*********@nt world.NOSPAM.co mwrote in message
news:l5****** *************@n ewsfe2-gui.ntli.net...
How can I use a delegate that I can set to call a non static
function but of any instance of the class ?

eg

class TypeTeader<T>
{
delegate T readDelegate<T> ();
readDelegate <TReadFunctio n;
public TypeTeader(read Delegate d)
{
ReadFunction=d;
}
public void read<T>(BinaryR eader reader,ref T p)
{
//use the ReadFunction delegate to acces the relevant function of
reader
}
}

TypeReader<I nt32Int32reader (/*pass ReadInt32 function of
BinaryReader */);

If I have understood what you want, I think that you can achieve
it by means of a MethodInfo instead of a delegate:

using System.Reflecti on;
...
class TypeTeader<T>
{
MethodInfo ReadFunction;
public TypeReader(Meth odInfo d)
{
ReadFunction=d;
}
public void read<T>(BinaryR eader reader,ref T p)
{
p = (T)ReadFunction .Invoke(reader, null);
}
}
...
Type t = typeof(BinaryRe ader);
TypeReader<In t32Int32reader = new
TypeReader<In t32>(t.GetMetho d("ReadInt32")) ;