How to programmatically switch tile palettes in Unity2D

Scenario: User has different tile palettes for each season (Summer, Fall, etc.) and switching between the two using popular Unity techniques would be tedious if the number of tiles in the tileset is greater than 5 or 10. How would said user switch between their tile palettes programmatically, instead of using a wasteful solution like prefab tiles?

This problem seems significant enough that Unity docs would cover it. However I found myself digging through years-old forum posts to come up with my solution. Here's what I came up with, and it's not too complicated.

1) Create your tilesets. Import your tilesets as multi-sprite spritesheets, and split them using the Unity sprite editor. Do not bother naming each sprite. Each tileset should be organized the same exact way (bushes/trees/objects should be in the same spot on every season's tilesheet). When you are finished, create a folder "Resources" in your "Assets" folder. Inside of resources, create a folder "Spritesheets", and place your spricesheets in it.

2) Run this renaming script:

 using UnityEngine;
 using UnityEditor;
 using System.Collections;
 
 public class SpriteRenamer : MonoBehaviour
 {
     public Texture2D[] texture2Ds;
     public string newName;
 
     private string path;
     private TextureImporter textureImporter;
 
     void Start ()
     {
         foreach(Texture2D texture2D in texture2Ds){
             path = AssetDatabase.GetAssetPath (texture2D);
             textureImporter = AssetImporter.GetAtPath (path) as TextureImporter;
             SpriteMetaData[] sliceMetaData = textureImporter.spritesheet;
 
             int index = 0;
             foreach (SpriteMetaData individualSliceData in sliceMetaData)
             {
                 sliceMetaData[index].name = string.Format (newName + "_{0}", index);
                 print (sliceMetaData[index].name);
 
                 index++;
             }
 
             textureImporter.spritesheet = sliceMetaData;
             EditorUtility.SetDirty (textureImporter);
             textureImporter.SaveAndReimport ();
 
             AssetDatabase.ImportAsset (path, ImportAssetOptions.ForceUpdate);
         }
     }
 }

Attach it to an empty GameObject in an empty Scene (just for simplicity). Drag and drop your spritesheets into the Texture2D array. Set the newName field to whatever you want, it will be the prefix for the name of each sprite in each spritesheet. Finally, run the scene and each spritesheet's sprites will be renamed to make each corresponding sprite have the same name.

3) We now have each of our seasons' tilesheets modified so each tile is identically named. The next step is to create a Grid object with a child TilePalette. Draw all of your scenery, collision, etc. You can use as many TilePalettes as needed, as long as they are children of the Grid object. Now, create a script called ReskinnableTileBase:

 using System.Collections;
 using System.Collections.Generic;
 using UnityEngine;
 using UnityEngine.Tilemaps;
 
 public class ReskinnableTileBase : TileBase
 {
     public Sprite sprite;
 
     public override void GetTileData(Vector3Int position, ITilemap tilemap, ref TileData tileData)
     {
         tileData.sprite = sprite;
     }
 }

4) Attach this Reskinner script to your Grid object:

 using System;
 using System.Linq;
 using UnityEngine;
 using UnityEngine.Tilemaps;
 
 public class Reskinner : MonoBehaviour
 {
 
     Sprite[] subSprites;
     Tilemap[] tilemaps;
 
     void Start(){
         tilemaps = GetComponentsInChildren<Tilemap>();
         SetSkin("#INSERT DEFAULT TILE PALETTE NAME HERE#");
     }
 
     public void SetSkin(string name){
         reloadSprites(name);
         foreach(Tilemap tilemap in tilemaps){
             for(int x = (int)tilemap.localBounds.min.x; x < tilemap.localBounds.max.x; x++){
                 for(int y = (int)tilemap.localBounds.min.y; y < tilemap.localBounds.max.y; y++){
                     TileBase tb = tilemap.GetTile(new Vector3Int(x, y, 0));
                     Debug.Log(tb);
 
                     ReskinnableTileBase rtb = (ReskinnableTileBase)ScriptableObject.CreateInstance(typeof(ReskinnableTileBase));
 
                     if(tb == null || rtb == null || tb.name.Length < 1){
                         continue;
                     }
 
                     Sprite replace = getSubSpriteByName(tb.name);
                     rtb.sprite = replace;
                     rtb.name = tb.name;
 
                     tilemap.SwapTile(tb, (TileBase)rtb);
                 }
             }
         }
     }
 
     void reloadSprites(string name){
         subSprites = Resources.LoadAll<Sprite>("Spritesheets/" + name);
     }
 
     Sprite getSubSpriteByName(string name){
         foreach(Sprite s in subSprites){
             if(s.name == name){
                 return s;
             }
         }
         return null;
     }
 }

5) And there you go! Now, any time you need to change the skin/season/tilesheet, just use a reference to the Grid's Reskinner script, and call the SetSkin method, like so:

 Reskinner reskinner = gridObject.GetComponent();
 reskinner.SetSkin("summer");