pet | Simple command-line snippet manager, written in Go | Text Editor library

My only idea for this is to create two classes for the animal: PetRequest and PetResponse

No, that's exactly how you're meant to do it (well, except for "cast the PetRequest to a Pet, don't do that, use AutoMapper or similar instead).

I argue that it's a shortsighted (_{or just lazy}) mistake to simply reuse a single DTO contract for all use-cases:

A common mantra in object/class/type-design is "make invalid states unrepresentable" (it is not without its detractors though) - which means that if a Pet object cannot have a meaningful PetId property (e.g. because it hasn't been INSERTed yet to get an IDENTITY/AUTONUMBER value back) then it shouldn't have a PetId property at all - which in-turn means you will need separate DTO types: NewPet and ExistingPet (or EditPet or similar).

You can (ab)use inheritance from a base PetValues DTO class to avoid repeating yourself or manually maintaining copy+pasta'd sets of object properties, but I feel it's a bad idea to use inheritance as a substitute for mixins (which C# still doesn't support, argh) because you'll end-up inadvertently including inappropriate members, and because if you want to use immutable types as DTOs then you'll run into lots of pain with immutable types' constructors as C# (still) doesn't have automatic constructor parameter inheritance (i.e. you can't add a new member to a base immutable DTO type without having also update all subclasses' constructors to add those new parameters for the new members).

_{Unfortunately Swagger doesn't play-nice with DTO type inheritance, either due to limitations in the tooling or other reasons, but in practice I find this isn't an issue because tooling that generates C#/.NET DTO types from Swagger JSON will let you customize the generated output. Polymorphism should not be a feature of DTOs/data-contracts anyway: they're meant to be record-style representations of structured data, not mutable object graphs.}

Anyway, I'd do it like this (caution: this is my personal style, also assuming C# 8.0+ non-nullable reference-types are enabled, and all DTO members are non-nullable):

In most programming languages, if you require an instance of B to construct A and an instance of A to construct B, then you won't be able to construct either.

Here:

• AccessTokenRefreshDataSource requires AuthenticationService
• AuthenticationService requires Retrofit
• Retrofit requires OkHttpClient
• OkHttpClient requires Authenticator
• Authenticator requires AccessTokenRefreshDataSource

...and consequently, regardless of your module or component structure, Dagger can't create any of those instances first.

However, if your AccessTokenRefreshDataSourceImpl does not need its AuthenticationService instance within the constructor itself, you can replace it with Provider: Dagger automatically lets you inject Provider for any T in the graph, among other useful bindings. This allows Dagger to create your AccessTokenRefreshDataSource without first creating an AuthenticationService, with the promise that once the object graph is created your AccessTokenRefreshDataSource can receive the singleton AuthenticationService instance it needs. After you inject the provider, just call authenticationServiceProvider.get() to get the instance wherever you need it (presumably outside the constructor).

Of course, you can solve your problem with the same refactor anywhere else in your graph you control. AccessTokenAuthenticator is also a reasonable refactor point, assuming you've written it yourself and thus can modify its constructor.

Points discussed in the comments:

• You can always inject a Provider instead of any binding T in your graph. In addition to being valuable for breaking dependency cycles, it can also be handy if your dependency-injected class needs to instantiate an arbitrary number of that object, or if creating the object takes a lot of memory or classloading and you want to delay it until later. Of course, if the object is cheap to construct without dependency cycles and you expect to call get() exactly once, then you can skip that and directly inject T as you've done here.

  • Provider is a single-method object. Calling get() on it is the same as calling a getter of type T on the Component itself. If the object is unscoped, you get a new one; if the object is scoped, you get the one that Dagger has stored in the Component.

  • Generally speaking you can just inject the Provider and call get on it directly:

Here is how you do it

I added two tables to a sheet: tblFruits and tblPets.

Then you can put the following formula in any cell on the same sheet or another sheet.

For versions of Excel that suppot LET

I believe you want to use CDO's distgrid and collgrid methods for this.

First, run this:

You need to get the nested order. As you see, the key 'name' is under 'dogs', then the key 'name' does not exist under . Thus, you need to call it as

If you are trying to get:

• a CollectionReference, then use collection():

The read_only_fields meta option will work for the fields which are not explicitly defined in the Serializer.

So, in your case, you need to add the read_only=True to those explicitly defined fields, as