public Mapper() { _assemblyRepository = new AssemblyRepository(); _typeRepository = new TypeRepository(_assemblyRepository); _memberRepository = new MemberRepository(_typeRepository); _modelCreator = new ModelCreator(_typeRepository, _memberRepository); }
public AvaloniaXamlMember(string name, XamlType owner, ITypeRepository xamlTypeRepository, ITypeFeatureProvider featureProvider) : base(name, owner, xamlTypeRepository, featureProvider) { }
/// <summary> /// Initializes a new instance of the <see cref="MethodInfoTypeFactory"/> class. /// </summary> /// <param name="typeRepository">The type repository.</param> public MethodInfoTypeFactory(ITypeRepository typeRepository) { if (typeRepository == null) throw new ArgumentNullException("typeRepository"); _typeRepository = typeRepository; }
public VehicleEditorModel(ICustomerRepository customerRepository, IVehicleGroupRepository vehicleGroupRepository, IVehicleRepository vehicleRepository, IVehicleDetailRepository vehicleDetailRepository, IVehicleWheelRepository vehicleWheelRepository, ISparepartRepository sparepartRepository, ITypeRepository typeRepository, ISpecialSparepartDetailRepository wheelDetailRepository, IBrandRepository brandRepository, ISparepartDetailRepository sparepartDetailRepository, ISpecialSparepartDetailRepository specialSparepartDetailRepository, ISparepartStockCardRepository sparepartStokCardRepository, IReferenceRepository referenceRepository, IUnitOfWork unitOfWork) : base() { _customerRepository = customerRepository; _vehicleGroupRepository = vehicleGroupRepository; _vehicleRepository = vehicleRepository; _vehicleDetailRepository = vehicleDetailRepository; _vehicleWheelRepository = vehicleWheelRepository; _specialSparepartDetailRepository = wheelDetailRepository; _sparepartDetailRepository = sparepartDetailRepository; _sparepartRepository = sparepartRepository; _typeRepository = typeRepository; _brandRepository = brandRepository; _sparepartStokCardRepository = sparepartStokCardRepository; _referenceRepository = referenceRepository; _unitOfWork = unitOfWork; }
public TypeEditorModel(ITypeRepository typeRepository, IUnitOfWork unitOfWork) : base() { _typeRepository = typeRepository; _unitOfWork = unitOfWork; }
/// <summary> /// Initializes a new instance of the <see cref="ProxyTypeBuilder"/> class. /// </summary> /// <param name="typeRepository">The type repository.</param> /// <param name="parentType">The parent type.</param> public ProxyTypeBuilder(ITypeRepository typeRepository, Type parentType) { if (typeRepository == null) throw new ArgumentNullException("typeRepository"); if (parentType == null) throw new ArgumentNullException("parentType"); if (parentType.IsSealed) throw new ArgumentException(Resources.ParentTypeMustNotBeSealed, "parentType"); if (parentType.IsGenericTypeDefinition) throw new ArgumentException(Resources.ParentTypeMustNotBeAGenericTypeDefinition, "parentType"); _typeRepository = typeRepository; _parentType = parentType; _typeBuilder = typeRepository.DefineType("Proxy" , parentType); _invocationHandlerFieldInfo = _typeBuilder.DefineField( "_invocationHandler", typeof (IInvocationHandler), FieldAttributes.Private | FieldAttributes.InitOnly); _interfaceTypes = new HashSet<Type>(); }
public WpfAttachableMember(string name, MethodInfo getter, MethodInfo setter, ITypeRepository typeRepository, ITypeFeatureProvider typeFeatureProvider) : base(name, getter, setter, typeRepository, typeFeatureProvider) { }
public PerspexAttachableXamlMember(string name, XamlType owner, MethodInfo getter, MethodInfo setter, ITypeRepository xamlTypeRepository, ITypeFeatureProvider featureProvider) : base(name, getter, setter, xamlTypeRepository, featureProvider) { }
private Type ResolveFromString(string type, ITypeRepository typeRepository) { Guard.ThrowIfNull(type, nameof(type)); var split = type.Split(':'); var prefix = split.Length == 1 ? split[0] : null; var typeName = split.Length == 1 ? split[1] : split[0]; var xamlType = typeRepository.GetByPrefix(prefix, typeName); return xamlType.UnderlyingType; }
public ModelCreator(ITypeRepository typeRepository, IMemberRepository memberRepository) { _types.Push(TypeKey.None); _methods.Push(MethodKey.None); _properties.Push(PropertyKey.None); _fields.Push(FieldKey.None); _events.Push(EventKey.None); _typeRepository = typeRepository; _memberRepository = memberRepository; }
public AttachableMember(string name, MethodInfo getter, MethodInfo setter, ITypeRepository typeRepository, ITypeFeatureProvider featureProvider) : base(name, typeRepository.GetByType(getter.DeclaringType), typeRepository, featureProvider) { this.getter = getter; this.setter = setter; XamlType = LookupType(); }
public TypeService() { try { string typeStr1 = ConfigurationManager.AppSettings["typeRepository"]; Type type1 = Type.GetType(typeStr1); repo = (ITypeRepository)Activator.CreateInstance(type1); repo.SourcePath = System.Web.Hosting.HostingEnvironment.MapPath("~/App_data/type.xml"); } catch (Exception ex) { } }
public XamlType(Type type, ITypeRepository typeRepository, ITypeFactory typeTypeFactory, ITypeFeatureProvider featureProvider) { Guard.ThrowIfNull(type, nameof(type)); Guard.ThrowIfNull(typeRepository, nameof(typeRepository)); Guard.ThrowIfNull(featureProvider, nameof(featureProvider)); TypeRepository = typeRepository; TypeFactory = typeTypeFactory; FeatureProvider = featureProvider; UnderlyingType = type; Name = type.Name; }
public Context(DbContext context = null, IUserRepository users = null, IUserProfileRepository profiles = null, IModelRepository models = null, IBrandRepository brands = null, ITypeRepository types =null, ICarRepository cars =null, IImageCarRepository imageCars =null) { _db = context ?? new CarDatabase(); Users = users ?? new UserRepository(_db,true); Profiles = profiles ?? new UserProfileRepository(_db, true); Models = models ?? new ModelRepository(_db, true); Brands = brands ?? new BrandRepository(_db, true); Types = types ?? new TypeRepository(_db, true); Cars = cars ?? new CarRepository(_db, true); ImageCars = imageCars ?? new ImageCarRepository(_db, true); }
public AvaloniaXamlType(Type type, ITypeRepository typeRepository, ITypeFactory typeFactory, ITypeFeatureProvider featureProvider) : base(type, typeRepository, typeFactory, featureProvider) { }
public TypeService(ITypeRepository typeRepository, IProductService productService) { _typeRepository = typeRepository; _productService = productService; }
public AuthorController(IAuthorRepository _authRepo, IBookRepository _bookRepo, ITypeRepository _typeRepo) { authorRepository = _authRepo; bookRepository = _bookRepo; typeRepository = _typeRepo; }
public TypeService(ITypeRepository typeRepository) { _typeRepository = typeRepository; }
// Ctor public AdminTypeController (ITypeRepository repo) => typeRepository = repo;
private static XamlInstructionBuilder CreateBuilder(ITypeRepository typeRepository) { return new XamlInstructionBuilder(typeRepository); }
public UnitOfWork(ApplicationDbContext context) { _context = context; CycleEvents = new CycleEventRepository(_context); Types = new TypeRepository(_context); }
public DeviceService(ILogger <DeviceService> log, IMapper mapper, IDeviceRepository dr, IProjectService ps, ITypeHardwareConfigService th, ITypeRepository tr) { this._log = log; this._mapper = mapper; this._dr = dr; this._ps = ps; this._th = th; this._tr = tr; }
public Member(string name, XamlType declaringType, ITypeRepository typeRepository, ITypeFeatureProvider featureProvider) : base(name, declaringType, typeRepository, featureProvider) { XamlType = LookupType(); }
public FunctionalTypeController(ITypeRepository typeRepository) { _typeRepository = typeRepository; }
public BookController(ILanguageRepository _languageRepo, IPublisherRepository _publisherRepo, IBookRepository _bookRepo, ITypeRepository _typeRepo, IAuthorRepository _authRepo) { bookRepository = _bookRepo; typeRepository = _typeRepo; authorRepository = _authRepo; publisherRepository = _publisherRepo; languageRepository = _languageRepo; }
public ValueCommand(StateCommuter stateCommuter, ITypeRepository typeSource, ITopDownValueContext topDownValueContext, string value) : base(stateCommuter) { this.value = value; ValuePipeLine = new ValuePipeline(typeSource, topDownValueContext); }
public XamlInstructionBuilder(ITypeRepository registry) { this.registry = registry; }
public RuntimeTypeSource(ITypeRepository typeRepository, INamespaceRegistry nsRegistry) { TypeRepository = typeRepository; NamespaceRegistry = nsRegistry; }
public TypeSystemService(ILogger <TypeSchemaService> log, IMapper mapper, ITypeSystemRepository tsr, ITypeRepository tr) { this._log = log; this._mapper = mapper; this._tsr = tsr; this._tr = tr; }
public TypeUpdateFileService(ILogger <TypeUpdateFileService> log, IMapper mapper, ITypeUpdateFileRepository tu, ITypeRepository tr) { this._log = log; this._mapper = mapper; this._tu = tu; this._tr = tr; }
public RecipeController(IProductRepository product, IRecipeRepository recipe, ITypeRepository type) { productRepository = product; recipeRepository = recipe; typeRepository = type; }
public ZoningDomainService(ITypeRepository typeRepository) { _typeRepository = typeRepository; }
public StartObjectCommand(StateCommuter stateCommuter, ITypeRepository typeRepository, XamlType xamlType, object rootInstance) : base(stateCommuter) { this.typeRepository = typeRepository; this.xamlType = xamlType; this.rootInstance = rootInstance; }
public TypeController(ITypeRepository repo, ILogger logger) { _repo = repo; _logger = logger; }
public MemberRepository(ITypeRepository typeRepository) { _typeRepository = typeRepository; }
public TypeConfigService(ILogger <TypeConfigService> log, ITypeConfigRepository tc, IMapper mapper, ITypeRepository tr) { this._log = log; this._tc = tc; this._mapper = mapper; this._tr = tr; }
public ValuesController(IProductRepository productContext, ITypeRepository productTypeRepository) { _productContext = productContext; _productTypeContext = productTypeRepository; }
public TypeListModel(ITypeRepository typeRepository, IUnitOfWork unitOfWork) : base() { _typeRepository = typeRepository; _unitOfWork = unitOfWork; }
public DeviceController(IDeviceRepository deviceRepository, IManufacturerRepository manufacturerRepository, ITypeRepository typeRepository, IOperatingSystemRepository operatingSystemRepository, IOSversionRepository osVersionRepository, IRAMamountRepository ramAmountRepository, IProcessorRepository processorRepository, IUserRepository userRepository) { _deviceRepository = deviceRepository; _manufacturerRepository = manufacturerRepository; _typeRepository = typeRepository; _operatingSystemRepository = operatingSystemRepository; _osVersionRepository = osVersionRepository; _ramAmountRepository = ramAmountRepository; _processorRepository = processorRepository; _userRepository = userRepository; }
public WpfMember(string name, XamlType declaringType, ITypeRepository typeRepository, ITypeFeatureProvider typeFeatureProvider) : base(name, declaringType, typeRepository, typeFeatureProvider) { }
public TypesController(ITypeRepository typeRepository) { _typeRepository = typeRepository; }
public TypeMenuViewComponent(ITypeRepository repo) { _repository = repo; }
public EndMemberCommand(ITypeRepository typeRepository, StateCommuter stateCommuter, IValueContext valueContext) : base(stateCommuter) { this.typeRepository = typeRepository; this.valueContext = valueContext; }
public EndMemberCommand(ITypeRepository typeRepository, StateCommuter stateCommuter) : base(stateCommuter) { this.typeRepository = typeRepository; }
public TypeService(ITypeRepository typeRepository, IUnitOfWork unitOfWork) { this._typeRepository = typeRepository; this._unitOfWork = unitOfWork; }
public TypesSeeds(ITypeRepository typeRepository) { _typeRepository = typeRepository; }
public HomeController(ILogger <HomeController> logger, ITypeRepository typeRepository) { _logger = logger; _typeRepository = typeRepository; }
public TypeService(ITypeRepository typeRepository) { this.typeRepository = typeRepository; }
public XamlTypeMock(Type type, ITypeRepository typeRepository, ITypeFactory typeTypeFactory, ITypeFeatureProvider featureProvider) : base(type, typeRepository, typeTypeFactory, featureProvider) { }
public ValueContext(ITypeRepository typeRepository, ITopDownValueContext topDownValueContext, IReadOnlyDictionary<string, object> parsingDictionary) { this.typeRepository = typeRepository; this.topDownValueContext = topDownValueContext; this.parsingDictionary = parsingDictionary; }
public DeviceController(IDeviceRepository repository, ICampaignRepository campaign, ITypeRepository type, IUsersRepository usersRepository) { _repository = repository; _campaign = campaign; _typeRepository = type; _usersRepository = usersRepository; }
public static XamlType Create(Type underlyingType, ITypeRepository typeRepository, ITypeFactory typeFactory, ITypeFeatureProvider featureProvider) { Guard.ThrowIfNull(underlyingType, nameof(typeRepository)); return new XamlType(underlyingType, typeRepository, typeFactory, featureProvider); }
public PerspexXamlType(Type type, ITypeRepository typeRepository, ITypeFactory typeFactory, ITypeFeatureProvider featureProvider) : base(type, typeRepository, typeFactory, featureProvider) { }
public AnothersExpenseController(UserManager <User> userManager, SignInManager <User> signInManager, ITypeRepository typeRepository, IAnothersExpenseRepository anothersExpenseRepository, ICategoryRepository categoryRepository) { _userManager = userManager; _signInManager = signInManager; _anothersExpenseRepository = anothersExpenseRepository; _categoryRepository = categoryRepository; _typeRepository = typeRepository; }
public ImageController(IImageRepository imageRepository, IHashRepository hashRepository, ITypeRepository typeRepository, IConfiguration configuration, IHttpClientFactory clientFactory) { ImageRepository = imageRepository; HashRepository = hashRepository; TypeRepository = typeRepository; Configuration = configuration; HttpClientFactory = clientFactory; }
public ValuePipeline(ITypeRepository typeRepository, ITopDownValueContext topDownValueContext) { this.typeRepository = typeRepository; this.topDownValueContext = topDownValueContext; }
public UploadController(ITypeRepository typeRepository) { this.typeRepository = typeRepository; }