Reflection code is slow. With Reflection you can invoche all method and can
see all code! This is not good idea if you don't now who use your code!
If I declare a function private is because this can be used only by my code
class. If another class invoke this function in the wrong way can make
disaster an application, or not?
If your class expose a public interface you can use this without now its
Type.
interface IHello
{
void write();
}
class Hello : IHello //english class
{
public void write()
{
Console.Writeln("Hello");
}
}
class Ciao : IHello //italian class
{
public void write()
{
Console.Writeln( "Ciao");
}
}
//Program
void Begin(IHello h)
{
h.write();
}
if IHello is Ciao class the program write "Ciao" otherwise write "Hello",
but your code never change!
Interface can be compiled in separated project so you can have dll with only
interface and no code. User in this way can develop UserControl without your
code!
Brun
"Bill Borg" <> wrote in message
news:3C468E98-C08A-4408-8E25-...
> Bruno, I've been playing with this for a case very similar to Earl's.
Your example is a big help--thank you!
>
> One thing, can you or anybody explain the differences/implications of
creating an interface versus using operations in the system.reflection
class, or is that sort of the same thing? Maybe the difference between
early and late binding?
>
> For example (vb syntax), from within my user control:
> Dim mi As System.Reflection.MethodInfo
> mi = Page.GetType.GetMethod("PageFunction")
> mi.Invoke(Page, Nothing)
>
> If I have a function called PageFunction on the page that I load this user
control from, it gets called from the user control, and I can pass
parameters, etc.
>
> Any thoughts?
>
> Thanks,
>
> Bill
>
> Earl, afaik, you're on exactly the right track--getting them from disk at
runtime is one of the big advantages of user controls. There's a pretty
good discussion of dynamic user controls in Walther's ASP.NET Unleashed
book, but it stops short of telling you how to go back and get methods and
properties in the parent page.
>
> ----- Bruno Sirianni wrote: -----
>
> With interface file client can compile UserControl code without have
your
> page code!
>
> If your pages or classes expose a public interface you can do this.
>
> Example :
>
> public interface IA
> {
> ....
> void Pippo();
> }
>
> public class A : IA
> {
> ...
> public void Pippo() { ... };
> }
>
> public interface IPublicPageForUser
> {
> ....
> IA GetAObject();
> }
>
> public MyPage : Page, IPublicPageForUser
> {
> public IA GetAObject()
> {
> A aObj = new A();
> return (IA)aObj;
> }
> }
>
>
> the user control retrieve the object A with :
>
> IA aObj = ((IPublicPageForUser)this.Page).GetAObject()
> aObj.Pippo();
>
> I hope that my example is clear and good for your work.
>
> Brun
>
> "Earl Teigrob" <> wrote in message
> news:...
> > I am writing an application that dynamically loads user controls at
run
> time
> > based on user options. I would like to give my users the ability to
build
> > their own user controls and add them to my user control folder so
that
> they
> > can be selected and loaded at run time also. These new controls
will need
> to
> > have access to many of the classes with there properties and
methods
> within
> > the complied code. Is this possible? This seems to be the reverse
of most
> > situations where the programmer accesses an object and uses its
> > functionality. I want my code to dynamically load a new user
control
> created
> > by a programmer who does not have access to my source code. Is
there any
> > reference material on doing such a thing?
> >> Thanks for you help!!!
> >> Earl
> >>
|
Similar Threads
