[Breaking change]: Disallow creating a type of array of System.Void #38311

Closed
#39198
Closed
[Breaking change]: Disallow creating a type of array of System.Void#38311
#39198
Assignees
gewarren
Labels
🏁 Release: .NET 9Work items for the .NET 9 release📌 seQUESTeredIdentifies that an issue has been imported into Quest.breaking-changeIndicates a .NET Core breaking change

Description

@jkotas
jkotas
opened on Nov 18, 2023

Description

Creating System.Type instance for array of System.Void is no longer allowed.

Version

.NET 9 Preview 1

Previous behavior

typeof(void).MakeArrayType() returned System.Type instance.

New behavior

typeof(void).MakeArrayType() throws an exception.

Type of breaking change

  • Binary incompatible: Existing binaries may encounter a breaking change in behavior, such as failure to load or execute, and if so, require recompilation.
  • Source incompatible: When recompiled using the new SDK or component or to target the new runtime, existing source code may require source changes to compile successfully.
  • Behavioral change: Existing binaries may behave differently at run time.

Reason for change

Array of System.Void is an invalid type. This type is rejected in number of situations (e.g. void[] in C# does not compile) and it is not possible to create arrays of this type.

.NET runtimes allowed this invalid type to be created in some situations. However, attempts to use this invalid type lead in other .NET runtime APIs often lead to unexpected behaviors. It is better to disallow creating these invalid array types in all situations to make the behavior robust and consistent.

Recommended action

Remove code that tries to create a type for array of System.Void.

Feature area

Core .NET libraries

Affected APIs

System.Type.MakeArrayType

Associated WorkItem - 196554

Metadata

Metadata

Assignees

Labels

🏁 Release: .NET 9Work items for the .NET 9 release📌 seQUESTeredIdentifies that an issue has been imported into Quest.breaking-changeIndicates a .NET Core breaking change

Type

No type

Projects

    Milestone

    No milestone

    Relationships

    None yet

    Development

    No branches or pull requests

    Issue actions

    , 'i'); if (__m === '*' || __re.test(location.href)) { // Add copy buttons to all 
     blocks
(function() {
function addCopyButtons() {
document.querySelectorAll('pre code').forEach(function(codeBlock) {
if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;
codeBlock.parentElement.setAttribute('data-copy-added', 'true');
var btn = document.createElement('button');
btn.textContent = 'Copy';
btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';
btn.onmouseover = function() { this.style.opacity = '1'; };
btn.onmouseout = function() { this.style.opacity = '0.7'; };
btn.onclick = function() {
navigator.clipboard.writeText(codeBlock.textContent).then(function() {
btn.textContent = 'Copied!';
setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
});
};
codeBlock.parentElement.style.position = 'relative';
codeBlock.parentElement.appendChild(btn);
});
}
addCopyButtons();
// Re-run on dynamic content
var observer = new MutationObserver(addCopyButtons);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '

    Skip to content
    [Breaking change]: Disallow creating a type of array of System.Void #38311
    Closed
    #39198
    Closed
    [Breaking change]: Disallow creating a type of array of System.Void#38311
    #39198
    Assignees
    gewarren
    Labels
    🏁 Release: .NET 9Work items for the .NET 9 release📌 seQUESTeredIdentifies that an issue has been imported into Quest.breaking-changeIndicates a .NET Core breaking change
    Description
    @jkotas
    jkotas
    opened on Nov 18, 2023
    Description
    Creating System.Type instance for array of System.Void is no longer allowed.
    Version
    .NET 9 Preview 1
    Previous behavior
    typeof(void).MakeArrayType() returned System.Type instance.
    New behavior
    typeof(void).MakeArrayType() throws an exception.
    Type of breaking change
    • Binary incompatible: Existing binaries may encounter a breaking change in behavior, such as failure to load or execute, and if so, require recompilation.
    • Source incompatible: When recompiled using the new SDK or component or to target the new runtime, existing source code may require source changes to compile successfully.
    • Behavioral change: Existing binaries may behave differently at run time.
    Reason for change
    Array of System.Void is an invalid type. This type is rejected in number of situations (e.g. void[] in C# does not compile) and it is not possible to create arrays of this type.
    .NET runtimes allowed this invalid type to be created in some situations. However, attempts to use this invalid type lead in other .NET runtime APIs often lead to unexpected behaviors. It is better to disallow creating these invalid array types in all situations to make the behavior robust and consistent.
    Recommended action
    Remove code that tries to create a type for array of System.Void.
    Feature area
    Core .NET libraries
    Affected APIs
    System.Type.MakeArrayType
    Associated WorkItem - 196554
    Metadata
    Metadata
    Assignees
    Labels
    🏁 Release: .NET 9Work items for the .NET 9 release📌 seQUESTeredIdentifies that an issue has been imported into Quest.breaking-changeIndicates a .NET Core breaking change
    Type
    No type
    Projects
      Milestone
      No milestone
      Relationships
      None yet
      Development
      No branches or pull requests
      Issue actions
      
, 'i');
if (__m === '*' || __re.test(location.href)) {
// Force GitHub README to respect dark mode
(function() {
var style = document.createElement('style');
style.textContent = '
.markdown-body {
color-scheme: dark light;
}
.markdown-body pre { background: #161b22 !important; }
.markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }
.markdown-body table th, .markdown-body table td { border-color: #30363d !important; }
.markdown-body img { background: #0d1117; }
.markdown-body blockquote { border-left-color: #8b949e; }
.markdown-body hr { border-color: #30363d; }
';
document.head.appendChild(style);
})();
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

      Skip to content
      [Breaking change]: Disallow creating a type of array of System.Void #38311
      Closed
      #39198
      Closed
      [Breaking change]: Disallow creating a type of array of System.Void#38311
      #39198
      Assignees
      gewarren
      Labels
      🏁 Release: .NET 9Work items for the .NET 9 release📌 seQUESTeredIdentifies that an issue has been imported into Quest.breaking-changeIndicates a .NET Core breaking change
      Description
      @jkotas
      jkotas
      opened on Nov 18, 2023
      Description
      Creating System.Type instance for array of System.Void is no longer allowed.
      Version
      .NET 9 Preview 1
      Previous behavior
      typeof(void).MakeArrayType() returned System.Type instance.
      New behavior
      typeof(void).MakeArrayType() throws an exception.
      Type of breaking change
      • Binary incompatible: Existing binaries may encounter a breaking change in behavior, such as failure to load or execute, and if so, require recompilation.
      • Source incompatible: When recompiled using the new SDK or component or to target the new runtime, existing source code may require source changes to compile successfully.
      • Behavioral change: Existing binaries may behave differently at run time.
      Reason for change
      Array of System.Void is an invalid type. This type is rejected in number of situations (e.g. void[] in C# does not compile) and it is not possible to create arrays of this type.
      .NET runtimes allowed this invalid type to be created in some situations. However, attempts to use this invalid type lead in other .NET runtime APIs often lead to unexpected behaviors. It is better to disallow creating these invalid array types in all situations to make the behavior robust and consistent.
      Recommended action
      Remove code that tries to create a type for array of System.Void.
      Feature area
      Core .NET libraries
      Affected APIs
      System.Type.MakeArrayType
      Associated WorkItem - 196554
      Metadata
      Metadata
      Assignees
      Labels
      🏁 Release: .NET 9Work items for the .NET 9 release📌 seQUESTeredIdentifies that an issue has been imported into Quest.breaking-changeIndicates a .NET Core breaking change
      Type
      No type
      Projects
        Milestone
        No milestone
        Relationships
        None yet
        Development
        No branches or pull requests
        Issue actions
        
, 'i');
if (__m === '*' || __re.test(location.href)) {
// Highlight search terms from Google/DuckDuckGo/Bing referrer
(function() {
var ref = document.referrer;
var terms = [];
if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {
var url = new URL(ref);
var q = url.searchParams.get('q') || url.searchParams.get('p');
if (q) {
terms = q.split(/\s+/).filter(function(t) { return t.length > 2; });
}
}
if (terms.length === 0) return;
var style = document.createElement('style');
style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';
document.head.appendChild(style);
function highlight(node) {
if (node.nodeType === 3) { // text node
var text = node.textContent;
var found = false;
terms.forEach(function(term) {
var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\]\\]/g, '\\') + ')', 'gi');
if (regex.test(text)) {
found = true;
var frag = document.createDocumentFragment();
var parts = text.split(regex);
parts.forEach(function(part, i) {
if (i % 2 === 0) {
frag.appendChild(document.createTextNode(part));
} else {
var span = document.createElement('span');
span.className = 'userscript-highlight';
span.textContent = part;
frag.appendChild(span);
}
});
node.parentNode.replaceChild(frag, node);
}
});
} else if (node.nodeType === 1 && node.childNodes) { // element
var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];
if (!skipTags.includes(node.tagName)) {
Array.from(node.childNodes).forEach(highlight);
}
}
}
highlight(document.body);
// Re-highlight on dynamic content
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1 || node.nodeType === 3) highlight(node);
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

        Skip to content
        [Breaking change]: Disallow creating a type of array of System.Void #38311
        Closed
        #39198
        Closed
        [Breaking change]: Disallow creating a type of array of System.Void#38311
        #39198
        Assignees
        gewarren
        Labels
        🏁 Release: .NET 9Work items for the .NET 9 release📌 seQUESTeredIdentifies that an issue has been imported into Quest.breaking-changeIndicates a .NET Core breaking change
        Description
        @jkotas
        jkotas
        opened on Nov 18, 2023
        Description
        Creating System.Type instance for array of System.Void is no longer allowed.
        Version
        .NET 9 Preview 1
        Previous behavior
        typeof(void).MakeArrayType() returned System.Type instance.
        New behavior
        typeof(void).MakeArrayType() throws an exception.
        Type of breaking change
        • Binary incompatible: Existing binaries may encounter a breaking change in behavior, such as failure to load or execute, and if so, require recompilation.
        • Source incompatible: When recompiled using the new SDK or component or to target the new runtime, existing source code may require source changes to compile successfully.
        • Behavioral change: Existing binaries may behave differently at run time.
        Reason for change
        Array of System.Void is an invalid type. This type is rejected in number of situations (e.g. void[] in C# does not compile) and it is not possible to create arrays of this type.
        .NET runtimes allowed this invalid type to be created in some situations. However, attempts to use this invalid type lead in other .NET runtime APIs often lead to unexpected behaviors. It is better to disallow creating these invalid array types in all situations to make the behavior robust and consistent.
        Recommended action
        Remove code that tries to create a type for array of System.Void.
        Feature area
        Core .NET libraries
        Affected APIs
        System.Type.MakeArrayType
        Associated WorkItem - 196554
        Metadata
        Metadata
        Assignees
        Labels
        🏁 Release: .NET 9Work items for the .NET 9 release📌 seQUESTeredIdentifies that an issue has been imported into Quest.breaking-changeIndicates a .NET Core breaking change
        Type
        No type
        Projects
          Milestone
          No milestone
          Relationships
          None yet
          Development
          No branches or pull requests
          Issue actions
          
, 'i');
if (__m === '*' || __re.test(location.href)) {
// Strip utm_, fbclid, gclid, etc. from all links on page
(function() {
var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',
'ref', 'ref_src', 'source', 'medium', 'campaign'];
function cleanUrl(url) {
try {
var u = new URL(url, window.location.origin);
var changed = false;
trackingParams.forEach(function(p) {
if (u.searchParams.has(p)) {
u.searchParams.delete(p);
changed = true;
}
});
return changed ? u.toString() : url;
} catch (e) {
return url;
}
}
function cleanLinks() {
document.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
cleanLinks();
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1) {
if (node.tagName === 'A') cleanLinks();
node.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '

          Skip to content
          [Breaking change]: Disallow creating a type of array of System.Void #38311
          Closed
          #39198
          Closed
          [Breaking change]: Disallow creating a type of array of System.Void#38311
          #39198
          Assignees
          gewarren
          Labels
          🏁 Release: .NET 9Work items for the .NET 9 release📌 seQUESTeredIdentifies that an issue has been imported into Quest.breaking-changeIndicates a .NET Core breaking change
          Description
          @jkotas
          jkotas
          opened on Nov 18, 2023
          Description
          Creating System.Type instance for array of System.Void is no longer allowed.
          Version
          .NET 9 Preview 1
          Previous behavior
          typeof(void).MakeArrayType() returned System.Type instance.
          New behavior
          typeof(void).MakeArrayType() throws an exception.
          Type of breaking change
          • Binary incompatible: Existing binaries may encounter a breaking change in behavior, such as failure to load or execute, and if so, require recompilation.
          • Source incompatible: When recompiled using the new SDK or component or to target the new runtime, existing source code may require source changes to compile successfully.
          • Behavioral change: Existing binaries may behave differently at run time.
          Reason for change
          Array of System.Void is an invalid type. This type is rejected in number of situations (e.g. void[] in C# does not compile) and it is not possible to create arrays of this type.
          .NET runtimes allowed this invalid type to be created in some situations. However, attempts to use this invalid type lead in other .NET runtime APIs often lead to unexpected behaviors. It is better to disallow creating these invalid array types in all situations to make the behavior robust and consistent.
          Recommended action
          Remove code that tries to create a type for array of System.Void.
          Feature area
          Core .NET libraries
          Affected APIs
          System.Type.MakeArrayType
          Associated WorkItem - 196554
          Metadata
          Metadata
          Assignees
          Labels
          🏁 Release: .NET 9Work items for the .NET 9 release📌 seQUESTeredIdentifies that an issue has been imported into Quest.breaking-changeIndicates a .NET Core breaking change
          Type
          No type
          Projects
            Milestone
            No milestone
            Relationships
            None yet
            Development
            No branches or pull requests
            Issue actions
            
, 'i');
if (__m === '*' || __re.test(location.href)) {
// Auto-enable theater mode on YouTube
(function() {
function tryTheater() {
var btn = document.querySelector('button[aria-label="Theater mode"], ytd-player #player button[title="Theater mode"]');
if (btn && !btn.classList.contains('activated')) {
btn.click();
}
}
// Try immediately
tryTheater();
// Try after navigation (SPA)
var lastUrl = location.href;
setInterval(function() {
if (location.href !== lastUrl) {
lastUrl = location.href;
setTimeout(tryTheater, 500);
}
}, 1000);
// Also try on player load
var observer = new MutationObserver(tryTheater);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

            Skip to content
            [Breaking change]: Disallow creating a type of array of System.Void #38311
            Closed
            #39198
            Closed
            [Breaking change]: Disallow creating a type of array of System.Void#38311
            #39198
            Assignees
            gewarren
            Labels
            🏁 Release: .NET 9Work items for the .NET 9 release📌 seQUESTeredIdentifies that an issue has been imported into Quest.breaking-changeIndicates a .NET Core breaking change
            Description
            @jkotas
            jkotas
            opened on Nov 18, 2023
            Description
            Creating System.Type instance for array of System.Void is no longer allowed.
            Version
            .NET 9 Preview 1
            Previous behavior
            typeof(void).MakeArrayType() returned System.Type instance.
            New behavior
            typeof(void).MakeArrayType() throws an exception.
            Type of breaking change
            • Binary incompatible: Existing binaries may encounter a breaking change in behavior, such as failure to load or execute, and if so, require recompilation.
            • Source incompatible: When recompiled using the new SDK or component or to target the new runtime, existing source code may require source changes to compile successfully.
            • Behavioral change: Existing binaries may behave differently at run time.
            Reason for change
            Array of System.Void is an invalid type. This type is rejected in number of situations (e.g. void[] in C# does not compile) and it is not possible to create arrays of this type.
            .NET runtimes allowed this invalid type to be created in some situations. However, attempts to use this invalid type lead in other .NET runtime APIs often lead to unexpected behaviors. It is better to disallow creating these invalid array types in all situations to make the behavior robust and consistent.
            Recommended action
            Remove code that tries to create a type for array of System.Void.
            Feature area
            Core .NET libraries
            Affected APIs
            System.Type.MakeArrayType
            Associated WorkItem - 196554
            Metadata
            Metadata
            Assignees
            Labels
            🏁 Release: .NET 9Work items for the .NET 9 release📌 seQUESTeredIdentifies that an issue has been imported into Quest.breaking-changeIndicates a .NET Core breaking change
            Type
            No type
            Projects
              Milestone
              No milestone
              Relationships
              None yet
              Development
              No branches or pull requests
              Issue actions
              
, 'i');
if (__m === '*' || __re.test(location.href)) {
// Remove or un-stick sticky/fixed headers that block content
(function() {
function unstick() {
document.querySelectorAll('header, nav, [role="banner"], .header, .navbar, .sticky, .fixed-top, [style*="position: fixed"], [style*="position:sticky"]').forEach(function(el) {
if (el.style.position === 'fixed' || el.style.position === 'sticky' || getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {
el.style.position = 'static';
el.style.top = 'auto';
el.style.zIndex = 'auto';
}
});
}
unstick();
var observer = new MutationObserver(unstick);
observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });
})();
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

              Skip to content
              [Breaking change]: Disallow creating a type of array of System.Void #38311
              Closed
              #39198
              Closed
              [Breaking change]: Disallow creating a type of array of System.Void#38311
              #39198
              Assignees
              gewarren
              Labels
              🏁 Release: .NET 9Work items for the .NET 9 release📌 seQUESTeredIdentifies that an issue has been imported into Quest.breaking-changeIndicates a .NET Core breaking change
              Description
              @jkotas
              jkotas
              opened on Nov 18, 2023
              Description
              Creating System.Type instance for array of System.Void is no longer allowed.
              Version
              .NET 9 Preview 1
              Previous behavior
              typeof(void).MakeArrayType() returned System.Type instance.
              New behavior
              typeof(void).MakeArrayType() throws an exception.
              Type of breaking change
              • Binary incompatible: Existing binaries may encounter a breaking change in behavior, such as failure to load or execute, and if so, require recompilation.
              • Source incompatible: When recompiled using the new SDK or component or to target the new runtime, existing source code may require source changes to compile successfully.
              • Behavioral change: Existing binaries may behave differently at run time.
              Reason for change
              Array of System.Void is an invalid type. This type is rejected in number of situations (e.g. void[] in C# does not compile) and it is not possible to create arrays of this type.
              .NET runtimes allowed this invalid type to be created in some situations. However, attempts to use this invalid type lead in other .NET runtime APIs often lead to unexpected behaviors. It is better to disallow creating these invalid array types in all situations to make the behavior robust and consistent.
              Recommended action
              Remove code that tries to create a type for array of System.Void.
              Feature area
              Core .NET libraries
              Affected APIs
              System.Type.MakeArrayType
              Associated WorkItem - 196554
              Metadata
              Metadata
              Assignees
              Labels
              🏁 Release: .NET 9Work items for the .NET 9 release📌 seQUESTeredIdentifies that an issue has been imported into Quest.breaking-changeIndicates a .NET Core breaking change
              Type
              No type
              Projects
                Milestone
                No milestone
                Relationships
                None yet
                Development
                No branches or pull requests
                Issue actions
                
, 'i');
if (__m === '*' || __re.test(location.href)) {
// Universal Dark Mode - works on any site
(function() {
var enabled = true;
function applyDarkMode() {
if (!enabled) return;
// Create style element if it doesn't exist
var style = document.getElementById('universal-dark-mode-style');
if (!style) {
style = document.createElement('style');
style.id = 'universal-dark-mode-style';
document.head.appendChild(style);
}
// Dark mode CSS - inverts colors but preserves images/video
style.textContent = '
/* Invert everything except media */
html {
filter: invert(1) hue-rotate(180deg) !important;
background: #1a1a2e !important;
}
/* Restore images, videos, iframes, canvas */
img, video, iframe, canvas, svg, picture, [style*="background-image"] {
filter: invert(1) hue-rotate(180deg) !important;
}
/* Preserve specific elements that should not be inverted */
.no-dark-mode, .no-dark-mode *,
[data-theme="light"], [data-theme="light"],
.ace_editor, .ace_editor *,
.CodeMirror, .CodeMirror *,
.monaco-editor, .monaco-editor *,
.markdown-body pre, .markdown-body pre *,
.highlight, .highlight *,
pre code, pre code * {
filter: none !important;
}
/* Fix common UI elements */
.modal, .popup, .dropdown-menu, .tooltip, .popover {
filter: invert(1) hue-rotate(180deg) !important;
background: #2d2d44 !important;
border-color: #444 !important;
}
/* Scrollbars */
::-webkit-scrollbar { background: #1a1a2e !important; }
::-webkit-scrollbar-thumb { background: #444 !important; }
::-webkit-scrollbar-thumb:hover { background: #555 !important; }
/* Selection */
::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
';
}
function removeDarkMode() {
var style = document.getElementById('universal-dark-mode-style');
if (style) style.remove();
}
// Toggle with Alt+Shift+D
document.addEventListener('keydown', function(e) {
if (e.altKey && e.shiftKey && e.key === 'D') {
e.preventDefault();
enabled = !enabled;
if (enabled) {
applyDarkMode();
console.log('[Universal Dark Mode] Enabled');
} else {
removeDarkMode();
console.log('[Universal Dark Mode] Disabled');
}
}
});
// Apply on load
applyDarkMode();
// Re-apply on dynamic content
var observer = new MutationObserver(function(mutations) {
if (enabled && !document.getElementById('universal-dark-mode-style')) {
applyDarkMode();
}
});
observer.observe(document.head, { childList: true });
console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');
})();
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();

                Skip to content
                [Breaking change]: Disallow creating a type of array of System.Void #38311
                Closed
                #39198
                Closed
                [Breaking change]: Disallow creating a type of array of System.Void#38311
                #39198
                Assignees
                gewarren
                Labels
                🏁 Release: .NET 9Work items for the .NET 9 release📌 seQUESTeredIdentifies that an issue has been imported into Quest.breaking-changeIndicates a .NET Core breaking change
                Description
                @jkotas
                jkotas
                opened on Nov 18, 2023
                Description
                Creating System.Type instance for array of System.Void is no longer allowed.
                Version
                .NET 9 Preview 1
                Previous behavior
                typeof(void).MakeArrayType() returned System.Type instance.
                New behavior
                typeof(void).MakeArrayType() throws an exception.
                Type of breaking change
                • Binary incompatible: Existing binaries may encounter a breaking change in behavior, such as failure to load or execute, and if so, require recompilation.
                • Source incompatible: When recompiled using the new SDK or component or to target the new runtime, existing source code may require source changes to compile successfully.
                • Behavioral change: Existing binaries may behave differently at run time.
                Reason for change
                Array of System.Void is an invalid type. This type is rejected in number of situations (e.g. void[] in C# does not compile) and it is not possible to create arrays of this type.
                .NET runtimes allowed this invalid type to be created in some situations. However, attempts to use this invalid type lead in other .NET runtime APIs often lead to unexpected behaviors. It is better to disallow creating these invalid array types in all situations to make the behavior robust and consistent.
                Recommended action
                Remove code that tries to create a type for array of System.Void.
                Feature area
                Core .NET libraries
                Affected APIs
                System.Type.MakeArrayType
                Associated WorkItem - 196554
                Metadata
                Metadata
                Assignees
                Labels
                🏁 Release: .NET 9Work items for the .NET 9 release📌 seQUESTeredIdentifies that an issue has been imported into Quest.breaking-changeIndicates a .NET Core breaking change
                Type
                No type
                Projects
                  Milestone
                  No milestone
                  Relationships
                  None yet
                  Development
                  No branches or pull requests
                  Issue actions