{"id":241,"date":"2024-11-06T12:00:21","date_gmt":"2024-11-06T12:00:21","guid":{"rendered":"https:\/\/unity3dperformance.com\/?p=241"},"modified":"2024-10-26T00:38:11","modified_gmt":"2024-10-26T00:38:11","slug":"linq-vs-traditional-searching-in-unity","status":"publish","type":"post","link":"https:\/\/unity3dperformance.com\/index.php\/2024\/11\/06\/linq-vs-traditional-searching-in-unity\/","title":{"rendered":"Comparing LINQ Performance with Traditional Element Searching in Unity"},"content":{"rendered":"\n

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

In game development, optimizing code is crucial for smooth gameplay. Particularly in Unity, where memory management and speed are of utmost importance, the method used to search and filter large data sets can significantly impact application performance. This article compares two methods of searching for elements in lists: using LINQ and traditional approaches. 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: Character<\/strong><\/p>\n\n\n\n

Let\u2019s start with the Character<\/code> class that represents a character object. Each character has an ID<\/code> and a CharacterType<\/code> (for example: Boss<\/code> or Npc<\/code>). This forms the basic structure of our data:<\/p>\n\n\n\n

<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
blic<\/span> <\/span>class<\/span> <\/span>Character<\/span><\/span>\n{<\/span><\/span>\n    <\/span>public<\/span> <\/span>int<\/span> <\/span>ID<\/span> { <\/span>private<\/span> <\/span>set<\/span>; <\/span>get<\/span>; }<\/span><\/span>\n    <\/span>public<\/span> <\/span>CharacterType<\/span> <\/span>CharacterType<\/span> { <\/span>private<\/span> <\/span>set<\/span>; <\/span>get<\/span>; }<\/span><\/span>\n<\/span>\n    <\/span>public<\/span> <\/span>Character<\/span>(<\/span>int<\/span> <\/span>id<\/span>, <\/span>CharacterType<\/span> <\/span>characterType<\/span>)<\/span><\/span>\n    {<\/span><\/span>\n        <\/span>ID<\/span> = <\/span>id<\/span>;<\/span><\/span>\n        <\/span>CharacterType<\/span> = <\/span>characterType<\/span>;<\/span><\/span>\n    }<\/span><\/span>\n}<\/span><\/span>\n<\/span>\npublic<\/span> <\/span>enum<\/span> <\/span>CharacterType<\/span><\/span>\n{<\/span><\/span>\n    <\/span>Boss<\/span>,<\/span><\/span>\n    <\/span>Npc<\/span><\/span>\n}<\/span><\/span>\n<\/span><\/code><\/pre><\/div>\n\n\n\n
<\/p>\n\n\n\n
Data Initialization<\/strong><\/p>\n\n\n\n
For testing purposes, we create a list of Character<\/code> objects with 100,000 randomly generated entries. Each object is assigned a random CharacterType<\/code>, giving us a realistic example of a large collection to filter.<\/p>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
private<\/span> <\/span>void<\/span> <\/span>InitData<\/span>()<\/span><\/span>\n{<\/span><\/span>\n    <\/span>for<\/span> (<\/span>int<\/span> <\/span>i<\/span> = <\/span>0<\/span>; <\/span>i<\/span> < <\/span>100000<\/span>; <\/span>i<\/span>++)<\/span><\/span>\n    {<\/span><\/span>\n        <\/span>CharacterType<\/span> <\/span>characterType<\/span> = (<\/span>CharacterType<\/span>)<\/span>Random<\/span>.<\/span>Range<\/span>(<\/span>0<\/span>, <\/span>1<\/span>);<\/span><\/span>\n        <\/span>_characters<\/span>.<\/span>Add<\/span>(<\/span>new<\/span> <\/span>Character<\/span>(<\/span>i<\/span>, <\/span>characterType<\/span>));<\/span><\/span>\n    }<\/span><\/span>\n    <\/span>_matchingCharacters<\/span> = <\/span>new<\/span> <\/span>List<\/span><<\/span>Character<\/span>>(<\/span>_characters<\/span>.<\/span>Count<\/span>);<\/span><\/span>\n}<\/span><\/span>\n<\/span><\/code><\/pre><\/div>\n\n\n\n
<\/p>\n\n\n\n
LINQ Without Optimization<\/h2>\n\n\n\n
Using LINQ without optimizations leads to significant memory allocations and increased garbage collection costs. Each call to .ToList()<\/code> creates a new list, which negatively impacts application performance, particularly when working with large datasets. This overhead can result in noticeable frame drops during gameplay, highlighting the importance of memory management in Unity.<\/p>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
private<\/span> <\/span>List<\/span><<\/span>Character<\/span>> <\/span>FindCharacterByTypeLinqu<\/span>(<\/span>CharacterType<\/span> <\/span>characterType<\/span>)<\/span><\/span>\n{<\/span><\/span>\n    <\/span>_matchingCharacters<\/span>.<\/span>Clear<\/span>();<\/span><\/span>\n    <\/span>return<\/span> <\/span>_characters<\/span>.<\/span>Where<\/span>(<\/span>c<\/span> => <\/span>c<\/span>.<\/span>CharacterType<\/span> == <\/span>characterType<\/span>).<\/span>ToList<\/span>();<\/span><\/span>\n}<\/span><\/span>\n<\/span><\/code><\/pre><\/div>\n\n\n\n
<\/p>\n\n\n\n
\"\"
High memory allocations and performance drops due to new list creation by LINQ.<\/figcaption><\/figure>\n\n\n\n
<\/p>\n\n\n\n
Optimized LINQ<\/h2>\n\n\n\n
By optimizing the LINQ method and removing the .ToList()<\/code> call, we see a noticeable improvement in memory efficiency. This adjustment allows us to manually add filtered elements to the _matchingCharacters<\/code> list, which significantly reduces memory overhead and the frequency of garbage collection calls. As a result, this optimized approach provides smoother performance, particularly beneficial when handling extensive collections of data.<\/p>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
private<\/span> <\/span>List<\/span><<\/span>Character<\/span>> <\/span>FindCharacterByTypeLinquNocAllock<\/span>(<\/span>CharacterType<\/span> <\/span>characterType<\/span>)<\/span><\/span>\n{<\/span><\/span>\n    <\/span>_matchingCharacters<\/span>.<\/span>Clear<\/span>();<\/span><\/span>\n    <\/span>foreach<\/span> (<\/span>var<\/span> <\/span>character<\/span> <\/span>in<\/span> <\/span>_characters<\/span>.<\/span>Where<\/span>(<\/span>c<\/span> => <\/span>c<\/span>.<\/span>CharacterType<\/span> == <\/span>characterType<\/span>))<\/span><\/span>\n    {<\/span><\/span>\n        <\/span>_matchingCharacters<\/span>.<\/span>Add<\/span>(<\/span>character<\/span>);<\/span><\/span>\n    }<\/span><\/span>\n<\/span>\n    <\/span>return<\/span> <\/span>_matchingCharacters<\/span>;<\/span><\/span>\n}<\/span><\/span>\n<\/span><\/code><\/pre><\/div>\n\n\n\n
<\/p>\n\n\n\n
\"\"
Significant reduction in memory allocations due to the removal of ToList()<\/code> in the LINQ method.<\/figcaption><\/figure>\n\n\n\n
<\/p>\n\n\n\n
Traditional List Searching<\/h2>\n\n\n\n
The traditional list searching method utilizes a simple for<\/code> loop, resulting in minimal memory allocations and the lowest memory management costs. This straightforward approach ensures that we check each character efficiently, allowing for maximum performance. Such efficiency is crucial in high-demand applications, where managing resources effectively can lead to smoother gameplay experiences.<\/p>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
private<\/span> <\/span>List<\/span><<\/span>Character<\/span>> <\/span>FindCharacterByType<\/span>(<\/span>CharacterType<\/span> <\/span>characterType<\/span>)<\/span><\/span>\n{<\/span><\/span>\n    <\/span>_matchingCharacters<\/span>.<\/span>Clear<\/span>();<\/span><\/span>\n<\/span>\n    <\/span>int<\/span> <\/span>charactersCount<\/span> = <\/span>_characters<\/span>.<\/span>Count<\/span>;<\/span><\/span>\n<\/span>\n    <\/span>Character<\/span> <\/span>currentCharacter<\/span> = <\/span>null<\/span>;<\/span><\/span>\n<\/span>\n    <\/span>for<\/span> (<\/span>int<\/span> <\/span>i<\/span> = <\/span>0<\/span>; <\/span>i<\/span> < <\/span>charactersCount<\/span>; <\/span>i<\/span>++)<\/span><\/span>\n    {<\/span><\/span>\n        <\/span>currentCharacter<\/span> = <\/span>_characters<\/span>[<\/span>i<\/span>];<\/span><\/span>\n<\/span>\n        <\/span>if<\/span> (<\/span>currentCharacter<\/span>.<\/span>CharacterType<\/span> == <\/span>characterType<\/span>)<\/span><\/span>\n        {<\/span><\/span>\n            <\/span>_matchingCharacters<\/span>.<\/span>Add<\/span>(<\/span>currentCharacter<\/span>);<\/span><\/span>\n        }<\/span><\/span>\n    }<\/span><\/span>\n<\/span>\n    <\/span>return<\/span> <\/span>_matchingCharacters<\/span>;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n<\/span><\/code><\/pre><\/div>\n\n\n\n
<\/p>\n\n\n\n
\"\"
Minimal memory allocations and optimal performance due to traditional iteration.<\/figcaption><\/figure>\n\n\n\n
<\/p>\n\n\n\n
Conclusion<\/h2>\n\n\n\n
Test results clearly show that each approach has its advantages and disadvantages:<\/p>\n\n\n\n
    \n
  • LINQ without optimization<\/strong> is simple and readable but has a large impact on memory and performance, especially with large collections.<\/li>\n\n\n\n
  • Optimized LINQ<\/strong> still benefits from convenient syntax but becomes more efficient in terms of memory due to the removal of .ToList()<\/code>.<\/li>\n\n\n\n
  • Traditional list searching<\/strong> is by far the most resource-efficient approach, although less elegant than LINQ.<\/li>\n<\/ul>\n\n\n\n
    The choice of the optimal method depends on the project’s scale and the specific requirements of the task. In situations where performance is critical (e.g., on mobile devices), it is advisable to consider the traditional approach. Conversely, in projects where code readability is more important than a slight performance compromise, optimized LINQ can be a great choice.<\/p>\n\n\n\n
    By utilizing profiling and analysis, developers can select the method that best meets their project needs, ensuring smooth gameplay and enhancing the user experience.<\/p>\n","protected":false},"excerpt":{"rendered":"
    Introduction In game development, optimizing code is crucial for smooth gameplay. Particularly in Unity, where memory management and speed are of utmost importance, the method used to search and filter large data sets can significantly impact application performance. This article compares two methods of searching for elements in lists: using LINQ and traditional approaches. We […]<\/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,24,25,18],"class_list":["post-241","post","type-post","status-publish","format-standard","hentry","category-unity-optimization","tag-code-optimization","tag-codeoptymalization","tag-linq","tag-unity-optimization"],"yoast_head":"\nComparing LINQ Performance with Traditional Element Searching in Unity - Unity3D Performance Blog<\/title>\n<meta name=\"description\" content=\"Discover the performance differences between LINQ and traditional searching methods in Unity. This article compares memory usage and execution speed, helping you choose the best approach for your game development needs.\" \/>\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\/06\/linq-vs-traditional-searching-in-unity\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Comparing LINQ Performance with Traditional Element Searching in Unity - Unity3D Performance Blog\" \/>\n<meta property=\"og:description\" content=\"Discover the performance differences between LINQ and traditional searching methods in Unity. This article compares memory usage and execution speed, helping you choose the best approach for your game development needs.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/unity3dperformance.com\/index.php\/2024\/11\/06\/linq-vs-traditional-searching-in-unity\/\" \/>\n<meta property=\"og:site_name\" content=\"Unity3D Performance Blog\" \/>\n<meta property=\"article:published_time\" content=\"2024-11-06T12:00:21+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2024-10-26T00:38:11+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/unity3dperformance.com\/wp-content\/uploads\/2024\/10\/obraz-6.png\" \/>\n\t<meta property=\"og:image:width\" content=\"1352\" \/>\n\t<meta property=\"og:image:height\" content=\"942\" \/>\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\/06\/linq-vs-traditional-searching-in-unity\/\",\"url\":\"https:\/\/unity3dperformance.com\/index.php\/2024\/11\/06\/linq-vs-traditional-searching-in-unity\/\",\"name\":\"Comparing LINQ Performance with Traditional Element Searching in Unity - Unity3D Performance Blog\",\"isPartOf\":{\"@id\":\"https:\/\/unity3dperformance.com\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/unity3dperformance.com\/index.php\/2024\/11\/06\/linq-vs-traditional-searching-in-unity\/#primaryimage\"},\"image\":{\"@id\":\"https:\/\/unity3dperformance.com\/index.php\/2024\/11\/06\/linq-vs-traditional-searching-in-unity\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/unity3dperformance.com\/wp-content\/uploads\/2024\/10\/obraz-6-1024x713.png\",\"datePublished\":\"2024-11-06T12:00:21+00:00\",\"dateModified\":\"2024-10-26T00:38:11+00:00\",\"author\":{\"@id\":\"https:\/\/unity3dperformance.com\/#\/schema\/person\/1296fd7575f681c85a3afc18bf973b0c\"},\"description\":\"Discover the performance differences between LINQ and traditional searching methods in Unity. This article compares memory usage and execution speed, helping you choose the best approach for your game development needs.\",\"breadcrumb\":{\"@id\":\"https:\/\/unity3dperformance.com\/index.php\/2024\/11\/06\/linq-vs-traditional-searching-in-unity\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/unity3dperformance.com\/index.php\/2024\/11\/06\/linq-vs-traditional-searching-in-unity\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/unity3dperformance.com\/index.php\/2024\/11\/06\/linq-vs-traditional-searching-in-unity\/#primaryimage\",\"url\":\"https:\/\/unity3dperformance.com\/wp-content\/uploads\/2024\/10\/obraz-6.png\",\"contentUrl\":\"https:\/\/unity3dperformance.com\/wp-content\/uploads\/2024\/10\/obraz-6.png\",\"width\":1352,\"height\":942},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/unity3dperformance.com\/index.php\/2024\/11\/06\/linq-vs-traditional-searching-in-unity\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/unity3dperformance.com\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Comparing LINQ Performance with Traditional Element Searching in Unity\"}]},{\"@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 LINQ Performance with Traditional Element Searching in Unity - Unity3D Performance Blog","description":"Discover the performance differences between LINQ and traditional searching methods in Unity. This article compares memory usage and execution speed, helping you choose the best approach for your game development needs.","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\/06\/linq-vs-traditional-searching-in-unity\/","og_locale":"en_US","og_type":"article","og_title":"Comparing LINQ Performance with Traditional Element Searching in Unity - Unity3D Performance Blog","og_description":"Discover the performance differences between LINQ and traditional searching methods in Unity. This article compares memory usage and execution speed, helping you choose the best approach for your game development needs.","og_url":"https:\/\/unity3dperformance.com\/index.php\/2024\/11\/06\/linq-vs-traditional-searching-in-unity\/","og_site_name":"Unity3D Performance Blog","article_published_time":"2024-11-06T12:00:21+00:00","article_modified_time":"2024-10-26T00:38:11+00:00","og_image":[{"width":1352,"height":942,"url":"https:\/\/unity3dperformance.com\/wp-content\/uploads\/2024\/10\/obraz-6.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\/06\/linq-vs-traditional-searching-in-unity\/","url":"https:\/\/unity3dperformance.com\/index.php\/2024\/11\/06\/linq-vs-traditional-searching-in-unity\/","name":"Comparing LINQ Performance with Traditional Element Searching in Unity - Unity3D Performance Blog","isPartOf":{"@id":"https:\/\/unity3dperformance.com\/#website"},"primaryImageOfPage":{"@id":"https:\/\/unity3dperformance.com\/index.php\/2024\/11\/06\/linq-vs-traditional-searching-in-unity\/#primaryimage"},"image":{"@id":"https:\/\/unity3dperformance.com\/index.php\/2024\/11\/06\/linq-vs-traditional-searching-in-unity\/#primaryimage"},"thumbnailUrl":"https:\/\/unity3dperformance.com\/wp-content\/uploads\/2024\/10\/obraz-6-1024x713.png","datePublished":"2024-11-06T12:00:21+00:00","dateModified":"2024-10-26T00:38:11+00:00","author":{"@id":"https:\/\/unity3dperformance.com\/#\/schema\/person\/1296fd7575f681c85a3afc18bf973b0c"},"description":"Discover the performance differences between LINQ and traditional searching methods in Unity. This article compares memory usage and execution speed, helping you choose the best approach for your game development needs.","breadcrumb":{"@id":"https:\/\/unity3dperformance.com\/index.php\/2024\/11\/06\/linq-vs-traditional-searching-in-unity\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/unity3dperformance.com\/index.php\/2024\/11\/06\/linq-vs-traditional-searching-in-unity\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/unity3dperformance.com\/index.php\/2024\/11\/06\/linq-vs-traditional-searching-in-unity\/#primaryimage","url":"https:\/\/unity3dperformance.com\/wp-content\/uploads\/2024\/10\/obraz-6.png","contentUrl":"https:\/\/unity3dperformance.com\/wp-content\/uploads\/2024\/10\/obraz-6.png","width":1352,"height":942},{"@type":"BreadcrumbList","@id":"https:\/\/unity3dperformance.com\/index.php\/2024\/11\/06\/linq-vs-traditional-searching-in-unity\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/unity3dperformance.com\/"},{"@type":"ListItem","position":2,"name":"Comparing LINQ Performance with Traditional Element Searching in Unity"}]},{"@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\/241","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=241"}],"version-history":[{"count":6,"href":"https:\/\/unity3dperformance.com\/index.php\/wp-json\/wp\/v2\/posts\/241\/revisions"}],"predecessor-version":[{"id":254,"href":"https:\/\/unity3dperformance.com\/index.php\/wp-json\/wp\/v2\/posts\/241\/revisions\/254"}],"wp:attachment":[{"href":"https:\/\/unity3dperformance.com\/index.php\/wp-json\/wp\/v2\/media?parent=241"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/unity3dperformance.com\/index.php\/wp-json\/wp\/v2\/categories?post=241"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/unity3dperformance.com\/index.php\/wp-json\/wp\/v2\/tags?post=241"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}