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 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);
}
public static void RunTest()
{
#region WRAPPED CLASS CONCRETIZATION WITH INHERITANCE FROM ABSTRACT CLASS
ITypeConfig typeConfig =
Core.FindOrCreateTypeConfig <IMyData, WrapperInterface>("MyType5");
typeConfig.AddStaticUtilsClass
(
nameof(G_StaticMethodsTests.WrapperInterface.TheClass),
typeof(MyDataUtils)
);
typeConfig.SetAllowNonPublicForAllMembers(nameof(WrapperInterface.TheClass));
//typeConfig.SetPropMap
//(
// nameof(WrapperInterface.TheClass),
// "GetTheFullName",
// nameof(IMyData.GetFullName),
// true);
typeConfig.ConfigurationCompleted();
IMyData myData = typeConfig.CreateInstanceOfType <IMyData>();
myData.FirstName = "Joe";
myData.LastName = "Doe";
Assert.Equal("Joe Doe", myData.GetFullName());
#endregion WRAPPED CLASS CONCRETIZATION WITH INHERITANCE FROM ABSTRACT CLASS
}
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 T ConcretizeType <T>()
{
ITypeConfig typeConfig = this.FindOrCreateConcretizationTypeConf <T>();
if (typeConfig.TheGeneratedType == null)
{
this.RegenerateAssembly();
}
return(typeConfig.CreateInstanceOfType <T>());
}
public TToImplement CreateImplInstance <TToImplement, TImplementor>
(
params object[] args)
{
ITypeConfig typeConfig =
FindOrCreateTypeConfigUsingImplementorWithAttrs
(
typeof(TToImplement),
typeof(TImplementor)
);
return(typeConfig.CreateInstanceOfType <TToImplement>(args));
}
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());
}
public static void RunTest()
{
#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>("MyPersonImplementation1234");
// 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 =
typeConfig.CreateInstanceOfType <IPerson>();
//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}'");
}
public TClass CreateClassObj <TClass>(string className = null, params object[] args)
{
ITypeConfig typeConfig = FindTypeConfig(className);
if (typeConfig == null)
{
return((TClass)Activator.CreateInstance(typeof(TClass), args));
}
if (typeConfig.TheGeneratedType == null)
{
RegenerateAssembly();
}
return(typeConfig.CreateInstanceOfType <TClass>(args));
}
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
}
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 <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);
}
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");
}
