Perform Matrix Multiplication in C#

Beginner

⏱️ 12 min read

📚 Updated: Aug 2026

🎯 3 Code Examples

🚀 Live Preview

Linear algebra

Overview

What You’ll Learn

Standard matrix multiplication builds each result cell as a row × column dot product: C[i, j] = sum(A[i, k] * B[k, j]), only when inner dimensions match. This tutorial covers the rule, triple nested loops, a live preview, worked C# examples, edge cases, and complexity.

Definition

Row · column

Each C[i, j] is a dot product of row i of A with column j of B.

Shape Rule

(m×n)(n×p)

AB exists only when columns of A equal rows of B; result is m×p.

Triple Loop

i, j, k

Outer i/j pick a cell; inner k accumulates products.

Zero Init

Start at 0

Every result cell is a running sum — initialize before adding.

Live Preview

Show 3×3

Run the classic 3×3 sample product in the browser.

Not Hadamard

Not cell×cell

This is true matrix product — not element-wise multiply.

Introduction

Matrix multiplication combines a row from A with a column from B. If A is m × n and B is n × p, then AB is defined and has size m × p, with C[i, j] = sum over k of A[i, k] * B[k, j].

This is not cell-by-cell multiplication (Hadamard product). Order matters: AB is generally not equal to BA.

Why it matters?

It is a classic interview problem that tests 2D indexing, accumulation, and understanding of linear-algebra shape rules.

Key Highlights

Dot Product Cells

Each output entry is one row dotted with one column.

Inner Dimensions

cols(A) must equal rows(B).

Three Loops

i and j pick the cell; k walks the shared dimension.

O(n³) Classic

Square case uses cubic work with the basic algorithm.

In short: if shapes are compatible, zero-init C, then for each i, j accumulate A[i, k] * B[k, j] over k.

Foundation

📝 Problem & Approach

Given compatible matrices A and B, build product C = AB using row–column dot products.

// (m x n) * (n x p) -> (m x p)
// C[i, j] = A[i][0]*B[0][j] + A[i][1]*B[1][j] + ...
// Not the same as A[i, j] * B[i, j]

Inputs & Outputs

Item	Type	Description
`A`, `B`	`int[,]`	Compatible matrices: cols(A) == rows(B).
Return / print	matrix / text	Product matrix of size rows(A) × cols(B).

Minimal workflow

Pseudocode

function multiply(A, B):
    n <- size
    C <- n x n matrix of zeros
    for i from 0 to n - 1:
        for j from 0 to n - 1:
            for k from 0 to n - 1:
                C[i, j] <- C[i, j] + A[i, k] * B[k, j]
    return C

Method comparison

Method	Idea	Notes
Triple nested loops	Accumulate A[i, k]*B[k, j]	Interview default — clear and correct
Element-wise (Hadamard)	A[i, j] * B[i, j]	Different operation — same shape required
Library helper / BLAS	Library product	Production path; show loops in interviews

Cheat Sheet

⚡ Quick Reference

Goal	Pattern
Accumulate cell	`result[i, j] += a[i, k] * b[k, j]`
Triple loop	`for i / for j / for k`
Zero-init	`new int[n][n]`
Shape check	`a.GetLength(1) == b.GetLength(0)` (cols A == rows B)
Result size	`m x p` when A is `m x n`, B is `n x p`
Trace one cell	Top-left 3×3 sample: `19 + 26 + 3*3 = 30`

Compare

📋 Matrix Product vs Hadamard vs Library

Same word “multiply” — very different meanings.

Matrix product

sum A[i, k]*B[k, j]

This page — classic interview style

Hadamard

A[i, j] * B[i, j]

Element-wise — needs same shape

Library

library mul

Fast in apps; show loops in interviews

Interview tip

state shape first

Say (m×n)(n×p)→m×p before coding

Context

When This Problem Shows Up

Reach for true matrix products when rows must combine with columns.

Interview classics
Triple loops plus shape rules are a common warm-up.
After entrywise ops
Natural step up from addition/division in this chain.
Linear transforms
Compose maps, graphics, and simple ML layers.
Teaching accumulation
Practice running sums over a shared index k.
Not for Hadamard
Clarify when the interviewer wants cell-by-cell multiply.

