You just pass it to `Depends` and **FastAPI** knows how to do the rest.

///

## Share `Annotated` dependencies { #share-annotated-dependencies }

In the examples above, you see that there's a tiny bit of **code duplication**.

    while (lines.peek() == null) {
      Java8Compatibility.clear(cbuf);
      // The default implementation of Reader#read(CharBuffer) allocates a
      // temporary char[], so we call Reader#read(char[], int, int) instead.
      int read = (reader != null) ? reader.read(buf, 0, buf.length) : readable.read(cbuf);
      if (read == -1) {
        lineBuf.finish();
        break;
      }

    for (String edge : edges) {
      checkArgument(
          edge.length() == 2, "Expecting each edge to consist of 2 characters but got %s", edge);
      char node1 = edge.charAt(0);
      char node2 = edge.charAt(1);
      graphMapBuilder.put(node1, node2);
      if (!directed) {
        graphMapBuilder.put(node2, node1);
      }
    }

          private final char[] unknown = new char[] {'?'};

          @Override
          protected char[] escapeUnsafe(int c) {
            return unknown;
          }
        };
    EscaperAsserts.assertBasic(replacingEscaper);

    // Replacements are applied first regardless of whether the character is in
    // the safe range or not ('&' is a safe char while '\t' and '\n' are not).

            throw new IOException("Service not started");
        }
        return serverSocket.getLocalPort();
    }

    /**
     * Simulate a witness registration
     *
     * @param shareName the share name
     * @param serverAddress the server address
     * @param flags the registration flags
     * @return the registration ID
     */

     * @return the access mask hint
     */
    public int getAccessMaskHint() {
        return accessMaskHint;
    }

    /**
     * Gets the share access hint for optimizing lease handling
     * @return the share access hint
     */
    public int getShareAccessHint() {
        return shareAccessHint;
    }

    @Override

    public static final String MIN_ELEMENT = "a";
    public static final String AFTER_LAST = "z";
    public static final String AFTER_LAST_2 = "zz";
  }

  public static class Chars extends SampleElements<Character> {
    public Chars() {
      // elements aren't sorted, to better test SortedSet iteration ordering
      super('b', 'a', 'c', 'd', 'e');
    }
  }

  public static class Enums extends SampleElements<AnEnum> {

                synonymMap.words.get(bytesReader.readVInt(), scratchBytes);
                if (scratchChars.chars.length < scratchBytes.length) {
                    scratchChars.chars = new char[scratchBytes.length];
                }
                scratchChars.length = UnicodeUtil.UTF8toUTF16(scratchBytes, scratchChars.chars);
                final String word = scratchChars.toString();
                int posInc = 0;

  static long copyReaderToBuilder(Reader from, StringBuilder to) throws IOException {
    checkNotNull(from);
    checkNotNull(to);
    char[] buf = new char[DEFAULT_BUF_SIZE];
    int nRead;
    long total = 0;
    while ((nRead = from.read(buf)) != -1) {
      to.append(buf, 0, nRead);
      total += nRead;
    }
    return total;
  }

  /**

  static CharEscaper createSimpleCharEscaper(ImmutableMap<Character, char[]> replacementMap) {
    return new CharEscaper() {
      @Override
      protected char[] escape(char c) {
        return replacementMap.get(c);
      }
    };
  }

  // A trivial non-optimized escaper for testing.
  static UnicodeEscaper createSimpleUnicodeEscaper(ImmutableMap<Integer, char[]> replacementMap) {
    return new UnicodeEscaper() {