static void Main(string[] args)
{
#region WRAPPED CLASS CONCRETIZATION WITH INHERITANCE FROM ABSTRACT CLASS
ITypeConfig <IMyData, NoClass, WrapperInterface> typeConfig =
Core.FindOrCreateTypeConfig <IMyData, NoClass, WrapperInterface>("MyType");
typeConfig.SetMemberMap
(
nameof(WrapperInterface.TheClass),
"TheLastName",
nameof(IMyData.LastName),
true
);
typeConfig.SetPropMapAllowNonPublic(nameof(WrapperInterface.TheClass), nameof(IMyData.GetFullName));
typeConfig.ConfigurationCompleted();
IMyData myData = Core.GetInstanceOfGeneratedType <IMyData>("MyType");
myData.FirstName = "Joe";
myData.LastName = "Doe";
Console.WriteLine(myData.GetFullName());
#endregion WRAPPED CLASS CONCRETIZATION WITH INHERITANCE FROM ABSTRACT CLASS
}
public static void RunTest()
{
ITypeConfig typeConfig = Core.FindOrCreateTypeConfig <IPerson, NoType>("Person1234");
typeConfig.SetEventBuilder(PropertyChangedEventBuilder.ThePropertyChangedEventBuilder, "PropertyChanged");
typeConfig.SetPropBuilder
(
PropertyChangedPropBuilder.ThePropertyChangedPropBuilder,
nameof(IPerson.Age),
nameof(IPerson.Profession)
);
typeConfig.ConfigurationCompleted();
IPerson person = typeConfig.CreateInstanceOfType <IPerson>();
person.FirstName = "Joe";
person.LastName = "Doe";
person.Age = 35;
person.Profession = "Astronaut";
Console.WriteLine($"Name='{person.FirstName} {person.LastName}'; Age='{person.Age}'; Profession='{person.Profession}'");
Core.Save("GeneratedCode");
}
public static void AssembleSelectableRemovableBusinessGroup()
{
ITypeConfig typeConfig =
Core.FindOrCreateTypeConfig <ISelectableRemovableBusinessGroup, ISelectableRemovableBusinessGroupWrapper>();
typeConfig.SetInit <SingleSelectionObservableCollection <ISelectableRemovablePerson> >(nameof(IBusinessGroup.People));
typeConfig.SetEventArgThisIdx(nameof(INotifyPropertyChanged.PropertyChanged), 0);
typeConfig.SetThisMemberMap
(
nameof(ISelectableRemovableBusinessGroupWrapper.TheParentChildSelectionBehavior),
nameof(ParentChildSelectionBehavior <ISelectableRemovableBusinessGroup, ISelectableRemovablePerson> .Parent)
);
typeConfig.SetMemberMap
(
nameof(ISelectableRemovableBusinessGroupWrapper.TheParentChildSelectionBehavior),
nameof(ParentChildSelectionBehavior <ISelectableRemovableBusinessGroup, ISelectableRemovablePerson> .Children),
nameof(IBusinessGroup.People)
);
typeConfig.SetMemberMap
(
nameof(ISelectableRemovableBusinessGroupWrapper.TheRemovableCollectionBehavior),
nameof(RemovableCollectionBehavior.TheCollection),
nameof(IBusinessGroup.People)
);
typeConfig.ConfigurationCompleted();
}
static void Main(string[] args)
{
#region CONCRETIZATION SAMPLE
//MyDataImplementorClass classConcretization =
// Core.GetClassConcretization<MyDataImplementorClass>();
#endregion CONCRETIZATION SAMPLE
#region WRAPPED CLASS CONCRETIZATION WITH INHERITANCE FROM ABSTRACT CLASS
//ITypeConfig<IMyData, MyData, WrapperInterface> typeConfig =
// Core.CreateTypeConfig<IMyData, MyData, WrapperInterface>("MyType");
//typeConfig.ConfigurationCompleted();
//MyData myData = Core.GetInstanceOfGeneratedType<MyData>("MyType");
//myData.FirstName = "Joe";
//myData.LastName = "Doe";
//Console.WriteLine(myData.GetFullName());
#endregion WRAPPED CLASS CONCRETIZATION WITH INHERITANCE FROM ABSTRACT CLASS
ITypeConfig <IMyData, NoClass, WrapperInterface1> typeConfig1 =
Core.FindOrCreateTypeConfig <IMyData, WrapperInterface1>("MyType1");
typeConfig1.ConfigurationCompleted();
IMyData myData1 = Core.GetInstanceOfGeneratedType <IMyData>("MyType1");
myData1.FirstName = "Joe";
myData1.LastName = "Doe";
Console.WriteLine(myData1.GetFullName());
}
public static void RunTest()
{
Core.SetSaveOnErrorPath("GeneratedCode");
ITypeConfig typeConfig =
Core.FindOrCreateTypeConfig <ISelectableData, SelectableWrapperInterface>();
typeConfig.SetEventArgThisIdx(nameof(ISelectableData.IsSelectedChanged), 0);
typeConfig.ConfigurationCompleted();
ISelectableData myInterfaceObj =
typeConfig.CreateInstanceOfType <ISelectableData>();
myInterfaceObj.FirstName = "Nick";
myInterfaceObj.LastName = "Polyak";
bool isSelectedChanged = false;
myInterfaceObj.IsSelectedChanged += (selectableItem) =>
{
isSelectedChanged = true;
};
myInterfaceObj.IsSelected = true;
Assert.Equal("Nick", myInterfaceObj.FirstName);
Assert.Equal("Polyak", myInterfaceObj.LastName);
Assert.True(isSelectedChanged);
}
static void Main(string[] args)
{
ITypeConfig typeConfig = Core.FindOrCreateTypeConfigByTypeToImpl <IPerson>("Person");
typeConfig.SetEventBuilder(PropertyChangedEventBuilder.ThePropertyChangedEventBuilder, "PropertyChanged");
typeConfig.SetPropBuilder
(
PropertyChangedPropBuilder.ThePropertyChangedPropBuilder,
nameof(IPerson.Age),
nameof(IPerson.Profession)
);
typeConfig.ConfigurationCompleted();
IPerson person = Core.GetInstanceOfGeneratedType <IPerson>("Person");
person.FirstName = "Joe";
person.LastName = "Doe";
person.Age = 35;
person.Profession = "Astronaut";
Console.WriteLine($"Name='{person.FirstName} {person.LastName}'; Age='{person.Age}'; Profession='{person.Profession}'");
Core.Save("GeneratedCode");
}
public static void RunTest()
{
#region WRAPPED CLASS CONCRETIZATION WITH INHERITANCE FROM ABSTRACT CLASS
Core.SetSaveOnErrorPath("GeneratedCode");
ITypeConfig typeConfig =
Core.FindOrCreateTypeConfig <IMyData, Implementor>("MyType10");
typeConfig.SetMemberMap
(
nameof(Implementor.TheClass),
"TheLastName",
nameof(IMyData.LastName),
true
);
typeConfig.SetMemberMapAllowNonPublic(nameof(Implementor.TheClass), nameof(IMyData.GetFullName));
typeConfig.ConfigurationCompleted();
IMyData myData = typeConfig.CreateInstanceOfType <IMyData>();
myData.FirstName = "Joe";
myData.LastName = "Doe";
Assert.Equal("Joe Doe", myData.GetFullName());
Core.Save("GeneratedCode");
#endregion WRAPPED CLASS CONCRETIZATION WITH INHERITANCE FROM ABSTRACT CLASS
}
public ITypeConfig FindOrCreateTypeConfigUsingImplementorWithAttrs
(
INamedTypeSymbol typeToImplementSymbol,
INamedTypeSymbol implementorTypeSymbol)
{
ImplementationClassNameAttribute implementationClassNameAttribute =
implementorTypeSymbol.GetAttrObject <ImplementationClassNameAttribute>();
string className;
if (implementationClassNameAttribute != null)
{
className = implementationClassNameAttribute.ClassName;
}
else
{
className = typeToImplementSymbol.CreateClassName(implementorTypeSymbol);
}
ITypeConfig typeConfig =
FindOrCreateTypeConf(className, typeToImplementSymbol, implementorTypeSymbol);
if (implementorTypeSymbol.IsNoTypeOrNull())
{
throw new Exception("Roxy Usage Error: CreateWrapper should have a non-trivial Wrapper argument passed to it.");
}
if (!typeConfig.ConfigurationHasBeenCompleted)
{
typeConfig.ConfigurationCompleted();
}
return(typeConfig);
}
public static void RunTest()
{
#region WRAPPED CLASS CONCRETIZATION WITH INHERITANCE FROM ABSTRACT CLASS
ITypeConfig typeConfig =
Core.FindOrCreateTypeConfig <IMyData, WrapperInterface>("MyType5");
typeConfig.AddStaticUtilsClass
(
nameof(StaticMethodsTests.WrapperInterface.TheClass),
typeof(MyDataUtils)
);
typeConfig.SetAllowNonPublicForAllMembers(nameof(WrapperInterface.TheClass));
//typeConfig.SetPropMap
//(
// nameof(WrapperInterface.TheClass),
// "GetTheFullName",
// nameof(IMyData.GetFullName),
// true);
typeConfig.ConfigurationCompleted();
IMyData myData = Core.GetInstanceOfGeneratedType <IMyData>("MyType5");
myData.FirstName = "Joe";
myData.LastName = "Doe";
Assert.Equal("Joe Doe", myData.GetFullName());
#endregion WRAPPED CLASS CONCRETIZATION WITH INHERITANCE FROM ABSTRACT CLASS
}
public void CreateEnumAdaptor <T, EnumType>(Type staticEnumExtensionsType, bool allowNonPublic = true)
{
ITypeConfig adapterTypeConfig =
FindOrCreateEnumWrapperTypeConfig <T, EnumType>(staticEnumExtensionsType, allowNonPublic);
adapterTypeConfig.ConfigurationCompleted();
}
public static void AssembleSelectableRemovablePerson()
{
ITypeConfig typeConfig =
Core.FindOrCreateTypeConfig <ISelectableRemovablePerson, PersonDataVM, ISelectableRemovablePersonWrapper>();
typeConfig.SetEventArgThisIdx(nameof(INotifyPropertyChanged.PropertyChanged), 0);
typeConfig.ConfigurationCompleted();
}
static void Main(string[] args)
{
ITypeConfig typeConfig =
Core.FindOrCreateTypeConfig <IMyInterface, WrapperInterface>("MyGeneratedClass");
typeConfig.SetPropBuilder(DelegatePropBuilder.TheDelegatePropBuilder, nameof(IMyInterface.TheStr));
typeConfig.ConfigurationCompleted();
IMyInterface myObj = Core.GetInstanceOfGeneratedType <IMyInterface>();
}
static void Main(string[] args)
{
Core.SetSaveOnErrorPath("GeneratedCode");
#region create the generated type configuration object
// get the type configuration object. The class that it is going to generate
// will be called "MyPersonImplementation"
ITypeConfig typeConfig =
Core.FindOrCreateTypeConfig <IPerson, PersonImplementationWrapperInterface>("MyPersonImplementation");
// allow access to non-public members of
// PersonImplementationWrapperInterface.ThePersonImplementation object.
typeConfig.SetAllowNonPublicForAllMembers
(
nameof(PersonImplementationWrapperInterface.ThePersonImplementation)
);
// map TheProfession property of the wrapped object
// into Profession property of the IPerson interface.
typeConfig.SetMemberMap
(
nameof(PersonImplementationWrapperInterface.ThePersonImplementation),
"TheProfession",
nameof(IPerson.Profession)
);
// Signal that the configuration is completed,
// after ConfigurationCompleted() method is called
// TypeConfig object for this class cannot be modified.
typeConfig.ConfigurationCompleted();
#endregion create the generated type configuration object
// get the instance of the generated type "MyPersonImplementation"
IPerson person =
Core.GetInstanceOfGeneratedType <IPerson>("MyPersonImplementation");
//IPerson person = Core.CreateWrapperWithNonPublicMembers<IPerson, PersonImplementationWrapperInterface>("MyPersonImplementation");
// set the properties
person.FirstName = "Joe";
person.LastName = "Doe";
person.Age = 35;
person.Profession = "Astronaut";
// test that the wrapped properties and the method work
Console.WriteLine($"Name/Profession='{person.GetFullNameAndProfession()}'; Age='{person.Age}'");
Core.Save("GeneratedCode");
}
public static void AssembleBusinessGroupsCollection()
{
ITypeConfig typeConfig =
Core.FindOrCreateTypeConfig <SingleSelectionObservableCollection <ISelectableRemovableBusinessGroup>, NoType, IRemovableCollectionBehaviorWrapper>();
typeConfig.SetThisMemberMap
(
nameof(IRemovableCollectionBehaviorWrapper.TheRemovableCollectionBehavior),
nameof(RemovableCollectionBehavior.TheCollection)
);
typeConfig.ConfigurationCompleted();
}
public static void RunTest()
{
Core.SetSaveOnErrorPath("GeneratedCode");
#region CONCRETIZATION SAMPLE
//MyDataImplementorClass classConcretization =
// Core.Concretize<MyDataImplementorClass>();
#endregion CONCRETIZATION SAMPLE
#region WRAPPED CLASS CONCRETIZATION WITH INHERITANCE FROM ABSTRACT CLASS
ITypeConfig typeConfig =
Core.FindOrCreateTypeConfig <IMyData, ImplementorClass>("MyType7");
typeConfig.ConfigurationCompleted();
MyData myData = typeConfig.CreateInstanceOfType <MyData>();
myData.FirstName = "Joe";
myData.LastName = "Doe";
Assert.Equal("Doe, Joe", myData.GetFullName());
#endregion WRAPPED CLASS CONCRETIZATION WITH INHERITANCE FROM ABSTRACT CLASS
ITypeConfig typeConfig1 =
Core.FindOrCreateTypeConfig <IMyData, WrapperInterface1>("MyType9");
typeConfig1.ConfigurationCompleted();
IMyData myData1 = typeConfig1.CreateInstanceOfType <IMyData>();
myData1.FirstName = "Joe";
myData1.LastName = "Doe";
Core.Save("GeneratedCode");
Assert.Equal("Doe, Joe", myData1.GetFullName());
ITypeConfig typeConfig2 =
Core.FindOrCreateTypeConfig <IMyData, ImplementorClass>();
typeConfig2.ConfigurationCompleted();
IMyData myData2 = typeConfig2.CreateInstanceOfType <IMyData>();
myData2.FirstName = "Joe";
myData2.LastName = "Doe";
Assert.Equal("Doe, Joe", myData2.GetFullName());
}
static void Main(string[] args)
{
// saves the generated files in case of a compilation error
Core.SetSaveOnErrorPath("GeneratedCode");
// created the ITypeConfig for configuring the IMyData implementation
// using IWrapper interface
ITypeConfig <IWrapper> typeConfig = Core.FindOrCreateTypeConfig <IMyData, IWrapper>();
// sets the GetGreetings method of IMyData
// interface to MydataImplGet.GreetingImpl implementation
// the two last type arguments signify the string argument that is
// passed to the method and the string output argument.
typeConfig.SetReturningMethodMap <IMyData, MyDataImpl, string, string>
(
// specifies the interface method to implement
(data, inputStr) => data.GetGreeting(inputStr),
// specifies the wrapper object that used
// to implement the interface method
(wrapper) => wrapper.TheDataImpl,
// specifies the method implementation
(dataImpl, inputStr) => dataImpl.GetGreetingImpl(inputStr)
);
// code is generated
typeConfig.ConfigurationCompleted();
// we get the instance of the generated class
// that implements IMyData interface
IMyData myData = Core.GetInstanceOfGeneratedType <IMyData>();
// set the first and last names
myData.FirstName = "Joe";
myData.LastName = "Doe";
// get the greeting by calling IMyData.GetGreeting method of
// the interface, passing "Hello" string to it
string greetingStr = myData.GetGreeting("Hello");
// Prints the resulting string
// "Hello Joe Doe!"
Console.WriteLine(greetingStr);
// saves the generated code in case of successful
// completion.
Core.Save("GeneratedCode");
}
static void Main(string[] args)
{
ITypeConfig typeConfig =
Core.FindOrCreateTypeConfig <IMyInterface, WrapperInterface>("MyGeneratedClass");
typeConfig.SetMemberMap(nameof(WrapperInterface.TheClass), nameof(MyClass.MyInt), nameof(IMyInterface.TheInt));
typeConfig.SetMemberMap(nameof(WrapperInterface.TheClass), nameof(MyClass.MyStr), nameof(IMyInterface.TheStr));
typeConfig.ConfigurationCompleted();
IMyInterface myInterfaceObj = Core.GetInstanceOfGeneratedType <IMyInterface>(typeConfig.ClassName);
myInterfaceObj.TheInt = 1234;
myInterfaceObj.TheStr = "Hello";
myInterfaceObj.MyMethod("blabla", 123);
}
static void Main(string[] args)
{
#region WRAPPED CLASS CONCRETIZATION WITH INHERITANCE FROM ABSTRACT CLASS
ITypeConfig <IMyData, MyData, WrapperInterface> typeConfig =
Core.FindOrCreateTypeConfig <IMyData, MyData, WrapperInterface>("MyType");
typeConfig.SetOverrideVirtual(nameof(MyData.GetFullName), false);
typeConfig.ConfigurationCompleted();
MyData myData = Core.GetInstanceOfGeneratedType <MyData>("MyType");
myData.FirstName = "Joe";
myData.LastName = "Doe";
Console.WriteLine(myData.GetFullName());
#endregion WRAPPED CLASS CONCRETIZATION WITH INHERITANCE FROM ABSTRACT CLASS
}
static void Main(string[] args)
{
// ITypeConfig is an interface
// that can be configured to generate the code
// for a specific type.
// The Template Argument IMyData specifies
// the interface to implement.
// SecondArgument NoInterface means
// that there are no wrapper objects.
ITypeConfig typeConfig =
Core.FindOrCreateTypeConfig <IMyData, NoInterface>();
// set up the lambda expression for IMyData.FullName Property
// implementation
typeConfig.SetPropGetter <IMyData, string>
(
// this expression specified the name
// of the property to implement
(data) => data.FullName,
// this is the property implementation expression:
// Full
(data) => data.LastName + ", " + data.FirstName
);
// specify that the type configuration is completed
typeConfig.ConfigurationCompleted();
// Get an instance of IMyData generated implementation
// type.
IMyData myData = Core.GetInstanceOfGeneratedType <IMyData>();
// set FirstName
myData.FirstName = "Joe";
// set LastName
myData.LastName = "Doe";
// Print FullName
Console.WriteLine(myData.FullName);
// save the Roxy generated project under GeneratedCode folder (within the
// directory that contains the executable)
Core.Save("GeneratedCode");
}
public static void RunTest()
{
#region WRAPPED CLASS CONCRETIZATION WITH INHERITANCE FROM ABSTRACT CLASS
ITypeConfig typeConfig =
Core.FindOrCreateTypeConfig <F_OverridingVirtualsTest.IMyData, F_OverridingVirtualsTest.WrapperInterface>("MyType3");
typeConfig.SetOverrideVirtual(nameof(MyData.GetFullName), false);
typeConfig.ConfigurationCompleted();
F_OverridingVirtualsTest.MyData myData =
typeConfig.CreateInstanceOfType <F_OverridingVirtualsTest.MyData>();
myData.FirstName = "Joe";
myData.LastName = "Doe";
Assert.Equal("Doe, Joe", myData.GetFullName());
#endregion WRAPPED CLASS CONCRETIZATION WITH INHERITANCE FROM ABSTRACT CLASS
}
static void Main(string[] args)
{
ITypeConfig typeConfig =
Core.FindOrCreateTypeConfig <NoInterface, MyDataImplementorClass, NoInterface>("MyGeneratedClass");
typeConfig.SetPropBuilder
(
DelegatePropBuilder.TheDelegatePropBuilder,
nameof(MyDataImplementorClass.FirstName),
nameof(MyDataImplementorClass.LastName),
nameof(MyDataImplementorClass.Age),
nameof(MyDataImplementorClass.DoSmth)
);
typeConfig.ConfigurationCompleted();
MyDataImplementorClass dataImplementor = Core.GetInstanceOfGeneratedType <MyDataImplementorClass>();
}
static void Main(string[] args)
{
ITypeConfig typeConfig =
Core.FindOrCreateTypeConfig <ISelectableData, MyData, WrapperInterface>();
typeConfig.SetEventArgThisIdx(nameof(ISelectableData.IsSelectedChanged), 0);
typeConfig.ConfigurationCompleted();
ISelectableData myInterfaceObj =
Core.GetInstanceOfGeneratedType <ISelectableData>(typeConfig.ClassName) as ISelectableData;
myInterfaceObj.FirstName = "Nick";
myInterfaceObj.LastName = "Polyak";
myInterfaceObj.IsSelectedChanged += MyInterfaceObj_IsSelectedChanged;
myInterfaceObj.IsSelected = true;
}
public TypeToImplement WrapWithNonPublicMembers <TypeToImplement, TWrapper>(string className)
{
ITypeConfig typeConfig = FindTypeConfig <TypeToImplement, TWrapper>(className);
if (typeConfig == null)
{
typeConfig = this.CreateTypeConf <TypeToImplement, TWrapper>(className);
}
typeConfig.SetAllowNonPublicForAllMembers();
typeConfig.ConfigurationCompleted();
if (typeConfig.TheGeneratedType == null)
{
RegenerateAssembly();
}
return(GetInstanceOfType <TypeToImplement>(typeConfig));
}
public ITypeConfig FindOrCreateConcretizationTypeConf
(
INamedTypeSymbol typeToConcretizeSymbol,
string concreteClassName = null)
{
concreteClassName = concreteClassName ?? typeToConcretizeSymbol.Name.GetConcretizationName();
ITypeConfig typeConfig =
TheCore.FindOrCreateTypeConfByTypeToImpl(concreteClassName, typeToConcretizeSymbol);
if (typeConfig.TheGeneratedCode == null)
{
typeConfig.TheBuilderSetter =
DefaultConcretizationMemberBuilderSetter.TheDefaultConcretizationBuilderSetter;
typeConfig.ConfigurationCompleted();
}
return(typeConfig);
}
public static void RunTest()
{
Core.SetSaveOnErrorPath("GeneratedCode");
ITypeConfig typeConfig =
Core.FindOrCreateTypeConfig <IMyInterface, WrapperInterface>("MyGeneratedClass3");
typeConfig.SetMemberMap(nameof(WrapperInterface.TheClass), nameof(MyClass.MyInt), nameof(IMyInterface.TheInt));
//typeConfig.SetPropBuilder(DelegatePropBuilder.TheDelegatePropBuilder, nameof(IMyInterface.TheStr));
typeConfig.ConfigurationCompleted();
IMyInterface myObj = typeConfig.CreateInstanceOfType <IMyInterface>();
myObj.TheInt = 123;
Core.Save("GeneratedCode");
Assert.Equal("The resulting string is: blabla_123", myObj.GetResultingStr("blabla", 123));
}
public static void RunTest()
{
Core.SetSaveOnErrorPath("GeneratedCode");
ITypeConfig typeConfig =
Core.FindOrCreateTypeConfig <MyDataImplementorClass, NoType>("MyGeneratedClass2");
typeConfig.SetPropBuilder
(
DelegatePropBuilder.TheDelegatePropBuilder,
nameof(MyDataImplementorClass.FirstName),
nameof(MyDataImplementorClass.LastName),
nameof(MyDataImplementorClass.Age)
);
typeConfig.SetMethodBuilder(DelegateMethodBuilder.TheDelegateMethodBuilder, nameof(MyDataImplementorClass.DoSmth));
typeConfig.ConfigurationCompleted();
MyDataImplementorClass dataImplementor = typeConfig.CreateInstanceOfType <MyDataImplementorClass>();
Core.Save("GeneratedCode");
}
static void Main(string[] args)
{
// saves the generated code on compilation error
Core.SetSaveOnErrorPath("GeneratedCode");
// creates the TypeConfig object
// for IMyData interface to be implemented
// using IWrapper.TheDataImpl
ITypeConfig <IWrapper> typeConfig =
Core.FindOrCreateTypeConfig <IMyData, IWrapper>();
// completes the configuration,
// generates the code.
typeConfig.ConfigurationCompleted();
// creates the object of generated class that
// implements IMyData interface
IMyData myData = Core.GetInstanceOfGeneratedType <IMyData>();
// sets first and last name
myData.FirstName = "Joe";
myData.LastName = "Doe";
// calls GetGreeting() method
string greetingStr1 = myData.GetGreeting();
// writes "Hello World1"
Console.WriteLine(greetingStr1);
// calls GetGreeting("Hello") method
string greetingStr2 = myData.GetGreeting("Hello");
// prints "Hello Joe Doe!"
Console.WriteLine(greetingStr2);
// saves the generated code in case of
// successful completion.
Core.Save("GeneratedCode");
}
public static void RunTest()
{
Core.SetSaveOnErrorPath("GeneratedCode");
ITypeConfig typeConfig =
Core.FindOrCreateTypeConfig <IMyInterface, WrapperInterface>("MyGeneratedClass1");
typeConfig.SetMemberMap(nameof(WrapperInterface.TheClass), nameof(MyClass.MyInt), nameof(IMyInterface.TheInt));
typeConfig.SetMemberMap(nameof(WrapperInterface.TheClass), nameof(MyClass.MyStr), nameof(IMyInterface.TheStr));
typeConfig.ConfigurationCompleted();
Core.Save("GeneratedCode");
IMyInterface myInterfaceObj = typeConfig.CreateInstanceOfType <IMyInterface>();
myInterfaceObj.TheInt = 1234;
myInterfaceObj.TheStr = "Hello";
string str = myInterfaceObj.GetResultingStr("blabla", 123);
Assert.Equal("The resulting string is: blabla_1234", str);
}
static void Main(string[] args)
{
// create the ITypeConfig for implementing the
// IProduct interface based on ProductKind enumeration
ITypeConfig <SingleWrapperInterface <ProductKind> > adapterTypeConfig =
Core.FindOrCreateSingleWrapperTypeConfig <IProduct, ProductKind>();
// set IProduct.DisplayName property to be implemented
// as ProductKindExtensions.GetDisplayName() extension method
// on the product kind value
adapterTypeConfig.SetWrappedPropGetter <IProduct, ProductKind, string>
(
prod => prod.DisplayName,
prodKind => prodKind.GetDisplayName()
);
// set IProduct.Description property to be implemented
// by calling ProductKindExtensions.GetDescription() extension method
// on the product kind value
adapterTypeConfig.SetWrappedPropGetter <IProduct, ProductKind, string>
(
prod => prod.Description,
prodKind => prodKind.GetDescription()
);
// complete configuration and generate the code
adapterTypeConfig.ConfigurationCompleted();
// get IProduct for ProductKind.Information enum value
IProduct product = Core.GetInstanceOfGeneratedType <IProduct>(null, ProductKind.Information);
// write <DisplayName>: <Description>
Console.WriteLine($"{product.DisplayName}: {product.Description}");
// save the Roxy generated project under GeneratedCode folder (within the
// directory that contains the executable)
Core.Save("GeneratedCode");
}
static void Main(string[] args)
{
ITypeConfig removableTypeConfig =
Core.FindOrCreateTypeConfig <IRemovableData, NoClass, IRemovableWrapper>();
string className = removableTypeConfig.ClassName;
removableTypeConfig.SetEventArgThisIdx(nameof(IRemovableData.RemoveEvent), 0);
removableTypeConfig.ConfigurationCompleted();
IRemovableData removableObj1 =
Core.GetInstanceOfGeneratedType <IRemovableData>();
removableObj1.FirstName = "Joe";
removableObj1.LastName = "Doe";
IRemovableData removableObj2 =
Core.GetInstanceOfGeneratedType <IRemovableData>();
removableObj2.FirstName = "Jane";
removableObj2.LastName = "Dane";
#region Using removableCollectionBehavior on top of the collection
ObservableCollection <IRemovableData> collectionWithRemovabledItems =
new ObservableCollection <IRemovableData>();
collectionWithRemovabledItems.Add(removableObj1);
collectionWithRemovabledItems.Add(removableObj2);
RemovableCollectionBehavior removableCollectionBehavior = new RemovableCollectionBehavior();
removableCollectionBehavior.TheCollection = collectionWithRemovabledItems;
removableObj1.Remove();
removableObj2.Remove();
#endregion Using removableCollectionBehavior on top of the collection
#region dynamically creating an observable collection class with removableCollectionBehavior inside
ITypeConfig <NoInterface, ObservableCollection <IRemovableData>, IRemovableBehaviorCollectionWrapper> collectionTypeConfig =
Core.FindOrCreateTypeConfig <NoInterface, ObservableCollection <IRemovableData>, IRemovableBehaviorCollectionWrapper>("CollectionWithRemovableBehavior");
collectionTypeConfig.UnInitAction =
(intrfc, superClass, collWrapper) =>
{
collWrapper.TheRemovableCollectionBehavior.TheCollection = null;
};
collectionTypeConfig.InitAction =
(intrfc, superClass, collWrapper) =>
{
collWrapper.TheRemovableCollectionBehavior.TheCollection = superClass;
};
collectionTypeConfig.ConfigurationCompleted();
ObservableCollection <IRemovableData> collection =
Core.GetInstanceOfGeneratedType <ObservableCollection <IRemovableData> >();
collection.Add(removableObj1);
collection.Add(removableObj2);
removableObj1.Remove();
#endregion dynamically creating an observable collection class with removableCollectionBehavior inside
}
