public unsafe string GetString(byte* bytes, int byteCount)
{
    ArgumentNullException.ThrowIfNull(bytes);
 
    ArgumentOutOfRangeException.ThrowIfNegative(byteCount);
 
    return string.CreateStringFromEncoding(bytes, byteCount, this);
}

public static unsafe byte ReadByte(IntPtr ptr, int ofs)
{
    try
    {
        byte* addr = (byte*)ptr + ofs;
        return *addr;
    }
    catch (NullReferenceException)
    {
        throw new AccessViolationException();
    }
}

/// <summary>Reads a single byte from unmanaged memory.</summary>
/// <safety>
/// The sum of <paramref name="ptr"/> and <paramref name="ofs"/> must address a byte
/// the caller is permitted to read.
/// </safety>
public static unsafe byte ReadByte(IntPtr ptr, int ofs)
{
    try
    {
        byte* addr = (byte*)ptr;
        unsafe
        {
            // SAFETY: relies on caller obligation.
            return addr[ofs];
        }
    }
    catch (NullReferenceException)
    {
        throw new AccessViolationException();
    }
}

void Caller()
{
    M();
}
 
unsafe void M() { }

/// <safety>
/// Caller must satisfy obligation 1
/// </safety>
unsafe void Caller1()
{
    unsafe
    {
        // SAFETY: Obligation is passed to caller.
        M();
    }
}
 
void Caller2()
{
    if (/* obligation 1 not satisfied */) throw new Exception();
 
    unsafe
    {
        // SAFETY: obligation 1 is discharged by the check above
        M();
    }
}
 
/// <safety>
/// Caller must satisfy obligation 1
/// </safety>
unsafe void M() { }

[LibraryImport("libc")]
internal static safe partial int getpid();
 
[LibraryImport("libc", StringMarshalling = StringMarshalling.Utf8)]
internal static unsafe partial nint strlen(byte* str);

$ cat main.rs
/// # Safety
///
/// `bytes` must be non-null and point to at least one readable byte.
pub unsafe fn first_byte(bytes: *const u8) -> u8 {
    // No inner `unsafe { }`: warns under `unsafe_op_in_unsafe_fn` (edition 2024).
    *bytes
}
 
fn main() {
    let data = [42u8];
    // No `unsafe { }` around the call: hard error E0133.
    let value = first_byte(data.as_ptr());
    println!("{value}");
}
 
$ cargo build
   Compiling unsafe_demo v0.1.0 (/private/tmp/unsafe-demo)
warning[E0133]: dereference of raw pointer is unsafe and requires unsafe block
 --> src/main.rs:6:5
  |
6 |     *bytes
  |     ^^^^^^ dereference of raw pointer
  |
  = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
note: an unsafe function restricts its caller, but its body is safe by default
 --> src/main.rs:4:1
  |
