Prototype Pattern

Overview

Instead of filling in a report preset from scratch, copy one that is already configured and change a few values. That configured original is the prototype.

The Prototype pattern gives an object an operation that copies it. Callers obtain new objects without repeating their internal construction details.

UML

The caller uses IPreset.Copy(). Preset owns the copy policy and allocates a separate mutable Tags list.

History

GoF cataloged Prototype as a creational pattern in Design Patterns in 1994. A prototype specifies the kind of object to create, and copying it produces the new instance.¹

Why use it?

Choosing a prototype selects a starting configuration. Keeping the copy policy with the object prevents callers from copying its internal fields themselves.

A new outer object can still share mutable children. Decide which state must be independent and how to handle resources such as file handles that cannot simply be duplicated.

Example

Copy the prototype and change only the new preset name.

using System;
using System.Collections.Generic;
using System.Linq;

var original = new Preset("base", new[] { "draft" });
var copy = (Preset)original.Copy();
copy.Name = "custom";
Console.WriteLine(original.Name + " / " + copy.Name);

interface IPreset { IPreset Copy(); }
sealed class Preset(string name, IEnumerable<string> tags) : IPreset
{
    public string Name { get; set; } = name;
    public List<string> Tags { get; } = new(tags);
    public IPreset Copy() => new Preset(Name, Tags);
}

base / custom

The prototype name stays unchanged because Copy() returns a new Preset.

An extended example

Add a tag to the copy. Copy() allocates a new list, so the prototype list remains unchanged.

using System;
using System.Collections.Generic;
using System.Linq;

var original = new Preset("base", new[] { "draft" });
var copy = (Preset)original.Copy();
copy.Tags.Add("reviewed");
Console.WriteLine(string.Join(",", original.Tags));
Console.WriteLine(string.Join(",", copy.Tags));

interface IPreset { IPreset Copy(); }
sealed class Preset(string name, IEnumerable<string> tags) : IPreset
{
    public string Name { get; set; } = name;
    public List<string> Tags { get; } = new(tags);
    public IPreset Copy() => new Preset(Name, Tags);
}

draft
draft,reviewed

The example copies the list and shares immutable string values. Mutable objects nested inside that list would need their own copying policy if they must be independent. Prototype does not require indiscriminate deep copying.

Related reading

• Programming patterns

• Builder Pattern

• Abstract Factory Pattern

Each example is a separate .NET 10 console program.