Key benefit: one short problem that locks in indexing, accumulation, and the (m×n)(n×p)→m×p rule.

Interactive

🔮 Live Preview

Uses the same 3×3 matrices as Example 1. Click to display both inputs and the product matrix.

Hands-On

Examples Gallery

Three complete C# programs — classic 3×3 product, easy-to-verify 2×2, and a shape-safe general multiplier. Click View Output to reveal sample console results.

📚 Getting Started

Triple nested loops with a zero-initialized result matrix.

Example 1 — Multiply Two 3×3 Matrices

Classic interview-style implementation with helpers for multiply and display.

using System;

class Program
{
    const int N = 3;

    static int[,] MultiplyMatrices(int[,] a, int[,] b)
    {
        int[,] result = new int[N, N];
        for (int i = 0; i < N; i++)
        {
            for (int j = 0; j < N; j++)
            {
                for (int k = 0; k < N; k++)
                {
                    result[i, j] += a[i, k] * b[k, j];
                }
            }
        }
        return result;
    }

    static void DisplayMatrix(int[,] matrix)
    {
        for (int i = 0; i < N; i++)
        {
            for (int j = 0; j < N; j++)
            {
                Console.Write(matrix[i, j]);
                if (j + 1 < N)
                {
                    Console.Write("\t");
                }
            }
            Console.WriteLine();
        }
    }

    static void Main()
    {
        int[,] firstMatrix = {
            { 1, 2, 3 },
            { 4, 5, 6 },
            { 7, 8, 9 },
        };
        int[,] secondMatrix = {
            { 9, 8, 7 },
            { 6, 5, 4 },
            { 3, 2, 1 },
        };

        int[,] result = MultiplyMatrices(firstMatrix, secondMatrix);

        Console.WriteLine("First Matrix:");
        DisplayMatrix(firstMatrix);
        Console.WriteLine("\nSecond Matrix:");
        DisplayMatrix(secondMatrix);
        Console.WriteLine("\nResult Matrix:");
        DisplayMatrix(result);
    }
}

How It Works

The innermost loop computes one dot product for each result cell: result[i, j] += a[i, k] * b[k, j]. Top-left output is 1*9 + 2*6 + 3*3 = 30.

⚡ Easy Manual Check

Same logic on a smaller matrix so you can verify by hand.

Example 2 — Smaller 2×2 Product

Same triple-loop pattern with values that are easy to dry-run.

using System;

class Program
{
    const int N = 2;

    static int[,] MultiplyMatrices(int[,] a, int[,] b)
    {
        int[,] result = new int[N, N];
        for (int i = 0; i < N; i++)
        {
            for (int j = 0; j < N; j++)
            {
                for (int k = 0; k < N; k++)
                {
                    result[i, j] += a[i, k] * b[k, j];
                }
            }
        }
        return result;
    }

    static void PrintMatrix(string title, int[,] m)
    {
        Console.WriteLine(title);
        for (int i = 0; i < N; i++)
        {
            for (int j = 0; j < N; j++)
            {
                Console.Write(m[i, j] + " ");
            }
            Console.WriteLine();
        }
    }

    static void Main()
    {
        int[,] a = { { 1, 2 }, { 3, 4 } };
        int[,] b = { { 5, 6 }, { 7, 8 } };
        int[,] r = MultiplyMatrices(a, b);

        PrintMatrix("A", a);
        Console.WriteLine();
        PrintMatrix("B", b);
        Console.WriteLine();
        PrintMatrix("AB", r);
    }
}

How It Works

Top-left value is 1*5 + 2*7 = 19; top-right is 1*6 + 2*8 = 22. Matching the printed AB confirms the accumulation logic.

⚙️ General Shape Validation

Drop fixed N and enforce cols(A) == rows(B).

Example 3 — Shape-Safe General Product

Checks inner dimensions, then multiplies any compatible m×n by n×p.

using System;
using System.Text;

class Program
{
    static bool CanMultiply(int[,] a, int[,] b)
    {
        if (a == null || b == null || a.GetLength(0) == 0 || b.GetLength(0) == 0
            || a.GetLength(1) == 0 || b.GetLength(1) == 0)
        {
            return false;
        }
        return a.GetLength(1) == b.GetLength(0);
    }

