Injector Open

[Margit Szermer]

Weare a privately owned support forum for the Dodge Ram Cummins Diesels. All information is free to read for everyone. To interact or ask questions you must have a subscription plan to enable all other features beyond reading. Please go over to the Subscription Page and pick out a plan that fits you best. At any time you wish to cancel the subscription please go back over to the Subscription Page and hit the Cancel button and your subscription will be stopped. All subscriptions are auto-renewing.

You may find one that doesn't make it run rough when you crack the line. That way you can pinpoint wich injector it is. If it's an injector ? Take it to shop that does injector work and have it checked out.

This is the same as pulling a spark plug cable off the plug to figure out wich cylinder is missing on a gas motor. The one already missing wont cause any miss when you pull the plug cable off the spark plug.

Please take the time and give the author a 1 to a 5-star rating for the information you have gained from anywhere on the website. All forum threads, articles, etc. If a members post is good information please don't forget to tell them "Thanks" or "Like"

I saw that you suspect an injector is stuck open, so I'd suggest checking your oil, smelling it for gas that has leaked through your piston rings from flooded cylinders, and if it smells off, changing the oil at least one time, possibly multiple times to get rid of any fuel in there.

Check the signal to each injector with a multimeter, unplug each connector and have an assistant spin the car over to get a DC voltage reading and to check that there isn't an odd short keeping your injector open.

Suggest you pull all the injectors. Not too bad a process, the forums have a helpful video available. ALSO PULL THE COLD START injector, which is at the bottom of the plenum. See why I recommend pulling the Intake?

Head gasket is possible, but you will smell antifreeze out the exhaust, not gasoline. To blow a head gasket you would need to massively overheat the engine, as in pegged temp gauge and steam billowing everywhere.

How can a stuck open exhaust blow the cat on the other side of the engine? In the intake process, there is always a bit of intake fuel mist coming back up through the intake valve before the valve completely shuts. Enough can kick back through to the other half of the Vee to richen up every cylinder.

Great idea until low tension piston rings and direct injectors happen to be present. Best tool I ever bought was the kit to blast the back of the valves after the intake is off. Hello Audi V-10!! Takes care of my boat payment.

.NET has superior support for generic programming and Simple Injector has been designed to make full use of it. Simple Injector arguably has the most advanced support for generics of all DI libraries. Simple Injector can handle any generic type and implementing patterns such as decorator, mediator, strategy, composite and chain of responsibility is a breeze.

Although many other DI libraries contain an advanced API for doing convention based registration, we found that doing this with custom LINQ queries is easier to write, more understandable, and can often prove to be more flexible than using a predefined and restrictive API.

Your application might contain many implementations of this interface for validating customers, employees, products, orders, etc. Without auto-registration you would probably end up with a set registrations similar to those you previously saw:

By default, Register searches the supplied assemblies for all types that implement the IValidator interface and registers each type by their specific (closed-generic) interface. It even works for types that implement multiple closed versions of the given interface.

Note: There is a Register overload available that takes a list of System.Type instances, instead a list of Assembly instances and there is a Container.GetTypesToRegister method that allows retrieving a list of types based on a given service type for a set of given assemblies. This gives you more control over how these types are registered.

Above are a couple of basic examples of the things you can do with auto-registration. A more advanced scenario could be the registration of multiple implementations of the same closed-generic type to a common interface, i.e. a set of types that all implement the same interface.

As an example, imagine the scenario where you have a CustomerValidator type and a GoldCustomerValidator type and they both implement IValidator and you want to register them both at the same time. The earlier registration methods would throw an exception alerting you to the fact that you have multiple types implementing the same closed-generic type. The following registration, however, does enable this scenario:

The code snippet registers all types from the given assembly that implement IValidator. As you now have multiple implementations the container cannot inject a single instance of IValidator and because of this, you need to register a collection. Because you register a collection, you can no longer call container.GetInstance(). Instead instances can be retrieved by having an IEnumerable constructor argument or by calling container.GetAllInstances().

It is not generally regarded as best practice to have an IEnumerable dependency in multiple class constructors (or accessed from the container directly). Depending on a set of types complicates your application design and can lead to code duplication. This can often be simplified with an alternate configuration. A better way is to have a single composite type that wraps IEnumerable and presents it to the consumer as a single instance, in this case a CompositeValidator:

This registration maps the open-generic IValidator interface to the open-generic CompositeValidator implementation. Because the CompositeValidator contains an IEnumerable dependency, the registered types will be injected into its constructor. This allows you to let the rest of the application simply depend on the IValidator, while registering a collection of IValidator implementations under the covers.

This will, however, not work because this registration will try to map any closed IValidator abstraction to the NullValidator implementation, but other registrations (such as ProductValidator and OrderValidator) already exist. What you need here is to make NullValidator a fallback registration and Simple Injector allows this using the RegisterConditional method overloads:

The result of this registration is exactly as you would have expected to see from the individual registrations above. Each request for IValidator, for example, will return a NullValidator instance each time. The RegisterConditional is supplied with a predicate. In this case the predicate checks whether there already is a different registration that handles the requested service type. In that case the predicate returns false and the registration is not applied.

The type SomeValidator is called partially-closed, since although its generic-type argument has been filled in with a type, it still contains a generic-type argument. Simple Injector will be able to apply these constraints, just as it handles any other generic-type constraints.

The Register overload that takes in a list of assemblies only selects non-generic implementations of the given open-generic type. Open-generic implementations are skipped, because they often need special attention.

In the previous example a set of IValidator implementations is supplied to the Collection.Register overload. This list contains one generic implementation, namely DataAnnotationsValidator. This leads to a registration that is equivalent to the following manual registration:

In other words, the supplied non-generic types are grouped by their closed IValidator interface and the DataAnnotationsValidator is applied to every group. This leads to three separate IEnumerable registrations. One for each closed-generic IValidator type.

Note: This will work equally well when the open-generic types contain type constraints. In that case those types will be applied conditionally to the collections based on their generic-type constraints.

In most cases, however, manually supplying the Collection.Register with a list of types leads to hard-to-maintain configurations, because the registration needs to be changed for each new validator you add to the system. Instead, you can make use of one of the Collection.Register overloads that accepts a list of assemblies and append the open-generic type separately:

The Register and Collection.Register overloads that accept a list of assemblies use this GetTypesToRegister method internally as well. Each, however, use their own TypesToRegisterOptions configuration.

Unregistered-type resolution is the ability to get notified by the container when a type that is currently unregistered in the container, is requested for the first time. This gives the user (or extension point) the chance of registering that type. Simple Injector supports this scenario with the ResolveUnregisteredType event. Unregistered type resolution enables many advanced scenarios.

Context-based injection is the ability to inject a particular dependency based on the context it lives in (or change the implementation based on the type it is injected into). Simple Injector contains the RegisterConditional method overloads that enable context-based injection.

3a8082e126