/// <summary>
/// Adds an entry.
/// </summary>
/// <returns>View Result or Redirect to Home if successful</returns>
/// <param name="baseModel">Model to add.</param>
/// <param name="baseInterface">Interface to use to add with.</param>
/// <typeparam name="T">The type of the Model.</typeparam>
public IActionResult AddEntry <T>(T baseModel, IBaseInterface <T> baseInterface) where T : BaseModel
{
if (IsEmptyModel(baseModel))
{
// Haven't filled in the form yet
return(View(baseModel));
}
if (ModelState.IsValid)
{
// Add the Company
if (baseInterface.AddEntry(baseModel))
{
// Add was successful
return(RedirectToAction("Index", "Home"));
}
else
{
// Error with saving record
ModelState.AddModelError("Save Error", "Error saving record, please try again");
}
}
// Display any errors on screen
return(View(baseModel));
}
public TestUseRepository(ITaskRepository taskR, ICustomerRepository customerR, IRepository <Task> task, IBaseInterface baseI)
{
_taskRepository = taskR;
_customerRepository = customerR;
_rep = task;
_baseInterface = baseI;
}
public TestContainsInterfaceField(IBaseInterface value)
{
if (value == null)
{
throw new ArgumentNullException(nameof(value));
}
Value = value;
}
public FiscalYearService(IFiscalYearRepository fiscalYearRepository,
IMessageClass messageClass,
IBaseInterface baseInterface,
IDateService dateService)
{
_fiscalYearRepository = fiscalYearRepository;
_messageClass = messageClass;
_baseInterface = baseInterface;
_dateService = dateService;
}
// Assignment Question
// Create 2 Assemblies(A and B)
// Declare 2 Classes(X and Y) in Assembly A both classes should be accessible in Assembly B.
// But restrict the instantiation of class Y in Assembly B.
// But methods from the Class Y should be accessible in Assembly B via Class X.
public static void Main()
{
ClassX classXObj = new ClassX();
classXObj.MethodOfClassX();
IBaseInterface baseInterface = classXObj.classYObject;
baseInterface.SomeMethod1();
baseInterface.SomeMethod2();
baseInterface.SomeMethod3();
}
private void There_is_right_discriminator(IBaseInterface entity)
{
var json = JsonConvert.SerializeObject(entity);
var jObject = JToken.Parse(json);
var discriminator = jObject[DiscriminatorName]?.Value <string>();
var obj = JsonConvert.DeserializeObject <IBaseInterface>(json);
obj.Should().BeEquivalentTo(entity);
Assert.AreEqual(discriminator, entity.GetType().Name);
}
private void RefMethod <reponse>(ref BClass <reponse> r) where reponse : IGenericInterface
{
IBaseInterface <reponse> i = r;
var result = Object.ReferenceEquals(i, r);
if (!result)
{
throw new Exception("Ref not equal");
}
RefMethod(ref i);
}
public ProductService(
IMessageClass messageClass,
IProductRepository productRepository,
IBaseInterface baseInterface,
IImageService imageService)
{
_productRepository = productRepository;
_messageClass = messageClass;
_baseInterface = baseInterface;
_imageService = imageService;
}
public void GetInner_Call_On_InnerObject_Returns_InnerObject()
{
// Arrange
DummyAggregatedClass dummyInnerObject = new DummyAggregatedClass();
IBaseInterface dummyBase = dummyInnerObject as IBaseInterface;
// Act
DummyAggregatedClass innerObject = Decorator.GetInner(dummyBase) as DummyAggregatedClass;
// Assert
Assert.Same(dummyInnerObject, innerObject);
}
public void GetInner_Call_On_Wrapper_Which_Does_Not_Contain_InnerObject_Returns_Wrapper()
{
// Arrange
DummyWrapper dummyWrapper = new DummyWrapper();
IBaseInterface dummyBase = dummyWrapper as IBaseInterface;
// Act
DummyWrapper innerObject = Decorator.GetInner(dummyBase) as DummyWrapper;
// Assert
Assert.Same(dummyWrapper, innerObject);
}
public int AnyClassReponseRefToCallAMethod <reponseClass, response>() where reponseClass : IBaseInterface <response> where response : IGenericInterface
{
IBaseInterface <response> genReponse = (reponseClass)Activator.CreateInstance(typeof(reponseClass));
var gen = (response)Activator.CreateInstance(typeof(response));
genReponse.SetReponse(gen);
RefMethod(ref genReponse);
var genMoop = genReponse.boop();
return(genMoop);
}
public void GetInner_Returns_Inner_Object_From_ObjectWrapper_Which_Wraps_Itself()
{
// Arrange
DummyAggregatedClass dummyInnerObject = new DummyAggregatedClass();
DummyBaseWrapper dummyBaseWrapper = new DummyBaseWrapper(dummyInnerObject);
IBaseInterface dummyBase = dummyBaseWrapper as IBaseInterface;
// Act
DummyBaseWrapper innerObject = Decorator.GetInner(dummyBase) as DummyBaseWrapper;
// Assert
Assert.Same(dummyBaseWrapper, innerObject);
}
/// <summary>
/// auto code event
/// </summary>
private void Button_Click_AutoCode(object sender, RoutedEventArgs e)
{
var mainWindow = this.DataContext as MainWindowModel;
if (mainWindow == null || string.IsNullOrWhiteSpace(_fullPath))
{
return;
}
IBaseInterface iChoose = DLLAccess.CreateBaseInterface(mainWindow.AssemblyFile, mainWindow.ClassNamespace);
iChoose.AutoCode(_fullPath);
}
public void GetInner_Returns_InnerMost_Object_From_ObjectWrapper()
{
// Arrange
DummyAggregatedClass dummyInnerObject = new DummyAggregatedClass();
DummyObjectWrapper dummyObjectWrapper = new DummyObjectWrapper(dummyInnerObject);
DummyDoubleLayerWrapper dummyDoubleLayerWrapper = new DummyDoubleLayerWrapper(dummyObjectWrapper);
IBaseInterface dummyBase = dummyDoubleLayerWrapper as IBaseInterface;
// Act
DummyAggregatedClass innerObject = Decorator.GetInner(dummyBase) as DummyAggregatedClass;
// Assert
Assert.Same(dummyInnerObject, innerObject);
}
public StaffsService(
IStaffsRepository staffsRepository,
IPhotoStorageRepository photoStorageRepository,
IUsersRepository usersRepository,
IMessageClass messageClass,
IBaseInterface baseInterface,
IAdministrationService administrationService,
IMenusService menusService)
{
_staffsRepository = staffsRepository;
_photoStorageRepository = photoStorageRepository;
_messageClass = messageClass;
_usersRepository = usersRepository;
_baseInterface = baseInterface;
_administrationService = administrationService;
_menusService = menusService;
}
public static void Test_Can_Serialize_Deserialize_Child_Through_Interface()
{
Assert.Warn("We don't support Interface types as the root object. This is not a supported feature at the moment.");
return;
//arrange
SerializerService serializer = new SerializerService();
//act
serializer.RegisterType <IBaseInterface>();
serializer.Compile();
IBaseInterface instance = serializer.Deserialize <IBaseInterface>(serializer.Serialize <IBaseInterface>(new ChildOfInterfaceTwo(5, 7)));
//assert
Assert.NotNull(instance);
Assert.AreEqual(5, ((ChildOfInterfaceTwo)instance).b);
Assert.AreEqual(7, ((ChildOfInterfaceTwo)instance).c);
}
public void BaseInterfaceWithClassProperty()
{
// Arrange
var expectedTimestamp = new DateTime(2015, 2, 22);
const int expectedCount = 27;
const string expectedMessage = "Happy Birthday";
// Act
IBaseInterface baseInterface = InterfaceBuilder.CreateObject <IBaseInterface>();
baseInterface.Details = new Details {
Timestamp = expectedTimestamp, Count = expectedCount
};
baseInterface.Message = expectedMessage;
// Assert
Assert.AreEqual(expectedTimestamp, baseInterface.Details.Timestamp, "Details.Timestamp");
Assert.AreEqual(expectedCount, baseInterface.Details.Count, "Details.Count");
Assert.AreEqual(expectedMessage, baseInterface.Message, "Message");
}
public CompanyController(IBaseInterface <Company, CompanyDto> companyRepository, ILoggerFactory loggerFactory)
{
_logger = loggerFactory.CreateLogger <CompanyController>();
_companyRepository = companyRepository;
}
public CompanyController(string connectionString)
{
this.dbSConStr = connectionString;
_companyRepository = new CompanyRepository(connectionString);
}
public UomsController(IBaseInterface <Uom> uomService)
{
_uomService = uomService;
}
public CategoriesController(IBaseInterface <Category> categoryService)
{
_categoryService = categoryService;
}
public CompanyController(IBaseInterface <CompanyDto, Company> companyRepo, ILoggerFactory loggerFactory, ITokenInfoProvider tokenInfoProvider)
{
_logger = loggerFactory.CreateLogger <CompanyController>();
_companyRepo = companyRepo;
} // Dependency Injection
public static void AMethodTakingBaseInterface(IBaseInterface arg)
{
InterfacesTests.Output = "OK";
}
public MenusService(IMenusRepository menusRepository,
IBaseInterface baseInterface)
{
_menusRepository = menusRepository;
_baseInterface = baseInterface;
}
public void PrintValue(IBaseInterface someclass)
{
Console.WriteLine(someclass.GetValue());
}
public TypesController(IBaseInterface <Models.Type> typeService)
{
_typeService = typeService;
}
public CustomersController(IBaseInterface <Customer> categoryService)
{
_categoryService = categoryService;
}
public PaymentsController(IBaseInterface <Payment> parentCategoryService)
{
_parentCategoryService = parentCategoryService;
}
public EmployeesController(IBaseInterface <EmployeeDto, Employee> employeeRepository, ILoggerFactory loggerFactory, ITokenInfoProvider tokenInfoProvider)
{
_logger = loggerFactory.CreateLogger <EmployeesController>();
_employeeRepository = employeeRepository;
_tokenInfoProvider = tokenInfoProvider;
}
public ProductsController(IBaseInterface <Product> productService)
{
_productService = productService;
}