    static int[,] MultiplySafe(int[,] a, int[,] b)
    {
        if (!CanMultiply(a, b))
        {
            return null;
        }
        int m = a.GetLength(0);
        int n = a.GetLength(1);
        int p = b.GetLength(1);
        int[,] result = new int[m, p];
        for (int i = 0; i < m; i++)
        {
            for (int j = 0; j < p; j++)
            {
                for (int k = 0; k < n; k++)
                {
                    result[i, j] += a[i, k] * b[k, j];
                }
            }
        }
        return result;
    }

    static string MatrixToString(int[,] m)
    {
        if (m == null)
        {
            return "null";
        }
        StringBuilder sb = new StringBuilder();
        sb.Append("[");
        int rows = m.GetLength(0);
        int cols = m.GetLength(1);
        for (int i = 0; i < rows; i++)
        {
            if (i > 0) sb.Append(", ");
            sb.Append("[");
            for (int j = 0; j < cols; j++)
            {
                if (j > 0) sb.Append(", ");
                sb.Append(m[i, j]);
            }
            sb.Append("]");
        }
        sb.Append("]");
        return sb.ToString();
    }

    static void Main()
    {
        int[,] ok = MultiplySafe(
            new int[,] { { 1, 2, 3 }, { 4, 5, 6 } },
            new int[,] { { 7, 8 }, { 9, 10 }, { 11, 12 } }
        );
        int[,] bad = MultiplySafe(
            new int[,] { { 1, 2 }, { 3, 4 } },
            new int[,] { { 5, 6, 7 } }
        );
        Console.WriteLine(MatrixToString(ok));
        Console.WriteLine(MatrixToString(bad));
    }
}

How It Works

First sample is 2×3 times 3×2 → 2×2. Second fails because columns of A (2) do not match rows of B (1).

🧠 How the Algorithm Builds C

Check shapes

Require cols(A) == rows(B); result will be rows(A) × cols(B).

Shape

Zero-init C

Create an m×p matrix of zeros before accumulation.

Init

Triple loop

For each i, j accumulate A[i, k] * B[k, j] over k.

Loops

Product matrix ready

C holds every row–column dot product.

Trace

🔎 Worked Walkthrough — Top Row of 3×3

Trace the first row of C for the Example 1 matrices.

Cell	Dot product	Value
`C[0][0]`	`19 + 26 + 3*3`	`30`
`C[0][1]`	`18 + 25 + 3*2`	`24`
`C[0][2]`	`17 + 24 + 3*1`	`18`

First row of the result is [30, 24, 18] — matching Example 1 output.

Use Cases

Where true matrix multiplication shows up beyond the interview prompt.

1. Interview Warm-Ups

2D indexing plus accumulation over k.

Example: write MultiplyMatrices(A, B).

2. After Entrywise Ops

Step up from addition/division to products.

Example: compare with Hadamard multiply.

3. Linear Transforms

Compose maps in graphics and simple ML.

Example: apply a 2×2 transform to points.

4. Shape Reasoning

Practice (m×n)(n×p)→m×p checks.

Example: reject incompatible pairs.

5. Complexity Talk

State O(n³) for the classic square case.

Example: mention libraries for large n.

6. Precursor to Subtract

Next page returns to entrywise ops.

Example: continue the matrix chain.

Pro Tip: open with “(m×n)(n×p)→m×p, C[i, j] is a row–column dot product” before writing loops.

Advantages

Why the classic triple-loop approach works well in interviews.

1. Clear Formula
One rule: C[i, j] = sum of A[i, k] * B[k, j].
2. Easy to Trace
2×2 dry-runs verify understanding in seconds.
3. Forces Shape Thinking
Inner-dimension checks are a natural follow-up question.
4. Maps to Libraries
Same idea as a library multiply — you just write the loops by hand.

Pro Tip: lead with loops and zero-init; mention library helpers only as a production aside.

Usage Tips

Small habits that keep matrix-multiplication solutions interview-ready.

1. State Shapes First
Say (m×n)(n×p)→m×p before writing code.
2. Zero-Init Every Cell
Accumulation requires starting at zero.
3. Keep k as the Shared Index
Always pair A[i, k] with B[k, j].
4. Build Fresh Row Lists
Avoid [[0]*n]*n shared references.
5. State O(n³) / O(mnp)
Square vs rectangular complexity in one sentence.

