Method start_resource

crates/csharp/src/interface.rs:1366–1523

(&mut self, id: TypeId, key: Option<&WorldKey>)

    }

    pub(crate) fn start_resource(&mut self, id: TypeId, key: Option<&WorldKey>) {
        let access = self.csharp_gen.access_modifier();
        let qualified = self.type_name_with_qualifier(&Type::Id(id), true);
        let info = &self.csharp_gen.all_resources[&id];
        let name = info.name.clone();
        let upper_camel = name.to_upper_camel_case();
        let docs = info.docs.clone();
        self.print_docs(&docs);

        match self.direction {
            Direction::Import => {
                let module_name = key
                    .map(|key| self.resolve.name_world_key(key))
                    .unwrap_or_else(|| "$root".into());

                // As of this writing, we cannot safely drop a handle to an imported resource from a .NET finalizer
                // because it may still have one or more open child resources.  Once WIT has explicit syntax for
                // indicating parent/child relationships, we should be able to use that information to keep track
                // of child resources automatically in generated code, at which point we'll be able to drop them in
                // the correct order from finalizers.
                uwriteln!(
                    self.src,
                    r#"
                    {access} class {upper_camel}: global::System.IDisposable {{
                        internal int Handle {{ get; set; }}

                        {access} readonly record struct THandle(int Handle);

                        {access} {upper_camel}(THandle handle) {{
                            Handle = handle.Handle;
                        }}

                        public void Dispose() {{
                            Dispose(true);
                        }}

                        [global::System.Runtime.InteropServices.DllImportAttribute("{module_name}", EntryPoint = "[resource-drop]{name}"), global::System.Runtime.InteropServices.WasmImportLinkageAttribute]
                        private static extern void wasmImportResourceDrop(int p0);

                        protected virtual void Dispose(bool disposing) {{
                            if (disposing && Handle != 0) {{
                                wasmImportResourceDrop(Handle);
                                Handle = 0;
                            }}
                        }}
                    "#
                );
            }
            Direction::Export => {
                let prefix = key
                    .map(|s| format!("{}#", self.resolve.name_world_key(s)))
                    .unwrap_or_default();

                uwrite!(
                    self.csharp_interop_src,
                    r#"
                    [global::System.Runtime.InteropServices.UnmanagedCallersOnlyAttribute(EntryPoint = "{prefix}[dtor]{name}")]
                    {access} static unsafe void wasmExportResourceDtor{upper_camel}(int rep) {{