public static void GenTypeAttributeTest(AssemblyGen ag)
{
TypeGen MyAttribute = ag.Public.Class("MyAttribute", typeof(Attribute))
.BeginAttribute <AttributeUsageAttribute>(AttributeTargets.Class).Set("AllowMultiple", true).End();
FieldGen testField = MyAttribute.Field <object>("testField")
.Attribute <DescriptionAttribute>("Test field");
PropertyGen testProperty = MyAttribute.Public.SimpleProperty(testField, "TestProperty")
.Attribute <ObsoleteAttribute>("Do not use this");
testProperty.Getter().Attribute <DescriptionAttribute>("Getter method");
testProperty.Getter().ReturnParameter.Attribute <DescriptionAttribute>("Getter return value");
testProperty.Setter().Attribute <DescriptionAttribute>("Setter method");
TypeGen tg = ag.Class("Test")
.BeginAttribute(MyAttribute).Set("TestProperty", 3).End()
.Attribute <DescriptionAttribute>("Test class");
tg.Static.Void("Main")
.BeginAttribute(MyAttribute).Set("TestProperty", 3).End();
TypeGen SimpleDelegate = ag.DelegateVoid("SimpleDelegate")
.Attribute <DescriptionAttribute>("Test delegate");
EventGen TestEvent = tg.Static.Event(SimpleDelegate, "TestEvent")
.Attribute <DescriptionAttribute>("Test event");
TestEvent.AddMethod().Attribute <DescriptionAttribute>("Event add method");
TestEvent.RemoveMethod().Attribute <DescriptionAttribute>("Event remove method");
}
// example based on the MSDN Delegates Sample (compose.cs)
public static void GenCompose(AssemblyGen ag)
{
TypeGen MyDelegate = ag.DelegateVoid("MyDelegate").Parameter <string>("string");
TypeGen MyClass = ag.Class("MyClass");
{
CodeGen g = MyClass.Public.Static.Void("Hello").Parameter <string>("s");
{
g.WriteLine(" Hello, {0}!", g.Arg("s"));
}
g = MyClass.Public.Static.Void("Goodbye").Parameter <string>("s");
{
g.WriteLine(" Goodbye, {0}!", g.Arg("s"));
}
g = MyClass.Public.Static.Void("Main");
{
Operand a = g.Local(), b = g.Local(), c = g.Local(), d = g.Local();
// Create the delegate object a that references
// the method Hello:
g.Assign(a, Exp.NewDelegate(MyDelegate, MyClass, "Hello"));
// Create the delegate object b that references
// the method Goodbye:
g.Assign(b, Exp.NewDelegate(MyDelegate, MyClass, "Goodbye"));
// The two delegates, a and b, are composed to form c,
// which calls both methods in order:
g.Assign(c, a + b);
// Remove a from the composed delegate, leaving d,
// which calls only the method Goodbye:
g.Assign(d, c - a);
g.WriteLine("Invoking delegate a:");
g.InvokeDelegate(a, "A");
g.WriteLine("Invoking delegate b:");
g.InvokeDelegate(b, "B");
g.WriteLine("Invoking delegate c:");
g.InvokeDelegate(c, "C");
g.WriteLine("Invoking delegate d:");
g.InvokeDelegate(d, "D");
}
}
}
// example based on the MSDN Events Sample (events1.cs)
public static void GenEvents1(AssemblyGen ag)
{
TypeGen ChangedEventHandler, ListWithChangedEvent;
using (ag.Namespace("MyCollections"))
{
// A delegate type for hooking up change notifications.
ChangedEventHandler = ag.DelegateVoid("ChangedEventHandler").Parameter("sender").Parameter <EventArgs>("e");
// A class that works just like ArrayList, but sends event
// notifications whenever the list changes.
ListWithChangedEvent = ag.Public.Class("ListWithChangedEvent", typeof(ArrayList));
{
// An event that clients can use to be notified whenever the
// elements of the list change.
EventGen Changed = ListWithChangedEvent.Public.Event(ChangedEventHandler, "Changed");
// Invoke the Changed event; called whenever list changes
CodeGen g = ListWithChangedEvent.Protected.Virtual.Void("OnChanged").Parameter <EventArgs>("e");
{
g.If(Changed != null);
{
g.InvokeDelegate(Changed, g.This(), g.Arg("e"));
}
g.End();
}
// Override some of the methods that can change the list;
// invoke event after each
g = ListWithChangedEvent.Public.Override.Method <int>("Add").Parameter("value");
{
Operand i = g.Local(g.Base().Invoke("Add", g.Arg("value")));
g.Invoke(g.This(), "OnChanged", Static.Field <EventArgs>("Empty"));
g.Return(i);
}
g = ListWithChangedEvent.Public.Override.Void("Clear");
{
g.Invoke(g.Base(), "Clear");
g.Invoke(g.This(), "OnChanged", Static.Field <EventArgs>("Empty"));
}
g = ListWithChangedEvent.Public.Override.Indexer <object>().Index <int>("index").Setter();
{
g.Assign(g.Base()[g.Arg("index")], g.PropertyValue());
g.Invoke(g.This(), "OnChanged", Static.Field <EventArgs>("Empty"));
}
}
}
using (ag.Namespace("TestEvents"))
{
TypeGen EventListener = ag.Class("EventListener");
{
FieldGen List = EventListener.Field(ListWithChangedEvent, "List");
// This will be called whenever the list changes.
CodeGen g = EventListener.Private.Void("ListChanged").Parameter("sender").Parameter <EventArgs>("eventArgs");
{
g.WriteLine("This is called when the event fires.");
}
g = EventListener.Public.Constructor().Parameter(ListWithChangedEvent, "list");
{
g.Assign(List, g.Arg("list"));
// Add "ListChanged" to the Changed event on "List".
g.SubscribeEvent(List, "Changed", Exp.NewDelegate(ChangedEventHandler, g.This(), "ListChanged"));
}
g = EventListener.Public.Void("Detach");
{
// Detach the event and delete the list
g.UnsubscribeEvent(List, "Changed", Exp.NewDelegate(ChangedEventHandler, g.This(), "ListChanged"));
g.Assign(List, null);
}
}
TypeGen Test = ag.Class("Test");
{
// Test the ListWithChangedEvent class.
CodeGen g = Test.Public.Static.Void("Main");
{
// Create a new list.
Operand list = g.Local(Exp.New(ListWithChangedEvent));
// Create a class that listens to the list's change event.
Operand listener = g.Local(Exp.New(EventListener, list));
// Add and remove items from the list.
g.Invoke(list, "Add", "item 1");
g.Invoke(list, "Clear");
g.Invoke(listener, "Detach");
}
}
}
}