4 | pub unsafe fn first_byte(bytes: *const u8) -> u8 {
  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/unsafe-op-in-unsafe-fn.html>
  = note: `#[warn(unsafe_op_in_unsafe_fn)]` (part of `#[warn(rust_2024_compatibility)]`) on by default
 
error[E0133]: call to unsafe function `first_byte` is unsafe and requires unsafe block
  --> src/main.rs:12:17
   |
12 |     let value = first_byte(data.as_ptr());
   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
   |
   = note: consult the function's documentation for information on how to avoid undefined behavior
 
For more information about this error, try `rustc --explain E0133`.
warning: `unsafe_demo` (bin "unsafe_demo") generated 1 warning
error: could not compile `unsafe_demo` (bin "unsafe_demo") due to 1 previous error; 1 warning emitted

/// Converts a mutable string slice to a mutable byte slice.
///
/// # Safety
///
/// The caller must ensure that the content of the slice is valid UTF-8
/// before the borrow ends and the underlying `str` is used.
///
/// Use of a `str` whose contents are not valid UTF-8 is undefined behavior.
///
/// ...
pub unsafe fn as_bytes_mut(&mut self) -> &mut [u8] {
    // SAFETY: the cast from `&str` to `&[u8]` is safe since `str`
    // has the same layout as `&[u8]` (only libstd can make this guarantee).
    // The pointer dereference is safe since it comes from a mutable reference which
    // is guaranteed to be valid for writes.
    unsafe { &mut *(self as *mut str as *mut [u8]) }
}

$ cat main.rs
#![deny(clippy::missing_safety_doc)]
 
pub unsafe fn first_byte(bytes: *const u8) -> u8 {
    unsafe { *bytes }
}
 
fn main() {
    let data = [42u8];
    let value = unsafe { first_byte(data.as_ptr()) };
    println!("{value}");
}
 
$ cargo clippy
    Checking unsafe_demo v0.1.0 (/private/tmp/unsafe-demo)
error: unsafe function's docs are missing a `# Safety` section
 --> src/main.rs:3:1
  |
3 | pub unsafe fn first_byte(bytes: *const u8) -> u8 {
  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  |
  = help: for further information visit https://rust-lang.github.io/rust-clippy/rust-1.95.0/index.html#missing_safety_doc
note: the lint level is defined here
 --> src/main.rs:1:9
  |
1 | #![deny(clippy::missing_safety_doc)]
  |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
error: could not compile `unsafe_demo` (bin "unsafe_demo") due to 1 previous error

/// <summary>Reads a single byte from unmanaged memory.</summary>
/// <safety>
/// The sum of <paramref name="ptr"/> and <paramref name="ofs"/> must address a byte
/// the caller is permitted to read.
/// </safety>
public static unsafe byte ReadByte(IntPtr ptr, int ofs)
{
    try
    {
        byte* addr = (byte*)ptr;
        unsafe
        {
            // SAFETY: relies on caller obligation.
            return addr[ofs];
        }
    }
    catch (NullReferenceException)
    {
        throw new AccessViolationException();
    }
}

pub fn split_at(&self, mid: usize) -> (&str, &str) {
    // is_char_boundary checks that the index is in [0, .len()]
    if self.is_char_boundary(mid) {
        // SAFETY: just checked that `mid` is on a char boundary.
        unsafe { (self.get_unchecked(0..mid), self.get_unchecked(mid..self.len())) }
    } else {
        slice_error_fail(self, 0, mid)
    }
}

// Converts a substring of this string to an array of characters. Copies the
// characters of this string beginning at position sourceIndex and ending at
// sourceIndex + count - 1 to the character array buffer, beginning
// at destinationIndex.
//
public void CopyTo(int sourceIndex, char[] destination, int destinationIndex, int count)
{
    ArgumentNullException.ThrowIfNull(destination);
 
    ArgumentOutOfRangeException.ThrowIfNegative(count);
    ArgumentOutOfRangeException.ThrowIfNegative(sourceIndex);
    ArgumentOutOfRangeException.ThrowIfGreaterThan(count, Length - sourceIndex, nameof(sourceIndex));
    ArgumentOutOfRangeException.ThrowIfGreaterThan(destinationIndex, destination.Length - count);
    ArgumentOutOfRangeException.ThrowIfNegative(destinationIndex);
 
    unsafe
    {
        // SAFETY: the bounds checks above ensure that `count` characters
        // starting at `sourceIndex` are in range of this string, and that
        // `count` characters starting at `destinationIndex` fit in `destination`.
        Buffer.Memmove(
            destination: ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(destination), destinationIndex),
            source: ref Unsafe.Add(ref _firstChar, sourceIndex),
            elementCount: (uint)count);
    }
}

public class NativeBuffer : IDisposable
{
    /// <safety>
    /// Must be null or point to a buffer of Length bytes.
    /// </safety>
    private unsafe byte* _ptr;
    public int Length { get; }
 
    public NativeBuffer(int length)
    {
        ArgumentOutOfRangeException.ThrowIfNegative(length);
        unsafe
        {
            // SAFETY: NativeMemory.Alloc throws OutOfMemoryException on failure rather than
            // returning null (unlike the malloc it wraps), so on return _ptr points to `length` bytes.
            _ptr = (byte*)NativeMemory.Alloc((nuint)length);
        }
        Length = length;
    }
 
    public byte ReadAt(int index)
    {
        ArgumentOutOfRangeException.ThrowIfNegative(index);
        ArgumentOutOfRangeException.ThrowIfGreaterThanOrEqual(index, Length);
        unsafe
        {
            ObjectDisposedException.ThrowIf(_ptr is null, this);
            // SAFETY: bounds checked above; null check just above; _ptr therefore points to Length bytes
            return _ptr[index];
        }
    }
 
    public void Dispose()
    {
        unsafe
        {
            // SAFETY: _ptr is null or was returned by NativeMemory.Alloc; Free accepts both
            NativeMemory.Free(_ptr);
            _ptr = null;
        }
    }
}

public class ArrayWrapper<T>
{
    /// <safety>
    /// Must always hold a value whose runtime type is T[].
    /// </safety>
    private readonly unsafe Array _array;
 
    public ArrayWrapper(T[] items)
    {
        ArgumentNullException.ThrowIfNull(items);
        unsafe
        {
            // SAFETY: items is statically T[], so the field invariant holds.
            _array = items;
        }
    }
 
    public T GetItem(int index)
    {
        unsafe
        {
            // SAFETY: _array is always a T[] per the field's <safety> block
            var typedArray = Unsafe.As<T[]>(_array);
            return typedArray[index];
        }
    }
}

pub struct Vec<T> {
    data: Box<[MaybeUninit<T>]>,
    len: usize,
}
 
impl<T> Vec<T> {
    // Safe code, but the next read is undefined behavior.
    pub fn evil(&mut self) {
        self.len += 2;
    }
}

struct Vec<T> {
    // SAFETY: The elements `data[i]` for
    // `i < len` are in a valid state.
    unsafe data: Box<[MaybeUninit<T>]>,
    unsafe len: usize,
}

public static void* Alloc(nuint byteCount);
 
/// <safety>
/// The caller must ensure:
///
/// - <paramref name="ptr"/> was returned by <see cref="Alloc(nuint)"/> (or a
///   compatible allocator) and has not already been freed.
/// - No live pointer or span aliases the storage at the time of this call.
/// </safety>
public static unsafe void Free(void* ptr);

private FileVersionInfo(string fileName)
{
    _fileName = fileName;
 
    uint infoSize = Interop.Version.GetFileVersionInfoSizeEx(
        Interop.Version.FileVersionInfoType.FILE_VER_GET_LOCALISED, _fileName, out _);
    if (infoSize != 0)
    {
        unsafe
        {
            // SAFETY:
            // - bounds: `infoSize` is the size returned by GetFileVersionInfoSizeEx
            //   and is the same value passed to both Alloc and GetFileVersionInfoEx,
            //   so all reads through `memPtr` stay within the allocated range.
            // - lifetime: `memPtr` is freed in the finally before this constructor
            //   returns, and never escapes; every consumer (GetLanguageAndCodePage,
            //   GetVersionInfoForCodePage) is called from within this method and
            //   writes its results into this object's fields.
            void* memPtr = NativeMemory.Alloc(infoSize);
            try
            {
                if (Interop.Version.GetFileVersionInfoEx(
                    /* flags */ default, _fileName, 0U, infoSize, memPtr))
                {
                    uint lcp = GetLanguageAndCodePage(memPtr);
                    _ = GetVersionInfoForCodePage(memPtr, lcp.ToString("X8")) ||
                        (lcp != 0x040904B0 && GetVersionInfoForCodePage(memPtr, "040904B0")) ||
                        (lcp != 0x040904E4 && GetVersionInfoForCodePage(memPtr, "040904E4")) ||
                        (lcp != 0x04090000 && GetVersionInfoForCodePage(memPtr, "04090000"));
                }
            }
            finally
            {
                NativeMemory.Free(memPtr);
            }
        }
    }
}

internal sealed class FixedMemoryKeyBox : SafeHandle
{
    /// <safety>
    /// Must equal the byte size of the allocation pointed to by <c>handle</c>.
    /// </safety>
    private readonly unsafe int _length;
 
    internal FixedMemoryKeyBox(ReadOnlySpan<byte> key) : base(IntPtr.Zero, ownsHandle: true)
    {
        void* memory;
        unsafe
        {
            // SAFETY:
            // - alloc:   NativeMemory.Alloc returns a pointer to key.Length writable bytes.
            // - span:    new Span<byte>(memory, key.Length) addresses exactly those bytes.
            // - lifetime: ownership of the pointer transfers to this SafeHandle
            //             via SetHandle below; ReleaseHandle frees the allocation when
            //             the ref-count reaches zero.
            // - _length: paired with the allocation made on this line.
            memory = NativeMemory.Alloc((nuint)key.Length);
            key.CopyTo(new Span<byte>(memory, key.Length));
            _length = key.Length;
        }
        SetHandle((IntPtr)memory);
    }
 
    /// <safety>
    /// The returned span aliases storage owned by this SafeHandle.
    /// The caller must ensure:
    ///
    /// - the span is not used after this SafeHandle is disposed;
    /// - access is bracketed by <see cref="SafeHandle.DangerousAddRef"/> and
    ///   <see cref="SafeHandle.DangerousRelease"/> (or equivalent), so
    ///   disposal on another thread can't free the buffer mid-use.
    /// </safety>
    internal unsafe ReadOnlySpan<byte> DangerousKeySpan
    {
        get
        {
            unsafe
            {
                // SAFETY:
                // - bounds: `_length` matches the allocation made in the ctor.
                // - lifetime: NOT discharged here; propagated to the caller
                //   via the <safety> block above. The `Dangerous` prefix
                //   echoes that contract in the API name.
                return new ReadOnlySpan<byte>((void*)handle, _length);
            }
        }
    }
 
    internal TRet UseKey<TState, TRet>(TState state, Func<TState, ReadOnlySpan<byte>, TRet> func)
    {
        bool addedRef = false;
        unsafe
        {
            // SAFETY: AddRef holds the SafeHandle alive for the duration of
            // the callback, so `DangerousKeySpan` aliases live storage. The
            // span is not retained beyond `func`'s return.
            try
            {
                DangerousAddRef(ref addedRef);
                return func(state, DangerousKeySpan);
            }
            finally
            {
                if (addedRef)
                {
                    DangerousRelease();
                }
            }
        }
    }
 
    protected override bool ReleaseHandle()
    {
        unsafe
        {
            // SAFETY: SafeHandle's ref-counting guarantees no live span
            // aliases `handle` at this point; the new Span<byte>(handle, _length)
            // addresses the allocation made in the ctor.
            CryptographicOperations.ZeroMemory(new Span<byte>((void*)handle, _length));
            NativeMemory.Free((void*)handle);
        }
        return true;
    }
 
    public override bool IsInvalid => handle == IntPtr.Zero;
}

 
DonneesPanel.Leave -= DonneesPanel_Leave;

 
DonneesPanel.Leave += DonneesPanel_Leave;

 
DonneesPanel.Enter -= DonneesPanel_Enter;
DonneesPanel.Enter += DonneesPanel_Enter;

  <WhereFilter>
 
    <FilterGroup ID="Racine">
    </FilterGroup>
 
    <Filter ID="MF1FILTRE1">
    </Filter>
 
    <FilterGroup ID="MF1GROUPE1">
    </FilterGroup>
 
    <Filter ID="MF1FILTRE2">
    </Filter>
 
    <Filter ID="MF1FILTRE3">
    </Filter>
 
  </WhereFilter>

    [XmlRoot(ElementName = "WhereFilter", Namespace = "")]
    public class WhereFilter
    {
        [XmlElement(ElementName = "FilterGroup", Namespace = "")]
        public List<FilterGroup> FilterGroup;  
 
        [XmlElement(ElementName = "Filter", Namespace = "")]
        public List<Filter> Filter;
    }

  <WhereFilter>
 
    <FilterGroup ID="Racine">
    </FilterGroup>
 
    <FilterGroup ID="MF1GROUPE1">
    </FilterGroup>
 
    <Filter ID="MF1FILTRE1">
    </Filter>
 
    <Filter ID="MF1FILTRE2">
    </Filter>
 
    <Filter ID="MF1FILTRE3">
    </Filter>
 
  </WhereFilter>

 
public static async Task HttpAsync()
{
    var url = "http://www.google.com"; 
    using (var httpClient = new HttpClient())
    {
        var content =await httpClient.GetStringAsync(url);
    }
}

 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
 
namespace TestsSharpPcap
{
    public class AwaitOperator
    {
        public static async Task Main()
        {
            Task<int> downloading = DownloadDocsMainPageAsync();
            Console.WriteLine($"{nameof(Main)}: Launched downloading.");
 
            int bytesLoaded = await downloading;
            Console.WriteLine($"{nameof(Main)}: Downloaded {bytesLoaded} bytes.");
        }
 
        private static async Task<int> DownloadDocsMainPageAsync()
        {
            Console.WriteLine($"{nameof(DownloadDocsMainPageAsync)}: About to start downloading.");
            var client = new HttpClient();
            byte[] content = await client.GetByteArrayAsync("http://www.google.com/");
            Console.WriteLine($"{nameof(DownloadDocsMainPageAsync)}: Finished downloading.");
            return content.Length;
        }
    }
}

 
Console.WriteLine($"{nameof(DownloadDocsMainPageAsync)}: Finished downloading.");
return content.Length;

 
using System.Runtime.InteropServices;

 
Interop s;