Pro Tip: dry-run 1*5 + 2*7 = 19 aloud on the 2×2 sample — if that matches, your indexing is correct.

Common Pitfalls

Mistakes that commonly break matrix-multiplication solutions.

1. Inner Dimensions Mismatch
Multiplying when cols(A) ≠ rows(B).
→ Validate shapes before looping.
2. Doing Element-Wise Multiply
Writing A[i, j] * B[i, j] instead of a dot product.
→ Use three loops and the k index.
3. Forgetting Zero Init
Accumulating into uninitialized cells.
→ Start every C[i, j] at 0.
4. Assuming AB = BA
Order usually changes the result (or validity).
→ Multiply in the requested order only.
5. Shared Row Initialization
[[0]*n]*n shares row lists.
→ Build each row separately.

Edge Cases

Common beginner mistakes — plus a few more.

Shape

Inner dimensions mismatch

Cannot multiply unless columns of A equal rows of B.

Order

AB is not always BA

Changing order usually changes result, and sometimes makes multiplication invalid.

Logic

Forgetting zero init

If result cells do not start at zero, accumulation gives incorrect values.

Ragged

Uneven rows

Validate GetLength(1) of A equals GetLength(0) of B before multiplying.

1×1

Single cell

Still a product: C[0][0] = A[0][0] * B[0][0].

Rect

Non-square pairs

Use m, n, p — not a single N — when shapes differ.

Math

⚖️ Facts Worth Knowing

Handy follow-ups interviewers sometimes ask.

Associative. (AB)C = A(BC) when shapes allow — but not commutative.
Not commutative. AB is generally not equal to BA.
Identity. AI = IA = A for the compatible identity matrix I.
Cost. Classic algorithm is O(n³) for n×n; faster algorithms exist but are advanced.

Drill

🎯 Practice Problems

Try these variations to lock in the pattern.

1. Dry-run 2×2

Reproduce Example 2 by hand
Expect [[19, 22], [43, 50]]

2. Trace C[0][0] on 3×3

Compute 1*9 + 2*6 + 3*3
Confirm 30 matches Example 1

3. Reject bad shapes

2×2 times 3×2 → null or throw
Assert cols(A) == rows(B)

4. Rectangular product

Multiply 2×3 by 3×2
Drop fixed N; use m, n, p

Important

Notes

Rule: C[i, j] = sum(A[i, k] * B[k, j]), with compatible dimensions.
Code pattern: initialize result to zeros, then use three loops.
Complexity: cubic for square matrices with the basic algorithm.
Non-square matrices use rowsA, colsA, and colsB with the check colsA == rowsB.

Quick Takeaway: compatible shapes first, zero-init C, then accumulate A[i, k]*B[k, j] with three nested loops.

Analysis

⏱️ Time and Space Complexity

Setting	Time	Extra space
Two `n × n` matrices, classic triple loop	`O(n^3)`	`O(1)` beyond output
`m × n` by `n × p`	`O(mnp)`	`O(1)` beyond output
Shape validation	`O(m + n)` row checks	`O(1)`

For large matrices, production code usually switches to optimized libraries; interviews still expect the triple-loop explanation.

Wrap Up

🎉 Conclusion

Matrix multiplication builds each result cell as a row–column dot product when inner dimensions match. Zero-init the result, use three nested loops, and distinguish this from element-wise multiplication.

Practice the three examples above, then continue to matrix subtraction for the next entrywise operation.

Compatible shapes first, zero-init C, then C[i, j] += A[i, k] * B[k, j].

View Examples Gallery Continue to Matrix Subtraction

Pro Tips

💡 Best Practices

✅ Do

State (m×n)(n×p)→m×p first
Zero-init the result matrix
Use three nested loops with index k
Dry-run one cell by hand
State O(n³) or O(mnp) complexity

❌ Don’t

Multiply incompatible shapes
Confuse this with Hadamard multiply
Skip zero initialization
Assume AB equals BA
Use shared-row list init

Summary

Key Takeaways

Knowledge Unlocked

Five things to remember about matrix multiplication

Multiply matrices the interview-friendly way.

Core concepts

