**FastAPI** stellt den gleichen `WebSocket` direkt zur Verfügung, als Annehmlichkeit für Sie, den Entwickler. Er kommt aber direkt von Starlette.

///

## Nachrichten erwarten und Nachrichten senden { #await-for-messages-and-send-messages }

In Ihrer WebSocket-Route können Sie Nachrichten `await`en und Nachrichten senden.

{* ../../docs_src/websockets_/tutorial001_py310.py hl[48:52] *}

Sie können Binär-, Text- und JSON-Daten empfangen und senden.

        // We have collected all the problems so let's mimic the way the old code worked and just blow up right here.
        // That's right lets just let it rip right here and send a big incomprehensible blob of text at unsuspecting
        // users. Bad dog!

        resolutionErrorHandler.throwErrors(request, result);

        return result;
    }

    end

    operation ->> client: Return response to client
    Note over client,operation: Response is already sent, can't change it anymore
    opt Tasks
        operation -->> tasks: Send background tasks
    end
    opt Raise other exception
        tasks -->> tasks: Handle exceptions in the background task code
    end
```

/// info

            if (aggregations != null) {
                builder.facetResponse(new FacetResponse(aggregations));
            }

        });
        return builder.build();
    }

    /**
     * Sends a search request to OpenSearch with the specified parameters.
     *
     * @param query the search query string
     * @param params the search request parameters

///

## What is "Form Data" { #what-is-form-data }

The way HTML forms (`<form></form>`) sends the data to the server normally uses a "special" encoding for that data, it's different from JSON.

**FastAPI** will make sure to read that data from the right place instead of JSON.

/// note | Technical Details

This includes, for example:

* Email notifications sent after performing an action:
    * As connecting to an email server and sending an email tends to be "slow" (several seconds), you can return the response right away and send the email notification in the background.
* Processing data:
    * For example, let's say you receive a file that must go through a slow process, you can return a response of "Accepted" (HTTP 202) and process the file in the background.

**FastAPI**, geliştirici olarak işinizi kolaylaştırmak için aynı `WebSocket`'i doğrudan sağlar. Ancak aslında doğrudan Starlette'ten gelir.

///

## Mesajları `await` Edin ve Mesaj Gönderin { #await-for-messages-and-send-messages }

WebSocket route'unuzda mesajları `await` edebilir ve mesaj gönderebilirsiniz.

{* ../../docs_src/websockets_/tutorial001_py310.py hl[48:52] *}

Binary, text ve JSON verisi alıp gönderebilirsiniz.

			t.Errorf("failed to read from client. %v", terr)
			return
		}
		received = string(b)
		if received != "message two\n" {
			t.Errorf(`server: expected: "message two\n", got: %v`, received)
			return
		}

		// Send a response.
		_, terr = io.WriteString(deadlineconn, "messages received\n")
		if terr != nil {
			t.Errorf("failed to write to client. %v", terr)
			return
		}
	}()

	c, err := net.Dial("tcp", serverAddr)

     * The module path is the collection of dependencies associated with {@link JavaPathType#MODULES}.
     * It is caller's responsibility to send the message to a logger.
     *
     * @return warning message if at least one filename-based auto-module was found
     */
    Optional<String> warningForFilenameBasedAutomodules();

            breakNotif.getNewLeaseState()
        );
        
        // Send acknowledgment
        Smb2LeaseBreakAcknowledgment ack = new Smb2LeaseBreakAcknowledgment(
            breakNotif.getLeaseKey(),
            breakNotif.getNewLeaseState()
        );
        
        sendAsync(ack);  // Send acknowledgment asynchronously
    }
    // ... handle other message types ...
}
```