diff --git a/encoding/xml/marshal.go b/encoding/xml/marshal.go
index ae39846..b25ce3f 100644
--- a/encoding/xml/marshal.go
+++ b/encoding/xml/marshal.go
@@ -7,6 +7,7 @@ package xml
 import (
 	"bufio"
 	"bytes"
+	"context"
 	"encoding"
 	"errors"
 	"fmt"
@@ -105,6 +106,8 @@ func Marshal(v any) ([]byte, error) {
 // to generate the XML output one token at a time.
 // The sequence of encoded tokens must make up zero or more valid
 // XML elements.
+// An implementation may access any Context passed to NewEncoderWithContext
+// via e.Context()
 type Marshaler interface {
 	MarshalXML(e *Encoder, start StartElement) error
 }
@@ -124,6 +127,13 @@ type MarshalerAttr interface {
 	MarshalXMLAttr(name Name) (Attr, error)
 }
 
+// ContextMarshalerAttr is the interface implemented by objects that can marshal
+// themselves into valid XML attributes and with reference to the Context provided
+// to NewEncoderWithContext.
+type ContextMarshalerAttr interface {
+	MarshalXMLAttrWithContext(ctx context.Context, name Name) (Attr, error)
+}
+
 // MarshalIndent works like Marshal, but each XML element begins on a new
 // indented line that starts with prefix and is followed by one or more
 // copies of indent according to the nesting depth.
@@ -142,16 +152,29 @@ func MarshalIndent(v any, prefix, indent string) ([]byte, error) {
 
 // An Encoder writes XML data to an output stream.
 type Encoder struct {
-	p printer
+	p   printer
+	ctx context.Context
 }
 
 // NewEncoder returns a new encoder that writes to w.
 func NewEncoder(w io.Writer) *Encoder {
-	e := &Encoder{printer{w: bufio.NewWriter(w)}}
+	//lint:ignore SA1012 allow nil context when not created with NewEncoderWithContext
+	return NewEncoderWithContext(nil, w)
+}
+
+// NewEncoderWithContext returns a new encoder that writes to w
+// and has an associated Context.
+func NewEncoderWithContext(ctx context.Context, w io.Writer) *Encoder {
+	e := &Encoder{
+		p:   printer{w: bufio.NewWriter(w)},
+		ctx: ctx,
+	}
 	e.p.encoder = e
 	return e
 }
 
+func (enc *Encoder) Context() context.Context { return enc.ctx }
+
 // Indent sets the encoder to generate XML in which each element
 // begins on a new indented line that starts with prefix and is followed by
 // one or more copies of indent according to the nesting depth.
@@ -415,9 +438,10 @@ func (p *printer) popPrefix() {
 }
 
 var (
-	marshalerType     = reflect.TypeOf((*Marshaler)(nil)).Elem()
-	marshalerAttrType = reflect.TypeOf((*MarshalerAttr)(nil)).Elem()
-	textMarshalerType = reflect.TypeOf((*encoding.TextMarshaler)(nil)).Elem()
+	marshalerType            = reflect.TypeOf((*Marshaler)(nil)).Elem()
+	marshalerAttrType        = reflect.TypeOf((*MarshalerAttr)(nil)).Elem()
+	contextMarshalerAttrType = reflect.TypeOf((*ContextMarshalerAttr)(nil)).Elem()
+	textMarshalerType        = reflect.TypeOf((*encoding.TextMarshaler)(nil)).Elem()
 )
 
 // marshalValue writes one or more XML elements representing val.
@@ -578,6 +602,17 @@ func (p *printer) marshalValue(val reflect.Value, finfo *fieldInfo, startTemplat
 
 // marshalAttr marshals an attribute with the given name and value, adding to start.Attr.
 func (p *printer) marshalAttr(start *StartElement, name Name, val reflect.Value) error {
+	if val.CanInterface() && val.Type().Implements(contextMarshalerAttrType) {
+		attr, err := val.Interface().(ContextMarshalerAttr).MarshalXMLAttrWithContext(p.encoder.Context(), name)
+		if err != nil {
+			return err
+		}
+		if attr.Name.Local != "" {
+			start.Attr = append(start.Attr, attr)
+		}
+		return nil
+	}
+
 	if val.CanInterface() && val.Type().Implements(marshalerAttrType) {
 		attr, err := val.Interface().(MarshalerAttr).MarshalXMLAttr(name)
 		if err != nil {
@@ -591,6 +626,18 @@ func (p *printer) marshalAttr(start *StartElement, name Name, val reflect.Value)
 
 	if val.CanAddr() {
 		pv := val.Addr()
+
+		if pv.CanInterface() && pv.Type().Implements(contextMarshalerAttrType) {
+			attr, err := pv.Interface().(ContextMarshalerAttr).MarshalXMLAttrWithContext(p.encoder.Context(), name)
+			if err != nil {
+				return err
+			}
+			if attr.Name.Local != "" {
+				start.Attr = append(start.Attr, attr)
+			}
+			return nil
+		}
+
 		if pv.CanInterface() && pv.Type().Implements(marshalerAttrType) {
 			attr, err := pv.Interface().(MarshalerAttr).MarshalXMLAttr(name)
 			if err != nil {