× 01

Rule

Row · column

Definition

= 02

Shape

(m×n)(n×p)

Constraint

3 03

Loops

i, j, then k

Pattern

0 04

Init

Start at zero

Safety

O 05

Cost

O(n³) / O(mnp)

Analysis

❓ Frequently Asked Questions

When can I multiply matrix A by matrix B?

A must have as many columns as B has rows. If A is m x n and B is n x p, then AB is defined and its size is m x p.

Is matrix multiplication the same as cell-by-cell multiplication?

No. Standard matrix multiplication uses row-column dot products. Cell-by-cell multiplication is a different operation called element-wise or Hadamard multiplication.

Why are there three nested loops?

One loop chooses result row i, another chooses result column j, and the innermost loop accumulates sum over k: A[i, k] * B[k, j].

Why initialize the result with zeros?

Each result cell is a running sum of products. It must start at zero before we add terms. In C#, a new int[,] is already zero-filled.

Can overflow happen in C#?

Yes for int/long products and sums. Use long (or BigInteger) when products may exceed int.MaxValue.

What is the time complexity for n x n matrices?

The classic triple-loop algorithm performs O(n^3) arithmetic operations for square matrices.

Does AB equal BA?

Not in general. Matrix multiplication is not commutative: AB and BA can differ, and one order may even be undefined.

What about libraries?

Libraries can hide the loops. Interviews usually want the triple-loop version first so you show indexing clearly.

Did you Know? 🔊

Matrix multiplication pairs rows of A with columns of B. If A is m x n and B is n x p, then AB exists and has size m x p.

Continue to Matrix Subtraction

Learn entrywise subtraction with matching dimensions — a simpler return to cell-by-cell ops.

Matrix subtraction tutorial →

About the author

Mari Selvan M P 🔗

Developer, cloud engineer, and technical writer

Experience 12 years building web and cloud systems
Focus Full Stack Development, AWS, and Developer Education

I write practical tutorials so students and working developers can learn by doing—from databases and APIs to deployment on AWS.

AWS Certified Developer – Associate (Credly)

8 people found this page helpful

C# Program to Perform Matrix Division C# Program to Perform Matrix Subtraction

Perform Matrix Multiplication in C#

What You’ll Learn

Definition

Shape Rule

Triple Loop

Zero Init

Live Preview

Not Hadamard

Introduction

Why it matters?

Dot Product Cells

Inner Dimensions

Three Loops

O(n³) Classic

📝 Problem & Approach

Inputs & Outputs

Minimal workflow

Method comparison

⚡ Quick Reference

📋 Matrix Product vs Hadamard vs Library

When This Problem Shows Up

Interview classics

After entrywise ops

Linear transforms

Teaching accumulation

Not for Hadamard

🔮 Live Preview

Examples Gallery

📚 Getting Started

Example 1 — Multiply Two 3×3 Matrices

How It Works

⚡ Easy Manual Check

Example 2 — Smaller 2×2 Product

How It Works

⚙️ General Shape Validation

Example 3 — Shape-Safe General Product

How It Works

🧠 How the Algorithm Builds C

Check shapes

Zero-init C

Triple loop

Product matrix ready

🔎 Worked Walkthrough — Top Row of 3×3

Use Cases

1. Interview Warm-Ups

2. After Entrywise Ops

3. Linear Transforms

4. Shape Reasoning

5. Complexity Talk

6. Precursor to Subtract

Advantages

1. Clear Formula

2. Easy to Trace

3. Forces Shape Thinking

4. Maps to Libraries

Usage Tips

1. State Shapes First

2. Zero-Init Every Cell

3. Keep k as the Shared Index

4. Build Fresh Row Lists

5. State O(n³) / O(mnp)

Common Pitfalls

1. Inner Dimensions Mismatch

2. Doing Element-Wise Multiply

3. Forgetting Zero Init

4. Assuming AB = BA

5. Shared Row Initialization

Edge Cases

Inner dimensions mismatch

AB is not always BA

Forgetting zero init

Uneven rows

Single cell

Non-square pairs

⚖️ Facts Worth Knowing

🎯 Practice Problems

1. Dry-run 2×2

2. Trace C[0][0] on 3×3

3. Reject bad shapes

4. Rectangular product