diff --git a/.ci-builds/.azure-pipelines-icu4c.yml b/.ci-builds/.azure-pipelines-icu4c.yml
index a749764931e..10a3af1e3f8 100644
--- a/.ci-builds/.azure-pipelines-icu4c.yml
+++ b/.ci-builds/.azure-pipelines-icu4c.yml
@@ -381,7 +381,7 @@ jobs:
 #-------------------------------------------------------------------------
 - job: ICU4C_MSVC_x64_Debug
   displayName: 'C: MSVC x64 Debug (VS 2022)'
-  timeoutInMinutes: 35
+  timeoutInMinutes: 60
   pool:
     vmImage: 'windows-2022'
     demands: 
@@ -487,7 +487,7 @@ jobs:
 #-------------------------------------------------------------------------
 - job: ICU4C_MSVC_x86_Debug_VS2019
   displayName: 'C: MSVC 32-bit Debug (VS 2019)'
-  timeoutInMinutes: 60
+  timeoutInMinutes: 90
   pool:
     vmImage: 'windows-2019'
     demands: 
diff --git a/icu4c/source/i18n/messageformat2_allocation.h b/icu4c/source/i18n/messageformat2_allocation.h
index 431862cecef..7be27e22252 100644
--- a/icu4c/source/i18n/messageformat2_allocation.h
+++ b/icu4c/source/i18n/messageformat2_allocation.h
@@ -24,16 +24,15 @@ namespace message2 {
     // Helpers
 
     template<typename T>
-    static T* copyArray(const T* source, int32_t& len) { // `len` is an in/out param
-        if (source == nullptr) {
-            len = 0;
+    static T* copyArray(const T* source, int32_t len, UErrorCode& status) {
+        if (U_FAILURE(status)) {
             return nullptr;
         }
+        U_ASSERT(source != nullptr);
+        U_ASSERT(len >= 0);
         T* dest = new T[len];
         if (dest == nullptr) {
-            // Set length to 0 to prevent the
-            // array from being accessed
-            len = 0;
+            status = U_MEMORY_ALLOCATION_ERROR;
         } else {
             for (int32_t i = 0; i < len; i++) {
                 dest[i] = source[i];
@@ -43,13 +42,14 @@ namespace message2 {
     }
 
     template<typename T>
-    static T* copyVectorToArray(const UVector& source, int32_t& len) {
-        len = source.size();
+    static T* copyVectorToArray(const UVector& source, UErrorCode& status) {
+        if (U_FAILURE(status)) {
+            return nullptr;
+        }
+        int32_t len = source.size();
         T* dest = new T[len];
         if (dest == nullptr) {
-            // Set length to 0 to prevent the
-            // array from being accessed
-            len = 0;
+            status = U_MEMORY_ALLOCATION_ERROR;
         } else {
             for (int32_t i = 0; i < len; i++) {
                 dest[i] = *(static_cast<T*>(source.elementAt(i)));
@@ -59,19 +59,21 @@ namespace message2 {
     }
 
     template<typename T>
-    static T* moveVectorToArray(UVector& source, int32_t& len) {
-        len = source.size();
+    static T* moveVectorToArray(UVector& source, UErrorCode& status) {
+        if (U_FAILURE(status)) {
+            return nullptr;
+        }
+
+        int32_t len = source.size();
         T* dest = new T[len];
         if (dest == nullptr) {
-            // Set length to 0 to prevent the
-            // array from being accessed
-            len = 0;
+            status = U_MEMORY_ALLOCATION_ERROR;
         } else {
             for (int32_t i = 0; i < len; i++) {
                 dest[i] = std::move(*static_cast<T*>(source.elementAt(i)));
             }
+            source.removeAllElements();
         }
-        source.removeAllElements();
         return dest;
     }
 
diff --git a/icu4c/source/i18n/messageformat2_data_model.cpp b/icu4c/source/i18n/messageformat2_data_model.cpp
index 822d20c3b84..8255de01af0 100644
--- a/icu4c/source/i18n/messageformat2_data_model.cpp
+++ b/icu4c/source/i18n/messageformat2_data_model.cpp
@@ -77,15 +77,10 @@ SelectorKeys::Builder::~Builder() {
 }
 
 SelectorKeys::SelectorKeys(const UVector& ks, UErrorCode& status) : len(ks.size()) {
+    Key* result = copyVectorToArray<Key>(ks, status);
     if (U_FAILURE(status)) {
         return;
     }
-    Key* result = copyVectorToArray<Key>(ks, len);
-    if (result == nullptr) {
-        status = U_MEMORY_ALLOCATION_ERROR;
-        len = 0;
-        return;
-    }
     keys.adoptInstead(result);
 }
 
@@ -95,7 +90,13 @@ SelectorKeys& SelectorKeys::operator=(SelectorKeys other) noexcept {
 }
 
 SelectorKeys::SelectorKeys(const SelectorKeys& other) : len(other.len) {
-    keys.adoptInstead(copyArray(other.keys.getAlias(), len));
+    UErrorCode localErrorCode = U_ZERO_ERROR;
+    if (len != 0) {
+        keys.adoptInstead(copyArray(other.keys.getAlias(), len, localErrorCode));
+    }
+    if (U_FAILURE(localErrorCode)) {
+        len = 0;
+    }
 }
 
 SelectorKeys::~SelectorKeys() {
@@ -198,9 +199,18 @@ Key::~Key() {}
 // ------------ Reserved
 
 // Copy constructor
-Reserved::Reserved(const Reserved& other) {
-    len = other.len;
-    parts.adoptInstead(copyArray(other.parts.getAlias(), len));
+Reserved::Reserved(const Reserved& other) : len(other.len) {
+    U_ASSERT(!other.bogus);
+
+    UErrorCode localErrorCode = U_ZERO_ERROR;
+    if (len == 0) {
+        parts.adoptInstead(nullptr);
+    } else {
+        parts.adoptInstead(copyArray(other.parts.getAlias(), len, localErrorCode));
+    }
+    if (U_FAILURE(localErrorCode)) {
+        bogus = true;
+    }
 }
 
 Reserved& Reserved::operator=(Reserved other) noexcept {
@@ -212,14 +222,16 @@ Reserved::Reserved(const UVector& ps, UErrorCode& status) noexcept : len(ps.size
     if (U_FAILURE(status)) {
         return;
     }
-    parts = LocalArray<Literal>(copyVectorToArray<Literal>(ps, len));
+    parts = LocalArray<Literal>(copyVectorToArray<Literal>(ps, status));
 }
 
 int32_t Reserved::numParts() const {
+    U_ASSERT(!bogus);
     return len;
 }
 
 const Literal& Reserved::getPart(int32_t i) const {
+    U_ASSERT(!bogus);
     U_ASSERT(i < numParts());
     return parts[i];
 }
@@ -257,14 +269,10 @@ Reserved::~Reserved() {
 
 //------------------------ Operator
 
-OptionMap::OptionMap(const UVector& opts, UErrorCode& status) {
-    CHECK_ERROR(status);
-
-    len = opts.size();
-    Option* result = copyVectorToArray<Option>(opts, len);
-    if (result == nullptr && len != 0) {
+OptionMap::OptionMap(const UVector& opts, UErrorCode& status) : len(opts.size()) {
+    Option* result = copyVectorToArray<Option>(opts, status);
+    if (U_FAILURE(status)) {
         bogus = true;
-        status = U_MEMORY_ALLOCATION_ERROR;
         return;
     }
     options.adoptInstead(result);
@@ -273,8 +281,9 @@ OptionMap::OptionMap(const UVector& opts, UErrorCode& status) {
 
 OptionMap::OptionMap(const OptionMap& other) : len(other.len) {
     U_ASSERT(!other.bogus);
-    Option* result = copyArray(other.options.getAlias(), len);
-    if (result == nullptr && len != 0) {
+    UErrorCode localErrorCode = U_ZERO_ERROR;
+    Option* result = copyArray(other.options.getAlias(), len, localErrorCode);
+    if (U_FAILURE(localErrorCode)) {
         bogus = true;
         return;
     }
@@ -653,16 +662,13 @@ const Reserved* UnsupportedStatement::getBody(UErrorCode& errorCode) const {
 UnsupportedStatement::UnsupportedStatement(const UnicodeString& k,
                                            const std::optional<Reserved>& r,
                                            const UVector& es,
-                                           UErrorCode& status) : keyword(k), body(r) {
+                                           UErrorCode& status)
+    : keyword(k), body(r), expressionsLen(es.size()) {
     CHECK_ERROR(status);
 
-    U_ASSERT(es.size() >= 1);
-    Expression* result = copyVectorToArray<Expression>(es, expressionsLen);
-    if (result == nullptr) {
-        status = U_MEMORY_ALLOCATION_ERROR;
-        expressionsLen = 0;
-        return;
-    }
+    U_ASSERT(expressionsLen >= 1);
+    Expression* result = copyVectorToArray<Expression>(es, status);
+    CHECK_ERROR(status);
     expressions.adoptInstead(result);
 }
 
@@ -671,7 +677,11 @@ UnsupportedStatement::UnsupportedStatement(const UnsupportedStatement& other) {
     body = other.body;
     expressionsLen = other.expressionsLen;
     U_ASSERT(expressionsLen > 0);
-    expressions.adoptInstead(copyArray(other.expressions.getAlias(), expressionsLen));
+    UErrorCode localErrorCode = U_ZERO_ERROR;
+    expressions.adoptInstead(copyArray(other.expressions.getAlias(), expressionsLen, localErrorCode));
+    if (U_FAILURE(localErrorCode)) {
+        expressionsLen = 0;
+    }
 }
 
 UnsupportedStatement& UnsupportedStatement::operator=(UnsupportedStatement other) noexcept {
@@ -722,21 +732,32 @@ Pattern::Pattern(const UVector& ps, UErrorCode& status) : len(ps.size()) {
     if (U_FAILURE(status)) {
         return;
     }
-    PatternPart* result = copyVectorToArray<PatternPart>(ps, len);
-    if (result == nullptr) {
-        status = U_MEMORY_ALLOCATION_ERROR;
-        return;
-    }
+    PatternPart* result = copyVectorToArray<PatternPart>(ps, status);
+    CHECK_ERROR(status);
     parts.adoptInstead(result);
 }
 
 // Copy constructor
-Pattern::Pattern(const Pattern& other) noexcept : len(other.len) {
-    parts.adoptInstead(copyArray(other.parts.getAlias(), len));
+Pattern::Pattern(const Pattern& other) : len(other.len) {
+    U_ASSERT(!other.bogus);
+    UErrorCode localErrorCode = U_ZERO_ERROR;
+    if (len == 0) {
+        parts.adoptInstead(nullptr);
+    } else {
+        parts.adoptInstead(copyArray(other.parts.getAlias(), len, localErrorCode));
+    }
+    if (U_FAILURE(localErrorCode)) {
+        bogus = true;
+    }
+}
+
+int32_t Pattern::numParts() const {
+    U_ASSERT(!bogus);
+    return len;
 }
 
 const PatternPart& Pattern::getPart(int32_t i) const {
-    U_ASSERT(i < numParts());
+    U_ASSERT(!bogus && i < numParts());
     return parts[i];
 }
 
@@ -875,12 +896,26 @@ Matcher& Matcher::operator=(Matcher other) {
 }
 
 Matcher::Matcher(const Matcher& other) {
+    U_ASSERT(!other.bogus);
     numSelectors = other.numSelectors;
     numVariants = other.numVariants;
-    selectors.adoptInstead(copyArray<Expression>(other.selectors.getAlias(), numSelectors));
-    variants.adoptInstead(copyArray<Variant>(other.variants.getAlias(), numVariants));
+    UErrorCode localErrorCode = U_ZERO_ERROR;
+    selectors.adoptInstead(copyArray<Expression>(other.selectors.getAlias(),
+                                                 numSelectors,
+                                                 localErrorCode));
+    variants.adoptInstead(copyArray<Variant>(other.variants.getAlias(),
+                                             numVariants,
+                                             localErrorCode));
+    if (U_FAILURE(localErrorCode)) {
+        bogus = true;
+    }
 }
 
+Matcher::Matcher(Expression* ss, int32_t ns, Variant* vs, int32_t nv)
+    : selectors(ss), numSelectors(ns), variants(vs), numVariants(nv) {}
+
+Matcher::~Matcher() {}
+
 // --------------- MFDataModel
 
 const Pattern& MFDataModel::getPattern() const {
@@ -1014,29 +1049,34 @@ MFDataModel::Builder& MFDataModel::Builder::setPattern(Pattern&& pat) {
 MFDataModel::MFDataModel(const MFDataModel& other) : body(Pattern()) {
     U_ASSERT(!other.bogus);
 
+    UErrorCode localErrorCode = U_ZERO_ERROR;
+
     if (other.hasPattern()) {
-        body.emplace<Pattern>(Pattern(*std::get_if<Pattern>(&other.body)));
+        //        body.emplace<Pattern>(Pattern(*std::get_if<Pattern>(&other.body)));
+        body = *std::get_if<Pattern>(&other.body);
     } else {
         const Expression* otherSelectors = other.getSelectorsInternal();
         const Variant* otherVariants = other.getVariantsInternal();
         int32_t numSelectors = other.numSelectors();
         int32_t numVariants = other.numVariants();
-        Expression* copiedSelectors = copyArray(otherSelectors, numSelectors);
-        Variant* copiedVariants = copyArray(otherVariants, numVariants);
-        if (!(copiedSelectors != nullptr && copiedVariants != nullptr)) {
+        Expression* copiedSelectors = copyArray(otherSelectors, numSelectors, localErrorCode);
+        Variant* copiedVariants = copyArray(otherVariants, numVariants, localErrorCode);
+        if (U_FAILURE(localErrorCode)) {
             bogus = true;
+            return;
         }
-        body.emplace<Matcher>(Matcher(copiedSelectors, numSelectors, copiedVariants, numVariants));
+        //        body.emplace<Matcher>(Matcher(copiedSelectors, numSelectors, copiedVariants, numVariants));
+        body = Matcher(copiedSelectors, numSelectors, copiedVariants, numVariants);
     }
 
     bindingsLen = other.bindingsLen;
-    bindings.adoptInstead(copyArray(other.bindings.getAlias(), bindingsLen));
-    if (!bindings.isValid()) {
+    bindings.adoptInstead(copyArray(other.bindings.getAlias(), bindingsLen, localErrorCode));
+    if (U_FAILURE(localErrorCode)) {
         bogus = true;
     }
     unsupportedStatementsLen = other.unsupportedStatementsLen;
-    unsupportedStatements.adoptInstead(copyArray(other.unsupportedStatements.getAlias(), unsupportedStatementsLen));
-    if (!unsupportedStatements.isValid()) {
+    unsupportedStatements.adoptInstead(copyArray(other.unsupportedStatements.getAlias(), unsupportedStatementsLen, localErrorCode));
+    if (U_FAILURE(localErrorCode)) {
         bogus = true;
     }
 }
@@ -1047,25 +1087,33 @@ MFDataModel::MFDataModel(const MFDataModel::Builder& builder, UErrorCode& errorC
     if (builder.hasPattern) {
         body.emplace<Pattern>(builder.pattern);
     } else {
-        int32_t numVariants = builder.variants == nullptr ? 0 : builder.variants->size();
-        int32_t numSelectors = builder.selectors == nullptr ? 0 : builder.selectors->size();
-        Variant* variants = copyVectorToArray<Variant>(*builder.variants, numVariants);
-        Expression* selectors = copyVectorToArray<Expression>(*builder.selectors, numSelectors);
-        bogus &= (variants != nullptr && selectors != nullptr);
+        U_ASSERT(builder.variants != nullptr);
+        U_ASSERT(builder.selectors != nullptr);
+        int32_t numVariants = builder.variants->size();
+        int32_t numSelectors = builder.selectors->size();
+        Variant* variants = copyVectorToArray<Variant>(*builder.variants, errorCode);
+        Expression* selectors = copyVectorToArray<Expression>(*builder.selectors, errorCode);
+        if (U_FAILURE(errorCode)) {
+            bogus = true;
+            return;
+        }
         body.emplace<Matcher>(Matcher(selectors, numSelectors, variants, numVariants));
     }
 
     U_ASSERT(builder.bindings != nullptr);
     bindingsLen = builder.bindings->size();
-    bindings.adoptInstead(copyVectorToArray<Binding>(*builder.bindings, bindingsLen));
+    bindings.adoptInstead(copyVectorToArray<Binding>(*builder.bindings, errorCode));
     unsupportedStatementsLen = builder.unsupportedStatements->size();
-    unsupportedStatements.adoptInstead(copyVectorToArray<UnsupportedStatement>(*builder.unsupportedStatements, unsupportedStatementsLen));
-    bogus &= ((bool) (bindings.isValid() && unsupportedStatements.isValid()));
+    unsupportedStatements.adoptInstead(copyVectorToArray<UnsupportedStatement>(*builder.unsupportedStatements, errorCode));
+    if (U_FAILURE(errorCode)) {
+        bogus = true;
+    }
 }
 
 MFDataModel::MFDataModel() : body(Pattern()) {}
 
 MFDataModel& MFDataModel::operator=(MFDataModel other) noexcept {
+    U_ASSERT(!other.bogus);
     swap(*this, other);
     return *this;
 }
diff --git a/icu4c/source/i18n/messageformat2_evaluation.cpp b/icu4c/source/i18n/messageformat2_evaluation.cpp
index 421add364e0..41e4c9a8020 100644
--- a/icu4c/source/i18n/messageformat2_evaluation.cpp
+++ b/icu4c/source/i18n/messageformat2_evaluation.cpp
@@ -40,10 +40,8 @@ const ResolvedFunctionOption* FunctionOptions::getResolvedFunctionOptions(int32_
 FunctionOptions::FunctionOptions(UVector&& optionsVector, UErrorCode& status) {
     CHECK_ERROR(status);
 
-    options = moveVectorToArray<ResolvedFunctionOption>(optionsVector, functionOptionsLen);
-    if (options == nullptr) {
-        status = U_MEMORY_ALLOCATION_ERROR;
-    }
+    functionOptionsLen = optionsVector.size();
+    options = moveVectorToArray<ResolvedFunctionOption>(optionsVector, status);
 }
 
 UBool FunctionOptions::getFunctionOption(const UnicodeString& key, Formattable& option) const {
diff --git a/icu4c/source/i18n/unicode/messageformat2_data_model.h b/icu4c/source/i18n/unicode/messageformat2_data_model.h
index e8436ca6cd6..6232b4ee307 100644
--- a/icu4c/source/i18n/unicode/messageformat2_data_model.h
+++ b/icu4c/source/i18n/unicode/messageformat2_data_model.h
@@ -167,6 +167,7 @@ namespace message2 {
             friend inline void swap(Reserved& r1, Reserved& r2) noexcept {
                 using std::swap;
 
+                swap(r1.bogus, r2.bogus);
                 swap(r1.parts, r2.parts);
                 swap(r1.len, r2.len);
             }
@@ -203,11 +204,16 @@ namespace message2 {
             friend class Builder;
             friend class Operator;
 
+            // True if a copy failed; this has to be distinguished
+            // from a valid `Reserved` with empty parts
+            bool bogus = false;
+
             // Possibly-empty list of parts
             // `literal` reserved as a quoted literal; `reserved-char` / `reserved-escape`
             // strings represented as unquoted literals
             /* const */ LocalArray<Literal> parts;
             int32_t len = 0;
+
             Reserved(const UVector& parts, UErrorCode& status) noexcept;
             // Helper
             static void initLiterals(Reserved&, const Reserved&);
@@ -2255,6 +2261,7 @@ namespace message2 {
             friend inline void swap(Pattern& p1, Pattern& p2) noexcept {
                 using std::swap;
 
+                swap(p1.bogus, p2.bogus);
                 swap(p1.len, p2.len);
                 swap(p1.parts, p2.parts);
             }
@@ -2264,7 +2271,7 @@ namespace message2 {
              * @internal ICU 75.0 technology preview
              * @deprecated This API is for technology preview only.
              */
-            Pattern(const Pattern& other) noexcept;
+            Pattern(const Pattern& other);
             /**
              * Assignment operator
              *
@@ -2336,6 +2343,11 @@ namespace message2 {
             friend class message2::MessageFormatter;
             friend class message2::Serializer;
 
+            // Set to true if a copy constructor fails;
+            // needed in order to distinguish an uninitialized
+            // Pattern from a 0-length pattern
+            bool bogus = false;
+
             // Possibly-empty array of parts
             int32_t len = 0;
             LocalArray<PatternPart> parts;
@@ -2352,7 +2364,7 @@ namespace message2 {
              * @internal ICU 75.0 technology preview
              * @deprecated This API is for technology preview only.
              */
-            int32_t numParts() const { return len; }
+            int32_t numParts() const;
             /**
              * Returns the `i`th part in the pattern.
              * Precondition: i < numParts()
@@ -2367,10 +2379,8 @@ namespace message2 {
 
             // Gets around not being able to declare Pattern::Iterator as a friend
             // in PatternPart
-            static const std::variant<UnicodeString, Expression, Markup>& patternContents(const PatternPart& p) {
-                return p.piece;
-            }
-
+            static const std::variant<UnicodeString, Expression, Markup>&
+                patternContents(const PatternPart& p) { return p.piece; }
         }; // class Pattern
 
         /**
@@ -2622,7 +2632,7 @@ namespace message2 {
     class MFDataModel;
 
     #ifndef U_IN_DOXYGEN
-    class Matcher {
+    class Matcher : public UObject {
     public:
         Matcher& operator=(Matcher);
         Matcher(const Matcher&);
@@ -2637,24 +2647,32 @@ namespace message2 {
         friend inline void swap(Matcher& m1, Matcher& m2) noexcept {
             using std::swap;
 
+            if (m1.bogus) {
+                m2.bogus = true;
+                return;
+            }
+            if (m2.bogus) {
+                m1.bogus = true;
+                return;
+            }
             swap(m1.selectors, m2.selectors);
             swap(m1.numSelectors, m2.numSelectors);
             swap(m1.variants, m2.variants);
             swap(m1.numVariants, m2.numVariants);
         }
+        virtual ~Matcher();
     private:
 
         friend class MFDataModel;
 
-        Matcher(Expression* ss, int32_t ns, Variant* vs, int32_t nv) : selectors(ss), numSelectors(ns), variants(vs), numVariants(nv) {
-            if (selectors == nullptr) {
-                numSelectors = 0;
-            }
-            if (variants == nullptr) {
-                numVariants = 0;
-            }
-        }
+        Matcher(Expression* ss, int32_t ns, Variant* vs, int32_t nv);
         Matcher() {}
+
+        // A Matcher may have numSelectors=0 and numVariants=0
+        // (this is a data model error, but it's representable).
+        // So we have to keep a separate flag to track failed copies.
+        bool bogus = false;
+
         // The expressions that are being matched on.
         LocalArray<Expression> selectors;
         // The number of selectors