v0.8.0

[vfsfitvnm]

• Add Il2Cpp.Backtracer:
  Similar to Il2Cpp.Tracer, but it prints the method backtrace instead, i.e. a stack of IL2CPP methods.
  This is still a very experimental feature, and slows down real large applications. Don't attach it to a whole assembly!

  Il2Cpp.perform(() => {
      Il2Cpp.backtrace() // creates a Il2Cpp.Bactracer instance
          .strategy("fuzzy") // can be either "fuzzy" or "accurate"
          .verbose(false) // false to avoid printing the same stack twice
          .assemblies(Il2Cpp.domain.assembly("Assembly-CSharp"))
          .and()
          .attach();
  });

• Add Il2Cpp::mainThread:
  A shorthand for Il2Cpp.attachedThreads[0].

• Add Il2Cpp::domain:
  A property to access the application domain.

  Il2Cpp.perform(() => {
      // old
      const _ = Il2Cpp.Domain.assembly(...);
  
      // new
      const _ = Il2Cpp.domain.assembly(...);
  });

• Add Il2Cpp::corlib:
  A property to access the COR library image.

  Il2Cpp.perform(() => {
      // old
      const _ = Il2Cpp.Image.corlib.class(...);
  
      // new
      const _ = Il2Cpp.corlib.class(...);
  });

• Add Il2Cpp::delegate:
  An helper function for painlessly creating delegates. It returns a Il2Cpp.Object of the given delegate class.

  Il2Cpp.perform(() => {
      const SystemString = Il2Cpp.corlib.class("System.String");
      const SystemAction = Il2Cpp.corlib.class("System.Action`1").inflate(SystemString);
  
      const delegate: Il2Cpp.Object = Il2Cpp.delegate(SystemAction, (string: Il2Cpp.String) => {
          console.log(`Whoa, ${string.content}!`);
      });
  
      delegate.method("Invoke").invoke(Il2Cpp.string("it works"));
  });
  
  // output:
  // Whoa, it works!

• Add Il2Cpp::array:
  An helper function for creating arrays.

  Il2Cpp.perform(() => {
      // old
      const _ = Il2Cpp.Array.from(...);
  
      // new
      const _ = Il2Cpp.array(...);
  });

• Add Il2Cpp::string:
  An helper function for creating strings.

  Il2Cpp.perform(() => {
      // old
      const _ = Il2Cpp.String.from(...);
  
      // new
      const _ = Il2Cpp.string(...);
  });

• Add Il2Cpp::reference:
  An helper function for creating references.

  Il2Cpp.perform(() => {
      // old
      const _ = Il2Cpp.Reference.to(...);
  
      // new
      const _ = Il2Cpp.reference(...);
  });

• Add Il2Cpp::memorySnapshot:
  An helper function for creating a memory snapshot without worrying to free it afterwards.

  Il2Cpp.perform(() => {
      const SystemString = Il2Cpp.corlib.class("System.String");
  
      const strings = Il2Cpp.memorySnapshot(_ => _.objects).filter(Il2Cpp.is(SystemString));
  });

• Add Il2Cpp::is:
  An helper function for creating a filter for Il2Cpp.Object based on the assignability of a class.

  Il2Cpp.perform(() => {
      const klass: Il2Cpp.Class = ...;
      const objects: Il2Cpp.Object[] = ...;
  
      // old
      const strings = objects.filter(Il2Cpp.Filtering.is(klass));
  
      // new
      const _ = objects.filter(Il2Cpp.is(klass));
  });

• Add Il2Cpp::isExactly:
  An helper function for creating a filter for Il2Cpp.Object based on the equality of a class.

  Il2Cpp.perform(() => {
      const klass: Il2Cpp.Class = ...;
      const objects: Il2Cpp.Object[] = ...;
  
      // old
      const strings = objects.filter(Il2Cpp.Filtering.isExactly(klass));
  
      // new
      const _ = objects.filter(Il2Cpp.isExactly(klass));
  });

• Add Il2Cpp::application:
  An object literal containing possibly useful information about the application.

  Il2Cpp.perform(() => {
      // old
      console.log(Il2Cpp.applicationIdentifier);
      console.log(Il2Cpp.applicationDataPath);
      console.log(Il2Cpp.applicationVersion);
  
      // new
      console.log(Il2Cpp.application.identifier);
      console.log(Il2Cpp.application.dataPath);
      console.log(Il2Cpp.application.version);
  });

• Add Il2Cpp::gc:
  An object literal containing garbage collector related functions and properties.

  Il2Cpp.perform(() => {
      // old
      Il2Cpp.GC.choose(...);
  
      // new
      Il2Cpp.gc.choose(...);
  });

• Add Il2Cpp.Class::fullName:
  A convenient accessor for having the namespace of a class concatenated to its name. It may return a different result than Il2Cpp.Type::name.

  Il2Cpp.perform(() => {
      const SystemAction = Il2Cpp.corlib.class("System.Action`1");
      console.log(SystemAction.fullName);
      console.log(SystemAction.type.name);
  });
  
  // output:
  // System.Action`1
  // System.Action<T>

• Add Il2Cpp.Thread::managedId:
  Returns the C# (?) thread id; the main thread is expected to have 1.

  Il2Cpp.perform(() => {
      console.log(Il2Cpp.mainThread.managedId); // probably 1
  });

• Fix Il2Cpp.gc::choose:
  Previously, it made the application crash on Unity 2021.1 and up; now should be fixed, or it shouldn't happen frequently at least. Please report a bug with a reproducible example if the issue persists.

• Fix Il2Cpp.Thread::id:
  Previously, it wasn't working on Windows due to an access violation error. However, I couldn't test its correctness: please let me know if the following snippet works (or not).

  Il2Cpp.perform(() => {
      // should be the same!
      console.log(Il2Cpp.currentThread?.id, Process.getCurrentThreadId());
  });

• Rename Il2Cpp.GC.Handle to Il2Cpp.GCHandle:
  A consequence of adding Il2Cpp::gc.

• Drop Il2Cpp::scheduleOnInitializerThread:
  It was a temporary and wobbly solution. Superseded by Il2Cpp.mainThread::schedule.

• Drop Il2Cpp.Image::corlib:
  Superseded by Il2Cpp::corlib.

• Drop Il2Cpp.Array::from:
  Superseded by Il2Cpp::array.

• Drop Il2Cpp.String::from:
  Superseded by Il2Cpp::string.

• Drop Il2Cpp.Reference::to:
  Superseded by Il2Cpp::reference.

• Drop Il2Cpp::applicationIdentifier:
  Superseded by Il2Cpp.application::identifier.

• Drop Il2Cpp::applicationDataPath:
  Superseded by Il2Cpp.application::dataPath.

• Drop Il2Cpp::applicationVersion:
  Superseded by Il2Cpp.application::version.

• Drop Il2Cpp::GC:
  Superseded by Il2Cpp::gc.

• Drop Il2Cpp.Filtering::is:
  Superseded by Il2Cpp::is.

• Drop Il2Cpp.Filtering::isExactly:
  Superseded by Il2Cpp::isExactly.

Full Changelog: v0.7.13...v0.8.0

---

This discussion was created from the release v0.8.0.

[thinhbuzz]

it should be Il2Cpp::memorySnapshot