{"id":255,"date":"2024-11-13T12:00:00","date_gmt":"2024-11-13T12:00:00","guid":{"rendered":"https:\/\/unity3dperformance.com\/?p=255"},"modified":"2024-10-28T17:36:14","modified_gmt":"2024-10-28T17:36:14","slug":"class-vs-struct-performance-unity-tile-search","status":"publish","type":"post","link":"https:\/\/unity3dperformance.com\/index.php\/2024\/11\/13\/class-vs-struct-performance-unity-tile-search\/","title":{"rendered":"Comparing Class, Dictionary, and Struct Performance in Tile Searching in Unity"},"content":{"rendered":"\n

Introduction<\/h2>\n\n\n\n

In game development, optimizing code is essential for ensuring smooth gameplay. This is particularly true in Unity, where memory management and execution speed are crucial. The methods used to search and filter large datasets can significantly impact application performance. This article compares three approaches for searching for elements in lists: using classes, dictionaries, and structs. We will investigate how these techniques perform in scenarios that require fast filtering of large collections of data.<\/p>\n\n\n\n

Sample Class: TileData<\/h2>\n\n\n\n

Let\u2019s begin with the TileData<\/code> class, which represents tile objects. Each tile has a position, type, and amount, forming the basic structure of our data:<\/p>\n\n\n\n

<\/span><\/span>
public<\/span> <\/span>class<\/span> <\/span>TileData<\/span><\/span>\n{<\/span><\/span>\n    <\/span>public<\/span> <\/span>int<\/span> <\/span>PositionX<\/span> { <\/span>get<\/span>; <\/span>private<\/span> <\/span>set<\/span>; }<\/span><\/span>\n    <\/span>public<\/span> <\/span>int<\/span> <\/span>PositionY<\/span> { <\/span>get<\/span>; <\/span>private<\/span> <\/span>set<\/span>; }<\/span><\/span>\n    <\/span>public<\/span> <\/span>TileType<\/span> <\/span>Type<\/span> { <\/span>get<\/span>; <\/span>private<\/span> <\/span>set<\/span>; }<\/span><\/span>\n    <\/span>public<\/span> <\/span>int<\/span> <\/span>Amount<\/span> { <\/span>get<\/span>; <\/span>private<\/span> <\/span>set<\/span>; }<\/span><\/span>\n<\/span>\n    <\/span>public<\/span> <\/span>TileData<\/span>(<\/span>int<\/span> <\/span>positionX<\/span>, <\/span>int<\/span> <\/span>positionY<\/span>, <\/span>TileType<\/span> <\/span>type<\/span>, <\/span>int<\/span> <\/span>amount<\/span>)<\/span><\/span>\n    {<\/span><\/span>\n        <\/span>PositionX<\/span> = <\/span>positionX<\/span>;<\/span><\/span>\n        <\/span>PositionY<\/span> = <\/span>positionY<\/span>;<\/span><\/span>\n        <\/span>Type<\/span> = <\/span>type<\/span>;<\/span><\/span>\n        <\/span>Amount<\/span> = <\/span>amount<\/span>;<\/span><\/span>\n    }<\/span><\/span>\n}<\/span><\/span>\n<\/span>\npublic<\/span> <\/span>enum<\/span> <\/span>TileType<\/span><\/span>\n{<\/span><\/span>\n    <\/span>Water<\/span>,<\/span><\/span>\n    <\/span>Rock<\/span>,<\/span><\/span>\n    <\/span>Snow<\/span>,<\/span><\/span>\n    <\/span>Grass<\/span>,<\/span><\/span>\n    <\/span>Air<\/span><\/span>\n}<\/span><\/span>\n<\/span><\/code><\/pre><\/div>\n\n\n\n
<\/p>\n\n\n\n
Data Initialization<\/h2>\n\n\n\n
For testing purposes, we create a list of TileData<\/code> objects with 1,000,000 randomly generated entries. Each object is assigned a random TileType<\/code>, giving us a realistic example of a large collection to filter.<\/p>\n\n\n\n
<\/span><\/span>
private<\/span> <\/span>void<\/span> <\/span>InitTiles<\/span>()<\/span><\/span>\n{<\/span><\/span>\n    <\/span>AllTiles<\/span> = <\/span>new<\/span> <\/span>List<\/span><<\/span>TileData<\/span>>();<\/span><\/span>\n    <\/span>System<\/span>.<\/span>Array<\/span> <\/span>tileTypes<\/span> = <\/span>System<\/span>.<\/span>Enum<\/span>.<\/span>GetValues<\/span>(<\/span>typeof<\/span>(<\/span>TileType<\/span>));<\/span><\/span>\n    <\/span>System<\/span>.<\/span>Random<\/span> <\/span>random<\/span> = <\/span>new<\/span> <\/span>System<\/span>.<\/span>Random<\/span>(<\/span>100<\/span>);<\/span><\/span>\n<\/span>\n    <\/span>for<\/span> (<\/span>int<\/span> <\/span>x<\/span> = <\/span>0<\/span>; <\/span>x<\/span> < <\/span>1000<\/span>; <\/span>x<\/span>++)<\/span><\/span>\n    {<\/span><\/span>\n        <\/span>for<\/span> (<\/span>int<\/span> <\/span>y<\/span> = <\/span>0<\/span>; <\/span>y<\/span> < <\/span>1000<\/span>; <\/span>y<\/span>++)<\/span><\/span>\n        {<\/span><\/span>\n            <\/span>TileType<\/span> <\/span>randomType<\/span> = (<\/span>TileType<\/span>)<\/span>tileTypes<\/span>.<\/span>GetValue<\/span>(<\/span>random<\/span>.<\/span>Next<\/span>(<\/span>tileTypes<\/span>.<\/span>Length<\/span>));<\/span><\/span>\n            <\/span>int<\/span> <\/span>randomAmount<\/span> = <\/span>random<\/span>.<\/span>Next<\/span>(<\/span>1<\/span>, <\/span>101<\/span>);<\/span><\/span>\n            <\/span>TileData<\/span> <\/span>tile<\/span> = <\/span>new<\/span> <\/span>TileData<\/span>(<\/span>x<\/span>, <\/span>y<\/span>, <\/span>randomType<\/span>, <\/span>randomAmount<\/span>);<\/span><\/span>\n            <\/span>AllTiles<\/span>.<\/span>Add<\/span>(<\/span>tile<\/span>);<\/span><\/span>\n        }<\/span><\/span>\n    }<\/span><\/span>\n    <\/span>matchingTiles<\/span> = <\/span>new<\/span> <\/span>List<\/span><<\/span>TileData<\/span>>(<\/span>1000<\/span> * <\/span>1000<\/span>);<\/span><\/span>\n}<\/span><\/span>\n<\/span><\/code><\/pre><\/div>\n\n\n\n
<\/p>\n\n\n\n
Searching with Class<\/h2>\n\n\n\n
The method below searches for tiles using the class-based approach, employing a linear search through the list. While straightforward, this method can result in longer execution times when dealing with large datasets.<\/p>\n\n\n\n
<\/span><\/span>
public<\/span> <\/span>List<\/span><<\/span>TileData<\/span>> <\/span>SearchTiles<\/span>(<\/span>TileType<\/span> <\/span>tileType<\/span>, <\/span>int<\/span> <\/span>amount<\/span>)<\/span><\/span>\n{<\/span><\/span>\n    <\/span>matchingTiles<\/span>.<\/span>Clear<\/span>();<\/span><\/span>\n    <\/span>foreach<\/span> (<\/span>var<\/span> <\/span>tile<\/span> <\/span>in<\/span> <\/span>AllTiles<\/span>)<\/span><\/span>\n    {<\/span><\/span>\n        <\/span>if<\/span> (<\/span>tile<\/span>.<\/span>Type<\/span> == <\/span>tileType<\/span> && <\/span>tile<\/span>.<\/span>Amount<\/span> >= <\/span>amount<\/span>)<\/span><\/span>\n        {<\/span><\/span>\n            <\/span>matchingTiles<\/span>.<\/span>Add<\/span>(<\/span>tile<\/span>);<\/span><\/span>\n        }<\/span><\/span>\n    }<\/span><\/span>\n    <\/span>return<\/span> <\/span>matchingTiles<\/span>;<\/span><\/span>\n}<\/span><\/span>\n<\/span><\/code><\/pre><\/div>\n\n\n\n
<\/p>\n\n\n\n
\"\"
This method shows a long execution time due to the linear search approach.<\/figcaption><\/figure>\n\n\n\n
<\/p>\n\n\n\n
Searching with Dictionary<\/h2>\n\n\n\n
Next, we can improve the search performance by using a dictionary to store tiles by their type. This allows for faster lookups compared to a linear search.<\/p>\n\n\n\n
<\/span><\/span>
public<\/span> <\/span>List<\/span><<\/span>TileData<\/span>> <\/span>SearchTilesInDictionary<\/span>(<\/span>TileType<\/span> <\/span>tileType<\/span>, <\/span>int<\/span> <\/span>amount<\/span>)<\/span><\/span>\n{<\/span><\/span>\n    <\/span>matchingTiles<\/span>.<\/span>Clear<\/span>();<\/span><\/span>\n    <\/span>if<\/span> (<\/span>tileDictionary<\/span>.<\/span>TryGetValue<\/span>(<\/span>tileType<\/span>, <\/span>out<\/span> <\/span>var<\/span> <\/span>tiles<\/span>))<\/span><\/span>\n    {<\/span><\/span>\n        <\/span>foreach<\/span> (<\/span>var<\/span> <\/span>tile<\/span> <\/span>in<\/span> <\/span>tiles<\/span>)<\/span><\/span>\n        {<\/span><\/span>\n            <\/span>if<\/span> (<\/span>tile<\/span>.<\/span>Amount<\/span> >= <\/span>amount<\/span>)<\/span><\/span>\n            {<\/span><\/span>\n                <\/span>matchingTiles<\/span>.<\/span>Add<\/span>(<\/span>tile<\/span>);<\/span><\/span>\n            }<\/span><\/span>\n        }<\/span><\/span>\n    }<\/span><\/span>\n    <\/span>return<\/span> <\/span>matchingTiles<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
<\/p>\n\n\n\n
\"\"
This shows a significant improvement in performance due to reduced search time using a dictionary.<\/figcaption><\/figure>\n\n\n\n
<\/p>\n\n\n\n
Changing to Structs<\/h2>\n\n\n\n
Now let\u2019s explore the performance benefits of using structs instead of classes. Structs are value types, meaning they are stored on the stack rather than the heap. This can lead to improved performance when working with large collections of data.<\/p>\n\n\n\n
<\/span><\/span>
public<\/span> <\/span>struct<\/span> <\/span>TileData<\/span><\/span>\n{<\/span><\/span>\n    <\/span>public<\/span> <\/span>int<\/span> <\/span>PositionX<\/span> { <\/span>get<\/span>; <\/span>private<\/span> <\/span>set<\/span>; }<\/span><\/span>\n    <\/span>public<\/span> <\/span>int<\/span> <\/span>PositionY<\/span> { <\/span>get<\/span>; <\/span>private<\/span> <\/span>set<\/span>; }<\/span><\/span>\n    <\/span>public<\/span> <\/span>TileType<\/span> <\/span>Type<\/span> { <\/span>get<\/span>; <\/span>private<\/span> <\/span>set<\/span>; }<\/span><\/span>\n    <\/span>public<\/span> <\/span>int<\/span> <\/span>Amount<\/span> { <\/span>get<\/span>; <\/span>private<\/span> <\/span>set<\/span>; }<\/span><\/span>\n<\/span>\n    <\/span>public<\/span> <\/span>TileData<\/span>(<\/span>int<\/span> <\/span>positionX<\/span>, <\/span>int<\/span> <\/span>positionY<\/span>, <\/span>TileType<\/span> <\/span>type<\/span>, <\/span>int<\/span> <\/span>amount<\/span>)<\/span><\/span>\n    {<\/span><\/span>\n        <\/span>PositionX<\/span> = <\/span>positionX<\/span>;<\/span><\/span>\n        <\/span>PositionY<\/span> = <\/span>positionY<\/span>;<\/span><\/span>\n        <\/span>Type<\/span> = <\/span>type<\/span>;<\/span><\/span>\n        <\/span>Amount<\/span> = <\/span>amount<\/span>;<\/span><\/span>\n    }<\/span><\/span>\n}<\/span><\/span>\n<\/span><\/code><\/pre><\/div>\n\n\n\n
<\/p>\n\n\n\n
\"\"
This shows a noticeable performance improvement due to the use of structs instead of classes.<\/figcaption><\/figure>\n\n\n\n
<\/p>\n\n\n\n
Conclusion<\/h2>\n\n\n\n
This analysis highlights how selecting an appropriate data structure and search method can greatly enhance performance in Unity.<\/p>\n\n\n\n
    \n
  • Classes<\/strong>: Best suited for more complex, long-lived objects that benefit from features like inheritance. Because classes are reference types, they are allocated on the heap, resulting in higher memory overhead and slower performance in data-intensive tasks.
    <\/li>\n\n\n\n
  • Dictionaries<\/strong>: Using dictionaries allows for efficient, constant-time lookups, which reduces the need for linear scans. This makes them ideal when fast retrieval of grouped data is needed, significantly improving search performance in scenarios with frequent lookups.
    <\/li>\n\n\n\n
  • Structs<\/strong>: Well-suited for small, homogeneous data sets that require fast access and are frequently created and destroyed. As value types, structs are allocated on the stack, minimizing memory overhead and improving cache locality, which can lead to faster execution times compared to classes.<\/li>\n<\/ul>\n\n\n\n
    Selecting the best data structure depends on the specific needs of your project. Testing each approach using Unity’s Profiler is crucial to achieve a balance between performance and memory usage, ensuring efficient gameplay and resource management.<\/p>\n","protected":false},"excerpt":{"rendered":"
    Introduction In game development, optimizing code is essential for ensuring smooth gameplay. This is particularly true in Unity, where memory management and execution speed are crucial. The methods used to search and filter large datasets can significantly impact application performance. This article compares three approaches for searching for elements in lists: using classes, dictionaries, and […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[6],"tags":[23,18],"class_list":["post-255","post","type-post","status-publish","format-standard","hentry","category-unity-optimization","tag-code-optimization","tag-unity-optimization"],"yoast_head":"\nComparing Class, Dictionary, and Struct Performance in Tile Searching in Unity - Unity3D Performance Blog<\/title>\n<meta name=\"description\" content=\"Explore how choosing between classes, structs, and dictionaries impacts performance in Unity tile search. Learn which data structures and search methods best optimize large datasets for gaming applications.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/unity3dperformance.com\/index.php\/2024\/11\/13\/class-vs-struct-performance-unity-tile-search\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Comparing Class, Dictionary, and Struct Performance in Tile Searching in Unity - Unity3D Performance Blog\" \/>\n<meta property=\"og:description\" content=\"Explore how choosing between classes, structs, and dictionaries impacts performance in Unity tile search. Learn which data structures and search methods best optimize large datasets for gaming applications.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/unity3dperformance.com\/index.php\/2024\/11\/13\/class-vs-struct-performance-unity-tile-search\/\" \/>\n<meta property=\"og:site_name\" content=\"Unity3D Performance Blog\" \/>\n<meta property=\"article:published_time\" content=\"2024-11-13T12:00:00+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2024-10-28T17:36:14+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/unity3dperformance.com\/wp-content\/uploads\/2024\/10\/obraz-9.png\" \/>\n\t<meta property=\"og:image:width\" content=\"1606\" \/>\n\t<meta property=\"og:image:height\" content=\"831\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/png\" \/>\n<meta name=\"author\" content=\"Rufi\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Rufi\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"3 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/unity3dperformance.com\/index.php\/2024\/11\/13\/class-vs-struct-performance-unity-tile-search\/\",\"url\":\"https:\/\/unity3dperformance.com\/index.php\/2024\/11\/13\/class-vs-struct-performance-unity-tile-search\/\",\"name\":\"Comparing Class, Dictionary, and Struct Performance in Tile Searching in Unity - Unity3D Performance Blog\",\"isPartOf\":{\"@id\":\"https:\/\/unity3dperformance.com\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/unity3dperformance.com\/index.php\/2024\/11\/13\/class-vs-struct-performance-unity-tile-search\/#primaryimage\"},\"image\":{\"@id\":\"https:\/\/unity3dperformance.com\/index.php\/2024\/11\/13\/class-vs-struct-performance-unity-tile-search\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/unity3dperformance.com\/wp-content\/uploads\/2024\/10\/obraz-9-1024x530.png\",\"datePublished\":\"2024-11-13T12:00:00+00:00\",\"dateModified\":\"2024-10-28T17:36:14+00:00\",\"author\":{\"@id\":\"https:\/\/unity3dperformance.com\/#\/schema\/person\/1296fd7575f681c85a3afc18bf973b0c\"},\"description\":\"Explore how choosing between classes, structs, and dictionaries impacts performance in Unity tile search. Learn which data structures and search methods best optimize large datasets for gaming applications.\",\"breadcrumb\":{\"@id\":\"https:\/\/unity3dperformance.com\/index.php\/2024\/11\/13\/class-vs-struct-performance-unity-tile-search\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/unity3dperformance.com\/index.php\/2024\/11\/13\/class-vs-struct-performance-unity-tile-search\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/unity3dperformance.com\/index.php\/2024\/11\/13\/class-vs-struct-performance-unity-tile-search\/#primaryimage\",\"url\":\"https:\/\/unity3dperformance.com\/wp-content\/uploads\/2024\/10\/obraz-9.png\",\"contentUrl\":\"https:\/\/unity3dperformance.com\/wp-content\/uploads\/2024\/10\/obraz-9.png\",\"width\":1606,\"height\":831},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/unity3dperformance.com\/index.php\/2024\/11\/13\/class-vs-struct-performance-unity-tile-search\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/unity3dperformance.com\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Class vs Struct Performance in Unity Tile Search\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/unity3dperformance.com\/#website\",\"url\":\"https:\/\/unity3dperformance.com\/\",\"name\":\"Unity3D Performance Blog\",\"description\":\"Discover tips and techniques to optimize your Unity3D projects for better performance and efficiency.\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/unity3dperformance.com\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Person\",\"@id\":\"https:\/\/unity3dperformance.com\/#\/schema\/person\/1296fd7575f681c85a3afc18bf973b0c\",\"name\":\"Rufi\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/unity3dperformance.com\/#\/schema\/person\/image\/\",\"url\":\"https:\/\/secure.gravatar.com\/avatar\/3f1f6db23df2ef8fe5ff6875fbab10a67f1fcfef48afa45d5c00ed04d0ccf792?s=96&d=mm&r=g\",\"contentUrl\":\"https:\/\/secure.gravatar.com\/avatar\/3f1f6db23df2ef8fe5ff6875fbab10a67f1fcfef48afa45d5c00ed04d0ccf792?s=96&d=mm&r=g\",\"caption\":\"Rufi\"},\"sameAs\":[\"http:\/\/unity3dperformance.com\"],\"url\":\"https:\/\/unity3dperformance.com\/index.php\/author\/admin2826\/\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Comparing Class, Dictionary, and Struct Performance in Tile Searching in Unity - Unity3D Performance Blog","description":"Explore how choosing between classes, structs, and dictionaries impacts performance in Unity tile search. Learn which data structures and search methods best optimize large datasets for gaming applications.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/unity3dperformance.com\/index.php\/2024\/11\/13\/class-vs-struct-performance-unity-tile-search\/","og_locale":"en_US","og_type":"article","og_title":"Comparing Class, Dictionary, and Struct Performance in Tile Searching in Unity - Unity3D Performance Blog","og_description":"Explore how choosing between classes, structs, and dictionaries impacts performance in Unity tile search. Learn which data structures and search methods best optimize large datasets for gaming applications.","og_url":"https:\/\/unity3dperformance.com\/index.php\/2024\/11\/13\/class-vs-struct-performance-unity-tile-search\/","og_site_name":"Unity3D Performance Blog","article_published_time":"2024-11-13T12:00:00+00:00","article_modified_time":"2024-10-28T17:36:14+00:00","og_image":[{"width":1606,"height":831,"url":"https:\/\/unity3dperformance.com\/wp-content\/uploads\/2024\/10\/obraz-9.png","type":"image\/png"}],"author":"Rufi","twitter_card":"summary_large_image","twitter_misc":{"Written by":"Rufi","Est. reading time":"3 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/unity3dperformance.com\/index.php\/2024\/11\/13\/class-vs-struct-performance-unity-tile-search\/","url":"https:\/\/unity3dperformance.com\/index.php\/2024\/11\/13\/class-vs-struct-performance-unity-tile-search\/","name":"Comparing Class, Dictionary, and Struct Performance in Tile Searching in Unity - Unity3D Performance Blog","isPartOf":{"@id":"https:\/\/unity3dperformance.com\/#website"},"primaryImageOfPage":{"@id":"https:\/\/unity3dperformance.com\/index.php\/2024\/11\/13\/class-vs-struct-performance-unity-tile-search\/#primaryimage"},"image":{"@id":"https:\/\/unity3dperformance.com\/index.php\/2024\/11\/13\/class-vs-struct-performance-unity-tile-search\/#primaryimage"},"thumbnailUrl":"https:\/\/unity3dperformance.com\/wp-content\/uploads\/2024\/10\/obraz-9-1024x530.png","datePublished":"2024-11-13T12:00:00+00:00","dateModified":"2024-10-28T17:36:14+00:00","author":{"@id":"https:\/\/unity3dperformance.com\/#\/schema\/person\/1296fd7575f681c85a3afc18bf973b0c"},"description":"Explore how choosing between classes, structs, and dictionaries impacts performance in Unity tile search. Learn which data structures and search methods best optimize large datasets for gaming applications.","breadcrumb":{"@id":"https:\/\/unity3dperformance.com\/index.php\/2024\/11\/13\/class-vs-struct-performance-unity-tile-search\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/unity3dperformance.com\/index.php\/2024\/11\/13\/class-vs-struct-performance-unity-tile-search\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/unity3dperformance.com\/index.php\/2024\/11\/13\/class-vs-struct-performance-unity-tile-search\/#primaryimage","url":"https:\/\/unity3dperformance.com\/wp-content\/uploads\/2024\/10\/obraz-9.png","contentUrl":"https:\/\/unity3dperformance.com\/wp-content\/uploads\/2024\/10\/obraz-9.png","width":1606,"height":831},{"@type":"BreadcrumbList","@id":"https:\/\/unity3dperformance.com\/index.php\/2024\/11\/13\/class-vs-struct-performance-unity-tile-search\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/unity3dperformance.com\/"},{"@type":"ListItem","position":2,"name":"Class vs Struct Performance in Unity Tile Search"}]},{"@type":"WebSite","@id":"https:\/\/unity3dperformance.com\/#website","url":"https:\/\/unity3dperformance.com\/","name":"Unity3D Performance Blog","description":"Discover tips and techniques to optimize your Unity3D projects for better performance and efficiency.","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/unity3dperformance.com\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Person","@id":"https:\/\/unity3dperformance.com\/#\/schema\/person\/1296fd7575f681c85a3afc18bf973b0c","name":"Rufi","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/unity3dperformance.com\/#\/schema\/person\/image\/","url":"https:\/\/secure.gravatar.com\/avatar\/3f1f6db23df2ef8fe5ff6875fbab10a67f1fcfef48afa45d5c00ed04d0ccf792?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/3f1f6db23df2ef8fe5ff6875fbab10a67f1fcfef48afa45d5c00ed04d0ccf792?s=96&d=mm&r=g","caption":"Rufi"},"sameAs":["http:\/\/unity3dperformance.com"],"url":"https:\/\/unity3dperformance.com\/index.php\/author\/admin2826\/"}]}},"_links":{"self":[{"href":"https:\/\/unity3dperformance.com\/index.php\/wp-json\/wp\/v2\/posts\/255","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/unity3dperformance.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/unity3dperformance.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/unity3dperformance.com\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/unity3dperformance.com\/index.php\/wp-json\/wp\/v2\/comments?post=255"}],"version-history":[{"count":6,"href":"https:\/\/unity3dperformance.com\/index.php\/wp-json\/wp\/v2\/posts\/255\/revisions"}],"predecessor-version":[{"id":267,"href":"https:\/\/unity3dperformance.com\/index.php\/wp-json\/wp\/v2\/posts\/255\/revisions\/267"}],"wp:attachment":[{"href":"https:\/\/unity3dperformance.com\/index.php\/wp-json\/wp\/v2\/media?parent=255"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/unity3dperformance.com\/index.php\/wp-json\/wp\/v2\/categories?post=255"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/unity3dperformance.com\/index.php\/wp-json\/wp\/v2\/tags?post=255"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}