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 }